diff options
17 files changed, 955 insertions, 593 deletions
diff --git a/services/core/java/com/android/server/hdmi/Constants.java b/services/core/java/com/android/server/hdmi/Constants.java index d0e7e459e7f2..58308d8f1343 100644 --- a/services/core/java/com/android/server/hdmi/Constants.java +++ b/services/core/java/com/android/server/hdmi/Constants.java @@ -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] diff --git a/services/core/java/com/android/server/hdmi/HdmiCecController.java b/services/core/java/com/android/server/hdmi/HdmiCecController.java index 1643ec162bc2..ad2ef2a2b665 100644 --- a/services/core/java/com/android/server/hdmi/HdmiCecController.java +++ b/services/core/java/com/android/server/hdmi/HdmiCecController.java @@ -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(); diff --git a/services/core/java/com/android/server/hdmi/HdmiCecLocalDevice.java b/services/core/java/com/android/server/hdmi/HdmiCecLocalDevice.java index bdc4e66cf7f9..505e743ed9a1 100755 --- a/services/core/java/com/android/server/hdmi/HdmiCecLocalDevice.java +++ b/services/core/java/com/android/server/hdmi/HdmiCecLocalDevice.java @@ -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 diff --git a/services/core/java/com/android/server/hdmi/HdmiCecLocalDeviceAudioSystem.java b/services/core/java/com/android/server/hdmi/HdmiCecLocalDeviceAudioSystem.java index bf5bf8bae6fc..790c067c1300 100644 --- a/services/core/java/com/android/server/hdmi/HdmiCecLocalDeviceAudioSystem.java +++ b/services/core/java/com/android/server/hdmi/HdmiCecLocalDeviceAudioSystem.java @@ -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) { diff --git a/services/core/java/com/android/server/hdmi/HdmiCecLocalDevicePlayback.java b/services/core/java/com/android/server/hdmi/HdmiCecLocalDevicePlayback.java index 299525207a60..10f6948f8782 100644 --- a/services/core/java/com/android/server/hdmi/HdmiCecLocalDevicePlayback.java +++ b/services/core/java/com/android/server/hdmi/HdmiCecLocalDevicePlayback.java @@ -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 diff --git a/services/core/java/com/android/server/hdmi/HdmiCecLocalDeviceSource.java b/services/core/java/com/android/server/hdmi/HdmiCecLocalDeviceSource.java index 2ed84811250e..979a1d4b0718 100644 --- a/services/core/java/com/android/server/hdmi/HdmiCecLocalDeviceSource.java +++ b/services/core/java/com/android/server/hdmi/HdmiCecLocalDeviceSource.java @@ -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. diff --git a/services/core/java/com/android/server/hdmi/HdmiCecLocalDeviceTv.java b/services/core/java/com/android/server/hdmi/HdmiCecLocalDeviceTv.java index 90d64339eac0..cd66a8fc7f01 100644 --- a/services/core/java/com/android/server/hdmi/HdmiCecLocalDeviceTv.java +++ b/services/core/java/com/android/server/hdmi/HdmiCecLocalDeviceTv.java @@ -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 diff --git a/services/core/java/com/android/server/hdmi/HdmiControlService.java b/services/core/java/com/android/server/hdmi/HdmiControlService.java index 03a83380246f..031c057018ad 100644 --- a/services/core/java/com/android/server/hdmi/HdmiControlService.java +++ b/services/core/java/com/android/server/hdmi/HdmiControlService.java @@ -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; } diff --git a/services/tests/servicestests/src/com/android/server/hdmi/ArcInitiationActionFromAvrTest.java b/services/tests/servicestests/src/com/android/server/hdmi/ArcInitiationActionFromAvrTest.java index 50ba761cef10..ee9de07a15d2 100644 --- a/services/tests/servicestests/src/com/android/server/hdmi/ArcInitiationActionFromAvrTest.java +++ b/services/tests/servicestests/src/com/android/server/hdmi/ArcInitiationActionFromAvrTest.java @@ -107,7 +107,7 @@ public class ArcInitiationActionFromAvrTest { } @Override - Looper getServiceLooper() { + protected Looper getServiceLooper() { return mTestLooper.getLooper(); } }; diff --git a/services/tests/servicestests/src/com/android/server/hdmi/ArcTerminationActionFromAvrTest.java b/services/tests/servicestests/src/com/android/server/hdmi/ArcTerminationActionFromAvrTest.java index aa5bc933002d..d5df07102d73 100644 --- a/services/tests/servicestests/src/com/android/server/hdmi/ArcTerminationActionFromAvrTest.java +++ b/services/tests/servicestests/src/com/android/server/hdmi/ArcTerminationActionFromAvrTest.java @@ -108,7 +108,7 @@ public class ArcTerminationActionFromAvrTest { } @Override - Looper getServiceLooper() { + protected Looper getServiceLooper() { return mTestLooper.getLooper(); } }; diff --git a/services/tests/servicestests/src/com/android/server/hdmi/DetectTvSystemAudioModeSupportActionTest.java b/services/tests/servicestests/src/com/android/server/hdmi/DetectTvSystemAudioModeSupportActionTest.java index 41f4a1e2d94c..8b23be511ac0 100644 --- a/services/tests/servicestests/src/com/android/server/hdmi/DetectTvSystemAudioModeSupportActionTest.java +++ b/services/tests/servicestests/src/com/android/server/hdmi/DetectTvSystemAudioModeSupportActionTest.java @@ -91,7 +91,7 @@ public class DetectTvSystemAudioModeSupportActionTest { } @Override - Looper getServiceLooper() { + protected Looper getServiceLooper() { return mTestLooper.getLooper(); } }; diff --git a/services/tests/servicestests/src/com/android/server/hdmi/HdmiCecControllerTest.java b/services/tests/servicestests/src/com/android/server/hdmi/HdmiCecControllerTest.java index b3ee18ddff55..ee1a85745701 100644 --- a/services/tests/servicestests/src/com/android/server/hdmi/HdmiCecControllerTest.java +++ b/services/tests/servicestests/src/com/android/server/hdmi/HdmiCecControllerTest.java @@ -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); + } } diff --git a/services/tests/servicestests/src/com/android/server/hdmi/HdmiCecLocalDeviceAudioSystemTest.java b/services/tests/servicestests/src/com/android/server/hdmi/HdmiCecLocalDeviceAudioSystemTest.java index 6bb148d43a57..38a44c6c0d55 100644 --- a/services/tests/servicestests/src/com/android/server/hdmi/HdmiCecLocalDeviceAudioSystemTest.java +++ b/services/tests/servicestests/src/com/android/server/hdmi/HdmiCecLocalDeviceAudioSystemTest.java @@ -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 diff --git a/services/tests/servicestests/src/com/android/server/hdmi/HdmiCecLocalDevicePlaybackTest.java b/services/tests/servicestests/src/com/android/server/hdmi/HdmiCecLocalDevicePlaybackTest.java index 1a6bad8b29cf..80da6961cf16 100644 --- a/services/tests/servicestests/src/com/android/server/hdmi/HdmiCecLocalDevicePlaybackTest.java +++ b/services/tests/servicestests/src/com/android/server/hdmi/HdmiCecLocalDevicePlaybackTest.java @@ -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( diff --git a/services/tests/servicestests/src/com/android/server/hdmi/HdmiCecLocalDeviceTest.java b/services/tests/servicestests/src/com/android/server/hdmi/HdmiCecLocalDeviceTest.java index b3f008598dc8..68803023c451 100644 --- a/services/tests/servicestests/src/com/android/server/hdmi/HdmiCecLocalDeviceTest.java +++ b/services/tests/servicestests/src/com/android/server/hdmi/HdmiCecLocalDeviceTest.java @@ -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(); } diff --git a/services/tests/servicestests/src/com/android/server/hdmi/HdmiCecLocalDeviceTvTest.java b/services/tests/servicestests/src/com/android/server/hdmi/HdmiCecLocalDeviceTvTest.java index 4b3ef2f2cfd1..39e06a3a362d 100644 --- a/services/tests/servicestests/src/com/android/server/hdmi/HdmiCecLocalDeviceTvTest.java +++ b/services/tests/servicestests/src/com/android/server/hdmi/HdmiCecLocalDeviceTvTest.java @@ -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(); } diff --git a/services/tests/servicestests/src/com/android/server/hdmi/HdmiControlServiceTest.java b/services/tests/servicestests/src/com/android/server/hdmi/HdmiControlServiceTest.java index b5336e3fd807..68aa96a1be7f 100644 --- a/services/tests/servicestests/src/com/android/server/hdmi/HdmiControlServiceTest.java +++ b/services/tests/servicestests/src/com/android/server/hdmi/HdmiControlServiceTest.java @@ -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)); - - mLocalDevices.add(mAudioSystemDevice); - mLocalDevices.add(mPlaybackDevice); + mHdmiControlServiceSpy, mNativeWrapper, mHdmiControlServiceSpy.getAtomWriter()); + mHdmiControlServiceSpy.setCecController(mHdmiCecController); + mHdmiControlServiceSpy.setHdmiMhlController(HdmiMhlControllerStub.create( + mHdmiControlServiceSpy)); + mHdmiControlServiceSpy.setMessageValidator(new HdmiCecMessageValidator( + mHdmiControlServiceSpy)); + + 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(); + + mPlaybackDeviceSpy.setCanGoToStandby(false); - mHdmiControlService.onStandby(HdmiControlService.STANDBY_SCREEN_OFF); - assertTrue(mPlaybackDevice.isStandby()); - assertTrue(mAudioSystemDevice.isStandby()); - assertFalse(mPlaybackDevice.isDisabled()); - assertFalse(mAudioSystemDevice.isDisabled()); + 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); + } } |