| /* |
| * Copyright (C) 2014 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.hdmi; |
| |
| import android.annotation.SystemApi; |
| import android.os.Parcel; |
| import 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 |
| */ |
| @SystemApi |
| public class HdmiDeviceInfo implements Parcelable { |
| |
| /** TV device type. */ |
| public static final int DEVICE_TV = 0; |
| |
| /** Recording device type. */ |
| public static final int DEVICE_RECORDER = 1; |
| |
| /** Device type reserved for future usage. */ |
| public static final int DEVICE_RESERVED = 2; |
| |
| /** Tuner device type. */ |
| public static final int DEVICE_TUNER = 3; |
| |
| /** Playback device type. */ |
| public static final int DEVICE_PLAYBACK = 4; |
| |
| /** Audio system device type. */ |
| public static final int DEVICE_AUDIO_SYSTEM = 5; |
| |
| /** @hide Pure CEC switch device type. */ |
| public static final int DEVICE_PURE_CEC_SWITCH = 6; |
| |
| /** @hide Video processor device type. */ |
| public static final int DEVICE_VIDEO_PROCESSOR = 7; |
| |
| // Value indicating the device is not an active source. |
| public static final int DEVICE_INACTIVE = -1; |
| |
| /** |
| * Logical address used to indicate the source comes from internal device. The logical address |
| * of TV(0) is used. |
| */ |
| public static final int ADDR_INTERNAL = 0; |
| |
| /** |
| * Physical address used to indicate the source comes from internal device. The physical address |
| * of TV(0) is used. |
| */ |
| public static final int PATH_INTERNAL = 0x0000; |
| |
| /** Invalid physical address (routing path) */ |
| public static final int PATH_INVALID = 0xFFFF; |
| |
| /** Invalid port ID */ |
| public static final int PORT_INVALID = -1; |
| |
| /** Invalid device ID */ |
| public static final int ID_INVALID = 0xFFFF; |
| |
| /** Device info used to indicate an inactivated device. */ |
| public static final HdmiDeviceInfo INACTIVE_DEVICE = new HdmiDeviceInfo(); |
| |
| private static final int HDMI_DEVICE_TYPE_CEC = 0; |
| private static final int HDMI_DEVICE_TYPE_MHL = 1; |
| private static final int HDMI_DEVICE_TYPE_HARDWARE = 2; |
| |
| // Type used to indicate the device that has relinquished its active source status. |
| private static final int HDMI_DEVICE_TYPE_INACTIVE = 100; |
| |
| // Offset used for id value. MHL devices, for instance, will be assigned the value from |
| // ID_OFFSET_MHL. |
| private static final int ID_OFFSET_CEC = 0x0; |
| private static final int ID_OFFSET_MHL = 0x80; |
| private static final int ID_OFFSET_HARDWARE = 0xC0; |
| |
| // Common parameters for all device. |
| private final int mId; |
| private final int mHdmiDeviceType; |
| private final int mPhysicalAddress; |
| private final int mPortId; |
| |
| // CEC only parameters. |
| private final int mLogicalAddress; |
| private final int mDeviceType; |
| private final int mVendorId; |
| private final String mDisplayName; |
| private final int mDevicePowerStatus; |
| |
| // MHL only parameters. |
| private final int mDeviceId; |
| private final int mAdopterId; |
| |
| /** |
| * A helper class to deserialize {@link HdmiDeviceInfo} for a parcel. |
| */ |
| public static final @android.annotation.NonNull Parcelable.Creator<HdmiDeviceInfo> CREATOR = |
| new Parcelable.Creator<HdmiDeviceInfo>() { |
| @Override |
| public HdmiDeviceInfo createFromParcel(Parcel source) { |
| int hdmiDeviceType = source.readInt(); |
| int physicalAddress = source.readInt(); |
| int portId = source.readInt(); |
| |
| switch (hdmiDeviceType) { |
| case HDMI_DEVICE_TYPE_CEC: |
| int logicalAddress = source.readInt(); |
| int deviceType = source.readInt(); |
| int vendorId = source.readInt(); |
| int powerStatus = source.readInt(); |
| String displayName = source.readString(); |
| return new HdmiDeviceInfo(logicalAddress, physicalAddress, portId, |
| deviceType, vendorId, displayName, powerStatus); |
| case HDMI_DEVICE_TYPE_MHL: |
| int deviceId = source.readInt(); |
| int adopterId = source.readInt(); |
| return new HdmiDeviceInfo(physicalAddress, portId, adopterId, deviceId); |
| case HDMI_DEVICE_TYPE_HARDWARE: |
| return new HdmiDeviceInfo(physicalAddress, portId); |
| case HDMI_DEVICE_TYPE_INACTIVE: |
| return HdmiDeviceInfo.INACTIVE_DEVICE; |
| default: |
| return null; |
| } |
| } |
| |
| @Override |
| public HdmiDeviceInfo[] newArray(int size) { |
| return new HdmiDeviceInfo[size]; |
| } |
| }; |
| |
| /** |
| * 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 |
| */ |
| public HdmiDeviceInfo(int logicalAddress, int physicalAddress, int portId, int deviceType, |
| int vendorId, String displayName, int powerStatus) { |
| 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; |
| } |
| |
| /** |
| * 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 |
| */ |
| public HdmiDeviceInfo(int logicalAddress, int physicalAddress, int portId, int deviceType, |
| int vendorId, String displayName) { |
| this(logicalAddress, physicalAddress, portId, deviceType, |
| vendorId, displayName, HdmiControlManager.POWER_STATUS_UNKNOWN); |
| } |
| |
| /** |
| * 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 |
| */ |
| public HdmiDeviceInfo(int physicalAddress, int portId) { |
| 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; |
| } |
| |
| /** |
| * 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 |
| */ |
| public HdmiDeviceInfo(int physicalAddress, int portId, int adopterId, int deviceId) { |
| 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; |
| } |
| |
| /** |
| * 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. |
| */ |
| public HdmiDeviceInfo() { |
| 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; |
| } |
| |
| /** |
| * Returns the id of the device. |
| */ |
| public int getId() { |
| return mId; |
| } |
| |
| /** |
| * Returns the id to be used for CEC device. |
| * |
| * @param address logical address of CEC device |
| * @return id for CEC device |
| */ |
| public static int idForCecDevice(int address) { |
| // The id is generated based on the logical address. |
| return ID_OFFSET_CEC + address; |
| } |
| |
| /** |
| * Returns the id to be used for MHL device. |
| * |
| * @param portId port which the MHL device is connected to |
| * @return id for MHL device |
| */ |
| public static int idForMhlDevice(int portId) { |
| // The id is generated based on the port id since there can be only one MHL device per port. |
| return ID_OFFSET_MHL + portId; |
| } |
| |
| /** |
| * Returns the id to be used for hardware port. |
| * |
| * @param portId port id |
| * @return id for hardware port |
| */ |
| public static int idForHardware(int portId) { |
| return ID_OFFSET_HARDWARE + portId; |
| } |
| |
| /** |
| * Returns the CEC logical address of the device. |
| */ |
| public int getLogicalAddress() { |
| return mLogicalAddress; |
| } |
| |
| /** |
| * Returns the physical address of the device. |
| */ |
| public int getPhysicalAddress() { |
| return mPhysicalAddress; |
| } |
| |
| /** |
| * Returns the port ID. |
| */ |
| public int getPortId() { |
| return mPortId; |
| } |
| |
| /** |
| * Returns CEC type of the device. For more details, refer constants between {@link #DEVICE_TV} |
| * and {@link #DEVICE_INACTIVE}. |
| */ |
| public int getDeviceType() { |
| return mDeviceType; |
| } |
| |
| /** |
| * Returns device's power status. It should be one of the following values. |
| * <ul> |
| * <li>{@link HdmiControlManager#POWER_STATUS_ON} |
| * <li>{@link HdmiControlManager#POWER_STATUS_STANDBY} |
| * <li>{@link HdmiControlManager#POWER_STATUS_TRANSIENT_TO_ON} |
| * <li>{@link HdmiControlManager#POWER_STATUS_TRANSIENT_TO_STANDBY} |
| * <li>{@link HdmiControlManager#POWER_STATUS_UNKNOWN} |
| * </ul> |
| */ |
| public int getDevicePowerStatus() { |
| return mDevicePowerStatus; |
| } |
| |
| /** |
| * Returns MHL device id. Return -1 for non-MHL device. |
| */ |
| public int getDeviceId() { |
| return mDeviceId; |
| } |
| |
| /** |
| * Returns MHL adopter id. Return -1 for non-MHL device. |
| */ |
| public int getAdopterId() { |
| return mAdopterId; |
| } |
| |
| /** |
| * Returns {@code true} if the device is of a type that can be an input source. |
| */ |
| public boolean isSourceType() { |
| if (isCecDevice()) { |
| return mDeviceType == DEVICE_PLAYBACK |
| || mDeviceType == DEVICE_RECORDER |
| || mDeviceType == DEVICE_TUNER; |
| } else if (isMhlDevice()) { |
| return true; |
| } else { |
| return false; |
| } |
| } |
| |
| /** |
| * Returns {@code true} if the device represents an HDMI-CEC device. {@code false} if the device |
| * is either MHL or other device. |
| */ |
| public boolean isCecDevice() { |
| return mHdmiDeviceType == HDMI_DEVICE_TYPE_CEC; |
| } |
| |
| /** |
| * Returns {@code true} if the device represents an MHL device. {@code false} if the device is |
| * either CEC or other device. |
| */ |
| public boolean isMhlDevice() { |
| return mHdmiDeviceType == HDMI_DEVICE_TYPE_MHL; |
| } |
| |
| /** |
| * 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). |
| */ |
| public boolean isInactivated() { |
| return mHdmiDeviceType == HDMI_DEVICE_TYPE_INACTIVE; |
| } |
| |
| /** |
| * Returns display (OSD) name of the device. |
| */ |
| public String getDisplayName() { |
| return mDisplayName; |
| } |
| |
| /** |
| * 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. |
| */ |
| public int getVendorId() { |
| return mVendorId; |
| } |
| |
| /** |
| * Describes the kinds of special objects contained in this Parcelable's marshalled |
| * representation. |
| */ |
| @Override |
| public int describeContents() { |
| return 0; |
| } |
| |
| /** |
| * 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}. |
| */ |
| @Override |
| public void writeToParcel(Parcel dest, int flags) { |
| 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 |
| } |
| } |
| |
| @Override |
| public String toString() { |
| 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(); |
| } |
| |
| @Override |
| public boolean equals(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; |
| } |
| } |