1 /*
2  * Copyright (C) 2022 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.server.companion.virtual;
18 
19 import static android.companion.virtual.VirtualDeviceParams.DEVICE_POLICY_CUSTOM;
20 import static android.companion.virtual.VirtualDeviceParams.DEVICE_POLICY_DEFAULT;
21 import static android.companion.virtual.VirtualDeviceParams.POLICY_TYPE_AUDIO;
22 import static android.companion.virtual.VirtualDeviceParams.POLICY_TYPE_CAMERA;
23 import static android.companion.virtual.VirtualDeviceParams.POLICY_TYPE_SENSORS;
24 import static android.content.Context.DEVICE_ID_DEFAULT;
25 import static android.content.Context.DEVICE_ID_INVALID;
26 
27 import static com.google.common.truth.Truth.assertThat;
28 
29 import static org.junit.Assert.assertThrows;
30 import static org.mockito.Mockito.when;
31 
32 import android.companion.virtual.IVirtualDevice;
33 import android.companion.virtual.VirtualDevice;
34 import android.companion.virtual.flags.Flags;
35 import android.os.Parcel;
36 import android.platform.test.annotations.Presubmit;
37 import android.platform.test.flag.junit.SetFlagsRule;
38 
39 import androidx.test.ext.junit.runners.AndroidJUnit4;
40 
41 import org.junit.Before;
42 import org.junit.Rule;
43 import org.junit.Test;
44 import org.junit.runner.RunWith;
45 import org.mockito.Mock;
46 import org.mockito.MockitoAnnotations;
47 
48 @Presubmit
49 @RunWith(AndroidJUnit4.class)
50 public class VirtualDeviceTest {
51 
52     private static final int VIRTUAL_DEVICE_ID = 42;
53     private static final String PERSISTENT_ID = "persistentId";
54     private static final String DEVICE_NAME = "VirtualDeviceName";
55     private static final String DISPLAY_NAME = "DisplayName";
56 
57     @Rule
58     public final SetFlagsRule mSetFlagsRule = new SetFlagsRule();
59 
60     @Mock
61     private IVirtualDevice mVirtualDevice;
62 
63     @Before
setUp()64     public void setUp() throws Exception {
65         MockitoAnnotations.initMocks(this);
66     }
67 
68     @Test
build_invalidId_shouldThrowIllegalArgumentException()69     public void build_invalidId_shouldThrowIllegalArgumentException() {
70         assertThrows(
71                 IllegalArgumentException.class,
72                 () -> new VirtualDevice(
73                         mVirtualDevice, DEVICE_ID_INVALID, PERSISTENT_ID, DEVICE_NAME));
74     }
75 
76     @Test
build_defaultId_shouldThrowIllegalArgumentException()77     public void build_defaultId_shouldThrowIllegalArgumentException() {
78         assertThrows(
79                 IllegalArgumentException.class,
80                 () -> new VirtualDevice(
81                         mVirtualDevice, DEVICE_ID_DEFAULT, PERSISTENT_ID, DEVICE_NAME));
82     }
83 
84     @Test
build_onlyRequiredFields()85     public void build_onlyRequiredFields() {
86         VirtualDevice virtualDevice =
87                 new VirtualDevice(
88                         mVirtualDevice, VIRTUAL_DEVICE_ID, /*persistentId=*/null, /*name=*/null);
89         assertThat(virtualDevice.getDeviceId()).isEqualTo(VIRTUAL_DEVICE_ID);
90         assertThat(virtualDevice.getPersistentDeviceId()).isNull();
91         assertThat(virtualDevice.getName()).isNull();
92     }
93 
94     @Test
parcelable_shouldRecreateSuccessfully()95     public void parcelable_shouldRecreateSuccessfully() {
96         VirtualDevice originalDevice =
97                 new VirtualDevice(mVirtualDevice, VIRTUAL_DEVICE_ID, PERSISTENT_ID, DEVICE_NAME,
98                         DISPLAY_NAME);
99         Parcel parcel = Parcel.obtain();
100         originalDevice.writeToParcel(parcel, 0);
101         parcel.setDataPosition(0);
102 
103         VirtualDevice device = VirtualDevice.CREATOR.createFromParcel(parcel);
104         assertThat(device.getDeviceId()).isEqualTo(VIRTUAL_DEVICE_ID);
105         assertThat(device.getPersistentDeviceId()).isEqualTo(PERSISTENT_ID);
106         assertThat(device.getName()).isEqualTo(DEVICE_NAME);
107         assertThat(device.getDisplayName().toString()).isEqualTo(DISPLAY_NAME);
108     }
109 
110     @Test
virtualDevice_getDisplayIds()111     public void virtualDevice_getDisplayIds() throws Exception {
112         mSetFlagsRule.enableFlags(Flags.FLAG_VDM_PUBLIC_APIS);
113 
114         VirtualDevice virtualDevice =
115                 new VirtualDevice(
116                         mVirtualDevice, VIRTUAL_DEVICE_ID, /*persistentId=*/null, /*name=*/null);
117 
118         when(mVirtualDevice.getDisplayIds()).thenReturn(new int[0]);
119         assertThat(virtualDevice.getDisplayIds()).hasLength(0);
120 
121         final int[] displayIds = new int[]{7, 18};
122         when(mVirtualDevice.getDisplayIds()).thenReturn(displayIds);
123         assertThat(virtualDevice.getDisplayIds()).isEqualTo(displayIds);
124     }
125 
126     @Test
virtualDevice_hasCustomSensorSupport()127     public void virtualDevice_hasCustomSensorSupport() throws Exception {
128         mSetFlagsRule.enableFlags(Flags.FLAG_VDM_PUBLIC_APIS);
129 
130         VirtualDevice virtualDevice =
131                 new VirtualDevice(
132                         mVirtualDevice, VIRTUAL_DEVICE_ID, /*persistentId=*/null, /*name=*/null);
133 
134         when(mVirtualDevice.getDevicePolicy(POLICY_TYPE_SENSORS)).thenReturn(DEVICE_POLICY_DEFAULT);
135         assertThat(virtualDevice.hasCustomSensorSupport()).isFalse();
136 
137         when(mVirtualDevice.getDevicePolicy(POLICY_TYPE_SENSORS)).thenReturn(DEVICE_POLICY_CUSTOM);
138         assertThat(virtualDevice.hasCustomSensorSupport()).isTrue();
139     }
140 
141     @Test
virtualDevice_hasCustomAudioInputSupport()142     public void virtualDevice_hasCustomAudioInputSupport() throws Exception {
143         mSetFlagsRule.enableFlags(Flags.FLAG_VDM_PUBLIC_APIS);
144         mSetFlagsRule.enableFlags(android.media.audiopolicy.Flags.FLAG_AUDIO_MIX_TEST_API);
145 
146         VirtualDevice virtualDevice =
147                 new VirtualDevice(
148                         mVirtualDevice, VIRTUAL_DEVICE_ID, /*persistentId=*/null, /*name=*/null);
149 
150         when(mVirtualDevice.getDevicePolicy(POLICY_TYPE_AUDIO)).thenReturn(DEVICE_POLICY_DEFAULT);
151         assertThat(virtualDevice.hasCustomAudioInputSupport()).isFalse();
152 
153         when(mVirtualDevice.getDevicePolicy(POLICY_TYPE_AUDIO)).thenReturn(DEVICE_POLICY_CUSTOM);
154         when(mVirtualDevice.hasCustomAudioInputSupport()).thenReturn(false);
155         assertThat(virtualDevice.hasCustomAudioInputSupport()).isFalse();
156 
157         when(mVirtualDevice.hasCustomAudioInputSupport()).thenReturn(true);
158         assertThat(virtualDevice.hasCustomAudioInputSupport()).isTrue();
159     }
160 
161     @Test
virtualDevice_hasCustomCameraSupport()162     public void virtualDevice_hasCustomCameraSupport() throws Exception {
163         mSetFlagsRule.enableFlags(Flags.FLAG_VDM_PUBLIC_APIS);
164 
165         VirtualDevice virtualDevice =
166                 new VirtualDevice(
167                         mVirtualDevice, VIRTUAL_DEVICE_ID, /*persistentId=*/null, /*name=*/null);
168 
169         when(mVirtualDevice.getDevicePolicy(POLICY_TYPE_CAMERA)).thenReturn(DEVICE_POLICY_DEFAULT);
170         assertThat(virtualDevice.hasCustomCameraSupport()).isFalse();
171 
172         when(mVirtualDevice.getDevicePolicy(POLICY_TYPE_CAMERA)).thenReturn(DEVICE_POLICY_CUSTOM);
173         assertThat(virtualDevice.hasCustomCameraSupport()).isTrue();
174     }
175 }
176