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

Merge changes I46fb8cfe,I4181b465,I99e1ca1d,I66b09693

Browse Source 
* changes:
  Only invoke listener once physical address becomes known
  Don't remove devices on onHotplug()
  Assign local device portId 0
  Set device type on first message received
This commit is contained in:
Nathalie Le Clair
2022-04-04 15:48:29 +00:00
committed by Gerrit Code Review
parent 3f0139b119 a598b93622
commit aa6698b0b4
9 changed files with 314 additions and 37 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
core/java/android/hardware/hdmi/IHdmiDeviceEventListener.aidl
View File

@@ -22,6 +22,8 @@ import android.hardware.hdmi.HdmiDeviceInfo;
* Callback interface definition for HDMI client to get informed of
* the CEC logical device status change event.
*
* Only to be used on TV panel and Audio System devices (b/226317598).
*
* @hide
*/
oneway interface IHdmiDeviceEventListener {

1
services/core/java/com/android/server/hdmi/HdmiCecLocalDevicePlayback.java
View File

@@ -127,6 +127,7 @@ public class HdmiCecLocalDevicePlayback extends HdmiCecLocalDeviceSource {
// We'll not invalidate the active source on the hotplug event to pass CETC 11.2.2-2 ~ 3.
if (!connected) {
getWakeLock().release();
mService.getHdmiCecNetwork().removeDevicesConnectedToPort(portId);
}
}

5
services/core/java/com/android/server/hdmi/HdmiCecLocalDeviceTv.java
View File

@@ -1218,6 +1218,11 @@ final class HdmiCecLocalDeviceTv extends HdmiCecLocalDevice {
@ServiceThreadOnly
void onHotplug(int portId, boolean connected) {
assertRunOnServiceThread();
if (!connected) {
mService.getHdmiCecNetwork().removeCecSwitches(portId);
}
// Turning System Audio Mode off when the AVR is unlugged or standby.
// When the device is not unplugged but reawaken from standby, we check if the System
// Audio Control Feature is enabled or not then decide if turning SAM on/off accordingly.

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

@@ -269,7 +269,10 @@ public class HdmiCecNetwork {
// The addition of a local device should not notify listeners
return;
}
if (old == null) {
if (info.getPhysicalAddress() == HdmiDeviceInfo.PATH_INVALID) {
// Don't notify listeners of devices that haven't reported their physical address yet
return;
} else if (old == null || old.getPhysicalAddress() == HdmiDeviceInfo.PATH_INVALID) {
invokeDeviceEventListener(info,
HdmiControlManager.DEVICE_EVENT_ADD_DEVICE);
} else if (!old.equals(info)) {
@@ -296,7 +299,10 @@ public class HdmiCecNetwork {
assertRunOnServiceThread();
HdmiDeviceInfo old = addDeviceInfo(info);
if (old == null) {
if (info.getPhysicalAddress() == HdmiDeviceInfo.PATH_INVALID) {
// Don't notify listeners of devices that haven't reported their physical address yet
return;
} else if (old == null || old.getPhysicalAddress() == HdmiDeviceInfo.PATH_INVALID) {
invokeDeviceEventListener(info,
HdmiControlManager.DEVICE_EVENT_ADD_DEVICE);
} else if (!old.equals(info)) {
@@ -370,10 +376,12 @@ public class HdmiCecNetwork {
// This only applies to TV devices.
// Returns true if the policy is set to true, and the device to check does not have
// a parent CEC device (which should be the CEC-enabled switch) in the list.
// Devices with an invalid physical address are assumed to NOT be connected to a legacy switch.
private boolean hideDevicesBehindLegacySwitch(HdmiDeviceInfo info) {
return isLocalDeviceAddress(Constants.ADDR_TV)
&& HdmiConfig.HIDE_DEVICES_BEHIND_LEGACY_SWITCH
&& !isConnectedToCecSwitch(info.getPhysicalAddress(), getCecSwitches());
&& !isConnectedToCecSwitch(info.getPhysicalAddress(), getCecSwitches())
&& info.getPhysicalAddress() != HdmiDeviceInfo.PATH_INVALID;
}
/**
@@ -387,6 +395,10 @@ public class HdmiCecNetwork {
HdmiDeviceInfo info = removeDeviceInfo(HdmiDeviceInfo.idForCecDevice(address));
localDevice.mCecMessageCache.flushMessagesFrom(address);
if (info.getPhysicalAddress() == HdmiDeviceInfo.PATH_INVALID) {
// Don't notify listeners of devices that haven't reported their physical address yet
return;
}
invokeDeviceEventListener(info,
HdmiControlManager.DEVICE_EVENT_REMOVE_DEVICE);
}
@@ -497,6 +509,34 @@ public class HdmiCecNetwork {
return device.getPhysicalAddress() == physicalAddress;
}
/**
* Attempts to deduce the device type of a device given its logical address.
* If multiple types are possible, returns {@link HdmiDeviceInfo#DEVICE_RESERVED}.
*/
private static int logicalAddressToDeviceType(int logicalAddress) {
switch (logicalAddress) {
case Constants.ADDR_TV:
return HdmiDeviceInfo.DEVICE_TV;
case Constants.ADDR_RECORDER_1:
case Constants.ADDR_RECORDER_2:
case Constants.ADDR_RECORDER_3:
return HdmiDeviceInfo.DEVICE_RECORDER;
case Constants.ADDR_TUNER_1:
case Constants.ADDR_TUNER_2:
case Constants.ADDR_TUNER_3:
case Constants.ADDR_TUNER_4:
return HdmiDeviceInfo.DEVICE_TUNER;
case Constants.ADDR_PLAYBACK_1:
case Constants.ADDR_PLAYBACK_2:
case Constants.ADDR_PLAYBACK_3:
return HdmiDeviceInfo.DEVICE_PLAYBACK;
case Constants.ADDR_AUDIO_SYSTEM:
return HdmiDeviceInfo.DEVICE_AUDIO_SYSTEM;
default:
return HdmiDeviceInfo.DEVICE_RESERVED;
}
}
/**
* Passively listen to incoming CEC messages.
*
@@ -510,7 +550,7 @@ public class HdmiCecNetwork {
if (getCecDeviceInfo(sourceAddress) == null) {
HdmiDeviceInfo newDevice = new HdmiDeviceInfo(sourceAddress,
HdmiDeviceInfo.PATH_INVALID, HdmiDeviceInfo.PORT_INVALID,
HdmiDeviceInfo.DEVICE_RESERVED, Constants.UNKNOWN_VENDOR_ID,
logicalAddressToDeviceType(sourceAddress), Constants.UNKNOWN_VENDOR_ID,
HdmiUtils.getDefaultDeviceName(sourceAddress));
addCecDevice(newDevice);
}
@@ -668,7 +708,7 @@ public class HdmiCecNetwork {
return mCecSwitches;
}
void removeDevicesConnectedToPort(int portId) {
void removeCecSwitches(int portId) {
Iterator<Integer> it = mCecSwitches.iterator();
while (it.hasNext()) {
int path = it.next();
@@ -677,6 +717,11 @@ public class HdmiCecNetwork {
it.remove();
}
}
}
void removeDevicesConnectedToPort(int portId) {
removeCecSwitches(portId);
List<Integer> toRemove = new ArrayList<>();
for (int i = 0; i < mDeviceInfos.size(); i++) {
int key = mDeviceInfos.keyAt(i);
@@ -788,7 +833,10 @@ public class HdmiCecNetwork {
public void clearDeviceList() {
assertRunOnServiceThread();
for (HdmiDeviceInfo info : HdmiUtils.sparseArrayToList(mDeviceInfos)) {
if (info.getPhysicalAddress() == getPhysicalAddress()) {
if (info.getPhysicalAddress() == getPhysicalAddress()
|| info.getPhysicalAddress() == HdmiDeviceInfo.PATH_INVALID) {
// Don't notify listeners of local devices or devices that haven't reported their
// physical address yet
continue;
}
invokeDeviceEventListener(info,
@@ -835,10 +883,13 @@ public class HdmiCecNetwork {
* on the current device.
*/
int physicalAddressToPortId(int path) {
int physicalAddress = getPhysicalAddress();
if (path == physicalAddress) {
// The local device isn't connected to any port; assign portId 0
return Constants.CEC_SWITCH_HOME;
}
int mask = 0xF000;
int finalMask = 0xF000;
int physicalAddress;
physicalAddress = getPhysicalAddress();
int maskedAddress = physicalAddress;
while (maskedAddress != 0) {

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

@@ -1251,10 +1251,6 @@ public class HdmiControlService extends SystemService {
device.onHotplug(portId, connected);
}
if (!connected) {
mHdmiCecNetwork.removeDevicesConnectedToPort(portId);
}
announceHotplugEvent(portId, connected);
}

6
services/core/java/com/android/server/hdmi/HotplugDetectionAction.java
View File

@@ -36,9 +36,9 @@ import java.util.List;
final class HotplugDetectionAction extends HdmiCecFeatureAction {
private static final String TAG = "HotPlugDetectionAction";
private static final int POLLING_INTERVAL_MS = 5000;
private static final int TIMEOUT_COUNT = 3;
private static final int AVR_COUNT_MAX = 3;
public static final int POLLING_INTERVAL_MS = 5000;
public static final int TIMEOUT_COUNT = 3;
public static final int AVR_COUNT_MAX = 3;
// State in which waits for next polling
private static final int STATE_WAIT_FOR_NEXT_POLLING = 1;

28
services/tests/servicestests/src/com/android/server/hdmi/HdmiCecLocalDevicePlaybackTest.java
View File

@@ -1789,4 +1789,32 @@ public class HdmiCecLocalDevicePlaybackTest {
assertThat(mNativeWrapper.getResultMessages()).doesNotContain(featureAbortPressed);
assertThat(mNativeWrapper.getResultMessages()).doesNotContain(featureAbortReleased);
}
@Test
public void onHotplugClearsDevices() {
mHdmiControlService.getHdmiCecNetwork().clearDeviceList();
assertThat(mHdmiControlService.getHdmiCecNetwork().getDeviceInfoList(false))
.isEmpty();
// Add a device to the network and assert that this device is included in the list of
// devices.
HdmiDeviceInfo infoPlayback = new HdmiDeviceInfo(
Constants.ADDR_PLAYBACK_3,
0x1000,
PORT_1,
HdmiDeviceInfo.DEVICE_PLAYBACK,
0x1000,
"Playback 3",
HdmiControlManager.POWER_STATUS_ON);
mHdmiControlService.getHdmiCecNetwork().addCecDevice(infoPlayback);
mTestLooper.dispatchAll();
assertThat(mHdmiControlService.getHdmiCecNetwork().getDeviceInfoList(false))
.hasSize(1);
// HAL detects a hotplug out. Assert that this device gets removed from the list of devices.
mHdmiControlService.onHotplug(PORT_1, false);
mTestLooper.dispatchAll();
assertThat(mHdmiControlService.getHdmiCecNetwork().getDeviceInfoList(false))
.isEmpty();
}
}

170
services/tests/servicestests/src/com/android/server/hdmi/HdmiCecLocalDeviceTvTest.java
View File

@@ -19,6 +19,7 @@ import static com.android.server.hdmi.Constants.ABORT_UNRECOGNIZED_OPCODE;
import static com.android.server.hdmi.Constants.ADDR_AUDIO_SYSTEM;
import static com.android.server.hdmi.Constants.ADDR_BROADCAST;
import static com.android.server.hdmi.Constants.ADDR_PLAYBACK_1;
import static com.android.server.hdmi.Constants.ADDR_PLAYBACK_2;
import static com.android.server.hdmi.Constants.ADDR_RECORDER_1;
import static com.android.server.hdmi.Constants.ADDR_TV;
import static com.android.server.hdmi.HdmiControlService.INITIATED_BY_ENABLE_CEC;
@@ -56,12 +57,14 @@ import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import java.util.ArrayList;
import java.util.List;
@SmallTest
@RunWith(JUnit4.class)
/** Tests for {@link HdmiCecLocalDeviceTv} class. */
public class HdmiCecLocalDeviceTvTest {
private static final int TIMEOUT_MS = HdmiConfig.TIMEOUT_MS + 1;
private static final int PORT_1 = 1;
private HdmiControlService mHdmiControlService;
private HdmiCecController mHdmiCecController;
@@ -73,6 +76,25 @@ public class HdmiCecLocalDeviceTvTest {
private int mTvPhysicalAddress;
private int mTvLogicalAddress;
private boolean mWokenUp;
private List<DeviceEventListener> mDeviceEventListeners = new ArrayList<>();
private class DeviceEventListener {
private HdmiDeviceInfo mDevice;
private int mStatus;
DeviceEventListener(HdmiDeviceInfo device, int status) {
this.mDevice = device;
this.mStatus = status;
}
int getStatus() {
return mStatus;
}
HdmiDeviceInfo getDeviceInfo() {
return mDevice;
}
}
@Mock
private IPowerManager mIPowerManagerMock;
@@ -124,6 +146,11 @@ public class HdmiCecLocalDeviceTvTest {
AudioManager getAudioManager() {
return mAudioManager;
}
@Override
void invokeDeviceEventListeners(HdmiDeviceInfo device, int status) {
mDeviceEventListeners.add(new DeviceEventListener(device, status));
}
};
mHdmiCecLocalDeviceTv = new HdmiCecLocalDeviceTv(mHdmiControlService);
@@ -596,4 +623,147 @@ public class HdmiCecLocalDeviceTvTest {
verify(mAudioManager, never()).setStreamVolume(anyInt(), anyInt(), anyInt());
}
@Test
public void hotplugDetectionActionClearsDevices() {
mHdmiControlService.getHdmiCecNetwork().clearDeviceList();
assertThat(mHdmiControlService.getHdmiCecNetwork().getDeviceInfoList(false))
.isEmpty();
// Add a device to the network and assert that this device is included in the list of
// devices.
HdmiDeviceInfo infoPlayback = new HdmiDeviceInfo(
Constants.ADDR_PLAYBACK_2,
0x1000,
PORT_1,
HdmiDeviceInfo.DEVICE_PLAYBACK,
0x1000,
"Playback 2",
HdmiControlManager.POWER_STATUS_ON);
mHdmiControlService.getHdmiCecNetwork().addCecDevice(infoPlayback);
mTestLooper.dispatchAll();
assertThat(mHdmiControlService.getHdmiCecNetwork().getDeviceInfoList(false))
.hasSize(1);
mDeviceEventListeners.clear();
assertThat(mDeviceEventListeners.size()).isEqualTo(0);
// HAL detects a hotplug out. Assert that this device stays in the list of devices.
mHdmiControlService.onHotplug(PORT_1, false);
assertThat(mHdmiControlService.getHdmiCecNetwork().getDeviceInfoList(false))
.hasSize(1);
assertThat(mDeviceEventListeners).isEmpty();
mTestLooper.dispatchAll();
// Make the device not acknowledge the poll message sent by the HotplugDetectionAction.
// Assert that this device is removed from the list of devices.
mNativeWrapper.setPollAddressResponse(Constants.ADDR_PLAYBACK_2, SendMessageResult.NACK);
for (int pollCount = 0; pollCount < HotplugDetectionAction.TIMEOUT_COUNT; pollCount++) {
mTestLooper.moveTimeForward(HotplugDetectionAction.POLLING_INTERVAL_MS);
mTestLooper.dispatchAll();
}
assertThat(mHdmiControlService.getHdmiCecNetwork().getDeviceInfoList(false))
.isEmpty();
assertThat(mDeviceEventListeners.size()).isEqualTo(1);
assertThat(mDeviceEventListeners.get(0).getStatus())
.isEqualTo(HdmiControlManager.DEVICE_EVENT_REMOVE_DEVICE);
HdmiDeviceInfo removedDeviceInfo = mDeviceEventListeners.get(0).getDeviceInfo();
assertThat(removedDeviceInfo.getPortId()).isEqualTo(PORT_1);
assertThat(removedDeviceInfo.getLogicalAddress()).isEqualTo(Constants.ADDR_PLAYBACK_2);
assertThat(removedDeviceInfo.getPhysicalAddress()).isEqualTo(0x1000);
assertThat(removedDeviceInfo.getDeviceType()).isEqualTo(HdmiDeviceInfo.DEVICE_PLAYBACK);
}
@Test
public void hotplugDetectionActionClearsDevices_AudioSystem() {
mHdmiControlService.getHdmiCecNetwork().clearDeviceList();
assertThat(mHdmiControlService.getHdmiCecNetwork().getDeviceInfoList(false))
.isEmpty();
// Add a device to the network and assert that this device is included in the list of
// devices.
HdmiDeviceInfo infoAudioSystem = new HdmiDeviceInfo(
ADDR_AUDIO_SYSTEM,
0x1000,
PORT_1,
HdmiDeviceInfo.DEVICE_AUDIO_SYSTEM,
0x1000,
"Audio System",
HdmiControlManager.POWER_STATUS_ON);
mHdmiControlService.getHdmiCecNetwork().addCecDevice(infoAudioSystem);
mTestLooper.dispatchAll();
assertThat(mHdmiControlService.getHdmiCecNetwork().getDeviceInfoList(false))
.hasSize(1);
mDeviceEventListeners.clear();
assertThat(mDeviceEventListeners.size()).isEqualTo(0);
// HAL detects a hotplug out. Assert that this device stays in the list of devices.
mHdmiControlService.onHotplug(PORT_1, false);
assertThat(mHdmiControlService.getHdmiCecNetwork().getDeviceInfoList(false))
.hasSize(1);
assertThat(mDeviceEventListeners).isEmpty();
mTestLooper.dispatchAll();
// Make the device not acknowledge the poll message sent by the HotplugDetectionAction.
// Assert that this device is removed from the list of devices.
mNativeWrapper.setPollAddressResponse(ADDR_AUDIO_SYSTEM, SendMessageResult.NACK);
for (int pollCount = 0; pollCount < HotplugDetectionAction.TIMEOUT_COUNT; pollCount++) {
mTestLooper.moveTimeForward(HotplugDetectionAction.POLLING_INTERVAL_MS);
mTestLooper.dispatchAll();
}
assertThat(mHdmiControlService.getHdmiCecNetwork().getDeviceInfoList(false))
.isEmpty();
assertThat(mDeviceEventListeners.size()).isEqualTo(1);
assertThat(mDeviceEventListeners.get(0).getStatus())
.isEqualTo(HdmiControlManager.DEVICE_EVENT_REMOVE_DEVICE);
HdmiDeviceInfo removedDeviceInfo = mDeviceEventListeners.get(0).getDeviceInfo();
assertThat(removedDeviceInfo.getPortId()).isEqualTo(PORT_1);
assertThat(removedDeviceInfo.getLogicalAddress()).isEqualTo(Constants.ADDR_AUDIO_SYSTEM);
assertThat(removedDeviceInfo.getPhysicalAddress()).isEqualTo(0x1000);
assertThat(removedDeviceInfo.getDeviceType()).isEqualTo(HdmiDeviceInfo.DEVICE_AUDIO_SYSTEM);
}
@Test
public void listenerInvokedIfPhysicalAddressReported() {
mHdmiControlService.getHdmiCecNetwork().clearDeviceList();
assertThat(mHdmiControlService.getHdmiCecNetwork().getDeviceInfoList(false))
.isEmpty();
HdmiCecMessage reportPhysicalAddress =
HdmiCecMessageBuilder.buildReportPhysicalAddressCommand(
ADDR_PLAYBACK_2, 0x1000, HdmiDeviceInfo.DEVICE_PLAYBACK);
mNativeWrapper.onCecMessage(reportPhysicalAddress);
mTestLooper.dispatchAll();
assertThat(mHdmiControlService.getHdmiCecNetwork().getDeviceInfoList(false))
.hasSize(1);
assertThat(mDeviceEventListeners.size()).isEqualTo(1);
assertThat(mDeviceEventListeners.get(0).getStatus())
.isEqualTo(HdmiControlManager.DEVICE_EVENT_ADD_DEVICE);
}
@Test
public void listenerNotInvokedIfPhysicalAddressUnknown() {
mHdmiControlService.getHdmiCecNetwork().clearDeviceList();
assertThat(mHdmiControlService.getHdmiCecNetwork().getDeviceInfoList(false))
.isEmpty();
HdmiCecMessage setOsdName = HdmiCecMessageBuilder.buildSetOsdNameCommand(
ADDR_PLAYBACK_2, ADDR_TV, "Playback 2");
mNativeWrapper.onCecMessage(setOsdName);
mTestLooper.dispatchAll();
assertThat(mHdmiControlService.getHdmiCecNetwork().getDeviceInfoList(false))
.hasSize(1);
assertThat(mDeviceEventListeners).isEmpty();
// When the device reports its physical address, the listener eventually is invoked.
HdmiCecMessage reportPhysicalAddress =
HdmiCecMessageBuilder.buildReportPhysicalAddressCommand(
ADDR_PLAYBACK_2, 0x1000, HdmiDeviceInfo.DEVICE_PLAYBACK);
mNativeWrapper.onCecMessage(reportPhysicalAddress);
mTestLooper.dispatchAll();
assertThat(mHdmiControlService.getHdmiCecNetwork().getDeviceInfoList(false))
.hasSize(1);
assertThat(mDeviceEventListeners.size()).isEqualTo(1);
assertThat(mDeviceEventListeners.get(0).getStatus())
.isEqualTo(HdmiControlManager.DEVICE_EVENT_ADD_DEVICE);
}
}

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

@@ -100,6 +100,8 @@ public class HdmiCecNetworkTest {
new HdmiPortInfo(5, HdmiPortInfo.PORT_OUTPUT, 0x0000, true, false, false);
mNativeWrapper.setPortInfo(mHdmiPortInfo);
mHdmiCecNetwork.initPortInfo();
mHdmiCecNetwork = mHdmiControlService.getHdmiCecNetwork();
}
@Test
@@ -139,8 +141,25 @@ public class HdmiCecNetworkTest {
Constants.INVALID_PORT_ID);
}
@Test
public void physicalAddressToPort_localDevice_weAreSourceDevice() {
mNativeWrapper.setPhysicalAddress(0x2000);
mHdmiCecNetwork.initPortInfo();
assertThat(mHdmiCecNetwork.physicalAddressToPortId(0x2000))
.isEqualTo(Constants.CEC_SWITCH_HOME);
}
@Test
public void physicalAddressToPort_localDevice_weAreTv() {
mNativeWrapper.setPhysicalAddress(0x0000);
mHdmiCecNetwork.initPortInfo();
assertThat(mHdmiCecNetwork.physicalAddressToPortId(0x0000))
.isEqualTo(Constants.CEC_SWITCH_HOME);
}
@Test
public void localDevices_verifyOne_tv() {
mHdmiCecNetwork.clearLocalDevices();
mHdmiCecNetwork.addLocalDevice(HdmiDeviceInfo.DEVICE_TV,
new HdmiCecLocalDeviceTv(mHdmiControlService));
@@ -153,6 +172,7 @@ public class HdmiCecNetworkTest {
@Test
public void localDevices_verifyOne_playback() {
mHdmiCecNetwork.clearLocalDevices();
mHdmiCecNetwork.addLocalDevice(HdmiDeviceInfo.DEVICE_PLAYBACK,
new HdmiCecLocalDevicePlayback(mHdmiControlService));
@@ -175,27 +195,26 @@ public class HdmiCecNetworkTest {
assertThat(cecDeviceInfo.getLogicalAddress()).isEqualTo(logicalAddress);
assertThat(cecDeviceInfo.getPhysicalAddress()).isEqualTo(
Constants.INVALID_PHYSICAL_ADDRESS);
assertThat(cecDeviceInfo.getDeviceType()).isEqualTo(HdmiDeviceInfo.DEVICE_RESERVED);
assertThat(cecDeviceInfo.getDeviceType()).isEqualTo(HdmiDeviceInfo.DEVICE_PLAYBACK);
assertThat(cecDeviceInfo.getDisplayName()).isEqualTo(
HdmiUtils.getDefaultDeviceName(logicalAddress));
assertThat(cecDeviceInfo.getVendorId()).isEqualTo(Constants.UNKNOWN_VENDOR_ID);
assertThat(cecDeviceInfo.getDevicePowerStatus()).isEqualTo(
HdmiControlManager.POWER_STATUS_UNKNOWN);
assertThat(mDeviceEventListenerStatuses).containsExactly(
HdmiControlManager.DEVICE_EVENT_ADD_DEVICE);
assertThat(mDeviceEventListenerStatuses).isEmpty();
}
@Test
public void cecDevices_tracking_logicalAddressOnly_doesntNotifyAgain() throws Exception {
int logicalAddress = Constants.ADDR_PLAYBACK_1;
int physicalAddress = 0x1000;
mHdmiCecNetwork.handleCecMessage(
HdmiCecMessageBuilder.buildActiveSource(logicalAddress, 0x1000));
HdmiCecMessageBuilder.buildActiveSource(logicalAddress, physicalAddress));
mHdmiCecNetwork.handleCecMessage(
HdmiCecMessageBuilder.buildActiveSource(logicalAddress, 0x1000));
HdmiCecMessageBuilder.buildActiveSource(logicalAddress, physicalAddress));
assertThat(mDeviceEventListenerStatuses).containsExactly(
HdmiControlManager.DEVICE_EVENT_ADD_DEVICE);
assertThat(mDeviceEventListenerStatuses).isEmpty();
}
@Test
@@ -219,6 +238,9 @@ public class HdmiCecNetworkTest {
assertThat(cecDeviceInfo.getVendorId()).isEqualTo(Constants.UNKNOWN_VENDOR_ID);
assertThat(cecDeviceInfo.getDevicePowerStatus()).isEqualTo(
HdmiControlManager.POWER_STATUS_UNKNOWN);
assertThat(mDeviceEventListenerStatuses).containsExactly(
HdmiControlManager.DEVICE_EVENT_ADD_DEVICE);
}
@Test
@@ -236,11 +258,10 @@ public class HdmiCecNetworkTest {
physicalAddress, type));
// ADD for logical address first detected
// UPDATE for updating device with physical address
// ADD for physical address first detected
// no UPDATE, since physical address didn't change
assertThat(mDeviceEventListenerStatuses).containsExactly(
HdmiControlManager.DEVICE_EVENT_ADD_DEVICE,
HdmiControlManager.DEVICE_EVENT_UPDATE_DEVICE);
HdmiControlManager.DEVICE_EVENT_ADD_DEVICE);
}
@Test
@@ -257,11 +278,13 @@ public class HdmiCecNetworkTest {
assertThat(cecDeviceInfo.getLogicalAddress()).isEqualTo(logicalAddress);
assertThat(cecDeviceInfo.getPhysicalAddress()).isEqualTo(
Constants.INVALID_PHYSICAL_ADDRESS);
assertThat(cecDeviceInfo.getDeviceType()).isEqualTo(HdmiDeviceInfo.DEVICE_RESERVED);
assertThat(cecDeviceInfo.getDeviceType()).isEqualTo(HdmiDeviceInfo.DEVICE_PLAYBACK);
assertThat(cecDeviceInfo.getVendorId()).isEqualTo(Constants.UNKNOWN_VENDOR_ID);
assertThat(cecDeviceInfo.getDisplayName()).isEqualTo(
HdmiUtils.getDefaultDeviceName(logicalAddress));
assertThat(cecDeviceInfo.getDevicePowerStatus()).isEqualTo(powerStatus);
assertThat(mDeviceEventListenerStatuses).isEmpty();
}
@Test
@@ -278,11 +301,13 @@ public class HdmiCecNetworkTest {
assertThat(cecDeviceInfo.getLogicalAddress()).isEqualTo(logicalAddress);
assertThat(cecDeviceInfo.getPhysicalAddress()).isEqualTo(
Constants.INVALID_PHYSICAL_ADDRESS);
assertThat(cecDeviceInfo.getDeviceType()).isEqualTo(HdmiDeviceInfo.DEVICE_RESERVED);
assertThat(cecDeviceInfo.getDeviceType()).isEqualTo(HdmiDeviceInfo.DEVICE_PLAYBACK);
assertThat(cecDeviceInfo.getVendorId()).isEqualTo(Constants.UNKNOWN_VENDOR_ID);
assertThat(cecDeviceInfo.getDisplayName()).isEqualTo(osdName);
assertThat(cecDeviceInfo.getDevicePowerStatus()).isEqualTo(
HdmiControlManager.POWER_STATUS_UNKNOWN);
assertThat(mDeviceEventListenerStatuses).isEmpty();
}
@Test
@@ -298,12 +323,14 @@ public class HdmiCecNetworkTest {
assertThat(cecDeviceInfo.getLogicalAddress()).isEqualTo(logicalAddress);
assertThat(cecDeviceInfo.getPhysicalAddress()).isEqualTo(
Constants.INVALID_PHYSICAL_ADDRESS);
assertThat(cecDeviceInfo.getDeviceType()).isEqualTo(HdmiDeviceInfo.DEVICE_RESERVED);
assertThat(cecDeviceInfo.getDeviceType()).isEqualTo(HdmiDeviceInfo.DEVICE_PLAYBACK);
assertThat(cecDeviceInfo.getDisplayName()).isEqualTo(
HdmiUtils.getDefaultDeviceName(logicalAddress));
assertThat(cecDeviceInfo.getVendorId()).isEqualTo(vendorId);
assertThat(cecDeviceInfo.getDevicePowerStatus()).isEqualTo(
HdmiControlManager.POWER_STATUS_UNKNOWN);
assertThat(mDeviceEventListenerStatuses).isEmpty();
}
@Test
@@ -362,12 +389,10 @@ public class HdmiCecNetworkTest {
assertThat(cecDeviceInfo.getPhysicalAddress()).isEqualTo(updatedPhysicalAddress);
assertThat(cecDeviceInfo.getDeviceType()).isEqualTo(type);
// ADD for logical address first detected
// UPDATE for updating device with physical address
// ADD for physical address first detected
// UPDATE for updating device with new physical address
assertThat(mDeviceEventListenerStatuses).containsExactly(
HdmiControlManager.DEVICE_EVENT_ADD_DEVICE,
HdmiControlManager.DEVICE_EVENT_UPDATE_DEVICE,
HdmiControlManager.DEVICE_EVENT_UPDATE_DEVICE);
}
@@ -429,7 +454,7 @@ public class HdmiCecNetworkTest {
assertThat(cecDeviceInfo.getLogicalAddress()).isEqualTo(logicalAddress);
assertThat(cecDeviceInfo.getPhysicalAddress()).isEqualTo(
Constants.INVALID_PHYSICAL_ADDRESS);
assertThat(cecDeviceInfo.getDeviceType()).isEqualTo(HdmiDeviceInfo.DEVICE_RESERVED);
assertThat(cecDeviceInfo.getDeviceType()).isEqualTo(HdmiDeviceInfo.DEVICE_PLAYBACK);
assertThat(cecDeviceInfo.getDisplayName()).isEqualTo(
HdmiUtils.getDefaultDeviceName(logicalAddress));
assertThat(cecDeviceInfo.getVendorId()).isEqualTo(updatedVendorId);
@@ -451,9 +476,8 @@ public class HdmiCecNetworkTest {
assertThat(mHdmiCecNetwork.getSafeCecDevicesLocked()).isEmpty();
assertThat(mDeviceEventListenerStatuses).containsExactly(
HdmiControlManager.DEVICE_EVENT_ADD_DEVICE,
HdmiControlManager.DEVICE_EVENT_REMOVE_DEVICE);
// Physical address never got reported, so no listeners are triggered
assertThat(mDeviceEventListenerStatuses).isEmpty();
}
@Test
@@ -470,7 +494,7 @@ public class HdmiCecNetworkTest {
assertThat(cecDeviceInfo.getLogicalAddress()).isEqualTo(logicalAddress);
assertThat(cecDeviceInfo.getPhysicalAddress()).isEqualTo(
Constants.INVALID_PHYSICAL_ADDRESS);
assertThat(cecDeviceInfo.getDeviceType()).isEqualTo(HdmiDeviceInfo.DEVICE_RESERVED);
assertThat(cecDeviceInfo.getDeviceType()).isEqualTo(HdmiDeviceInfo.DEVICE_PLAYBACK);
assertThat(cecDeviceInfo.getVendorId()).isEqualTo(Constants.UNKNOWN_VENDOR_ID);
assertThat(cecDeviceInfo.getDisplayName()).isEqualTo(
HdmiUtils.getDefaultDeviceName(logicalAddress));