/** Called by the Binder stub. */
void dump(String[] args, PrintWriter pw) {
synchronized (mLock) {
final long screenOnTime = getScreenOnTimeLocked(checkAndGetTimeLocked());
IndentingPrintWriter idpw = new IndentingPrintWriter(pw, " ");
ArraySet<String> argSet = new ArraySet<>();
argSet.addAll(Arrays.asList(args));
final int userCount = mUserState.size();
for (int i = 0; i < userCount; i++) {
idpw.printPair("user", mUserState.keyAt(i));
idpw.println();
idpw.increaseIndent();
if (argSet.contains("--checkin")) {
mUserState.valueAt(i).checkin(idpw, screenOnTime);
} else {
mUserState.valueAt(i).dump(idpw, screenOnTime);
idpw.println();
if (args.length > 0 && "history".equals(args[0])) {
mAppIdleHistory.dump(idpw, mUserState.keyAt(i));
}
}
idpw.decreaseIndent();
}
pw.write("Screen On Timebase:" + mScreenOnTime + "\n");
}
}
public void removeSimulatedPort(String portId, IndentingPrintWriter pw) {
synchronized (mLock) {
final int index = mSimulatedPorts.indexOfKey(portId);
if (index < 0) {
pw.println("Cannot remove simulated port which does not exist.");
return;
}
pw.println("Disconnecting simulated port: portId=" + portId);
mSimulatedPorts.removeAt(index);
updatePortsLocked(pw);
}
}
public void connectSimulatedPort(
String portId,
int mode,
boolean canChangeMode,
int powerRole,
boolean canChangePowerRole,
int dataRole,
boolean canChangeDataRole,
IndentingPrintWriter pw) {
synchronized (mLock) {
final SimulatedPortInfo portInfo = mSimulatedPorts.get(portId);
if (portInfo == null) {
pw.println("Cannot connect simulated port which does not exist.");
return;
}
if (mode == 0 || powerRole == 0 || dataRole == 0) {
pw.println("Cannot connect simulated port in null mode, " + "power role, or data role.");
return;
}
if ((portInfo.mSupportedModes & mode) == 0) {
pw.println("Simulated port does not support mode: " + UsbPort.modeToString(mode));
return;
}
pw.println(
"Connecting simulated port: portId="
+ portId
+ ", mode="
+ UsbPort.modeToString(mode)
+ ", canChangeMode="
+ canChangeMode
+ ", powerRole="
+ UsbPort.powerRoleToString(powerRole)
+ ", canChangePowerRole="
+ canChangePowerRole
+ ", dataRole="
+ UsbPort.dataRoleToString(dataRole)
+ ", canChangeDataRole="
+ canChangeDataRole);
portInfo.mCurrentMode = mode;
portInfo.mCanChangeMode = canChangeMode;
portInfo.mCurrentPowerRole = powerRole;
portInfo.mCanChangePowerRole = canChangePowerRole;
portInfo.mCurrentDataRole = dataRole;
portInfo.mCanChangeDataRole = canChangeDataRole;
updatePortsLocked(pw);
}
}
public void addSimulatedPort(String portId, int supportedModes, IndentingPrintWriter pw) {
synchronized (mLock) {
if (mSimulatedPorts.containsKey(portId)) {
pw.println("Port with same name already exists. Please remove it first.");
return;
}
pw.println(
"Adding simulated port: portId="
+ portId
+ ", supportedModes="
+ UsbPort.modeToString(supportedModes));
mSimulatedPorts.put(portId, new SimulatedPortInfo(portId, supportedModes));
updatePortsLocked(pw);
}
}
public void dump(IndentingPrintWriter pw) {
synchronized (mLock) {
pw.print("USB Port State:");
if (!mSimulatedPorts.isEmpty()) {
pw.print(" (simulation active; end with 'dumpsys usb reset')");
}
pw.println();
if (mPorts.isEmpty()) {
pw.println(" <no ports>");
} else {
for (PortInfo portInfo : mPorts.values()) {
pw.println(" " + portInfo.mUsbPort.getId() + ": " + portInfo);
}
}
}
}
public static void dumpCallEvents(IndentingPrintWriter pw) {
pw.println("Historical Calls:");
pw.increaseIndent();
for (CallEventRecord callEventRecord : mCallEventRecords) {
callEventRecord.dump(pw);
}
pw.decreaseIndent();
}
public void resetSimulation(IndentingPrintWriter pw) {
synchronized (mLock) {
pw.println("Removing all simulated ports and ending simulation.");
if (!mSimulatedPorts.isEmpty()) {
mSimulatedPorts.clear();
updatePortsLocked(pw);
}
}
}
public void disconnectSimulatedPort(String portId, IndentingPrintWriter pw) {
synchronized (mLock) {
final SimulatedPortInfo portInfo = mSimulatedPorts.get(portId);
if (portInfo == null) {
pw.println("Cannot disconnect simulated port which does not exist.");
return;
}
pw.println("Disconnecting simulated port: portId=" + portId);
portInfo.mCurrentMode = 0;
portInfo.mCanChangeMode = false;
portInfo.mCurrentPowerRole = 0;
portInfo.mCanChangePowerRole = false;
portInfo.mCurrentDataRole = 0;
portInfo.mCanChangeDataRole = false;
updatePortsLocked(pw);
}
}
public void dump(IndentingPrintWriter pw) {
pw.println("USB Device State:");
pw.println(" mCurrentFunctions: " + mCurrentFunctions);
pw.println(" mCurrentFunctionsApplied: " + mCurrentFunctionsApplied);
pw.println(" mConnected: " + mConnected);
pw.println(" mConfigured: " + mConfigured);
pw.println(" mUsbDataUnlocked: " + mUsbDataUnlocked);
pw.println(" mCurrentAccessory: " + mCurrentAccessory);
try {
pw.println(
" Kernel state: " + FileUtils.readTextFile(new File(STATE_PATH), 0, null).trim());
pw.println(
" Kernel function list: "
+ FileUtils.readTextFile(new File(FUNCTIONS_PATH), 0, null).trim());
} catch (IOException e) {
pw.println("IOException: " + e);
}
}
@Override
public void dump(FileDescriptor fd, PrintWriter writer, String[] args) {
final IndentingPrintWriter pw = new IndentingPrintWriter(writer, " ", 160);
synchronized (mRootsLock) {
for (int i = 0; i < mRoots.size(); i++) {
final RootInfo root = mRoots.valueAt(i);
pw.println("Root{" + root.rootId + "}:");
pw.increaseIndent();
pw.printPair("flags", DebugUtils.flagsToString(Root.class, "FLAG_", root.flags));
pw.println();
pw.printPair("title", root.title);
pw.printPair("docId", root.docId);
pw.println();
pw.printPair("path", root.path);
pw.printPair("visiblePath", root.visiblePath);
pw.decreaseIndent();
pw.println();
}
}
}
private static void logAndPrint(int priority, IndentingPrintWriter pw, String msg) {
Slog.println(priority, TAG, msg);
if (pw != null) {
pw.println(msg);
}
}
public void setPortRoles(
String portId, int newPowerRole, int newDataRole, IndentingPrintWriter pw) {
synchronized (mLock) {
final PortInfo portInfo = mPorts.get(portId);
if (portInfo == null) {
if (pw != null) {
pw.println("No such USB port: " + portId);
}
return;
}
// Check whether the new role is actually supported.
if (!portInfo.mUsbPortStatus.isRoleCombinationSupported(newPowerRole, newDataRole)) {
logAndPrint(
Log.ERROR,
pw,
"Attempted to set USB port into unsupported "
+ "role combination: portId="
+ portId
+ ", newPowerRole="
+ UsbPort.powerRoleToString(newPowerRole)
+ ", newDataRole="
+ UsbPort.dataRoleToString(newDataRole));
return;
}
// Check whether anything actually changed.
final int currentDataRole = portInfo.mUsbPortStatus.getCurrentDataRole();
final int currentPowerRole = portInfo.mUsbPortStatus.getCurrentPowerRole();
if (currentDataRole == newDataRole && currentPowerRole == newPowerRole) {
if (pw != null) {
pw.println("No change.");
}
return;
}
// Determine whether we need to change the mode in order to accomplish this goal.
// We prefer not to do this since it's more likely to fail.
//
// Note: Arguably it might be worth allowing the client to influence this policy
// decision so that we could show more powerful developer facing UI but let's
// see how far we can get without having to do that.
final boolean canChangeMode = portInfo.mCanChangeMode;
final boolean canChangePowerRole = portInfo.mCanChangePowerRole;
final boolean canChangeDataRole = portInfo.mCanChangeDataRole;
final int currentMode = portInfo.mUsbPortStatus.getCurrentMode();
final int newMode;
if ((!canChangePowerRole && currentPowerRole != newPowerRole)
|| (!canChangeDataRole && currentDataRole != newDataRole)) {
if (canChangeMode
&& newPowerRole == UsbPort.POWER_ROLE_SOURCE
&& newDataRole == UsbPort.DATA_ROLE_HOST) {
newMode = UsbPort.MODE_DFP;
} else if (canChangeMode
&& newPowerRole == UsbPort.POWER_ROLE_SINK
&& newDataRole == UsbPort.DATA_ROLE_DEVICE) {
newMode = UsbPort.MODE_UFP;
} else {
logAndPrint(
Log.ERROR,
pw,
"Found mismatch in supported USB role combinations "
+ "while attempting to change role: "
+ portInfo
+ ", newPowerRole="
+ UsbPort.powerRoleToString(newPowerRole)
+ ", newDataRole="
+ UsbPort.dataRoleToString(newDataRole));
return;
}
} else {
newMode = currentMode;
}
// Make it happen.
logAndPrint(
Log.INFO,
pw,
"Setting USB port mode and role: portId="
+ portId
+ ", currentMode="
+ UsbPort.modeToString(currentMode)
+ ", currentPowerRole="
+ UsbPort.powerRoleToString(currentPowerRole)
+ ", currentDataRole="
+ UsbPort.dataRoleToString(currentDataRole)
+ ", newMode="
+ UsbPort.modeToString(newMode)
+ ", newPowerRole="
+ UsbPort.powerRoleToString(newPowerRole)
+ ", newDataRole="
+ UsbPort.dataRoleToString(newDataRole));
SimulatedPortInfo sim = mSimulatedPorts.get(portId);
if (sim != null) {
// Change simulated state.
sim.mCurrentMode = newMode;
sim.mCurrentPowerRole = newPowerRole;
sim.mCurrentDataRole = newDataRole;
} else if (mHaveKernelSupport) {
// Change actual state.
final File portDir = new File(SYSFS_CLASS, portId);
if (!portDir.exists()) {
logAndPrint(Log.ERROR, pw, "USB port not found: portId=" + portId);
return;
}
if (currentMode != newMode) {
// Changing the mode will have the side-effect of also changing
// the power and data roles but it might take some time to apply
// and the renegotiation might fail. Due to limitations of the USB
// hardware, we have no way of knowing whether it will work apriori
// which is why we would prefer to set the power and data roles
// directly instead.
if (!writeFile(
portDir,
SYSFS_PORT_MODE,
newMode == UsbPort.MODE_DFP ? PORT_MODE_DFP : PORT_MODE_UFP)) {
logAndPrint(
Log.ERROR,
pw,
"Failed to set the USB port mode: "
+ "portId="
+ portId
+ ", newMode="
+ UsbPort.modeToString(newMode));
return;
}
} else {
// Change power and data role independently as needed.
if (currentPowerRole != newPowerRole) {
if (!writeFile(
portDir,
SYSFS_PORT_POWER_ROLE,
newPowerRole == UsbPort.POWER_ROLE_SOURCE
? PORT_POWER_ROLE_SOURCE
: PORT_POWER_ROLE_SINK)) {
logAndPrint(
Log.ERROR,
pw,
"Failed to set the USB port power role: "
+ "portId="
+ portId
+ ", newPowerRole="
+ UsbPort.powerRoleToString(newPowerRole));
return;
}
}
if (currentDataRole != newDataRole) {
if (!writeFile(
portDir,
SYSFS_PORT_DATA_ROLE,
newDataRole == UsbPort.DATA_ROLE_HOST
? PORT_DATA_ROLE_HOST
: PORT_DATA_ROLE_DEVICE)) {
logAndPrint(
Log.ERROR,
pw,
"Failed to set the USB port data role: "
+ "portId="
+ portId
+ ", newDataRole="
+ UsbPort.dataRoleToString(newDataRole));
return;
}
}
}
}
updatePortsLocked(pw);
}
}
public static void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
pw.println("PhoneFactory:");
PhoneProxy[] phones = (PhoneProxy[]) PhoneFactory.getPhones();
int i = -1;
for (PhoneProxy phoneProxy : phones) {
PhoneBase phoneBase;
i += 1;
try {
phoneBase = (PhoneBase) phoneProxy.getActivePhone();
phoneBase.dump(fd, pw, args);
} catch (Exception e) {
pw.println("Telephony DebugService: Could not get Phone[" + i + "] e=" + e);
continue;
}
pw.flush();
pw.println("++++++++++++++++++++++++++++++++");
try {
((IccCardProxy) phoneProxy.getIccCard()).dump(fd, pw, args);
} catch (Exception e) {
e.printStackTrace();
}
pw.flush();
pw.println("++++++++++++++++++++++++++++++++");
}
try {
DctController.getInstance().dump(fd, pw, args);
} catch (Exception e) {
e.printStackTrace();
}
try {
mUiccController.dump(fd, pw, args);
} catch (Exception e) {
e.printStackTrace();
}
pw.flush();
pw.println("++++++++++++++++++++++++++++++++");
try {
SubscriptionController.getInstance().dump(fd, pw, args);
} catch (Exception e) {
e.printStackTrace();
}
pw.flush();
pw.println("++++++++++++++++++++++++++++++++");
try {
sSubInfoRecordUpdater.dump(fd, pw, args);
} catch (Exception e) {
e.printStackTrace();
}
pw.flush();
pw.println("++++++++++++++++++++++++++++++++");
synchronized (sLocalLogs) {
final IndentingPrintWriter ipw = new IndentingPrintWriter(pw, " ");
for (String key : sLocalLogs.keySet()) {
ipw.println(key);
ipw.increaseIndent();
sLocalLogs.get(key).dump(fd, ipw, args);
ipw.decreaseIndent();
}
ipw.flush();
}
}
@Override
protected void dump(final IndentingPrintWriter pw) {
super.dump(pw);
pw.println("mIsActiveSource: " + mIsActiveSource);
}
public void dump(IndentingPrintWriter pw) {
Map<String, CallEvent> pendingResponses = new HashMap<>();
pw.print("Call ");
pw.print(mId);
pw.print(" [");
pw.print(sDateFormat.format(new Date(mCall.getCreationTimeMillis())));
pw.print("]");
pw.println(mCall.isIncoming() ? "(MT - incoming)" : "(MO - outgoing)");
pw.increaseIndent();
pw.println("To address: " + piiHandle(mCall.getHandle()));
for (CallEvent event : mEvents) {
// We print out events in chronological order. During that process we look at each
// event and see if it maps to a request on the Request-Response pairs map. If it
// does, then we effectively start 'listening' for the response. We do that by
// storing the response event ID in {@code pendingResponses}. When we find the
// response in a later iteration of the loop, we grab the original request and
// calculate the time it took to get a response.
if (Events.requestResponsePairs.containsKey(event.eventId)) {
// This event expects a response, so add that response to the maps
// of pending events.
String pendingResponse = Events.requestResponsePairs.get(event.eventId);
pendingResponses.put(pendingResponse, event);
}
pw.print(sDateFormat.format(new Date(event.time)));
pw.print(" - ");
pw.print(event.eventId);
if (event.data != null) {
pw.print(" (");
Object data = event.data;
if (data instanceof Call) {
// If the data is another call, then change the data to the call's CallEvent
// ID instead.
CallEventRecord record = mCallEventRecordMap.get(data);
if (record != null) {
data = "Call " + record.mId;
}
}
pw.print(data);
pw.print(")");
}
// If this event is a response event that we've been waiting for, calculate the time
// it took for the response to complete and print that out as well.
CallEvent requestEvent = pendingResponses.remove(event.eventId);
if (requestEvent != null) {
pw.print(", time since ");
pw.print(requestEvent.eventId);
pw.print(": ");
pw.print(event.time - requestEvent.time);
pw.print(" ms");
}
pw.println();
}
pw.decreaseIndent();
}