1 /*
2  * Copyright (C) 2020 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 com.android.settings.notification;
18 
19 import static com.android.settings.core.BasePreferenceController.AVAILABLE_UNSEARCHABLE;
20 import static com.android.settings.core.BasePreferenceController.CONDITIONALLY_UNAVAILABLE;
21 
22 import static com.google.common.truth.Truth.assertThat;
23 
24 import static org.mockito.Mockito.doReturn;
25 import static org.mockito.Mockito.mock;
26 import static org.mockito.Mockito.spy;
27 import static org.mockito.Mockito.when;
28 
29 import android.content.Context;
30 import android.content.SharedPreferences;
31 import android.content.pm.ApplicationInfo;
32 import android.content.pm.PackageInfo;
33 import android.content.pm.PackageStats;
34 import android.media.MediaRouter2Manager;
35 import android.media.RoutingSessionInfo;
36 import android.media.session.MediaSessionManager;
37 
38 import androidx.preference.Preference;
39 import androidx.preference.PreferenceCategory;
40 import androidx.preference.PreferenceManager;
41 import androidx.preference.PreferenceScreen;
42 
43 import com.android.settings.R;
44 import com.android.settings.Utils;
45 import com.android.settings.testutils.shadow.ShadowBluetoothAdapter;
46 import com.android.settings.widget.SeekBarPreference;
47 import com.android.settingslib.media.LocalMediaManager;
48 
49 import org.junit.Before;
50 import org.junit.Test;
51 import org.junit.runner.RunWith;
52 import org.mockito.Mock;
53 import org.mockito.MockitoAnnotations;
54 import org.robolectric.RobolectricTestRunner;
55 import org.robolectric.RuntimeEnvironment;
56 import org.robolectric.Shadows;
57 import org.robolectric.annotation.Config;
58 import org.robolectric.shadows.ShadowPackageManager;
59 
60 import java.util.ArrayList;
61 import java.util.List;
62 
63 @RunWith(RobolectricTestRunner.class)
64 @Config(shadows = {ShadowBluetoothAdapter.class})
65 public class RemoteVolumeGroupControllerTest {
66 
67     private static final String KEY_REMOTE_VOLUME_GROUP = "remote_media_group";
68     private static final String TEST_SESSION_1_ID = "test_session_1_id";
69     private static final String TEST_SESSION_1_NAME = "test_session_1_name";
70     private static final String TEST_PACKAGE_NAME = "com.test";
71     private static final String TEST_APPLICATION_LABEL = "APP Test Label";
72     private static final int CURRENT_VOLUME = 30;
73     private static final int MAX_VOLUME = 100;
74 
75     @Mock
76     private LocalMediaManager mLocalMediaManager;
77     @Mock
78     private PreferenceScreen mScreen;
79     @Mock
80     private PreferenceManager mPreferenceManager;
81     @Mock
82     private SharedPreferences mSharedPreferences;
83     @Mock
84     private MediaSessionManager mMediaSessionManager;
85 
86     private final List<RoutingSessionInfo> mRoutingSessionInfos = new ArrayList<>();
87 
88     private Context mContext;
89     private RemoteVolumeGroupController mController;
90     private PreferenceCategory mPreferenceCategory;
91     private ShadowPackageManager mShadowPackageManager;
92     private ApplicationInfo mAppInfo;
93     private PackageInfo mPackageInfo;
94     private PackageStats mPackageStats;
95 
96     @Before
setUp()97     public void setUp() {
98         MockitoAnnotations.initMocks(this);
99         mContext = spy(RuntimeEnvironment.application);
100         doReturn(mMediaSessionManager).when(mContext).getSystemService(
101                 Context.MEDIA_SESSION_SERVICE);
102         mController = new RemoteVolumeGroupController(mContext, KEY_REMOTE_VOLUME_GROUP);
103         mController.mLocalMediaManager = mLocalMediaManager;
104         mController.mRouterManager = mock(MediaRouter2Manager.class);
105         mPreferenceCategory = spy(new PreferenceCategory(mContext));
106         mPreferenceCategory.setKey(mController.getPreferenceKey());
107 
108         when(mPreferenceCategory.getPreferenceManager()).thenReturn(mPreferenceManager);
109         when(mPreferenceManager.getSharedPreferences()).thenReturn(mSharedPreferences);
110         when(mScreen.findPreference(mController.getPreferenceKey())).thenReturn(
111                 mPreferenceCategory);
112         final RoutingSessionInfo remoteSessionInfo = mock(RoutingSessionInfo.class);
113         when(remoteSessionInfo.getId()).thenReturn(TEST_SESSION_1_ID);
114         when(remoteSessionInfo.getName()).thenReturn(TEST_SESSION_1_NAME);
115         when(remoteSessionInfo.getVolumeMax()).thenReturn(MAX_VOLUME);
116         when(remoteSessionInfo.getVolume()).thenReturn(CURRENT_VOLUME);
117         when(remoteSessionInfo.getClientPackageName()).thenReturn(TEST_PACKAGE_NAME);
118         when(remoteSessionInfo.isSystemSession()).thenReturn(false);
119         mRoutingSessionInfos.add(remoteSessionInfo);
120         when(mLocalMediaManager.getActiveMediaSession()).thenReturn(mRoutingSessionInfos);
121     }
122 
123     @Test
getAvailabilityStatus_withActiveSession_returnAvailableUnsearchable()124     public void getAvailabilityStatus_withActiveSession_returnAvailableUnsearchable() {
125         mController.displayPreference(mScreen);
126 
127         assertThat(mController.getAvailabilityStatus()).isEqualTo(AVAILABLE_UNSEARCHABLE);
128     }
129 
130     @Test
getAvailabilityStatus_noActiveSession_returnConditionallyUnavailable()131     public void getAvailabilityStatus_noActiveSession_returnConditionallyUnavailable() {
132         mRoutingSessionInfos.clear();
133         mController.displayPreference(mScreen);
134 
135         assertThat(mController.getAvailabilityStatus()).isEqualTo(CONDITIONALLY_UNAVAILABLE);
136     }
137 
138     @Test
displayPreference_noActiveSession_checkPreferenceCount()139     public void displayPreference_noActiveSession_checkPreferenceCount() {
140         mRoutingSessionInfos.clear();
141         mController.displayPreference(mScreen);
142 
143         assertThat(mPreferenceCategory.getPreferenceCount()).isEqualTo(0);
144     }
145 
146     @Test
displayPreference_withActiveSession_checkPreferenceCount()147     public void displayPreference_withActiveSession_checkPreferenceCount() {
148         mController.displayPreference(mScreen);
149 
150         assertThat(mPreferenceCategory.getPreferenceCount()).isEqualTo(2);
151     }
152 
153     @Test
displayPreference_withActiveSession_checkSeekBarTitle()154     public void displayPreference_withActiveSession_checkSeekBarTitle() {
155         mController.displayPreference(mScreen);
156         final Preference preference = mPreferenceCategory.findPreference(TEST_SESSION_1_ID);
157 
158         assertThat(preference.getTitle()).isEqualTo(mContext.getText(
159                 R.string.remote_media_volume_option_title));
160     }
161 
162     @Test
displayPreference_withActiveSession_checkSeekBarMaxVolume()163     public void displayPreference_withActiveSession_checkSeekBarMaxVolume() {
164         mController.displayPreference(mScreen);
165         final SeekBarPreference preference = mPreferenceCategory.findPreference(TEST_SESSION_1_ID);
166 
167         assertThat(preference.getMax()).isEqualTo(MAX_VOLUME);
168     }
169 
170     @Test
displayPreference_withActiveSession_checkSeekBarCurrentVolume()171     public void displayPreference_withActiveSession_checkSeekBarCurrentVolume() {
172         mController.displayPreference(mScreen);
173         final SeekBarPreference preference = mPreferenceCategory.findPreference(TEST_SESSION_1_ID);
174 
175         assertThat(preference.getProgress()).isEqualTo(CURRENT_VOLUME);
176     }
177 
178     @Test
displayPreference_withActiveSession_checkSwitcherPreferenceTitle()179     public void displayPreference_withActiveSession_checkSwitcherPreferenceTitle() {
180         initPackage();
181         mShadowPackageManager.addPackage(mPackageInfo, mPackageStats);
182         mController.displayPreference(mScreen);
183         final Preference preference = mPreferenceCategory.findPreference(
184                 RemoteVolumeGroupController.SWITCHER_PREFIX + TEST_SESSION_1_ID);
185 
186         assertThat(preference.getTitle()).isEqualTo(mContext.getString(
187                 R.string.media_output_label_title, Utils.getApplicationLabel(mContext,
188                         TEST_PACKAGE_NAME)));
189     }
190 
191     @Test
displayPreference_withActiveSession_checkSwitcherPreferenceSummary()192     public void displayPreference_withActiveSession_checkSwitcherPreferenceSummary() {
193         mController.displayPreference(mScreen);
194         final Preference preference = mPreferenceCategory.findPreference(
195                 RemoteVolumeGroupController.SWITCHER_PREFIX + TEST_SESSION_1_ID);
196 
197         assertThat(preference.getSummary()).isEqualTo(TEST_SESSION_1_NAME);
198     }
199 
initPackage()200     private void initPackage() {
201         mShadowPackageManager = Shadows.shadowOf(mContext.getPackageManager());
202         mAppInfo = new ApplicationInfo();
203         mAppInfo.flags = ApplicationInfo.FLAG_INSTALLED;
204         mAppInfo.packageName = TEST_PACKAGE_NAME;
205         mAppInfo.name = TEST_APPLICATION_LABEL;
206         mPackageInfo = new PackageInfo();
207         mPackageInfo.packageName = TEST_PACKAGE_NAME;
208         mPackageInfo.applicationInfo = mAppInfo;
209         mPackageStats = new PackageStats(TEST_PACKAGE_NAME);
210     }
211 }
212