src.com.android.server.usb.UsbService Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of android-all Show documentation
Show all versions of android-all Show documentation
A library jar that provides APIs for Applications written for the Google Android Platform.
/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions an
* limitations under the License.
*/
package com.android.server.usb;
import static android.hardware.usb.UsbPortStatus.DATA_ROLE_DEVICE;
import static android.hardware.usb.UsbPortStatus.DATA_ROLE_HOST;
import static android.hardware.usb.UsbPortStatus.MODE_DFP;
import static android.hardware.usb.UsbPortStatus.MODE_DUAL;
import static android.hardware.usb.UsbPortStatus.MODE_UFP;
import static android.hardware.usb.UsbPortStatus.POWER_ROLE_SINK;
import static android.hardware.usb.UsbPortStatus.POWER_ROLE_SOURCE;
import android.annotation.NonNull;
import android.annotation.UserIdInt;
import android.app.PendingIntent;
import android.app.admin.DevicePolicyManager;
import android.content.BroadcastReceiver;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.pm.PackageManager;
import android.hardware.usb.IUsbManager;
import android.hardware.usb.ParcelableUsbPort;
import android.hardware.usb.UsbAccessory;
import android.hardware.usb.UsbDevice;
import android.hardware.usb.UsbManager;
import android.hardware.usb.UsbPort;
import android.hardware.usb.UsbPortStatus;
import android.os.Binder;
import android.os.Bundle;
import android.os.ParcelFileDescriptor;
import android.os.UserHandle;
import android.os.UserManager;
import android.service.usb.UsbServiceDumpProto;
import android.util.ArraySet;
import android.util.Slog;
import android.util.proto.ProtoOutputStream;
import com.android.internal.annotations.GuardedBy;
import com.android.internal.util.DumpUtils;
import com.android.internal.util.IndentingPrintWriter;
import com.android.internal.util.Preconditions;
import com.android.internal.util.dump.DualDumpOutputStream;
import com.android.server.FgThread;
import com.android.server.SystemServerInitThreadPool;
import com.android.server.SystemService;
import java.io.File;
import java.io.FileDescriptor;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.CompletableFuture;
/**
* UsbService manages all USB related state, including both host and device support.
* Host related events and calls are delegated to UsbHostManager, and device related
* support is delegated to UsbDeviceManager.
*/
public class UsbService extends IUsbManager.Stub {
public static class Lifecycle extends SystemService {
private UsbService mUsbService;
private final CompletableFuture mOnStartFinished = new CompletableFuture<>();
private final CompletableFuture mOnActivityManagerPhaseFinished =
new CompletableFuture<>();
public Lifecycle(Context context) {
super(context);
}
@Override
public void onStart() {
SystemServerInitThreadPool.submit(() -> {
mUsbService = new UsbService(getContext());
publishBinderService(Context.USB_SERVICE, mUsbService);
mOnStartFinished.complete(null);
}, "UsbService$Lifecycle#onStart");
}
@Override
public void onBootPhase(int phase) {
if (phase == SystemService.PHASE_ACTIVITY_MANAGER_READY) {
SystemServerInitThreadPool.submit(() -> {
mOnStartFinished.join();
mUsbService.systemReady();
mOnActivityManagerPhaseFinished.complete(null);
}, "UsbService$Lifecycle#onBootPhase");
} else if (phase == SystemService.PHASE_BOOT_COMPLETED) {
mOnActivityManagerPhaseFinished.join();
mUsbService.bootCompleted();
}
}
@Override
public void onUserSwitching(TargetUser from, TargetUser to) {
FgThread.getHandler()
.postAtFrontOfQueue(() -> mUsbService.onSwitchUser(to.getUserIdentifier()));
}
@Override
public void onUserStopping(TargetUser userInfo) {
mUsbService.onStopUser(userInfo.getUserHandle());
}
@Override
public void onUserUnlocking(TargetUser userInfo) {
mUsbService.onUnlockUser(userInfo.getUserIdentifier());
}
}
private static final String TAG = "UsbService";
private final Context mContext;
private final UserManager mUserManager;
private UsbDeviceManager mDeviceManager;
private UsbHostManager mHostManager;
private UsbPortManager mPortManager;
private final UsbAlsaManager mAlsaManager;
private final UsbSettingsManager mSettingsManager;
private final UsbPermissionManager mPermissionManager;
/**
* The user id of the current user. There might be several profiles (with separate user ids)
* per user.
*/
@GuardedBy("mLock")
private @UserIdInt int mCurrentUserId;
private final Object mLock = new Object();
/**
* @return the {@link UsbUserSettingsManager} for the given userId
*/
UsbUserSettingsManager getSettingsForUser(@UserIdInt int userId) {
return mSettingsManager.getSettingsForUser(userId);
}
/**
* @return the {@link UsbUserPermissionManager} for the given userId
*/
UsbUserPermissionManager getPermissionsForUser(@UserIdInt int userId) {
return mPermissionManager.getPermissionsForUser(userId);
}
public UsbService(Context context) {
mContext = context;
mUserManager = context.getSystemService(UserManager.class);
mSettingsManager = new UsbSettingsManager(context, this);
mPermissionManager = new UsbPermissionManager(context, this);
mAlsaManager = new UsbAlsaManager(context);
final PackageManager pm = mContext.getPackageManager();
if (pm.hasSystemFeature(PackageManager.FEATURE_USB_HOST)) {
mHostManager = new UsbHostManager(context, mAlsaManager, mPermissionManager);
}
if (new File("/sys/class/android_usb").exists()) {
mDeviceManager = new UsbDeviceManager(context, mAlsaManager, mSettingsManager,
mPermissionManager);
}
if (mHostManager != null || mDeviceManager != null) {
mPortManager = new UsbPortManager(context);
}
onSwitchUser(UserHandle.USER_SYSTEM);
BroadcastReceiver receiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
final String action = intent.getAction();
if (DevicePolicyManager.ACTION_DEVICE_POLICY_MANAGER_STATE_CHANGED
.equals(action)) {
if (mDeviceManager != null) {
mDeviceManager.updateUserRestrictions();
}
}
}
};
final IntentFilter filter = new IntentFilter();
filter.setPriority(IntentFilter.SYSTEM_HIGH_PRIORITY);
filter.addAction(DevicePolicyManager.ACTION_DEVICE_POLICY_MANAGER_STATE_CHANGED);
mContext.registerReceiverAsUser(receiver, UserHandle.ALL, filter, null, null);
}
/**
* Set new {@link #mCurrentUserId} and propagate it to other modules.
*
* @param newUserId The user id of the new current user.
*/
private void onSwitchUser(@UserIdInt int newUserId) {
synchronized (mLock) {
mCurrentUserId = newUserId;
// The following two modules need to know about the current profile group. If they need
// to distinguish by profile of the user, the id has to be passed in the call to the
// module.
UsbProfileGroupSettingsManager settings =
mSettingsManager.getSettingsForProfileGroup(UserHandle.of(newUserId));
if (mHostManager != null) {
mHostManager.setCurrentUserSettings(settings);
}
if (mDeviceManager != null) {
mDeviceManager.setCurrentUser(newUserId, settings);
}
}
}
/**
* Execute operations when a user is stopped.
*
* @param stoppedUser The user that is stopped
*/
private void onStopUser(@NonNull UserHandle stoppedUser) {
mSettingsManager.remove(stoppedUser);
}
public void systemReady() {
mAlsaManager.systemReady();
if (mDeviceManager != null) {
mDeviceManager.systemReady();
}
if (mHostManager != null) {
mHostManager.systemReady();
}
if (mPortManager != null) {
mPortManager.systemReady();
}
}
public void bootCompleted() {
if (mDeviceManager != null) {
mDeviceManager.bootCompleted();
}
}
/** Called when a user is unlocked. */
public void onUnlockUser(int user) {
if (mDeviceManager != null) {
mDeviceManager.onUnlockUser(user);
}
}
/* Returns a list of all currently attached USB devices (host mdoe) */
@Override
public void getDeviceList(Bundle devices) {
if (mHostManager != null) {
mHostManager.getDeviceList(devices);
}
}
/* Opens the specified USB device (host mode) */
@Override
public ParcelFileDescriptor openDevice(String deviceName, String packageName) {
ParcelFileDescriptor fd = null;
if (mHostManager != null) {
if (deviceName != null) {
int uid = Binder.getCallingUid();
int pid = Binder.getCallingPid();
int user = UserHandle.getUserId(uid);
final long ident = clearCallingIdentity();
try {
synchronized (mLock) {
if (mUserManager.isSameProfileGroup(user, mCurrentUserId)) {
fd = mHostManager.openDevice(deviceName, getPermissionsForUser(user),
packageName, pid, uid);
} else {
Slog.w(TAG, "Cannot open " + deviceName + " for user " + user
+ " as user is not active.");
}
}
} finally {
restoreCallingIdentity(ident);
}
}
}
return fd;
}
/* returns the currently attached USB accessory (device mode) */
@Override
public UsbAccessory getCurrentAccessory() {
if (mDeviceManager != null) {
return mDeviceManager.getCurrentAccessory();
} else {
return null;
}
}
/* opens the currently attached USB accessory (device mode) */
@Override
public ParcelFileDescriptor openAccessory(UsbAccessory accessory) {
if (mDeviceManager != null) {
int uid = Binder.getCallingUid();
int user = UserHandle.getUserId(uid);
final long ident = clearCallingIdentity();
try {
synchronized (mLock) {
if (mUserManager.isSameProfileGroup(user, mCurrentUserId)) {
return mDeviceManager.openAccessory(accessory, getPermissionsForUser(user),
uid);
} else {
Slog.w(TAG, "Cannot open " + accessory + " for user " + user
+ " as user is not active.");
}
}
} finally {
restoreCallingIdentity(ident);
}
}
return null;
}
/* Returns a dup of the control file descriptor for the given function. */
@Override
public ParcelFileDescriptor getControlFd(long function) {
mContext.enforceCallingOrSelfPermission(android.Manifest.permission.ACCESS_MTP, null);
return mDeviceManager.getControlFd(function);
}
@Override
public void setDevicePackage(UsbDevice device, String packageName, int userId) {
Objects.requireNonNull(device);
mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MANAGE_USB, null);
UserHandle user = UserHandle.of(userId);
final long token = Binder.clearCallingIdentity();
try {
mSettingsManager.getSettingsForProfileGroup(user).setDevicePackage(device, packageName,
user);
} finally {
Binder.restoreCallingIdentity(token);
}
}
@Override
public void setAccessoryPackage(UsbAccessory accessory, String packageName, int userId) {
Objects.requireNonNull(accessory);
mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MANAGE_USB, null);
UserHandle user = UserHandle.of(userId);
final long token = Binder.clearCallingIdentity();
try {
mSettingsManager.getSettingsForProfileGroup(user).setAccessoryPackage(accessory,
packageName, user);
} finally {
Binder.restoreCallingIdentity(token);
}
}
@Override
public void addDevicePackagesToPreferenceDenied(UsbDevice device, String[] packageNames,
UserHandle user) {
Objects.requireNonNull(device);
packageNames = Preconditions.checkArrayElementsNotNull(packageNames, "packageNames");
Objects.requireNonNull(user);
mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MANAGE_USB, null);
final long token = Binder.clearCallingIdentity();
try {
mSettingsManager.getSettingsForProfileGroup(user)
.addDevicePackagesToDenied(device, packageNames, user);
} finally {
Binder.restoreCallingIdentity(token);
}
}
@Override
public void addAccessoryPackagesToPreferenceDenied(UsbAccessory accessory,
String[] packageNames, UserHandle user) {
Objects.requireNonNull(accessory);
packageNames = Preconditions.checkArrayElementsNotNull(packageNames, "packageNames");
Objects.requireNonNull(user);
mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MANAGE_USB, null);
final long token = Binder.clearCallingIdentity();
try {
mSettingsManager.getSettingsForProfileGroup(user)
.addAccessoryPackagesToDenied(accessory, packageNames, user);
} finally {
Binder.restoreCallingIdentity(token);
}
}
@Override
public void removeDevicePackagesFromPreferenceDenied(UsbDevice device, String[] packageNames,
UserHandle user) {
Objects.requireNonNull(device);
packageNames = Preconditions.checkArrayElementsNotNull(packageNames, "packageNames");
Objects.requireNonNull(user);
mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MANAGE_USB, null);
final long token = Binder.clearCallingIdentity();
try {
mSettingsManager.getSettingsForProfileGroup(user)
.removeDevicePackagesFromDenied(device, packageNames, user);
} finally {
Binder.restoreCallingIdentity(token);
}
}
@Override
public void removeAccessoryPackagesFromPreferenceDenied(UsbAccessory accessory,
String[] packageNames, UserHandle user) {
Objects.requireNonNull(accessory);
packageNames = Preconditions.checkArrayElementsNotNull(packageNames, "packageNames");
Objects.requireNonNull(user);
mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MANAGE_USB, null);
final long token = Binder.clearCallingIdentity();
try {
mSettingsManager.getSettingsForProfileGroup(user)
.removeAccessoryPackagesFromDenied(accessory, packageNames, user);
} finally {
Binder.restoreCallingIdentity(token);
}
}
@Override
public void setDevicePersistentPermission(UsbDevice device, int uid, UserHandle user,
boolean shouldBeGranted) {
Objects.requireNonNull(device);
Objects.requireNonNull(user);
mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MANAGE_USB, null);
final long token = Binder.clearCallingIdentity();
try {
mPermissionManager.getPermissionsForUser(user).setDevicePersistentPermission(device,
uid, shouldBeGranted);
} finally {
Binder.restoreCallingIdentity(token);
}
}
@Override
public void setAccessoryPersistentPermission(UsbAccessory accessory, int uid,
UserHandle user, boolean shouldBeGranted) {
Objects.requireNonNull(accessory);
Objects.requireNonNull(user);
mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MANAGE_USB, null);
final long token = Binder.clearCallingIdentity();
try {
mPermissionManager.getPermissionsForUser(user).setAccessoryPersistentPermission(
accessory, uid, shouldBeGranted);
} finally {
Binder.restoreCallingIdentity(token);
}
}
@Override
public boolean hasDevicePermission(UsbDevice device, String packageName) {
final int uid = Binder.getCallingUid();
final int pid = Binder.getCallingPid();
final int userId = UserHandle.getUserId(uid);
final long token = Binder.clearCallingIdentity();
try {
return getPermissionsForUser(userId).hasPermission(device, packageName, pid, uid);
} finally {
Binder.restoreCallingIdentity(token);
}
}
@Override
public boolean hasAccessoryPermission(UsbAccessory accessory) {
final int uid = Binder.getCallingUid();
final int userId = UserHandle.getUserId(uid);
final long token = Binder.clearCallingIdentity();
try {
return getPermissionsForUser(userId).hasPermission(accessory, uid);
} finally {
Binder.restoreCallingIdentity(token);
}
}
@Override
public void requestDevicePermission(UsbDevice device, String packageName, PendingIntent pi) {
final int uid = Binder.getCallingUid();
final int pid = Binder.getCallingPid();
final int userId = UserHandle.getUserId(uid);
final long token = Binder.clearCallingIdentity();
try {
getPermissionsForUser(userId).requestPermission(device, packageName, pi, pid, uid);
} finally {
Binder.restoreCallingIdentity(token);
}
}
@Override
public void requestAccessoryPermission(
UsbAccessory accessory, String packageName, PendingIntent pi) {
final int uid = Binder.getCallingUid();
final int userId = UserHandle.getUserId(uid);
final long token = Binder.clearCallingIdentity();
try {
getPermissionsForUser(userId).requestPermission(accessory, packageName, pi, uid);
} finally {
Binder.restoreCallingIdentity(token);
}
}
@Override
public void grantDevicePermission(UsbDevice device, int uid) {
mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MANAGE_USB, null);
final int userId = UserHandle.getUserId(uid);
final long token = Binder.clearCallingIdentity();
try {
getPermissionsForUser(userId).grantDevicePermission(device, uid);
} finally {
Binder.restoreCallingIdentity(token);
}
}
@Override
public void grantAccessoryPermission(UsbAccessory accessory, int uid) {
mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MANAGE_USB, null);
final int userId = UserHandle.getUserId(uid);
final long token = Binder.clearCallingIdentity();
try {
getPermissionsForUser(userId).grantAccessoryPermission(accessory, uid);
} finally {
Binder.restoreCallingIdentity(token);
}
}
@Override
public boolean hasDefaults(String packageName, int userId) {
packageName = Preconditions.checkStringNotEmpty(packageName);
mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MANAGE_USB, null);
UserHandle user = UserHandle.of(userId);
final long token = Binder.clearCallingIdentity();
try {
return mSettingsManager.getSettingsForProfileGroup(user).hasDefaults(packageName, user);
} finally {
Binder.restoreCallingIdentity(token);
}
}
@Override
public void clearDefaults(String packageName, int userId) {
packageName = Preconditions.checkStringNotEmpty(packageName);
mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MANAGE_USB, null);
UserHandle user = UserHandle.of(userId);
final long token = Binder.clearCallingIdentity();
try {
mSettingsManager.getSettingsForProfileGroup(user).clearDefaults(packageName, user);
} finally {
Binder.restoreCallingIdentity(token);
}
}
@Override
public void setCurrentFunctions(long functions) {
mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MANAGE_USB, null);
Preconditions.checkArgument(UsbManager.areSettableFunctions(functions));
Preconditions.checkState(mDeviceManager != null);
mDeviceManager.setCurrentFunctions(functions);
}
@Override
public void setCurrentFunction(String functions, boolean usbDataUnlocked) {
setCurrentFunctions(UsbManager.usbFunctionsFromString(functions));
}
@Override
public boolean isFunctionEnabled(String function) {
return (getCurrentFunctions() & UsbManager.usbFunctionsFromString(function)) != 0;
}
@Override
public long getCurrentFunctions() {
mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MANAGE_USB, null);
Preconditions.checkState(mDeviceManager != null);
return mDeviceManager.getCurrentFunctions();
}
@Override
public void setScreenUnlockedFunctions(long functions) {
mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MANAGE_USB, null);
Preconditions.checkArgument(UsbManager.areSettableFunctions(functions));
Preconditions.checkState(mDeviceManager != null);
mDeviceManager.setScreenUnlockedFunctions(functions);
}
@Override
public long getScreenUnlockedFunctions() {
mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MANAGE_USB, null);
Preconditions.checkState(mDeviceManager != null);
return mDeviceManager.getScreenUnlockedFunctions();
}
@Override
public int getCurrentUsbSpeed() {
mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MANAGE_USB, null);
Preconditions.checkNotNull(mDeviceManager, "DeviceManager must not be null");
final long ident = Binder.clearCallingIdentity();
try {
return mDeviceManager.getCurrentUsbSpeed();
} finally {
Binder.restoreCallingIdentity(ident);
}
}
@Override
public int getGadgetHalVersion() {
mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MANAGE_USB, null);
Preconditions.checkNotNull(mDeviceManager, "DeviceManager must not be null");
final long ident = Binder.clearCallingIdentity();
try {
return mDeviceManager.getGadgetHalVersion();
} finally {
Binder.restoreCallingIdentity(ident);
}
}
@Override
public void resetUsbGadget() {
mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MANAGE_USB, null);
Preconditions.checkNotNull(mDeviceManager, "DeviceManager must not be null");
final long ident = Binder.clearCallingIdentity();
try {
mDeviceManager.resetUsbGadget();
} finally {
Binder.restoreCallingIdentity(ident);
}
}
@Override
public List getPorts() {
mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MANAGE_USB, null);
final long ident = Binder.clearCallingIdentity();
try {
if (mPortManager == null) {
return null;
} else {
final UsbPort[] ports = mPortManager.getPorts();
final int numPorts = ports.length;
ArrayList parcelablePorts = new ArrayList<>();
for (int i = 0; i < numPorts; i++) {
parcelablePorts.add(ParcelableUsbPort.of(ports[i]));
}
return parcelablePorts;
}
} finally {
Binder.restoreCallingIdentity(ident);
}
}
@Override
public UsbPortStatus getPortStatus(String portId) {
Objects.requireNonNull(portId, "portId must not be null");
mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MANAGE_USB, null);
final long ident = Binder.clearCallingIdentity();
try {
return mPortManager != null ? mPortManager.getPortStatus(portId) : null;
} finally {
Binder.restoreCallingIdentity(ident);
}
}
@Override
public void setPortRoles(String portId, int powerRole, int dataRole) {
Objects.requireNonNull(portId, "portId must not be null");
UsbPort.checkRoles(powerRole, dataRole);
mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MANAGE_USB, null);
final long ident = Binder.clearCallingIdentity();
try {
if (mPortManager != null) {
mPortManager.setPortRoles(portId, powerRole, dataRole, null);
}
} finally {
Binder.restoreCallingIdentity(ident);
}
}
@Override
public void enableContaminantDetection(String portId, boolean enable) {
Objects.requireNonNull(portId, "portId must not be null");
mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MANAGE_USB, null);
final long ident = Binder.clearCallingIdentity();
try {
if (mPortManager != null) {
mPortManager.enableContaminantDetection(portId, enable, null);
}
} finally {
Binder.restoreCallingIdentity(ident);
}
}
@Override
public int getUsbHalVersion() {
mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MANAGE_USB, null);
final long ident = Binder.clearCallingIdentity();
try {
if (mPortManager != null) {
return mPortManager.getUsbHalVersion();
} else {
return UsbManager.USB_HAL_NOT_SUPPORTED;
}
} finally {
Binder.restoreCallingIdentity(ident);
}
}
@Override
public boolean enableUsbDataSignal(boolean enable) {
mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MANAGE_USB, null);
final long ident = Binder.clearCallingIdentity();
try {
if (mPortManager != null) {
return mPortManager.enableUsbDataSignal(enable);
} else {
return false;
}
} finally {
Binder.restoreCallingIdentity(ident);
}
}
@Override
public void setUsbDeviceConnectionHandler(ComponentName usbDeviceConnectionHandler) {
mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MANAGE_USB, null);
synchronized (mLock) {
if (mCurrentUserId == UserHandle.getCallingUserId()) {
if (mHostManager != null) {
mHostManager.setUsbDeviceConnectionHandler(usbDeviceConnectionHandler);
}
} else {
throw new IllegalArgumentException("Only the current user can register a usb " +
"connection handler");
}
}
}
@Override
public void dump(FileDescriptor fd, PrintWriter writer, String[] args) {
if (!DumpUtils.checkDumpPermission(mContext, TAG, writer)) return;
final IndentingPrintWriter pw = new IndentingPrintWriter(writer, " ");
final long ident = Binder.clearCallingIdentity();
try {
ArraySet argsSet = new ArraySet<>();
Collections.addAll(argsSet, args);
boolean dumpAsProto = false;
if (argsSet.contains("--proto")) {
dumpAsProto = true;
}
if (args == null || args.length == 0 || args[0].equals("-a") || dumpAsProto) {
DualDumpOutputStream dump;
if (dumpAsProto) {
dump = new DualDumpOutputStream(new ProtoOutputStream(fd));
} else {
pw.println("USB MANAGER STATE (dumpsys usb):");
dump = new DualDumpOutputStream(new IndentingPrintWriter(pw, " "));
}
if (mDeviceManager != null) {
mDeviceManager.dump(dump, "device_manager", UsbServiceDumpProto.DEVICE_MANAGER);
}
if (mHostManager != null) {
mHostManager.dump(dump, "host_manager", UsbServiceDumpProto.HOST_MANAGER);
}
if (mPortManager != null) {
mPortManager.dump(dump, "port_manager", UsbServiceDumpProto.PORT_MANAGER);
}
mAlsaManager.dump(dump, "alsa_manager", UsbServiceDumpProto.ALSA_MANAGER);
mSettingsManager.dump(dump, "settings_manager",
UsbServiceDumpProto.SETTINGS_MANAGER);
mPermissionManager.dump(dump, "permissions_manager",
UsbServiceDumpProto.PERMISSIONS_MANAGER);
dump.flush();
} else if ("set-port-roles".equals(args[0]) && args.length == 4) {
final String portId = args[1];
final int powerRole;
switch (args[2]) {
case "source":
powerRole = POWER_ROLE_SOURCE;
break;
case "sink":
powerRole = POWER_ROLE_SINK;
break;
case "no-power":
powerRole = 0;
break;
default:
pw.println("Invalid power role: " + args[2]);
return;
}
final int dataRole;
switch (args[3]) {
case "host":
dataRole = DATA_ROLE_HOST;
break;
case "device":
dataRole = DATA_ROLE_DEVICE;
break;
case "no-data":
dataRole = 0;
break;
default:
pw.println("Invalid data role: " + args[3]);
return;
}
if (mPortManager != null) {
mPortManager.setPortRoles(portId, powerRole, dataRole, pw);
// Note: It might take some time for the side-effects of this operation
// to be fully applied by the kernel since the driver may need to
// renegotiate the USB port mode. If this proves to be an issue
// during debugging, it might be worth adding a sleep here before
// dumping the new state.
pw.println();
mPortManager.dump(new DualDumpOutputStream(new IndentingPrintWriter(pw, " ")),
"", 0);
}
} else if ("add-port".equals(args[0]) && args.length == 3) {
final String portId = args[1];
final int supportedModes;
switch (args[2]) {
case "ufp":
supportedModes = MODE_UFP;
break;
case "dfp":
supportedModes = MODE_DFP;
break;
case "dual":
supportedModes = MODE_DUAL;
break;
case "none":
supportedModes = 0;
break;
default:
pw.println("Invalid mode: " + args[2]);
return;
}
if (mPortManager != null) {
mPortManager.addSimulatedPort(portId, supportedModes, pw);
pw.println();
mPortManager.dump(new DualDumpOutputStream(new IndentingPrintWriter(pw, " ")),
"", 0);
}
} else if ("connect-port".equals(args[0]) && args.length == 5) {
final String portId = args[1];
final int mode;
final boolean canChangeMode = args[2].endsWith("?");
switch (canChangeMode ? removeLastChar(args[2]) : args[2]) {
case "ufp":
mode = MODE_UFP;
break;
case "dfp":
mode = MODE_DFP;
break;
default:
pw.println("Invalid mode: " + args[2]);
return;
}
final int powerRole;
final boolean canChangePowerRole = args[3].endsWith("?");
switch (canChangePowerRole ? removeLastChar(args[3]) : args[3]) {
case "source":
powerRole = POWER_ROLE_SOURCE;
break;
case "sink":
powerRole = POWER_ROLE_SINK;
break;
default:
pw.println("Invalid power role: " + args[3]);
return;
}
final int dataRole;
final boolean canChangeDataRole = args[4].endsWith("?");
switch (canChangeDataRole ? removeLastChar(args[4]) : args[4]) {
case "host":
dataRole = DATA_ROLE_HOST;
break;
case "device":
dataRole = DATA_ROLE_DEVICE;
break;
default:
pw.println("Invalid data role: " + args[4]);
return;
}
if (mPortManager != null) {
mPortManager.connectSimulatedPort(portId, mode, canChangeMode,
powerRole, canChangePowerRole, dataRole, canChangeDataRole, pw);
pw.println();
mPortManager.dump(new DualDumpOutputStream(new IndentingPrintWriter(pw, " ")),
"", 0);
}
} else if ("disconnect-port".equals(args[0]) && args.length == 2) {
final String portId = args[1];
if (mPortManager != null) {
mPortManager.disconnectSimulatedPort(portId, pw);
pw.println();
mPortManager.dump(new DualDumpOutputStream(new IndentingPrintWriter(pw, " ")),
"", 0);
}
} else if ("remove-port".equals(args[0]) && args.length == 2) {
final String portId = args[1];
if (mPortManager != null) {
mPortManager.removeSimulatedPort(portId, pw);
pw.println();
mPortManager.dump(new DualDumpOutputStream(new IndentingPrintWriter(pw, " ")),
"", 0);
}
} else if ("reset".equals(args[0]) && args.length == 1) {
if (mPortManager != null) {
mPortManager.resetSimulation(pw);
pw.println();
mPortManager.dump(new DualDumpOutputStream(new IndentingPrintWriter(pw, " ")),
"", 0);
}
} else if ("set-contaminant-status".equals(args[0]) && args.length == 3) {
final String portId = args[1];
final Boolean wet = Boolean.parseBoolean(args[2]);
if (mPortManager != null) {
mPortManager.simulateContaminantStatus(portId, wet, pw);
pw.println();
mPortManager.dump(new DualDumpOutputStream(new IndentingPrintWriter(pw, " ")),
"", 0);
}
} else if ("ports".equals(args[0]) && args.length == 1) {
if (mPortManager != null) {
mPortManager.dump(new DualDumpOutputStream(new IndentingPrintWriter(pw, " ")),
"", 0);
}
} else if ("dump-descriptors".equals(args[0])) {
mHostManager.dumpDescriptors(pw, args);
} else {
pw.println("Dump current USB state or issue command:");
pw.println(" ports");
pw.println(" set-port-roles ");
pw.println(" add-port ");
pw.println(" connect-port ");
pw.println(" (add ? suffix if mode, power role, or data role can be changed)");
pw.println(" disconnect-port ");
pw.println(" remove-port ");
pw.println(" reset");
pw.println();
pw.println("Example USB type C port role switch:");
pw.println(" dumpsys usb set-port-roles \"default\" source device");
pw.println();
pw.println("Example USB type C port simulation with full capabilities:");
pw.println(" dumpsys usb add-port \"matrix\" dual");
pw.println(" dumpsys usb connect-port \"matrix\" ufp? sink? device?");
pw.println(" dumpsys usb ports");
pw.println(" dumpsys usb disconnect-port \"matrix\"");
pw.println(" dumpsys usb remove-port \"matrix\"");
pw.println(" dumpsys usb reset");
pw.println();
pw.println("Example USB type C port where only power role can be changed:");
pw.println(" dumpsys usb add-port \"matrix\" dual");
pw.println(" dumpsys usb connect-port \"matrix\" dfp source? host");
pw.println(" dumpsys usb reset");
pw.println();
pw.println("Example USB OTG port where id pin determines function:");
pw.println(" dumpsys usb add-port \"matrix\" dual");
pw.println(" dumpsys usb connect-port \"matrix\" dfp source host");
pw.println(" dumpsys usb reset");
pw.println();
pw.println("Example USB device-only port:");
pw.println(" dumpsys usb add-port \"matrix\" ufp");
pw.println(" dumpsys usb connect-port \"matrix\" ufp sink device");
pw.println(" dumpsys usb reset");
pw.println();
pw.println("Example simulate contaminant status:");
pw.println(" dumpsys usb add-port \"matrix\" ufp");
pw.println(" dumpsys usb set-contaminant-status \"matrix\" true");
pw.println(" dumpsys usb set-contaminant-status \"matrix\" false");
pw.println();
pw.println("Example USB device descriptors:");
pw.println(" dumpsys usb dump-descriptors -dump-short");
pw.println(" dumpsys usb dump-descriptors -dump-tree");
pw.println(" dumpsys usb dump-descriptors -dump-list");
pw.println(" dumpsys usb dump-descriptors -dump-raw");
}
} finally {
Binder.restoreCallingIdentity(ident);
}
}
private static String removeLastChar(String value) {
return value.substring(0, value.length() - 1);
}
}