/**@class android.os.UserHandle
 implements android.os.Parcelable

@extends java.lang.Object

 Representation of a user on the device.
*/
var UserHandle = {

/** @hide Range of uids allocated for a user.
*/
PER_USER_RANGE : "100000",
/**@hide A user id to indicate all users on the device */
USER_ALL : "-1",
/**@hide A user handle to indicate all users on the device */
ALL : "null",
/**@hide A user id to indicate the currently active user */
USER_CURRENT : "-2",
/**@hide A user handle to indicate the current user of the device */
CURRENT : "null",
/**@hide A user id to indicate that we would like to send to the current
  user, but if this is calling from a user process then we will send it
  to the caller's user instead of failing with a security exception */
USER_CURRENT_OR_SELF : "-3",
/**@hide A user handle to indicate that we would like to send to the current
  user, but if this is calling from a user process then we will send it
  to the caller's user instead of failing with a security exception */
CURRENT_OR_SELF : "null",
/**@hide An undefined user id */
USER_NULL : "-10000",
/**@hide A user id constant to indicate the "owner" user of the device */
USER_OWNER : "0",
/**@hide A user handle to indicate the primary/owner user of the device */
OWNER : "null",
/** @hide Enable multi-user related side effects. Set this to false if
 there are problems with single user use-cases.
*/
MU_ENABLED : "true",
/***/
CREATOR : "null",
/**Checks to see if the user id is the same for the two uids, i.e., they belong to the same
 user.
@hide 
*/
isSameUser : function(  ) {},

/**Checks to see if both uids are referring to the same app id, ignoring the user id part of the
 uids.
@param {Number} uid1 uid to compare
@param {Number} uid2 other uid to compare
@return {Boolean} whether the appId is the same for both uids
@hide 
*/
isSameApp : function(  ) {},

/**
@hide 
*/
isIsolated : function(  ) {},

/**
@hide 
*/
isApp : function(  ) {},

/**Returns the user id for a given uid.
@hide 
*/
getUserId : function(  ) {},

/**
@hide 
*/
getCallingUserId : function(  ) {},

/**
@hide 
*/
getCallingUserHandle : function(  ) {},

/**Returns the uid that is composed from the userId and the appId.
@hide 
*/
getUid : function(  ) {},

/**Returns the app id (or base uid) for a given uid, stripping out the user id from it.
@hide 
*/
getAppId : function(  ) {},

/**Returns the gid shared between all apps with this userId.
@hide 
*/
getUserGid : function(  ) {},

/**Returns the shared app gid for a given uid or appId.
@hide 
*/
getSharedAppGid : function(  ) {},

/**Returns the app id for a given shared app gid.
@hide 
*/
getAppIdFromSharedAppGid : function(  ) {},

/**Generate a text representation of the uid, breaking out its individual
 components -- user, app, isolated, etc.
@hide 
*/
formatUid : function(  ) {},

/**Generate a text representation of the uid, breaking out its individual
 components -- user, app, isolated, etc.
@hide 
*/
formatUid : function(  ) {},

/**Generate a text representation of the uid, breaking out its individual
 components -- user, app, isolated, etc.
@hide 
*/
formatUid : function(  ) {},

/**Returns the user id of the current process
@return {Number} user id of the current process
@hide 
*/
myUserId : function(  ) {},

/**Returns true if this UserHandle refers to the owner user; false otherwise.
@return {Boolean} true if this UserHandle refers to the owner user; false otherwise.
@hide 
*/
isOwner : function(  ) {},

/**Returns the userId stored in this UserHandle.
@hide 
*/
getIdentifier : function(  ) {},

/**
*/
toString : function(  ) {},

/**
*/
equals : function(  ) {},

/**
*/
hashCode : function(  ) {},

/**
*/
describeContents : function(  ) {},

/**
*/
writeToParcel : function(  ) {},

/**Write a UserHandle to a Parcel, handling null pointers.  Must be
 read with {@link #readFromParcel}(Parcel).
@param {Object {UserHandle}} h The UserHandle to be written.
@param {Object {Parcel}} out The Parcel in which the UserHandle will be placed.
@see #readFromParcel(Parcel)
*/
writeToParcel : function(  ) {},

/**Read a UserHandle from a Parcel that was previously written
 with {@link #writeToandroid.os.Parcel(UserHandle, android.os.Parcel)}, returning either
 a null or new object as appropriate.
@param {Object {Parcel}} in The Parcel from which to read the UserHandle
@return {Object {android.os.UserHandle}} Returns a new UserHandle matching the previously written
 object, or null if a null had been written.
@see #writeToParcel(UserHandle, Parcel)
*/
readFromParcel : function(  ) {},


};