/**@class android.hardware.usb.UsbManager
@extends java.lang.Object

 This class allows you to access the state of USB and communicate with USB devices.
 Currently only host mode is supported in the public API.

 <div class="special reference">
 <h3>Developer Guides</h3>
 <p>For more information about communicating with USB hardware, read the
 <a href="{@docRoot}guide/topics/connectivity/usb/index.html">USB developer guide</a>.</p>
 </div>
*/
var UsbManager = {

/** Broadcast Action:  A sticky broadcast for USB state change events when in device mode.

 This is a sticky broadcast for clients that includes USB connected/disconnected state,
 <ul>
 <li> {@link #USB_CONNECTED} boolean indicating whether USB is connected or disconnected.
 <li> {@link #USB_HOST_CONNECTED} boolean indicating whether USB is connected or
     disconnected as host.
 <li> {@link #USB_CONFIGURED} boolean indicating whether USB is configured.
 currently zero if not configured, one for configured.
 <li> {@link #USB_FUNCTION_ADB} boolean extra indicating whether the
 adb function is enabled
 <li> {@link #USB_FUNCTION_RNDIS} boolean extra indicating whether the
 RNDIS ethernet function is enabled
 <li> {@link #USB_FUNCTION_MTP} boolean extra indicating whether the
 MTP function is enabled
 <li> {@link #USB_FUNCTION_PTP} boolean extra indicating whether the
 PTP function is enabled
 <li> {@link #USB_FUNCTION_ACCESSORY} boolean extra indicating whether the
 accessory function is enabled
 <li> {@link #USB_FUNCTION_AUDIO_SOURCE} boolean extra indicating whether the
 audio source function is enabled
 <li> {@link #USB_FUNCTION_MIDI} boolean extra indicating whether the
 MIDI function is enabled
 </ul>
 If the sticky intent has not been found, that indicates USB is disconnected,
 USB is not configued, MTP function is enabled, and all the other functions are disabled.

 {@hide}
*/
ACTION_USB_STATE : "android.hardware.usb.action.USB_STATE",
/** Broadcast Action: A broadcast for USB port changes.

 This intent is sent when a USB port is added, removed, or changes state.

 @hide
*/
ACTION_USB_PORT_CHANGED : "android.hardware.usb.action.USB_PORT_CHANGED",
/** Activity intent sent when user attaches a USB device.

 This intent is sent when a USB device is attached to the USB bus when in host mode.
 <ul>
 <li> {@link #EXTRA_DEVICE} containing the {@link android.hardware.usb.UsbDevice}
 for the attached device
 </ul>
*/
ACTION_USB_DEVICE_ATTACHED : "android.hardware.usb.action.USB_DEVICE_ATTACHED",
/** Broadcast Action:  A broadcast for USB device detached event.

 This intent is sent when a USB device is detached from the USB bus when in host mode.
 <ul>
 <li> {@link #EXTRA_DEVICE} containing the {@link android.hardware.usb.UsbDevice}
 for the detached device
 </ul>
*/
ACTION_USB_DEVICE_DETACHED : "android.hardware.usb.action.USB_DEVICE_DETACHED",
/** Activity intent sent when user attaches a USB accessory.

 <ul>
 <li> {@link #EXTRA_ACCESSORY} containing the {@link android.hardware.usb.UsbAccessory}
 for the attached accessory
 </ul>
*/
ACTION_USB_ACCESSORY_ATTACHED : "android.hardware.usb.action.USB_ACCESSORY_ATTACHED",
/** Broadcast Action:  A broadcast for USB accessory detached event.

 This intent is sent when a USB accessory is detached.
 <ul>
 <li> {@link #EXTRA_ACCESSORY} containing the {@link android.hardware.usb.UsbAccessory}
 for the attached accessory that was detached
 </ul>
*/
ACTION_USB_ACCESSORY_DETACHED : "android.hardware.usb.action.USB_ACCESSORY_DETACHED",
/** Boolean extra indicating whether USB is connected or disconnected.
 Used in extras for the {@link #ACTION_USB_STATE} broadcast.

 {@hide}
*/
USB_CONNECTED : "connected",
/** Boolean extra indicating whether USB is connected or disconnected as host.
 Used in extras for the {@link #ACTION_USB_STATE} broadcast.

 {@hide}
*/
USB_HOST_CONNECTED : "host_connected",
/** Boolean extra indicating whether USB is configured.
 Used in extras for the {@link #ACTION_USB_STATE} broadcast.

 {@hide}
*/
USB_CONFIGURED : "configured",
/** Boolean extra indicating whether confidential user data, such as photos, should be
 made available on the USB connection. This variable will only be set when the user
 has explicitly asked for this data to be unlocked.
 Used in extras for the {@link #ACTION_USB_STATE} broadcast.

 {@hide}
*/
USB_DATA_UNLOCKED : "unlocked",
/** A placeholder indicating that no USB function is being specified.
 Used for compatibility with old init scripts to indicate no functions vs. charging function.

 {@hide}
*/
USB_FUNCTION_NONE : "none",
/** Name of the adb USB function.
 Used in extras for the {@link #ACTION_USB_STATE} broadcast

 {@hide}
*/
USB_FUNCTION_ADB : "adb",
/** Name of the RNDIS ethernet USB function.
 Used in extras for the {@link #ACTION_USB_STATE} broadcast

 {@hide}
*/
USB_FUNCTION_RNDIS : "rndis",
/** Name of the MTP USB function.
 Used in extras for the {@link #ACTION_USB_STATE} broadcast

 {@hide}
*/
USB_FUNCTION_MTP : "mtp",
/** Name of the PTP USB function.
 Used in extras for the {@link #ACTION_USB_STATE} broadcast

 {@hide}
*/
USB_FUNCTION_PTP : "ptp",
/** Name of the audio source USB function.
 Used in extras for the {@link #ACTION_USB_STATE} broadcast

 {@hide}
*/
USB_FUNCTION_AUDIO_SOURCE : "audio_source",
/** Name of the MIDI USB function.
 Used in extras for the {@link #ACTION_USB_STATE} broadcast

 {@hide}
*/
USB_FUNCTION_MIDI : "midi",
/** Name of the Accessory USB function.
 Used in extras for the {@link #ACTION_USB_STATE} broadcast

 {@hide}
*/
USB_FUNCTION_ACCESSORY : "accessory",
/** Name of extra for {@link #ACTION_USB_PORT_CHANGED}
 containing the {@link android.hardware.usb.UsbPort} object for the port.

 @hide
*/
EXTRA_PORT : "port",
/** Name of extra for {@link #ACTION_USB_PORT_CHANGED}
 containing the {@link android.hardware.usb.UsbPortStatus} object for the port, or null if the port
 was removed.

 @hide
*/
EXTRA_PORT_STATUS : "portStatus",
/** Name of extra for {@link #ACTION_USB_DEVICE_ATTACHED} and
 {@link #ACTION_USB_DEVICE_DETACHED} broadcasts
 containing the {@link android.hardware.usb.UsbDevice} object for the device.
*/
EXTRA_DEVICE : "device",
/** Name of extra for {@link #ACTION_USB_ACCESSORY_ATTACHED} and
 {@link #ACTION_USB_ACCESSORY_DETACHED} broadcasts
 containing the {@link android.hardware.usb.UsbAccessory} object for the accessory.
*/
EXTRA_ACCESSORY : "accessory",
/** Name of extra added to the {@link android.app.PendingIntent}
 passed into {@link #requestPermission(UsbDevice, PendingIntent)}
 or {@link #requestPermission(UsbAccessory, PendingIntent)}
 containing a boolean value indicating whether the user granted permission or not.
*/
EXTRA_PERMISSION_GRANTED : "permission",
/** Name of extra added to start systemui.usb.UsbPermissionActivity
 containing package name of the app which requests USB permission.

 @hide
*/
EXTRA_PACKAGE : "android.hardware.usb.extra.PACKAGE",
/** Name of extra added to start systemui.usb.UsbPermissionActivity
 containing the whether the app which requests USB permission can be set as default handler
 for USB device attach event or USB accessory attach event or not.

 @hide
*/
EXTRA_CAN_BE_DEFAULT : "android.hardware.usb.extra.CAN_BE_DEFAULT",
/** Code for the charging usb function. Passed into {@link #setCurrentFunctions}(long)
 {@hide}
*/
FUNCTION_NONE : "0",
/** Code for the mtp usb function. Passed as a mask into {@link #setCurrentFunctions}(long)
 {@hide}
*/
FUNCTION_MTP : "null",
/** Code for the ptp usb function. Passed as a mask into {@link #setCurrentFunctions}(long)
 {@hide}
*/
FUNCTION_PTP : "null",
/** Code for the rndis usb function. Passed as a mask into {@link #setCurrentFunctions}(long)
 {@hide}
*/
FUNCTION_RNDIS : "null",
/** Code for the midi usb function. Passed as a mask into {@link #setCurrentFunctions}(long)
 {@hide}
*/
FUNCTION_MIDI : "null",
/** Code for the accessory usb function.
 {@hide}
*/
FUNCTION_ACCESSORY : "null",
/** Code for the audio source usb function.
 {@hide}
*/
FUNCTION_AUDIO_SOURCE : "null",
/** Code for the adb usb function.
 {@hide}
*/
FUNCTION_ADB : "null",
/**Returns a HashMap containing all USB devices currently attached.
 USB device name is the key for the returned HashMap.
 The result will be empty if no devices are attached, or if
 USB host mode is inactive or unsupported.
@return {Object {java.util.HashMap}} HashMap containing all connected USB devices.
*/
getDeviceList : function(  ) {},

/**Opens the device so it can be used to send and receive
 data using {@link android.hardware.usb.UsbRequest}.
@param {Object {UsbDevice}} device the device to open
@return {Object {android.hardware.usb.UsbDeviceConnection}} a {@link UsbDeviceConnection}, or {@code null} if open failed
*/
openDevice : function(  ) {},

/**Returns a list of currently attached USB accessories.
 (in the current implementation there can be at most one)
@return {Object {android.hardware.usb.UsbAccessory}} list of USB accessories, or null if none are attached.
*/
getAccessoryList : function(  ) {},

/**Opens a file descriptor for reading and writing data to the USB accessory.

 <p>If data is read from the {@link java.io.InputStream} created from this file descriptor all
 data of a USB transfer should be read at once. If only a partial request is read the rest of
 the transfer is dropped.
@param {Object {UsbAccessory}} accessory the USB accessory to open
@return {Object {android.os.ParcelFileDescriptor}} file descriptor, or null if the accessory could not be opened.
*/
openAccessory : function(  ) {},

/**Gets the functionfs control file descriptor for the given function, with
 the usb descriptors and strings already written. The file descriptor is used
 by the function implementation to handle events and control requests.
@param {Number} function to get control fd for. Currently {@link #FUNCTION_MTP} and
 {@link #FUNCTION_PTP} are supported.
@return {Object {android.os.ParcelFileDescriptor}} A ParcelFileDescriptor holding the valid fd, or null if the fd was not found.

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

/**Returns true if the caller has permission to access the device.
 Permission might have been granted temporarily via
 {@link #requestPermission(UsbDevice, PendingIntent)} or
 by the user choosing the caller as the default application for the device.
 Permission for USB devices of class {@link android.hardware.usb.UsbConstants#USB_CLASS_VIDEO} for clients that
 target SDK {@link android.os.Build.VERSION_CODES#P} and above can be granted only if they
 have additionally the {@link android.Manifest.permission#CAMERA} permission.
@param {Object {UsbDevice}} device to check permissions for
@return {Boolean} true if caller has permission
*/
hasPermission : function(  ) {},

/**Returns true if the caller has permission to access the accessory.
 Permission might have been granted temporarily via
 {@link #requestPermission(UsbAccessory, PendingIntent)} or
 by the user choosing the caller as the default application for the accessory.
@param {Object {UsbAccessory}} accessory to check permissions for
@return {Boolean} true if caller has permission
*/
hasPermission : function(  ) {},

/**Requests temporary permission for the given package to access the device.
 This may result in a system dialog being displayed to the user
 if permission had not already been granted.
 Success or failure is returned via the {@link android.app.PendingIntent} pi.
 If successful, this grants the caller permission to access the device only
 until the device is disconnected.

 The following extras will be added to pi:
 <ul>
 <li> {@link #EXTRA_DEVICE} containing the device passed into this call
 <li> {@link #EXTRA_PERMISSION_GRANTED} containing boolean indicating whether
 permission was granted by the user
 </ul>

 Permission for USB devices of class {@link android.hardware.usb.UsbConstants#USB_CLASS_VIDEO} for clients that
 target SDK {@link android.os.Build.VERSION_CODES#P} and above can be granted only if they
 have additionally the {@link android.Manifest.permission#CAMERA} permission.
@param {Object {UsbDevice}} device to request permissions for
@param {Object {PendingIntent}} pi PendingIntent for returning result
*/
requestPermission : function(  ) {},

/**Requests temporary permission for the given package to access the accessory.
 This may result in a system dialog being displayed to the user
 if permission had not already been granted.
 Success or failure is returned via the {@link android.app.PendingIntent} pi.
 If successful, this grants the caller permission to access the accessory only
 until the device is disconnected.

 The following extras will be added to pi:
 <ul>
 <li> {@link #EXTRA_ACCESSORY} containing the accessory passed into this call
 <li> {@link #EXTRA_PERMISSION_GRANTED} containing boolean indicating whether
 permission was granted by the user
 </ul>
@param {Object {UsbAccessory}} accessory to request permissions for
@param {Object {PendingIntent}} pi PendingIntent for returning result
*/
requestPermission : function(  ) {},

/**Grants permission for USB device without showing system dialog.
 Only system components can call this function.
@param {Object {UsbDevice}} device to request permissions for

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

/**Grants permission for USB device to given uid without showing system dialog.
 Only system components can call this function.
@param {Object {UsbDevice}} device to request permissions for
@uid uid to give permission

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

/**Grants permission to specified package for USB device without showing system dialog.
 Only system components can call this function, as it requires the MANAGE_USB permission.
@param {Object {UsbDevice}} device to request permissions for
@param {String} packageName of package to grant permissions

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

/**Returns true if the specified USB function is currently enabled when in device mode.
 <p>
 USB functions represent interfaces which are published to the host to access
 services offered by the device.
 </p>
@param {String} function name of the USB function
@param function name of the USB function
@return {Boolean} true if the USB function is enabled

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

/**Sets the current USB functions when in device mode.
 <p>
 USB functions represent interfaces which are published to the host to access
 services offered by the device.
 </p><p>
 This method is intended to select among primary USB functions.  The system may
 automatically activate additional functions such as {@link #USB_FUNCTION_ADB}
 or {@link #USB_FUNCTION_ACCESSORY} based on other settings and states.
 </p><p>
 An argument of 0 indicates that the device is charging, and can pick any
 appropriate function for that purpose.
 </p><p>
 Note: This function is asynchronous and may fail silently without applying
 the requested changes.
 </p>
@param {Number} functions the USB function(s) to set, as a bitwise mask.
                  Must satisfy {@link UsbManager#areSettableFunctions}

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

/**Sets the current USB functions when in device mode.
@param {String} functions the USB function(s) to set.
@param {Boolean} usbDataUnlocked unused

 {@hide}
@param usbDataUnlocked unused

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

/**Returns the current USB functions in device mode.
 <p>
 This function returns the state of primary USB functions and can return a
 mask containing any usb function(s) except for ADB.
 </p>
@return {Number} The currently enabled functions, in a bitwise mask.
 A zero mask indicates that the current function is the charging function.

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

/**Sets the screen unlocked functions, which are persisted and set as the current functions
 whenever the screen is unlocked.
 <p>
 A zero mask has the effect of switching off this feature, so functions
 no longer change on screen unlock.
 </p><p>
 Note: When the screen is on, this method will apply given functions as current functions,
 which is asynchronous and may fail silently without applying the requested changes.
 </p>
@param {Number} functions functions to set, in a bitwise mask.
                  Must satisfy {@link UsbManager#areSettableFunctions}

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

/**Gets the current screen unlocked functions.
@return {Number} The currently set screen enabled functions.
 A zero mask indicates that the screen unlocked functions feature is not enabled.

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

/**Returns a list of physical USB ports on the device.
 <p>
 This list is guaranteed to contain all dual-role USB Type C ports but it might
 be missing other ports depending on whether the kernel USB drivers have been
 updated to publish all of the device's ports through the new "dual_role_usb"
 device class (which supports all types of ports despite its name).
 </p>
@return {Object {java.util.List}} The list of USB ports
@hide 
*/
getPorts : function(  ) {},

/**Sets the component that will handle USB device connection.
 <p>
 Setting component allows to specify external USB host manager to handle use cases, where
 selection dialog for an activity that will handle USB device is undesirable.
 Only system components can call this function, as it requires the MANAGE_USB permission.
@param {Object {ComponentName}} usbDeviceConnectionHandler The component to handle usb connections,
 {@code null} to unset.

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

/**Returns whether the given functions are valid inputs to UsbManager.
 Currently the empty functions or any of MTP, PTP, RNDIS, MIDI are accepted.
@return {Boolean} Whether the mask is settable.

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

/**Converts the given function mask to string. Maintains ordering with respect to init scripts.
@return {String} String representation of given mask

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

/**Parses a string of usb functions that are comma separated.
@return {Number} A mask of all valid functions in the string

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


};