hostsidetests/hdmicec/src/android/hdmicec/cts/BaseHdmiCecAbsoluteVolumeControlTest.java - platform/cts - Git at Google

 /*
  * Copyright (C) 2022 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package android.hdmicec.cts;

 import static com.google.common.truth.Truth.assertThat;
 import static com.google.common.truth.Truth.assertWithMessage;

 import static org.junit.Assume.assumeTrue;

 import org.junit.Before;
 import org.junit.Test;

 /**
  * Abstract base class for tests for Absolute Volume Control (AVC). Subclasses must call
  * this class's constructor to specify the device type of the DUT and the System Audio device.
  * The three valid pairs of (DUT type, System Audio device type) for AVC are as follows:
  * (Playback, TV); (Playback, Audio System); (TV, Audio System).
  *
  * Currently, it is only feasible to test the case where the DUT is a playback device and the
  * System Audio device is a TV. This is because the CEC adapter responds <Feature Abort> to
  * <Set Audio Volume Level> when it is started as an Audio System.
  */
 public abstract class BaseHdmiCecAbsoluteVolumeControlTest extends BaseHdmiCecCtsTest {

     /**
      * Constructor. The test device type and client params (determining the client's device type)
      * passed in here determine the behavior of the tests.
      */
     public BaseHdmiCecAbsoluteVolumeControlTest(@HdmiCecConstants.CecDeviceType int testDeviceType,
             String... clientParams) {
         super(testDeviceType, clientParams);
     }

     /**
      * Returns the audio output device being used.
      */
     public int getAudioOutputDevice() {
         if (mTestDeviceType == HdmiCecConstants.CEC_DEVICE_TYPE_TV) {
             return HdmiCecConstants.DEVICE_OUT_HDMI_ARC;
         } else {
             return HdmiCecConstants.DEVICE_OUT_HDMI;
         }
     }

     @Before
     @Override
     public void setUp() throws Exception {
         super.setUp();

         // This setting must be enabled to use AVC. Start with it disabled to ensure that we can
         // control when the AVC initiation process starts.
         setSettingsValue(HdmiCecConstants.SETTING_VOLUME_CONTROL_ENABLED,
                 HdmiCecConstants.VOLUME_CONTROL_DISABLED);

         // Disable and enable CEC on the DUT to clear its knowledge of device feature support.
         // If the DUT isn't a TV, simulate a connected sink as well.
         if (mTestDeviceType == HdmiCecConstants.CEC_DEVICE_TYPE_TV) {
             getDevice().executeShellCommand("cmd hdmi_control cec_setting set hdmi_cec_enabled 0");
             waitForCondition(() -> !isCecAvailable(getDevice()), "Could not disable CEC");
             getDevice().executeShellCommand("cmd hdmi_control cec_setting set hdmi_cec_enabled 1");
             waitForCondition(() -> isCecAvailable(getDevice()), "Could not enable CEC");
         } else {
             simulateCecSinkConnected(getDevice(), getTargetLogicalAddress());
         }

         // Full volume behavior is a prerequisite for AVC. However, we cannot control this
         // condition from CTS tests or shell due to missing permissions. Therefore, we run these
         // tests only if it is already true.
         assumeTrue(isFullVolumeDevice(getAudioOutputDevice()));
     }

     /**
      * Requires the device to be able to adopt CEC 2.0 so that it sends <Give Features>.
      *
      * Tests that the DUT enables and disables AVC in response to changes in the System Audio
      * device's support for <Set Audio Volume Level>. In this test, this support status is
      * communicated through <Report Features> messages.
      */
     @Test
     public void testEnableDisableAvc_cec20_triggeredByReportFeatures() throws Exception {
         // Enable CEC 2.0
         setCec20();

         // Enable CEC volume
         setSettingsValue(HdmiCecConstants.SETTING_VOLUME_CONTROL_ENABLED,
                 HdmiCecConstants.VOLUME_CONTROL_ENABLED);

         // Enable System Audio Mode if the System Audio device is an Audio System
         enableSystemAudioModeIfApplicable();

         // Since CEC 2.0 is enabled, DUT should also use <Give Features> to query AVC support
         hdmiCecClient.checkExpectedOutput(hdmiCecClient.getSelfDevice(),
                 CecOperand.GIVE_FEATURES);
         hdmiCecClient.checkExpectedOutput(hdmiCecClient.getSelfDevice(),
                 CecOperand.SET_AUDIO_VOLUME_LEVEL);

         // System Audio device reports support for <Set Audio Volume Level> via <Report Features>
         sendReportFeatures(true);

         // DUT queries audio status
         hdmiCecClient.checkExpectedOutput(hdmiCecClient.getSelfDevice(),
                 CecOperand.GIVE_AUDIO_STATUS);
         checkAbsoluteVolumeControlStatus(false);

         // DUT receives audio status
         hdmiCecClient.sendCecMessage(hdmiCecClient.getSelfDevice(), CecOperand.REPORT_AUDIO_STATUS,
                 CecMessage.formatParams(50));
         checkAbsoluteVolumeControlStatus(true);

         // System Audio device reports no support for <Set Audio Volume Level>
         sendReportFeatures(false);
         checkAbsoluteVolumeControlStatus(false);
     }

     /**
      * Tests that the DUT enables and disables AVC in response to changes in the System Audio
      * device's support for <Set Audio Volume Level>. In this test, this support status is
      * communicated through (the lack of) <Feature Abort> responses to <Set Audio Volume Level>.
      */
     @Test
     public void testEnableDisableAvc_triggeredByAvcSupportChanged() throws Exception {
         setSettingsValue(HdmiCecConstants.SETTING_VOLUME_CONTROL_ENABLED,
                 HdmiCecConstants.VOLUME_CONTROL_ENABLED);

         enableSystemAudioModeIfApplicable();

         // DUT queries AVC support by sending <Set Audio Volume Level>
         hdmiCecClient.checkExpectedOutput(hdmiCecClient.getSelfDevice(),
                 CecOperand.SET_AUDIO_VOLUME_LEVEL);

         // System Audio device does not respond with <Feature Abort>. DUT queries audio status
         hdmiCecClient.checkExpectedOutput(hdmiCecClient.getSelfDevice(),
                 CecOperand.GIVE_AUDIO_STATUS);
         checkAbsoluteVolumeControlStatus(false);

         // DUT receives audio status
         hdmiCecClient.sendCecMessage(hdmiCecClient.getSelfDevice(), CecOperand.REPORT_AUDIO_STATUS,
                 CecMessage.formatParams(50));
         checkAbsoluteVolumeControlStatus(true);

         // System Audio device responds to <Set Audio Volume Level> with
         // <Feature Abort>[Unrecognized opcode]
         hdmiCecClient.sendCecMessage(hdmiCecClient.getSelfDevice(), CecOperand.FEATURE_ABORT,
                 CecMessage.formatParams(CecOperand.SET_AUDIO_VOLUME_LEVEL + "00"));
         checkAbsoluteVolumeControlStatus(false);
     }

     /**
      * Tests that the DUT enables and disables AVC in response to CEC volume control being
      * enabled or disabled.
      */
     @Test
     public void testEnableAndDisableAVC_triggeredByVolumeControlSettingChange() throws Exception {
         enableSystemAudioModeIfApplicable();

         // System audio device reports support for <Set Audio Volume Level>
         sendReportFeatures(true);

         // Enable CEC volume
         setSettingsValue(HdmiCecConstants.SETTING_VOLUME_CONTROL_ENABLED,
                 HdmiCecConstants.VOLUME_CONTROL_ENABLED);

         // DUT queries audio status
         hdmiCecClient.checkExpectedOutput(hdmiCecClient.getSelfDevice(),
                 CecOperand.GIVE_AUDIO_STATUS);
         checkAbsoluteVolumeControlStatus(false);

         // DUT receives audio status
         hdmiCecClient.sendCecMessage(hdmiCecClient.getSelfDevice(), CecOperand.REPORT_AUDIO_STATUS,
                 CecMessage.formatParams(50));
         checkAbsoluteVolumeControlStatus(true);

         // CEC volume control is disabled on the DUT
         setSettingsValue(HdmiCecConstants.SETTING_VOLUME_CONTROL_ENABLED,
                 HdmiCecConstants.VOLUME_CONTROL_DISABLED);
         checkAbsoluteVolumeControlStatus(false);
     }

     /**
      * Tests that the DUT enables and disables AVC in response to System Audio mode being
      * enabled or disabled.
      *
      * Only valid when the System Audio device is an Audio System.
      */
     @Test
     public void testEnableDisableAvc_triggeredBySystemAudioModeChange() throws Exception {
         assumeTrue("Skipping this test for this setup because the System Audio device "
                         + "is not an Audio System.",
                 hdmiCecClient.getSelfDevice().getDeviceType()
                         == HdmiCecConstants.CEC_DEVICE_TYPE_AUDIO_SYSTEM);

         // System audio device reports support for <Set Audio Volume Level>
         sendReportFeatures(true);

         // CEC volume control is enabled on the DUT
         setSettingsValue(HdmiCecConstants.SETTING_VOLUME_CONTROL_ENABLED,
                 HdmiCecConstants.VOLUME_CONTROL_ENABLED);

         // Enable System Audio Mode
         broadcastSystemAudioModeMessage(true);

         // DUT queries audio status
         hdmiCecClient.checkExpectedOutput(hdmiCecClient.getSelfDevice(),
                 CecOperand.GIVE_AUDIO_STATUS);
         checkAbsoluteVolumeControlStatus(false);

         // DUT receives audio status
         hdmiCecClient.sendCecMessage(hdmiCecClient.getSelfDevice(), CecOperand.REPORT_AUDIO_STATUS,
                 CecMessage.formatParams(50));
         checkAbsoluteVolumeControlStatus(true);

         // System Audio Mode is disabled
         broadcastSystemAudioModeMessage(false);
         checkAbsoluteVolumeControlStatus(false);
     }

     /**
      * Tests that the DUT sends the correct CEC messages when AVC is enabled and Android
      * initiates volume changes.
      */
     @Test
     public void testOutgoingVolumeUpdates() throws Exception {
         // Enable AVC
         setSettingsValue(HdmiCecConstants.SETTING_VOLUME_CONTROL_ENABLED,
                 HdmiCecConstants.VOLUME_CONTROL_ENABLED);
         enableSystemAudioModeIfApplicable();
         sendReportFeatures(true);
         hdmiCecClient.checkExpectedOutput(hdmiCecClient.getSelfDevice(),
                 CecOperand.GIVE_AUDIO_STATUS);
         hdmiCecClient.sendCecMessage(hdmiCecClient.getSelfDevice(), CecOperand.REPORT_AUDIO_STATUS,
                 CecMessage.formatParams(50));
         checkAbsoluteVolumeControlStatus(true);

         // Calling AudioManager#setStreamVolume should cause the DUT to send
         // <Set Audio Volume Level> with the new volume level as a parameter
         AudioManagerHelper.setDeviceVolume(getDevice(), 80);
         String setAudioVolumeLevelMessage = hdmiCecClient.checkExpectedOutput(
                 hdmiCecClient.getSelfDevice(), CecOperand.SET_AUDIO_VOLUME_LEVEL);
         assertThat(CecMessage.getParams(setAudioVolumeLevelMessage)).isEqualTo(80);

         // Calling AudioManager#adjustStreamVolume should cause the DUT to send
         // <User Control Pressed>, <User Control Released>, and <Give Audio Status>
         AudioManagerHelper.raiseVolume(getDevice());
         String userControlPressedMessage = hdmiCecClient.checkExpectedOutput(
                 hdmiCecClient.getSelfDevice(), CecOperand.USER_CONTROL_PRESSED);
         assertThat(CecMessage.getParams(userControlPressedMessage))
                 .isEqualTo(HdmiCecConstants.CEC_KEYCODE_VOLUME_UP);
         hdmiCecClient.checkExpectedOutput(hdmiCecClient.getSelfDevice(),
                 CecOperand.USER_CONTROL_RELEASED);
         hdmiCecClient.checkExpectedOutput(hdmiCecClient.getSelfDevice(),
                 CecOperand.GIVE_AUDIO_STATUS);
     }

     /**
      * Tests that the DUT notifies AudioManager when it receives <Report Audio Status> from the
      * System Audio device.
      */
     @Test
     public void testIncomingVolumeUpdates() throws Exception {
         // Enable AVC
         setSettingsValue(HdmiCecConstants.SETTING_VOLUME_CONTROL_ENABLED,
                 HdmiCecConstants.VOLUME_CONTROL_ENABLED);
         enableSystemAudioModeIfApplicable();
         sendReportFeatures(true);
         hdmiCecClient.checkExpectedOutput(hdmiCecClient.getSelfDevice(),
                 CecOperand.GIVE_AUDIO_STATUS);
         hdmiCecClient.sendCecMessage(hdmiCecClient.getSelfDevice(), CecOperand.REPORT_AUDIO_STATUS,
                 CecMessage.formatParams(50)); // Volume 50, mute off
         checkAbsoluteVolumeControlStatus(true);

         // Volume and mute status should match the initial <Report Audio Status>
         assertApproximateDeviceVolumeAndMute(50, false);

         // Test an incoming <Report Audio Status> that does not mute the device
         hdmiCecClient.sendCecMessage(hdmiCecClient.getSelfDevice(), CecOperand.REPORT_AUDIO_STATUS,
                 CecMessage.formatParams(90)); // Volume 90, mute off
         assertApproximateDeviceVolumeAndMute(90, false);

         // Test an incoming <Report Audio Status> that mutes the device
         hdmiCecClient.sendCecMessage(hdmiCecClient.getSelfDevice(), CecOperand.REPORT_AUDIO_STATUS,
                 CecMessage.formatParams(70 + 0b1000_0000)); // Volume 70, mute on
         assertApproximateDeviceVolumeAndMute(0, true);
     }

     /**
      * Enables System Audio Mode if the System Audio device is an Audio System.
      */
     private void enableSystemAudioModeIfApplicable() throws Exception {
         if (hdmiCecClient.getSelfDevice() == LogicalAddress.AUDIO_SYSTEM) {
             broadcastSystemAudioModeMessage(true);
         }
     }

     /**
      * Has the CEC client broadcast a message enabling or disabling System Audio Mode.
      */
     private void broadcastSystemAudioModeMessage(boolean val) throws Exception {
         hdmiCecClient.sendCecMessage(
                 hdmiCecClient.getSelfDevice(),
                 LogicalAddress.BROADCAST,
                 CecOperand.SET_SYSTEM_AUDIO_MODE,
                 CecMessage.formatParams(val ? 1 : 0));
     }

     /**
      * Has the CEC client send a <Report Features> message expressing support or lack of support for
      * <Set Audio Volume Level>.
      */
     private void sendReportFeatures(boolean setAudioVolumeLevelSupport) throws Exception {
         String deviceTypeNibble = hdmiCecClient.getSelfDevice() == LogicalAddress.TV
                 ? "80" : "08";
         String featureSupportNibble = setAudioVolumeLevelSupport ? "01" : "00";
         hdmiCecClient.sendCecMessage(hdmiCecClient.getSelfDevice(), CecOperand.REPORT_FEATURES,
                 "06:" + deviceTypeNibble + ":00:" + featureSupportNibble);
     }

     /**
      * Checks that the status of Absolute Volume Control on the DUT to match the expected status.
      * Waits and rechecks a limited number of times if the status does not currently match.
      */
     private void checkAbsoluteVolumeControlStatus(boolean enabledStatus) throws Exception {
         String expectedStatus = enabledStatus ? "enabled" : "disabled";
         waitForCondition(() -> getAbsoluteVolumeControlStatus() == enabledStatus,
                 "Absolute Volume Control was not " + expectedStatus + " when expected");
     }

     /**
      * Returns the state of Absolute Volume Control on the DUT. This is determined by the
      * volume behavior of the audio output device being used for HDMI audio.
      */
     private boolean getAbsoluteVolumeControlStatus() throws Exception {
         return getDevice()
                 .executeShellCommand("dumpsys hdmi_control | grep mIsAbsoluteVolumeControlEnabled:")
                 .replace("mIsAbsoluteVolumeControlEnabled:", "").trim()
                 .equals("true");
     }

     /**
      * Asserts that the DUT's volume (scale: [0, 100]) is within 5 points of an expected volume.
      * This accounts for small differences due to rounding when converting between volume scales.
      * Also asserts that the DUT's mute status is equal to {@code expectedMute}.
      *
      * Asserting both volume and mute at the same time saves a shell command because both are
      * conveyed in a single log message.
      */
     private void assertApproximateDeviceVolumeAndMute(int expectedVolume, boolean expectedMute)
             throws Exception {
         // Raw output is equal to volume out of 100, plus 128 if muted
         // In practice, if the stream is muted, volume equals 0, so this will be at most 128
         int rawOutput = AudioManagerHelper.getDutAudioVolume(getDevice());

         int actualVolume = rawOutput % 128;
         assertWithMessage("Expected DUT to have volume " + expectedVolume
                 + " but was actually " + actualVolume)
                 .that(Math.abs(expectedVolume - actualVolume) <= 5)
                 .isTrue();

         boolean actualMute = rawOutput >= 128;
         String expectedMuteString = expectedMute ? "muted" : "unmuted";
         String actualMuteString = actualMute ? "muted" : "unmuted";
         assertWithMessage("Expected DUT to be " + expectedMuteString
                 + "but was actually " + actualMuteString)
                 .that(expectedMute)
                 .isEqualTo(actualMute);
     }
 }
	/*
	* Copyright (C) 2022 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package android.hdmicec.cts;

	import static com.google.common.truth.Truth.assertThat;
	import static com.google.common.truth.Truth.assertWithMessage;

	import static org.junit.Assume.assumeTrue;

	import org.junit.Before;
	import org.junit.Test;

	/**
	* Abstract base class for tests for Absolute Volume Control (AVC). Subclasses must call
	* this class's constructor to specify the device type of the DUT and the System Audio device.
	* The three valid pairs of (DUT type, System Audio device type) for AVC are as follows:
	* (Playback, TV); (Playback, Audio System); (TV, Audio System).
	*
	* Currently, it is only feasible to test the case where the DUT is a playback device and the
	* System Audio device is a TV. This is because the CEC adapter responds <Feature Abort> to
	* <Set Audio Volume Level> when it is started as an Audio System.
	*/
	public abstract class BaseHdmiCecAbsoluteVolumeControlTest extends BaseHdmiCecCtsTest {

	/**
	* Constructor. The test device type and client params (determining the client's device type)
	* passed in here determine the behavior of the tests.
	*/
	public BaseHdmiCecAbsoluteVolumeControlTest(@HdmiCecConstants.CecDeviceType int testDeviceType,
	String... clientParams) {
	super(testDeviceType, clientParams);
	}

	/**
	* Returns the audio output device being used.
	*/
	public int getAudioOutputDevice() {
	if (mTestDeviceType == HdmiCecConstants.CEC_DEVICE_TYPE_TV) {
	return HdmiCecConstants.DEVICE_OUT_HDMI_ARC;
	} else {
	return HdmiCecConstants.DEVICE_OUT_HDMI;
	}
	}

	@Before
	@Override
	public void setUp() throws Exception {
	super.setUp();

	// This setting must be enabled to use AVC. Start with it disabled to ensure that we can
	// control when the AVC initiation process starts.
	setSettingsValue(HdmiCecConstants.SETTING_VOLUME_CONTROL_ENABLED,
	HdmiCecConstants.VOLUME_CONTROL_DISABLED);

	// Disable and enable CEC on the DUT to clear its knowledge of device feature support.
	// If the DUT isn't a TV, simulate a connected sink as well.
	if (mTestDeviceType == HdmiCecConstants.CEC_DEVICE_TYPE_TV) {
	getDevice().executeShellCommand("cmd hdmi_control cec_setting set hdmi_cec_enabled 0");
	waitForCondition(() -> !isCecAvailable(getDevice()), "Could not disable CEC");
	getDevice().executeShellCommand("cmd hdmi_control cec_setting set hdmi_cec_enabled 1");
	waitForCondition(() -> isCecAvailable(getDevice()), "Could not enable CEC");
	} else {
	simulateCecSinkConnected(getDevice(), getTargetLogicalAddress());
	}

	// Full volume behavior is a prerequisite for AVC. However, we cannot control this
	// condition from CTS tests or shell due to missing permissions. Therefore, we run these
	// tests only if it is already true.
	assumeTrue(isFullVolumeDevice(getAudioOutputDevice()));
	}

	/**
	* Requires the device to be able to adopt CEC 2.0 so that it sends <Give Features>.
	*
	* Tests that the DUT enables and disables AVC in response to changes in the System Audio
	* device's support for <Set Audio Volume Level>. In this test, this support status is
	* communicated through <Report Features> messages.
	*/
	@Test
	public void testEnableDisableAvc_cec20_triggeredByReportFeatures() throws Exception {
	// Enable CEC 2.0
	setCec20();

	// Enable CEC volume
	setSettingsValue(HdmiCecConstants.SETTING_VOLUME_CONTROL_ENABLED,
	HdmiCecConstants.VOLUME_CONTROL_ENABLED);

	// Enable System Audio Mode if the System Audio device is an Audio System
	enableSystemAudioModeIfApplicable();

	// Since CEC 2.0 is enabled, DUT should also use <Give Features> to query AVC support
	hdmiCecClient.checkExpectedOutput(hdmiCecClient.getSelfDevice(),
	CecOperand.GIVE_FEATURES);
	hdmiCecClient.checkExpectedOutput(hdmiCecClient.getSelfDevice(),
	CecOperand.SET_AUDIO_VOLUME_LEVEL);

	// System Audio device reports support for <Set Audio Volume Level> via <Report Features>
	sendReportFeatures(true);

	// DUT queries audio status
	hdmiCecClient.checkExpectedOutput(hdmiCecClient.getSelfDevice(),
	CecOperand.GIVE_AUDIO_STATUS);
	checkAbsoluteVolumeControlStatus(false);

	// DUT receives audio status
	hdmiCecClient.sendCecMessage(hdmiCecClient.getSelfDevice(), CecOperand.REPORT_AUDIO_STATUS,
	CecMessage.formatParams(50));
	checkAbsoluteVolumeControlStatus(true);

	// System Audio device reports no support for <Set Audio Volume Level>
	sendReportFeatures(false);
	checkAbsoluteVolumeControlStatus(false);
	}

	/**
	* Tests that the DUT enables and disables AVC in response to changes in the System Audio
	* device's support for <Set Audio Volume Level>. In this test, this support status is
	* communicated through (the lack of) <Feature Abort> responses to <Set Audio Volume Level>.
	*/
	@Test
	public void testEnableDisableAvc_triggeredByAvcSupportChanged() throws Exception {
	setSettingsValue(HdmiCecConstants.SETTING_VOLUME_CONTROL_ENABLED,
	HdmiCecConstants.VOLUME_CONTROL_ENABLED);

	enableSystemAudioModeIfApplicable();

	// DUT queries AVC support by sending <Set Audio Volume Level>
	hdmiCecClient.checkExpectedOutput(hdmiCecClient.getSelfDevice(),
	CecOperand.SET_AUDIO_VOLUME_LEVEL);

	// System Audio device does not respond with <Feature Abort>. DUT queries audio status
	hdmiCecClient.checkExpectedOutput(hdmiCecClient.getSelfDevice(),
	CecOperand.GIVE_AUDIO_STATUS);
	checkAbsoluteVolumeControlStatus(false);

	// DUT receives audio status
	hdmiCecClient.sendCecMessage(hdmiCecClient.getSelfDevice(), CecOperand.REPORT_AUDIO_STATUS,
	CecMessage.formatParams(50));
	checkAbsoluteVolumeControlStatus(true);

	// System Audio device responds to <Set Audio Volume Level> with
	// <Feature Abort>[Unrecognized opcode]
	hdmiCecClient.sendCecMessage(hdmiCecClient.getSelfDevice(), CecOperand.FEATURE_ABORT,
	CecMessage.formatParams(CecOperand.SET_AUDIO_VOLUME_LEVEL + "00"));
	checkAbsoluteVolumeControlStatus(false);
	}

	/**
	* Tests that the DUT enables and disables AVC in response to CEC volume control being
	* enabled or disabled.
	*/
	@Test
	public void testEnableAndDisableAVC_triggeredByVolumeControlSettingChange() throws Exception {
	enableSystemAudioModeIfApplicable();

	// System audio device reports support for <Set Audio Volume Level>
	sendReportFeatures(true);

	// Enable CEC volume
	setSettingsValue(HdmiCecConstants.SETTING_VOLUME_CONTROL_ENABLED,
	HdmiCecConstants.VOLUME_CONTROL_ENABLED);

	// DUT queries audio status
	hdmiCecClient.checkExpectedOutput(hdmiCecClient.getSelfDevice(),
	CecOperand.GIVE_AUDIO_STATUS);
	checkAbsoluteVolumeControlStatus(false);

	// DUT receives audio status
	hdmiCecClient.sendCecMessage(hdmiCecClient.getSelfDevice(), CecOperand.REPORT_AUDIO_STATUS,
	CecMessage.formatParams(50));
	checkAbsoluteVolumeControlStatus(true);

	// CEC volume control is disabled on the DUT
	setSettingsValue(HdmiCecConstants.SETTING_VOLUME_CONTROL_ENABLED,
	HdmiCecConstants.VOLUME_CONTROL_DISABLED);
	checkAbsoluteVolumeControlStatus(false);
	}

	/**
	* Tests that the DUT enables and disables AVC in response to System Audio mode being
	* enabled or disabled.
	*
	* Only valid when the System Audio device is an Audio System.
	*/
	@Test
	public void testEnableDisableAvc_triggeredBySystemAudioModeChange() throws Exception {
	assumeTrue("Skipping this test for this setup because the System Audio device "
	+ "is not an Audio System.",
	hdmiCecClient.getSelfDevice().getDeviceType()
	== HdmiCecConstants.CEC_DEVICE_TYPE_AUDIO_SYSTEM);

	// System audio device reports support for <Set Audio Volume Level>
	sendReportFeatures(true);

	// CEC volume control is enabled on the DUT
	setSettingsValue(HdmiCecConstants.SETTING_VOLUME_CONTROL_ENABLED,
	HdmiCecConstants.VOLUME_CONTROL_ENABLED);

	// Enable System Audio Mode
	broadcastSystemAudioModeMessage(true);

	// DUT queries audio status
	hdmiCecClient.checkExpectedOutput(hdmiCecClient.getSelfDevice(),
	CecOperand.GIVE_AUDIO_STATUS);
	checkAbsoluteVolumeControlStatus(false);

	// DUT receives audio status
	hdmiCecClient.sendCecMessage(hdmiCecClient.getSelfDevice(), CecOperand.REPORT_AUDIO_STATUS,
	CecMessage.formatParams(50));
	checkAbsoluteVolumeControlStatus(true);

	// System Audio Mode is disabled
	broadcastSystemAudioModeMessage(false);
	checkAbsoluteVolumeControlStatus(false);
	}

	/**
	* Tests that the DUT sends the correct CEC messages when AVC is enabled and Android
	* initiates volume changes.
	*/
	@Test
	public void testOutgoingVolumeUpdates() throws Exception {
	// Enable AVC
	setSettingsValue(HdmiCecConstants.SETTING_VOLUME_CONTROL_ENABLED,
	HdmiCecConstants.VOLUME_CONTROL_ENABLED);
	enableSystemAudioModeIfApplicable();
	sendReportFeatures(true);
	hdmiCecClient.checkExpectedOutput(hdmiCecClient.getSelfDevice(),
	CecOperand.GIVE_AUDIO_STATUS);
	hdmiCecClient.sendCecMessage(hdmiCecClient.getSelfDevice(), CecOperand.REPORT_AUDIO_STATUS,
	CecMessage.formatParams(50));
	checkAbsoluteVolumeControlStatus(true);

	// Calling AudioManager#setStreamVolume should cause the DUT to send
	// <Set Audio Volume Level> with the new volume level as a parameter
	AudioManagerHelper.setDeviceVolume(getDevice(), 80);
	String setAudioVolumeLevelMessage = hdmiCecClient.checkExpectedOutput(
	hdmiCecClient.getSelfDevice(), CecOperand.SET_AUDIO_VOLUME_LEVEL);
	assertThat(CecMessage.getParams(setAudioVolumeLevelMessage)).isEqualTo(80);

	// Calling AudioManager#adjustStreamVolume should cause the DUT to send
	// <User Control Pressed>, <User Control Released>, and <Give Audio Status>
	AudioManagerHelper.raiseVolume(getDevice());
	String userControlPressedMessage = hdmiCecClient.checkExpectedOutput(
	hdmiCecClient.getSelfDevice(), CecOperand.USER_CONTROL_PRESSED);
	assertThat(CecMessage.getParams(userControlPressedMessage))
	.isEqualTo(HdmiCecConstants.CEC_KEYCODE_VOLUME_UP);
	hdmiCecClient.checkExpectedOutput(hdmiCecClient.getSelfDevice(),
	CecOperand.USER_CONTROL_RELEASED);
	hdmiCecClient.checkExpectedOutput(hdmiCecClient.getSelfDevice(),
	CecOperand.GIVE_AUDIO_STATUS);
	}

	/**
	* Tests that the DUT notifies AudioManager when it receives <Report Audio Status> from the
	* System Audio device.
	*/
	@Test
	public void testIncomingVolumeUpdates() throws Exception {
	// Enable AVC
	setSettingsValue(HdmiCecConstants.SETTING_VOLUME_CONTROL_ENABLED,
	HdmiCecConstants.VOLUME_CONTROL_ENABLED);
	enableSystemAudioModeIfApplicable();
	sendReportFeatures(true);
	hdmiCecClient.checkExpectedOutput(hdmiCecClient.getSelfDevice(),
	CecOperand.GIVE_AUDIO_STATUS);
	hdmiCecClient.sendCecMessage(hdmiCecClient.getSelfDevice(), CecOperand.REPORT_AUDIO_STATUS,
	CecMessage.formatParams(50)); // Volume 50, mute off
	checkAbsoluteVolumeControlStatus(true);

	// Volume and mute status should match the initial <Report Audio Status>
	assertApproximateDeviceVolumeAndMute(50, false);

	// Test an incoming <Report Audio Status> that does not mute the device
	hdmiCecClient.sendCecMessage(hdmiCecClient.getSelfDevice(), CecOperand.REPORT_AUDIO_STATUS,
	CecMessage.formatParams(90)); // Volume 90, mute off
	assertApproximateDeviceVolumeAndMute(90, false);

	// Test an incoming <Report Audio Status> that mutes the device
	hdmiCecClient.sendCecMessage(hdmiCecClient.getSelfDevice(), CecOperand.REPORT_AUDIO_STATUS,
	CecMessage.formatParams(70 + 0b1000_0000)); // Volume 70, mute on
	assertApproximateDeviceVolumeAndMute(0, true);
	}

	/**
	* Enables System Audio Mode if the System Audio device is an Audio System.
	*/
	private void enableSystemAudioModeIfApplicable() throws Exception {
	if (hdmiCecClient.getSelfDevice() == LogicalAddress.AUDIO_SYSTEM) {
	broadcastSystemAudioModeMessage(true);
	}
	}

	/**
	* Has the CEC client broadcast a message enabling or disabling System Audio Mode.
	*/
	private void broadcastSystemAudioModeMessage(boolean val) throws Exception {
	hdmiCecClient.sendCecMessage(
	hdmiCecClient.getSelfDevice(),
	LogicalAddress.BROADCAST,
	CecOperand.SET_SYSTEM_AUDIO_MODE,
	CecMessage.formatParams(val ? 1 : 0));
	}

	/**
	* Has the CEC client send a <Report Features> message expressing support or lack of support for
	* <Set Audio Volume Level>.
	*/
	private void sendReportFeatures(boolean setAudioVolumeLevelSupport) throws Exception {
	String deviceTypeNibble = hdmiCecClient.getSelfDevice() == LogicalAddress.TV
	? "80" : "08";
	String featureSupportNibble = setAudioVolumeLevelSupport ? "01" : "00";
	hdmiCecClient.sendCecMessage(hdmiCecClient.getSelfDevice(), CecOperand.REPORT_FEATURES,
	"06:" + deviceTypeNibble + ":00:" + featureSupportNibble);
	}

	/**
	* Checks that the status of Absolute Volume Control on the DUT to match the expected status.
	* Waits and rechecks a limited number of times if the status does not currently match.
	*/
	private void checkAbsoluteVolumeControlStatus(boolean enabledStatus) throws Exception {
	String expectedStatus = enabledStatus ? "enabled" : "disabled";
	waitForCondition(() -> getAbsoluteVolumeControlStatus() == enabledStatus,
	"Absolute Volume Control was not " + expectedStatus + " when expected");
	}

	/**
	* Returns the state of Absolute Volume Control on the DUT. This is determined by the
	* volume behavior of the audio output device being used for HDMI audio.
	*/
	private boolean getAbsoluteVolumeControlStatus() throws Exception {
	return getDevice()
	.executeShellCommand("dumpsys hdmi_control \| grep mIsAbsoluteVolumeControlEnabled:")
	.replace("mIsAbsoluteVolumeControlEnabled:", "").trim()
	.equals("true");
	}

	/**
	* Asserts that the DUT's volume (scale: [0, 100]) is within 5 points of an expected volume.
	* This accounts for small differences due to rounding when converting between volume scales.
	* Also asserts that the DUT's mute status is equal to {@code expectedMute}.
	*
	* Asserting both volume and mute at the same time saves a shell command because both are
	* conveyed in a single log message.
	*/
	private void assertApproximateDeviceVolumeAndMute(int expectedVolume, boolean expectedMute)
	throws Exception {
	// Raw output is equal to volume out of 100, plus 128 if muted
	// In practice, if the stream is muted, volume equals 0, so this will be at most 128
	int rawOutput = AudioManagerHelper.getDutAudioVolume(getDevice());

	int actualVolume = rawOutput % 128;
	assertWithMessage("Expected DUT to have volume " + expectedVolume
	+ " but was actually " + actualVolume)
	.that(Math.abs(expectedVolume - actualVolume) <= 5)
	.isTrue();

	boolean actualMute = rawOutput >= 128;
	String expectedMuteString = expectedMute ? "muted" : "unmuted";
	String actualMuteString = actualMute ? "muted" : "unmuted";
	assertWithMessage("Expected DUT to be " + expectedMuteString
	+ "but was actually " + actualMuteString)
	.that(expectedMute)
	.isEqualTo(actualMute);
	}
	}