FileDocCategorySizeDatePackage
HdmiDeviceInfo.javaAPI DocAndroid 5.1 API17504Thu Mar 12 22:22:10 GMT 2015android.hardware.hdmi

HdmiDeviceInfo

public class HdmiDeviceInfo extends Object implements android.os.Parcelable
A class to encapsulate device information for HDMI devices including CEC and MHL. In terms of CEC, this container includes basic information such as logical address, physical address and device type, and additional information like vendor id and osd name. In terms of MHL device, this container includes adopter id and device type. Otherwise, it keeps the information of other type devices for which only port ID, physical address are meaningful.
hide

Fields Summary
public static final int
DEVICE_TV
TV device type.
public static final int
DEVICE_RECORDER
Recording device type.
public static final int
DEVICE_RESERVED
Device type reserved for future usage.
public static final int
DEVICE_TUNER
Tuner device type.
public static final int
DEVICE_PLAYBACK
Playback device type.
public static final int
DEVICE_AUDIO_SYSTEM
Audio system device type.
public static final int
DEVICE_PURE_CEC_SWITCH
public static final int
DEVICE_VIDEO_PROCESSOR
public static final int
DEVICE_INACTIVE
public static final int
ADDR_INTERNAL
Logical address used to indicate the source comes from internal device. The logical address of TV(0) is used.
public static final int
PATH_INTERNAL
Physical address used to indicate the source comes from internal device. The physical address of TV(0) is used.
public static final int
PATH_INVALID
Invalid physical address (routing path)
public static final int
PORT_INVALID
Invalid port ID
public static final int
ID_INVALID
Invalid device ID
public static final HdmiDeviceInfo
INACTIVE_DEVICE
Device info used to indicate an inactivated device.
private static final int
HDMI_DEVICE_TYPE_CEC
private static final int
HDMI_DEVICE_TYPE_MHL
private static final int
HDMI_DEVICE_TYPE_HARDWARE
private static final int
HDMI_DEVICE_TYPE_INACTIVE
private static final int
ID_OFFSET_CEC
private static final int
ID_OFFSET_MHL
private static final int
ID_OFFSET_HARDWARE
private final int
mId
private final int
mHdmiDeviceType
private final int
mPhysicalAddress
private final int
mPortId
private final int
mLogicalAddress
private final int
mDeviceType
private final int
mVendorId
private final String
mDisplayName
private final int
mDevicePowerStatus
private final int
mDeviceId
private final int
mAdopterId
public static final Parcelable.Creator
CREATOR
A helper class to deserialize {@link HdmiDeviceInfo} for a parcel.
Constructors Summary
public HdmiDeviceInfo(int logicalAddress, int physicalAddress, int portId, int deviceType, int vendorId, String displayName, int powerStatus)
Constructor. Used to initialize the instance for CEC device.

param
logicalAddress logical address of HDMI-CEC device
param
physicalAddress physical address of HDMI-CEC device
param
portId HDMI port ID (1 for HDMI1)
param
deviceType type of device
param
vendorId vendor id of device. Used for vendor specific command.
param
displayName name of device
param
powerStatus device power status
hide


                                                                   
            
                  
        mHdmiDeviceType = HDMI_DEVICE_TYPE_CEC;
        mPhysicalAddress = physicalAddress;
        mPortId = portId;

        mId = idForCecDevice(logicalAddress);
        mLogicalAddress = logicalAddress;
        mDeviceType = deviceType;
        mVendorId = vendorId;
        mDevicePowerStatus = powerStatus;
        mDisplayName = displayName;

        mDeviceId = -1;
        mAdopterId = -1;
public HdmiDeviceInfo(int logicalAddress, int physicalAddress, int portId, int deviceType, int vendorId, String displayName)
Constructor. Used to initialize the instance for CEC device.

param
logicalAddress logical address of HDMI-CEC device
param
physicalAddress physical address of HDMI-CEC device
param
portId HDMI port ID (1 for HDMI1)
param
deviceType type of device
param
vendorId vendor id of device. Used for vendor specific command.
param
displayName name of device
hide

        this(logicalAddress, physicalAddress, portId, deviceType,
                vendorId, displayName, HdmiControlManager.POWER_STATUS_UNKNOWN);
public HdmiDeviceInfo(int physicalAddress, int portId)
Constructor. Used to initialize the instance for device representing hardware port.

param
physicalAddress physical address of the port
param
portId HDMI port ID (1 for HDMI1)
hide

        mHdmiDeviceType = HDMI_DEVICE_TYPE_HARDWARE;
        mPhysicalAddress = physicalAddress;
        mPortId = portId;

        mId = idForHardware(portId);
        mLogicalAddress = -1;
        mDeviceType = DEVICE_RESERVED;
        mVendorId = 0;
        mDevicePowerStatus = HdmiControlManager.POWER_STATUS_UNKNOWN;
        mDisplayName = "HDMI" + portId;

        mDeviceId = -1;
        mAdopterId = -1;
public HdmiDeviceInfo(int physicalAddress, int portId, int adopterId, int deviceId)
Constructor. Used to initialize the instance for MHL device.

param
physicalAddress physical address of HDMI device
param
portId portId HDMI port ID (1 for HDMI1)
param
adopterId adopter id of MHL
param
deviceId device id of MHL
hide

        mHdmiDeviceType = HDMI_DEVICE_TYPE_MHL;
        mPhysicalAddress = physicalAddress;
        mPortId = portId;

        mId = idForMhlDevice(portId);
        mLogicalAddress = -1;
        mDeviceType = DEVICE_RESERVED;
        mVendorId = 0;
        mDevicePowerStatus = HdmiControlManager.POWER_STATUS_UNKNOWN;
        mDisplayName = "Mobile";

        mDeviceId = adopterId;
        mAdopterId = deviceId;
public HdmiDeviceInfo()
Constructor. Used to initialize the instance representing an inactivated device. Can be passed input change listener to indicate the active source yielded its status, hence the listener should take an appropriate action such as switching to other input.

        mHdmiDeviceType = HDMI_DEVICE_TYPE_INACTIVE;
        mPhysicalAddress = PATH_INVALID;
        mId = ID_INVALID;

        mLogicalAddress = -1;
        mDeviceType = DEVICE_INACTIVE;
        mPortId = PORT_INVALID;
        mDevicePowerStatus = HdmiControlManager.POWER_STATUS_UNKNOWN;
        mDisplayName = "Inactive";
        mVendorId = 0;

        mDeviceId = -1;
        mAdopterId = -1;
Methods Summary
public intdescribeContents()
Describes the kinds of special objects contained in this Parcelable's marshalled representation.

        return 0;
public booleanequals(java.lang.Object obj)

        if (!(obj instanceof HdmiDeviceInfo)) {
            return false;
        }

        HdmiDeviceInfo other = (HdmiDeviceInfo) obj;
        return mHdmiDeviceType == other.mHdmiDeviceType
                && mPhysicalAddress == other.mPhysicalAddress
                && mPortId == other.mPortId
                && mLogicalAddress == other.mLogicalAddress
                && mDeviceType == other.mDeviceType
                && mVendorId == other.mVendorId
                && mDevicePowerStatus == other.mDevicePowerStatus
                && mDisplayName.equals(other.mDisplayName)
                && mDeviceId == other.mDeviceId
                && mAdopterId == other.mAdopterId;
public intgetAdopterId()
Returns MHL adopter id. Return -1 for non-MHL device.

        return mAdopterId;
public intgetDeviceId()
Returns MHL device id. Return -1 for non-MHL device.

        return mDeviceId;
public intgetDevicePowerStatus()
Returns device's power status. It should be one of the following values.
  • {@link HdmiControlManager#POWER_STATUS_ON}
  • {@link HdmiControlManager#POWER_STATUS_STANDBY}
  • {@link HdmiControlManager#POWER_STATUS_TRANSIENT_TO_ON}
  • {@link HdmiControlManager#POWER_STATUS_TRANSIENT_TO_STANDBY}
  • {@link HdmiControlManager#POWER_STATUS_UNKNOWN} 

        return mDevicePowerStatus;
public intgetDeviceType()
Returns CEC type of the device. For more details, refer constants between {@link #DEVICE_TV} and {@link #DEVICE_INACTIVE}.

        return mDeviceType;
public java.lang.StringgetDisplayName()
Returns display (OSD) name of the device.

        return mDisplayName;
public intgetId()
Returns the id of the device.

        return mId;
public intgetLogicalAddress()
Returns the CEC logical address of the device.

        return mLogicalAddress;
public intgetPhysicalAddress()
Returns the physical address of the device.

        return mPhysicalAddress;
public intgetPortId()
Returns the port ID.

        return mPortId;
public intgetVendorId()
Returns vendor id of the device. Vendor id is used to distinguish devices built by other manufactures. This is required for vendor-specific command on CEC standard.

        return mVendorId;
public static intidForCecDevice(int address)
Returns the id to be used for CEC device.

param
address logical address of CEC device
return
id for CEC device

        // The id is generated based on the logical address.
        return ID_OFFSET_CEC + address;
public static intidForHardware(int portId)
Returns the id to be used for hardware port.

param
portId port id
return
id for hardware port

        return ID_OFFSET_HARDWARE + portId;
public static intidForMhlDevice(int portId)
Returns the id to be used for MHL device.

param
portId port which the MHL device is connected to
return
id for MHL device

        // The id is generated based on the port id since there can be only one MHL device per port.
        return ID_OFFSET_MHL + portId;
public booleanisCecDevice()
Returns {@code true} if the device represents an HDMI-CEC device. {@code false} if the device is either MHL or other device.

        return mHdmiDeviceType == HDMI_DEVICE_TYPE_CEC;
public booleanisInactivated()
Return {@code true} if the device represents an inactivated device that relinquishes its status as active source by <Active Source> (HDMI-CEC) or Content-off (MHL).

        return mHdmiDeviceType == HDMI_DEVICE_TYPE_INACTIVE;
public booleanisMhlDevice()
Returns {@code true} if the device represents an MHL device. {@code false} if the device is either CEC or other device.

        return mHdmiDeviceType == HDMI_DEVICE_TYPE_MHL;
public booleanisSourceType()
Returns {@code true} if the device is of a type that can be an input source.

        if (isCecDevice()) {
            return mDeviceType == DEVICE_PLAYBACK
                    || mDeviceType == DEVICE_RECORDER
                    || mDeviceType == DEVICE_TUNER;
        } else if (isMhlDevice()) {
            return true;
        } else {
            return false;
        }
public java.lang.StringtoString()

        StringBuffer s = new StringBuffer();
        switch (mHdmiDeviceType) {
            case HDMI_DEVICE_TYPE_CEC:
                s.append("CEC: ");
                s.append("logical_address: ").append(String.format("0x%02X", mLogicalAddress));
                s.append(" ");
                s.append("device_type: ").append(mDeviceType).append(" ");
                s.append("vendor_id: ").append(mVendorId).append(" ");
                s.append("display_name: ").append(mDisplayName).append(" ");
                s.append("power_status: ").append(mDevicePowerStatus).append(" ");
                break;
            case HDMI_DEVICE_TYPE_MHL:
                s.append("MHL: ");
                s.append("device_id: ").append(String.format("0x%04X", mDeviceId)).append(" ");
                s.append("adopter_id: ").append(String.format("0x%04X", mAdopterId)).append(" ");
                break;

            case HDMI_DEVICE_TYPE_HARDWARE:
                s.append("Hardware: ");
                break;
            case HDMI_DEVICE_TYPE_INACTIVE:
                s.append("Inactivated: ");
                break;
            default:
                return "";
        }
        s.append("physical_address: ").append(String.format("0x%04X", mPhysicalAddress));
        s.append(" ");
        s.append("port_id: ").append(mPortId);
        return s.toString();
public voidwriteToParcel(android.os.Parcel dest, int flags)
Serializes this object into a {@link Parcel}.

param
dest The Parcel in which the object should be written.
param
flags Additional flags about how the object should be written. May be 0 or {@link Parcelable#PARCELABLE_WRITE_RETURN_VALUE}.

        dest.writeInt(mHdmiDeviceType);
        dest.writeInt(mPhysicalAddress);
        dest.writeInt(mPortId);
        switch (mHdmiDeviceType) {
            case HDMI_DEVICE_TYPE_CEC:
                dest.writeInt(mLogicalAddress);
                dest.writeInt(mDeviceType);
                dest.writeInt(mVendorId);
                dest.writeInt(mDevicePowerStatus);
                dest.writeString(mDisplayName);
                break;
            case HDMI_DEVICE_TYPE_MHL:
                dest.writeInt(mDeviceId);
                dest.writeInt(mAdopterId);
                break;
            case HDMI_DEVICE_TYPE_INACTIVE:
                // flow through
            default:
                // no-op
        }