Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge changes I944dc1cd,I97c962d5

Browse Source 
* changes:
  Track CEC version of CEC devices
  Add HdmiDeviceInfo#mHdmiCecVersion
This commit is contained in:
TreeHugger Robot
2020-12-10 12:23:49 +00:00
committed by Android (Google) Code Review
parent 9e75ca54a3 17c51c7b85
commit 2c70cd586b
8 changed files with 233 additions and 15 deletions
Download Patch File Download Diff File Expand all files Collapse all files

47
core/java/android/hardware/hdmi/HdmiDeviceInfo.java
View File

@@ -19,6 +19,7 @@ package android.hardware.hdmi;
import android.annotation.NonNull;
import android.annotation.Nullable;
import android.annotation.SystemApi;
import android.hardware.hdmi.HdmiControlManager.HdmiCecVersion;
import android.os.Parcel;
import android.os.Parcelable;
@@ -107,6 +108,8 @@ public class HdmiDeviceInfo implements Parcelable {
// CEC only parameters.
private final int mLogicalAddress;
private final int mDeviceType;
@HdmiCecVersion
private final int mHdmiCecVersion;
private final int mVendorId;
private final String mDisplayName;
private final int mDevicePowerStatus;
@@ -133,8 +136,9 @@ public class HdmiDeviceInfo implements Parcelable {
int vendorId = source.readInt();
int powerStatus = source.readInt();
String displayName = source.readString();
int cecVersion = source.readInt();
return new HdmiDeviceInfo(logicalAddress, physicalAddress, portId,
deviceType, vendorId, displayName, powerStatus);
deviceType, vendorId, displayName, powerStatus, cecVersion);
case HDMI_DEVICE_TYPE_MHL:
int deviceId = source.readInt();
int adopterId = source.readInt();
@@ -167,7 +171,7 @@ public class HdmiDeviceInfo implements Parcelable {
* @hide
*/
public HdmiDeviceInfo(int logicalAddress, int physicalAddress, int portId, int deviceType,
int vendorId, String displayName, int powerStatus) {
int vendorId, String displayName, int powerStatus, int hdmiCecVersion) {
mHdmiDeviceType = HDMI_DEVICE_TYPE_CEC;
mPhysicalAddress = physicalAddress;
mPortId = portId;
@@ -175,6 +179,7 @@ public class HdmiDeviceInfo implements Parcelable {
mId = idForCecDevice(logicalAddress);
mLogicalAddress = logicalAddress;
mDeviceType = deviceType;
mHdmiCecVersion = hdmiCecVersion;
mVendorId = vendorId;
mDevicePowerStatus = powerStatus;
mDisplayName = displayName;
@@ -192,12 +197,31 @@ public class HdmiDeviceInfo implements Parcelable {
* @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) {
this(logicalAddress, physicalAddress, portId, deviceType,
vendorId, displayName, powerStatus, HdmiControlManager.HDMI_CEC_VERSION_1_4_b);
}
/**
* 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);
vendorId, displayName, HdmiControlManager.POWER_STATUS_UNKNOWN,
HdmiControlManager.HDMI_CEC_VERSION_1_4_b);
}
/**
@@ -215,6 +239,7 @@ public class HdmiDeviceInfo implements Parcelable {
mId = idForHardware(portId);
mLogicalAddress = -1;
mDeviceType = DEVICE_RESERVED;
mHdmiCecVersion = HdmiControlManager.HDMI_CEC_VERSION_1_4_b;
mVendorId = 0;
mDevicePowerStatus = HdmiControlManager.POWER_STATUS_UNKNOWN;
mDisplayName = "HDMI" + portId;
@@ -240,6 +265,7 @@ public class HdmiDeviceInfo implements Parcelable {
mId = idForMhlDevice(portId);
mLogicalAddress = -1;
mDeviceType = DEVICE_RESERVED;
mHdmiCecVersion = HdmiControlManager.HDMI_CEC_VERSION_1_4_b;
mVendorId = 0;
mDevicePowerStatus = HdmiControlManager.POWER_STATUS_UNKNOWN;
mDisplayName = "Mobile";
@@ -261,6 +287,7 @@ public class HdmiDeviceInfo implements Parcelable {
mLogicalAddress = -1;
mDeviceType = DEVICE_INACTIVE;
mHdmiCecVersion = HdmiControlManager.HDMI_CEC_VERSION_1_4_b;
mPortId = PORT_INVALID;
mDevicePowerStatus = HdmiControlManager.POWER_STATUS_UNKNOWN;
mDisplayName = "Inactive";
@@ -338,6 +365,16 @@ public class HdmiDeviceInfo implements Parcelable {
return mDeviceType;
}
/**
* Returns the CEC version the device supports.
*
* @hide
*/
@HdmiCecVersion
public int getCecVersion() {
return mHdmiCecVersion;
}
/**
* Returns device's power status. It should be one of the following values.
* <ul>
@@ -448,6 +485,7 @@ public class HdmiDeviceInfo implements Parcelable {
dest.writeInt(mVendorId);
dest.writeInt(mDevicePowerStatus);
dest.writeString(mDisplayName);
dest.writeInt(mHdmiCecVersion);
break;
case HDMI_DEVICE_TYPE_MHL:
dest.writeInt(mDeviceId);
@@ -470,6 +508,7 @@ public class HdmiDeviceInfo implements Parcelable {
s.append("logical_address: ").append(String.format("0x%02X", mLogicalAddress));
s.append(" ");
s.append("device_type: ").append(mDeviceType).append(" ");
s.append("cec_version: ").append(mHdmiCecVersion).append(" ");
s.append("vendor_id: ").append(mVendorId).append(" ");
s.append("display_name: ").append(mDisplayName).append(" ");
s.append("power_status: ").append(mDevicePowerStatus).append(" ");
@@ -507,6 +546,7 @@ public class HdmiDeviceInfo implements Parcelable {
&& mPortId == other.mPortId
&& mLogicalAddress == other.mLogicalAddress
&& mDeviceType == other.mDeviceType
&& mHdmiCecVersion == other.mHdmiCecVersion
&& mVendorId == other.mVendorId
&& mDevicePowerStatus == other.mDevicePowerStatus
&& mDisplayName.equals(other.mDisplayName)
@@ -522,6 +562,7 @@ public class HdmiDeviceInfo implements Parcelable {
mPortId,
mLogicalAddress,
mDeviceType,
mHdmiCecVersion,
mVendorId,
mDevicePowerStatus,
mDisplayName,

11
core/tests/hdmitests/src/android/hardware/hdmi/HdmiDeviceInfoTest.java
View File

@@ -37,6 +37,7 @@ public class HdmiDeviceInfoTest {
int deviceType = 0;
int vendorId = 0x123456;
String displayName = "test device";
int cecVersion = HdmiControlManager.HDMI_CEC_VERSION_2_0;
int powerStatus = HdmiControlManager.POWER_STATUS_TRANSIENT_TO_STANDBY;
int deviceId = 3;
int adopterId = 2;
@@ -70,6 +71,16 @@ public class HdmiDeviceInfoTest {
vendorId,
displayName,
powerStatus))
.addEqualityGroup(
new HdmiDeviceInfo(
logicalAddr,
phyAddr,
portId,
deviceType,
vendorId,
displayName,
powerStatus,
cecVersion))
.testEquals();
}
}

10
services/core/java/com/android/server/hdmi/HdmiCecLocalDevice.java
View File

@@ -282,6 +282,8 @@ abstract class HdmiCecLocalDevice {
return handleGiveOsdName(message);
case Constants.MESSAGE_GIVE_DEVICE_VENDOR_ID:
return handleGiveDeviceVendorId(null);
case Constants.MESSAGE_CEC_VERSION:
return handleCecVersion();
case Constants.MESSAGE_GET_CEC_VERSION:
return handleGetCecVersion(message);
case Constants.MESSAGE_REPORT_PHYSICAL_ADDRESS:
@@ -405,6 +407,14 @@ abstract class HdmiCecLocalDevice {
return true;
}
@ServiceThreadOnly
private boolean handleCecVersion() {
assertRunOnServiceThread();
// Return true to avoid <Feature Abort> responses. Cec Version is tracked in HdmiCecNetwork.
return true;
}
@ServiceThreadOnly
protected boolean handleActiveSource(HdmiCecMessage message) {
return false;

57
services/core/java/com/android/server/hdmi/HdmiCecNetwork.java
View File

@@ -166,7 +166,6 @@ public class HdmiCecNetwork {
}
return false;
}
/**
* Clear all logical addresses registered in the device.
*
@@ -523,10 +522,31 @@ public class HdmiCecNetwork {
case Constants.MESSAGE_DEVICE_VENDOR_ID:
handleDeviceVendorId(message);
break;
case Constants.MESSAGE_CEC_VERSION:
handleCecVersion(message);
break;
case Constants.MESSAGE_REPORT_FEATURES:
handleReportFeatures(message);
break;
}
}
@ServiceThreadOnly
private void handleReportFeatures(HdmiCecMessage message) {
assertRunOnServiceThread();
int version = Byte.toUnsignedInt(message.getParams()[0]);
updateDeviceCecVersion(message.getSource(), version);
}
@ServiceThreadOnly
private void handleCecVersion(HdmiCecMessage message) {
assertRunOnServiceThread();
int version = Byte.toUnsignedInt(message.getParams()[0]);
updateDeviceCecVersion(message.getSource(), version);
}
@ServiceThreadOnly
private void handleReportPhysicalAddress(HdmiCecMessage message) {
assertRunOnServiceThread();
@@ -543,7 +563,8 @@ public class HdmiCecNetwork {
HdmiDeviceInfo updatedDeviceInfo = new HdmiDeviceInfo(deviceInfo.getLogicalAddress(),
physicalAddress,
physicalAddressToPortId(physicalAddress), type, deviceInfo.getVendorId(),
deviceInfo.getDisplayName(), deviceInfo.getDevicePowerStatus());
deviceInfo.getDisplayName(), deviceInfo.getDevicePowerStatus(),
deviceInfo.getCecVersion());
updateCecDevice(updatedDeviceInfo);
}
}
@@ -554,6 +575,31 @@ public class HdmiCecNetwork {
// Update power status of device
int newStatus = message.getParams()[0] & 0xFF;
updateDevicePowerStatus(message.getSource(), newStatus);
if (message.getDestination() == Constants.ADDR_BROADCAST) {
updateDeviceCecVersion(message.getSource(), HdmiControlManager.HDMI_CEC_VERSION_2_0);
}
}
@ServiceThreadOnly
private void updateDeviceCecVersion(int logicalAddress, int hdmiCecVersion) {
assertRunOnServiceThread();
HdmiDeviceInfo deviceInfo = getCecDeviceInfo(logicalAddress);
if (deviceInfo == null) {
Slog.w(TAG, "Can not update CEC version of non-existing device:" + logicalAddress);
return;
}
if (deviceInfo.getCecVersion() == hdmiCecVersion) {
return;
}
HdmiDeviceInfo updatedDeviceInfo = new HdmiDeviceInfo(deviceInfo.getLogicalAddress(),
deviceInfo.getPhysicalAddress(), deviceInfo.getPortId(), deviceInfo.getDeviceType(),
deviceInfo.getVendorId(),
deviceInfo.getDisplayName(), deviceInfo.getDevicePowerStatus(),
hdmiCecVersion);
updateCecDevice(updatedDeviceInfo);
}
@ServiceThreadOnly
@@ -586,7 +632,7 @@ public class HdmiCecNetwork {
updateCecDevice(new HdmiDeviceInfo(deviceInfo.getLogicalAddress(),
deviceInfo.getPhysicalAddress(), deviceInfo.getPortId(),
deviceInfo.getDeviceType(), deviceInfo.getVendorId(), osdName,
deviceInfo.getDevicePowerStatus()));
deviceInfo.getDevicePowerStatus(), deviceInfo.getCecVersion()));
}
@ServiceThreadOnly
@@ -602,7 +648,8 @@ public class HdmiCecNetwork {
HdmiDeviceInfo updatedDeviceInfo = new HdmiDeviceInfo(deviceInfo.getLogicalAddress(),
deviceInfo.getPhysicalAddress(),
deviceInfo.getPortId(), deviceInfo.getDeviceType(), vendorId,
deviceInfo.getDisplayName(), deviceInfo.getDevicePowerStatus());
deviceInfo.getDisplayName(), deviceInfo.getDevicePowerStatus(),
deviceInfo.getCecVersion());
updateCecDevice(updatedDeviceInfo);
}
}

9
services/core/java/com/android/server/hdmi/HdmiControlService.java
View File

@@ -813,7 +813,7 @@ public class HdmiControlService extends SystemService {
// with system.
HdmiDeviceInfo deviceInfo = createDeviceInfo(logicalAddress,
deviceType,
HdmiControlManager.POWER_STATUS_ON);
HdmiControlManager.POWER_STATUS_ON, getCecVersion());
localDevice.setDeviceInfo(deviceInfo);
mHdmiCecNetwork.addLocalDevice(deviceType, localDevice);
mCecController.addLogicalAddress(logicalAddress);
@@ -1222,11 +1222,12 @@ public class HdmiControlService extends SystemService {
}
}
private HdmiDeviceInfo createDeviceInfo(int logicalAddress, int deviceType, int powerStatus) {
private HdmiDeviceInfo createDeviceInfo(int logicalAddress, int deviceType, int powerStatus,
int cecVersion) {
String displayName = readStringSetting(Global.DEVICE_NAME, Build.MODEL);
return new HdmiDeviceInfo(logicalAddress,
getPhysicalAddress(), pathToPortId(getPhysicalAddress()), deviceType,
getVendorId(), displayName, powerStatus);
getVendorId(), displayName, powerStatus, cecVersion);
}
// Set the display name in HdmiDeviceInfo of the current devices to content provided by
@@ -1240,7 +1241,7 @@ public class HdmiControlService extends SystemService {
device.setDeviceInfo(new HdmiDeviceInfo(
deviceInfo.getLogicalAddress(), deviceInfo.getPhysicalAddress(),
deviceInfo.getPortId(), deviceInfo.getDeviceType(), deviceInfo.getVendorId(),
newDisplayName, deviceInfo.getDevicePowerStatus()));
newDisplayName, deviceInfo.getDevicePowerStatus(), deviceInfo.getCecVersion()));
sendCecCommand(HdmiCecMessageBuilder.buildSetOsdNameCommand(
device.mAddress, Constants.ADDR_TV, newDisplayName));
}

2
services/core/java/com/android/server/hdmi/HdmiUtils.java
View File

@@ -396,7 +396,7 @@ final class HdmiUtils {
static HdmiDeviceInfo cloneHdmiDeviceInfo(HdmiDeviceInfo info, int newPowerStatus) {
return new HdmiDeviceInfo(info.getLogicalAddress(),
info.getPhysicalAddress(), info.getPortId(), info.getDeviceType(),
info.getVendorId(), info.getDisplayName(), newPowerStatus);
info.getVendorId(), info.getDisplayName(), newPowerStatus, info.getCecVersion());
}
/**

12
services/tests/servicestests/src/com/android/server/hdmi/HdmiCecLocalDeviceTest.java
View File

@@ -25,6 +25,8 @@ import static com.android.server.hdmi.Constants.ADDR_UNREGISTERED;
import static com.android.server.hdmi.Constants.MESSAGE_DEVICE_VENDOR_ID;
import static com.android.server.hdmi.Constants.MESSAGE_REPORT_PHYSICAL_ADDRESS;
import static com.google.common.truth.Truth.assertThat;
import static junit.framework.Assert.assertEquals;
import static junit.framework.Assert.assertFalse;
import static junit.framework.Assert.assertTrue;
@@ -264,4 +266,14 @@ public class HdmiCecLocalDeviceTest {
assertFalse(result);
}
@Test
public void handleCecVersion_isHandled() {
boolean result = mHdmiLocalDevice.onMessage(
HdmiCecMessageBuilder.buildCecVersion(ADDR_PLAYBACK_1, mHdmiLocalDevice.mAddress,
HdmiControlManager.HDMI_CEC_VERSION_1_4_b));
assertThat(result).isTrue();
}
}

100
services/tests/servicestests/src/com/android/server/hdmi/HdmiCecNetworkTest.java
View File

@@ -36,6 +36,7 @@ import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
@@ -313,6 +314,7 @@ public class HdmiCecNetworkTest {
int powerStatus = HdmiControlManager.POWER_STATUS_ON;
String osdName = "Test Device";
int vendorId = 1234;
int cecVersion = HdmiControlManager.HDMI_CEC_VERSION_2_0;
mHdmiCecNetwork.handleCecMessage(
HdmiCecMessageBuilder.buildReportPhysicalAddressCommand(logicalAddress,
@@ -325,6 +327,8 @@ public class HdmiCecNetworkTest {
Constants.ADDR_BROADCAST, osdName));
mHdmiCecNetwork.handleCecMessage(
HdmiCecMessageBuilder.buildDeviceVendorIdCommand(logicalAddress, vendorId));
mHdmiCecNetwork.handleCecMessage(HdmiCecMessageBuilder.buildCecVersion(logicalAddress,
Constants.ADDR_BROADCAST, cecVersion));
assertThat(mHdmiCecNetwork.getSafeCecDevicesLocked()).hasSize(1);
@@ -335,6 +339,7 @@ public class HdmiCecNetworkTest {
assertThat(cecDeviceInfo.getDisplayName()).isEqualTo(osdName);
assertThat(cecDeviceInfo.getVendorId()).isEqualTo(vendorId);
assertThat(cecDeviceInfo.getDevicePowerStatus()).isEqualTo(powerStatus);
assertThat(cecDeviceInfo.getCecVersion()).isEqualTo(cecVersion);
}
@Test
@@ -374,16 +379,18 @@ public class HdmiCecNetworkTest {
mHdmiCecNetwork.handleCecMessage(
HdmiCecMessageBuilder.buildReportPowerStatus(logicalAddress,
Constants.ADDR_BROADCAST, powerStatus));
Constants.ADDR_TV, powerStatus));
mHdmiCecNetwork.handleCecMessage(
HdmiCecMessageBuilder.buildReportPowerStatus(logicalAddress,
Constants.ADDR_BROADCAST, updatedPowerStatus));
Constants.ADDR_TV, updatedPowerStatus));
assertThat(mHdmiCecNetwork.getSafeCecDevicesLocked()).hasSize(1);
HdmiDeviceInfo cecDeviceInfo = mHdmiCecNetwork.getCecDeviceInfo(logicalAddress);
assertThat(cecDeviceInfo.getLogicalAddress()).isEqualTo(logicalAddress);
assertThat(cecDeviceInfo.getDevicePowerStatus()).isEqualTo(updatedPowerStatus);
assertThat(cecDeviceInfo.getCecVersion()).isEqualTo(
HdmiControlManager.HDMI_CEC_VERSION_1_4_b);
}
@Test
@@ -428,6 +435,8 @@ public class HdmiCecNetworkTest {
assertThat(cecDeviceInfo.getVendorId()).isEqualTo(updatedVendorId);
assertThat(cecDeviceInfo.getDevicePowerStatus()).isEqualTo(
HdmiControlManager.POWER_STATUS_UNKNOWN);
assertThat(cecDeviceInfo.getCecVersion()).isEqualTo(
HdmiControlManager.HDMI_CEC_VERSION_1_4_b);
}
@Test
@@ -446,4 +455,91 @@ public class HdmiCecNetworkTest {
HdmiControlManager.DEVICE_EVENT_ADD_DEVICE,
HdmiControlManager.DEVICE_EVENT_REMOVE_DEVICE);
}
@Test
public void cecDevices_tracking_reportPowerStatus_broadcast_infersCec2() {
int logicalAddress = Constants.ADDR_PLAYBACK_1;
int powerStatus = HdmiControlManager.POWER_STATUS_ON;
mHdmiCecNetwork.handleCecMessage(
HdmiCecMessageBuilder.buildReportPowerStatus(logicalAddress,
Constants.ADDR_BROADCAST, powerStatus));
assertThat(mHdmiCecNetwork.getSafeCecDevicesLocked()).hasSize(1);
HdmiDeviceInfo cecDeviceInfo = mHdmiCecNetwork.getCecDeviceInfo(logicalAddress);
assertThat(cecDeviceInfo.getLogicalAddress()).isEqualTo(logicalAddress);
assertThat(cecDeviceInfo.getPhysicalAddress()).isEqualTo(
Constants.INVALID_PHYSICAL_ADDRESS);
assertThat(cecDeviceInfo.getDeviceType()).isEqualTo(HdmiDeviceInfo.DEVICE_RESERVED);
assertThat(cecDeviceInfo.getVendorId()).isEqualTo(Constants.UNKNOWN_VENDOR_ID);
assertThat(cecDeviceInfo.getDisplayName()).isEqualTo(
HdmiUtils.getDefaultDeviceName(logicalAddress));
assertThat(cecDeviceInfo.getDevicePowerStatus()).isEqualTo(powerStatus);
assertThat(cecDeviceInfo.getCecVersion()).isEqualTo(
HdmiControlManager.HDMI_CEC_VERSION_2_0);
}
@Test
public void cecDevices_tracking_reportCecVersion_tracksCecVersion_cec14() {
int logicalAddress = Constants.ADDR_PLAYBACK_1;
int cecVersion = HdmiControlManager.HDMI_CEC_VERSION_1_4_b;
mHdmiCecNetwork.handleCecMessage(
HdmiCecMessageBuilder.buildCecVersion(logicalAddress, Constants.ADDR_BROADCAST,
cecVersion));
assertThat(mHdmiCecNetwork.getSafeCecDevicesLocked()).hasSize(1);
HdmiDeviceInfo cecDeviceInfo = mHdmiCecNetwork.getCecDeviceInfo(logicalAddress);
assertThat(cecDeviceInfo.getLogicalAddress()).isEqualTo(logicalAddress);
assertThat(cecDeviceInfo.getCecVersion()).isEqualTo(cecVersion);
}
@Test
public void cecDevices_tracking_reportCecVersion_tracksCecVersion_cec20() {
int logicalAddress = Constants.ADDR_PLAYBACK_1;
int cecVersion = HdmiControlManager.HDMI_CEC_VERSION_2_0;
mHdmiCecNetwork.handleCecMessage(
HdmiCecMessageBuilder.buildCecVersion(logicalAddress, Constants.ADDR_BROADCAST,
cecVersion));
assertThat(mHdmiCecNetwork.getSafeCecDevicesLocked()).hasSize(1);
HdmiDeviceInfo cecDeviceInfo = mHdmiCecNetwork.getCecDeviceInfo(logicalAddress);
assertThat(cecDeviceInfo.getLogicalAddress()).isEqualTo(logicalAddress);
assertThat(cecDeviceInfo.getCecVersion()).isEqualTo(cecVersion);
}
@Test
public void cecDevices_tracking_reportFeatures_tracksCecVersion_cec14() {
int logicalAddress = Constants.ADDR_PLAYBACK_1;
int cecVersion = HdmiControlManager.HDMI_CEC_VERSION_1_4_b;
mHdmiCecNetwork.handleCecMessage(
HdmiCecMessageBuilder.buildReportFeatures(logicalAddress,
cecVersion, Collections.emptyList(),
Constants.RC_PROFILE_SOURCE, Collections.emptyList(),
Collections.emptyList()));
assertThat(mHdmiCecNetwork.getSafeCecDevicesLocked()).hasSize(1);
HdmiDeviceInfo cecDeviceInfo = mHdmiCecNetwork.getCecDeviceInfo(logicalAddress);
assertThat(cecDeviceInfo.getLogicalAddress()).isEqualTo(logicalAddress);
assertThat(cecDeviceInfo.getCecVersion()).isEqualTo(cecVersion);
}
@Test
public void cecDevices_tracking_reportFeatures_tracksCecVersion_cec20() {
int logicalAddress = Constants.ADDR_PLAYBACK_1;
int cecVersion = HdmiControlManager.HDMI_CEC_VERSION_2_0;
mHdmiCecNetwork.handleCecMessage(
HdmiCecMessageBuilder.buildReportFeatures(logicalAddress,
cecVersion, Collections.emptyList(),
Constants.RC_PROFILE_SOURCE, Collections.emptyList(),
Collections.emptyList()));
assertThat(mHdmiCecNetwork.getSafeCecDevicesLocked()).hasSize(1);
HdmiDeviceInfo cecDeviceInfo = mHdmiCecNetwork.getCecDeviceInfo(logicalAddress);
assertThat(cecDeviceInfo.getLogicalAddress()).isEqualTo(logicalAddress);
assertThat(cecDeviceInfo.getCecVersion()).isEqualTo(cecVersion);
}
}