• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2021 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 
17 package android.platform.helpers;
18 
19 import android.app.Instrumentation;
20 import android.app.UiAutomation;
21 import android.content.Context;
22 import android.media.session.MediaController;
23 import android.media.session.MediaSessionManager;
24 import android.media.session.PlaybackState;
25 import android.platform.helpers.ScrollUtility.ScrollActions;
26 import android.platform.helpers.ScrollUtility.ScrollDirection;
27 import android.platform.helpers.exceptions.UnknownUiException;
28 
29 import androidx.test.uiautomator.By;
30 import androidx.test.uiautomator.BySelector;
31 import androidx.test.uiautomator.Direction;
32 import androidx.test.uiautomator.UiObject;
33 import androidx.test.uiautomator.UiObject2;
34 import androidx.test.uiautomator.UiObjectNotFoundException;
35 
36 import java.util.List;
37 import java.util.regex.Pattern;
38 
39 /**
40  * Helper class for functional test for Mediacenter test
41  */
42 public class MediaCenterHelperImpl extends AbstractStandardAppHelper implements IAutoMediaHelper {
43 
44     private MediaSessionManager mMediaSessionManager;
45     private UiAutomation mUiAutomation;
46 
47     private ScrollUtility mScrollUtility;
48     private ScrollActions mScrollAction;
49     private BySelector mBackwardButtonSelector;
50     private BySelector mForwardButtonSelector;
51     private BySelector mScrollableElementSelector;
52     private ScrollDirection mScrollDirection;
53 
MediaCenterHelperImpl(Instrumentation instr)54     public MediaCenterHelperImpl(Instrumentation instr) {
55         super(instr);
56         mUiAutomation = instr.getUiAutomation();
57         mUiAutomation.adoptShellPermissionIdentity("android.permission.MEDIA_CONTENT_CONTROL");
58         mMediaSessionManager =
59                 (MediaSessionManager)
60                         instr.getContext().getSystemService(Context.MEDIA_SESSION_SERVICE);
61         mScrollUtility = ScrollUtility.getInstance(getSpectatioUiUtil());
62         mScrollAction =
63                 ScrollActions.valueOf(
64                         getActionFromConfig(AutomotiveConfigConstants.MEDIA_APP_SCROLL_ACTION));
65         mBackwardButtonSelector =
66                 getUiElementFromConfig(AutomotiveConfigConstants.MEDIA_APP_SCROLL_FORWARD_BUTTON);
67         mForwardButtonSelector =
68                 getUiElementFromConfig(AutomotiveConfigConstants.MEDIA_APP_SCROLL_BACKWARD_BUTTON);
69         mScrollableElementSelector =
70                 getUiElementFromConfig(AutomotiveConfigConstants.MEDIA_APP_SCROLL_ELEMENT);
71         mScrollDirection =
72                 ScrollDirection.valueOf(
73                         getActionFromConfig(AutomotiveConfigConstants.MEDIA_APP_SCROLL_DIRECTION));
74     }
75 
76     /**
77      * {@inheritDoc}
78      */
79     @Override
exit()80     public void exit() {
81         getSpectatioUiUtil().pressHome();
82         getSpectatioUiUtil().wait1Second();
83     }
84 
85     /**
86      * {@inheritDoc}
87      */
88     @Override
getLauncherName()89     public String getLauncherName() {
90         throw new UnsupportedOperationException("Operation not supported.");
91     }
92 
93     /**
94      * {@inheritDoc}
95      */
96     @Override
dismissInitialDialogs()97     public void dismissInitialDialogs() {
98         // Nothing to dismiss
99     }
100 
101     /**
102      * {@inheritDoc}
103      */
104     @Override
scrollUpOnePage()105     public boolean scrollUpOnePage() {
106         return false;
107     }
108 
109     /**
110      * {@inheritDoc}
111      */
112     @Override
scrollDownOnePage()113     public boolean scrollDownOnePage() {
114         return false;
115     }
116 
117     /**
118      * {@inheritDoc}
119      */
120     @Override
getPackage()121     public String getPackage() {
122         return getPackageFromConfig(AutomotiveConfigConstants.MEDIA_CENTER_PACKAGE);
123     }
124 
125     /**
126      * {@inheritDoc}
127      */
open()128     public void open() {
129         openMediaApp();
130     }
131 
openMediaApp()132     private void openMediaApp() {
133         getSpectatioUiUtil().pressHome();
134         getSpectatioUiUtil().waitForIdle();
135         getSpectatioUiUtil()
136                 .executeShellCommand(
137                         getCommandFromConfig(AutomotiveConfigConstants.MEDIA_LAUNCH_COMMAND));
138     }
139 
140     /**
141      * {@inheritDoc}
142      */
playMedia()143     public void playMedia() {
144         if (!isPlaying()) {
145             BySelector playButtonSelector =
146                     getUiElementFromConfig(AutomotiveConfigConstants.PLAY_PAUSE_BUTTON);
147             UiObject2 playButton = getSpectatioUiUtil().findUiObject(playButtonSelector);
148             getSpectatioUiUtil()
149                     .validateUiObject(playButton, AutomotiveConfigConstants.PLAY_PAUSE_BUTTON);
150             getSpectatioUiUtil().clickAndWait(playButton);
151             getSpectatioUiUtil().wait5Seconds();
152         }
153     }
154 
155     /**
156      * {@inheritDoc}
157      */
playPauseMediaFromHomeScreen()158     public void playPauseMediaFromHomeScreen() {
159         BySelector playButtonSelector =
160                 getUiElementFromConfig(AutomotiveConfigConstants.PLAY_PAUSE_BUTTON_HOME_SCREEN);
161         UiObject2 playButtonHomeScreen = getSpectatioUiUtil().findUiObject(playButtonSelector);
162         getSpectatioUiUtil()
163                 .validateUiObject(
164                         playButtonHomeScreen,
165                         AutomotiveConfigConstants.PLAY_PAUSE_BUTTON_HOME_SCREEN);
166         getSpectatioUiUtil().clickAndWait(playButtonHomeScreen);
167         getSpectatioUiUtil().wait5Seconds();
168     }
169 
170     /**
171      * {@inheritDoc}
172      */
pauseMedia()173     public void pauseMedia() {
174         BySelector pauseButtonSelector =
175                 getUiElementFromConfig(AutomotiveConfigConstants.PLAY_PAUSE_BUTTON);
176         UiObject2 pauseButton = getSpectatioUiUtil().findUiObject(pauseButtonSelector);
177         getSpectatioUiUtil()
178                 .validateUiObject(pauseButton, AutomotiveConfigConstants.PLAY_PAUSE_BUTTON);
179         getSpectatioUiUtil().clickAndWait(pauseButton);
180         getSpectatioUiUtil().wait5Seconds();
181     }
182 
183     /**
184      * {@inheritDoc}
185      */
clickNextTrack()186     public void clickNextTrack() {
187         BySelector nextTrackButtonSelector =
188                 getUiElementFromConfig(AutomotiveConfigConstants.NEXT_BUTTON);
189         UiObject2 nextTrackButton = getSpectatioUiUtil().findUiObject(nextTrackButtonSelector);
190         getSpectatioUiUtil()
191                 .validateUiObject(nextTrackButton, AutomotiveConfigConstants.NEXT_BUTTON);
192         getSpectatioUiUtil().clickAndWait(nextTrackButton);
193         getSpectatioUiUtil().wait5Seconds();
194     }
195 
196     /**
197      * {@inheritDoc}
198      */
clickNextTrackFromHomeScreen()199     public void clickNextTrackFromHomeScreen() {
200         BySelector nextTrackButtonSelector =
201                 getUiElementFromConfig(AutomotiveConfigConstants.NEXT_BUTTON_HOME_SCREEN);
202         UiObject2 nextTrackHomeScreenButton =
203                 getSpectatioUiUtil().findUiObject(nextTrackButtonSelector);
204         getSpectatioUiUtil()
205                 .validateUiObject(
206                         nextTrackHomeScreenButton,
207                         AutomotiveConfigConstants.NEXT_BUTTON_HOME_SCREEN);
208         getSpectatioUiUtil().clickAndWait(nextTrackHomeScreenButton);
209         getSpectatioUiUtil().wait5Seconds();
210     }
211 
212     /**
213      * {@inheritDoc}
214      */
clickPreviousTrack()215     public void clickPreviousTrack() {
216         BySelector previousTrackButtonSelector =
217                 getUiElementFromConfig(AutomotiveConfigConstants.PREVIOUS_BUTTON);
218         UiObject2 previousTrackMediaCenterButton =
219                 getSpectatioUiUtil().findUiObject(previousTrackButtonSelector);
220         getSpectatioUiUtil()
221                 .validateUiObject(
222                         previousTrackMediaCenterButton, AutomotiveConfigConstants.PREVIOUS_BUTTON);
223         getSpectatioUiUtil().clickAndWait(previousTrackMediaCenterButton);
224         getSpectatioUiUtil().wait5Seconds();
225     }
226 
227     /**
228      * {@inheritDoc}
229      */
clickPreviousTrackFromHomeScreen()230     public void clickPreviousTrackFromHomeScreen() {
231         BySelector previousTrackButtonSelector =
232                 getUiElementFromConfig(AutomotiveConfigConstants.PREVIOUS_BUTTON_HOME_SCREEN);
233         UiObject2 previousTrackHomeScreenButton =
234                 getSpectatioUiUtil().findUiObject(previousTrackButtonSelector);
235         getSpectatioUiUtil()
236                 .validateUiObject(
237                         previousTrackHomeScreenButton, AutomotiveConfigConstants.PREVIOUS_BUTTON);
238         getSpectatioUiUtil().clickAndWait(previousTrackHomeScreenButton);
239         getSpectatioUiUtil().wait5Seconds();
240     }
241 
242     /**
243      * {@inheritDoc}
244      */
clickShuffleAll()245     public void clickShuffleAll() {
246         BySelector shufflePlaylistButtonSelector =
247                 getUiElementFromConfig(AutomotiveConfigConstants.SHUFFLE_BUTTON);
248         UiObject2 shufflePlaylistButton =
249                 getSpectatioUiUtil().findUiObject(shufflePlaylistButtonSelector);
250         getSpectatioUiUtil()
251                 .validateUiObject(shufflePlaylistButton, AutomotiveConfigConstants.SHUFFLE_BUTTON);
252         getSpectatioUiUtil().clickAndWait(shufflePlaylistButton);
253         getSpectatioUiUtil().wait5Seconds();
254     }
255 
256     /**
257      * TODO - Keeping the empty functions for now, to avoid the compilation error in Vendor it will
258      * be removed after vendor clean up (b/266449779)
259      */
260 
261     /**
262      * Click the nth instance among the visible menu items
263      */
clickMenuItem(int instance)264     public void clickMenuItem(int instance) {
265     }
266 
267     /**
268      * TODO - Keeping the empty functions for now, to avoid the compilation error in Vendor it will
269      * be removed after vendor clean up (b/266449779)
270      */
271 
272     /**
273      * {@inheritDoc}
274      */
275     @Override
openMenuWith(String... menuOptions)276     public void openMenuWith(String... menuOptions) {
277     }
278 
279     /**
280      * TODO - Keeping the empty functions for now, to avoid the compilation error in Vendor it will
281      * be removed after vendor clean up (b/266449779)
282      */
283 
284     /**
285      * {@inheritDoc}
286      */
287     @Override
openNowPlayingWith(String trackName)288     public void openNowPlayingWith(String trackName) {
289     }
290 
291     /**
292      * {@inheritDoc}
293      */
getMediaTrackName()294     public String getMediaTrackName() {
295         String track;
296         BySelector mediaControlSelector =
297                 getUiElementFromConfig(AutomotiveConfigConstants.MINIMIZED_MEDIA_CONTROLS);
298         UiObject2 mediaControl = getSpectatioUiUtil().findUiObject(mediaControlSelector);
299 
300         if (mediaControl != null) {
301             track = getMediaTrackNameFromMinimizedControl();
302         } else {
303             track = getMediaTrackNameFromPlayback();
304         }
305         return track;
306     }
307 
308     /**
309      * {@inheritDoc}
310      */
getMediaTrackNameFromHomeScreen()311     public String getMediaTrackNameFromHomeScreen() {
312         String trackName;
313         BySelector trackNameSelector =
314                 getUiElementFromConfig(AutomotiveConfigConstants.TRACK_NAME_HOME_SCREEN);
315         UiObject2 trackNamexTextHomeScreen = getSpectatioUiUtil().findUiObject(trackNameSelector);
316         getSpectatioUiUtil()
317                 .validateUiObject(
318                         trackNamexTextHomeScreen, AutomotiveConfigConstants.TRACK_NAME_HOME_SCREEN);
319         trackName = trackNamexTextHomeScreen.getText();
320         return trackName;
321     }
322 
getMediaTrackNameFromMinimizedControl()323     private String getMediaTrackNameFromMinimizedControl() {
324         String trackName;
325         BySelector trackNameSelector =
326                 getUiElementFromConfig(AutomotiveConfigConstants.TRACK_NAME_MINIMIZED_CONTROL);
327         UiObject2 trackNameTextMinimizeControl =
328                 getSpectatioUiUtil().findUiObject(trackNameSelector);
329         getSpectatioUiUtil()
330                 .validateUiObject(
331                         trackNameTextMinimizeControl,
332                         AutomotiveConfigConstants.TRACK_NAME_MINIMIZED_CONTROL);
333         trackName = trackNameTextMinimizeControl.getText();
334         return trackName;
335     }
336 
getMediaTrackNameFromPlayback()337     private String getMediaTrackNameFromPlayback() {
338         String trackName;
339         BySelector trackNameSelector = getUiElementFromConfig(AutomotiveConfigConstants.TRACK_NAME);
340         UiObject2 trackNameTextPlayback = getSpectatioUiUtil().findUiObject(trackNameSelector);
341         getSpectatioUiUtil()
342                 .validateUiObject(trackNameTextPlayback, AutomotiveConfigConstants.TRACK_NAME);
343         trackName = trackNameTextPlayback.getText();
344         return trackName;
345     }
346 
347     /**
348      * {@inheritDoc}
349      */
goBackToMediaHomePage()350     public void goBackToMediaHomePage() {
351         minimizeNowPlaying();
352         BySelector back_btnSelector = getUiElementFromConfig(AutomotiveConfigConstants.BACK_BUTTON);
353         UiObject2 back_btn = getSpectatioUiUtil().findUiObject(back_btnSelector);
354         getSpectatioUiUtil().validateUiObject(back_btn, AutomotiveConfigConstants.BACK_BUTTON);
355         while (back_btn != null) {
356             getSpectatioUiUtil().clickAndWait(back_btn);
357             getSpectatioUiUtil().wait5Seconds();
358             back_btn = getSpectatioUiUtil().findUiObject(back_btnSelector);
359         }
360     }
361 
362     /** Minimize the Now Playing window. */
363     /**
364      * {@inheritDoc}
365      */
366     @Override
minimizeNowPlaying()367     public void minimizeNowPlaying() {
368         BySelector trackNameSelector = getUiElementFromConfig(AutomotiveConfigConstants.TRACK_NAME);
369         UiObject2 trackNameText = getSpectatioUiUtil().findUiObject(trackNameSelector);
370         if (trackNameText != null) {
371             trackNameText.swipe(Direction.DOWN, 1.0f, 500);
372         }
373     }
374 
375     /** Maximize the Now Playing window. */
376     /**
377      * {@inheritDoc}
378      */
379     @Override
maximizeNowPlaying()380     public void maximizeNowPlaying() {
381         BySelector trackNameSelector =
382                 getUiElementFromConfig(AutomotiveConfigConstants.MINIMIZED_MEDIA_CONTROLS);
383         UiObject2 trackNameText = getSpectatioUiUtil().findUiObject(trackNameSelector);
384         if (trackNameText != null) {
385             trackNameText.click();
386         }
387     }
388 
389     /**
390      * Scrolls through the list in search of the provided menu
391      *
392      * @param menu : menu to search
393      * @return UiObject found for the menu searched
394      */
selectByName(String menu)395     private UiObject selectByName(String menu) throws UiObjectNotFoundException {
396         UiObject menuListItem = null;
397 
398         /**
399          * TODO - Keeping the empty functions for now, to avoid the compilation error in Vendor it
400          * will be removed after vendor clean up (b/266449779)
401          */
402         return menuListItem;
403     }
404 
405     /**
406      * {@inheritDoc}
407      */
408     @Override
isPlaying()409     public boolean isPlaying() {
410         List<MediaController> controllers = mMediaSessionManager.getActiveSessions(null);
411         if (controllers.size() == 0) {
412             throw new RuntimeException("Unable to find Media Controller");
413         }
414         PlaybackState state = controllers.get(0).getPlaybackState();
415         return state.getState() == PlaybackState.STATE_PLAYING;
416     }
417 
418     /**
419      * {@inheritDoc}
420      */
421     @Override
getMediaAppTitle()422     public String getMediaAppTitle() {
423         BySelector mediaAppTitleSelector =
424                 getUiElementFromConfig(AutomotiveConfigConstants.MEDIA_APP_TITLE);
425         UiObject2 mediaAppTitle = getSpectatioUiUtil().findUiObject(mediaAppTitleSelector);
426         getSpectatioUiUtil()
427                 .validateUiObject(mediaAppTitle, AutomotiveConfigConstants.MEDIA_APP_TITLE);
428         return mediaAppTitle.getText();
429     }
430 
431     /**
432      * {@inheritDoc}
433      */
434     @Override
openMediaAppMenuItems()435     public void openMediaAppMenuItems() {
436         BySelector mediaDropDownMenuSelector =
437                 getUiElementFromConfig(AutomotiveConfigConstants.MEDIA_APP_DROP_DOWN_MENU);
438         List<UiObject2> menuItemElements =
439                 getSpectatioUiUtil().findUiObjects(mediaDropDownMenuSelector);
440         getSpectatioUiUtil()
441                 .validateUiObjects(
442                         menuItemElements, AutomotiveConfigConstants.MEDIA_APP_DROP_DOWN_MENU);
443         if (menuItemElements.size() == 0) {
444             throw new UnknownUiException("Unable to find Media drop down.");
445         }
446         // Media menu drop down is the last item in Media App Screen
447         int positionOfMenuItemDropDown = menuItemElements.size() - 1;
448         getSpectatioUiUtil().clickAndWait(menuItemElements.get(positionOfMenuItemDropDown));
449     }
450 
451     /**
452      * {@inheritDoc}
453      */
454     @Override
areMediaAppsPresent(List<String> mediaAppsNames)455     public boolean areMediaAppsPresent(List<String> mediaAppsNames) {
456         BySelector mediaAppPageTitleSelector =
457                 getUiElementFromConfig(AutomotiveConfigConstants.MEDIA_APPS_GRID_TITLE);
458         UiObject2 mediaAppPageTitle = getSpectatioUiUtil().findUiObject(mediaAppPageTitleSelector);
459         getSpectatioUiUtil()
460                 .validateUiObject(
461                         mediaAppPageTitle, AutomotiveConfigConstants.MEDIA_APPS_GRID_TITLE);
462         if (mediaAppsNames == null || mediaAppsNames.size() == 0) {
463             return false;
464         }
465         // Scroll and find media apps in Media App Grid
466         for (String expectedApp : mediaAppsNames) {
467             UiObject2 mediaApp =
468                     scrollAndFindApp(
469                             By.text(Pattern.compile(expectedApp, Pattern.CASE_INSENSITIVE)));
470             if (mediaApp == null || !mediaApp.getText().equals(expectedApp)) {
471                 return false;
472             }
473         }
474         return true;
475     }
476 
477     /**
478      * {@inheritDoc}
479      */
480     @Override
openApp(String appName)481     public void openApp(String appName) {
482         getSpectatioUiUtil().wait1Second(); // to avoid stale object error
483         UiObject2 app = scrollAndFindApp(By.text(appName));
484         if (app != null) {
485             getSpectatioUiUtil().clickAndWait(app);
486         } else {
487             throw new IllegalStateException(String.format("App %s cannot be found", appName));
488         }
489     }
490 
491     /**
492      * {@inheritDoc}
493      */
494     @Override
openMediaAppSettingsPage()495     public void openMediaAppSettingsPage() {
496         BySelector menuItemElementSelector =
497                 getUiElementFromConfig(AutomotiveConfigConstants.MEDIA_APP_DROP_DOWN_MENU);
498         List<UiObject2> menuItemElements =
499                 getSpectatioUiUtil().findUiObjects(menuItemElementSelector);
500         getSpectatioUiUtil()
501                 .validateUiObjects(
502                         menuItemElements, AutomotiveConfigConstants.MEDIA_APP_DROP_DOWN_MENU);
503         int settingsItemPosition = menuItemElements.size() - 2;
504         getSpectatioUiUtil().clickAndWait(menuItemElements.get(settingsItemPosition));
505     }
506 
507     /**
508      * {@inheritDoc}
509      */
510     @Override
getMediaAppUserNotLoggedInErrorMessage()511     public String getMediaAppUserNotLoggedInErrorMessage() {
512         BySelector noLoginMsgSelector =
513                 getUiElementFromConfig(AutomotiveConfigConstants.MEDIA_APP_NO_LOGIN_MSG);
514         UiObject2 noLoginMsg = getSpectatioUiUtil().findUiObject(noLoginMsgSelector);
515         getSpectatioUiUtil()
516                 .validateUiObject(noLoginMsg, AutomotiveConfigConstants.MEDIA_APP_NO_LOGIN_MSG);
517         return noLoginMsg.getText();
518     }
519 
520     /**
521      * {@inheritDoc}
522      */
523     @Override
selectMediaTrack(String... menuOptions)524     public void selectMediaTrack(String... menuOptions) {
525         for (String option : menuOptions) {
526             UiObject2 mediaTrack =
527                     scrollAndFindApp(By.text(Pattern.compile(option, Pattern.CASE_INSENSITIVE)));
528             getSpectatioUiUtil()
529                     .validateUiObject(mediaTrack, String.format("media track: %s", option));
530             mediaTrack.click();
531             getSpectatioUiUtil().waitForIdle();
532         }
533     }
534 
535     /**
536      * {@inheritDoc}
537      */
538     @Override
isBluetoothAudioDisconnectedLabelVisible()539     public boolean isBluetoothAudioDisconnectedLabelVisible() {
540         BySelector isBluetoothAudioDisconnectedLabel =
541                 getUiElementFromConfig(AutomotiveConfigConstants.BLUETOOTH_DISCONNECTED_LABEL);
542         return getSpectatioUiUtil().hasUiElement(isBluetoothAudioDisconnectedLabel);
543     }
544 
545     /**
546      * {@inheritDoc}
547      */
548     @Override
isConnectToBluetoothLabelVisible()549     public boolean isConnectToBluetoothLabelVisible() {
550         BySelector connectToBluetoothLabel =
551                 getUiElementFromConfig(AutomotiveConfigConstants.CONNECT_TO_BLUETOOTH);
552         return getSpectatioUiUtil().hasUiElement(connectToBluetoothLabel);
553     }
554 
scrollAndFindApp(BySelector selector)555     private UiObject2 scrollAndFindApp(BySelector selector) {
556 
557         UiObject2 object =
558                 mScrollUtility.scrollAndFindUiObject(
559                         mScrollAction,
560                         mScrollDirection,
561                         mForwardButtonSelector,
562                         mBackwardButtonSelector,
563                         mScrollableElementSelector,
564                         selector,
565                         String.format("Scroll through media app grid to find %s", selector));
566         getSpectatioUiUtil()
567                 .validateUiObject(object, String.format("Given media app %s", selector));
568         return object;
569     }
570 
571     /**
572      * {@inheritDoc}
573      */
574     @Override
openBluetoothMediaApp()575     public void openBluetoothMediaApp() {
576         getSpectatioUiUtil().pressHome();
577         getSpectatioUiUtil().waitForIdle();
578         getSpectatioUiUtil()
579                 .executeShellCommand(
580                         getCommandFromConfig(AutomotiveConfigConstants.MEDIA_LAUNCH_BLUETOOTH_AUDIO_COMMAND));
581     }
582 
583     /**
584      * {@inheritDoc}
585      */
586     @Override
clickOnBluetoothToggle()587     public void clickOnBluetoothToggle() {
588         BySelector cenableDisableBluetoothToggle =
589                 getUiElementFromConfig(AutomotiveConfigConstants.ENABLE_DISABLE_BT_TOGGLE);
590         UiObject2 cenableDisableBluetooth =
591                 getSpectatioUiUtil().findUiObject(cenableDisableBluetoothToggle);
592         getSpectatioUiUtil()
593                 .validateUiObject(
594                         cenableDisableBluetooth,
595                         AutomotiveConfigConstants.ENABLE_DISABLE_BT_TOGGLE);
596         getSpectatioUiUtil().clickAndWait(cenableDisableBluetooth);
597         getSpectatioUiUtil().wait5Seconds();
598     }
599 
600     /**
601      * {@inheritDoc}
602      */
603     @Override
cancelBluetoothAudioConncetion()604     public void cancelBluetoothAudioConncetion() {
605         BySelector cancelBluetoothAudioConncetionButton =
606                 getUiElementFromConfig(AutomotiveConfigConstants.CANCEL_BT_AUDIO_CONNECTION_BUTTON);
607         UiObject2 cancelBluetoothAudioConncetion =
608                 getSpectatioUiUtil().findUiObject(cancelBluetoothAudioConncetionButton);
609         getSpectatioUiUtil()
610                 .validateUiObject(
611                         cancelBluetoothAudioConncetion,
612                         AutomotiveConfigConstants.CANCEL_BT_AUDIO_CONNECTION_BUTTON);
613         getSpectatioUiUtil().clickAndWait(cancelBluetoothAudioConncetion);
614         getSpectatioUiUtil().wait5Seconds();
615     }
616 
617     /**
618      * {@inheritDoc}
619      */
620     @Override
scrollPlayListDown()621     public void scrollPlayListDown() {
622         int scrollCount = 0;
623         int MAX_SCROLL_COUNT = 10;
624         boolean canScroll = true;
625         while (canScroll && scrollCount < MAX_SCROLL_COUNT) {
626             canScroll = getSpectatioUiUtil()
627                     .scrollUsingButton(getUiElementFromConfig(AutomotiveConfigConstants.MEDIA_SCROLL_DOWN_BUTTON));
628             scrollCount++;
629         }
630     }
631 
632     /**
633      * {@inheritDoc}
634      */
635     @Override
clickOnSongFromPlaylist()636     public void clickOnSongFromPlaylist() {
637         BySelector songInPlaylist =
638                 getUiElementFromConfig(AutomotiveConfigConstants.MEDIA_SONG_IN_PLAYLIST);
639         UiObject2 songInPlaylistObject =
640                 getSpectatioUiUtil().findUiObject(songInPlaylist);
641         getSpectatioUiUtil()
642                 .validateUiObject(
643                         songInPlaylistObject,
644                         AutomotiveConfigConstants.MEDIA_SONG_IN_PLAYLIST);
645         getSpectatioUiUtil().clickAndWait(songInPlaylistObject);
646         getSpectatioUiUtil().wait5Seconds();
647     }
648 
649     /**
650      * {@inheritDoc}
651      */
652     @Override
getArtistrTitle()653     public String getArtistrTitle() {
654         BySelector artistTitle =
655                 getUiElementFromConfig(AutomotiveConfigConstants.ARTIST_TITLE);
656         UiObject2 objectArtistTitle = getSpectatioUiUtil().findUiObject(artistTitle);
657         getSpectatioUiUtil()
658                 .validateUiObject(objectArtistTitle, AutomotiveConfigConstants.ARTIST_TITLE);
659         return objectArtistTitle.getText().trim();
660     }
661 
662     /**
663      * {@inheritDoc}
664      */
665     @Override
getAlbumTitle()666     public String getAlbumTitle() {
667         BySelector albumTitle =
668                 getUiElementFromConfig(AutomotiveConfigConstants.ALBUM_TITLE);
669         UiObject2 objectAlbumTitle = getSpectatioUiUtil().findUiObject(albumTitle);
670         getSpectatioUiUtil()
671                 .validateUiObject(objectAlbumTitle, AutomotiveConfigConstants.ALBUM_TITLE);
672         return objectAlbumTitle.getText().trim();
673     }
674 
675     /**
676      * {@inheritDoc}
677      */
678     @Override
getSongCurrentPlayingTime()679     public String getSongCurrentPlayingTime() {
680         BySelector songCurrentTime =
681                 getUiElementFromConfig(AutomotiveConfigConstants.CURRENT_SONG_TIME);
682         UiObject2 objectSongCurrentTime = getSpectatioUiUtil().findUiObject(songCurrentTime);
683         getSpectatioUiUtil()
684                 .validateUiObject(objectSongCurrentTime, AutomotiveConfigConstants.CURRENT_SONG_TIME);
685         return objectSongCurrentTime.getText().trim();
686     }
687 
688     /**
689      * {@inheritDoc}
690      */
691     @Override
getCurrentSongMaxPlayingTime()692     public String getCurrentSongMaxPlayingTime() {
693         BySelector songMaxPlayingTime =
694                 getUiElementFromConfig(AutomotiveConfigConstants.MAX_SONG_TIME);
695         UiObject2 objectSongMaxPlayingTime = getSpectatioUiUtil().findUiObject(songMaxPlayingTime);
696         getSpectatioUiUtil()
697                 .validateUiObject(objectSongMaxPlayingTime, AutomotiveConfigConstants.MAX_SONG_TIME);
698         return objectSongMaxPlayingTime.getText().trim();
699     }
700 
701     /**
702      * {@inheritDoc}
703      */
704     @Override
isNowPlayingLabelVisible()705     public boolean isNowPlayingLabelVisible() {
706         BySelector isNowPlayingLabel =
707                 getUiElementFromConfig(AutomotiveConfigConstants.MOW_PLAYING_LABEL);
708         return getSpectatioUiUtil().hasUiElement(isNowPlayingLabel);
709     }
710 
711     /**
712      * {@inheritDoc}
713      */
714     @Override
isPlaylistIconVisible()715     public boolean isPlaylistIconVisible() {
716         BySelector playlistIcon =
717                 getUiElementFromConfig(AutomotiveConfigConstants.MEDIA_PLAYLIST_ICON);
718         return getSpectatioUiUtil().hasUiElement(playlistIcon);
719     }
720 
721     /**
722      * {@inheritDoc}
723      */
724     @Override
clickOnPlaylistIcon()725     public void clickOnPlaylistIcon() {
726         BySelector playlistIcon =
727                 getUiElementFromConfig(AutomotiveConfigConstants.MEDIA_PLAYLIST_ICON);
728         UiObject2 playlistIconObject =
729                 getSpectatioUiUtil().findUiObject(playlistIcon);
730         getSpectatioUiUtil()
731                 .validateUiObject(
732                         playlistIconObject,
733                         AutomotiveConfigConstants.MEDIA_PLAYLIST_ICON);
734         getSpectatioUiUtil().clickAndWait(playlistIconObject);
735     }
736 
737     /**
738      * {@inheritDoc}
739      */
740     @Override
grantRestrictedPermissionsForBTMedia(String permission)741     public void grantRestrictedPermissionsForBTMedia(String permission) {
742         if (permission == null || permission.length() < 1) {
743             throw new UnknownUiException("Permission must be provided");
744         }
745         mUiAutomation.adoptShellPermissionIdentity(permission);
746     }
747 }
748