content: /*
   * Copyright (C) 2018 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 and
   * limitations under the License.
   */
  
  package com.android.internal.usb;
  
  import static android.hardware.usb.UsbPortStatus.MODE_AUDIO_ACCESSORY;
  import static android.hardware.usb.UsbPortStatus.MODE_DEBUG_ACCESSORY;
  import static android.hardware.usb.UsbPortStatus.MODE_DFP;
  import static android.hardware.usb.UsbPortStatus.MODE_DUAL;
  import static android.hardware.usb.UsbPortStatus.MODE_NONE;
  import static android.hardware.usb.UsbPortStatus.MODE_UFP;
  
  import static com.android.internal.util.dump.DumpUtils.writeStringIfNotNull;
  
  import android.annotation.NonNull;
  import android.hardware.usb.UsbAccessory;
  import android.hardware.usb.UsbConfiguration;
  import android.hardware.usb.UsbDevice;
  import android.hardware.usb.UsbEndpoint;
  import android.hardware.usb.UsbInterface;
  import android.hardware.usb.UsbPort;
  import android.hardware.usb.UsbPortStatus;
  import android.hardware.usb.V1_0.Constants;
  import android.service.usb.UsbAccessoryProto;
  import android.service.usb.UsbConfigurationProto;
  import android.service.usb.UsbDeviceProto;
  import android.service.usb.UsbEndPointProto;
  import android.service.usb.UsbInterfaceProto;
  import android.service.usb.UsbPortProto;
  import android.service.usb.UsbPortStatusProto;
  import android.service.usb.UsbPortStatusRoleCombinationProto;
  
  import com.android.internal.util.dump.DualDumpOutputStream;
  
  /** Dump methods for public USB classes */
  public class DumpUtils {
      public static void writeAccessory(@NonNull DualDumpOutputStream dump, @NonNull String idName,
              long id, @NonNull UsbAccessory accessory) {
          long token = dump.start(idName, id);
  
          dump.write("manufacturer", UsbAccessoryProto.MANUFACTURER, accessory.getManufacturer());
          dump.write("model", UsbAccessoryProto.MODEL, accessory.getModel());
          writeStringIfNotNull(dump, "description", UsbAccessoryProto.DESCRIPTION,
                  accessory.getManufacturer());
          dump.write("version", UsbAccessoryProto.VERSION, accessory.getVersion());
          writeStringIfNotNull(dump, "uri", UsbAccessoryProto.URI, accessory.getUri());
          dump.write("serial", UsbAccessoryProto.SERIAL, accessory.getSerial());
  
          dump.end(token);
      }
  
      public static void writeDevice(@NonNull DualDumpOutputStream dump, @NonNull String idName,
              long id, @NonNull UsbDevice device) {
          long token = dump.start(idName, id);
  
          dump.write("name", UsbDeviceProto.NAME, device.getDeviceName());
          dump.write("vendor_id", UsbDeviceProto.VENDOR_ID, device.getVendorId());
          dump.write("product_id", UsbDeviceProto.PRODUCT_ID, device.getProductId());
          dump.write("class", UsbDeviceProto.CLASS, device.getDeviceClass());
          dump.write("subclass", UsbDeviceProto.SUBCLASS, device.getDeviceSubclass());
          dump.write("protocol", UsbDeviceProto.PROTOCOL, device.getDeviceProtocol());
          dump.write("manufacturer_name", UsbDeviceProto.MANUFACTURER_NAME,
                  device.getManufacturerName());
          dump.write("product_name", UsbDeviceProto.PRODUCT_NAME, device.getProductName());
          dump.write("version", UsbDeviceProto.VERSION, device.getVersion());
          dump.write("serial_number", UsbDeviceProto.SERIAL_NUMBER, device.getSerialNumber());
  
          int numConfigurations = device.getConfigurationCount();
          for (int i = 0; i < numConfigurations; i++) {
              writeConfiguration(dump, "configurations", UsbDeviceProto.CONFIGURATIONS,
                      device.getConfiguration(i));
          }
  
          dump.end(token);
      }
  
      private static void writeConfiguration(@NonNull DualDumpOutputStream dump,
              @NonNull String idName, long id, @NonNull UsbConfiguration configuration) {
          long token = dump.start(idName, id);
          dump.write("id", UsbConfigurationProto.ID, configuration.getId());
          dump.write("name", UsbConfigurationProto.NAME, configuration.getName());
          dump.write("attributes", UsbConfigurationProto.ATTRIBUTES, configuration.getAttributes());
          dump.write("max_power", UsbConfigurationProto.MAX_POWER, configuration.getMaxPower());
  
          int numInterfaces = configuration.getInterfaceCount();
          for (int i = 0; i < numInterfaces; i++) {
              writeInterface(dump, "interfaces", UsbConfigurationProto.INTERFACES,
                      configuration.getInterface(i));
          }
          dump.end(token);
      }
  
      private static void writeInterface(@NonNull DualDumpOutputStream dump, @NonNull String idName,
              long id, @NonNull UsbInterface iface) {
          long token = dump.start(idName, id);
  
          dump.write("id", UsbInterfaceProto.ID, iface.getId());
          dump.write("alternate_settings", UsbInterfaceProto.ALTERNATE_SETTINGS,
                  iface.getAlternateSetting());
          dump.write("name", UsbInterfaceProto.NAME, iface.getName());
          dump.write("class", UsbInterfaceProto.CLASS, iface.getInterfaceClass());
          dump.write("subclass", UsbInterfaceProto.SUBCLASS, iface.getInterfaceSubclass());
          dump.write("protocol", UsbInterfaceProto.PROTOCOL, iface.getInterfaceProtocol());
  
          int numEndpoints = iface.getEndpointCount();
          for (int i = 0; i < numEndpoints; i++) {
              writeEndpoint(dump, "endpoints", UsbInterfaceProto.ENDPOINTS, iface.getEndpoint(i));
          }
          dump.end(token);
      }
  
      private static void writeEndpoint(@NonNull DualDumpOutputStream dump, @NonNull String idName,
              long id, @NonNull UsbEndpoint endpoint) {
          long token = dump.start(idName, id);
  
          dump.write("endpoint_number", UsbEndPointProto.ENDPOINT_NUMBER,
                  endpoint.getEndpointNumber());
          dump.write("direction", UsbEndPointProto.DIRECTION, endpoint.getDirection());
          dump.write("address", UsbEndPointProto.ADDRESS, endpoint.getAddress());
          dump.write("type", UsbEndPointProto.TYPE, endpoint.getType());
          dump.write("attributes", UsbEndPointProto.ATTRIBUTES,
                  endpoint.getAttributes());
          dump.write("max_packet_size", UsbEndPointProto.MAX_PACKET_SIZE,
                  endpoint.getMaxPacketSize());
          dump.write("interval", UsbEndPointProto.INTERVAL, endpoint.getInterval());
  
          dump.end(token);
      }
  
      public static void writePort(@NonNull DualDumpOutputStream dump, @NonNull String idName,
              long id, @NonNull UsbPort port) {
          long token = dump.start(idName, id);
  
          dump.write("id", UsbPortProto.ID, port.getId());
  
          int mode = port.getSupportedModes();
          if (dump.isProto()) {
              if (mode == MODE_NONE) {
                  dump.write("supported_modes", UsbPortProto.SUPPORTED_MODES, MODE_NONE);
              } else {
                  if ((mode & MODE_DUAL) == MODE_DUAL) {
                      dump.write("supported_modes", UsbPortProto.SUPPORTED_MODES, MODE_DUAL);
                  } else {
                      if ((mode & MODE_DFP) == MODE_DFP) {
                          dump.write("supported_modes", UsbPortProto.SUPPORTED_MODES, MODE_DFP);
                      } else if ((mode & MODE_UFP) == MODE_UFP) {
                          dump.write("supported_modes", UsbPortProto.SUPPORTED_MODES, MODE_UFP);
                      }
                  }
  
                  if ((mode & MODE_AUDIO_ACCESSORY) == MODE_AUDIO_ACCESSORY) {
                      dump.write("supported_modes", UsbPortProto.SUPPORTED_MODES,
                              MODE_AUDIO_ACCESSORY);
                  }
  
                  if ((mode & MODE_DEBUG_ACCESSORY) == MODE_DEBUG_ACCESSORY) {
                      dump.write("supported_modes", UsbPortProto.SUPPORTED_MODES,
                              MODE_DEBUG_ACCESSORY);
                  }
              }
          } else {
              dump.write("supported_modes", UsbPortProto.SUPPORTED_MODES, UsbPort.modeToString(mode));
          }
  
          dump.end(token);
      }
  
      private static void writePowerRole(@NonNull DualDumpOutputStream dump, @NonNull String idName,
              long id, int powerRole) {
          if (dump.isProto()) {
              dump.write(idName, id, powerRole);
          } else {
              dump.write(idName, id, UsbPort.powerRoleToString(powerRole));
          }
      }
  
      private static void writeDataRole(@NonNull DualDumpOutputStream dump, @NonNull String idName,
              long id, int dataRole) {
          if (dump.isProto()) {
              dump.write(idName, id, dataRole);
          } else {
              dump.write(idName, id, UsbPort.dataRoleToString(dataRole));
          }
      }
  
      private static void writeContaminantPresenceStatus(@NonNull DualDumpOutputStream dump,
              @NonNull String idName, long id, int contaminantPresenceStatus) {
          if (dump.isProto()) {
              dump.write(idName, id, contaminantPresenceStatus);
          } else {
              dump.write(idName, id,
                      UsbPort.contaminantPresenceStatusToString(contaminantPresenceStatus));
          }
      }
  
      public static void writePortStatus(@NonNull DualDumpOutputStream dump, @NonNull String idName,
              long id, @NonNull UsbPortStatus status) {
          long token = dump.start(idName, id);
  
          dump.write("connected", UsbPortStatusProto.CONNECTED, status.isConnected());
  
          if (dump.isProto()) {
              dump.write("current_mode", UsbPortStatusProto.CURRENT_MODE, status.getCurrentMode());
          } else {
              dump.write("current_mode", UsbPortStatusProto.CURRENT_MODE,
                      UsbPort.modeToString(status.getCurrentMode()));
          }
  
          writePowerRole(dump, "power_role", UsbPortStatusProto.POWER_ROLE,
                  status.getCurrentPowerRole());
          writeDataRole(dump, "data_role", UsbPortStatusProto.DATA_ROLE, status.getCurrentDataRole());
  
          int undumpedCombinations = status.getSupportedRoleCombinations();
          while (undumpedCombinations != 0) {
              int index = Integer.numberOfTrailingZeros(undumpedCombinations);
              undumpedCombinations &= ~(1 << index);
  
              int powerRole = (index / Constants.PortDataRole.NUM_DATA_ROLES
                      + Constants.PortPowerRole.NONE);
              int dataRole = index % Constants.PortDataRole.NUM_DATA_ROLES;
  
              long roleCombinationToken = dump.start("role_combinations",
                      UsbPortStatusProto.ROLE_COMBINATIONS);
              writePowerRole(dump, "power_role", UsbPortStatusRoleCombinationProto.POWER_ROLE,
                      powerRole);
              writeDataRole(dump, "data_role", UsbPortStatusRoleCombinationProto.DATA_ROLE,
                      dataRole);
              dump.end(roleCombinationToken);
          }
  
          writeContaminantPresenceStatus(dump, "contaminant_presence_status",
                  UsbPortStatusProto.CONTAMINANT_PRESENCE_STATUS,
                  status.getContaminantDetectionStatus());
  
          dump.end(token);
      }
  }
  