giteadmin/script-astra
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
4380f00a78
script-astra/Android/Sdk/sources/android-35/android/hardware/usb/UsbPortStatus.java

944 lines
34 KiB
Java
Raw Normal View History

init
2025-01-20 15:15:20 +00:00
/*
* 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;
}
};
}
Reference in New Issue Copy Permalink