| /* |
| * Copyright (C) 2015 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 android.hardware.usb; |
| |
| import android.annotation.CheckResult; |
| import android.annotation.FlaggedApi; |
| import android.annotation.IntDef; |
| import android.annotation.NonNull; |
| import android.annotation.Nullable; |
| import android.annotation.SystemApi; |
| import android.hardware.usb.flags.Flags; |
| import android.os.Parcel; |
| import android.os.Parcelable; |
| |
| import com.android.internal.annotations.Immutable; |
| |
| import java.lang.annotation.Retention; |
| import java.lang.annotation.RetentionPolicy; |
| |
| /** |
| * Describes the status of a USB port. |
| * |
| * @hide |
| */ |
| @Immutable |
| @SystemApi |
| public final class UsbPortStatus implements Parcelable { |
| private static final String TAG = "UsbPortStatus"; |
| private final int mCurrentMode; |
| private final @UsbPowerRole int mCurrentPowerRole; |
| private final @UsbDataRole int mCurrentDataRole; |
| private final int mSupportedRoleCombinations; |
| private final @ContaminantProtectionStatus int mContaminantProtectionStatus; |
| private final @ContaminantDetectionStatus int mContaminantDetectionStatus; |
| private final boolean mPowerTransferLimited; |
| private final @UsbDataStatus int mUsbDataStatus; |
| private final @PowerBrickConnectionStatus int mPowerBrickConnectionStatus; |
| private final @NonNull @ComplianceWarning int[] mComplianceWarnings; |
| private final @PlugState int mPlugState; |
| /** |
| * Holds the DisplayPort Alt Mode info for the Port. This field |
| * is null if the device does not support DisplayPort Alt Mode. |
| */ |
| private final @Nullable DisplayPortAltModeInfo mDisplayPortAltModeInfo; |
| |
| |
| /** |
| * Power role: This USB port does not have a power role. |
| */ |
| public static final int POWER_ROLE_NONE = 0; |
| |
| /** |
| * Power role: This USB port can act as a source (provide power). |
| */ |
| public static final int POWER_ROLE_SOURCE = 1; |
| |
| /** |
| * Power role: This USB port can act as a sink (receive power). |
| */ |
| public static final int POWER_ROLE_SINK = 2; |
| |
| @IntDef(prefix = { "POWER_ROLE_" }, value = { |
| POWER_ROLE_NONE, |
| POWER_ROLE_SOURCE, |
| POWER_ROLE_SINK |
| }) |
| @Retention(RetentionPolicy.SOURCE) |
| @interface UsbPowerRole{} |
| |
| /** |
| * Power role: This USB port does not have a data role. |
| */ |
| public static final int DATA_ROLE_NONE = 0; |
| |
| /** |
| * Data role: This USB port can act as a host (access data services). |
| */ |
| public static final int DATA_ROLE_HOST = 1; |
| |
| /** |
| * Data role: This USB port can act as a device (offer data services). |
| */ |
| public static final int DATA_ROLE_DEVICE = 2; |
| |
| @IntDef(prefix = { "DATA_ROLE_" }, value = { |
| DATA_ROLE_NONE, |
| DATA_ROLE_HOST, |
| DATA_ROLE_DEVICE |
| }) |
| @Retention(RetentionPolicy.SOURCE) |
| @interface UsbDataRole{} |
| |
| /** |
| * There is currently nothing connected to this USB port. |
| */ |
| public static final int MODE_NONE = 0; |
| |
| /** |
| * This USB port can act as an upstream facing port (device). |
| * |
| * <p> Implies that the port supports the {@link #POWER_ROLE_SINK} and |
| * {@link #DATA_ROLE_DEVICE} combination of roles (and possibly others as well). |
| */ |
| public static final int MODE_UFP = 1 << 0; |
| |
| /** |
| * This USB port can act as a downstream facing port (host). |
| * |
| * <p> Implies that the port supports the {@link #POWER_ROLE_SOURCE} and |
| * {@link #DATA_ROLE_HOST} combination of roles (and possibly others as well). |
| */ |
| public static final int MODE_DFP = 1 << 1; |
| |
| /** |
| * This USB port can act either as an downstream facing port (host) or as |
| * an upstream facing port (device). |
| * |
| * <p> Implies that the port supports the {@link #POWER_ROLE_SOURCE} and |
| * {@link #DATA_ROLE_HOST} combination of roles and the {@link #POWER_ROLE_SINK} and |
| * {@link #DATA_ROLE_DEVICE} combination of roles (and possibly others as well). |
| * |
| * @hide |
| */ |
| public static final int MODE_DUAL = MODE_UFP | MODE_DFP; |
| |
| /** |
| * This USB port can support USB Type-C Audio accessory. |
| */ |
| public static final int MODE_AUDIO_ACCESSORY = 1 << 2; |
| |
| /** |
| * This USB port can support USB Type-C debug accessory. |
| */ |
| public static final int MODE_DEBUG_ACCESSORY = 1 << 3; |
| |
| /** |
| * Contaminant presence detection not supported by the device. |
| * @hide |
| */ |
| public static final int CONTAMINANT_DETECTION_NOT_SUPPORTED = 0; |
| |
| /** |
| * Contaminant presence detection supported but disabled. |
| * @hide |
| */ |
| public static final int CONTAMINANT_DETECTION_DISABLED = 1; |
| |
| /** |
| * Contaminant presence enabled but not detected. |
| * @hide |
| */ |
| public static final int CONTAMINANT_DETECTION_NOT_DETECTED = 2; |
| |
| /** |
| * Contaminant presence enabled and detected. |
| * @hide |
| */ |
| public static final int CONTAMINANT_DETECTION_DETECTED = 3; |
| |
| /** |
| * Contaminant protection - No action performed upon detection of |
| * contaminant presence. |
| * @hide |
| */ |
| public static final int CONTAMINANT_PROTECTION_NONE = 0; |
| |
| /** |
| * Contaminant protection - Port is forced to sink upon detection of |
| * contaminant presence. |
| * @hide |
| */ |
| public static final int CONTAMINANT_PROTECTION_SINK = 1 << 0; |
| |
| /** |
| * Contaminant protection - Port is forced to source upon detection of |
| * contaminant presence. |
| * @hide |
| */ |
| public static final int CONTAMINANT_PROTECTION_SOURCE = 1 << 1; |
| |
| /** |
| * Contaminant protection - Port is disabled upon detection of |
| * contaminant presence. |
| * @hide |
| */ |
| public static final int CONTAMINANT_PROTECTION_FORCE_DISABLE = 1 << 2; |
| |
| /** |
| * Contaminant protection - Port is disabled upon detection of |
| * contaminant presence. |
| * @hide |
| */ |
| public static final int CONTAMINANT_PROTECTION_DISABLED = 1 << 3; |
| |
| /** |
| * USB data status is not known. |
| */ |
| public static final int DATA_STATUS_UNKNOWN = 0; |
| |
| /** |
| * USB data is enabled. |
| */ |
| public static final int DATA_STATUS_ENABLED = 1 << 0; |
| |
| /** |
| * USB data is disabled as the port is too hot. |
| */ |
| public static final int DATA_STATUS_DISABLED_OVERHEAT = 1 << 1; |
| |
| /** |
| * USB data is disabled due to contaminated port. |
| */ |
| public static final int DATA_STATUS_DISABLED_CONTAMINANT = 1 << 2; |
| |
| /** |
| * This flag indicates that some or all data modes are disabled |
| * due to docking event, and the specific sub-statuses viz., |
| * {@link #DATA_STATUS_DISABLED_DOCK_HOST_MODE}, |
| * {@link #DATA_STATUS_DISABLED_DOCK_DEVICE_MODE} |
| * can be checked for individual modes. |
| */ |
| public static final int DATA_STATUS_DISABLED_DOCK = 1 << 3; |
| |
| /** |
| * USB data is disabled by |
| * {@link UsbPort#enableUsbData UsbPort.enableUsbData}. |
| */ |
| public static final int DATA_STATUS_DISABLED_FORCE = 1 << 4; |
| |
| /** |
| * USB data is disabled for debug. |
| */ |
| public static final int DATA_STATUS_DISABLED_DEBUG = 1 << 5; |
| |
| /** |
| * USB host mode is disabled due to docking event. |
| * {@link #DATA_STATUS_DISABLED_DOCK} will be set as well. |
| */ |
| public static final int DATA_STATUS_DISABLED_DOCK_HOST_MODE = 1 << 6; |
| |
| /** |
| * USB device mode is disabled due to docking event. |
| * {@link #DATA_STATUS_DISABLED_DOCK} will be set as well. |
| */ |
| public static final int DATA_STATUS_DISABLED_DOCK_DEVICE_MODE = 1 << 7; |
| |
| /** |
| * Unknown whether a power brick is connected. |
| */ |
| public static final int POWER_BRICK_STATUS_UNKNOWN = 0; |
| |
| /** |
| * The connected device is a power brick. |
| */ |
| public static final int POWER_BRICK_STATUS_CONNECTED = 1; |
| |
| /** |
| * The connected device is not power brick. |
| */ |
| public static final int POWER_BRICK_STATUS_DISCONNECTED = 2; |
| |
| /** |
| * Used to indicate attached sources/cables/accessories/ports |
| * that do not match the other warnings below and do not meet the |
| * requirements of specifications including but not limited to |
| * USB Type-C Cable and Connector, Universal Serial Bus |
| * Power Delivery, and Universal Serial Bus 1.x/2.0/3.x/4.0. |
| * In addition, constants introduced after the target sdk will be |
| * remapped into COMPLIANCE_WARNING_OTHER. |
| */ |
| public static final int COMPLIANCE_WARNING_OTHER = 1; |
| |
| /** |
| * Used to indicate Type-C port partner |
| * (cable/accessory/source) that identifies itself as debug |
| * accessory source as defined in USB Type-C Cable and |
| * Connector Specification. However, the specification states |
| * that this is meant for debug only and shall not be used for |
| * with commercial products. |
| */ |
| public static final int COMPLIANCE_WARNING_DEBUG_ACCESSORY = 2; |
| |
| /** |
| * Used to indicate USB ports that does not |
| * identify itself as one of the charging port types (SDP/CDP |
| * DCP etc) as defined by Battery Charging v1.2 Specification. |
| */ |
| public static final int COMPLIANCE_WARNING_BC_1_2 = 3; |
| |
| /** |
| * Used to indicate Type-C sources/cables that are missing pull |
| * up resistors on the CC pins as required by USB Type-C Cable |
| * and Connector Specification. |
| */ |
| public static final int COMPLIANCE_WARNING_MISSING_RP = 4; |
| |
| /** |
| * Used to indicate the charging setups on the USB ports are unable to |
| * deliver negotiated power. Introduced in Android V (API level 35) |
| * and client applicantions that target API levels lower than 35 will |
| * receive {@link #COMPLIANCE_WARNING_OTHER} instead. |
| */ |
| @FlaggedApi(Flags.FLAG_ENABLE_USB_DATA_COMPLIANCE_WARNING) |
| public static final int COMPLIANCE_WARNING_INPUT_POWER_LIMITED = 5; |
| |
| /** |
| * Used to indicate the cable/connector on the USB ports are missing |
| * the required wires on the data pins to make data transfer. |
| * Introduced in Android V (API level 35) and client applicantions that |
| * target API levels lower than 35 will receive |
| * {@link #COMPLIANCE_WARNING_OTHER} instead. |
| */ |
| @FlaggedApi(Flags.FLAG_ENABLE_USB_DATA_COMPLIANCE_WARNING) |
| public static final int COMPLIANCE_WARNING_MISSING_DATA_LINES = 6; |
| |
| /** |
| * Used to indicate enumeration failures on the USB ports, potentially due to |
| * signal integrity issues or other causes. Introduced in Android V |
| * (API level 35) and client applicantions that target API levels lower |
| * than 35 will receive {@link #COMPLIANCE_WARNING_OTHER} instead. |
| */ |
| @FlaggedApi(Flags.FLAG_ENABLE_USB_DATA_COMPLIANCE_WARNING) |
| public static final int COMPLIANCE_WARNING_ENUMERATION_FAIL = 7; |
| |
| /** |
| * Used to indicate unexpected data disconnection on the USB ports, |
| * potentially due to signal integrity issues or other causes. |
| * Introduced in Android V (API level 35) and client applicantions that |
| * target API levels lower than 35 will receive |
| * {@link #COMPLIANCE_WARNING_OTHER} instead. |
| */ |
| @FlaggedApi(Flags.FLAG_ENABLE_USB_DATA_COMPLIANCE_WARNING) |
| public static final int COMPLIANCE_WARNING_FLAKY_CONNECTION = 8; |
| |
| /** |
| * Used to indicate unreliable or slow data transfer on the USB ports, |
| * potentially due to signal integrity issues or other causes. |
| * Introduced in Android V (API level 35) and client applicantions that |
| * target API levels lower than 35 will receive |
| * {@link #COMPLIANCE_WARNING_OTHER} instead. |
| */ |
| @FlaggedApi(Flags.FLAG_ENABLE_USB_DATA_COMPLIANCE_WARNING) |
| public static final int COMPLIANCE_WARNING_UNRELIABLE_IO = 9; |
| |
| /** |
| * Indicates that the Type-C plug orientation cannot be |
| * determined because the connected state of the device is unknown. |
| */ |
| public static final int PLUG_STATE_UNKNOWN = 0; |
| |
| /** |
| * Indicates no Type-C plug is inserted into the device. |
| */ |
| public static final int PLUG_STATE_UNPLUGGED = 1; |
| |
| /** |
| * Indicates a Type-C plug is inserted into the device, but |
| * the orientation cannot be determined. |
| */ |
| public static final int PLUG_STATE_PLUGGED_ORIENTATION_UNKNOWN = 2; |
| |
| /** |
| * Indicates that the connected plug uses its CC1 |
| * pin to manage the Source-to-Sink connection. |
| */ |
| public static final int PLUG_STATE_PLUGGED_ORIENTATION_NORMAL = 3; |
| |
| /** |
| * Indicates that the connected plug uses its CC2 |
| * pin to manage the Source-to-Sink connection. |
| */ |
| public static final int PLUG_STATE_PLUGGED_ORIENTATION_FLIPPED = 4; |
| |
| @IntDef(prefix = { "CONTAMINANT_DETECTION_" }, value = { |
| CONTAMINANT_DETECTION_NOT_SUPPORTED, |
| CONTAMINANT_DETECTION_DISABLED, |
| CONTAMINANT_DETECTION_NOT_DETECTED, |
| CONTAMINANT_DETECTION_DETECTED, |
| }) |
| @Retention(RetentionPolicy.SOURCE) |
| @interface ContaminantDetectionStatus{} |
| |
| @IntDef(prefix = { "CONTAMINANT_PROTECTION_" }, flag = true, value = { |
| CONTAMINANT_PROTECTION_NONE, |
| CONTAMINANT_PROTECTION_SINK, |
| CONTAMINANT_PROTECTION_SOURCE, |
| CONTAMINANT_PROTECTION_FORCE_DISABLE, |
| CONTAMINANT_PROTECTION_DISABLED, |
| }) |
| @Retention(RetentionPolicy.SOURCE) |
| @interface ContaminantProtectionStatus{} |
| |
| @IntDef(prefix = { "MODE_" }, value = { |
| MODE_NONE, |
| MODE_DFP, |
| MODE_UFP, |
| MODE_AUDIO_ACCESSORY, |
| MODE_DEBUG_ACCESSORY, |
| }) |
| @Retention(RetentionPolicy.SOURCE) |
| @interface UsbPortMode{} |
| |
| @IntDef(prefix = { "COMPLIANCE_WARNING_" }, value = { |
| COMPLIANCE_WARNING_OTHER, |
| COMPLIANCE_WARNING_DEBUG_ACCESSORY, |
| COMPLIANCE_WARNING_BC_1_2, |
| COMPLIANCE_WARNING_MISSING_RP, |
| COMPLIANCE_WARNING_INPUT_POWER_LIMITED, |
| COMPLIANCE_WARNING_MISSING_DATA_LINES, |
| COMPLIANCE_WARNING_ENUMERATION_FAIL, |
| COMPLIANCE_WARNING_FLAKY_CONNECTION, |
| COMPLIANCE_WARNING_UNRELIABLE_IO, |
| }) |
| @Retention(RetentionPolicy.SOURCE) |
| @interface ComplianceWarning{} |
| |
| @IntDef(prefix = { "PLUG_STATE_" }, value = { |
| PLUG_STATE_UNKNOWN, |
| PLUG_STATE_UNPLUGGED, |
| PLUG_STATE_PLUGGED_ORIENTATION_UNKNOWN, |
| PLUG_STATE_PLUGGED_ORIENTATION_NORMAL, |
| PLUG_STATE_PLUGGED_ORIENTATION_FLIPPED, |
| }) |
| @Retention(RetentionPolicy.SOURCE) |
| @interface PlugState{} |
| |
| /** @hide */ |
| @IntDef(prefix = { "DATA_STATUS_" }, flag = true, value = { |
| DATA_STATUS_UNKNOWN, |
| DATA_STATUS_ENABLED, |
| DATA_STATUS_DISABLED_OVERHEAT, |
| DATA_STATUS_DISABLED_CONTAMINANT, |
| DATA_STATUS_DISABLED_DOCK, |
| DATA_STATUS_DISABLED_DOCK_HOST_MODE, |
| DATA_STATUS_DISABLED_DOCK_DEVICE_MODE, |
| DATA_STATUS_DISABLED_FORCE, |
| DATA_STATUS_DISABLED_DEBUG, |
| }) |
| @Retention(RetentionPolicy.SOURCE) |
| @interface UsbDataStatus{} |
| |
| /** @hide */ |
| @IntDef(prefix = { "POWER_BRICK_STATUS_" }, value = { |
| POWER_BRICK_STATUS_UNKNOWN, |
| POWER_BRICK_STATUS_DISCONNECTED, |
| POWER_BRICK_STATUS_CONNECTED, |
| }) |
| @Retention(RetentionPolicy.SOURCE) |
| @interface PowerBrickConnectionStatus{} |
| |
| /** @hide */ |
| public UsbPortStatus(int currentMode, int currentPowerRole, int currentDataRole, |
| int supportedRoleCombinations, int contaminantProtectionStatus, |
| int contaminantDetectionStatus, @UsbDataStatus int usbDataStatus, |
| boolean powerTransferLimited, |
| @PowerBrickConnectionStatus int powerBrickConnectionStatus, |
| @NonNull @ComplianceWarning int[] complianceWarnings, |
| int plugState, |
| @Nullable DisplayPortAltModeInfo displayPortAltModeInfo) { |
| mCurrentMode = currentMode; |
| mCurrentPowerRole = currentPowerRole; |
| mCurrentDataRole = currentDataRole; |
| mSupportedRoleCombinations = supportedRoleCombinations; |
| mContaminantProtectionStatus = contaminantProtectionStatus; |
| mContaminantDetectionStatus = contaminantDetectionStatus; |
| |
| // Older implementations that only set the DISABLED_DOCK_MODE will have the other two |
| // set at the HAL interface level, so the "dock mode only" state shouldn't be visible here. |
| // But the semantics are ensured here. |
| int disabledDockModes = (usbDataStatus & |
| (DATA_STATUS_DISABLED_DOCK_HOST_MODE | DATA_STATUS_DISABLED_DOCK_DEVICE_MODE)); |
| if (disabledDockModes != 0) { |
| // Set DATA_STATUS_DISABLED_DOCK when one of DATA_STATUS_DISABLED_DOCK_*_MODE is set |
| usbDataStatus |= DATA_STATUS_DISABLED_DOCK; |
| } else { |
| // Clear DATA_STATUS_DISABLED_DOCK when none of DATA_STATUS_DISABLED_DOCK_*_MODE is set |
| usbDataStatus &= ~DATA_STATUS_DISABLED_DOCK; |
| } |
| |
| mUsbDataStatus = usbDataStatus; |
| mPowerTransferLimited = powerTransferLimited; |
| mPowerBrickConnectionStatus = powerBrickConnectionStatus; |
| mComplianceWarnings = complianceWarnings; |
| mPlugState = plugState; |
| mDisplayPortAltModeInfo = displayPortAltModeInfo; |
| } |
| |
| /** @hide */ |
| public UsbPortStatus(int currentMode, int currentPowerRole, int currentDataRole, |
| int supportedRoleCombinations, int contaminantProtectionStatus, |
| int contaminantDetectionStatus, @UsbDataStatus int usbDataStatus, |
| boolean powerTransferLimited, |
| @PowerBrickConnectionStatus int powerBrickConnectionStatus) { |
| this(currentMode, currentPowerRole, currentDataRole, supportedRoleCombinations, |
| contaminantProtectionStatus, contaminantDetectionStatus, |
| usbDataStatus, powerTransferLimited, powerBrickConnectionStatus, |
| new int[] {}, PLUG_STATE_UNKNOWN, null); |
| } |
| |
| /** @hide */ |
| public UsbPortStatus(int currentMode, int currentPowerRole, int currentDataRole, |
| int supportedRoleCombinations, int contaminantProtectionStatus, |
| int contaminantDetectionStatus) { |
| this(currentMode, currentPowerRole, currentDataRole, supportedRoleCombinations, |
| contaminantProtectionStatus, contaminantDetectionStatus, |
| DATA_STATUS_UNKNOWN, false, POWER_BRICK_STATUS_UNKNOWN, |
| new int[] {}, PLUG_STATE_UNKNOWN, null); |
| } |
| |
| /** |
| * Returns true if there is anything connected to the port. |
| * |
| * @return {@code true} iff there is anything connected to the port. |
| */ |
| public boolean isConnected() { |
| return mCurrentMode != 0; |
| } |
| |
| /** |
| * Gets the current mode of the port. |
| * |
| * @return The current mode: {@link #MODE_DFP}, {@link #MODE_UFP}, |
| * {@link #MODE_AUDIO_ACCESSORY}, {@link #MODE_DEBUG_ACCESSORY}, or {@link {@link #MODE_NONE} if |
| * nothing is connected. |
| */ |
| public @UsbPortMode int getCurrentMode() { |
| return mCurrentMode; |
| } |
| |
| /** |
| * Gets the current power role of the port. |
| * |
| * @return The current power role: {@link #POWER_ROLE_SOURCE}, {@link #POWER_ROLE_SINK}, or |
| * {@link #POWER_ROLE_NONE} if nothing is connected. |
| */ |
| public @UsbPowerRole int getCurrentPowerRole() { |
| return mCurrentPowerRole; |
| } |
| |
| /** |
| * Gets the current data role of the port. |
| * |
| * @return The current data role: {@link #DATA_ROLE_HOST}, {@link #DATA_ROLE_DEVICE}, or |
| * {@link #DATA_ROLE_NONE} if nothing is connected. |
| */ |
| public @UsbDataRole int getCurrentDataRole() { |
| return mCurrentDataRole; |
| } |
| |
| /** |
| * Returns true if the specified power and data role combination is supported |
| * given what is currently connected to the port. |
| * |
| * @param powerRole The power role to check: {@link #POWER_ROLE_SOURCE} or |
| * {@link #POWER_ROLE_SINK}, or {@link #POWER_ROLE_NONE} if no power role. |
| * @param dataRole The data role to check: either {@link #DATA_ROLE_HOST} or |
| * {@link #DATA_ROLE_DEVICE}, or {@link #DATA_ROLE_NONE} if no data role. |
| */ |
| public boolean isRoleCombinationSupported(@UsbPowerRole int powerRole, |
| @UsbDataRole int dataRole) { |
| return (mSupportedRoleCombinations & |
| UsbPort.combineRolesAsBit(powerRole, dataRole)) != 0; |
| } |
| |
| /** |
| * This function checks if the port is USB Power Delivery (PD) compliant - |
| * https://www.usb.org/usb-charger-pd. All of the power and data roles must be supported for a |
| * port to be PD compliant. |
| * |
| * @return true if the port is PD compliant. |
| */ |
| @FlaggedApi(Flags.FLAG_ENABLE_IS_PD_COMPLIANT_API) |
| public boolean isPdCompliant() { |
| return isRoleCombinationSupported(POWER_ROLE_SINK, DATA_ROLE_DEVICE) |
| && isRoleCombinationSupported(POWER_ROLE_SINK, DATA_ROLE_HOST) |
| && isRoleCombinationSupported(POWER_ROLE_SOURCE, DATA_ROLE_DEVICE) |
| && isRoleCombinationSupported(POWER_ROLE_SOURCE, DATA_ROLE_HOST); |
| } |
| |
| /** |
| * Get the supported role combinations. |
| */ |
| public int getSupportedRoleCombinations() { |
| return mSupportedRoleCombinations; |
| } |
| |
| /** |
| * Returns contaminant detection status. |
| * |
| * @hide |
| */ |
| public @ContaminantDetectionStatus int getContaminantDetectionStatus() { |
| return mContaminantDetectionStatus; |
| } |
| |
| /** |
| * Returns contamiant protection status. |
| * |
| * @hide |
| */ |
| public @ContaminantProtectionStatus int getContaminantProtectionStatus() { |
| return mContaminantProtectionStatus; |
| } |
| |
| /** |
| * Returns UsbData status. |
| * |
| * @return Current USB data status of the port with one or more of the following values |
| * {@link #DATA_STATUS_UNKNOWN}, {@link #DATA_STATUS_ENABLED}, |
| * {@link #DATA_STATUS_DISABLED_OVERHEAT}, {@link #DATA_STATUS_DISABLED_CONTAMINANT}, |
| * {@link #DATA_STATUS_DISABLED_DOCK}, {@link #DATA_STATUS_DISABLED_FORCE}, |
| * {@link #DATA_STATUS_DISABLED_DEBUG}, {@link #DATA_STATUS_DISABLED_DOCK_HOST_MODE}, |
| * {@link #DATA_STATUS_DISABLED_DOCK_DEVICE_MODE} |
| */ |
| public @UsbDataStatus int getUsbDataStatus() { |
| return mUsbDataStatus; |
| } |
| |
| /** |
| * Returns whether power transfer is limited. |
| * |
| * @return true when power transfer is limited. |
| * false otherwise. |
| */ |
| public boolean isPowerTransferLimited() { |
| return mPowerTransferLimited; |
| } |
| |
| /** |
| * Returns the connection status of the power brick. |
| * |
| * @return {@link #POWER_BRICK_STATUS_UNKNOWN} |
| * or {@link #POWER_BRICK_STATUS_CONNECTED} |
| * or {@link #POWER_BRICK_STATUS_DISCONNECTED} |
| */ |
| public @PowerBrickConnectionStatus int getPowerBrickConnectionStatus() { |
| return mPowerBrickConnectionStatus; |
| } |
| |
| /** |
| * Returns non compliant reasons, if any, for the connected |
| * charger/cable/accessory/USB port. |
| * |
| * @return array including {@link #COMPLIANCE_WARNING_OTHER}, |
| * {@link #COMPLIANCE_WARNING_DEBUG_ACCESSORY}, |
| * {@link #COMPLIANCE_WARNING_BC_1_2}, |
| * {@link #COMPLIANCE_WARNING_MISSING_RP}. |
| */ |
| @CheckResult |
| @NonNull |
| public @ComplianceWarning int[] getComplianceWarnings() { |
| return mComplianceWarnings; |
| } |
| |
| /** |
| * Returns the plug state of the attached cable/adapter. |
| * |
| */ |
| public @PlugState int getPlugState() { |
| return mPlugState; |
| } |
| |
| /** |
| * Returns the DisplayPortInfo of the USB Port, if applicable. |
| * |
| * @return an instance of type DisplayPortInfo |
| * or null if not applicable. |
| */ |
| @Nullable |
| public DisplayPortAltModeInfo getDisplayPortAltModeInfo() { |
| return (mDisplayPortAltModeInfo == null) ? null : mDisplayPortAltModeInfo; |
| } |
| |
| @NonNull |
| @Override |
| public String toString() { |
| StringBuilder mString = new StringBuilder("UsbPortStatus{connected=" + isConnected() |
| + ", currentMode=" + UsbPort.modeToString(mCurrentMode) |
| + ", currentPowerRole=" + UsbPort.powerRoleToString(mCurrentPowerRole) |
| + ", currentDataRole=" + UsbPort.dataRoleToString(mCurrentDataRole) |
| + ", supportedRoleCombinations=" |
| + UsbPort.roleCombinationsToString(mSupportedRoleCombinations) |
| + ", contaminantDetectionStatus=" |
| + getContaminantDetectionStatus() |
| + ", contaminantProtectionStatus=" |
| + getContaminantProtectionStatus() |
| + ", usbDataStatus=" |
| + UsbPort.usbDataStatusToString(getUsbDataStatus()) |
| + ", isPowerTransferLimited=" |
| + isPowerTransferLimited() |
| + ", powerBrickConnectionStatus=" |
| + UsbPort |
| .powerBrickConnectionStatusToString(getPowerBrickConnectionStatus()) |
| + ", complianceWarnings=" |
| + UsbPort.complianceWarningsToString(getComplianceWarnings()) |
| + ", plugState=" |
| + getPlugState() |
| + ", displayPortAltModeInfo=" |
| + mDisplayPortAltModeInfo |
| + "}"); |
| return mString.toString(); |
| } |
| |
| @Override |
| public int describeContents() { |
| return 0; |
| } |
| |
| @Override |
| public void writeToParcel(Parcel dest, int flags) { |
| dest.writeInt(mCurrentMode); |
| dest.writeInt(mCurrentPowerRole); |
| dest.writeInt(mCurrentDataRole); |
| dest.writeInt(mSupportedRoleCombinations); |
| dest.writeInt(mContaminantProtectionStatus); |
| dest.writeInt(mContaminantDetectionStatus); |
| dest.writeInt(mUsbDataStatus); |
| dest.writeBoolean(mPowerTransferLimited); |
| dest.writeInt(mPowerBrickConnectionStatus); |
| dest.writeIntArray(mComplianceWarnings); |
| dest.writeInt(mPlugState); |
| if (mDisplayPortAltModeInfo == null) { |
| dest.writeBoolean(false); |
| } else { |
| dest.writeBoolean(true); |
| mDisplayPortAltModeInfo.writeToParcel(dest, 0); |
| } |
| } |
| |
| public static final @NonNull Parcelable.Creator<UsbPortStatus> CREATOR = |
| new Parcelable.Creator<UsbPortStatus>() { |
| @Override |
| public UsbPortStatus createFromParcel(Parcel in) { |
| int currentMode = in.readInt(); |
| int currentPowerRole = in.readInt(); |
| int currentDataRole = in.readInt(); |
| int supportedRoleCombinations = in.readInt(); |
| int contaminantProtectionStatus = in.readInt(); |
| int contaminantDetectionStatus = in.readInt(); |
| int usbDataStatus = in.readInt(); |
| boolean powerTransferLimited = in.readBoolean(); |
| int powerBrickConnectionStatus = in.readInt(); |
| @ComplianceWarning int[] complianceWarnings = in.createIntArray(); |
| int plugState = in.readInt(); |
| boolean supportsDisplayPortAltMode = in.readBoolean(); |
| DisplayPortAltModeInfo displayPortAltModeInfo; |
| if (supportsDisplayPortAltMode) { |
| displayPortAltModeInfo = DisplayPortAltModeInfo.CREATOR.createFromParcel(in); |
| } else { |
| displayPortAltModeInfo = null; |
| } |
| return new UsbPortStatus(currentMode, currentPowerRole, currentDataRole, |
| supportedRoleCombinations, contaminantProtectionStatus, |
| contaminantDetectionStatus, usbDataStatus, powerTransferLimited, |
| powerBrickConnectionStatus, |
| complianceWarnings, plugState, displayPortAltModeInfo); |
| } |
| |
| @Override |
| public UsbPortStatus[] newArray(int size) { |
| return new UsbPortStatus[size]; |
| } |
| }; |
| |
| /** |
| * Builder is used to create {@link UsbPortStatus} objects. |
| * |
| * @hide |
| */ |
| public static final class Builder { |
| private @UsbPortMode int mCurrentMode; |
| private @UsbPowerRole int mCurrentPowerRole; |
| private @UsbDataRole int mCurrentDataRole; |
| private int mSupportedRoleCombinations; |
| private @ContaminantProtectionStatus int mContaminantProtectionStatus; |
| private @ContaminantDetectionStatus int mContaminantDetectionStatus; |
| private boolean mPowerTransferLimited; |
| private @UsbDataStatus int mUsbDataStatus; |
| private @PowerBrickConnectionStatus int mPowerBrickConnectionStatus; |
| private @ComplianceWarning int[] mComplianceWarnings; |
| private @PlugState int mPlugState; |
| private @Nullable DisplayPortAltModeInfo mDisplayPortAltModeInfo; |
| |
| public Builder() { |
| mCurrentMode = MODE_NONE; |
| mCurrentPowerRole = POWER_ROLE_NONE; |
| mCurrentDataRole = DATA_ROLE_NONE; |
| mContaminantProtectionStatus = CONTAMINANT_PROTECTION_NONE; |
| mContaminantDetectionStatus = CONTAMINANT_DETECTION_NOT_SUPPORTED; |
| mUsbDataStatus = DATA_STATUS_UNKNOWN; |
| mPowerBrickConnectionStatus = POWER_BRICK_STATUS_UNKNOWN; |
| mComplianceWarnings = new int[] {}; |
| mPlugState = PLUG_STATE_UNKNOWN; |
| mDisplayPortAltModeInfo = null; |
| } |
| |
| /** |
| * Sets the current mode of {@link UsbPortStatus} |
| * |
| * @return Instance of {@link Builder} |
| */ |
| @NonNull |
| public Builder setCurrentMode(@UsbPortMode int currentMode) { |
| mCurrentMode = currentMode; |
| return this; |
| } |
| |
| /** |
| * Sets the current power role and data role of {@link UsbPortStatus} |
| * |
| * @return Instance of {@link Builder} |
| */ |
| @NonNull |
| public Builder setCurrentRoles(@UsbPowerRole int currentPowerRole, |
| @UsbDataRole int currentDataRole) { |
| mCurrentPowerRole = currentPowerRole; |
| mCurrentDataRole = currentDataRole; |
| return this; |
| } |
| |
| /** |
| * Sets supported role combinations of {@link UsbPortStatus} |
| * |
| * @return Instance of {@link Builder} |
| */ |
| @NonNull |
| public Builder setSupportedRoleCombinations(int supportedRoleCombinations) { |
| mSupportedRoleCombinations = supportedRoleCombinations; |
| return this; |
| } |
| |
| /** |
| * Sets current contaminant status of {@link UsbPortStatus} |
| * |
| * @return Instance of {@link Builder} |
| */ |
| @NonNull |
| public Builder setContaminantStatus( |
| @ContaminantProtectionStatus int contaminantProtectionStatus, |
| @ContaminantDetectionStatus int contaminantDetectionStatus) { |
| mContaminantProtectionStatus = contaminantProtectionStatus; |
| mContaminantDetectionStatus = contaminantDetectionStatus; |
| return this; |
| } |
| |
| /** |
| * Sets power limit power transfer of {@link UsbPortStatus} |
| * |
| * @return Instance of {@link Builder} |
| */ |
| @NonNull |
| public Builder setPowerTransferLimited(boolean powerTransferLimited) { |
| mPowerTransferLimited = powerTransferLimited; |
| return this; |
| } |
| |
| /** |
| * Sets the USB data status of {@link UsbPortStatus} |
| * |
| * @return Instance of {@link Builder} |
| */ |
| @NonNull |
| public Builder setUsbDataStatus(@UsbDataStatus int usbDataStatus) { |
| mUsbDataStatus = usbDataStatus; |
| return this; |
| } |
| |
| /** |
| * Sets the power brick connection status of {@link UsbPortStatus} |
| * |
| * @return Instance of {@link Builder} |
| */ |
| @NonNull |
| public Builder setPowerBrickConnectionStatus( |
| @PowerBrickConnectionStatus int powerBrickConnectionStatus) { |
| mPowerBrickConnectionStatus = powerBrickConnectionStatus; |
| return this; |
| } |
| |
| /** |
| * Sets the non-compliant charger reasons of {@link UsbPortStatus} |
| * |
| * @return Instance of {@link Builder} |
| */ |
| @NonNull |
| public Builder setComplianceWarnings( |
| @NonNull int[] complianceWarnings) { |
| mComplianceWarnings = complianceWarnings == null ? new int[] {} : |
| complianceWarnings; |
| return this; |
| } |
| |
| /** |
| * Sets the plug orientation of {@link UsbPortStatus} |
| * |
| * @return Instance of {@link Builder} |
| */ |
| @NonNull |
| public Builder setPlugState(int plugState) { |
| mPlugState = plugState; |
| return this; |
| } |
| |
| /** |
| * Sets the plug orientation of {@link UsbPortStatus} |
| * |
| * @return Instance of {@link Builder} |
| */ |
| @NonNull |
| public Builder setDisplayPortAltModeInfo( |
| @Nullable DisplayPortAltModeInfo displayPortAltModeInfo) { |
| mDisplayPortAltModeInfo = displayPortAltModeInfo; |
| return this; |
| } |
| |
| /** |
| * Creates the {@link UsbPortStatus} object. |
| */ |
| @NonNull |
| public UsbPortStatus build() { |
| UsbPortStatus status = new UsbPortStatus(mCurrentMode, mCurrentPowerRole, |
| mCurrentDataRole, mSupportedRoleCombinations, mContaminantProtectionStatus, |
| mContaminantDetectionStatus, mUsbDataStatus, mPowerTransferLimited, |
| mPowerBrickConnectionStatus, mComplianceWarnings, |
| mPlugState, mDisplayPortAltModeInfo); |
| return status; |
| } |
| }; |
| } |
