1 /*
2  * Copyright (C) 2018 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package com.android.server.hdmi;
17 
18 import static com.android.server.SystemService.PHASE_SYSTEM_SERVICES_READY;
19 import static com.android.server.hdmi.Constants.ADDR_AUDIO_SYSTEM;
20 import static com.android.server.hdmi.Constants.ADDR_BROADCAST;
21 import static com.android.server.hdmi.Constants.ADDR_PLAYBACK_1;
22 import static com.android.server.hdmi.Constants.ADDR_TUNER_1;
23 import static com.android.server.hdmi.Constants.ADDR_TV;
24 import static com.android.server.hdmi.HdmiControlService.INITIATED_BY_ENABLE_CEC;
25 import static com.android.server.hdmi.HdmiControlService.STANDBY_SCREEN_OFF;
26 
27 import static com.google.common.truth.Truth.assertThat;
28 
29 import android.content.Context;
30 import android.hardware.hdmi.HdmiControlManager;
31 import android.hardware.hdmi.HdmiDeviceInfo;
32 import android.hardware.hdmi.HdmiPortInfo;
33 import android.hardware.hdmi.IHdmiControlCallback;
34 import android.media.AudioManager;
35 import android.os.Looper;
36 import android.os.test.TestLooper;
37 import android.platform.test.annotations.Presubmit;
38 
39 import androidx.test.InstrumentationRegistry;
40 import androidx.test.filters.SmallTest;
41 
42 import com.android.server.hdmi.HdmiCecLocalDevice.ActiveSource;
43 
44 import org.junit.Before;
45 import org.junit.Ignore;
46 import org.junit.Test;
47 import org.junit.runner.RunWith;
48 import org.junit.runners.JUnit4;
49 
50 import java.util.ArrayList;
51 
52 @SmallTest
53 @Presubmit
54 @RunWith(JUnit4.class)
55 /** Tests for {@link HdmiCecLocalDeviceAudioSystem} class. */
56 public class HdmiCecLocalDeviceAudioSystemTest {
57     private static final HdmiCecMessage MESSAGE_REQUEST_SAD_LCPM =
58             HdmiCecMessageBuilder.buildRequestShortAudioDescriptor(
59                     ADDR_TV, ADDR_AUDIO_SYSTEM, new int[] {Constants.AUDIO_CODEC_LPCM});
60 
61     private static final int EMPTY_FLAGS = 0;
62 
63     private HdmiControlService mHdmiControlService;
64     private HdmiCecController mHdmiCecController;
65     private HdmiCecLocalDeviceAudioSystem mHdmiCecLocalDeviceAudioSystem;
66     private HdmiCecLocalDevicePlayback mHdmiCecLocalDevicePlayback;
67     private FakeNativeWrapper mNativeWrapper;
68     private FakePowerManagerWrapper mPowerManager;
69     private FakeAudioFramework mAudioFramework;
70     private AudioManagerWrapper mAudioManager;
71     private Looper mMyLooper;
72     private TestLooper mTestLooper = new TestLooper();
73     private ArrayList<HdmiCecLocalDevice> mLocalDevices = new ArrayList<>();
74     private static final int SELF_PHYSICAL_ADDRESS = 0x2000;
75     private static final int HDMI_1_PHYSICAL_ADDRESS = 0x2100;
76     private static final int HDMI_2_PHYSICAL_ADDRESS = 0x2200;
77     private static final int HDMI_3_PHYSICAL_ADDRESS = 0x2300;
78     private int mInvokeDeviceEventState;
79     private HdmiDeviceInfo mDeviceInfo;
80     private boolean mArcSupport;
81     private HdmiPortInfo[] mHdmiPortInfo;
82     private ArrayList<Integer> mLocalDeviceTypes = new ArrayList<>();
83 
84     @Before
setUp()85     public void setUp() {
86         Context context = InstrumentationRegistry.getTargetContext();
87         mMyLooper = mTestLooper.getLooper();
88         mLocalDeviceTypes.add(HdmiDeviceInfo.DEVICE_PLAYBACK);
89         mLocalDeviceTypes.add(HdmiDeviceInfo.DEVICE_AUDIO_SYSTEM);
90 
91         mAudioFramework = new FakeAudioFramework();
92         mAudioManager = mAudioFramework.getAudioManager();
93         mHdmiControlService =
94             new HdmiControlService(InstrumentationRegistry.getTargetContext(),
95                     mLocalDeviceTypes, mAudioManager,
96                     mAudioFramework.getAudioDeviceVolumeManager()) {
97                 @Override
98                 void invokeDeviceEventListeners(HdmiDeviceInfo device, int status) {
99                     mDeviceInfo = device;
100                     mInvokeDeviceEventState = status;
101                 }
102 
103                 @Override
104                 protected void writeStringSystemProperty(String key, String value) {
105                     // do nothing
106                 }
107 
108                 @Override
109                 boolean readBooleanSystemProperty(String key, boolean defVal) {
110                     switch (key) {
111                         case Constants.PROPERTY_ARC_SUPPORT:
112                             return mArcSupport;
113                         default:
114                             return defVal;
115                     }
116                 }
117             };
118 
119         mHdmiControlService.getHdmiCecConfig().setIntValue(
120                 HdmiControlManager.CEC_SETTING_NAME_VOLUME_CONTROL_MODE,
121                 HdmiControlManager.VOLUME_CONTROL_ENABLED);
122         mMyLooper = mTestLooper.getLooper();
123         mHdmiControlService.setHdmiCecConfig(new FakeHdmiCecConfig(context));
124         mHdmiControlService.setDeviceConfig(new FakeDeviceConfigWrapper());
125         mHdmiCecLocalDeviceAudioSystem = new HdmiCecLocalDeviceAudioSystem(mHdmiControlService);
126         mHdmiCecLocalDevicePlayback = new HdmiCecLocalDevicePlayback(mHdmiControlService) {
127             @Override
128             protected int getPreferredAddress() {
129                 return ADDR_PLAYBACK_1;
130             }
131         };
132         mHdmiCecLocalDeviceAudioSystem.init();
133         mHdmiCecLocalDevicePlayback.init();
134         mHdmiControlService.setIoLooper(mMyLooper);
135         mNativeWrapper = new FakeNativeWrapper();
136         mNativeWrapper.setPhysicalAddress(SELF_PHYSICAL_ADDRESS);
137         mHdmiCecController = HdmiCecController.createWithNativeWrapper(
138                 mHdmiControlService, mNativeWrapper, mHdmiControlService.getAtomWriter());
139         mHdmiControlService.setCecController(mHdmiCecController);
140         mHdmiControlService.setHdmiMhlController(HdmiMhlControllerStub.create(mHdmiControlService));
141         mLocalDevices.add(mHdmiCecLocalDeviceAudioSystem);
142         mLocalDevices.add(mHdmiCecLocalDevicePlayback);
143         mHdmiCecLocalDeviceAudioSystem.setRoutingControlFeatureEnabled(true);
144         mHdmiPortInfo = new HdmiPortInfo[4];
145         mHdmiPortInfo[0] =
146             new HdmiPortInfo.Builder(0, HdmiPortInfo.PORT_INPUT, SELF_PHYSICAL_ADDRESS)
147                     .setCecSupported(true)
148                     .setMhlSupported(false)
149                     .setArcSupported(false)
150                     .build();
151         mHdmiPortInfo[1] =
152             new HdmiPortInfo.Builder(2, HdmiPortInfo.PORT_INPUT, HDMI_1_PHYSICAL_ADDRESS)
153                     .setCecSupported(true)
154                     .setMhlSupported(false)
155                     .setArcSupported(false)
156                     .build();
157         mHdmiPortInfo[2] =
158             new HdmiPortInfo.Builder(1, HdmiPortInfo.PORT_INPUT, HDMI_2_PHYSICAL_ADDRESS)
159                     .setCecSupported(true)
160                     .setMhlSupported(false)
161                     .setArcSupported(false)
162                     .build();
163         mHdmiPortInfo[3] =
164             new HdmiPortInfo.Builder(4, HdmiPortInfo.PORT_INPUT, HDMI_3_PHYSICAL_ADDRESS)
165                     .setCecSupported(true)
166                     .setMhlSupported(false)
167                     .setArcSupported(false)
168                     .build();
169         mNativeWrapper.setPortInfo(mHdmiPortInfo);
170         mHdmiControlService.initService();
171         mHdmiControlService.onBootPhase(PHASE_SYSTEM_SERVICES_READY);
172         mPowerManager = new FakePowerManagerWrapper(context);
173         mHdmiControlService.setPowerManager(mPowerManager);
174         // No TV device interacts with AVR so system audio control won't be turned on here
175         mHdmiControlService.allocateLogicalAddress(mLocalDevices, INITIATED_BY_ENABLE_CEC);
176         mTestLooper.dispatchAll();
177         mNativeWrapper.clearResultMessages();
178         mArcSupport = true;
179         mInvokeDeviceEventState = 0;
180         mDeviceInfo = null;
181     }
182 
183     @Test
handleGiveAudioStatus_volume_10_mute_true()184     public void handleGiveAudioStatus_volume_10_mute_true() throws Exception {
185         mAudioManager.setStreamVolume(AudioManager.STREAM_MUSIC, 10, EMPTY_FLAGS);
186         mAudioManager.adjustStreamVolume(AudioManager.STREAM_MUSIC, AudioManager.ADJUST_MUTE,
187                 EMPTY_FLAGS);
188         mAudioFramework.setStreamMaxVolume(AudioManager.STREAM_MUSIC, 20);
189         int scaledVolume = VolumeControlAction.scaleToCecVolume(10,
190                 mAudioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC));
191         HdmiCecMessage expectedMessage =
192                 HdmiCecMessageBuilder.buildReportAudioStatus(
193                         ADDR_AUDIO_SYSTEM, ADDR_TV, scaledVolume, true);
194         HdmiCecMessage messageGive =
195                 HdmiCecMessageBuilder.buildGiveAudioStatus(ADDR_TV, ADDR_AUDIO_SYSTEM);
196         assertThat(mHdmiCecLocalDeviceAudioSystem.handleGiveAudioStatus(messageGive))
197             .isEqualTo(Constants.HANDLED);
198         mTestLooper.dispatchAll();
199         assertThat(mNativeWrapper.getOnlyResultMessage()).isEqualTo(expectedMessage);
200     }
201 
202     @Test
203     @Ignore("b/120845532")
handleGiveSystemAudioModeStatus_originalOff()204     public void handleGiveSystemAudioModeStatus_originalOff() throws Exception {
205         HdmiCecMessage expectedMessage =
206                 HdmiCecMessageBuilder.buildReportSystemAudioMode(
207                         ADDR_AUDIO_SYSTEM, ADDR_TV, false);
208         HdmiCecMessage messageGive =
209                 HdmiCecMessageBuilder.buildGiveSystemAudioModeStatus(ADDR_TV, ADDR_AUDIO_SYSTEM);
210         assertThat(mHdmiCecLocalDeviceAudioSystem.handleGiveSystemAudioModeStatus(messageGive))
211                 .isEqualTo(Constants.HANDLED);
212         mTestLooper.dispatchAll();
213         assertThat(mNativeWrapper.getOnlyResultMessage()).isEqualTo(expectedMessage);
214     }
215 
216     @Test
handleRequestShortAudioDescriptor_featureDisabled()217     public void handleRequestShortAudioDescriptor_featureDisabled() throws Exception {
218         mHdmiCecLocalDeviceAudioSystem.setSystemAudioControlFeatureEnabled(false);
219         assertThat(mHdmiCecLocalDeviceAudioSystem.handleRequestShortAudioDescriptor(
220                 MESSAGE_REQUEST_SAD_LCPM))
221                 .isEqualTo(Constants.ABORT_REFUSED);
222     }
223 
224     @Test
handleRequestShortAudioDescriptor_samOff()225     public void handleRequestShortAudioDescriptor_samOff() throws Exception {
226         mHdmiCecLocalDeviceAudioSystem.checkSupportAndSetSystemAudioMode(false);
227         assertThat(mHdmiCecLocalDeviceAudioSystem.handleRequestShortAudioDescriptor(
228                 MESSAGE_REQUEST_SAD_LCPM))
229                 .isEqualTo(Constants.ABORT_NOT_IN_CORRECT_MODE);
230     }
231 
232     // Testing device has sadConfig.xml
233     @Ignore("b/120845532")
234     @Test
handleRequestShortAudioDescriptor_noAudioDeviceInfo()235     public void handleRequestShortAudioDescriptor_noAudioDeviceInfo() throws Exception {
236         HdmiCecMessage expectedMessage =
237                 HdmiCecMessageBuilder.buildFeatureAbortCommand(
238                         ADDR_AUDIO_SYSTEM,
239                         ADDR_TV,
240                         Constants.MESSAGE_REQUEST_SHORT_AUDIO_DESCRIPTOR,
241                         Constants.ABORT_UNABLE_TO_DETERMINE);
242 
243         mHdmiCecLocalDeviceAudioSystem.checkSupportAndSetSystemAudioMode(true);
244         assertThat(mHdmiCecLocalDeviceAudioSystem.handleRequestShortAudioDescriptor(
245                 MESSAGE_REQUEST_SAD_LCPM))
246                 .isEqualTo(Constants.HANDLED);
247         mTestLooper.dispatchAll();
248         assertThat(mNativeWrapper.getOnlyResultMessage()).isEqualTo(expectedMessage);
249     }
250 
251     @Test
252     @Ignore("b/120845532")
handleSetSystemAudioMode_setOn_orignalOff()253     public void handleSetSystemAudioMode_setOn_orignalOff() throws Exception {
254         mAudioManager.setStreamMute(AudioManager.STREAM_MUSIC, true);
255         HdmiCecMessage messageSet =
256                 HdmiCecMessageBuilder.buildSetSystemAudioMode(ADDR_TV, ADDR_AUDIO_SYSTEM, true);
257         HdmiCecMessage messageGive =
258                 HdmiCecMessageBuilder.buildGiveSystemAudioModeStatus(ADDR_TV, ADDR_AUDIO_SYSTEM);
259         // Check if originally off
260         HdmiCecMessage expectedMessage =
261                 HdmiCecMessageBuilder.buildReportSystemAudioMode(ADDR_AUDIO_SYSTEM, ADDR_TV, false);
262         assertThat(mHdmiCecLocalDeviceAudioSystem.handleGiveSystemAudioModeStatus(messageGive))
263             .isEqualTo(Constants.HANDLED);
264         mTestLooper.dispatchAll();
265         assertThat(mNativeWrapper.getOnlyResultMessage()).isEqualTo(expectedMessage);
266         // Check if correctly turned on
267         mNativeWrapper.clearResultMessages();
268         expectedMessage =
269             HdmiCecMessageBuilder.buildReportSystemAudioMode(ADDR_AUDIO_SYSTEM, ADDR_TV, true);
270         assertThat(mHdmiCecLocalDeviceAudioSystem.handleSetSystemAudioMode(messageSet))
271                 .isEqualTo(Constants.HANDLED);
272         mTestLooper.dispatchAll();
273         assertThat(mHdmiCecLocalDeviceAudioSystem.handleGiveSystemAudioModeStatus(messageGive))
274                 .isEqualTo(Constants.HANDLED);
275         mTestLooper.dispatchAll();
276         assertThat(mNativeWrapper.getOnlyResultMessage()).isEqualTo(expectedMessage);
277         assertThat(mAudioManager.isStreamMute(AudioManager.STREAM_MUSIC)).isFalse();
278     }
279 
280     @Test
281     @Ignore("b/120845532")
handleSystemAudioModeRequest_turnOffByTv()282     public void handleSystemAudioModeRequest_turnOffByTv() throws Exception {
283         assertThat(mAudioManager.isStreamMute(AudioManager.STREAM_MUSIC)).isFalse();
284         // Check if feature correctly turned off
285         HdmiCecMessage messageGive =
286                 HdmiCecMessageBuilder.buildGiveSystemAudioModeStatus(ADDR_TV, ADDR_AUDIO_SYSTEM);
287         HdmiCecMessage messageRequestOff =
288                 HdmiCecMessageBuilder.buildSystemAudioModeRequest(
289                         ADDR_TV, ADDR_AUDIO_SYSTEM, 2, false);
290         HdmiCecMessage expectedMessage =
291                 HdmiCecMessageBuilder.buildSetSystemAudioMode(
292                         ADDR_AUDIO_SYSTEM, ADDR_BROADCAST, false);
293         assertThat(mHdmiCecLocalDeviceAudioSystem.handleSystemAudioModeRequest(messageRequestOff))
294                 .isEqualTo(Constants.HANDLED);
295         mTestLooper.dispatchAll();
296         assertThat(mNativeWrapper.getOnlyResultMessage()).isEqualTo(expectedMessage);
297 
298         mNativeWrapper.clearResultMessages();
299         expectedMessage =
300             HdmiCecMessageBuilder.buildReportSystemAudioMode(ADDR_AUDIO_SYSTEM, ADDR_TV, false);
301         assertThat(mHdmiCecLocalDeviceAudioSystem.handleGiveSystemAudioModeStatus(messageGive))
302             .isEqualTo(Constants.HANDLED);
303         mTestLooper.dispatchAll();
304         assertThat(mNativeWrapper.getOnlyResultMessage()).isEqualTo(expectedMessage);
305         assertThat(mAudioManager.isStreamMute(AudioManager.STREAM_MUSIC)).isTrue();
306     }
307 
308     @Test
onStandbyAudioSystem_currentSystemAudioControlOn()309     public void onStandbyAudioSystem_currentSystemAudioControlOn() throws Exception {
310         // Set system audio control on first
311         mHdmiCecLocalDeviceAudioSystem.checkSupportAndSetSystemAudioMode(true);
312         // Check if standby correctly turns off the feature
313         mHdmiCecLocalDeviceAudioSystem.onStandby(false, STANDBY_SCREEN_OFF);
314         mTestLooper.dispatchAll();
315         HdmiCecMessage expectedMessage =
316                 HdmiCecMessageBuilder.buildSetSystemAudioMode(
317                         ADDR_AUDIO_SYSTEM, ADDR_BROADCAST, false);
318         assertThat(mNativeWrapper.getResultMessages()).contains(expectedMessage);
319         assertThat(mAudioManager.isStreamMute(AudioManager.STREAM_MUSIC)).isTrue();
320     }
321 
322     @Test
systemAudioControlOnPowerOn_alwaysOn()323     public void systemAudioControlOnPowerOn_alwaysOn() throws Exception {
324         mHdmiCecLocalDeviceAudioSystem.removeAction(SystemAudioInitiationActionFromAvr.class);
325         mHdmiCecLocalDeviceAudioSystem.systemAudioControlOnPowerOn(
326                 Constants.ALWAYS_SYSTEM_AUDIO_CONTROL_ON_POWER_ON, true);
327         assertThat(
328             mHdmiCecLocalDeviceAudioSystem.getActions(
329                 SystemAudioInitiationActionFromAvr.class))
330             .isNotEmpty();
331     }
332 
333     @Test
systemAudioControlOnPowerOn_neverOn()334     public void systemAudioControlOnPowerOn_neverOn() throws Exception {
335         mHdmiCecLocalDeviceAudioSystem.removeAction(SystemAudioInitiationActionFromAvr.class);
336         mHdmiCecLocalDeviceAudioSystem.systemAudioControlOnPowerOn(
337                 Constants.NEVER_SYSTEM_AUDIO_CONTROL_ON_POWER_ON, false);
338         assertThat(
339             mHdmiCecLocalDeviceAudioSystem.getActions(
340                 SystemAudioInitiationActionFromAvr.class))
341             .isEmpty();
342     }
343 
344     @Test
systemAudioControlOnPowerOn_useLastState_off()345     public void systemAudioControlOnPowerOn_useLastState_off() throws Exception {
346         mHdmiCecLocalDeviceAudioSystem.removeAction(SystemAudioInitiationActionFromAvr.class);
347         mHdmiCecLocalDeviceAudioSystem.systemAudioControlOnPowerOn(
348                 Constants.USE_LAST_STATE_SYSTEM_AUDIO_CONTROL_ON_POWER_ON, false);
349         assertThat(
350             mHdmiCecLocalDeviceAudioSystem.getActions(
351                 SystemAudioInitiationActionFromAvr.class))
352             .isEmpty();
353     }
354 
355     @Test
systemAudioControlOnPowerOn_useLastState_on()356     public void systemAudioControlOnPowerOn_useLastState_on() throws Exception {
357         mHdmiCecLocalDeviceAudioSystem.removeAction(SystemAudioInitiationActionFromAvr.class);
358         mHdmiCecLocalDeviceAudioSystem.systemAudioControlOnPowerOn(
359                 Constants.USE_LAST_STATE_SYSTEM_AUDIO_CONTROL_ON_POWER_ON, true);
360         assertThat(
361             mHdmiCecLocalDeviceAudioSystem.getActions(
362                 SystemAudioInitiationActionFromAvr.class))
363             .isNotEmpty();
364     }
365 
366     @Test
handleActiveSource_updateActiveSource()367     public void handleActiveSource_updateActiveSource() throws Exception {
368         HdmiCecMessage message = HdmiCecMessageBuilder.buildActiveSource(ADDR_TV, 0x0000);
369         ActiveSource expectedActiveSource = new ActiveSource(ADDR_TV, 0x0000);
370         assertThat(mHdmiCecLocalDeviceAudioSystem.handleActiveSource(message))
371                 .isEqualTo(Constants.HANDLED);
372         mTestLooper.dispatchAll();
373         assertThat(mHdmiCecLocalDeviceAudioSystem.getActiveSource().equals(expectedActiveSource))
374             .isTrue();
375     }
376 
377     @Test
systemAudioModeMuting_enabled()378     public void systemAudioModeMuting_enabled() {
379         mHdmiControlService.getHdmiCecConfig().setIntValue(
380                 HdmiControlManager.CEC_SETTING_NAME_SYSTEM_AUDIO_MODE_MUTING,
381                 HdmiControlManager.SYSTEM_AUDIO_MODE_MUTING_ENABLED);
382         mHdmiCecLocalDeviceAudioSystem.checkSupportAndSetSystemAudioMode(true);
383         assertThat(mHdmiCecLocalDeviceAudioSystem.isSystemAudioActivated()).isTrue();
384         assertThat(mHdmiControlService.getAudioManager().isStreamMute(
385                 AudioManager.STREAM_MUSIC)).isFalse();
386         mHdmiCecLocalDeviceAudioSystem.checkSupportAndSetSystemAudioMode(false);
387         assertThat(mHdmiCecLocalDeviceAudioSystem.isSystemAudioActivated()).isFalse();
388         assertThat(mHdmiControlService.getAudioManager().isStreamMute(
389                 AudioManager.STREAM_MUSIC)).isTrue();
390     }
391 
392     @Test
systemAudioModeMuting_disabled()393     public void systemAudioModeMuting_disabled() {
394         mHdmiControlService.getHdmiCecConfig().setIntValue(
395                 HdmiControlManager.CEC_SETTING_NAME_SYSTEM_AUDIO_MODE_MUTING,
396                 HdmiControlManager.SYSTEM_AUDIO_MODE_MUTING_DISABLED);
397         mHdmiCecLocalDeviceAudioSystem.checkSupportAndSetSystemAudioMode(true);
398         assertThat(mHdmiCecLocalDeviceAudioSystem.isSystemAudioActivated()).isTrue();
399         assertThat(mHdmiControlService.getAudioManager().isStreamMute(
400                 AudioManager.STREAM_MUSIC)).isFalse();
401         mHdmiCecLocalDeviceAudioSystem.checkSupportAndSetSystemAudioMode(false);
402         assertThat(mHdmiCecLocalDeviceAudioSystem.isSystemAudioActivated()).isFalse();
403         assertThat(mHdmiControlService.getAudioManager().isStreamMute(
404                 AudioManager.STREAM_MUSIC)).isFalse();
405         mHdmiControlService.getHdmiCecConfig().setIntValue(
406                 HdmiControlManager.CEC_SETTING_NAME_SYSTEM_AUDIO_MODE_MUTING,
407                 HdmiControlManager.SYSTEM_AUDIO_MODE_MUTING_ENABLED);
408     }
409 
410     @Test
terminateSystemAudioMode_systemAudioModeOff()411     public void terminateSystemAudioMode_systemAudioModeOff() throws Exception {
412         mHdmiCecLocalDeviceAudioSystem.checkSupportAndSetSystemAudioMode(false);
413         assertThat(mHdmiCecLocalDeviceAudioSystem.isSystemAudioActivated()).isFalse();
414         mAudioManager.setStreamMute(AudioManager.STREAM_MUSIC, false);
415         HdmiCecMessage message =
416                 HdmiCecMessageBuilder.buildSetSystemAudioMode(
417                         ADDR_AUDIO_SYSTEM, ADDR_BROADCAST, false);
418         mHdmiCecLocalDeviceAudioSystem.terminateSystemAudioMode();
419         assertThat(mHdmiCecLocalDeviceAudioSystem.isSystemAudioActivated()).isFalse();
420         assertThat(mAudioManager.isStreamMute(AudioManager.STREAM_MUSIC)).isFalse();
421         assertThat(mNativeWrapper.getResultMessages()).isEmpty();
422     }
423 
424     @Test
terminateSystemAudioMode_systemAudioModeOn()425     public void terminateSystemAudioMode_systemAudioModeOn() throws Exception {
426         mHdmiCecLocalDeviceAudioSystem.checkSupportAndSetSystemAudioMode(true);
427         assertThat(mHdmiCecLocalDeviceAudioSystem.isSystemAudioActivated()).isTrue();
428         mAudioManager.setStreamMute(AudioManager.STREAM_MUSIC, false);
429         HdmiCecMessage expectedMessage =
430                 HdmiCecMessageBuilder.buildSetSystemAudioMode(
431                         ADDR_AUDIO_SYSTEM, ADDR_BROADCAST, false);
432         mHdmiCecLocalDeviceAudioSystem.terminateSystemAudioMode();
433         assertThat(mHdmiCecLocalDeviceAudioSystem.isSystemAudioActivated()).isFalse();
434         assertThat(mAudioManager.isStreamMute(AudioManager.STREAM_MUSIC)).isTrue();
435         mTestLooper.dispatchAll();
436         assertThat(mNativeWrapper.getResultMessages()).contains(expectedMessage);
437     }
438 
439     @Test
handleRequestArcInitiate_isNotDirectConnectedToTv()440     public void handleRequestArcInitiate_isNotDirectConnectedToTv() throws Exception {
441         HdmiCecMessage message =
442                 HdmiCecMessageBuilder.buildRequestArcInitiation(ADDR_TV, ADDR_AUDIO_SYSTEM);
443         mNativeWrapper.setPhysicalAddress(0x1100);
444 
445         assertThat(mHdmiCecLocalDeviceAudioSystem.handleRequestArcInitiate(message))
446                 .isEqualTo(Constants.ABORT_NOT_IN_CORRECT_MODE);
447     }
448 
449     @Test
handleRequestArcInitiate_startArcInitiationActionFromAvr()450     public void handleRequestArcInitiate_startArcInitiationActionFromAvr() throws Exception {
451         HdmiCecMessage message =
452                 HdmiCecMessageBuilder.buildRequestArcInitiation(ADDR_TV, ADDR_AUDIO_SYSTEM);
453         mNativeWrapper.setPhysicalAddress(0x1000);
454         mHdmiCecLocalDeviceAudioSystem.removeAction(ArcInitiationActionFromAvr.class);
455 
456         assertThat(mHdmiCecLocalDeviceAudioSystem.handleRequestArcInitiate(message))
457                 .isEqualTo(Constants.HANDLED);
458         mTestLooper.dispatchAll();
459         assertThat(mHdmiCecLocalDeviceAudioSystem.getActions(ArcInitiationActionFromAvr.class))
460             .isNotEmpty();
461     }
462 
463     @Test
handleRequestArcTerminate_arcIsOn_startTerminationActionFromAvr()464     public void handleRequestArcTerminate_arcIsOn_startTerminationActionFromAvr() throws Exception {
465         mHdmiCecLocalDeviceAudioSystem.setArcStatus(true);
466         assertThat(mHdmiCecLocalDeviceAudioSystem.isArcEnabled()).isTrue();
467 
468         HdmiCecMessage message =
469                 HdmiCecMessageBuilder.buildRequestArcTermination(ADDR_TV, ADDR_AUDIO_SYSTEM);
470         mHdmiCecLocalDeviceAudioSystem.removeAction(ArcTerminationActionFromAvr.class);
471 
472         assertThat(mHdmiCecLocalDeviceAudioSystem.handleRequestArcTermination(message))
473                 .isEqualTo(Constants.HANDLED);
474         mTestLooper.dispatchAll();
475         assertThat(mHdmiCecLocalDeviceAudioSystem.getActions(ArcTerminationActionFromAvr.class))
476             .isNotEmpty();
477     }
478 
479     @Test
480     @Ignore("b/120845532")
handleRequestArcTerminate_arcIsNotOn()481     public void handleRequestArcTerminate_arcIsNotOn() throws Exception {
482         assertThat(mHdmiCecLocalDeviceAudioSystem.isArcEnabled()).isFalse();
483         HdmiCecMessage message =
484                 HdmiCecMessageBuilder.buildRequestArcTermination(ADDR_TV, ADDR_AUDIO_SYSTEM);
485         HdmiCecMessage expectedMessage =
486                 HdmiCecMessageBuilder.buildFeatureAbortCommand(
487                         ADDR_AUDIO_SYSTEM,
488                         ADDR_TV,
489                         Constants.MESSAGE_REQUEST_ARC_TERMINATION,
490                         Constants.ABORT_NOT_IN_CORRECT_MODE);
491 
492         assertThat(mHdmiCecLocalDeviceAudioSystem.handleRequestArcTermination(message))
493                 .isEqualTo(Constants.HANDLED);
494         mTestLooper.dispatchAll();
495         assertThat(mNativeWrapper.getResultMessages()).contains(expectedMessage);
496     }
497 
498     @Test
handleRequestArcTerminate_callbackIsPreserved()499     public void handleRequestArcTerminate_callbackIsPreserved() throws Exception {
500         TestCallback callback = new TestCallback();
501 
502         mHdmiCecLocalDeviceAudioSystem.setArcStatus(true);
503         assertThat(mHdmiCecLocalDeviceAudioSystem.isArcEnabled()).isTrue();
504         mHdmiCecLocalDeviceAudioSystem.addAndStartAction(
505                 new ArcTerminationActionFromAvr(mHdmiCecLocalDeviceAudioSystem, callback));
506 
507         HdmiCecMessage message =
508                 HdmiCecMessageBuilder.buildRequestArcTermination(ADDR_TV, ADDR_AUDIO_SYSTEM);
509         assertThat(mHdmiCecLocalDeviceAudioSystem.handleRequestArcTermination(message))
510                 .isEqualTo(Constants.HANDLED);
511 
512         mTestLooper.dispatchAll();
513         assertThat(mHdmiCecLocalDeviceAudioSystem.getActions(
514                 ArcTerminationActionFromAvr.class).get(0).mCallbacks.get(0)).isEqualTo(callback);
515     }
516 
517     @Test
handleRequestArcInit_arcIsNotSupported()518     public void handleRequestArcInit_arcIsNotSupported() throws Exception {
519         HdmiCecMessage message =
520                 HdmiCecMessageBuilder.buildRequestArcInitiation(ADDR_TV, ADDR_AUDIO_SYSTEM);
521         mArcSupport = false;
522 
523         assertThat(mHdmiCecLocalDeviceAudioSystem.handleRequestArcInitiate(message))
524                 .isEqualTo(Constants.ABORT_UNRECOGNIZED_OPCODE);
525     }
526 
527     @Test
setArcStatus()528     public void setArcStatus() {
529         mHdmiCecLocalDeviceAudioSystem.setArcStatus(true);
530         assertThat(mHdmiCecLocalDeviceAudioSystem.isArcEnabled()).isTrue();
531 
532         mHdmiCecLocalDeviceAudioSystem.setArcStatus(false);
533         assertThat(mHdmiCecLocalDeviceAudioSystem.isArcEnabled()).isFalse();
534     }
535 
536     @Test
537     @Ignore("b/151150320")
handleSystemAudioModeRequest_fromNonTV_tVNotSupport()538     public void handleSystemAudioModeRequest_fromNonTV_tVNotSupport() {
539         HdmiCecMessage message =
540                 HdmiCecMessageBuilder.buildSystemAudioModeRequest(
541                         ADDR_TUNER_1, ADDR_AUDIO_SYSTEM,
542                         SELF_PHYSICAL_ADDRESS, true);
543         HdmiCecMessage expectedMessage =
544                 HdmiCecMessageBuilder.buildFeatureAbortCommand(
545                         ADDR_AUDIO_SYSTEM,
546                         ADDR_TUNER_1,
547                         Constants.MESSAGE_SYSTEM_AUDIO_MODE_REQUEST,
548                         Constants.ABORT_REFUSED);
549 
550         assertThat(mHdmiCecLocalDeviceAudioSystem.handleSystemAudioModeRequest(message))
551                 .isEqualTo(Constants.ABORT_UNRECOGNIZED_OPCODE);
552         mTestLooper.dispatchAll();
553         assertThat(mNativeWrapper.getOnlyResultMessage()).isEqualTo(expectedMessage);
554     }
555 
556     @Test
handleSystemAudioModeRequest_fromNonTV_tVSupport()557     public void handleSystemAudioModeRequest_fromNonTV_tVSupport() {
558         HdmiCecMessage message =
559                 HdmiCecMessageBuilder.buildSystemAudioModeRequest(
560                         ADDR_TUNER_1, ADDR_AUDIO_SYSTEM,
561                         SELF_PHYSICAL_ADDRESS, true);
562         HdmiCecMessage expectedMessage =
563                 HdmiCecMessageBuilder.buildSetSystemAudioMode(
564                         ADDR_AUDIO_SYSTEM, Constants.ADDR_BROADCAST, true);
565         mHdmiCecLocalDeviceAudioSystem.setTvSystemAudioModeSupport(true);
566 
567 
568         assertThat(mHdmiCecLocalDeviceAudioSystem.handleSystemAudioModeRequest(message))
569                 .isEqualTo(Constants.HANDLED);
570         mTestLooper.dispatchAll();
571         assertThat(mNativeWrapper.getOnlyResultMessage()).isEqualTo(expectedMessage);
572     }
573 
574     @Test
handleActiveSource_activeSourceFromTV_swithToArc()575     public void handleActiveSource_activeSourceFromTV_swithToArc() {
576         mHdmiCecLocalDeviceAudioSystem.setArcStatus(true);
577         HdmiCecMessage message =
578                 HdmiCecMessageBuilder.buildActiveSource(ADDR_TV, 0x0000);
579 
580         ActiveSource expectedActiveSource = ActiveSource.of(ADDR_TV, 0x0000);
581 
582         assertThat(mHdmiCecLocalDeviceAudioSystem.handleActiveSource(message))
583                 .isEqualTo(Constants.HANDLED);
584         mTestLooper.dispatchAll();
585         assertThat(mHdmiCecLocalDeviceAudioSystem.getActiveSource())
586             .isEqualTo(expectedActiveSource);
587     }
588 
589     @Test
590     @Ignore("b/151150320")
handleRoutingChange_currentActivePortIsHome()591     public void handleRoutingChange_currentActivePortIsHome() {
592         HdmiCecMessage message =
593                 HdmiCecMessageBuilder.buildRoutingChange(ADDR_TV, 0x3000, SELF_PHYSICAL_ADDRESS);
594 
595         HdmiCecMessage expectedMessage =
596                 HdmiCecMessageBuilder.buildActiveSource(ADDR_PLAYBACK_1, SELF_PHYSICAL_ADDRESS);
597         ActiveSource expectedActiveSource = ActiveSource.of(ADDR_PLAYBACK_1, SELF_PHYSICAL_ADDRESS);
598         int expectedLocalActivePort = Constants.CEC_SWITCH_HOME;
599 
600         assertThat(mHdmiCecLocalDeviceAudioSystem.handleRoutingChange(message))
601                 .isEqualTo(Constants.HANDLED);
602         mTestLooper.dispatchAll();
603         assertThat(mHdmiCecLocalDeviceAudioSystem.getActiveSource())
604             .isEqualTo(expectedActiveSource);
605         assertThat(mHdmiCecLocalDeviceAudioSystem.getRoutingPort())
606             .isEqualTo(expectedLocalActivePort);
607         assertThat(mNativeWrapper.getResultMessages()).contains(expectedMessage);
608     }
609 
610     @Test
handleRoutingInformation_currentActivePortIsHDMI1()611     public void handleRoutingInformation_currentActivePortIsHDMI1() {
612         HdmiCecMessage message =
613                 HdmiCecMessageBuilder.buildRoutingInformation(ADDR_TV, SELF_PHYSICAL_ADDRESS);
614         mHdmiCecLocalDeviceAudioSystem.setRoutingPort(mHdmiPortInfo[1].getId());
615         HdmiCecMessage expectedMessage =
616                 HdmiCecMessageBuilder.buildRoutingInformation(
617                         ADDR_AUDIO_SYSTEM, HDMI_1_PHYSICAL_ADDRESS);
618 
619         assertThat(mHdmiCecLocalDeviceAudioSystem.handleRoutingInformation(message))
620                 .isEqualTo(Constants.HANDLED);
621         mTestLooper.dispatchAll();
622         assertThat(mNativeWrapper.getOnlyResultMessage()).isEqualTo(expectedMessage);
623     }
624 
625     @Ignore("b/120845532")
626     @Test
handleRoutingChange_homeIsActive_playbackSendActiveSource()627     public void handleRoutingChange_homeIsActive_playbackSendActiveSource() {
628         HdmiCecMessage message =
629                 HdmiCecMessageBuilder.buildRoutingChange(ADDR_TV, 0x0000, 0x2000);
630 
631         HdmiCecMessage expectedMessage =
632                 HdmiCecMessageBuilder.buildActiveSource(ADDR_PLAYBACK_1, 0x2000);
633 
634         assertThat(mHdmiCecLocalDeviceAudioSystem.handleRoutingChange(message))
635                 .isEqualTo(Constants.HANDLED);
636         mTestLooper.dispatchAll();
637         assertThat(mNativeWrapper.getResultMessages()).contains(expectedMessage);
638     }
639 
640     @Test
doNotWakeUpOnHotPlug_PlugIn()641     public void doNotWakeUpOnHotPlug_PlugIn() {
642         mPowerManager.setInteractive(false);
643         mHdmiCecLocalDeviceAudioSystem.onHotplug(0, true);
644         assertThat(mPowerManager.isInteractive()).isFalse();
645     }
646 
647     @Test
doNotWakeUpOnHotPlug_PlugOut()648     public void doNotWakeUpOnHotPlug_PlugOut() {
649         mPowerManager.setInteractive(false);
650         mHdmiCecLocalDeviceAudioSystem.onHotplug(0, false);
651         assertThat(mPowerManager.isInteractive()).isFalse();
652     }
653 
654     @Test
giveAudioStatus_volumeEnabled()655     public void giveAudioStatus_volumeEnabled() {
656         mHdmiControlService.setHdmiCecVolumeControlEnabledInternal(
657                 HdmiControlManager.VOLUME_CONTROL_ENABLED);
658         mHdmiCecLocalDeviceAudioSystem.setSystemAudioControlFeatureEnabled(true);
659 
660         int volume = mHdmiControlService.getAudioManager()
661                 .getStreamVolume(AudioManager.STREAM_MUSIC);
662         boolean mute = mHdmiControlService.getAudioManager()
663                 .isStreamMute(AudioManager.STREAM_MUSIC);
664         int maxVolume = mHdmiControlService.getAudioManager()
665                 .getStreamMaxVolume(AudioManager.STREAM_MUSIC);
666         int scaledVolume = VolumeControlAction.scaleToCecVolume(volume, maxVolume);
667         HdmiCecMessage expected = HdmiCecMessageBuilder.buildReportAudioStatus(ADDR_AUDIO_SYSTEM,
668                 ADDR_TV, scaledVolume, mute);
669 
670         HdmiCecMessage giveAudioStatus = HdmiCecMessageBuilder.buildGiveAudioStatus(ADDR_TV,
671                 ADDR_AUDIO_SYSTEM);
672         mNativeWrapper.clearResultMessages();
673         assertThat(mHdmiCecLocalDeviceAudioSystem.handleGiveAudioStatus(giveAudioStatus))
674                         .isEqualTo(Constants.HANDLED);
675         mTestLooper.dispatchAll();
676 
677         assertThat(mNativeWrapper.getResultMessages()).contains(expected);
678     }
679 
680     @Test
giveAudioStatus_volumeDisabled()681     public void giveAudioStatus_volumeDisabled() {
682         mHdmiControlService.setHdmiCecVolumeControlEnabledInternal(
683                 HdmiControlManager.VOLUME_CONTROL_DISABLED);
684         mHdmiCecLocalDeviceAudioSystem.setSystemAudioControlFeatureEnabled(true);
685 
686         int volume = mHdmiControlService.getAudioManager()
687                 .getStreamVolume(AudioManager.STREAM_MUSIC);
688         boolean mute = mHdmiControlService.getAudioManager()
689                 .isStreamMute(AudioManager.STREAM_MUSIC);
690         int maxVolume = mHdmiControlService.getAudioManager()
691                 .getStreamMaxVolume(AudioManager.STREAM_MUSIC);
692         int scaledVolume = VolumeControlAction.scaleToCecVolume(volume, maxVolume);
693         HdmiCecMessage unexpected = HdmiCecMessageBuilder.buildReportAudioStatus(ADDR_AUDIO_SYSTEM,
694                 ADDR_TV, scaledVolume, mute);
695 
696         HdmiCecMessage giveAudioStatus = HdmiCecMessageBuilder.buildGiveAudioStatus(ADDR_TV,
697                 ADDR_AUDIO_SYSTEM);
698         mNativeWrapper.clearResultMessages();
699         assertThat(mHdmiCecLocalDeviceAudioSystem.handleGiveAudioStatus(giveAudioStatus))
700                 .isEqualTo(Constants.ABORT_REFUSED);
701         mTestLooper.dispatchAll();
702 
703         assertThat(mNativeWrapper.getResultMessages()).doesNotContain(unexpected);
704     }
705 
706     @Test
reportAudioStatus_volumeEnabled()707     public void reportAudioStatus_volumeEnabled() {
708         mHdmiControlService.setHdmiCecVolumeControlEnabledInternal(
709                 HdmiControlManager.VOLUME_CONTROL_ENABLED);
710         mHdmiCecLocalDeviceAudioSystem.setSystemAudioControlFeatureEnabled(true);
711 
712         int volume = mHdmiControlService.getAudioManager()
713                 .getStreamVolume(AudioManager.STREAM_MUSIC);
714         boolean mute = mHdmiControlService.getAudioManager()
715                 .isStreamMute(AudioManager.STREAM_MUSIC);
716         int maxVolume = mHdmiControlService.getAudioManager()
717                 .getStreamMaxVolume(AudioManager.STREAM_MUSIC);
718         int scaledVolume = VolumeControlAction.scaleToCecVolume(volume, maxVolume);
719         HdmiCecMessage expected = HdmiCecMessageBuilder.buildReportAudioStatus(ADDR_AUDIO_SYSTEM,
720                 ADDR_TV, scaledVolume, mute);
721 
722         mNativeWrapper.clearResultMessages();
723         mHdmiCecLocalDeviceAudioSystem.reportAudioStatus(ADDR_TV);
724         mTestLooper.dispatchAll();
725 
726         assertThat(mNativeWrapper.getResultMessages()).contains(expected);
727     }
728 
729     @Test
reportAudioStatus_volumeDisabled()730     public void reportAudioStatus_volumeDisabled() {
731         mHdmiControlService.setHdmiCecVolumeControlEnabledInternal(
732                 HdmiControlManager.VOLUME_CONTROL_DISABLED);
733         mHdmiCecLocalDeviceAudioSystem.setSystemAudioControlFeatureEnabled(true);
734 
735         int volume = mHdmiControlService.getAudioManager()
736                 .getStreamVolume(AudioManager.STREAM_MUSIC);
737         boolean mute = mHdmiControlService.getAudioManager()
738                 .isStreamMute(AudioManager.STREAM_MUSIC);
739         int maxVolume = mHdmiControlService.getAudioManager()
740                 .getStreamMaxVolume(AudioManager.STREAM_MUSIC);
741         int scaledVolume = VolumeControlAction.scaleToCecVolume(volume, maxVolume);
742         HdmiCecMessage unexpected = HdmiCecMessageBuilder.buildReportAudioStatus(ADDR_AUDIO_SYSTEM,
743                 ADDR_TV, scaledVolume, mute);
744 
745         mNativeWrapper.clearResultMessages();
746         mHdmiCecLocalDeviceAudioSystem.reportAudioStatus(ADDR_TV);
747         mTestLooper.dispatchAll();
748 
749         assertThat(mNativeWrapper.getResultMessages()).doesNotContain(unexpected);
750     }
751 
752     @Test
setActiveSource_localDevice_playback()753     public void setActiveSource_localDevice_playback() {
754         mHdmiControlService.setActiveSource(
755                 mHdmiCecLocalDevicePlayback.getDeviceInfo().getLogicalAddress(),
756                 SELF_PHYSICAL_ADDRESS,
757                 "HdmiControlServiceTest");
758 
759         assertThat(mHdmiControlService.getLocalActiveSource().logicalAddress)
760                 .isEqualTo(mHdmiCecLocalDevicePlayback.getDeviceInfo().getLogicalAddress());
761         assertThat(mHdmiControlService.getLocalActiveSource().physicalAddress).isEqualTo(
762                 SELF_PHYSICAL_ADDRESS);
763         assertThat(mHdmiCecLocalDevicePlayback.isActiveSource()).isTrue();
764         assertThat(mHdmiCecLocalDeviceAudioSystem.isActiveSource()).isFalse();
765     }
766 
767     @Test
setActiveSource_localDevice_audio()768     public void setActiveSource_localDevice_audio() {
769         mHdmiControlService.setActiveSource(
770                 mHdmiCecLocalDeviceAudioSystem.getDeviceInfo().getLogicalAddress(),
771                 SELF_PHYSICAL_ADDRESS,
772                 "HdmiControlServiceTest");
773 
774         assertThat(mHdmiControlService.getLocalActiveSource().logicalAddress)
775                 .isEqualTo(mHdmiCecLocalDeviceAudioSystem.getDeviceInfo().getLogicalAddress());
776         assertThat(mHdmiControlService.getLocalActiveSource().physicalAddress).isEqualTo(
777                 SELF_PHYSICAL_ADDRESS);
778         assertThat(mHdmiCecLocalDevicePlayback.isActiveSource()).isFalse();
779         assertThat(mHdmiCecLocalDeviceAudioSystem.isActiveSource()).isTrue();
780     }
781 
782     @Test
setActiveSource_remoteDevice()783     public void setActiveSource_remoteDevice() {
784         mHdmiControlService.setActiveSource(Constants.ADDR_TV, 0x0000, "HdmiControlServiceTest");
785 
786         assertThat(mHdmiControlService.getLocalActiveSource().logicalAddress).isEqualTo(
787                 Constants.ADDR_TV);
788         assertThat(mHdmiControlService.getLocalActiveSource().physicalAddress).isEqualTo(0x000);
789         assertThat(mHdmiCecLocalDevicePlayback.isActiveSource()).isFalse();
790         assertThat(mHdmiCecLocalDeviceAudioSystem.isActiveSource()).isFalse();
791     }
792 
793     @Test
setActiveSource_nonCecDevice()794     public void setActiveSource_nonCecDevice() {
795         mHdmiControlService.setActiveSource(Constants.ADDR_INVALID, 0x1234,
796                 "HdmiControlServiceTest");
797 
798         assertThat(mHdmiControlService.getLocalActiveSource().logicalAddress).isEqualTo(
799                 Constants.ADDR_INVALID);
800         assertThat(mHdmiControlService.getLocalActiveSource().physicalAddress).isEqualTo(0x1234);
801         assertThat(mHdmiCecLocalDevicePlayback.isActiveSource()).isFalse();
802         assertThat(mHdmiCecLocalDeviceAudioSystem.isActiveSource()).isFalse();
803     }
804 
805     @Test
setActiveSource_unknown()806     public void setActiveSource_unknown() {
807         mHdmiControlService.setActiveSource(Constants.ADDR_INVALID,
808                 Constants.INVALID_PHYSICAL_ADDRESS, "HdmiControlServiceTest");
809 
810         assertThat(mHdmiControlService.getLocalActiveSource().logicalAddress).isEqualTo(
811                 Constants.ADDR_INVALID);
812         assertThat(mHdmiControlService.getLocalActiveSource().physicalAddress).isEqualTo(
813                 Constants.INVALID_PHYSICAL_ADDRESS);
814         assertThat(mHdmiCecLocalDevicePlayback.isActiveSource()).isFalse();
815         assertThat(mHdmiCecLocalDeviceAudioSystem.isActiveSource()).isFalse();
816     }
817 
818     @Test
819     @Ignore("b/151150320")
oneTouchPlay()820     public void oneTouchPlay() {
821         mHdmiControlService.oneTouchPlay(new IHdmiControlCallback.Stub() {
822             @Override
823             public void onComplete(int result) {
824             }
825         });
826         mTestLooper.dispatchAll();
827 
828         HdmiCecMessage textViewOn_fromPlayback = HdmiCecMessageBuilder.buildTextViewOn(
829                 mHdmiCecLocalDevicePlayback.getDeviceInfo().getLogicalAddress(), ADDR_TV);
830         HdmiCecMessage activeSource_fromPlayback = HdmiCecMessageBuilder.buildActiveSource(
831                 mHdmiCecLocalDevicePlayback.getDeviceInfo().getLogicalAddress(),
832                 SELF_PHYSICAL_ADDRESS);
833         HdmiCecMessage systemAudioModeRequest_fromPlayback =
834                 HdmiCecMessageBuilder.buildSystemAudioModeRequest(
835                         mHdmiCecLocalDevicePlayback.getDeviceInfo().getLogicalAddress(),
836                         ADDR_AUDIO_SYSTEM, SELF_PHYSICAL_ADDRESS, true);
837         HdmiCecMessage textViewOn_fromAudioSystem = HdmiCecMessageBuilder.buildTextViewOn(
838                 mHdmiCecLocalDeviceAudioSystem.getDeviceInfo().getLogicalAddress(), ADDR_TV);
839         HdmiCecMessage activeSource_fromAudioSystem = HdmiCecMessageBuilder.buildActiveSource(
840                 mHdmiCecLocalDeviceAudioSystem.getDeviceInfo().getLogicalAddress(),
841                 SELF_PHYSICAL_ADDRESS);
842         HdmiCecMessage systemAudioModeRequest_fromAudioSystem =
843                 HdmiCecMessageBuilder.buildSystemAudioModeRequest(
844                         mHdmiCecLocalDeviceAudioSystem.getDeviceInfo().getLogicalAddress(),
845                         ADDR_AUDIO_SYSTEM, SELF_PHYSICAL_ADDRESS, true);
846         assertThat(mNativeWrapper.getResultMessages()).contains(textViewOn_fromPlayback);
847         assertThat(mNativeWrapper.getResultMessages()).contains(activeSource_fromPlayback);
848         assertThat(mNativeWrapper.getResultMessages()).doesNotContain(
849                 systemAudioModeRequest_fromPlayback);
850         assertThat(mNativeWrapper.getResultMessages()).doesNotContain(textViewOn_fromAudioSystem);
851         assertThat(mNativeWrapper.getResultMessages()).doesNotContain(activeSource_fromAudioSystem);
852         assertThat(mNativeWrapper.getResultMessages()).doesNotContain(
853                 systemAudioModeRequest_fromAudioSystem);
854     }
855 
856     private static class TestCallback extends IHdmiControlCallback.Stub {
857         private final ArrayList<Integer> mCallbackResult = new ArrayList<Integer>();
858 
859         @Override
onComplete(int result)860         public void onComplete(int result) {
861             mCallbackResult.add(result);
862         }
863     }
864 }
865