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 android.nearby.integration.privileged
18 
19 import android.content.Context
20 import android.nearby.BroadcastCallback
21 import android.nearby.BroadcastRequest
22 import android.nearby.NearbyDevice
23 import android.nearby.NearbyManager
24 import android.nearby.PresenceBroadcastRequest
25 import android.nearby.PresenceCredential
26 import android.nearby.PrivateCredential
27 import android.nearby.ScanCallback
28 import android.nearby.ScanRequest
29 import androidx.test.core.app.ApplicationProvider
30 import androidx.test.ext.junit.runners.AndroidJUnit4
31 import com.google.common.truth.Truth.assertThat
32 import org.junit.Assert.assertThrows
33 import org.junit.Before
34 import org.junit.Test
35 import org.junit.runner.RunWith
36 
37 @RunWith(AndroidJUnit4::class)
38 class NearbyManagerTest {
39     private lateinit var appContext: Context
40 
41     @Before
setUpnull42     fun setUp() {
43         appContext = ApplicationProvider.getApplicationContext<Context>()
44     }
45 
46     /** Verify privileged app can get Nearby service. */
47     @Test
testContextGetNearbySystemService_fromPrivilegedApp_returnsNoneNullnull48     fun testContextGetNearbySystemService_fromPrivilegedApp_returnsNoneNull() {
49         assertThat(appContext.getSystemService(Context.NEARBY_SERVICE)).isNotNull()
50     }
51 
52     /** Verify privileged app can start/stop scan without exception. */
53     @Test
testNearbyManagerStartScanStopScan_fromPrivilegedApp_succeednull54     fun testNearbyManagerStartScanStopScan_fromPrivilegedApp_succeed() {
55         val nearbyManager = appContext.getSystemService(Context.NEARBY_SERVICE) as NearbyManager
56         val scanRequest = ScanRequest.Builder()
57             .setScanMode(ScanRequest.SCAN_MODE_LOW_LATENCY)
58             .setScanType(ScanRequest.SCAN_TYPE_FAST_PAIR)
59             .setBleEnabled(true)
60             .build()
61         val scanCallback = object : ScanCallback {
62             override fun onDiscovered(device: NearbyDevice) {}
63 
64             override fun onUpdated(device: NearbyDevice) {}
65 
66             override fun onLost(device: NearbyDevice) {}
67 
68             override fun onError(errorCode: Int) {}
69         }
70 
71         nearbyManager.startScan(scanRequest, /* executor */ { it.run() }, scanCallback)
72         nearbyManager.stopScan(scanCallback)
73     }
74 
75     /** Verify privileged app can start/stop broadcast without exception. */
76     @Test
testNearbyManagerStartBroadcastStopBroadcast_fromPrivilegedApp_succeednull77     fun testNearbyManagerStartBroadcastStopBroadcast_fromPrivilegedApp_succeed() {
78         val nearbyManager = appContext.getSystemService(Context.NEARBY_SERVICE) as NearbyManager
79         val salt = byteArrayOf(1, 2)
80         val secreteId = byteArrayOf(1, 2, 3, 4)
81         val metadataEncryptionKey = ByteArray(14)
82         val authenticityKey = byteArrayOf(0, 1, 1, 1)
83         val deviceName = "test_device"
84         val mediums = listOf(BroadcastRequest.MEDIUM_BLE)
85         val credential =
86             PrivateCredential.Builder(secreteId, authenticityKey, metadataEncryptionKey, deviceName)
87                 .setIdentityType(PresenceCredential.IDENTITY_TYPE_PRIVATE)
88                 .build()
89         val broadcastRequest: BroadcastRequest =
90             PresenceBroadcastRequest.Builder(mediums, salt, credential)
91                 .addAction(123)
92                 .build()
93         val broadcastCallback = BroadcastCallback { }
94 
95         nearbyManager.startBroadcast(
96             broadcastRequest, /* executor */ { it.run() }, broadcastCallback
97         )
98         nearbyManager.stopBroadcast(broadcastCallback)
99     }
100 
101     /** Verify privileged app can set powered off finding ephemeral IDs without exception. */
102     @Test
testNearbyManagerSetPoweredOffFindingEphemeralIds_fromPrivilegedApp_succeednull103     fun testNearbyManagerSetPoweredOffFindingEphemeralIds_fromPrivilegedApp_succeed() {
104         val nearbyManager = appContext.getSystemService(Context.NEARBY_SERVICE) as NearbyManager
105         // Only test supporting devices.
106         if (nearbyManager.getPoweredOffFindingMode()
107                 == NearbyManager.POWERED_OFF_FINDING_MODE_UNSUPPORTED) return
108 
109         val eid = ByteArray(20)
110 
111         nearbyManager.setPoweredOffFindingEphemeralIds(listOf(eid))
112     }
113 
114     /**
115      * Verifies that [NearbyManager.setPoweredOffFindingEphemeralIds] checkes the ephemeral ID
116      * length.
117      */
118     @Test
testNearbyManagerSetPoweredOffFindingEphemeralIds_wrongSize_throwsExceptionnull119     fun testNearbyManagerSetPoweredOffFindingEphemeralIds_wrongSize_throwsException() {
120         val nearbyManager = appContext.getSystemService(Context.NEARBY_SERVICE) as NearbyManager
121         // Only test supporting devices.
122         if (nearbyManager.getPoweredOffFindingMode()
123                 == NearbyManager.POWERED_OFF_FINDING_MODE_UNSUPPORTED) return
124 
125         assertThrows(IllegalArgumentException::class.java) {
126             nearbyManager.setPoweredOffFindingEphemeralIds(listOf(ByteArray(21)))
127         }
128         assertThrows(IllegalArgumentException::class.java) {
129             nearbyManager.setPoweredOffFindingEphemeralIds(listOf(ByteArray(19)))
130         }
131     }
132 
133     /** Verify privileged app can set and get powered off finding mode without exception. */
134     @Test
testNearbyManagerSetGetPoweredOffMode_fromPrivilegedApp_succeednull135     fun testNearbyManagerSetGetPoweredOffMode_fromPrivilegedApp_succeed() {
136         val nearbyManager = appContext.getSystemService(Context.NEARBY_SERVICE) as NearbyManager
137         // Only test supporting devices.
138         if (nearbyManager.getPoweredOffFindingMode()
139                 == NearbyManager.POWERED_OFF_FINDING_MODE_UNSUPPORTED) return
140 
141         nearbyManager.setPoweredOffFindingMode(NearbyManager.POWERED_OFF_FINDING_MODE_DISABLED)
142         assertThat(nearbyManager.getPoweredOffFindingMode())
143                 .isEqualTo(NearbyManager.POWERED_OFF_FINDING_MODE_DISABLED)
144     }
145 }
146