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

Merge "Refactor handling of <Feature Abort> responses" into sc-dev

Browse Source
This commit is contained in:
TreeHugger Robot
2021-03-23 14:19:46 +00:00
committed by Android (Google) Code Review
parent ab77b87f11 9b7f74f6e9
commit 699d25c00b
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);
}
}