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

Refactor handling of <Feature Abort> responses

Browse Source 
When handling a message, local devices return a constant instead of
a boolean. The constant represents 3 cases:
1. A <Feature Abort> response with a specific operand
2. The message was successfully handled
3. The message was not handled

This allows (almost) all <Feature Abort> messages to be sent by
HdmiCecController instead of local devices.

Test: atest com.android.server.hdmi
Bug: 180103617
Change-Id: If3a65f512c689a1b0596dd4b8d9fcf489c3468e3
This commit is contained in:
Yan Han
2021-03-16 16:58:07 +01:00
parent abe60b3500
commit 9b7f74f6e9
17 changed files with 954 additions and 592 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
services/core/java/com/android/server/hdmi/Constants.java
View File

@@ -250,7 +250,19 @@ final class Constants {
@Retention(RetentionPolicy.SOURCE)
@IntDef({
ABORT_NO_ERROR,
NOT_HANDLED,
HANDLED,
ABORT_UNRECOGNIZED_OPCODE,
ABORT_NOT_IN_CORRECT_MODE,
ABORT_CANNOT_PROVIDE_SOURCE,
ABORT_INVALID_OPERAND,
ABORT_REFUSED,
ABORT_UNABLE_TO_DETERMINE,
})
public @interface HandleMessageResult {}
@Retention(RetentionPolicy.SOURCE)
@IntDef({
ABORT_UNRECOGNIZED_OPCODE,
ABORT_NOT_IN_CORRECT_MODE,
ABORT_CANNOT_PROVIDE_SOURCE,
@@ -260,8 +272,11 @@ final class Constants {
})
public @interface AbortReason {}
// Internal abort error code. It's the same as success.
static final int ABORT_NO_ERROR = -1;
// Indicates that a message was not handled, but could be handled by another local device.
// If no local devices handle the message, we send <Feature Abort>[Unrecognized Opcode].
static final int NOT_HANDLED = -2;
// Indicates that a message has been handled successfully; no feature abort needed.
static final int HANDLED = -1;
// Constants related to operands of HDMI CEC commands.
// Refer to CEC Table 29 in HDMI Spec v1.4b.
// [Abort Reason]

19
services/core/java/com/android/server/hdmi/HdmiCecController.java
View File

@@ -565,19 +565,24 @@ final class HdmiCecController {
}
@ServiceThreadOnly
private void onReceiveCommand(HdmiCecMessage message) {
@VisibleForTesting
void onReceiveCommand(HdmiCecMessage message) {
assertRunOnServiceThread();
if ((isAcceptableAddress(message.getDestination())
|| !mService.isAddressAllocated())
&& mService.handleCecCommand(message)) {
if (mService.isAddressAllocated() && !isAcceptableAddress(message.getDestination())) {
return;
}
// Not handled message, so we will reply it with <Feature Abort>.
maySendFeatureAbortCommand(message, Constants.ABORT_UNRECOGNIZED_OPCODE);
@Constants.HandleMessageResult int messageState = mService.handleCecCommand(message);
if (messageState == Constants.NOT_HANDLED) {
// Message was not handled
maySendFeatureAbortCommand(message, Constants.ABORT_UNRECOGNIZED_OPCODE);
} else if (messageState != Constants.HANDLED) {
// Message handler wants to send a feature abort
maySendFeatureAbortCommand(message, messageState);
}
}
@ServiceThreadOnly
void maySendFeatureAbortCommand(HdmiCecMessage message, int reason) {
void maySendFeatureAbortCommand(HdmiCecMessage message, @Constants.AbortReason int reason) {
assertRunOnServiceThread();
// Swap the source and the destination.
int src = message.getDestination();

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

@@ -248,11 +248,13 @@ abstract class HdmiCecLocalDevice {
* @return true if consumed a message; otherwise, return false.
*/
@ServiceThreadOnly
boolean dispatchMessage(HdmiCecMessage message) {
@VisibleForTesting
@Constants.HandleMessageResult
protected int dispatchMessage(HdmiCecMessage message) {
assertRunOnServiceThread();
int dest = message.getDestination();
if (dest != mAddress && dest != Constants.ADDR_BROADCAST) {
return false;
return Constants.NOT_HANDLED;
}
// Cache incoming message if it is included in the list of cacheable opcodes.
mCecMessageCache.cacheMessage(message);
@@ -260,10 +262,11 @@ abstract class HdmiCecLocalDevice {
}
@ServiceThreadOnly
protected final boolean onMessage(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected final int onMessage(HdmiCecMessage message) {
assertRunOnServiceThread();
if (dispatchMessageToAction(message)) {
return true;
return Constants.HANDLED;
}
switch (message.getOpcode()) {
case Constants.MESSAGE_ACTIVE_SOURCE:
@@ -357,7 +360,7 @@ abstract class HdmiCecLocalDevice {
case Constants.MESSAGE_GIVE_FEATURES:
return handleGiveFeatures(message);
default:
return false;
return Constants.NOT_HANDLED;
}
}
@@ -375,7 +378,8 @@ abstract class HdmiCecLocalDevice {
}
@ServiceThreadOnly
protected boolean handleGivePhysicalAddress(@Nullable SendMessageCallback callback) {
@Constants.HandleMessageResult
protected int handleGivePhysicalAddress(@Nullable SendMessageCallback callback) {
assertRunOnServiceThread();
int physicalAddress = mService.getPhysicalAddress();
@@ -383,76 +387,83 @@ abstract class HdmiCecLocalDevice {
HdmiCecMessageBuilder.buildReportPhysicalAddressCommand(
mAddress, physicalAddress, mDeviceType);
mService.sendCecCommand(cecMessage, callback);
return true;
return Constants.HANDLED;
}
@ServiceThreadOnly
protected boolean handleGiveDeviceVendorId(@Nullable SendMessageCallback callback) {
@Constants.HandleMessageResult
protected int handleGiveDeviceVendorId(@Nullable SendMessageCallback callback) {
assertRunOnServiceThread();
int vendorId = mService.getVendorId();
HdmiCecMessage cecMessage =
HdmiCecMessageBuilder.buildDeviceVendorIdCommand(mAddress, vendorId);
mService.sendCecCommand(cecMessage, callback);
return true;
return Constants.HANDLED;
}
@ServiceThreadOnly
protected boolean handleGetCecVersion(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleGetCecVersion(HdmiCecMessage message) {
assertRunOnServiceThread();
int version = mService.getCecVersion();
HdmiCecMessage cecMessage =
HdmiCecMessageBuilder.buildCecVersion(
message.getDestination(), message.getSource(), version);
mService.sendCecCommand(cecMessage);
return true;
return Constants.HANDLED;
}
@ServiceThreadOnly
private boolean handleCecVersion() {
@Constants.HandleMessageResult
protected int handleCecVersion() {
assertRunOnServiceThread();
// Return true to avoid <Feature Abort> responses. Cec Version is tracked in HdmiCecNetwork.
return true;
return Constants.HANDLED;
}
@ServiceThreadOnly
protected boolean handleActiveSource(HdmiCecMessage message) {
return false;
@Constants.HandleMessageResult
protected int handleActiveSource(HdmiCecMessage message) {
return Constants.NOT_HANDLED;
}
@ServiceThreadOnly
protected boolean handleInactiveSource(HdmiCecMessage message) {
return false;
@Constants.HandleMessageResult
protected int handleInactiveSource(HdmiCecMessage message) {
return Constants.NOT_HANDLED;
}
@ServiceThreadOnly
protected boolean handleRequestActiveSource(HdmiCecMessage message) {
return false;
@Constants.HandleMessageResult
protected int handleRequestActiveSource(HdmiCecMessage message) {
return Constants.NOT_HANDLED;
}
@ServiceThreadOnly
protected boolean handleGetMenuLanguage(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleGetMenuLanguage(HdmiCecMessage message) {
assertRunOnServiceThread();
Slog.w(TAG, "Only TV can handle <Get Menu Language>:" + message.toString());
// 'return false' will cause to reply with <Feature Abort>.
return false;
return Constants.NOT_HANDLED;
}
@ServiceThreadOnly
protected boolean handleSetMenuLanguage(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleSetMenuLanguage(HdmiCecMessage message) {
assertRunOnServiceThread();
Slog.w(TAG, "Only Playback device can handle <Set Menu Language>:" + message.toString());
// 'return false' will cause to reply with <Feature Abort>.
return false;
return Constants.NOT_HANDLED;
}
@ServiceThreadOnly
protected boolean handleGiveOsdName(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleGiveOsdName(HdmiCecMessage message) {
assertRunOnServiceThread();
// Note that since this method is called after logical address allocation is done,
// mDeviceInfo should not be null.
buildAndSendSetOsdName(message.getSource());
return true;
return Constants.HANDLED;
}
protected void buildAndSendSetOsdName(int dest) {
@@ -475,18 +486,21 @@ abstract class HdmiCecLocalDevice {
// Audio System device with no Playback device type
// needs to refactor this function if it's also a switch
protected boolean handleRoutingChange(HdmiCecMessage message) {
return false;
@Constants.HandleMessageResult
protected int handleRoutingChange(HdmiCecMessage message) {
return Constants.NOT_HANDLED;
}
// Audio System device with no Playback device type
// needs to refactor this function if it's also a switch
protected boolean handleRoutingInformation(HdmiCecMessage message) {
return false;
@Constants.HandleMessageResult
protected int handleRoutingInformation(HdmiCecMessage message) {
return Constants.NOT_HANDLED;
}
@CallSuper
protected boolean handleReportPhysicalAddress(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleReportPhysicalAddress(HdmiCecMessage message) {
// <Report Physical Address> is also handled in HdmiCecNetwork to update the local network
// state
@@ -495,7 +509,7 @@ abstract class HdmiCecLocalDevice {
// Ignore if [Device Discovery Action] is going on.
if (hasAction(DeviceDiscoveryAction.class)) {
Slog.i(TAG, "Ignored while Device Discovery Action is in progress: " + message);
return true;
return Constants.HANDLED;
}
HdmiDeviceInfo cecDeviceInfo = mService.getHdmiCecNetwork().getCecDeviceInfo(address);
@@ -506,63 +520,77 @@ abstract class HdmiCecLocalDevice {
HdmiCecMessageBuilder.buildGiveOsdNameCommand(mAddress, address));
}
return true;
return Constants.HANDLED;
}
protected boolean handleSystemAudioModeStatus(HdmiCecMessage message) {
return false;
@Constants.HandleMessageResult
protected int handleSystemAudioModeStatus(HdmiCecMessage message) {
return Constants.NOT_HANDLED;
}
protected boolean handleGiveSystemAudioModeStatus(HdmiCecMessage message) {
return false;
@Constants.HandleMessageResult
protected int handleGiveSystemAudioModeStatus(HdmiCecMessage message) {
return Constants.NOT_HANDLED;
}
protected boolean handleSetSystemAudioMode(HdmiCecMessage message) {
return false;
@Constants.HandleMessageResult
protected int handleSetSystemAudioMode(HdmiCecMessage message) {
return Constants.NOT_HANDLED;
}
protected boolean handleSystemAudioModeRequest(HdmiCecMessage message) {
return false;
@Constants.HandleMessageResult
protected int handleSystemAudioModeRequest(HdmiCecMessage message) {
return Constants.NOT_HANDLED;
}
protected boolean handleTerminateArc(HdmiCecMessage message) {
return false;
@Constants.HandleMessageResult
protected int handleTerminateArc(HdmiCecMessage message) {
return Constants.NOT_HANDLED;
}
protected boolean handleInitiateArc(HdmiCecMessage message) {
return false;
@Constants.HandleMessageResult
protected int handleInitiateArc(HdmiCecMessage message) {
return Constants.NOT_HANDLED;
}
protected boolean handleRequestArcInitiate(HdmiCecMessage message) {
return false;
@Constants.HandleMessageResult
protected int handleRequestArcInitiate(HdmiCecMessage message) {
return Constants.NOT_HANDLED;
}
protected boolean handleRequestArcTermination(HdmiCecMessage message) {
return false;
@Constants.HandleMessageResult
protected int handleRequestArcTermination(HdmiCecMessage message) {
return Constants.NOT_HANDLED;
}
protected boolean handleReportArcInitiate(HdmiCecMessage message) {
return false;
@Constants.HandleMessageResult
protected int handleReportArcInitiate(HdmiCecMessage message) {
return Constants.NOT_HANDLED;
}
protected boolean handleReportArcTermination(HdmiCecMessage message) {
return false;
@Constants.HandleMessageResult
protected int handleReportArcTermination(HdmiCecMessage message) {
return Constants.NOT_HANDLED;
}
protected boolean handleReportAudioStatus(HdmiCecMessage message) {
return false;
@Constants.HandleMessageResult
protected int handleReportAudioStatus(HdmiCecMessage message) {
return Constants.NOT_HANDLED;
}
protected boolean handleGiveAudioStatus(HdmiCecMessage message) {
return false;
@Constants.HandleMessageResult
protected int handleGiveAudioStatus(HdmiCecMessage message) {
return Constants.NOT_HANDLED;
}
protected boolean handleRequestShortAudioDescriptor(HdmiCecMessage message) {
return false;
@Constants.HandleMessageResult
protected int handleRequestShortAudioDescriptor(HdmiCecMessage message) {
return Constants.NOT_HANDLED;
}
protected boolean handleReportShortAudioDescriptor(HdmiCecMessage message) {
return false;
@Constants.HandleMessageResult
protected int handleReportShortAudioDescriptor(HdmiCecMessage message) {
return Constants.NOT_HANDLED;
}
@Constants.RcProfile
@@ -572,13 +600,14 @@ abstract class HdmiCecLocalDevice {
protected abstract List<Integer> getDeviceFeatures();
protected boolean handleGiveFeatures(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleGiveFeatures(HdmiCecMessage message) {
if (mService.getCecVersion() < HdmiControlManager.HDMI_CEC_VERSION_2_0) {
return false;
return Constants.ABORT_UNRECOGNIZED_OPCODE;
}
reportFeatures();
return true;
return Constants.HANDLED;
}
protected void reportFeatures() {
@@ -598,32 +627,34 @@ abstract class HdmiCecLocalDevice {
}
@ServiceThreadOnly
protected boolean handleStandby(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleStandby(HdmiCecMessage message) {
assertRunOnServiceThread();
// Seq #12
if (mService.isControlEnabled()
&& !mService.isProhibitMode()
&& mService.isPowerOnOrTransient()) {
mService.standby();
return true;
return Constants.HANDLED;
}
return false;
return Constants.ABORT_NOT_IN_CORRECT_MODE;
}
@ServiceThreadOnly
protected boolean handleUserControlPressed(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleUserControlPressed(HdmiCecMessage message) {
assertRunOnServiceThread();
mHandler.removeMessages(MSG_USER_CONTROL_RELEASE_TIMEOUT);
if (mService.isPowerOnOrTransient() && isPowerOffOrToggleCommand(message)) {
mService.standby();
return true;
return Constants.HANDLED;
} else if (mService.isPowerStandbyOrTransient() && isPowerOnOrToggleCommand(message)) {
mService.wakeUp();
return true;
return Constants.HANDLED;
} else if (mService.getHdmiCecVolumeControl()
== HdmiControlManager.VOLUME_CONTROL_DISABLED && isVolumeOrMuteCommand(
message)) {
return false;
return Constants.ABORT_REFUSED;
}
if (isPowerOffOrToggleCommand(message) || isPowerOnOrToggleCommand(message)) {
@@ -631,7 +662,7 @@ abstract class HdmiCecLocalDevice {
// keycode to Android keycode.
// Do not <Feature Abort> as the local device should already be in the correct power
// state.
return true;
return Constants.HANDLED;
}
final long downTime = SystemClock.uptimeMillis();
@@ -653,15 +684,15 @@ abstract class HdmiCecLocalDevice {
mHandler.sendMessageDelayed(
Message.obtain(mHandler, MSG_USER_CONTROL_RELEASE_TIMEOUT),
FOLLOWER_SAFETY_TIMEOUT);
return true;
return Constants.HANDLED;
}
mService.maySendFeatureAbortCommand(message, Constants.ABORT_INVALID_OPERAND);
return true;
return Constants.ABORT_INVALID_OPERAND;
}
@ServiceThreadOnly
protected boolean handleUserControlReleased() {
@Constants.HandleMessageResult
protected int handleUserControlReleased() {
assertRunOnServiceThread();
mHandler.removeMessages(MSG_USER_CONTROL_RELEASE_TIMEOUT);
mLastKeyRepeatCount = 0;
@@ -670,7 +701,7 @@ abstract class HdmiCecLocalDevice {
injectKeyEvent(upTime, KeyEvent.ACTION_UP, mLastKeycode, 0);
mLastKeycode = HdmiCecKeycode.UNSUPPORTED_KEYCODE;
}
return true;
return Constants.HANDLED;
}
static void injectKeyEvent(long time, int action, int keycode, int repeat) {
@@ -717,38 +748,45 @@ abstract class HdmiCecLocalDevice {
|| params[0] == HdmiCecKeycode.CEC_KEYCODE_RESTORE_VOLUME_FUNCTION);
}
protected boolean handleTextViewOn(HdmiCecMessage message) {
return false;
@Constants.HandleMessageResult
protected int handleTextViewOn(HdmiCecMessage message) {
return Constants.NOT_HANDLED;
}
protected boolean handleImageViewOn(HdmiCecMessage message) {
return false;
@Constants.HandleMessageResult
protected int handleImageViewOn(HdmiCecMessage message) {
return Constants.NOT_HANDLED;
}
protected boolean handleSetStreamPath(HdmiCecMessage message) {
return false;
@Constants.HandleMessageResult
protected int handleSetStreamPath(HdmiCecMessage message) {
return Constants.NOT_HANDLED;
}
protected boolean handleGiveDevicePowerStatus(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleGiveDevicePowerStatus(HdmiCecMessage message) {
mService.sendCecCommand(
HdmiCecMessageBuilder.buildReportPowerStatus(
mAddress, message.getSource(), mService.getPowerStatus()));
return true;
return Constants.HANDLED;
}
protected boolean handleMenuRequest(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleMenuRequest(HdmiCecMessage message) {
// Always report menu active to receive Remote Control.
mService.sendCecCommand(
HdmiCecMessageBuilder.buildReportMenuStatus(
mAddress, message.getSource(), Constants.MENU_STATE_ACTIVATED));
return true;
return Constants.HANDLED;
}
protected boolean handleMenuStatus(HdmiCecMessage message) {
return false;
@Constants.HandleMessageResult
protected int handleMenuStatus(HdmiCecMessage message) {
return Constants.NOT_HANDLED;
}
protected boolean handleVendorCommand(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleVendorCommand(HdmiCecMessage message) {
if (!mService.invokeVendorCommandListenersOnReceived(
mDeviceType,
message.getSource(),
@@ -757,57 +795,64 @@ abstract class HdmiCecLocalDevice {
false)) {
// Vendor command listener may not have been registered yet. Respond with
// <Feature Abort> [Refused] so that the sender can try again later.
mService.maySendFeatureAbortCommand(message, Constants.ABORT_REFUSED);
return Constants.ABORT_REFUSED;
}
return true;
return Constants.HANDLED;
}
protected boolean handleVendorCommandWithId(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleVendorCommandWithId(HdmiCecMessage message) {
byte[] params = message.getParams();
int vendorId = HdmiUtils.threeBytesToInt(params);
if (vendorId == mService.getVendorId()) {
if (!mService.invokeVendorCommandListenersOnReceived(
mDeviceType, message.getSource(), message.getDestination(), params, true)) {
mService.maySendFeatureAbortCommand(message, Constants.ABORT_REFUSED);
return Constants.ABORT_REFUSED;
}
} else if (message.getDestination() != Constants.ADDR_BROADCAST
&& message.getSource() != Constants.ADDR_UNREGISTERED) {
Slog.v(TAG, "Wrong direct vendor command. Replying with <Feature Abort>");
mService.maySendFeatureAbortCommand(message, Constants.ABORT_UNRECOGNIZED_OPCODE);
return Constants.ABORT_UNRECOGNIZED_OPCODE;
} else {
Slog.v(TAG, "Wrong broadcast vendor command. Ignoring");
}
return true;
return Constants.HANDLED;
}
protected void sendStandby(int deviceId) {
// Do nothing.
}
protected boolean handleSetOsdName(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleSetOsdName(HdmiCecMessage message) {
// <Set OSD name> is also handled in HdmiCecNetwork to update the local network state
return true;
return Constants.HANDLED;
}
protected boolean handleRecordTvScreen(HdmiCecMessage message) {
return false;
@Constants.HandleMessageResult
protected int handleRecordTvScreen(HdmiCecMessage message) {
return Constants.NOT_HANDLED;
}
protected boolean handleTimerClearedStatus(HdmiCecMessage message) {
return false;
@Constants.HandleMessageResult
protected int handleTimerClearedStatus(HdmiCecMessage message) {
return Constants.NOT_HANDLED;
}
protected boolean handleReportPowerStatus(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleReportPowerStatus(HdmiCecMessage message) {
// <Report Power Status> is also handled in HdmiCecNetwork to update the local network state
return true;
return Constants.HANDLED;
}
protected boolean handleTimerStatus(HdmiCecMessage message) {
return false;
@Constants.HandleMessageResult
protected int handleTimerStatus(HdmiCecMessage message) {
return Constants.NOT_HANDLED;
}
protected boolean handleRecordStatus(HdmiCecMessage message) {
return false;
@Constants.HandleMessageResult
protected int handleRecordStatus(HdmiCecMessage message) {
return Constants.NOT_HANDLED;
}
@ServiceThreadOnly

103
services/core/java/com/android/server/hdmi/HdmiCecLocalDeviceAudioSystem.java
View File

@@ -316,7 +316,8 @@ public class HdmiCecLocalDeviceAudioSystem extends HdmiCecLocalDeviceSource {
@Override
@ServiceThreadOnly
protected boolean handleActiveSource(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleActiveSource(HdmiCecMessage message) {
assertRunOnServiceThread();
int logicalAddress = message.getSource();
int physicalAddress = HdmiUtils.twoBytesToInt(message.getParams());
@@ -339,52 +340,56 @@ public class HdmiCecLocalDeviceAudioSystem extends HdmiCecLocalDeviceSource {
mDelayedMessageBuffer.removeActiveSource();
return super.handleActiveSource(message);
}
return true;
return Constants.HANDLED;
}
@Override
@ServiceThreadOnly
protected boolean handleInitiateArc(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleInitiateArc(HdmiCecMessage message) {
assertRunOnServiceThread();
// TODO(amyjojo): implement initiate arc handler
HdmiLogger.debug(TAG + "Stub handleInitiateArc");
return true;
return Constants.HANDLED;
}
@Override
@ServiceThreadOnly
protected boolean handleReportArcInitiate(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleReportArcInitiate(HdmiCecMessage message) {
assertRunOnServiceThread();
// TODO(amyjojo): implement report arc initiate handler
HdmiLogger.debug(TAG + "Stub handleReportArcInitiate");
return true;
return Constants.HANDLED;
}
@Override
@ServiceThreadOnly
protected boolean handleReportArcTermination(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleReportArcTermination(HdmiCecMessage message) {
assertRunOnServiceThread();
// TODO(amyjojo): implement report arc terminate handler
HdmiLogger.debug(TAG + "Stub handleReportArcTermination");
return true;
return Constants.HANDLED;
}
@Override
@ServiceThreadOnly
protected boolean handleGiveAudioStatus(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleGiveAudioStatus(HdmiCecMessage message) {
assertRunOnServiceThread();
if (isSystemAudioControlFeatureEnabled() && mService.getHdmiCecVolumeControl()
== HdmiControlManager.VOLUME_CONTROL_ENABLED) {
reportAudioStatus(message.getSource());
} else {
mService.maySendFeatureAbortCommand(message, Constants.ABORT_REFUSED);
return Constants.HANDLED;
}
return true;
return Constants.ABORT_REFUSED;
}
@Override
@ServiceThreadOnly
protected boolean handleGiveSystemAudioModeStatus(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleGiveSystemAudioModeStatus(HdmiCecMessage message) {
assertRunOnServiceThread();
// If the audio system is initiating the system audio mode on and TV asks the sam status at
// the same time, respond with true. Since we know TV supports sam in this situation.
@@ -399,52 +404,53 @@ public class HdmiCecLocalDeviceAudioSystem extends HdmiCecLocalDeviceSource {
mService.sendCecCommand(
HdmiCecMessageBuilder.buildReportSystemAudioMode(
mAddress, message.getSource(), isSystemAudioModeOnOrTurningOn));
return true;
return Constants.HANDLED;
}
@Override
@ServiceThreadOnly
protected boolean handleRequestArcInitiate(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleRequestArcInitiate(HdmiCecMessage message) {
assertRunOnServiceThread();
removeAction(ArcInitiationActionFromAvr.class);
if (!mService.readBooleanSystemProperty(Constants.PROPERTY_ARC_SUPPORT, true)) {
mService.maySendFeatureAbortCommand(message, Constants.ABORT_UNRECOGNIZED_OPCODE);
return Constants.ABORT_UNRECOGNIZED_OPCODE;
} else if (!isDirectConnectToTv()) {
HdmiLogger.debug("AVR device is not directly connected with TV");
mService.maySendFeatureAbortCommand(message, Constants.ABORT_NOT_IN_CORRECT_MODE);
return Constants.ABORT_NOT_IN_CORRECT_MODE;
} else {
addAndStartAction(new ArcInitiationActionFromAvr(this));
return Constants.HANDLED;
}
return true;
}
@Override
@ServiceThreadOnly
protected boolean handleRequestArcTermination(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleRequestArcTermination(HdmiCecMessage message) {
assertRunOnServiceThread();
if (!SystemProperties.getBoolean(Constants.PROPERTY_ARC_SUPPORT, true)) {
mService.maySendFeatureAbortCommand(message, Constants.ABORT_UNRECOGNIZED_OPCODE);
return Constants.ABORT_UNRECOGNIZED_OPCODE;
} else if (!isArcEnabled()) {
HdmiLogger.debug("ARC is not established between TV and AVR device");
mService.maySendFeatureAbortCommand(message, Constants.ABORT_NOT_IN_CORRECT_MODE);
return Constants.ABORT_NOT_IN_CORRECT_MODE;
} else {
removeAction(ArcTerminationActionFromAvr.class);
addAndStartAction(new ArcTerminationActionFromAvr(this));
return Constants.HANDLED;
}
return true;
}
@ServiceThreadOnly
protected boolean handleRequestShortAudioDescriptor(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleRequestShortAudioDescriptor(HdmiCecMessage message) {
assertRunOnServiceThread();
HdmiLogger.debug(TAG + "Stub handleRequestShortAudioDescriptor");
if (!isSystemAudioControlFeatureEnabled()) {
mService.maySendFeatureAbortCommand(message, Constants.ABORT_REFUSED);
return true;
return Constants.ABORT_REFUSED;
}
if (!isSystemAudioActivated()) {
mService.maySendFeatureAbortCommand(message, Constants.ABORT_NOT_IN_CORRECT_MODE);
return true;
return Constants.ABORT_NOT_IN_CORRECT_MODE;
}
List<DeviceConfig> config = null;
@@ -468,21 +474,20 @@ public class HdmiCecLocalDeviceAudioSystem extends HdmiCecLocalDeviceSource {
} else {
AudioDeviceInfo deviceInfo = getSystemAudioDeviceInfo();
if (deviceInfo == null) {
mService.maySendFeatureAbortCommand(message, Constants.ABORT_UNABLE_TO_DETERMINE);
return true;
return Constants.ABORT_UNABLE_TO_DETERMINE;
}
sadBytes = getSupportedShortAudioDescriptors(deviceInfo, audioFormatCodes);
}
if (sadBytes.length == 0) {
mService.maySendFeatureAbortCommand(message, Constants.ABORT_INVALID_OPERAND);
return Constants.ABORT_INVALID_OPERAND;
} else {
mService.sendCecCommand(
HdmiCecMessageBuilder.buildReportShortAudioDescriptor(
mAddress, message.getSource(), sadBytes));
return Constants.HANDLED;
}
return true;
}
private byte[] getSupportedShortAudioDescriptors(
@@ -624,7 +629,8 @@ public class HdmiCecLocalDeviceAudioSystem extends HdmiCecLocalDeviceSource {
@Override
@ServiceThreadOnly
protected boolean handleSystemAudioModeRequest(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleSystemAudioModeRequest(HdmiCecMessage message) {
assertRunOnServiceThread();
boolean systemAudioStatusOn = message.getParams().length != 0;
// Check if the request comes from a non-TV device.
@@ -632,8 +638,7 @@ public class HdmiCecLocalDeviceAudioSystem extends HdmiCecLocalDeviceSource {
// if non-TV device tries to turn on the feature
if (message.getSource() != Constants.ADDR_TV) {
if (systemAudioStatusOn) {
handleSystemAudioModeOnFromNonTvDevice(message);
return true;
return handleSystemAudioModeOnFromNonTvDevice(message);
}
} else {
// If TV request the feature on
@@ -644,8 +649,7 @@ public class HdmiCecLocalDeviceAudioSystem extends HdmiCecLocalDeviceSource {
// If TV or Audio System does not support the feature,
// will send abort command.
if (!checkSupportAndSetSystemAudioMode(systemAudioStatusOn)) {
mService.maySendFeatureAbortCommand(message, Constants.ABORT_REFUSED);
return true;
return Constants.ABORT_REFUSED;
}
mService.sendCecCommand(
@@ -660,7 +664,7 @@ public class HdmiCecLocalDeviceAudioSystem extends HdmiCecLocalDeviceSource {
if (HdmiUtils.getLocalPortFromPhysicalAddress(
sourcePhysicalAddress, getDeviceInfo().getPhysicalAddress())
!= HdmiUtils.TARGET_NOT_UNDER_LOCAL_DEVICE) {
return true;
return Constants.HANDLED;
}
HdmiDeviceInfo safeDeviceInfoByPath =
mService.getHdmiCecNetwork().getSafeDeviceInfoByPath(sourcePhysicalAddress);
@@ -668,29 +672,31 @@ public class HdmiCecLocalDeviceAudioSystem extends HdmiCecLocalDeviceSource {
switchInputOnReceivingNewActivePath(sourcePhysicalAddress);
}
}
return true;
return Constants.HANDLED;
}
@Override
@ServiceThreadOnly
protected boolean handleSetSystemAudioMode(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleSetSystemAudioMode(HdmiCecMessage message) {
assertRunOnServiceThread();
if (!checkSupportAndSetSystemAudioMode(
HdmiUtils.parseCommandParamSystemAudioStatus(message))) {
mService.maySendFeatureAbortCommand(message, Constants.ABORT_REFUSED);
return Constants.ABORT_REFUSED;
}
return true;
return Constants.HANDLED;
}
@Override
@ServiceThreadOnly
protected boolean handleSystemAudioModeStatus(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleSystemAudioModeStatus(HdmiCecMessage message) {
assertRunOnServiceThread();
if (!checkSupportAndSetSystemAudioMode(
HdmiUtils.parseCommandParamSystemAudioStatus(message))) {
mService.maySendFeatureAbortCommand(message, Constants.ABORT_REFUSED);
return Constants.ABORT_REFUSED;
}
return true;
return Constants.HANDLED;
}
@ServiceThreadOnly
@@ -948,13 +954,13 @@ public class HdmiCecLocalDeviceAudioSystem extends HdmiCecLocalDeviceSource {
/**
* Handler of System Audio Mode Request on from non TV device
*/
void handleSystemAudioModeOnFromNonTvDevice(HdmiCecMessage message) {
@Constants.HandleMessageResult
int handleSystemAudioModeOnFromNonTvDevice(HdmiCecMessage message) {
if (!isSystemAudioControlFeatureEnabled()) {
HdmiLogger.debug(
"Cannot turn on" + "system audio mode "
+ "because the System Audio Control feature is disabled.");
mService.maySendFeatureAbortCommand(message, Constants.ABORT_REFUSED);
return;
return Constants.ABORT_REFUSED;
}
// Wake up device
mService.wakeUp();
@@ -967,7 +973,7 @@ public class HdmiCecLocalDeviceAudioSystem extends HdmiCecLocalDeviceSource {
mService.sendCecCommand(
HdmiCecMessageBuilder.buildSetSystemAudioMode(
mAddress, Constants.ADDR_BROADCAST, true));
return;
return Constants.HANDLED;
}
// Check if TV supports System Audio Control.
// Handle broadcasting setSystemAudioMode on or aborting message on callback.
@@ -983,6 +989,7 @@ public class HdmiCecLocalDeviceAudioSystem extends HdmiCecLocalDeviceSource {
}
}
});
return Constants.HANDLED;
}
void setTvSystemAudioModeSupport(boolean supported) {

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

@@ -251,7 +251,8 @@ public class HdmiCecLocalDevicePlayback extends HdmiCecLocalDeviceSource {
}
@ServiceThreadOnly
protected boolean handleUserControlPressed(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleUserControlPressed(HdmiCecMessage message) {
assertRunOnServiceThread();
wakeUpIfActiveSource();
return super.handleUserControlPressed(message);
@@ -270,10 +271,11 @@ public class HdmiCecLocalDevicePlayback extends HdmiCecLocalDeviceSource {
}
@ServiceThreadOnly
protected boolean handleSetMenuLanguage(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleSetMenuLanguage(HdmiCecMessage message) {
assertRunOnServiceThread();
if (!SET_MENU_LANGUAGE) {
return false;
return Constants.ABORT_UNRECOGNIZED_OPCODE;
}
try {
@@ -283,7 +285,7 @@ public class HdmiCecLocalDevicePlayback extends HdmiCecLocalDeviceSource {
// Do not switch language if the new language is the same as the current one.
// This helps avoid accidental country variant switching from en_US to en_AU
// due to the limitation of CEC. See the warning below.
return true;
return Constants.HANDLED;
}
// Don't use Locale.getAvailableLocales() since it returns a locale
@@ -298,36 +300,38 @@ public class HdmiCecLocalDevicePlayback extends HdmiCecLocalDeviceSource {
// will always be mapped to en-AU among other variants like en-US, en-GB,
// an en-IN, which may not be the expected one.
LocalePicker.updateLocale(localeInfo.getLocale());
return true;
return Constants.HANDLED;
}
}
Slog.w(TAG, "Can't handle <Set Menu Language> of " + iso3Language);
return false;
return Constants.ABORT_INVALID_OPERAND;
} catch (UnsupportedEncodingException e) {
Slog.w(TAG, "Can't handle <Set Menu Language>", e);
return false;
return Constants.ABORT_INVALID_OPERAND;
}
}
@Override
protected boolean handleSetSystemAudioMode(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleSetSystemAudioMode(HdmiCecMessage message) {
// System Audio Mode only turns on/off when Audio System broadcasts on/off message.
// For device with type 4 and 5, it can set system audio mode on/off
// when there is another audio system device connected into the system first.
if (message.getDestination() != Constants.ADDR_BROADCAST
|| message.getSource() != Constants.ADDR_AUDIO_SYSTEM
|| mService.audioSystem() != null) {
return true;
return Constants.HANDLED;
}
boolean setSystemAudioModeOn = HdmiUtils.parseCommandParamSystemAudioStatus(message);
if (mService.isSystemAudioActivated() != setSystemAudioModeOn) {
mService.setSystemAudioActivated(setSystemAudioModeOn);
}
return true;
return Constants.HANDLED;
}
@Override
protected boolean handleSystemAudioModeStatus(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleSystemAudioModeStatus(HdmiCecMessage message) {
// Only directly addressed System Audio Mode Status message can change internal
// system audio mode status.
if (message.getDestination() == mAddress
@@ -337,25 +341,27 @@ public class HdmiCecLocalDevicePlayback extends HdmiCecLocalDeviceSource {
mService.setSystemAudioActivated(setSystemAudioModeOn);
}
}
return true;
return Constants.HANDLED;
}
@Override
@ServiceThreadOnly
protected boolean handleRoutingChange(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleRoutingChange(HdmiCecMessage message) {
assertRunOnServiceThread();
int physicalAddress = HdmiUtils.twoBytesToInt(message.getParams(), 2);
handleRoutingChangeAndInformation(physicalAddress, message);
return true;
return Constants.HANDLED;
}
@Override
@ServiceThreadOnly
protected boolean handleRoutingInformation(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleRoutingInformation(HdmiCecMessage message) {
assertRunOnServiceThread();
int physicalAddress = HdmiUtils.twoBytesToInt(message.getParams());
handleRoutingChangeAndInformation(physicalAddress, message);
return true;
return Constants.HANDLED;
}
@Override

31
services/core/java/com/android/server/hdmi/HdmiCecLocalDeviceSource.java
View File

@@ -203,7 +203,8 @@ abstract class HdmiCecLocalDeviceSource extends HdmiCecLocalDevice {
}
@ServiceThreadOnly
protected boolean handleActiveSource(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleActiveSource(HdmiCecMessage message) {
assertRunOnServiceThread();
int logicalAddress = message.getSource();
int physicalAddress = HdmiUtils.twoBytesToInt(message.getParams());
@@ -215,20 +216,22 @@ abstract class HdmiCecLocalDeviceSource extends HdmiCecLocalDevice {
if (isRoutingControlFeatureEnabled()) {
switchInputOnReceivingNewActivePath(physicalAddress);
}
return true;
return Constants.HANDLED;
}
@Override
@ServiceThreadOnly
protected boolean handleRequestActiveSource(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleRequestActiveSource(HdmiCecMessage message) {
assertRunOnServiceThread();
maySendActiveSource(message.getSource());
return true;
return Constants.HANDLED;
}
@Override
@ServiceThreadOnly
protected boolean handleSetStreamPath(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleSetStreamPath(HdmiCecMessage message) {
assertRunOnServiceThread();
int physicalAddress = HdmiUtils.twoBytesToInt(message.getParams());
// If current device is the target path, set to Active Source.
@@ -242,12 +245,13 @@ abstract class HdmiCecLocalDeviceSource extends HdmiCecLocalDevice {
setActiveSource(physicalAddress, "HdmiCecLocalDeviceSource#handleSetStreamPath()");
}
switchInputOnReceivingNewActivePath(physicalAddress);
return true;
return Constants.HANDLED;
}
@Override
@ServiceThreadOnly
protected boolean handleRoutingChange(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleRoutingChange(HdmiCecMessage message) {
assertRunOnServiceThread();
int physicalAddress = HdmiUtils.twoBytesToInt(message.getParams(), 2);
if (physicalAddress != mService.getPhysicalAddress() || !isActiveSource()) {
@@ -256,16 +260,16 @@ abstract class HdmiCecLocalDeviceSource extends HdmiCecLocalDevice {
setActiveSource(physicalAddress, "HdmiCecLocalDeviceSource#handleRoutingChange()");
}
if (!isRoutingControlFeatureEnabled()) {
mService.maySendFeatureAbortCommand(message, Constants.ABORT_REFUSED);
return true;
return Constants.ABORT_REFUSED;
}
handleRoutingChangeAndInformation(physicalAddress, message);
return true;
return Constants.HANDLED;
}
@Override
@ServiceThreadOnly
protected boolean handleRoutingInformation(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleRoutingInformation(HdmiCecMessage message) {
assertRunOnServiceThread();
int physicalAddress = HdmiUtils.twoBytesToInt(message.getParams());
if (physicalAddress != mService.getPhysicalAddress() || !isActiveSource()) {
@@ -274,11 +278,10 @@ abstract class HdmiCecLocalDeviceSource extends HdmiCecLocalDevice {
setActiveSource(physicalAddress, "HdmiCecLocalDeviceSource#handleRoutingInformation()");
}
if (!isRoutingControlFeatureEnabled()) {
mService.maySendFeatureAbortCommand(message, Constants.ABORT_REFUSED);
return true;
return Constants.ABORT_REFUSED;
}
handleRoutingChangeAndInformation(physicalAddress, message);
return true;
return Constants.HANDLED;
}
// Method to switch Input with the new Active Path.

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

@@ -47,6 +47,7 @@ import android.util.Slog;
import android.util.SparseBooleanArray;
import com.android.internal.annotations.GuardedBy;
import com.android.internal.annotations.VisibleForTesting;
import com.android.internal.util.IndentingPrintWriter;
import com.android.server.hdmi.DeviceDiscoveryAction.DeviceDiscoveryCallback;
import com.android.server.hdmi.HdmiAnnotations.ServiceThreadOnly;
@@ -210,11 +211,13 @@ final class HdmiCecLocalDeviceTv extends HdmiCecLocalDevice {
@Override
@ServiceThreadOnly
boolean dispatchMessage(HdmiCecMessage message) {
@VisibleForTesting
@Constants.HandleMessageResult
protected int dispatchMessage(HdmiCecMessage message) {
assertRunOnServiceThread();
if (mService.isPowerStandby() && !mService.isWakeUpMessageReceived()
&& mStandbyHandler.handleCommand(message)) {
return true;
return Constants.HANDLED;
}
return super.onMessage(message);
}
@@ -409,7 +412,8 @@ final class HdmiCecLocalDeviceTv extends HdmiCecLocalDevice {
@Override
@ServiceThreadOnly
protected boolean handleActiveSource(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleActiveSource(HdmiCecMessage message) {
assertRunOnServiceThread();
int logicalAddress = message.getSource();
int physicalAddress = HdmiUtils.twoBytesToInt(message.getParams());
@@ -429,21 +433,22 @@ final class HdmiCecLocalDeviceTv extends HdmiCecLocalDevice {
HdmiLogger.debug("Input not ready for device: %X; buffering the command", info.getId());
mDelayedMessageBuffer.add(message);
}
return true;
return Constants.HANDLED;
}
@Override
@ServiceThreadOnly
protected boolean handleInactiveSource(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleInactiveSource(HdmiCecMessage message) {
assertRunOnServiceThread();
// Seq #10
// Ignore <Inactive Source> from non-active source device.
if (getActiveSource().logicalAddress != message.getSource()) {
return true;
return Constants.HANDLED;
}
if (isProhibitMode()) {
return true;
return Constants.HANDLED;
}
int portId = getPrevPortId();
if (portId != Constants.INVALID_PORT_ID) {
@@ -452,10 +457,10 @@ final class HdmiCecLocalDeviceTv extends HdmiCecLocalDevice {
HdmiDeviceInfo inactiveSource = mService.getHdmiCecNetwork().getCecDeviceInfo(
message.getSource());
if (inactiveSource == null) {
return true;
return Constants.HANDLED;
}
if (mService.pathToPortId(inactiveSource.getPhysicalAddress()) == portId) {
return true;
return Constants.HANDLED;
}
// TODO: Switch the TV freeze mode off
@@ -468,29 +473,31 @@ final class HdmiCecLocalDeviceTv extends HdmiCecLocalDevice {
setActivePath(Constants.INVALID_PHYSICAL_ADDRESS);
mService.invokeInputChangeListener(HdmiDeviceInfo.INACTIVE_DEVICE);
}
return true;
return Constants.HANDLED;
}
@Override
@ServiceThreadOnly
protected boolean handleRequestActiveSource(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleRequestActiveSource(HdmiCecMessage message) {
assertRunOnServiceThread();
// Seq #19
if (mAddress == getActiveSource().logicalAddress) {
mService.sendCecCommand(
HdmiCecMessageBuilder.buildActiveSource(mAddress, getActivePath()));
}
return true;
return Constants.HANDLED;
}
@Override
@ServiceThreadOnly
protected boolean handleGetMenuLanguage(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleGetMenuLanguage(HdmiCecMessage message) {
assertRunOnServiceThread();
if (!broadcastMenuLanguage(mService.getLanguage())) {
Slog.w(TAG, "Failed to respond to <Get Menu Language>: " + message.toString());
}
return true;
return Constants.HANDLED;
}
@ServiceThreadOnly
@@ -506,7 +513,8 @@ final class HdmiCecLocalDeviceTv extends HdmiCecLocalDevice {
}
@Override
protected boolean handleReportPhysicalAddress(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleReportPhysicalAddress(HdmiCecMessage message) {
super.handleReportPhysicalAddress(message);
int path = HdmiUtils.twoBytesToInt(message.getParams());
int address = message.getSource();
@@ -516,19 +524,21 @@ final class HdmiCecLocalDeviceTv extends HdmiCecLocalDevice {
handleNewDeviceAtTheTailOfActivePath(path);
}
startNewDeviceAction(ActiveSource.of(address, path), type);
return true;
return Constants.HANDLED;
}
@Override
protected boolean handleTimerStatus(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleTimerStatus(HdmiCecMessage message) {
// Do nothing.
return true;
return Constants.HANDLED;
}
@Override
protected boolean handleRecordStatus(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleRecordStatus(HdmiCecMessage message) {
// Do nothing.
return true;
return Constants.HANDLED;
}
void startNewDeviceAction(ActiveSource activeSource, int deviceType) {
@@ -590,7 +600,8 @@ final class HdmiCecLocalDeviceTv extends HdmiCecLocalDevice {
@Override
@ServiceThreadOnly
protected boolean handleRoutingChange(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleRoutingChange(HdmiCecMessage message) {
assertRunOnServiceThread();
// Seq #21
byte[] params = message.getParams();
@@ -601,27 +612,29 @@ final class HdmiCecLocalDeviceTv extends HdmiCecLocalDevice {
int newPath = HdmiUtils.twoBytesToInt(params, 2);
addAndStartAction(new RoutingControlAction(this, newPath, true, null));
}
return true;
return Constants.HANDLED;
}
@Override
@ServiceThreadOnly
protected boolean handleReportAudioStatus(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleReportAudioStatus(HdmiCecMessage message) {
assertRunOnServiceThread();
if (mService.getHdmiCecVolumeControl()
== HdmiControlManager.VOLUME_CONTROL_DISABLED) {
return false;
return Constants.ABORT_REFUSED;
}
boolean mute = HdmiUtils.isAudioStatusMute(message);
int volume = HdmiUtils.getAudioStatusVolume(message);
setAudioStatus(mute, volume);
return true;
return Constants.HANDLED;
}
@Override
@ServiceThreadOnly
protected boolean handleTextViewOn(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleTextViewOn(HdmiCecMessage message) {
assertRunOnServiceThread();
// Note that <Text View On> (and <Image View On>) command won't be handled here in
@@ -634,12 +647,13 @@ final class HdmiCecLocalDeviceTv extends HdmiCecLocalDevice {
if (mService.isPowerStandbyOrTransient() && getAutoWakeup()) {
mService.wakeUp();
}
return true;
return Constants.HANDLED;
}
@Override
@ServiceThreadOnly
protected boolean handleImageViewOn(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleImageViewOn(HdmiCecMessage message) {
assertRunOnServiceThread();
// Currently, it's the same as <Text View On>.
return handleTextViewOn(message);
@@ -977,7 +991,8 @@ final class HdmiCecLocalDeviceTv extends HdmiCecLocalDevice {
@Override
@ServiceThreadOnly
protected boolean handleInitiateArc(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleInitiateArc(HdmiCecMessage message) {
assertRunOnServiceThread();
if (!canStartArcUpdateAction(message.getSource(), true)) {
@@ -985,13 +1000,12 @@ final class HdmiCecLocalDeviceTv extends HdmiCecLocalDevice {
if (avrDeviceInfo == null) {
// AVR may not have been discovered yet. Delay the message processing.
mDelayedMessageBuffer.add(message);
return true;
return Constants.HANDLED;
}
mService.maySendFeatureAbortCommand(message, Constants.ABORT_REFUSED);
if (!isConnectedToArcPort(avrDeviceInfo.getPhysicalAddress())) {
displayOsd(OSD_MESSAGE_ARC_CONNECTED_INVALID_PORT);
}
return true;
return Constants.ABORT_REFUSED;
}
// In case where <Initiate Arc> is started by <Request ARC Initiation>
@@ -1000,7 +1014,7 @@ final class HdmiCecLocalDeviceTv extends HdmiCecLocalDevice {
SetArcTransmissionStateAction action = new SetArcTransmissionStateAction(this,
message.getSource(), true);
addAndStartAction(action);
return true;
return Constants.HANDLED;
}
private boolean canStartArcUpdateAction(int avrAddress, boolean enabled) {
@@ -1022,11 +1036,12 @@ final class HdmiCecLocalDeviceTv extends HdmiCecLocalDevice {
@Override
@ServiceThreadOnly
protected boolean handleTerminateArc(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleTerminateArc(HdmiCecMessage message) {
assertRunOnServiceThread();
if (mService .isPowerStandbyOrTransient()) {
setArcStatus(false);
return true;
return Constants.HANDLED;
}
// Do not check ARC configuration since the AVR might have been already removed.
// Clean up RequestArcTerminationAction in case <Terminate Arc> was started by
@@ -1035,12 +1050,13 @@ final class HdmiCecLocalDeviceTv extends HdmiCecLocalDevice {
SetArcTransmissionStateAction action = new SetArcTransmissionStateAction(this,
message.getSource(), false);
addAndStartAction(action);
return true;
return Constants.HANDLED;
}
@Override
@ServiceThreadOnly
protected boolean handleSetSystemAudioMode(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleSetSystemAudioMode(HdmiCecMessage message) {
assertRunOnServiceThread();
boolean systemAudioStatus = HdmiUtils.parseCommandParamSystemAudioStatus(message);
if (!isMessageForSystemAudio(message)) {
@@ -1049,30 +1065,29 @@ final class HdmiCecLocalDeviceTv extends HdmiCecLocalDevice {
mDelayedMessageBuffer.add(message);
} else {
HdmiLogger.warning("Invalid <Set System Audio Mode> message:" + message);
mService.maySendFeatureAbortCommand(message, Constants.ABORT_REFUSED);
return Constants.ABORT_REFUSED;
}
return true;
} else if (systemAudioStatus && !isSystemAudioControlFeatureEnabled()) {
HdmiLogger.debug("Ignoring <Set System Audio Mode> message "
+ "because the System Audio Control feature is disabled: %s", message);
mService.maySendFeatureAbortCommand(message, Constants.ABORT_REFUSED);
return true;
return Constants.ABORT_REFUSED;
}
removeAction(SystemAudioAutoInitiationAction.class);
SystemAudioActionFromAvr action = new SystemAudioActionFromAvr(this,
message.getSource(), systemAudioStatus, null);
addAndStartAction(action);
return true;
return Constants.HANDLED;
}
@Override
@ServiceThreadOnly
protected boolean handleSystemAudioModeStatus(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleSystemAudioModeStatus(HdmiCecMessage message) {
assertRunOnServiceThread();
if (!isMessageForSystemAudio(message)) {
HdmiLogger.warning("Invalid <System Audio Mode Status> message:" + message);
// Ignore this message.
return true;
return Constants.HANDLED;
}
boolean tvSystemAudioMode = isSystemAudioControlFeatureEnabled();
boolean avrSystemAudioMode = HdmiUtils.parseCommandParamSystemAudioStatus(message);
@@ -1089,13 +1104,14 @@ final class HdmiCecLocalDeviceTv extends HdmiCecLocalDevice {
setSystemAudioMode(tvSystemAudioMode);
}
return true;
return Constants.HANDLED;
}
// Seq #53
@Override
@ServiceThreadOnly
protected boolean handleRecordTvScreen(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleRecordTvScreen(HdmiCecMessage message) {
List<OneTouchRecordAction> actions = getActions(OneTouchRecordAction.class);
if (!actions.isEmpty()) {
// Assumes only one OneTouchRecordAction.
@@ -1107,25 +1123,21 @@ final class HdmiCecLocalDeviceTv extends HdmiCecLocalDevice {
}
// The default behavior of <Record TV Screen> is replying <Feature Abort> with
// "Cannot provide source".
mService.maySendFeatureAbortCommand(message, Constants.ABORT_CANNOT_PROVIDE_SOURCE);
return true;
return Constants.ABORT_CANNOT_PROVIDE_SOURCE;
}
int recorderAddress = message.getSource();
byte[] recordSource = mService.invokeRecordRequestListener(recorderAddress);
int reason = startOneTouchRecord(recorderAddress, recordSource);
if (reason != Constants.ABORT_NO_ERROR) {
mService.maySendFeatureAbortCommand(message, reason);
}
return true;
return startOneTouchRecord(recorderAddress, recordSource);
}
@Override
protected boolean handleTimerClearedStatus(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleTimerClearedStatus(HdmiCecMessage message) {
byte[] params = message.getParams();
int timerClearedStatusData = params[0] & 0xFF;
announceTimerRecordingResult(message.getSource(), timerClearedStatusData);
return true;
return Constants.HANDLED;
}
void announceOneTouchRecordResult(int recorderAddress, int result) {
@@ -1337,6 +1349,7 @@ final class HdmiCecLocalDeviceTv extends HdmiCecLocalDevice {
// Seq #54 and #55
@ServiceThreadOnly
@Constants.HandleMessageResult
int startOneTouchRecord(int recorderAddress, byte[] recordSource) {
assertRunOnServiceThread();
if (!mService.isControlEnabled()) {
@@ -1362,7 +1375,7 @@ final class HdmiCecLocalDeviceTv extends HdmiCecLocalDevice {
addAndStartAction(new OneTouchRecordAction(this, recorderAddress, recordSource));
Slog.i(TAG, "Start new [One Touch Record]-Target:" + recorderAddress + ", recordSource:"
+ Arrays.toString(recordSource));
return Constants.ABORT_NO_ERROR;
return Constants.HANDLED;
}
@ServiceThreadOnly
@@ -1494,9 +1507,10 @@ final class HdmiCecLocalDeviceTv extends HdmiCecLocalDevice {
}
@Override
protected boolean handleMenuStatus(HdmiCecMessage message) {
@Constants.HandleMessageResult
protected int handleMenuStatus(HdmiCecMessage message) {
// Do nothing and just return true not to prevent from responding <Feature Abort>.
return true;
return Constants.HANDLED;
}
@Constants.RcProfile

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

@@ -372,8 +372,7 @@ public class HdmiControlService extends SystemService {
private HdmiCecMessageValidator mMessageValidator;
private final HdmiCecPowerStatusController mPowerStatusController =
new HdmiCecPowerStatusController(this);
private HdmiCecPowerStatusController mPowerStatusController;
@ServiceThreadOnly
private String mMenuLanguage = localeToMenuLanguage(Locale.getDefault());
@@ -427,7 +426,7 @@ public class HdmiControlService extends SystemService {
// Use getAtomWriter() instead of accessing directly, to allow dependency injection for testing.
private HdmiCecAtomWriter mAtomWriter = new HdmiCecAtomWriter();
private CecMessageBuffer mCecMessageBuffer = new CecMessageBuffer(this);
private CecMessageBuffer mCecMessageBuffer;
private final SelectRequestBuffer mSelectRequestBuffer = new SelectRequestBuffer();
@@ -493,6 +492,9 @@ public class HdmiControlService extends SystemService {
mIoLooper = mIoThread.getLooper();
}
if (mPowerStatusController == null) {
mPowerStatusController = new HdmiCecPowerStatusController(this);
}
mPowerStatusController.setPowerStatus(getInitialPowerStatus());
mProhibitMode = false;
mHdmiControlEnabled = mHdmiCecConfig.getIntValue(
@@ -501,6 +503,9 @@ public class HdmiControlService extends SystemService {
HdmiControlManager.CEC_SETTING_NAME_VOLUME_CONTROL_MODE));
mMhlInputChangeEnabled = readBooleanSetting(Global.MHL_INPUT_SWITCHING_ENABLED, true);
if (mCecMessageBuffer == null) {
mCecMessageBuffer = new CecMessageBuffer(this);
}
if (mCecController == null) {
mCecController = HdmiCecController.create(this, getAtomWriter());
}
@@ -948,11 +953,10 @@ public class HdmiControlService extends SystemService {
/**
* Returns {@link Looper} for IO operation.
*
* <p>Declared as package-private.
*/
@Nullable
Looper getIoLooper() {
@VisibleForTesting
protected Looper getIoLooper() {
return mIoLooper;
}
@@ -974,10 +978,9 @@ public class HdmiControlService extends SystemService {
/**
* Returns {@link Looper} of main thread. Use this {@link Looper} instance
* for tasks that are running on main service thread.
*
* <p>Declared as package-private.
*/
Looper getServiceLooper() {
@VisibleForTesting
protected Looper getServiceLooper() {
return mHandler.getLooper();
}
@@ -1015,8 +1018,9 @@ public class HdmiControlService extends SystemService {
/**
* Returns version of CEC.
*/
@VisibleForTesting
@HdmiControlManager.HdmiCecVersion
int getCecVersion() {
protected int getCecVersion() {
return mCecVersion;
}
@@ -1087,23 +1091,30 @@ public class HdmiControlService extends SystemService {
}
@ServiceThreadOnly
boolean handleCecCommand(HdmiCecMessage message) {
@VisibleForTesting
@Constants.HandleMessageResult
protected int handleCecCommand(HdmiCecMessage message) {
assertRunOnServiceThread();
int errorCode = mMessageValidator.isValid(message);
if (errorCode != HdmiCecMessageValidator.OK) {
// We'll not response on the messages with the invalid source or destination
// or with parameter length shorter than specified in the standard.
if (errorCode == HdmiCecMessageValidator.ERROR_PARAMETER) {
maySendFeatureAbortCommand(message, Constants.ABORT_INVALID_OPERAND);
return Constants.ABORT_INVALID_OPERAND;
}
return true;
return Constants.HANDLED;
}
getHdmiCecNetwork().handleCecMessage(message);
if (dispatchMessageToLocalDevice(message)) {
return true;
@Constants.HandleMessageResult int handleMessageResult =
dispatchMessageToLocalDevice(message);
if (handleMessageResult == Constants.NOT_HANDLED
&& !mAddressAllocated
&& mCecMessageBuffer.bufferMessage(message)) {
return Constants.HANDLED;
}
return (!mAddressAllocated) ? mCecMessageBuffer.bufferMessage(message) : false;
return handleMessageResult;
}
void enableAudioReturnChannel(int portId, boolean enabled) {
@@ -1111,19 +1122,25 @@ public class HdmiControlService extends SystemService {
}
@ServiceThreadOnly
private boolean dispatchMessageToLocalDevice(HdmiCecMessage message) {
@VisibleForTesting
@Constants.HandleMessageResult
protected int dispatchMessageToLocalDevice(HdmiCecMessage message) {
assertRunOnServiceThread();
for (HdmiCecLocalDevice device : mHdmiCecNetwork.getLocalDeviceList()) {
if (device.dispatchMessage(message)
@Constants.HandleMessageResult int messageResult = device.dispatchMessage(message);
if (messageResult != Constants.NOT_HANDLED
&& message.getDestination() != Constants.ADDR_BROADCAST) {
return true;
return messageResult;
}
}
if (message.getDestination() != Constants.ADDR_BROADCAST) {
// We should never respond <Feature Abort> to a broadcast message
if (message.getDestination() == Constants.ADDR_BROADCAST) {
return Constants.HANDLED;
} else {
HdmiLogger.warning("Unhandled cec command:" + message);
return Constants.NOT_HANDLED;
}
return false;
}
/**
@@ -2970,7 +2987,7 @@ public class HdmiControlService extends SystemService {
}
@VisibleForTesting
boolean isStandbyMessageReceived() {
protected boolean isStandbyMessageReceived() {
return mStandbyMessageReceived;
}

2
services/tests/servicestests/src/com/android/server/hdmi/ArcInitiationActionFromAvrTest.java
View File

@@ -107,7 +107,7 @@ public class ArcInitiationActionFromAvrTest {
}
@Override
Looper getServiceLooper() {
protected Looper getServiceLooper() {
return mTestLooper.getLooper();
}
};

2
services/tests/servicestests/src/com/android/server/hdmi/ArcTerminationActionFromAvrTest.java
View File

@@ -108,7 +108,7 @@ public class ArcTerminationActionFromAvrTest {
}
@Override
Looper getServiceLooper() {
protected Looper getServiceLooper() {
return mTestLooper.getLooper();
}
};

2
services/tests/servicestests/src/com/android/server/hdmi/DetectTvSystemAudioModeSupportActionTest.java
View File

@@ -91,7 +91,7 @@ public class DetectTvSystemAudioModeSupportActionTest {
}
@Override
Looper getServiceLooper() {
protected Looper getServiceLooper() {
return mTestLooper.getLooper();
}
};

162
services/tests/servicestests/src/com/android/server/hdmi/HdmiCecControllerTest.java
View File

@@ -19,21 +19,35 @@ import static android.hardware.hdmi.HdmiDeviceInfo.DEVICE_AUDIO_SYSTEM;
import static android.hardware.hdmi.HdmiDeviceInfo.DEVICE_PLAYBACK;
import static android.hardware.hdmi.HdmiDeviceInfo.DEVICE_TV;
import static com.android.server.hdmi.Constants.ABORT_REFUSED;
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_BACKUP_1;
import static com.android.server.hdmi.Constants.ADDR_BACKUP_2;
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_PLAYBACK_3;
import static com.android.server.hdmi.Constants.ADDR_SPECIFIC_USE;
import static com.android.server.hdmi.Constants.ADDR_TV;
import static com.android.server.hdmi.Constants.ADDR_UNREGISTERED;
import static com.android.server.hdmi.Constants.HANDLED;
import static com.android.server.hdmi.Constants.MESSAGE_STANDBY;
import static com.android.server.hdmi.Constants.NOT_HANDLED;
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;
import android.content.Context;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.spy;
import android.hardware.hdmi.HdmiControlManager;
import android.hardware.tv.cec.V1_0.SendMessageResult;
import android.os.Binder;
@@ -44,6 +58,7 @@ import android.platform.test.annotations.Presubmit;
import androidx.test.InstrumentationRegistry;
import androidx.test.filters.SmallTest;
import com.android.server.SystemService;
import com.android.server.hdmi.HdmiCecController.AllocateAddressCallback;
import junit.framework.TestCase;
@@ -53,6 +68,7 @@ import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
import java.util.ArrayList;
import java.util.Optional;
/** Tests for {@link com.android.server.hdmi.HdmiCecController} class. */
@@ -63,27 +79,7 @@ public class HdmiCecControllerTest {
private FakeNativeWrapper mNativeWrapper;
private class MyHdmiControlService extends HdmiControlService {
MyHdmiControlService(Context context) {
super(context);
}
@Override
Looper getIoLooper() {
return mMyLooper;
}
@Override
Looper getServiceLooper() {
return mMyLooper;
}
@Override
int getCecVersion() {
return mCecVersion;
}
}
private HdmiControlService mHdmiControlServiceSpy;
private HdmiCecController mHdmiCecController;
private int mCecVersion = HdmiControlManager.HDMI_CEC_VERSION_1_4_B;
@@ -101,12 +97,39 @@ public class HdmiCecControllerTest {
@Before
public void SetUp() {
mMyLooper = mTestLooper.getLooper();
mMyLooper = mTestLooper.getLooper();
HdmiControlService hdmiControlService = new MyHdmiControlService(
InstrumentationRegistry.getTargetContext());
mHdmiControlServiceSpy = spy(new HdmiControlService(
InstrumentationRegistry.getTargetContext()));
doReturn(mMyLooper).when(mHdmiControlServiceSpy).getIoLooper();
doReturn(mMyLooper).when(mHdmiControlServiceSpy).getServiceLooper();
doAnswer(__ -> mCecVersion).when(mHdmiControlServiceSpy).getCecVersion();
doNothing().when(mHdmiControlServiceSpy)
.writeStringSystemProperty(anyString(), anyString());
mNativeWrapper = new FakeNativeWrapper();
mHdmiCecController = HdmiCecController.createWithNativeWrapper(
hdmiControlService, mNativeWrapper, hdmiControlService.getAtomWriter());
mHdmiControlServiceSpy, mNativeWrapper, mHdmiControlServiceSpy.getAtomWriter());
}
/** Additional setup for tests for onMessage
* Adds a local playback device and allocates addresses
*/
public void setUpForOnMessageTest() {
mHdmiControlServiceSpy.setCecController(mHdmiCecController);
HdmiCecLocalDevicePlayback playbackDevice =
new HdmiCecLocalDevicePlayback(mHdmiControlServiceSpy);
playbackDevice.init();
ArrayList<HdmiCecLocalDevice> localDevices = new ArrayList<>();
localDevices.add(playbackDevice);
mHdmiControlServiceSpy.initService();
mHdmiControlServiceSpy.allocateLogicalAddress(localDevices,
HdmiControlService.INITIATED_BY_ENABLE_CEC);
mHdmiControlServiceSpy.onBootPhase(SystemService.PHASE_SYSTEM_SERVICES_READY);
mTestLooper.dispatchAll();
}
/** Tests for {@link HdmiCecController#allocateLogicalAddress} */
@@ -119,7 +142,6 @@ public class HdmiCecControllerTest {
@Test
public void testAllocateLogicalAddress_TvDeviceNonPreferredNotOccupied() {
mHdmiCecController.allocateLogicalAddress(DEVICE_TV, ADDR_UNREGISTERED, mCallback);
mTestLooper.dispatchAll();
assertEquals(ADDR_TV, mLogicalAddress);
@@ -308,4 +330,90 @@ public class HdmiCecControllerTest {
TestCase.assertEquals(Optional.of(callerUid), uidReadingRunnable.getWorkSourceUid());
TestCase.assertEquals(runnerUid, Binder.getCallingWorkSourceUid());
}
@Test
public void onMessage_broadcastMessage_doesNotSendFeatureAbort() {
setUpForOnMessageTest();
doReturn(ABORT_UNRECOGNIZED_OPCODE).when(mHdmiControlServiceSpy).handleCecCommand(any());
HdmiCecMessage receivedMessage = HdmiCecMessageBuilder.buildStandby(
ADDR_TV, ADDR_BROADCAST);
mNativeWrapper.onCecMessage(receivedMessage);
mTestLooper.dispatchAll();
assertFalse("No <Feature Abort> messages should be sent",
mNativeWrapper.getResultMessages().stream().anyMatch(
message -> message.getOpcode() == Constants.MESSAGE_FEATURE_ABORT));
}
@Test
public void onMessage_notTheDestination_doesNotSendFeatureAbort() {
setUpForOnMessageTest();
doReturn(ABORT_UNRECOGNIZED_OPCODE).when(mHdmiControlServiceSpy).handleCecCommand(any());
HdmiCecMessage receivedMessage = HdmiCecMessageBuilder.buildStandby(
ADDR_TV, ADDR_AUDIO_SYSTEM);
mNativeWrapper.onCecMessage(receivedMessage);
mTestLooper.dispatchAll();
assertFalse("No <Feature Abort> messages should be sent",
mNativeWrapper.getResultMessages().stream().anyMatch(
message -> message.getOpcode() == Constants.MESSAGE_FEATURE_ABORT));
}
@Test
public void onMessage_handledMessage_doesNotSendFeatureAbort() {
setUpForOnMessageTest();
doReturn(HANDLED).when(mHdmiControlServiceSpy).handleCecCommand(any());
HdmiCecMessage receivedMessage = HdmiCecMessageBuilder.buildStandby(
ADDR_TV, ADDR_PLAYBACK_1);
mNativeWrapper.onCecMessage(receivedMessage);
mTestLooper.dispatchAll();
assertFalse("No <Feature Abort> messages should be sent",
mNativeWrapper.getResultMessages().stream().anyMatch(
message -> message.getOpcode() == Constants.MESSAGE_FEATURE_ABORT));
}
@Test
public void onMessage_unhandledMessage_sendsFeatureAbortUnrecognizedOpcode() {
setUpForOnMessageTest();
doReturn(NOT_HANDLED).when(mHdmiControlServiceSpy).handleCecCommand(any());
HdmiCecMessage receivedMessage = HdmiCecMessageBuilder.buildStandby(
ADDR_TV, ADDR_PLAYBACK_1);
mNativeWrapper.onCecMessage(receivedMessage);
mTestLooper.dispatchAll();
HdmiCecMessage featureAbort = HdmiCecMessageBuilder.buildFeatureAbortCommand(
DEVICE_PLAYBACK, DEVICE_TV, MESSAGE_STANDBY, ABORT_UNRECOGNIZED_OPCODE);
assertThat(mNativeWrapper.getResultMessages()).contains(featureAbort);
}
@Test
public void onMessage_sendsFeatureAbortWithRequestedOperand() {
setUpForOnMessageTest();
doReturn(ABORT_REFUSED).when(mHdmiControlServiceSpy).handleCecCommand(any());
HdmiCecMessage receivedMessage = HdmiCecMessageBuilder.buildStandby(
ADDR_TV, ADDR_PLAYBACK_1);
mNativeWrapper.onCecMessage(receivedMessage);
mTestLooper.dispatchAll();
HdmiCecMessage featureAbort = HdmiCecMessageBuilder.buildFeatureAbortCommand(
DEVICE_PLAYBACK, DEVICE_TV, MESSAGE_STANDBY, ABORT_REFUSED);
assertThat(mNativeWrapper.getResultMessages()).contains(featureAbort);
}
}

116
services/tests/servicestests/src/com/android/server/hdmi/HdmiCecLocalDeviceAudioSystemTest.java
View File

@@ -20,7 +20,6 @@ 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_TUNER_1;
import static com.android.server.hdmi.Constants.ADDR_TV;
import static com.android.server.hdmi.Constants.MESSAGE_GIVE_AUDIO_STATUS;
import static com.android.server.hdmi.HdmiControlService.INITIATED_BY_ENABLE_CEC;
import static com.android.server.hdmi.HdmiControlService.STANDBY_SCREEN_OFF;
@@ -248,7 +247,8 @@ public class HdmiCecLocalDeviceAudioSystemTest {
ADDR_AUDIO_SYSTEM, ADDR_TV, scaledVolume, true);
HdmiCecMessage messageGive =
HdmiCecMessageBuilder.buildGiveAudioStatus(ADDR_TV, ADDR_AUDIO_SYSTEM);
assertThat(mHdmiCecLocalDeviceAudioSystem.handleGiveAudioStatus(messageGive)).isTrue();
assertThat(mHdmiCecLocalDeviceAudioSystem.handleGiveAudioStatus(messageGive))
.isEqualTo(Constants.HANDLED);
mTestLooper.dispatchAll();
assertThat(mNativeWrapper.getOnlyResultMessage()).isEqualTo(expectedMessage);
}
@@ -262,45 +262,25 @@ public class HdmiCecLocalDeviceAudioSystemTest {
HdmiCecMessage messageGive =
HdmiCecMessageBuilder.buildGiveSystemAudioModeStatus(ADDR_TV, ADDR_AUDIO_SYSTEM);
assertThat(mHdmiCecLocalDeviceAudioSystem.handleGiveSystemAudioModeStatus(messageGive))
.isTrue();
.isEqualTo(Constants.HANDLED);
mTestLooper.dispatchAll();
assertThat(mNativeWrapper.getOnlyResultMessage()).isEqualTo(expectedMessage);
}
@Test
public void handleRequestShortAudioDescriptor_featureDisabled() throws Exception {
HdmiCecMessage expectedMessage =
HdmiCecMessageBuilder.buildFeatureAbortCommand(
ADDR_AUDIO_SYSTEM,
ADDR_TV,
Constants.MESSAGE_REQUEST_SHORT_AUDIO_DESCRIPTOR,
Constants.ABORT_REFUSED);
mHdmiCecLocalDeviceAudioSystem.setSystemAudioControlFeatureEnabled(false);
assertThat(
mHdmiCecLocalDeviceAudioSystem.handleRequestShortAudioDescriptor(
assertThat(mHdmiCecLocalDeviceAudioSystem.handleRequestShortAudioDescriptor(
MESSAGE_REQUEST_SAD_LCPM))
.isTrue();
mTestLooper.dispatchAll();
assertThat(mNativeWrapper.getOnlyResultMessage()).isEqualTo(expectedMessage);
.isEqualTo(Constants.ABORT_REFUSED);
}
@Test
public void handleRequestShortAudioDescriptor_samOff() throws Exception {
HdmiCecMessage expectedMessage =
HdmiCecMessageBuilder.buildFeatureAbortCommand(
ADDR_AUDIO_SYSTEM,
ADDR_TV,
Constants.MESSAGE_REQUEST_SHORT_AUDIO_DESCRIPTOR,
Constants.ABORT_NOT_IN_CORRECT_MODE);
mHdmiCecLocalDeviceAudioSystem.checkSupportAndSetSystemAudioMode(false);
assertThat(
mHdmiCecLocalDeviceAudioSystem.handleRequestShortAudioDescriptor(
assertThat(mHdmiCecLocalDeviceAudioSystem.handleRequestShortAudioDescriptor(
MESSAGE_REQUEST_SAD_LCPM))
.isEqualTo(true);
mTestLooper.dispatchAll();
assertThat(mNativeWrapper.getOnlyResultMessage()).isEqualTo(expectedMessage);
.isEqualTo(Constants.ABORT_NOT_IN_CORRECT_MODE);
}
// Testing device has sadConfig.xml
@@ -315,10 +295,9 @@ public class HdmiCecLocalDeviceAudioSystemTest {
Constants.ABORT_UNABLE_TO_DETERMINE);
mHdmiCecLocalDeviceAudioSystem.checkSupportAndSetSystemAudioMode(true);
assertThat(
mHdmiCecLocalDeviceAudioSystem.handleRequestShortAudioDescriptor(
assertThat(mHdmiCecLocalDeviceAudioSystem.handleRequestShortAudioDescriptor(
MESSAGE_REQUEST_SAD_LCPM))
.isEqualTo(true);
.isEqualTo(Constants.HANDLED);
mTestLooper.dispatchAll();
assertThat(mNativeWrapper.getOnlyResultMessage()).isEqualTo(expectedMessage);
}
@@ -335,17 +314,18 @@ public class HdmiCecLocalDeviceAudioSystemTest {
HdmiCecMessage expectedMessage =
HdmiCecMessageBuilder.buildReportSystemAudioMode(ADDR_AUDIO_SYSTEM, ADDR_TV, false);
assertThat(mHdmiCecLocalDeviceAudioSystem.handleGiveSystemAudioModeStatus(messageGive))
.isTrue();
.isEqualTo(Constants.HANDLED);
mTestLooper.dispatchAll();
assertThat(mNativeWrapper.getOnlyResultMessage()).isEqualTo(expectedMessage);
// Check if correctly turned on
mNativeWrapper.clearResultMessages();
expectedMessage =
HdmiCecMessageBuilder.buildReportSystemAudioMode(ADDR_AUDIO_SYSTEM, ADDR_TV, true);
assertThat(mHdmiCecLocalDeviceAudioSystem.handleSetSystemAudioMode(messageSet)).isTrue();
assertThat(mHdmiCecLocalDeviceAudioSystem.handleSetSystemAudioMode(messageSet))
.isEqualTo(Constants.HANDLED);
mTestLooper.dispatchAll();
assertThat(mHdmiCecLocalDeviceAudioSystem.handleGiveSystemAudioModeStatus(messageGive))
.isTrue();
.isEqualTo(Constants.HANDLED);
mTestLooper.dispatchAll();
assertThat(mNativeWrapper.getOnlyResultMessage()).isEqualTo(expectedMessage);
assertThat(mMusicMute).isFalse();
@@ -365,7 +345,7 @@ public class HdmiCecLocalDeviceAudioSystemTest {
HdmiCecMessageBuilder.buildSetSystemAudioMode(
ADDR_AUDIO_SYSTEM, ADDR_BROADCAST, false);
assertThat(mHdmiCecLocalDeviceAudioSystem.handleSystemAudioModeRequest(messageRequestOff))
.isTrue();
.isEqualTo(Constants.HANDLED);
mTestLooper.dispatchAll();
assertThat(mNativeWrapper.getOnlyResultMessage()).isEqualTo(expectedMessage);
@@ -373,7 +353,7 @@ public class HdmiCecLocalDeviceAudioSystemTest {
expectedMessage =
HdmiCecMessageBuilder.buildReportSystemAudioMode(ADDR_AUDIO_SYSTEM, ADDR_TV, false);
assertThat(mHdmiCecLocalDeviceAudioSystem.handleGiveSystemAudioModeStatus(messageGive))
.isTrue();
.isEqualTo(Constants.HANDLED);
mTestLooper.dispatchAll();
assertThat(mNativeWrapper.getOnlyResultMessage()).isEqualTo(expectedMessage);
assertThat(mMusicMute).isTrue();
@@ -441,7 +421,8 @@ public class HdmiCecLocalDeviceAudioSystemTest {
public void handleActiveSource_updateActiveSource() throws Exception {
HdmiCecMessage message = HdmiCecMessageBuilder.buildActiveSource(ADDR_TV, 0x0000);
ActiveSource expectedActiveSource = new ActiveSource(ADDR_TV, 0x0000);
assertThat(mHdmiCecLocalDeviceAudioSystem.handleActiveSource(message)).isTrue();
assertThat(mHdmiCecLocalDeviceAudioSystem.handleActiveSource(message))
.isEqualTo(Constants.HANDLED);
mTestLooper.dispatchAll();
assertThat(mHdmiCecLocalDeviceAudioSystem.getActiveSource().equals(expectedActiveSource))
.isTrue();
@@ -513,17 +494,10 @@ public class HdmiCecLocalDeviceAudioSystemTest {
public void handleRequestArcInitiate_isNotDirectConnectedToTv() throws Exception {
HdmiCecMessage message =
HdmiCecMessageBuilder.buildRequestArcInitiation(ADDR_TV, ADDR_AUDIO_SYSTEM);
HdmiCecMessage expectedMessage =
HdmiCecMessageBuilder.buildFeatureAbortCommand(
ADDR_AUDIO_SYSTEM,
ADDR_TV,
Constants.MESSAGE_REQUEST_ARC_INITIATION,
Constants.ABORT_NOT_IN_CORRECT_MODE);
mNativeWrapper.setPhysicalAddress(0x1100);
assertThat(mHdmiCecLocalDeviceAudioSystem.handleRequestArcInitiate(message)).isTrue();
mTestLooper.dispatchAll();
assertThat(mNativeWrapper.getResultMessages()).contains(expectedMessage);
assertThat(mHdmiCecLocalDeviceAudioSystem.handleRequestArcInitiate(message))
.isEqualTo(Constants.ABORT_NOT_IN_CORRECT_MODE);
}
@Test
@@ -533,7 +507,8 @@ public class HdmiCecLocalDeviceAudioSystemTest {
mNativeWrapper.setPhysicalAddress(0x1000);
mHdmiCecLocalDeviceAudioSystem.removeAction(ArcInitiationActionFromAvr.class);
assertThat(mHdmiCecLocalDeviceAudioSystem.handleRequestArcInitiate(message)).isTrue();
assertThat(mHdmiCecLocalDeviceAudioSystem.handleRequestArcInitiate(message))
.isEqualTo(Constants.HANDLED);
mTestLooper.dispatchAll();
assertThat(mHdmiCecLocalDeviceAudioSystem.getActions(ArcInitiationActionFromAvr.class))
.isNotEmpty();
@@ -548,7 +523,8 @@ public class HdmiCecLocalDeviceAudioSystemTest {
HdmiCecMessageBuilder.buildRequestArcTermination(ADDR_TV, ADDR_AUDIO_SYSTEM);
mHdmiCecLocalDeviceAudioSystem.removeAction(ArcTerminationActionFromAvr.class);
assertThat(mHdmiCecLocalDeviceAudioSystem.handleRequestArcTermination(message)).isTrue();
assertThat(mHdmiCecLocalDeviceAudioSystem.handleRequestArcTermination(message))
.isEqualTo(Constants.HANDLED);
mTestLooper.dispatchAll();
assertThat(mHdmiCecLocalDeviceAudioSystem.getActions(ArcTerminationActionFromAvr.class))
.isNotEmpty();
@@ -567,7 +543,8 @@ public class HdmiCecLocalDeviceAudioSystemTest {
Constants.MESSAGE_REQUEST_ARC_TERMINATION,
Constants.ABORT_NOT_IN_CORRECT_MODE);
assertThat(mHdmiCecLocalDeviceAudioSystem.handleRequestArcTermination(message)).isTrue();
assertThat(mHdmiCecLocalDeviceAudioSystem.handleRequestArcTermination(message))
.isEqualTo(Constants.HANDLED);
mTestLooper.dispatchAll();
assertThat(mNativeWrapper.getResultMessages()).contains(expectedMessage);
}
@@ -576,17 +553,10 @@ public class HdmiCecLocalDeviceAudioSystemTest {
public void handleRequestArcInit_arcIsNotSupported() throws Exception {
HdmiCecMessage message =
HdmiCecMessageBuilder.buildRequestArcInitiation(ADDR_TV, ADDR_AUDIO_SYSTEM);
HdmiCecMessage expectedMessage =
HdmiCecMessageBuilder.buildFeatureAbortCommand(
ADDR_AUDIO_SYSTEM,
ADDR_TV,
Constants.MESSAGE_REQUEST_ARC_INITIATION,
Constants.ABORT_UNRECOGNIZED_OPCODE);
mArcSupport = false;
assertThat(mHdmiCecLocalDeviceAudioSystem.handleRequestArcInitiate(message)).isTrue();
mTestLooper.dispatchAll();
assertThat(mNativeWrapper.getOnlyResultMessage()).isEqualTo(expectedMessage);
assertThat(mHdmiCecLocalDeviceAudioSystem.handleRequestArcInitiate(message))
.isEqualTo(Constants.ABORT_UNRECOGNIZED_OPCODE);
}
@Test
@@ -612,7 +582,8 @@ public class HdmiCecLocalDeviceAudioSystemTest {
Constants.MESSAGE_SYSTEM_AUDIO_MODE_REQUEST,
Constants.ABORT_REFUSED);
assertThat(mHdmiCecLocalDeviceAudioSystem.handleSystemAudioModeRequest(message)).isTrue();
assertThat(mHdmiCecLocalDeviceAudioSystem.handleSystemAudioModeRequest(message))
.isEqualTo(Constants.ABORT_UNRECOGNIZED_OPCODE);
mTestLooper.dispatchAll();
assertThat(mNativeWrapper.getOnlyResultMessage()).isEqualTo(expectedMessage);
}
@@ -629,7 +600,8 @@ public class HdmiCecLocalDeviceAudioSystemTest {
mHdmiCecLocalDeviceAudioSystem.setTvSystemAudioModeSupport(true);
assertThat(mHdmiCecLocalDeviceAudioSystem.handleSystemAudioModeRequest(message)).isTrue();
assertThat(mHdmiCecLocalDeviceAudioSystem.handleSystemAudioModeRequest(message))
.isEqualTo(Constants.HANDLED);
mTestLooper.dispatchAll();
assertThat(mNativeWrapper.getOnlyResultMessage()).isEqualTo(expectedMessage);
}
@@ -642,7 +614,8 @@ public class HdmiCecLocalDeviceAudioSystemTest {
ActiveSource expectedActiveSource = ActiveSource.of(ADDR_TV, 0x0000);
assertThat(mHdmiCecLocalDeviceAudioSystem.handleActiveSource(message)).isTrue();
assertThat(mHdmiCecLocalDeviceAudioSystem.handleActiveSource(message))
.isEqualTo(Constants.HANDLED);
mTestLooper.dispatchAll();
assertThat(mHdmiCecLocalDeviceAudioSystem.getActiveSource())
.isEqualTo(expectedActiveSource);
@@ -659,7 +632,8 @@ public class HdmiCecLocalDeviceAudioSystemTest {
ActiveSource expectedActiveSource = ActiveSource.of(ADDR_PLAYBACK_1, SELF_PHYSICAL_ADDRESS);
int expectedLocalActivePort = Constants.CEC_SWITCH_HOME;
assertThat(mHdmiCecLocalDeviceAudioSystem.handleRoutingChange(message)).isTrue();
assertThat(mHdmiCecLocalDeviceAudioSystem.handleRoutingChange(message))
.isEqualTo(Constants.HANDLED);
mTestLooper.dispatchAll();
assertThat(mHdmiCecLocalDeviceAudioSystem.getActiveSource())
.isEqualTo(expectedActiveSource);
@@ -677,7 +651,8 @@ public class HdmiCecLocalDeviceAudioSystemTest {
HdmiCecMessageBuilder.buildRoutingInformation(
ADDR_AUDIO_SYSTEM, HDMI_1_PHYSICAL_ADDRESS);
assertThat(mHdmiCecLocalDeviceAudioSystem.handleRoutingInformation(message)).isTrue();
assertThat(mHdmiCecLocalDeviceAudioSystem.handleRoutingInformation(message))
.isEqualTo(Constants.HANDLED);
mTestLooper.dispatchAll();
assertThat(mNativeWrapper.getOnlyResultMessage()).isEqualTo(expectedMessage);
}
@@ -691,7 +666,8 @@ public class HdmiCecLocalDeviceAudioSystemTest {
HdmiCecMessage expectedMessage =
HdmiCecMessageBuilder.buildActiveSource(ADDR_PLAYBACK_1, 0x2000);
assertThat(mHdmiCecLocalDeviceAudioSystem.handleRoutingChange(message)).isTrue();
assertThat(mHdmiCecLocalDeviceAudioSystem.handleRoutingChange(message))
.isEqualTo(Constants.HANDLED);
mTestLooper.dispatchAll();
assertThat(mNativeWrapper.getResultMessages()).contains(expectedMessage);
}
@@ -727,18 +703,15 @@ public class HdmiCecLocalDeviceAudioSystemTest {
int scaledVolume = VolumeControlAction.scaleToCecVolume(volume, maxVolume);
HdmiCecMessage expected = HdmiCecMessageBuilder.buildReportAudioStatus(ADDR_AUDIO_SYSTEM,
ADDR_TV, scaledVolume, mute);
HdmiCecMessage featureAbort = HdmiCecMessageBuilder.buildFeatureAbortCommand(
ADDR_AUDIO_SYSTEM, ADDR_TV, MESSAGE_GIVE_AUDIO_STATUS, Constants.ABORT_REFUSED);
HdmiCecMessage giveAudioStatus = HdmiCecMessageBuilder.buildGiveAudioStatus(ADDR_TV,
ADDR_AUDIO_SYSTEM);
mNativeWrapper.clearResultMessages();
boolean handled = mHdmiCecLocalDeviceAudioSystem.handleGiveAudioStatus(giveAudioStatus);
assertThat(mHdmiCecLocalDeviceAudioSystem.handleGiveAudioStatus(giveAudioStatus))
.isEqualTo(Constants.HANDLED);
mTestLooper.dispatchAll();
assertThat(mNativeWrapper.getResultMessages()).contains(expected);
assertThat(mNativeWrapper.getResultMessages()).doesNotContain(featureAbort);
assertThat(handled).isTrue();
}
@Test
@@ -758,18 +731,15 @@ public class HdmiCecLocalDeviceAudioSystemTest {
int scaledVolume = VolumeControlAction.scaleToCecVolume(volume, maxVolume);
HdmiCecMessage unexpected = HdmiCecMessageBuilder.buildReportAudioStatus(ADDR_AUDIO_SYSTEM,
ADDR_TV, scaledVolume, mute);
HdmiCecMessage featureAbort = HdmiCecMessageBuilder.buildFeatureAbortCommand(
ADDR_AUDIO_SYSTEM, ADDR_TV, MESSAGE_GIVE_AUDIO_STATUS, Constants.ABORT_REFUSED);
HdmiCecMessage giveAudioStatus = HdmiCecMessageBuilder.buildGiveAudioStatus(ADDR_TV,
ADDR_AUDIO_SYSTEM);
mNativeWrapper.clearResultMessages();
boolean handled = mHdmiCecLocalDeviceAudioSystem.handleGiveAudioStatus(giveAudioStatus);
assertThat(mHdmiCecLocalDeviceAudioSystem.handleGiveAudioStatus(giveAudioStatus))
.isEqualTo(Constants.ABORT_REFUSED);
mTestLooper.dispatchAll();
assertThat(mNativeWrapper.getResultMessages()).contains(featureAbort);
assertThat(mNativeWrapper.getResultMessages()).doesNotContain(unexpected);
assertThat(handled).isTrue();
}
@Test

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

@@ -113,7 +113,7 @@ public class HdmiCecLocalDevicePlaybackTest {
}
@Override
boolean isStandbyMessageReceived() {
protected boolean isStandbyMessageReceived() {
return mStandby;
}
@@ -184,7 +184,8 @@ public class HdmiCecLocalDevicePlaybackTest {
HdmiCecMessageBuilder.buildActiveSource(mPlaybackLogicalAddress,
mPlaybackPhysicalAddress);
assertThat(mHdmiCecLocalDevicePlayback.handleRoutingChange(message)).isTrue();
assertThat(mHdmiCecLocalDevicePlayback.handleRoutingChange(message))
.isEqualTo(Constants.HANDLED);
mTestLooper.dispatchAll();
assertThat(mWokenUp).isFalse();
assertThat(mNativeWrapper.getResultMessages().contains(expectedMessage)).isFalse();
@@ -205,7 +206,8 @@ public class HdmiCecLocalDevicePlaybackTest {
HdmiCecMessageBuilder.buildActiveSource(mPlaybackLogicalAddress,
mPlaybackPhysicalAddress);
assertThat(mHdmiCecLocalDevicePlayback.handleRoutingInformation(message)).isTrue();
assertThat(mHdmiCecLocalDevicePlayback.handleRoutingInformation(message))
.isEqualTo(Constants.HANDLED);
mTestLooper.dispatchAll();
assertThat(mWokenUp).isFalse();
assertThat(mNativeWrapper.getResultMessages().contains(expectedMessage)).isFalse();
@@ -226,7 +228,8 @@ public class HdmiCecLocalDevicePlaybackTest {
HdmiCecMessageBuilder.buildActiveSource(mPlaybackLogicalAddress,
mPlaybackPhysicalAddress);
assertThat(mHdmiCecLocalDevicePlayback.handleRoutingChange(message)).isTrue();
assertThat(mHdmiCecLocalDevicePlayback.handleRoutingChange(message))
.isEqualTo(Constants.HANDLED);
mTestLooper.dispatchAll();
assertThat(mWokenUp).isTrue();
assertThat(mNativeWrapper.getResultMessages().contains(expectedMessage)).isFalse();
@@ -247,7 +250,8 @@ public class HdmiCecLocalDevicePlaybackTest {
HdmiCecMessageBuilder.buildActiveSource(mPlaybackLogicalAddress,
mPlaybackPhysicalAddress);
assertThat(mHdmiCecLocalDevicePlayback.handleRoutingInformation(message)).isTrue();
assertThat(mHdmiCecLocalDevicePlayback.handleRoutingInformation(message))
.isEqualTo(Constants.HANDLED);
mTestLooper.dispatchAll();
assertThat(mWokenUp).isTrue();
assertThat(mNativeWrapper.getResultMessages().contains(expectedMessage)).isFalse();
@@ -270,7 +274,8 @@ public class HdmiCecLocalDevicePlaybackTest {
HdmiCecMessageBuilder.buildActiveSource(mPlaybackLogicalAddress,
mPlaybackPhysicalAddress);
assertThat(mHdmiCecLocalDevicePlayback.handleRoutingChange(message)).isTrue();
assertThat(mHdmiCecLocalDevicePlayback.handleRoutingChange(message))
.isEqualTo(Constants.HANDLED);
mTestLooper.dispatchAll();
assertThat(mWokenUp).isTrue();
assertThat(mNativeWrapper.getResultMessages()).contains(expectedMessage);
@@ -293,7 +298,8 @@ public class HdmiCecLocalDevicePlaybackTest {
HdmiCecMessageBuilder.buildActiveSource(mPlaybackLogicalAddress,
mPlaybackPhysicalAddress);
assertThat(mHdmiCecLocalDevicePlayback.handleRoutingInformation(message)).isTrue();
assertThat(mHdmiCecLocalDevicePlayback.handleRoutingInformation(message))
.isEqualTo(Constants.HANDLED);
mTestLooper.dispatchAll();
assertThat(mWokenUp).isTrue();
assertThat(mNativeWrapper.getResultMessages()).contains(expectedMessage);
@@ -309,7 +315,8 @@ public class HdmiCecLocalDevicePlaybackTest {
mStandby = false;
HdmiCecMessage message =
HdmiCecMessageBuilder.buildRoutingChange(ADDR_TV, 0x0000, 0x5000);
assertThat(mHdmiCecLocalDevicePlayback.handleRoutingChange(message)).isTrue();
assertThat(mHdmiCecLocalDevicePlayback.handleRoutingChange(message))
.isEqualTo(Constants.HANDLED);
assertThat(mHdmiCecLocalDevicePlayback.isActiveSource()).isFalse();
assertThat(mHdmiCecLocalDevicePlayback.getActiveSource().physicalAddress).isEqualTo(
0x5000);
@@ -329,7 +336,8 @@ public class HdmiCecLocalDevicePlaybackTest {
HdmiCecMessage message =
HdmiCecMessageBuilder.buildRoutingChange(ADDR_TV, 0x0000,
mPlaybackPhysicalAddress);
assertThat(mHdmiCecLocalDevicePlayback.handleRoutingChange(message)).isTrue();
assertThat(mHdmiCecLocalDevicePlayback.handleRoutingChange(message))
.isEqualTo(Constants.HANDLED);
assertThat(mHdmiCecLocalDevicePlayback.isActiveSource()).isTrue();
assertThat(mHdmiCecLocalDevicePlayback.getActiveSource().physicalAddress).isEqualTo(
mPlaybackPhysicalAddress);
@@ -349,7 +357,8 @@ public class HdmiCecLocalDevicePlaybackTest {
HdmiCecMessage message =
HdmiCecMessageBuilder.buildRoutingChange(ADDR_TV, 0x0000,
mPlaybackPhysicalAddress);
assertThat(mHdmiCecLocalDevicePlayback.handleRoutingChange(message)).isTrue();
assertThat(mHdmiCecLocalDevicePlayback.handleRoutingChange(message))
.isEqualTo(Constants.HANDLED);
assertThat(mHdmiCecLocalDevicePlayback.isActiveSource()).isFalse();
assertThat(mHdmiCecLocalDevicePlayback.getActiveSource().physicalAddress).isEqualTo(
mPlaybackPhysicalAddress);
@@ -368,7 +377,8 @@ public class HdmiCecLocalDevicePlaybackTest {
mStandby = false;
HdmiCecMessage message =
HdmiCecMessageBuilder.buildRoutingChange(ADDR_TV, 0x0000, 0x5000);
assertThat(mHdmiCecLocalDevicePlayback.handleRoutingChange(message)).isTrue();
assertThat(mHdmiCecLocalDevicePlayback.handleRoutingChange(message))
.isEqualTo(Constants.HANDLED);
assertThat(mHdmiCecLocalDevicePlayback.isActiveSource()).isFalse();
assertThat(mStandby).isTrue();
}
@@ -383,7 +393,8 @@ public class HdmiCecLocalDevicePlaybackTest {
mStandby = false;
HdmiCecMessage message =
HdmiCecMessageBuilder.buildRoutingChange(ADDR_TV, 0x0000, 0x5000);
assertThat(mHdmiCecLocalDevicePlayback.handleRoutingChange(message)).isTrue();
assertThat(mHdmiCecLocalDevicePlayback.handleRoutingChange(message))
.isEqualTo(Constants.HANDLED);
assertThat(mHdmiCecLocalDevicePlayback.isActiveSource()).isFalse();
assertThat(mStandby).isFalse();
}
@@ -399,7 +410,8 @@ public class HdmiCecLocalDevicePlaybackTest {
HdmiCecMessage message =
HdmiCecMessageBuilder.buildRoutingChange(ADDR_TV, 0x0000,
mPlaybackPhysicalAddress);
assertThat(mHdmiCecLocalDevicePlayback.handleRoutingChange(message)).isTrue();
assertThat(mHdmiCecLocalDevicePlayback.handleRoutingChange(message))
.isEqualTo(Constants.HANDLED);
assertThat(mHdmiCecLocalDevicePlayback.isActiveSource()).isTrue();
assertThat(mStandby).isFalse();
}
@@ -461,7 +473,8 @@ public class HdmiCecLocalDevicePlaybackTest {
mPlaybackPhysicalAddress, "HdmiCecLocalDevicePlaybackTest");
mStandby = false;
HdmiCecMessage message = HdmiCecMessageBuilder.buildRoutingInformation(ADDR_TV, 0x5000);
assertThat(mHdmiCecLocalDevicePlayback.handleRoutingInformation(message)).isTrue();
assertThat(mHdmiCecLocalDevicePlayback.handleRoutingInformation(message))
.isEqualTo(Constants.HANDLED);
assertThat(mHdmiCecLocalDevicePlayback.isActiveSource()).isFalse();
assertThat(mHdmiCecLocalDevicePlayback.getActiveSource().physicalAddress).isEqualTo(
0x5000);
@@ -481,7 +494,8 @@ public class HdmiCecLocalDevicePlaybackTest {
HdmiCecMessage message =
HdmiCecMessageBuilder.buildRoutingInformation(ADDR_TV,
mPlaybackPhysicalAddress);
assertThat(mHdmiCecLocalDevicePlayback.handleRoutingInformation(message)).isTrue();
assertThat(mHdmiCecLocalDevicePlayback.handleRoutingInformation(message))
.isEqualTo(Constants.HANDLED);
assertThat(mHdmiCecLocalDevicePlayback.isActiveSource()).isTrue();
assertThat(mHdmiCecLocalDevicePlayback.getActiveSource().physicalAddress).isEqualTo(
mPlaybackPhysicalAddress);
@@ -501,7 +515,8 @@ public class HdmiCecLocalDevicePlaybackTest {
HdmiCecMessage message =
HdmiCecMessageBuilder.buildRoutingInformation(ADDR_TV,
mPlaybackPhysicalAddress);
assertThat(mHdmiCecLocalDevicePlayback.handleRoutingInformation(message)).isTrue();
assertThat(mHdmiCecLocalDevicePlayback.handleRoutingInformation(message))
.isEqualTo(Constants.HANDLED);
assertThat(mHdmiCecLocalDevicePlayback.isActiveSource()).isFalse();
assertThat(mHdmiCecLocalDevicePlayback.getActiveSource().physicalAddress).isEqualTo(
mPlaybackPhysicalAddress);
@@ -520,7 +535,8 @@ public class HdmiCecLocalDevicePlaybackTest {
mStandby = false;
HdmiCecMessage message =
HdmiCecMessageBuilder.buildRoutingInformation(ADDR_TV, 0x5000);
assertThat(mHdmiCecLocalDevicePlayback.handleRoutingInformation(message)).isTrue();
assertThat(mHdmiCecLocalDevicePlayback.handleRoutingInformation(message))
.isEqualTo(Constants.HANDLED);
assertThat(mHdmiCecLocalDevicePlayback.isActiveSource()).isFalse();
assertThat(mStandby).isTrue();
}
@@ -535,7 +551,8 @@ public class HdmiCecLocalDevicePlaybackTest {
mStandby = false;
HdmiCecMessage message =
HdmiCecMessageBuilder.buildRoutingInformation(ADDR_TV, 0x5000);
assertThat(mHdmiCecLocalDevicePlayback.handleRoutingInformation(message)).isTrue();
assertThat(mHdmiCecLocalDevicePlayback.handleRoutingInformation(message))
.isEqualTo(Constants.HANDLED);
assertThat(mHdmiCecLocalDevicePlayback.isActiveSource()).isFalse();
assertThat(mStandby).isFalse();
}
@@ -551,7 +568,8 @@ public class HdmiCecLocalDevicePlaybackTest {
HdmiCecMessage message =
HdmiCecMessageBuilder.buildRoutingInformation(ADDR_TV,
mPlaybackPhysicalAddress);
assertThat(mHdmiCecLocalDevicePlayback.handleRoutingInformation(message)).isTrue();
assertThat(mHdmiCecLocalDevicePlayback.handleRoutingInformation(message))
.isEqualTo(Constants.HANDLED);
assertThat(mHdmiCecLocalDevicePlayback.isActiveSource()).isTrue();
assertThat(mStandby).isFalse();
}
@@ -606,7 +624,8 @@ public class HdmiCecLocalDevicePlaybackTest {
public void handleSetStreamPath() {
HdmiCecMessage message =
HdmiCecMessageBuilder.buildSetStreamPath(ADDR_TV, 0x2100);
assertThat(mHdmiCecLocalDevicePlayback.handleSetStreamPath(message)).isTrue();
assertThat(mHdmiCecLocalDevicePlayback.handleSetStreamPath(message))
.isEqualTo(Constants.HANDLED);
}
@Test
@@ -616,7 +635,8 @@ public class HdmiCecLocalDevicePlaybackTest {
HdmiCecMessage message =
HdmiCecMessageBuilder.buildSetSystemAudioMode(
Constants.ADDR_AUDIO_SYSTEM, Constants.ADDR_BROADCAST, true);
assertThat(mHdmiCecLocalDevicePlayback.handleSetSystemAudioMode(message)).isTrue();
assertThat(mHdmiCecLocalDevicePlayback.handleSetSystemAudioMode(message))
.isEqualTo(Constants.HANDLED);
assertThat(mHdmiCecLocalDevicePlayback.mService.isSystemAudioActivated()).isTrue();
}
@@ -629,7 +649,8 @@ public class HdmiCecLocalDevicePlaybackTest {
HdmiCecMessage message =
HdmiCecMessageBuilder.buildSetSystemAudioMode(
Constants.ADDR_AUDIO_SYSTEM, mHdmiCecLocalDevicePlayback.mAddress, false);
assertThat(mHdmiCecLocalDevicePlayback.handleSetSystemAudioMode(message)).isTrue();
assertThat(mHdmiCecLocalDevicePlayback.handleSetSystemAudioMode(message))
.isEqualTo(Constants.HANDLED);
assertThat(mHdmiCecLocalDevicePlayback.mService.isSystemAudioActivated()).isTrue();
}
@@ -640,7 +661,8 @@ public class HdmiCecLocalDevicePlaybackTest {
HdmiCecMessage message =
HdmiCecMessageBuilder.buildReportSystemAudioMode(
Constants.ADDR_AUDIO_SYSTEM, mHdmiCecLocalDevicePlayback.mAddress, true);
assertThat(mHdmiCecLocalDevicePlayback.handleSystemAudioModeStatus(message)).isTrue();
assertThat(mHdmiCecLocalDevicePlayback.handleSystemAudioModeStatus(message))
.isEqualTo(Constants.HANDLED);
assertThat(mHdmiCecLocalDevicePlayback.mService.isSystemAudioActivated()).isTrue();
}
@@ -883,7 +905,8 @@ public class HdmiCecLocalDevicePlaybackTest {
mStandby = false;
HdmiCecMessage message = HdmiCecMessageBuilder.buildActiveSource(mPlaybackLogicalAddress,
mPlaybackPhysicalAddress);
assertThat(mHdmiCecLocalDevicePlayback.handleActiveSource(message)).isTrue();
assertThat(mHdmiCecLocalDevicePlayback.handleActiveSource(message))
.isEqualTo(Constants.HANDLED);
mTestLooper.dispatchAll();
assertThat(mStandby).isFalse();
assertThat(mHdmiCecLocalDevicePlayback.isActiveSource()).isTrue();
@@ -900,7 +923,8 @@ public class HdmiCecLocalDevicePlaybackTest {
HdmiControlManager.POWER_STATE_CHANGE_ON_ACTIVE_SOURCE_LOST_NONE);
mStandby = false;
HdmiCecMessage message = HdmiCecMessageBuilder.buildActiveSource(ADDR_TV, 0x0000);
assertThat(mHdmiCecLocalDevicePlayback.handleActiveSource(message)).isTrue();
assertThat(mHdmiCecLocalDevicePlayback.handleActiveSource(message))
.isEqualTo(Constants.HANDLED);
mTestLooper.dispatchAll();
assertThat(mStandby).isFalse();
assertThat(mHdmiCecLocalDevicePlayback.isActiveSource()).isFalse();
@@ -918,7 +942,8 @@ public class HdmiCecLocalDevicePlaybackTest {
mStandby = false;
HdmiCecMessage message = HdmiCecMessageBuilder.buildActiveSource(mPlaybackLogicalAddress,
mPlaybackPhysicalAddress);
assertThat(mHdmiCecLocalDevicePlayback.handleActiveSource(message)).isTrue();
assertThat(mHdmiCecLocalDevicePlayback.handleActiveSource(message))
.isEqualTo(Constants.HANDLED);
mTestLooper.dispatchAll();
assertThat(mStandby).isFalse();
assertThat(mHdmiCecLocalDevicePlayback.isActiveSource()).isTrue();
@@ -931,7 +956,8 @@ public class HdmiCecLocalDevicePlaybackTest {
HdmiControlManager.POWER_STATE_CHANGE_ON_ACTIVE_SOURCE_LOST_STANDBY_NOW);
mStandby = false;
HdmiCecMessage message = HdmiCecMessageBuilder.buildActiveSource(ADDR_TV, 0x0000);
assertThat(mHdmiCecLocalDevicePlayback.handleActiveSource(message)).isTrue();
assertThat(mHdmiCecLocalDevicePlayback.handleActiveSource(message))
.isEqualTo(Constants.HANDLED);
mTestLooper.dispatchAll();
assertThat(mStandby).isTrue();
assertThat(mHdmiCecLocalDevicePlayback.isActiveSource()).isFalse();
@@ -996,12 +1022,14 @@ public class HdmiCecLocalDevicePlaybackTest {
// 1. DUT is <AS>.
HdmiCecMessage message1 = HdmiCecMessageBuilder.buildActiveSource(
mHdmiCecLocalDevicePlayback.mAddress, mPlaybackPhysicalAddress);
assertThat(mHdmiCecLocalDevicePlayback.handleActiveSource(message1)).isTrue();
assertThat(mHdmiCecLocalDevicePlayback.handleActiveSource(message1))
.isEqualTo(Constants.HANDLED);
assertThat(mHdmiCecLocalDevicePlayback.isActiveSource()).isTrue();
assertThat(mStandby).isFalse();
// 2. DUT loses <AS> and goes to sleep.
HdmiCecMessage message2 = HdmiCecMessageBuilder.buildActiveSource(ADDR_TV, 0x0000);
assertThat(mHdmiCecLocalDevicePlayback.handleActiveSource(message2)).isTrue();
assertThat(mHdmiCecLocalDevicePlayback.handleActiveSource(message2))
.isEqualTo(Constants.HANDLED);
assertThat(mHdmiCecLocalDevicePlayback.isActiveSource()).isFalse();
assertThat(mStandby).isTrue();
// 3. DUT becomes <AS> again.
@@ -1271,7 +1299,8 @@ public class HdmiCecLocalDevicePlaybackTest {
mStandby = false;
HdmiCecMessage message =
HdmiCecMessageBuilder.buildSetStreamPath(ADDR_TV, 0x5000);
assertThat(mHdmiCecLocalDevicePlayback.handleSetStreamPath(message)).isTrue();
assertThat(mHdmiCecLocalDevicePlayback.handleSetStreamPath(message))
.isEqualTo(Constants.HANDLED);
assertThat(mHdmiCecLocalDevicePlayback.isActiveSource()).isFalse();
assertThat(mHdmiCecLocalDevicePlayback.getActiveSource().physicalAddress).isEqualTo(
0x5000);
@@ -1290,7 +1319,8 @@ public class HdmiCecLocalDevicePlaybackTest {
mStandby = false;
HdmiCecMessage message =
HdmiCecMessageBuilder.buildSetStreamPath(ADDR_TV, 0x5000);
assertThat(mHdmiCecLocalDevicePlayback.handleSetStreamPath(message)).isTrue();
assertThat(mHdmiCecLocalDevicePlayback.handleSetStreamPath(message))
.isEqualTo(Constants.HANDLED);
assertThat(mHdmiCecLocalDevicePlayback.isActiveSource()).isFalse();
assertThat(mStandby).isTrue();
}
@@ -1305,7 +1335,8 @@ public class HdmiCecLocalDevicePlaybackTest {
mStandby = false;
HdmiCecMessage message =
HdmiCecMessageBuilder.buildSetStreamPath(ADDR_TV, 0x5000);
assertThat(mHdmiCecLocalDevicePlayback.handleSetStreamPath(message)).isTrue();
assertThat(mHdmiCecLocalDevicePlayback.handleSetStreamPath(message))
.isEqualTo(Constants.HANDLED);
assertThat(mHdmiCecLocalDevicePlayback.isActiveSource()).isFalse();
assertThat(mStandby).isFalse();
}
@@ -1492,7 +1523,8 @@ public class HdmiCecLocalDevicePlaybackTest {
mHdmiControlService.toggleAndFollowTvPower();
HdmiCecMessage tvPowerStatus = HdmiCecMessageBuilder.buildReportPowerStatus(ADDR_TV,
mPlaybackLogicalAddress, HdmiControlManager.POWER_STATUS_ON);
assertThat(mHdmiCecLocalDevicePlayback.dispatchMessage(tvPowerStatus)).isTrue();
assertThat(mHdmiCecLocalDevicePlayback.dispatchMessage(tvPowerStatus))
.isEqualTo(Constants.HANDLED);
mTestLooper.dispatchAll();
HdmiCecMessage expectedMessage = HdmiCecMessageBuilder.buildStandby(
@@ -1510,7 +1542,8 @@ public class HdmiCecLocalDevicePlaybackTest {
mHdmiControlService.toggleAndFollowTvPower();
HdmiCecMessage tvPowerStatus = HdmiCecMessageBuilder.buildReportPowerStatus(ADDR_TV,
mPlaybackLogicalAddress, HdmiControlManager.POWER_STATUS_ON);
assertThat(mHdmiCecLocalDevicePlayback.dispatchMessage(tvPowerStatus)).isTrue();
assertThat(mHdmiCecLocalDevicePlayback.dispatchMessage(tvPowerStatus))
.isEqualTo(Constants.HANDLED);
mTestLooper.dispatchAll();
HdmiCecMessage expectedMessage = HdmiCecMessageBuilder.buildStandby(
@@ -1525,7 +1558,8 @@ public class HdmiCecLocalDevicePlaybackTest {
mHdmiControlService.toggleAndFollowTvPower();
HdmiCecMessage tvPowerStatus = HdmiCecMessageBuilder.buildReportPowerStatus(ADDR_TV,
mPlaybackLogicalAddress, HdmiControlManager.POWER_STATUS_STANDBY);
assertThat(mHdmiCecLocalDevicePlayback.dispatchMessage(tvPowerStatus)).isTrue();
assertThat(mHdmiCecLocalDevicePlayback.dispatchMessage(tvPowerStatus))
.isEqualTo(Constants.HANDLED);
mTestLooper.dispatchAll();
HdmiCecMessage textViewOn = HdmiCecMessageBuilder.buildTextViewOn(mPlaybackLogicalAddress,
@@ -1543,7 +1577,8 @@ public class HdmiCecLocalDevicePlaybackTest {
mHdmiControlService.toggleAndFollowTvPower();
HdmiCecMessage tvPowerStatus = HdmiCecMessageBuilder.buildReportPowerStatus(ADDR_TV,
mPlaybackLogicalAddress, HdmiControlManager.POWER_STATUS_UNKNOWN);
assertThat(mHdmiCecLocalDevicePlayback.dispatchMessage(tvPowerStatus)).isTrue();
assertThat(mHdmiCecLocalDevicePlayback.dispatchMessage(tvPowerStatus))
.isEqualTo(Constants.HANDLED);
mTestLooper.dispatchAll();
HdmiCecMessage userControlPressed = HdmiCecMessageBuilder.buildUserControlPressed(

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

@@ -198,8 +198,8 @@ public class HdmiCecLocalDeviceTest {
ADDR_PLAYBACK_1,
Constants.MESSAGE_CEC_VERSION,
HdmiCecMessage.EMPTY_PARAM);
boolean handleResult = mHdmiLocalDevice.dispatchMessage(msg);
assertFalse(handleResult);
@Constants.HandleMessageResult int handleResult = mHdmiLocalDevice.dispatchMessage(msg);
assertEquals(Constants.NOT_HANDLED, handleResult);
}
@Test
@@ -213,7 +213,7 @@ public class HdmiCecLocalDeviceTest {
(byte) (DEVICE_TV & 0xFF)
};
callbackResult = -1;
boolean handleResult =
@Constants.HandleMessageResult int handleResult =
mHdmiLocalDevice.handleGivePhysicalAddress(
(int finalResult) -> callbackResult = finalResult);
mTestLooper.dispatchAll();
@@ -221,7 +221,7 @@ public class HdmiCecLocalDeviceTest {
* Test if CecMessage is sent successfully SendMessageResult#SUCCESS is defined in HAL as 0
*/
assertEquals(0, callbackResult);
assertTrue(handleResult);
assertEquals(Constants.HANDLED, handleResult);
}
@Test
@@ -251,85 +251,85 @@ public class HdmiCecLocalDeviceTest {
public void handleUserControlPressed_volumeUp() {
mHdmiControlService.setHdmiCecVolumeControlEnabledInternal(
HdmiControlManager.VOLUME_CONTROL_ENABLED);
boolean result = mHdmiLocalDevice.handleUserControlPressed(
@Constants.HandleMessageResult int result = mHdmiLocalDevice.handleUserControlPressed(
HdmiCecMessageBuilder.buildUserControlPressed(ADDR_PLAYBACK_1, ADDR_TV,
HdmiCecKeycode.CEC_KEYCODE_VOLUME_UP));
assertTrue(result);
assertEquals(Constants.HANDLED, result);
}
@Test
public void handleUserControlPressed_volumeDown() {
mHdmiControlService.setHdmiCecVolumeControlEnabledInternal(
HdmiControlManager.VOLUME_CONTROL_ENABLED);
boolean result = mHdmiLocalDevice.handleUserControlPressed(
@Constants.HandleMessageResult int result = mHdmiLocalDevice.handleUserControlPressed(
HdmiCecMessageBuilder.buildUserControlPressed(ADDR_PLAYBACK_1, ADDR_TV,
HdmiCecKeycode.CEC_KEYCODE_VOLUME_DOWN));
assertTrue(result);
assertEquals(Constants.HANDLED, result);
}
@Test
public void handleUserControlPressed_volumeMute() {
mHdmiControlService.setHdmiCecVolumeControlEnabledInternal(
HdmiControlManager.VOLUME_CONTROL_ENABLED);
boolean result = mHdmiLocalDevice.handleUserControlPressed(
@Constants.HandleMessageResult int result = mHdmiLocalDevice.handleUserControlPressed(
HdmiCecMessageBuilder.buildUserControlPressed(ADDR_PLAYBACK_1, ADDR_TV,
HdmiCecKeycode.CEC_KEYCODE_MUTE));
assertTrue(result);
assertEquals(Constants.HANDLED, result);
}
@Test
public void handleUserControlPressed_volumeUp_disabled() {
mHdmiControlService.setHdmiCecVolumeControlEnabledInternal(
HdmiControlManager.VOLUME_CONTROL_DISABLED);
boolean result = mHdmiLocalDevice.handleUserControlPressed(
@Constants.HandleMessageResult int result = mHdmiLocalDevice.handleUserControlPressed(
HdmiCecMessageBuilder.buildUserControlPressed(ADDR_PLAYBACK_1, ADDR_TV,
HdmiCecKeycode.CEC_KEYCODE_VOLUME_UP));
assertFalse(result);
assertThat(result).isEqualTo(Constants.ABORT_REFUSED);
}
@Test
public void handleUserControlPressed_volumeDown_disabled() {
mHdmiControlService.setHdmiCecVolumeControlEnabledInternal(
HdmiControlManager.VOLUME_CONTROL_DISABLED);
boolean result = mHdmiLocalDevice.handleUserControlPressed(
@Constants.HandleMessageResult int result = mHdmiLocalDevice.handleUserControlPressed(
HdmiCecMessageBuilder.buildUserControlPressed(ADDR_PLAYBACK_1, ADDR_TV,
HdmiCecKeycode.CEC_KEYCODE_VOLUME_DOWN));
assertFalse(result);
assertThat(result).isEqualTo(Constants.ABORT_REFUSED);
}
@Test
public void handleUserControlPressed_volumeMute_disabled() {
mHdmiControlService.setHdmiCecVolumeControlEnabledInternal(
HdmiControlManager.VOLUME_CONTROL_DISABLED);
boolean result = mHdmiLocalDevice.handleUserControlPressed(
@Constants.HandleMessageResult int result = mHdmiLocalDevice.handleUserControlPressed(
HdmiCecMessageBuilder.buildUserControlPressed(ADDR_PLAYBACK_1, ADDR_TV,
HdmiCecKeycode.CEC_KEYCODE_MUTE));
assertFalse(result);
assertThat(result).isEqualTo(Constants.ABORT_REFUSED);
}
@Test
public void handleCecVersion_isHandled() {
boolean result = mHdmiLocalDevice.onMessage(
@Constants.HandleMessageResult int result = mHdmiLocalDevice.onMessage(
HdmiCecMessageBuilder.buildCecVersion(ADDR_PLAYBACK_1, mHdmiLocalDevice.mAddress,
HdmiControlManager.HDMI_CEC_VERSION_1_4_B));
assertThat(result).isTrue();
assertEquals(Constants.HANDLED, result);
}
@Test
public void handleUserControlPressed_power_localDeviceInStandby_shouldTurnOn() {
mPowerStatus = HdmiControlManager.POWER_STATUS_STANDBY;
boolean result = mHdmiLocalDevice.handleUserControlPressed(
@Constants.HandleMessageResult int result = mHdmiLocalDevice.handleUserControlPressed(
HdmiCecMessageBuilder.buildUserControlPressed(ADDR_TV, ADDR_PLAYBACK_1,
HdmiCecKeycode.CEC_KEYCODE_POWER));
assertThat(result).isTrue();
assertEquals(Constants.HANDLED, result);
assertThat(mWakeupMessageReceived).isTrue();
assertThat(mStandbyMessageReceived).isFalse();
}
@@ -337,11 +337,11 @@ public class HdmiCecLocalDeviceTest {
@Test
public void handleUserControlPressed_power_localDeviceOn_shouldNotChangePowerStatus() {
mPowerStatus = HdmiControlManager.POWER_STATUS_ON;
boolean result = mHdmiLocalDevice.handleUserControlPressed(
@Constants.HandleMessageResult int result = mHdmiLocalDevice.handleUserControlPressed(
HdmiCecMessageBuilder.buildUserControlPressed(ADDR_TV, ADDR_PLAYBACK_1,
HdmiCecKeycode.CEC_KEYCODE_POWER));
assertThat(result).isTrue();
assertEquals(Constants.HANDLED, result);
assertThat(mWakeupMessageReceived).isFalse();
assertThat(mStandbyMessageReceived).isFalse();
}
@@ -349,11 +349,11 @@ public class HdmiCecLocalDeviceTest {
@Test
public void handleUserControlPressed_powerToggleFunction_localDeviceInStandby_shouldTurnOn() {
mPowerStatus = HdmiControlManager.POWER_STATUS_STANDBY;
boolean result = mHdmiLocalDevice.handleUserControlPressed(
@Constants.HandleMessageResult int result = mHdmiLocalDevice.handleUserControlPressed(
HdmiCecMessageBuilder.buildUserControlPressed(ADDR_TV, ADDR_PLAYBACK_1,
HdmiCecKeycode.CEC_KEYCODE_POWER_TOGGLE_FUNCTION));
assertThat(result).isTrue();
assertEquals(Constants.HANDLED, result);
assertThat(mWakeupMessageReceived).isTrue();
assertThat(mStandbyMessageReceived).isFalse();
}
@@ -361,11 +361,11 @@ public class HdmiCecLocalDeviceTest {
@Test
public void handleUserControlPressed_powerToggleFunction_localDeviceOn_shouldTurnOff() {
mPowerStatus = HdmiControlManager.POWER_STATUS_ON;
boolean result = mHdmiLocalDevice.handleUserControlPressed(
@Constants.HandleMessageResult int result = mHdmiLocalDevice.handleUserControlPressed(
HdmiCecMessageBuilder.buildUserControlPressed(ADDR_TV, ADDR_PLAYBACK_1,
HdmiCecKeycode.CEC_KEYCODE_POWER_TOGGLE_FUNCTION));
assertThat(result).isTrue();
assertEquals(Constants.HANDLED, result);
assertThat(mWakeupMessageReceived).isFalse();
assertThat(mStandbyMessageReceived).isTrue();
}
@@ -373,11 +373,11 @@ public class HdmiCecLocalDeviceTest {
@Test
public void handleUserControlPressed_powerOnFunction_localDeviceInStandby_shouldTurnOn() {
mPowerStatus = HdmiControlManager.POWER_STATUS_STANDBY;
boolean result = mHdmiLocalDevice.handleUserControlPressed(
@Constants.HandleMessageResult int result = mHdmiLocalDevice.handleUserControlPressed(
HdmiCecMessageBuilder.buildUserControlPressed(ADDR_TV, ADDR_PLAYBACK_1,
HdmiCecKeycode.CEC_KEYCODE_POWER_ON_FUNCTION));
assertThat(result).isTrue();
assertEquals(Constants.HANDLED, result);
assertThat(mWakeupMessageReceived).isTrue();
assertThat(mStandbyMessageReceived).isFalse();
}
@@ -385,11 +385,11 @@ public class HdmiCecLocalDeviceTest {
@Test
public void handleUserControlPressed_powerOnFunction_localDeviceOn_noPowerStatusChange() {
mPowerStatus = HdmiControlManager.POWER_STATUS_ON;
boolean result = mHdmiLocalDevice.handleUserControlPressed(
@Constants.HandleMessageResult int result = mHdmiLocalDevice.handleUserControlPressed(
HdmiCecMessageBuilder.buildUserControlPressed(ADDR_TV, ADDR_PLAYBACK_1,
HdmiCecKeycode.CEC_KEYCODE_POWER_ON_FUNCTION));
assertThat(result).isTrue();
assertEquals(Constants.HANDLED, result);
assertThat(mWakeupMessageReceived).isFalse();
assertThat(mStandbyMessageReceived).isFalse();
}
@@ -397,11 +397,11 @@ public class HdmiCecLocalDeviceTest {
@Test
public void handleUserControlPressed_powerOffFunction_localDeviceStandby_noPowerStatusChange() {
mPowerStatus = HdmiControlManager.POWER_STATUS_STANDBY;
boolean result = mHdmiLocalDevice.handleUserControlPressed(
@Constants.HandleMessageResult int result = mHdmiLocalDevice.handleUserControlPressed(
HdmiCecMessageBuilder.buildUserControlPressed(ADDR_TV, ADDR_PLAYBACK_1,
HdmiCecKeycode.CEC_KEYCODE_POWER_OFF_FUNCTION));
assertThat(result).isTrue();
assertEquals(Constants.HANDLED, result);
assertThat(mWakeupMessageReceived).isFalse();
assertThat(mStandbyMessageReceived).isFalse();
}
@@ -409,11 +409,11 @@ public class HdmiCecLocalDeviceTest {
@Test
public void handleUserControlPressed_powerOffFunction_localDeviceOn_shouldTurnOff() {
mPowerStatus = HdmiControlManager.POWER_STATUS_ON;
boolean result = mHdmiLocalDevice.handleUserControlPressed(
@Constants.HandleMessageResult int result = mHdmiLocalDevice.handleUserControlPressed(
HdmiCecMessageBuilder.buildUserControlPressed(ADDR_TV, ADDR_PLAYBACK_1,
HdmiCecKeycode.CEC_KEYCODE_POWER_OFF_FUNCTION));
assertThat(result).isTrue();
assertEquals(Constants.HANDLED, result);
assertThat(mWakeupMessageReceived).isFalse();
assertThat(mStandbyMessageReceived).isTrue();
}

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

@@ -233,7 +233,7 @@ public class HdmiCecLocalDeviceTvTest {
mWokenUp = false;
HdmiCecMessage textViewOn = HdmiCecMessageBuilder.buildTextViewOn(ADDR_PLAYBACK_1,
mTvLogicalAddress);
assertThat(mHdmiCecLocalDeviceTv.dispatchMessage(textViewOn)).isTrue();
assertThat(mHdmiCecLocalDeviceTv.dispatchMessage(textViewOn)).isEqualTo(Constants.HANDLED);
mTestLooper.dispatchAll();
assertThat(mWokenUp).isTrue();
}
@@ -247,7 +247,7 @@ public class HdmiCecLocalDeviceTvTest {
mWokenUp = false;
HdmiCecMessage imageViewOn = new HdmiCecMessage(ADDR_PLAYBACK_1, mTvLogicalAddress,
Constants.MESSAGE_IMAGE_VIEW_ON, HdmiCecMessage.EMPTY_PARAM);
assertThat(mHdmiCecLocalDeviceTv.dispatchMessage(imageViewOn)).isTrue();
assertThat(mHdmiCecLocalDeviceTv.dispatchMessage(imageViewOn)).isEqualTo(Constants.HANDLED);
mTestLooper.dispatchAll();
assertThat(mWokenUp).isTrue();
}
@@ -261,7 +261,7 @@ public class HdmiCecLocalDeviceTvTest {
mWokenUp = false;
HdmiCecMessage textViewOn = HdmiCecMessageBuilder.buildTextViewOn(ADDR_PLAYBACK_1,
mTvLogicalAddress);
assertThat(mHdmiCecLocalDeviceTv.dispatchMessage(textViewOn)).isTrue();
assertThat(mHdmiCecLocalDeviceTv.dispatchMessage(textViewOn)).isEqualTo(Constants.HANDLED);
mTestLooper.dispatchAll();
assertThat(mWokenUp).isFalse();
}
@@ -275,7 +275,7 @@ public class HdmiCecLocalDeviceTvTest {
mWokenUp = false;
HdmiCecMessage imageViewOn = new HdmiCecMessage(ADDR_PLAYBACK_1, mTvLogicalAddress,
Constants.MESSAGE_IMAGE_VIEW_ON, HdmiCecMessage.EMPTY_PARAM);
assertThat(mHdmiCecLocalDeviceTv.dispatchMessage(imageViewOn)).isTrue();
assertThat(mHdmiCecLocalDeviceTv.dispatchMessage(imageViewOn)).isEqualTo(Constants.HANDLED);
mTestLooper.dispatchAll();
assertThat(mWokenUp).isFalse();
}

413
services/tests/servicestests/src/com/android/server/hdmi/HdmiControlServiceTest.java
View File

@@ -28,6 +28,9 @@ import static junit.framework.Assert.assertFalse;
import static junit.framework.Assert.assertTrue;
import static junit.framework.TestCase.assertEquals;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.when;
@@ -68,7 +71,7 @@ import java.util.Optional;
@RunWith(JUnit4.class)
public class HdmiControlServiceTest {
private class MockPlaybackDevice extends HdmiCecLocalDevicePlayback {
protected static class MockPlaybackDevice extends HdmiCecLocalDevicePlayback {
private boolean mCanGoToStandby;
private boolean mIsStandby;
@@ -118,7 +121,7 @@ public class HdmiControlServiceTest {
mCanGoToStandby = canGoToStandby;
}
}
private class MockAudioSystemDevice extends HdmiCecLocalDeviceAudioSystem {
protected static class MockAudioSystemDevice extends HdmiCecLocalDeviceAudioSystem {
private boolean mCanGoToStandby;
private boolean mIsStandby;
@@ -171,15 +174,14 @@ public class HdmiControlServiceTest {
private static final String TAG = "HdmiControlServiceTest";
private Context mContextSpy;
private HdmiControlService mHdmiControlService;
private HdmiControlService mHdmiControlServiceSpy;
private HdmiCecController mHdmiCecController;
private MockAudioSystemDevice mAudioSystemDevice;
private MockPlaybackDevice mPlaybackDevice;
private MockAudioSystemDevice mAudioSystemDeviceSpy;
private MockPlaybackDevice mPlaybackDeviceSpy;
private FakeNativeWrapper mNativeWrapper;
private Looper mMyLooper;
private TestLooper mTestLooper = new TestLooper();
private ArrayList<HdmiCecLocalDevice> mLocalDevices = new ArrayList<>();
private boolean mStandbyMessageReceived;
private HdmiPortInfo[] mHdmiPortInfo;
@Mock private IPowerManager mIPowerManagerMock;
@@ -199,36 +201,32 @@ public class HdmiControlServiceTest {
HdmiCecConfig hdmiCecConfig = new FakeHdmiCecConfig(mContextSpy);
mHdmiControlService = new HdmiControlService(mContextSpy) {
@Override
boolean isStandbyMessageReceived() {
return mStandbyMessageReceived;
}
mHdmiControlServiceSpy = spy(new HdmiControlService(mContextSpy));
doNothing().when(mHdmiControlServiceSpy)
.writeStringSystemProperty(anyString(), anyString());
@Override
protected void writeStringSystemProperty(String key, String value) {
}
};
mMyLooper = mTestLooper.getLooper();
mAudioSystemDevice = new MockAudioSystemDevice(mHdmiControlService);
mPlaybackDevice = new MockPlaybackDevice(mHdmiControlService);
mAudioSystemDevice.init();
mPlaybackDevice.init();
mAudioSystemDeviceSpy = spy(new MockAudioSystemDevice(mHdmiControlServiceSpy));
mPlaybackDeviceSpy = spy(new MockPlaybackDevice(mHdmiControlServiceSpy));
mAudioSystemDeviceSpy.init();
mPlaybackDeviceSpy.init();
mHdmiControlService.setIoLooper(mMyLooper);
mHdmiControlService.setHdmiCecConfig(hdmiCecConfig);
mHdmiControlService.onBootPhase(PHASE_SYSTEM_SERVICES_READY);
mHdmiControlServiceSpy.setIoLooper(mMyLooper);
mHdmiControlServiceSpy.setHdmiCecConfig(hdmiCecConfig);
mHdmiControlServiceSpy.onBootPhase(PHASE_SYSTEM_SERVICES_READY);
mNativeWrapper = new FakeNativeWrapper();
mHdmiCecController = HdmiCecController.createWithNativeWrapper(
mHdmiControlService, mNativeWrapper, mHdmiControlService.getAtomWriter());
mHdmiControlService.setCecController(mHdmiCecController);
mHdmiControlService.setHdmiMhlController(HdmiMhlControllerStub.create(mHdmiControlService));
mHdmiControlService.setMessageValidator(new HdmiCecMessageValidator(mHdmiControlService));
mHdmiControlServiceSpy, mNativeWrapper, mHdmiControlServiceSpy.getAtomWriter());
mHdmiControlServiceSpy.setCecController(mHdmiCecController);
mHdmiControlServiceSpy.setHdmiMhlController(HdmiMhlControllerStub.create(
mHdmiControlServiceSpy));
mHdmiControlServiceSpy.setMessageValidator(new HdmiCecMessageValidator(
mHdmiControlServiceSpy));
mLocalDevices.add(mAudioSystemDevice);
mLocalDevices.add(mPlaybackDevice);
mLocalDevices.add(mAudioSystemDeviceSpy);
mLocalDevices.add(mPlaybackDeviceSpy);
mHdmiPortInfo = new HdmiPortInfo[4];
mHdmiPortInfo[0] =
new HdmiPortInfo(1, HdmiPortInfo.PORT_INPUT, 0x2100, true, false, false);
@@ -239,80 +237,81 @@ public class HdmiControlServiceTest {
mHdmiPortInfo[3] =
new HdmiPortInfo(4, HdmiPortInfo.PORT_INPUT, 0x3000, true, false, false);
mNativeWrapper.setPortInfo(mHdmiPortInfo);
mHdmiControlService.getHdmiCecConfig().setIntValue(
mHdmiControlServiceSpy.getHdmiCecConfig().setIntValue(
HdmiControlManager.CEC_SETTING_NAME_HDMI_CEC_ENABLED,
HdmiControlManager.HDMI_CEC_CONTROL_ENABLED);
mHdmiControlService.initService();
mHdmiControlService.allocateLogicalAddress(mLocalDevices, INITIATED_BY_ENABLE_CEC);
mHdmiControlServiceSpy.initService();
mHdmiControlServiceSpy.allocateLogicalAddress(mLocalDevices, INITIATED_BY_ENABLE_CEC);
mTestLooper.dispatchAll();
}
@Test
public void onStandby_notByCec_cannotGoToStandby() {
mStandbyMessageReceived = false;
mPlaybackDevice.setCanGoToStandby(false);
doReturn(false).when(mHdmiControlServiceSpy).isStandbyMessageReceived();
mHdmiControlService.onStandby(HdmiControlService.STANDBY_SCREEN_OFF);
assertTrue(mPlaybackDevice.isStandby());
assertTrue(mAudioSystemDevice.isStandby());
assertFalse(mPlaybackDevice.isDisabled());
assertFalse(mAudioSystemDevice.isDisabled());
mPlaybackDeviceSpy.setCanGoToStandby(false);
mHdmiControlServiceSpy.onStandby(HdmiControlService.STANDBY_SCREEN_OFF);
assertTrue(mPlaybackDeviceSpy.isStandby());
assertTrue(mAudioSystemDeviceSpy.isStandby());
assertFalse(mPlaybackDeviceSpy.isDisabled());
assertFalse(mAudioSystemDeviceSpy.isDisabled());
}
@Test
public void onStandby_byCec() {
mStandbyMessageReceived = true;
doReturn(true).when(mHdmiControlServiceSpy).isStandbyMessageReceived();
mHdmiControlService.onStandby(HdmiControlService.STANDBY_SCREEN_OFF);
assertTrue(mPlaybackDevice.isStandby());
assertTrue(mAudioSystemDevice.isStandby());
assertTrue(mPlaybackDevice.isDisabled());
assertTrue(mAudioSystemDevice.isDisabled());
mHdmiControlServiceSpy.onStandby(HdmiControlService.STANDBY_SCREEN_OFF);
assertTrue(mPlaybackDeviceSpy.isStandby());
assertTrue(mAudioSystemDeviceSpy.isStandby());
assertTrue(mPlaybackDeviceSpy.isDisabled());
assertTrue(mAudioSystemDeviceSpy.isDisabled());
}
@Test
public void initialPowerStatus_normalBoot_isTransientToStandby() {
assertThat(mHdmiControlService.getInitialPowerStatus()).isEqualTo(
assertThat(mHdmiControlServiceSpy.getInitialPowerStatus()).isEqualTo(
HdmiControlManager.POWER_STATUS_TRANSIENT_TO_STANDBY);
}
@Test
public void initialPowerStatus_quiescentBoot_isTransientToStandby() throws RemoteException {
when(mIPowerManagerMock.isInteractive()).thenReturn(false);
assertThat(mHdmiControlService.getInitialPowerStatus()).isEqualTo(
assertThat(mHdmiControlServiceSpy.getInitialPowerStatus()).isEqualTo(
HdmiControlManager.POWER_STATUS_TRANSIENT_TO_STANDBY);
}
@Test
public void powerStatusAfterBootComplete_normalBoot_isOn() {
mHdmiControlService.setPowerStatus(HdmiControlManager.POWER_STATUS_TRANSIENT_TO_ON);
mHdmiControlService.onBootPhase(PHASE_BOOT_COMPLETED);
assertThat(mHdmiControlService.getPowerStatus()).isEqualTo(
mHdmiControlServiceSpy.setPowerStatus(HdmiControlManager.POWER_STATUS_TRANSIENT_TO_ON);
mHdmiControlServiceSpy.onBootPhase(PHASE_BOOT_COMPLETED);
assertThat(mHdmiControlServiceSpy.getPowerStatus()).isEqualTo(
HdmiControlManager.POWER_STATUS_TRANSIENT_TO_ON);
}
@Test
public void powerStatusAfterBootComplete_quiescentBoot_isStandby() throws RemoteException {
when(mIPowerManagerMock.isInteractive()).thenReturn(false);
mHdmiControlService.onBootPhase(PHASE_BOOT_COMPLETED);
assertThat(mHdmiControlService.getPowerStatus()).isEqualTo(
mHdmiControlServiceSpy.onBootPhase(PHASE_BOOT_COMPLETED);
assertThat(mHdmiControlServiceSpy.getPowerStatus()).isEqualTo(
HdmiControlManager.POWER_STATUS_STANDBY);
}
@Test
public void initialPowerStatus_normalBoot_goToStandby_doesNotBroadcastsPowerStatus_1_4() {
mHdmiControlService.getHdmiCecConfig().setIntValue(
mHdmiControlServiceSpy.getHdmiCecConfig().setIntValue(
HdmiControlManager.CEC_SETTING_NAME_HDMI_CEC_VERSION,
HdmiControlManager.HDMI_CEC_VERSION_1_4_B);
mHdmiControlService.setControlEnabled(HdmiControlManager.HDMI_CEC_CONTROL_ENABLED);
mHdmiControlServiceSpy.setControlEnabled(HdmiControlManager.HDMI_CEC_CONTROL_ENABLED);
mNativeWrapper.clearResultMessages();
assertThat(mHdmiControlService.getInitialPowerStatus()).isEqualTo(
assertThat(mHdmiControlServiceSpy.getInitialPowerStatus()).isEqualTo(
HdmiControlManager.POWER_STATUS_TRANSIENT_TO_STANDBY);
mHdmiControlService.onStandby(HdmiControlService.STANDBY_SCREEN_OFF);
mHdmiControlServiceSpy.onStandby(HdmiControlService.STANDBY_SCREEN_OFF);
HdmiCecMessage reportPowerStatus = HdmiCecMessageBuilder.buildReportPowerStatus(
Constants.ADDR_PLAYBACK_1, Constants.ADDR_BROADCAST,
@@ -322,21 +321,21 @@ public class HdmiControlServiceTest {
@Test
public void initialPowerStatus_normalBoot_goToStandby_broadcastsPowerStatus_2_0() {
mHdmiControlService.getHdmiCecConfig().setIntValue(
mHdmiControlServiceSpy.getHdmiCecConfig().setIntValue(
HdmiControlManager.CEC_SETTING_NAME_HDMI_CEC_VERSION,
HdmiControlManager.HDMI_CEC_VERSION_2_0);
mTestLooper.dispatchAll();
mHdmiControlService.setControlEnabled(HdmiControlManager.HDMI_CEC_CONTROL_ENABLED);
mHdmiControlServiceSpy.setControlEnabled(HdmiControlManager.HDMI_CEC_CONTROL_ENABLED);
mNativeWrapper.clearResultMessages();
mHdmiControlService.allocateLogicalAddress(mLocalDevices, INITIATED_BY_ENABLE_CEC);
mHdmiControlServiceSpy.allocateLogicalAddress(mLocalDevices, INITIATED_BY_ENABLE_CEC);
mTestLooper.dispatchAll();
assertThat(mHdmiControlService.getInitialPowerStatus()).isEqualTo(
assertThat(mHdmiControlServiceSpy.getInitialPowerStatus()).isEqualTo(
HdmiControlManager.POWER_STATUS_TRANSIENT_TO_STANDBY);
mHdmiControlService.onStandby(HdmiControlService.STANDBY_SCREEN_OFF);
mHdmiControlServiceSpy.onStandby(HdmiControlService.STANDBY_SCREEN_OFF);
mTestLooper.dispatchAll();
HdmiCecMessage reportPowerStatus = HdmiCecMessageBuilder.buildReportPowerStatus(
@@ -347,53 +346,53 @@ public class HdmiControlServiceTest {
@Test
public void setAndGetCecVolumeControlEnabled_isApi() {
mHdmiControlService.getHdmiCecConfig().setIntValue(
mHdmiControlServiceSpy.getHdmiCecConfig().setIntValue(
HdmiControlManager.CEC_SETTING_NAME_VOLUME_CONTROL_MODE,
HdmiControlManager.VOLUME_CONTROL_DISABLED);
assertThat(mHdmiControlService.getHdmiCecConfig().getIntValue(
assertThat(mHdmiControlServiceSpy.getHdmiCecConfig().getIntValue(
HdmiControlManager.CEC_SETTING_NAME_VOLUME_CONTROL_MODE)).isEqualTo(
HdmiControlManager.VOLUME_CONTROL_DISABLED);
mHdmiControlService.getHdmiCecConfig().setIntValue(
mHdmiControlServiceSpy.getHdmiCecConfig().setIntValue(
HdmiControlManager.CEC_SETTING_NAME_VOLUME_CONTROL_MODE,
HdmiControlManager.VOLUME_CONTROL_ENABLED);
assertThat(mHdmiControlService.getHdmiCecConfig().getIntValue(
assertThat(mHdmiControlServiceSpy.getHdmiCecConfig().getIntValue(
HdmiControlManager.CEC_SETTING_NAME_VOLUME_CONTROL_MODE)).isEqualTo(
HdmiControlManager.VOLUME_CONTROL_ENABLED);
}
@Test
public void setAndGetCecVolumeControlEnabled_changesSetting() {
mHdmiControlService.getHdmiCecConfig().setIntValue(
mHdmiControlServiceSpy.getHdmiCecConfig().setIntValue(
HdmiControlManager.CEC_SETTING_NAME_VOLUME_CONTROL_MODE,
HdmiControlManager.VOLUME_CONTROL_DISABLED);
assertThat(mHdmiControlService.readIntSetting(
assertThat(mHdmiControlServiceSpy.readIntSetting(
Settings.Global.HDMI_CONTROL_VOLUME_CONTROL_ENABLED, -1)).isEqualTo(
HdmiControlManager.VOLUME_CONTROL_DISABLED);
mHdmiControlService.getHdmiCecConfig().setIntValue(
mHdmiControlServiceSpy.getHdmiCecConfig().setIntValue(
HdmiControlManager.CEC_SETTING_NAME_VOLUME_CONTROL_MODE,
HdmiControlManager.VOLUME_CONTROL_ENABLED);
assertThat(mHdmiControlService.readIntSetting(
assertThat(mHdmiControlServiceSpy.readIntSetting(
Settings.Global.HDMI_CONTROL_VOLUME_CONTROL_ENABLED, -1)).isEqualTo(
HdmiControlManager.VOLUME_CONTROL_ENABLED);
}
@Test
public void setAndGetCecVolumeControlEnabledInternal_doesNotChangeSetting() {
mHdmiControlService.getHdmiCecConfig().setIntValue(
mHdmiControlServiceSpy.getHdmiCecConfig().setIntValue(
HdmiControlManager.CEC_SETTING_NAME_VOLUME_CONTROL_MODE,
HdmiControlManager.VOLUME_CONTROL_ENABLED);
mHdmiControlService.setHdmiCecVolumeControlEnabledInternal(
mHdmiControlServiceSpy.setHdmiCecVolumeControlEnabledInternal(
HdmiControlManager.VOLUME_CONTROL_DISABLED);
assertThat(mHdmiControlService.getHdmiCecConfig().getIntValue(
assertThat(mHdmiControlServiceSpy.getHdmiCecConfig().getIntValue(
HdmiControlManager.CEC_SETTING_NAME_VOLUME_CONTROL_MODE)).isEqualTo(
HdmiControlManager.VOLUME_CONTROL_ENABLED);
mHdmiControlService.setHdmiCecVolumeControlEnabledInternal(
mHdmiControlServiceSpy.setHdmiCecVolumeControlEnabledInternal(
HdmiControlManager.VOLUME_CONTROL_ENABLED);
assertThat(mHdmiControlService.getHdmiCecConfig().getIntValue(
assertThat(mHdmiControlServiceSpy.getHdmiCecConfig().getIntValue(
HdmiControlManager.CEC_SETTING_NAME_VOLUME_CONTROL_MODE)).isEqualTo(
HdmiControlManager.VOLUME_CONTROL_ENABLED);
}
@@ -401,60 +400,61 @@ public class HdmiControlServiceTest {
@Test
public void disableAndReenableCec_volumeControlReturnsToOriginalValue_enabled() {
int volumeControlEnabled = HdmiControlManager.VOLUME_CONTROL_ENABLED;
mHdmiControlService.setHdmiCecVolumeControlEnabledInternal(volumeControlEnabled);
mHdmiControlServiceSpy.setHdmiCecVolumeControlEnabledInternal(volumeControlEnabled);
mHdmiControlService.setControlEnabled(HdmiControlManager.HDMI_CEC_CONTROL_DISABLED);
assertThat(mHdmiControlService.getHdmiCecVolumeControl()).isEqualTo(
mHdmiControlServiceSpy.setControlEnabled(HdmiControlManager.HDMI_CEC_CONTROL_DISABLED);
assertThat(mHdmiControlServiceSpy.getHdmiCecVolumeControl()).isEqualTo(
HdmiControlManager.VOLUME_CONTROL_DISABLED);
mHdmiControlService.setControlEnabled(HdmiControlManager.HDMI_CEC_CONTROL_ENABLED);
assertThat(mHdmiControlService.getHdmiCecVolumeControl()).isEqualTo(volumeControlEnabled);
mHdmiControlServiceSpy.setControlEnabled(HdmiControlManager.HDMI_CEC_CONTROL_ENABLED);
assertThat(mHdmiControlServiceSpy.getHdmiCecVolumeControl())
.isEqualTo(volumeControlEnabled);
}
@Test
public void disableAndReenableCec_volumeControlReturnsToOriginalValue_disabled() {
int volumeControlEnabled = HdmiControlManager.VOLUME_CONTROL_DISABLED;
mHdmiControlService.getHdmiCecConfig().setIntValue(
mHdmiControlServiceSpy.getHdmiCecConfig().setIntValue(
HdmiControlManager.CEC_SETTING_NAME_VOLUME_CONTROL_MODE, volumeControlEnabled);
mHdmiControlService.setControlEnabled(HdmiControlManager.HDMI_CEC_CONTROL_DISABLED);
assertThat(mHdmiControlService.getHdmiCecConfig().getIntValue(
mHdmiControlServiceSpy.setControlEnabled(HdmiControlManager.HDMI_CEC_CONTROL_DISABLED);
assertThat(mHdmiControlServiceSpy.getHdmiCecConfig().getIntValue(
HdmiControlManager.CEC_SETTING_NAME_VOLUME_CONTROL_MODE)).isEqualTo(
volumeControlEnabled);
mHdmiControlService.setControlEnabled(HdmiControlManager.HDMI_CEC_CONTROL_ENABLED);
assertThat(mHdmiControlService.getHdmiCecConfig().getIntValue(
mHdmiControlServiceSpy.setControlEnabled(HdmiControlManager.HDMI_CEC_CONTROL_ENABLED);
assertThat(mHdmiControlServiceSpy.getHdmiCecConfig().getIntValue(
HdmiControlManager.CEC_SETTING_NAME_VOLUME_CONTROL_MODE)).isEqualTo(
volumeControlEnabled);
}
@Test
public void disableAndReenableCec_volumeControlFeatureListenersNotified() {
mHdmiControlService.getHdmiCecConfig().setIntValue(
mHdmiControlServiceSpy.getHdmiCecConfig().setIntValue(
HdmiControlManager.CEC_SETTING_NAME_VOLUME_CONTROL_MODE,
HdmiControlManager.VOLUME_CONTROL_ENABLED);
VolumeControlFeatureCallback callback = new VolumeControlFeatureCallback();
mHdmiControlService.addHdmiCecVolumeControlFeatureListener(callback);
mHdmiControlServiceSpy.addHdmiCecVolumeControlFeatureListener(callback);
mHdmiControlService.setControlEnabled(HdmiControlManager.HDMI_CEC_CONTROL_DISABLED);
mHdmiControlServiceSpy.setControlEnabled(HdmiControlManager.HDMI_CEC_CONTROL_DISABLED);
assertThat(callback.mCallbackReceived).isTrue();
assertThat(callback.mVolumeControlEnabled).isEqualTo(
HdmiControlManager.VOLUME_CONTROL_DISABLED);
mHdmiControlService.setControlEnabled(HdmiControlManager.HDMI_CEC_CONTROL_ENABLED);
mHdmiControlServiceSpy.setControlEnabled(HdmiControlManager.HDMI_CEC_CONTROL_ENABLED);
assertThat(callback.mVolumeControlEnabled).isEqualTo(
HdmiControlManager.VOLUME_CONTROL_ENABLED);
}
@Test
public void addHdmiCecVolumeControlFeatureListener_emitsCurrentState_enabled() {
mHdmiControlService.setHdmiCecVolumeControlEnabledInternal(
mHdmiControlServiceSpy.setHdmiCecVolumeControlEnabledInternal(
HdmiControlManager.VOLUME_CONTROL_ENABLED);
VolumeControlFeatureCallback callback = new VolumeControlFeatureCallback();
mHdmiControlService.addHdmiCecVolumeControlFeatureListener(callback);
mHdmiControlServiceSpy.addHdmiCecVolumeControlFeatureListener(callback);
mTestLooper.dispatchAll();
assertThat(callback.mCallbackReceived).isTrue();
@@ -464,11 +464,11 @@ public class HdmiControlServiceTest {
@Test
public void addHdmiCecVolumeControlFeatureListener_emitsCurrentState_disabled() {
mHdmiControlService.setHdmiCecVolumeControlEnabledInternal(
mHdmiControlServiceSpy.setHdmiCecVolumeControlEnabledInternal(
HdmiControlManager.VOLUME_CONTROL_DISABLED);
VolumeControlFeatureCallback callback = new VolumeControlFeatureCallback();
mHdmiControlService.addHdmiCecVolumeControlFeatureListener(callback);
mHdmiControlServiceSpy.addHdmiCecVolumeControlFeatureListener(callback);
mTestLooper.dispatchAll();
assertThat(callback.mCallbackReceived).isTrue();
@@ -478,13 +478,13 @@ public class HdmiControlServiceTest {
@Test
public void addHdmiCecVolumeControlFeatureListener_notifiesStateUpdate() {
mHdmiControlService.setHdmiCecVolumeControlEnabledInternal(
mHdmiControlServiceSpy.setHdmiCecVolumeControlEnabledInternal(
HdmiControlManager.VOLUME_CONTROL_DISABLED);
VolumeControlFeatureCallback callback = new VolumeControlFeatureCallback();
mHdmiControlService.addHdmiCecVolumeControlFeatureListener(callback);
mHdmiControlServiceSpy.addHdmiCecVolumeControlFeatureListener(callback);
mHdmiControlService.setHdmiCecVolumeControlEnabledInternal(
mHdmiControlServiceSpy.setHdmiCecVolumeControlEnabledInternal(
HdmiControlManager.VOLUME_CONTROL_ENABLED);
mTestLooper.dispatchAll();
@@ -495,15 +495,15 @@ public class HdmiControlServiceTest {
@Test
public void addHdmiCecVolumeControlFeatureListener_honorsUnregistration() {
mHdmiControlService.setHdmiCecVolumeControlEnabledInternal(
mHdmiControlServiceSpy.setHdmiCecVolumeControlEnabledInternal(
HdmiControlManager.VOLUME_CONTROL_DISABLED);
VolumeControlFeatureCallback callback = new VolumeControlFeatureCallback();
mHdmiControlService.addHdmiCecVolumeControlFeatureListener(callback);
mHdmiControlServiceSpy.addHdmiCecVolumeControlFeatureListener(callback);
mTestLooper.dispatchAll();
mHdmiControlService.removeHdmiControlVolumeControlStatusChangeListener(callback);
mHdmiControlService.setHdmiCecVolumeControlEnabledInternal(
mHdmiControlServiceSpy.removeHdmiControlVolumeControlStatusChangeListener(callback);
mHdmiControlServiceSpy.setHdmiCecVolumeControlEnabledInternal(
HdmiControlManager.VOLUME_CONTROL_ENABLED);
mTestLooper.dispatchAll();
@@ -514,16 +514,16 @@ public class HdmiControlServiceTest {
@Test
public void addHdmiCecVolumeControlFeatureListener_notifiesStateUpdate_multiple() {
mHdmiControlService.setHdmiCecVolumeControlEnabledInternal(
mHdmiControlServiceSpy.setHdmiCecVolumeControlEnabledInternal(
HdmiControlManager.VOLUME_CONTROL_DISABLED);
VolumeControlFeatureCallback callback1 = new VolumeControlFeatureCallback();
VolumeControlFeatureCallback callback2 = new VolumeControlFeatureCallback();
mHdmiControlService.addHdmiCecVolumeControlFeatureListener(callback1);
mHdmiControlService.addHdmiCecVolumeControlFeatureListener(callback2);
mHdmiControlServiceSpy.addHdmiCecVolumeControlFeatureListener(callback1);
mHdmiControlServiceSpy.addHdmiCecVolumeControlFeatureListener(callback2);
mHdmiControlService.setHdmiCecVolumeControlEnabledInternal(
mHdmiControlServiceSpy.setHdmiCecVolumeControlEnabledInternal(
HdmiControlManager.VOLUME_CONTROL_ENABLED);
mTestLooper.dispatchAll();
@@ -537,47 +537,48 @@ public class HdmiControlServiceTest {
@Test
public void getCecVersion_1_4() {
mHdmiControlService.getHdmiCecConfig().setIntValue(
mHdmiControlServiceSpy.getHdmiCecConfig().setIntValue(
HdmiControlManager.CEC_SETTING_NAME_HDMI_CEC_VERSION,
HdmiControlManager.HDMI_CEC_VERSION_1_4_B);
mHdmiControlService.setControlEnabled(HdmiControlManager.HDMI_CEC_CONTROL_ENABLED);
assertThat(mHdmiControlService.getCecVersion()).isEqualTo(
mHdmiControlServiceSpy.setControlEnabled(HdmiControlManager.HDMI_CEC_CONTROL_ENABLED);
assertThat(mHdmiControlServiceSpy.getCecVersion()).isEqualTo(
HdmiControlManager.HDMI_CEC_VERSION_1_4_B);
}
@Test
public void getCecVersion_2_0() {
mHdmiControlService.getHdmiCecConfig().setIntValue(
mHdmiControlServiceSpy.getHdmiCecConfig().setIntValue(
HdmiControlManager.CEC_SETTING_NAME_HDMI_CEC_VERSION,
HdmiControlManager.HDMI_CEC_VERSION_2_0);
mHdmiControlService.setControlEnabled(HdmiControlManager.HDMI_CEC_CONTROL_ENABLED);
assertThat(mHdmiControlService.getCecVersion()).isEqualTo(
mHdmiControlServiceSpy.setControlEnabled(HdmiControlManager.HDMI_CEC_CONTROL_ENABLED);
assertThat(mHdmiControlServiceSpy.getCecVersion()).isEqualTo(
HdmiControlManager.HDMI_CEC_VERSION_2_0);
}
@Test
public void getCecVersion_change() {
mHdmiControlService.getHdmiCecConfig().setIntValue(
mHdmiControlServiceSpy.getHdmiCecConfig().setIntValue(
HdmiControlManager.CEC_SETTING_NAME_HDMI_CEC_VERSION,
HdmiControlManager.HDMI_CEC_VERSION_1_4_B);
mHdmiControlService.setControlEnabled(HdmiControlManager.HDMI_CEC_CONTROL_ENABLED);
assertThat(mHdmiControlService.getCecVersion()).isEqualTo(
mHdmiControlServiceSpy.setControlEnabled(HdmiControlManager.HDMI_CEC_CONTROL_ENABLED);
assertThat(mHdmiControlServiceSpy.getCecVersion()).isEqualTo(
HdmiControlManager.HDMI_CEC_VERSION_1_4_B);
mHdmiControlService.getHdmiCecConfig().setIntValue(
mHdmiControlServiceSpy.getHdmiCecConfig().setIntValue(
HdmiControlManager.CEC_SETTING_NAME_HDMI_CEC_VERSION,
HdmiControlManager.HDMI_CEC_VERSION_2_0);
mHdmiControlService.setControlEnabled(HdmiControlManager.HDMI_CEC_CONTROL_ENABLED);
assertThat(mHdmiControlService.getCecVersion()).isEqualTo(
mHdmiControlServiceSpy.setControlEnabled(HdmiControlManager.HDMI_CEC_CONTROL_ENABLED);
assertThat(mHdmiControlServiceSpy.getCecVersion()).isEqualTo(
HdmiControlManager.HDMI_CEC_VERSION_2_0);
}
@Test
public void handleGiveFeatures_cec14_featureAbort() {
mHdmiControlService.getHdmiCecConfig().setIntValue(
mHdmiControlServiceSpy.getHdmiCecConfig().setIntValue(
HdmiControlManager.CEC_SETTING_NAME_HDMI_CEC_VERSION,
HdmiControlManager.HDMI_CEC_VERSION_1_4_B);
mHdmiControlService.setControlEnabled(HdmiControlManager.HDMI_CEC_CONTROL_ENABLED);
mHdmiControlServiceSpy.setControlEnabled(HdmiControlManager.HDMI_CEC_CONTROL_ENABLED);
mHdmiControlServiceSpy.allocateLogicalAddress(mLocalDevices, INITIATED_BY_ENABLE_CEC);
mTestLooper.dispatchAll();
mNativeWrapper.onCecMessage(HdmiCecMessageBuilder.buildGiveFeatures(Constants.ADDR_TV,
@@ -592,11 +593,11 @@ public class HdmiControlServiceTest {
@Test
public void handleGiveFeatures_cec20_reportsFeatures() {
mHdmiControlService.getHdmiCecConfig().setIntValue(
mHdmiControlServiceSpy.getHdmiCecConfig().setIntValue(
HdmiControlManager.CEC_SETTING_NAME_HDMI_CEC_VERSION,
HdmiControlManager.HDMI_CEC_VERSION_2_0);
mHdmiControlService.setControlEnabled(HdmiControlManager.HDMI_CEC_CONTROL_ENABLED);
mHdmiControlService.allocateLogicalAddress(mLocalDevices, INITIATED_BY_ENABLE_CEC);
mHdmiControlServiceSpy.setControlEnabled(HdmiControlManager.HDMI_CEC_CONTROL_ENABLED);
mHdmiControlServiceSpy.allocateLogicalAddress(mLocalDevices, INITIATED_BY_ENABLE_CEC);
mTestLooper.dispatchAll();
mNativeWrapper.onCecMessage(HdmiCecMessageBuilder.buildGiveFeatures(Constants.ADDR_TV,
@@ -606,43 +607,43 @@ public class HdmiControlServiceTest {
HdmiCecMessage reportFeatures = HdmiCecMessageBuilder.buildReportFeatures(
Constants.ADDR_PLAYBACK_1, HdmiControlManager.HDMI_CEC_VERSION_2_0,
Arrays.asList(DEVICE_PLAYBACK, DEVICE_AUDIO_SYSTEM),
mPlaybackDevice.getRcProfile(), mPlaybackDevice.getRcFeatures(),
mPlaybackDevice.getDeviceFeatures());
mPlaybackDeviceSpy.getRcProfile(), mPlaybackDeviceSpy.getRcFeatures(),
mPlaybackDeviceSpy.getDeviceFeatures());
assertThat(mNativeWrapper.getResultMessages()).contains(reportFeatures);
}
@Test
public void initializeCec_14_doesNotBroadcastReportFeatures() {
mNativeWrapper.clearResultMessages();
mHdmiControlService.getHdmiCecConfig().setIntValue(
mHdmiControlServiceSpy.getHdmiCecConfig().setIntValue(
HdmiControlManager.CEC_SETTING_NAME_HDMI_CEC_VERSION,
HdmiControlManager.HDMI_CEC_VERSION_1_4_B);
mHdmiControlService.setControlEnabled(HdmiControlManager.HDMI_CEC_CONTROL_ENABLED);
mHdmiControlService.allocateLogicalAddress(mLocalDevices, INITIATED_BY_ENABLE_CEC);
mHdmiControlServiceSpy.setControlEnabled(HdmiControlManager.HDMI_CEC_CONTROL_ENABLED);
mHdmiControlServiceSpy.allocateLogicalAddress(mLocalDevices, INITIATED_BY_ENABLE_CEC);
mTestLooper.dispatchAll();
HdmiCecMessage reportFeatures = HdmiCecMessageBuilder.buildReportFeatures(
Constants.ADDR_PLAYBACK_1, HdmiControlManager.HDMI_CEC_VERSION_2_0,
Arrays.asList(DEVICE_PLAYBACK, DEVICE_AUDIO_SYSTEM),
mPlaybackDevice.getRcProfile(), mPlaybackDevice.getRcFeatures(),
mPlaybackDevice.getDeviceFeatures());
mPlaybackDeviceSpy.getRcProfile(), mPlaybackDeviceSpy.getRcFeatures(),
mPlaybackDeviceSpy.getDeviceFeatures());
assertThat(mNativeWrapper.getResultMessages()).doesNotContain(reportFeatures);
}
@Test
public void initializeCec_20_reportsFeaturesBroadcast() {
mHdmiControlService.getHdmiCecConfig().setIntValue(
mHdmiControlServiceSpy.getHdmiCecConfig().setIntValue(
HdmiControlManager.CEC_SETTING_NAME_HDMI_CEC_VERSION,
HdmiControlManager.HDMI_CEC_VERSION_2_0);
mHdmiControlService.setControlEnabled(HdmiControlManager.HDMI_CEC_CONTROL_ENABLED);
mHdmiControlService.allocateLogicalAddress(mLocalDevices, INITIATED_BY_ENABLE_CEC);
mHdmiControlServiceSpy.setControlEnabled(HdmiControlManager.HDMI_CEC_CONTROL_ENABLED);
mHdmiControlServiceSpy.allocateLogicalAddress(mLocalDevices, INITIATED_BY_ENABLE_CEC);
mTestLooper.dispatchAll();
HdmiCecMessage reportFeatures = HdmiCecMessageBuilder.buildReportFeatures(
Constants.ADDR_PLAYBACK_1, HdmiControlManager.HDMI_CEC_VERSION_2_0,
Arrays.asList(DEVICE_PLAYBACK, DEVICE_AUDIO_SYSTEM),
mPlaybackDevice.getRcProfile(), mPlaybackDevice.getRcFeatures(),
mPlaybackDevice.getDeviceFeatures());
mPlaybackDeviceSpy.getRcProfile(), mPlaybackDeviceSpy.getRcFeatures(),
mPlaybackDeviceSpy.getDeviceFeatures());
assertThat(mNativeWrapper.getResultMessages()).contains(reportFeatures);
}
@@ -653,7 +654,7 @@ public class HdmiControlServiceTest {
Binder.setCallingWorkSourceUid(callerUid);
WorkSourceUidReadingRunnable uidReadingRunnable = new WorkSourceUidReadingRunnable();
mHdmiControlService.runOnServiceThread(uidReadingRunnable);
mHdmiControlServiceSpy.runOnServiceThread(uidReadingRunnable);
Binder.setCallingWorkSourceUid(runnerUid);
@@ -666,36 +667,36 @@ public class HdmiControlServiceTest {
@Test
public void initCecVersion_limitToMinimumSupportedVersion() {
mNativeWrapper.setCecVersion(HdmiControlManager.HDMI_CEC_VERSION_1_4_B);
mHdmiControlService.getHdmiCecConfig().setIntValue(
mHdmiControlServiceSpy.getHdmiCecConfig().setIntValue(
HdmiControlManager.CEC_SETTING_NAME_HDMI_CEC_VERSION,
HdmiControlManager.HDMI_CEC_VERSION_2_0);
mTestLooper.dispatchAll();
assertThat(mHdmiControlService.getCecVersion()).isEqualTo(
assertThat(mHdmiControlServiceSpy.getCecVersion()).isEqualTo(
HdmiControlManager.HDMI_CEC_VERSION_1_4_B);
}
@Test
public void initCecVersion_limitToAtLeast1_4() {
mNativeWrapper.setCecVersion(0x0);
mHdmiControlService.getHdmiCecConfig().setIntValue(
mHdmiControlServiceSpy.getHdmiCecConfig().setIntValue(
HdmiControlManager.CEC_SETTING_NAME_HDMI_CEC_VERSION,
HdmiControlManager.HDMI_CEC_VERSION_2_0);
mTestLooper.dispatchAll();
assertThat(mHdmiControlService.getCecVersion()).isEqualTo(
assertThat(mHdmiControlServiceSpy.getCecVersion()).isEqualTo(
HdmiControlManager.HDMI_CEC_VERSION_1_4_B);
}
@Test
public void initCecVersion_useHighestMatchingVersion() {
mNativeWrapper.setCecVersion(HdmiControlManager.HDMI_CEC_VERSION_2_0);
mHdmiControlService.getHdmiCecConfig().setIntValue(
mHdmiControlServiceSpy.getHdmiCecConfig().setIntValue(
HdmiControlManager.CEC_SETTING_NAME_HDMI_CEC_VERSION,
HdmiControlManager.HDMI_CEC_VERSION_2_0);
mTestLooper.dispatchAll();
assertThat(mHdmiControlService.getCecVersion()).isEqualTo(
assertThat(mHdmiControlServiceSpy.getCecVersion()).isEqualTo(
HdmiControlManager.HDMI_CEC_VERSION_2_0);
}
@@ -710,4 +711,140 @@ public class HdmiControlServiceTest {
this.mVolumeControlEnabled = enabled;
}
}
@Test
public void handleCecCommand_errorParameter_returnsAbortInvalidOperand() {
// Validity ERROR_PARAMETER. Taken from HdmiCecMessageValidatorTest#isValid_menuStatus
HdmiCecMessage message = HdmiUtils.buildMessage("40:8D:03");
assertThat(mHdmiControlServiceSpy.handleCecCommand(message))
.isEqualTo(Constants.ABORT_INVALID_OPERAND);
}
@Test
public void handleCecCommand_errorSource_returnsHandled() {
// Validity ERROR_SOURCE. Taken from HdmiCecMessageValidatorTest#isValid_menuStatus
HdmiCecMessage message = HdmiUtils.buildMessage("F0:8E");
assertThat(mHdmiControlServiceSpy.handleCecCommand(message))
.isEqualTo(Constants.HANDLED);
}
@Test
public void handleCecCommand_errorDestination_returnsHandled() {
// Validity ERROR_DESTINATION. Taken from HdmiCecMessageValidatorTest#isValid_menuStatus
HdmiCecMessage message = HdmiUtils.buildMessage("0F:8E:00");
assertThat(mHdmiControlServiceSpy.handleCecCommand(message))
.isEqualTo(Constants.HANDLED);
}
@Test
public void handleCecCommand_errorParameterShort_returnsHandled() {
// Validity ERROR_PARAMETER_SHORT
// Taken from HdmiCecMessageValidatorTest#isValid_menuStatus
HdmiCecMessage message = HdmiUtils.buildMessage("40:8E");
assertThat(mHdmiControlServiceSpy.handleCecCommand(message))
.isEqualTo(Constants.HANDLED);
}
@Test
public void handleCecCommand_notHandledByLocalDevice_returnsNotHandled() {
HdmiCecMessage message = HdmiCecMessageBuilder.buildReportPowerStatus(
Constants.ADDR_TV,
Constants.ADDR_PLAYBACK_1,
HdmiControlManager.POWER_STATUS_ON);
doReturn(Constants.NOT_HANDLED).when(mHdmiControlServiceSpy)
.dispatchMessageToLocalDevice(message);
assertThat(mHdmiControlServiceSpy.handleCecCommand(message))
.isEqualTo(Constants.NOT_HANDLED);
}
@Test
public void handleCecCommand_handledByLocalDevice_returnsHandled() {
HdmiCecMessage message = HdmiCecMessageBuilder.buildReportPowerStatus(
Constants.ADDR_TV,
Constants.ADDR_PLAYBACK_1,
HdmiControlManager.POWER_STATUS_ON);
doReturn(Constants.HANDLED).when(mHdmiControlServiceSpy)
.dispatchMessageToLocalDevice(message);
assertThat(mHdmiControlServiceSpy.handleCecCommand(message))
.isEqualTo(Constants.HANDLED);
}
@Test
public void handleCecCommand_localDeviceReturnsFeatureAbort_returnsFeatureAbort() {
HdmiCecMessage message = HdmiCecMessageBuilder.buildReportPowerStatus(
Constants.ADDR_TV,
Constants.ADDR_PLAYBACK_1,
HdmiControlManager.POWER_STATUS_ON);
doReturn(Constants.ABORT_REFUSED).when(mHdmiControlServiceSpy)
.dispatchMessageToLocalDevice(message);
assertThat(mHdmiControlServiceSpy.handleCecCommand(message))
.isEqualTo(Constants.ABORT_REFUSED);
}
@Test
public void dispatchMessageToLocalDevice_broadcastMessage_returnsHandled() {
HdmiCecMessage message = HdmiCecMessageBuilder.buildStandby(
Constants.ADDR_TV,
Constants.ADDR_BROADCAST);
doReturn(Constants.ABORT_REFUSED).when(mPlaybackDeviceSpy).dispatchMessage(message);
doReturn(Constants.ABORT_NOT_IN_CORRECT_MODE)
.when(mAudioSystemDeviceSpy).dispatchMessage(message);
assertThat(mHdmiControlServiceSpy.dispatchMessageToLocalDevice(message))
.isEqualTo(Constants.HANDLED);
}
@Test
public void dispatchMessageToLocalDevice_localDevicesDoNotHandleMessage_returnsUnhandled() {
HdmiCecMessage message = HdmiCecMessageBuilder.buildStandby(
Constants.ADDR_TV,
Constants.ADDR_PLAYBACK_1);
doReturn(Constants.NOT_HANDLED).when(mPlaybackDeviceSpy).dispatchMessage(message);
doReturn(Constants.NOT_HANDLED)
.when(mAudioSystemDeviceSpy).dispatchMessage(message);
assertThat(mHdmiControlServiceSpy.dispatchMessageToLocalDevice(message))
.isEqualTo(Constants.NOT_HANDLED);
}
@Test
public void dispatchMessageToLocalDevice_localDeviceHandlesMessage_returnsHandled() {
HdmiCecMessage message = HdmiCecMessageBuilder.buildStandby(
Constants.ADDR_TV,
Constants.ADDR_PLAYBACK_1);
doReturn(Constants.NOT_HANDLED).when(mPlaybackDeviceSpy).dispatchMessage(message);
doReturn(Constants.HANDLED)
.when(mAudioSystemDeviceSpy).dispatchMessage(message);
assertThat(mHdmiControlServiceSpy.dispatchMessageToLocalDevice(message))
.isEqualTo(Constants.HANDLED);
}
@Test
public void dispatchMessageToLocalDevice_localDeviceReturnsFeatureAbort_returnsFeatureAbort() {
HdmiCecMessage message = HdmiCecMessageBuilder.buildStandby(
Constants.ADDR_TV,
Constants.ADDR_PLAYBACK_1);
doReturn(Constants.NOT_HANDLED).when(mPlaybackDeviceSpy).dispatchMessage(message);
doReturn(Constants.ABORT_REFUSED)
.when(mAudioSystemDeviceSpy).dispatchMessage(message);
assertThat(mHdmiControlServiceSpy.dispatchMessageToLocalDevice(message))
.isEqualTo(Constants.ABORT_REFUSED);
}
}