public UsbDeviceManager(Context context, UsbAlsaManager alsaManager) {
    mContext = context;
    mUsbAlsaManager = alsaManager;
    mContentResolver = context.getContentResolver();
    PackageManager pm = mContext.getPackageManager();
    mHasUsbAccessory = pm.hasSystemFeature(PackageManager.FEATURE_USB_ACCESSORY);
    initRndisAddress();

    readOemUsbOverrideConfig();

    mHandler = new UsbHandler(FgThread.get().getLooper());

    if (nativeIsStartRequested()) {
      if (DEBUG) Slog.d(TAG, "accessory attached at boot");
      startAccessoryMode();
    }

    boolean secureAdbEnabled = SystemProperties.getBoolean("ro.adb.secure", false);
    boolean dataEncrypted = "1".equals(SystemProperties.get("vold.decrypt"));
    if (secureAdbEnabled && !dataEncrypted) {
      mDebuggingManager = new UsbDebuggingManager(context);
    }
    mContext.registerReceiver(mHostReceiver, new IntentFilter(UsbManager.ACTION_USB_PORT_CHANGED));
  }
/**
 * Allows trusted components to control the properties of physical USB ports via the
 * "/sys/class/dual_role_usb" kernel interface.
 *
 * <p>Note: This interface may not be supported on all chipsets since the USB drivers must be
 * changed to publish this information through the module. At the moment we only need this for
 * devices with USB Type C ports to allow the System UI to control USB charging and data direction.
 * On devices that do not support this interface the list of ports may incorrectly appear to be
 * empty (but we don't care today).
 */
public class UsbPortManager {
  private static final String TAG = "UsbPortManager";

  private static final int MSG_UPDATE_PORTS = 1;

  // UEvent path to watch.
  private static final String UEVENT_FILTER = "SUBSYSTEM=dual_role_usb";

  // SysFS directory that contains USB ports as subdirectories.
  private static final String SYSFS_CLASS = "/sys/class/dual_role_usb";

  // SysFS file that contains a USB port's supported modes.  (read-only)
  // Contents: "", "ufp", "dfp", or "ufp dfp".
  private static final String SYSFS_PORT_SUPPORTED_MODES = "supported_modes";

  // SysFS file that contains a USB port's current mode.  (read-write if configurable)
  // Contents: "", "ufp", or "dfp".
  private static final String SYSFS_PORT_MODE = "mode";

  // SysFS file that contains a USB port's current power role.  (read-write if configurable)
  // Contents: "", "source", or "sink".
  private static final String SYSFS_PORT_POWER_ROLE = "power_role";

  // SysFS file that contains a USB port's current data role.  (read-write if configurable)
  // Contents: "", "host", or "device".
  private static final String SYSFS_PORT_DATA_ROLE = "data_role";

  // Port modes: upstream facing port or downstream facing port.
  private static final String PORT_MODE_DFP = "dfp";
  private static final String PORT_MODE_UFP = "ufp";

  // Port power roles: source or sink.
  private static final String PORT_POWER_ROLE_SOURCE = "source";
  private static final String PORT_POWER_ROLE_SINK = "sink";

  // Port data roles: host or device.
  private static final String PORT_DATA_ROLE_HOST = "host";
  private static final String PORT_DATA_ROLE_DEVICE = "device";

  private static final String USB_TYPEC_PROP_PREFIX = "sys.usb.typec.";
  private static final String USB_TYPEC_STATE = "sys.usb.typec.state";

  // All non-trivial role combinations.
  private static final int COMBO_SOURCE_HOST =
      UsbPort.combineRolesAsBit(UsbPort.POWER_ROLE_SOURCE, UsbPort.DATA_ROLE_HOST);
  private static final int COMBO_SOURCE_DEVICE =
      UsbPort.combineRolesAsBit(UsbPort.POWER_ROLE_SOURCE, UsbPort.DATA_ROLE_DEVICE);
  private static final int COMBO_SINK_HOST =
      UsbPort.combineRolesAsBit(UsbPort.POWER_ROLE_SINK, UsbPort.DATA_ROLE_HOST);
  private static final int COMBO_SINK_DEVICE =
      UsbPort.combineRolesAsBit(UsbPort.POWER_ROLE_SINK, UsbPort.DATA_ROLE_DEVICE);

  // The system context.
  private final Context mContext;

  // True if we have kernel support.
  private final boolean mHaveKernelSupport;

  // Mutex for all mutable shared state.
  private final Object mLock = new Object();

  // List of all ports, indexed by id.
  // Ports may temporarily have different dispositions as they are added or removed
  // but the class invariant is that this list will only contain ports with DISPOSITION_READY
  // except while updatePortsLocked() is in progress.
  private final ArrayMap<String, PortInfo> mPorts = new ArrayMap<String, PortInfo>();

  // List of all simulated ports, indexed by id.
  private final ArrayMap<String, SimulatedPortInfo> mSimulatedPorts =
      new ArrayMap<String, SimulatedPortInfo>();

  public UsbPortManager(Context context) {
    mContext = context;
    mHaveKernelSupport = new File(SYSFS_CLASS).exists();
  }

  public void systemReady() {
    mUEventObserver.startObserving(UEVENT_FILTER);
    scheduleUpdatePorts();
  }

  public UsbPort[] getPorts() {
    synchronized (mLock) {
      final int count = mPorts.size();
      final UsbPort[] result = new UsbPort[count];
      for (int i = 0; i < count; i++) {
        result[i] = mPorts.valueAt(i).mUsbPort;
      }
      return result;
    }
  }

  public UsbPortStatus getPortStatus(String portId) {
    synchronized (mLock) {
      final PortInfo portInfo = mPorts.get(portId);
      return portInfo != null ? portInfo.mUsbPortStatus : null;
    }
  }

  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 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 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 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 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 resetSimulation(IndentingPrintWriter pw) {
    synchronized (mLock) {
      pw.println("Removing all simulated ports and ending simulation.");
      if (!mSimulatedPorts.isEmpty()) {
        mSimulatedPorts.clear();
        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);
        }
      }
    }
  }

  private void updatePortsLocked(IndentingPrintWriter pw) {
    // Assume all ports are gone unless informed otherwise.
    // Kind of pessimistic but simple.
    for (int i = mPorts.size(); i-- > 0; ) {
      mPorts.valueAt(i).mDisposition = PortInfo.DISPOSITION_REMOVED;
    }

    // Enumerate all extant ports.
    if (!mSimulatedPorts.isEmpty()) {
      final int count = mSimulatedPorts.size();
      for (int i = 0; i < count; i++) {
        final SimulatedPortInfo portInfo = mSimulatedPorts.valueAt(i);
        addOrUpdatePortLocked(
            portInfo.mPortId,
            portInfo.mSupportedModes,
            portInfo.mCurrentMode,
            portInfo.mCanChangeMode,
            portInfo.mCurrentPowerRole,
            portInfo.mCanChangePowerRole,
            portInfo.mCurrentDataRole,
            portInfo.mCanChangeDataRole,
            pw);
      }
    } else if (mHaveKernelSupport) {
      final File[] portDirs = new File(SYSFS_CLASS).listFiles();
      if (portDirs != null) {
        for (File portDir : portDirs) {
          if (!portDir.isDirectory()) {
            continue;
          }

          // Parse the sysfs file contents.
          final String portId = portDir.getName();
          final int supportedModes = readSupportedModes(portDir);
          final int currentMode = readCurrentMode(portDir);
          final boolean canChangeMode = canChangeMode(portDir);
          final int currentPowerRole = readCurrentPowerRole(portDir);
          final boolean canChangePowerRole = canChangePowerRole(portDir);
          final int currentDataRole = readCurrentDataRole(portDir);
          final boolean canChangeDataRole = canChangeDataRole(portDir);
          addOrUpdatePortLocked(
              portId,
              supportedModes,
              currentMode,
              canChangeMode,
              currentPowerRole,
              canChangePowerRole,
              currentDataRole,
              canChangeDataRole,
              pw);
        }
      }
    }

    // Process the updates.
    // Once finished, the list of ports will only contain ports in DISPOSITION_READY.
    for (int i = mPorts.size(); i-- > 0; ) {
      final PortInfo portInfo = mPorts.valueAt(i);
      switch (portInfo.mDisposition) {
        case PortInfo.DISPOSITION_ADDED:
          handlePortAddedLocked(portInfo, pw);
          portInfo.mDisposition = PortInfo.DISPOSITION_READY;
          break;
        case PortInfo.DISPOSITION_CHANGED:
          handlePortChangedLocked(portInfo, pw);
          portInfo.mDisposition = PortInfo.DISPOSITION_READY;
          break;
        case PortInfo.DISPOSITION_REMOVED:
          mPorts.removeAt(i);
          portInfo.mUsbPortStatus = null; // must do this early
          handlePortRemovedLocked(portInfo, pw);
          break;
      }
    }
  }

  // Must only be called by updatePortsLocked.
  private void addOrUpdatePortLocked(
      String portId,
      int supportedModes,
      int currentMode,
      boolean canChangeMode,
      int currentPowerRole,
      boolean canChangePowerRole,
      int currentDataRole,
      boolean canChangeDataRole,
      IndentingPrintWriter pw) {
    // Only allow mode switch capability for dual role ports.
    // Validate that the current mode matches the supported modes we expect.
    if (supportedModes != UsbPort.MODE_DUAL) {
      canChangeMode = false;
      if (currentMode != 0 && currentMode != supportedModes) {
        logAndPrint(
            Log.WARN,
            pw,
            "Ignoring inconsistent current mode from USB "
                + "port driver: supportedModes="
                + UsbPort.modeToString(supportedModes)
                + ", currentMode="
                + UsbPort.modeToString(currentMode));
        currentMode = 0;
      }
    }

    // Determine the supported role combinations.
    // Note that the policy is designed to prefer setting the power and data
    // role independently rather than changing the mode.
    int supportedRoleCombinations = UsbPort.combineRolesAsBit(currentPowerRole, currentDataRole);
    if (currentMode != 0 && currentPowerRole != 0 && currentDataRole != 0) {
      if (canChangePowerRole && canChangeDataRole) {
        // Can change both power and data role independently.
        // Assume all combinations are possible.
        supportedRoleCombinations |=
            COMBO_SOURCE_HOST | COMBO_SOURCE_DEVICE | COMBO_SINK_HOST | COMBO_SINK_DEVICE;
      } else if (canChangePowerRole) {
        // Can only change power role.
        // Assume data role must remain at its current value.
        supportedRoleCombinations |=
            UsbPort.combineRolesAsBit(UsbPort.POWER_ROLE_SOURCE, currentDataRole);
        supportedRoleCombinations |=
            UsbPort.combineRolesAsBit(UsbPort.POWER_ROLE_SINK, currentDataRole);
      } else if (canChangeDataRole) {
        // Can only change data role.
        // Assume power role must remain at its current value.
        supportedRoleCombinations |=
            UsbPort.combineRolesAsBit(currentPowerRole, UsbPort.DATA_ROLE_HOST);
        supportedRoleCombinations |=
            UsbPort.combineRolesAsBit(currentPowerRole, UsbPort.DATA_ROLE_DEVICE);
      } else if (canChangeMode) {
        // Can only change the mode.
        // Assume both standard UFP and DFP configurations will become available
        // when this happens.
        supportedRoleCombinations |= COMBO_SOURCE_HOST | COMBO_SINK_DEVICE;
      }
    }

    // Update the port data structures.
    PortInfo portInfo = mPorts.get(portId);
    if (portInfo == null) {
      portInfo = new PortInfo(portId, supportedModes);
      portInfo.setStatus(
          currentMode,
          canChangeMode,
          currentPowerRole,
          canChangePowerRole,
          currentDataRole,
          canChangeDataRole,
          supportedRoleCombinations);
      mPorts.put(portId, portInfo);
    } else {
      // Sanity check that ports aren't changing definition out from under us.
      if (supportedModes != portInfo.mUsbPort.getSupportedModes()) {
        logAndPrint(
            Log.WARN,
            pw,
            "Ignoring inconsistent list of supported modes from "
                + "USB port driver (should be immutable): "
                + "previous="
                + UsbPort.modeToString(portInfo.mUsbPort.getSupportedModes())
                + ", current="
                + UsbPort.modeToString(supportedModes));
      }

      if (portInfo.setStatus(
          currentMode,
          canChangeMode,
          currentPowerRole,
          canChangePowerRole,
          currentDataRole,
          canChangeDataRole,
          supportedRoleCombinations)) {
        portInfo.mDisposition = PortInfo.DISPOSITION_CHANGED;
      } else {
        portInfo.mDisposition = PortInfo.DISPOSITION_READY;
      }
    }
  }

  private void handlePortAddedLocked(PortInfo portInfo, IndentingPrintWriter pw) {
    logAndPrint(Log.INFO, pw, "USB port added: " + portInfo);
    sendPortChangedBroadcastLocked(portInfo);
  }

  private void handlePortChangedLocked(PortInfo portInfo, IndentingPrintWriter pw) {
    logAndPrint(Log.INFO, pw, "USB port changed: " + portInfo);
    sendPortChangedBroadcastLocked(portInfo);
  }

  private void handlePortRemovedLocked(PortInfo portInfo, IndentingPrintWriter pw) {
    logAndPrint(Log.INFO, pw, "USB port removed: " + portInfo);
    sendPortChangedBroadcastLocked(portInfo);
  }

  private void sendPortChangedBroadcastLocked(PortInfo portInfo) {
    final Intent intent = new Intent(UsbManager.ACTION_USB_PORT_CHANGED);
    intent.addFlags(Intent.FLAG_RECEIVER_FOREGROUND);
    intent.putExtra(UsbManager.EXTRA_PORT, portInfo.mUsbPort);
    intent.putExtra(UsbManager.EXTRA_PORT_STATUS, portInfo.mUsbPortStatus);

    // Guard against possible reentrance by posting the broadcast from the handler
    // instead of from within the critical section.
    mHandler.post(
        new Runnable() {
          @Override
          public void run() {
            mContext.sendBroadcastAsUser(intent, UserHandle.ALL);
          }
        });
  }

  private void scheduleUpdatePorts() {
    if (!mHandler.hasMessages(MSG_UPDATE_PORTS)) {
      mHandler.sendEmptyMessage(MSG_UPDATE_PORTS);
    }
  }

  private static int readSupportedModes(File portDir) {
    int modes = 0;
    final String contents = readFile(portDir, SYSFS_PORT_SUPPORTED_MODES);
    if (contents != null) {
      if (contents.contains(PORT_MODE_DFP)) {
        modes |= UsbPort.MODE_DFP;
      }
      if (contents.contains(PORT_MODE_UFP)) {
        modes |= UsbPort.MODE_UFP;
      }
    }
    return modes;
  }

  private static int readCurrentMode(File portDir) {
    final String contents = readFile(portDir, SYSFS_PORT_MODE);
    if (contents != null) {
      if (contents.equals(PORT_MODE_DFP)) {
        return UsbPort.MODE_DFP;
      }
      if (contents.equals(PORT_MODE_UFP)) {
        return UsbPort.MODE_UFP;
      }
    }
    return 0;
  }

  private static int readCurrentPowerRole(File portDir) {
    final String contents = readFile(portDir, SYSFS_PORT_POWER_ROLE);
    if (contents != null) {
      if (contents.equals(PORT_POWER_ROLE_SOURCE)) {
        return UsbPort.POWER_ROLE_SOURCE;
      }
      if (contents.equals(PORT_POWER_ROLE_SINK)) {
        return UsbPort.POWER_ROLE_SINK;
      }
    }
    return 0;
  }

  private static int readCurrentDataRole(File portDir) {
    final String contents = readFile(portDir, SYSFS_PORT_DATA_ROLE);
    if (contents != null) {
      if (contents.equals(PORT_DATA_ROLE_HOST)) {
        return UsbPort.DATA_ROLE_HOST;
      }
      if (contents.equals(PORT_DATA_ROLE_DEVICE)) {
        return UsbPort.DATA_ROLE_DEVICE;
      }
    }
    return 0;
  }

  private static boolean fileIsRootWritable(String path) {
    try {
      // If the file is user writable, then it is root writable.
      return (Os.stat(path).st_mode & OsConstants.S_IWUSR) != 0;
    } catch (ErrnoException e) {
      return false;
    }
  }

  private static boolean canChangeMode(File portDir) {
    return fileIsRootWritable(new File(portDir, SYSFS_PORT_MODE).getPath());
  }

  private static boolean canChangePowerRole(File portDir) {
    return fileIsRootWritable(new File(portDir, SYSFS_PORT_POWER_ROLE).getPath());
  }

  private static boolean canChangeDataRole(File portDir) {
    return fileIsRootWritable(new File(portDir, SYSFS_PORT_DATA_ROLE).getPath());
  }

  private static String readFile(File dir, String filename) {
    final File file = new File(dir, filename);
    try {
      return IoUtils.readFileAsString(file.getAbsolutePath()).trim();
    } catch (IOException ex) {
      return null;
    }
  }

  private static boolean waitForState(String property, String state) {
    // wait for the transition to complete.
    // give up after 5 seconds.
    // 5 seconds is probably too long, but we have seen hardware that takes
    // over 3 seconds to change states.
    String value = null;
    for (int i = 0; i < 100; i++) {
      // State transition is done when property is set to the new configuration
      value = SystemProperties.get(property);
      if (state.equals(value)) return true;
      SystemClock.sleep(50);
    }
    Slog.e(TAG, "waitForState(" + state + ") for " + property + " FAILED: got " + value);
    return false;
  }

  private static String propertyFromFilename(String filename) {
    return USB_TYPEC_PROP_PREFIX + filename;
  }

  private static boolean writeFile(File dir, String filename, String contents) {
    SystemProperties.set(propertyFromFilename(filename), contents);
    return waitForState(USB_TYPEC_STATE, contents);
  }

  private static void logAndPrint(int priority, IndentingPrintWriter pw, String msg) {
    Slog.println(priority, TAG, msg);
    if (pw != null) {
      pw.println(msg);
    }
  }

  private final Handler mHandler =
      new Handler(FgThread.get().getLooper()) {
        @Override
        public void handleMessage(Message msg) {
          switch (msg.what) {
            case MSG_UPDATE_PORTS:
              {
                synchronized (mLock) {
                  updatePortsLocked(null);
                }
                break;
              }
          }
        }
      };

  private final UEventObserver mUEventObserver =
      new UEventObserver() {
        @Override
        public void onUEvent(UEvent event) {
          scheduleUpdatePorts();
        }
      };

  /** Describes a USB port. */
  private static final class PortInfo {
    public static final int DISPOSITION_ADDED = 0;
    public static final int DISPOSITION_CHANGED = 1;
    public static final int DISPOSITION_READY = 2;
    public static final int DISPOSITION_REMOVED = 3;

    public final UsbPort mUsbPort;
    public UsbPortStatus mUsbPortStatus;
    public boolean mCanChangeMode;
    public boolean mCanChangePowerRole;
    public boolean mCanChangeDataRole;
    public int mDisposition; // default initialized to 0 which means added

    public PortInfo(String portId, int supportedModes) {
      mUsbPort = new UsbPort(portId, supportedModes);
    }

    public boolean setStatus(
        int currentMode,
        boolean canChangeMode,
        int currentPowerRole,
        boolean canChangePowerRole,
        int currentDataRole,
        boolean canChangeDataRole,
        int supportedRoleCombinations) {
      mCanChangeMode = canChangeMode;
      mCanChangePowerRole = canChangePowerRole;
      mCanChangeDataRole = canChangeDataRole;
      if (mUsbPortStatus == null
          || mUsbPortStatus.getCurrentMode() != currentMode
          || mUsbPortStatus.getCurrentPowerRole() != currentPowerRole
          || mUsbPortStatus.getCurrentDataRole() != currentDataRole
          || mUsbPortStatus.getSupportedRoleCombinations() != supportedRoleCombinations) {
        mUsbPortStatus =
            new UsbPortStatus(
                currentMode, currentPowerRole, currentDataRole, supportedRoleCombinations);
        return true;
      }
      return false;
    }

    @Override
    public String toString() {
      return "port="
          + mUsbPort
          + ", status="
          + mUsbPortStatus
          + ", canChangeMode="
          + mCanChangeMode
          + ", canChangePowerRole="
          + mCanChangePowerRole
          + ", canChangeDataRole="
          + mCanChangeDataRole;
    }
  }

  /**
   * Describes a simulated USB port. Roughly mirrors the information we would ordinarily get from
   * the kernel.
   */
  private static final class SimulatedPortInfo {
    public final String mPortId;
    public final int mSupportedModes;
    public int mCurrentMode;
    public boolean mCanChangeMode;
    public int mCurrentPowerRole;
    public boolean mCanChangePowerRole;
    public int mCurrentDataRole;
    public boolean mCanChangeDataRole;

    public SimulatedPortInfo(String portId, int supportedModes) {
      mPortId = portId;
      mSupportedModes = supportedModes;
    }
  }
}
 public UsbDebuggingManager(Context context) {
   mHandler = new UsbDebuggingHandler(FgThread.get().getLooper());
   mContext = context;
 }