For more information about communicating with USB hardware, read the * USB developer guide.
*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 accessory the USB accessory to open * @return file descriptor, or null if the accessory could not be opened. */ @RequiresFeature(PackageManager.FEATURE_USB_ACCESSORY) public ParcelFileDescriptor openAccessory(UsbAccessory accessory) { try { return mService.openAccessory(accessory); } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } } /** * 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 function to get control fd for. Currently {@link #FUNCTION_MTP} and * {@link #FUNCTION_PTP} are supported. * @return A ParcelFileDescriptor holding the valid fd, or null if the fd was not found. * * {@hide} */ public ParcelFileDescriptor getControlFd(long function) { try { return mService.getControlFd(function); } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } } /** * 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 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 device to check permissions for * @return true if caller has permission */ @RequiresFeature(PackageManager.FEATURE_USB_HOST) public boolean hasPermission(UsbDevice device) { if (mService == null) { return false; } try { return mService.hasDevicePermission(device, mContext.getPackageName()); } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } } /** * 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 accessory to check permissions for * @return true if caller has permission */ @RequiresFeature(PackageManager.FEATURE_USB_ACCESSORY) public boolean hasPermission(UsbAccessory accessory) { if (mService == null) { return false; } try { return mService.hasAccessoryPermission(accessory); } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } } /** * 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: *
* USB functions represent interfaces which are published to the host to access * services offered by the device. *
* * @deprecated use getCurrentFunctions() instead. * @param function name of the USB function * @return true if the USB function is enabled * * {@hide} */ @Deprecated @UnsupportedAppUsage public boolean isFunctionEnabled(String function) { try { return mService.isFunctionEnabled(function); } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } } /** * Sets the current USB functions when in device mode. ** USB functions represent interfaces which are published to the host to access * services offered by the device. *
* 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. *
* An argument of 0 indicates that the device is charging, and can pick any * appropriate function for that purpose. *
* Note: This function is asynchronous and may fail silently without applying * the requested changes. *
* * @param functions the USB function(s) to set, as a bitwise mask. * Must satisfy {@link UsbManager#areSettableFunctions} * * {@hide} */ @SystemApi @RequiresPermission(Manifest.permission.MANAGE_USB) public void setCurrentFunctions(@UsbFunctionMode long functions) { try { mService.setCurrentFunctions(functions); } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } } /** * Sets the current USB functions when in device mode. * * @deprecated use setCurrentFunctions(long) instead. * @param functions the USB function(s) to set. * @param usbDataUnlocked unused * {@hide} */ @Deprecated @UnsupportedAppUsage public void setCurrentFunction(String functions, boolean usbDataUnlocked) { try { mService.setCurrentFunction(functions, usbDataUnlocked); } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } } /** * Returns the current USB functions in device mode. ** This function returns the state of primary USB functions and can return a * mask containing any usb function(s) except for ADB. *
* * @return The currently enabled functions, in a bitwise mask. * A zero mask indicates that the current function is the charging function. * * {@hide} */ @SystemApi @RequiresPermission(Manifest.permission.MANAGE_USB) public long getCurrentFunctions() { try { return mService.getCurrentFunctions(); } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } } /** * Sets the screen unlocked functions, which are persisted and set as the current functions * whenever the screen is unlocked. ** A zero mask has the effect of switching off this feature, so functions * no longer change on screen unlock. *
* 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. *
* * @param functions functions to set, in a bitwise mask. * Must satisfy {@link UsbManager#areSettableFunctions} * * {@hide} */ public void setScreenUnlockedFunctions(long functions) { try { mService.setScreenUnlockedFunctions(functions); } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } } /** * Gets the current screen unlocked functions. * * @return The currently set screen enabled functions. * A zero mask indicates that the screen unlocked functions feature is not enabled. * * {@hide} */ public long getScreenUnlockedFunctions() { try { return mService.getScreenUnlockedFunctions(); } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } } /** * Resets the USB Gadget. ** Performs USB data stack reset through USB Gadget HAL. * It will force USB data connection reset. The connection will disconnect and reconnect. *
* * @hide */ @SystemApi @RequiresPermission(Manifest.permission.MANAGE_USB) public void resetUsbGadget() { try { mService.resetUsbGadget(); } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } } /** * Returns a list of physical USB ports on the device. ** 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). *
* * @return The list of USB ports * * @hide */ @SystemApi @RequiresPermission(Manifest.permission.MANAGE_USB) public @NonNull List* 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 usbDeviceConnectionHandler The component to handle usb connections, * {@code null} to unset. * * {@hide} */ public void setUsbDeviceConnectionHandler(@Nullable ComponentName usbDeviceConnectionHandler) { try { mService.setUsbDeviceConnectionHandler(usbDeviceConnectionHandler); } catch (RemoteException e) { throw e.rethrowFromSystemServer(); } } /** * Returns whether the given functions are valid inputs to UsbManager. * Currently the empty functions or any of MTP, PTP, RNDIS, MIDI are accepted. * * @return Whether the mask is settable. * * {@hide} */ public static boolean areSettableFunctions(long functions) { return functions == FUNCTION_NONE || ((~SETTABLE_FUNCTIONS & functions) == 0 && Long.bitCount(functions) == 1); } /** * Converts the given function mask to string. Maintains ordering with respect to init scripts. * * @return String representation of given mask * * {@hide} */ public static String usbFunctionsToString(long functions) { StringJoiner joiner = new StringJoiner(","); if ((functions & FUNCTION_MTP) != 0) { joiner.add(UsbManager.USB_FUNCTION_MTP); } if ((functions & FUNCTION_PTP) != 0) { joiner.add(UsbManager.USB_FUNCTION_PTP); } if ((functions & FUNCTION_RNDIS) != 0) { joiner.add(UsbManager.USB_FUNCTION_RNDIS); } if ((functions & FUNCTION_MIDI) != 0) { joiner.add(UsbManager.USB_FUNCTION_MIDI); } if ((functions & FUNCTION_ACCESSORY) != 0) { joiner.add(UsbManager.USB_FUNCTION_ACCESSORY); } if ((functions & FUNCTION_AUDIO_SOURCE) != 0) { joiner.add(UsbManager.USB_FUNCTION_AUDIO_SOURCE); } if ((functions & FUNCTION_NCM) != 0) { joiner.add(UsbManager.USB_FUNCTION_NCM); } if ((functions & FUNCTION_ADB) != 0) { joiner.add(UsbManager.USB_FUNCTION_ADB); } return joiner.toString(); } /** * Parses a string of usb functions that are comma separated. * * @return A mask of all valid functions in the string * * {@hide} */ public static long usbFunctionsFromString(String functions) { if (functions == null || functions.equals(USB_FUNCTION_NONE)) { return FUNCTION_NONE; } long ret = 0; for (String function : functions.split(",")) { if (FUNCTION_NAME_TO_CODE.containsKey(function)) { ret |= FUNCTION_NAME_TO_CODE.get(function); } else if (function.length() > 0) { throw new IllegalArgumentException("Invalid usb function " + functions); } } return ret; } }