1 /* 2 * Copyright (C) 2017 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.car; 18 19 import static org.junit.Assert.assertEquals; 20 import static org.junit.Assert.assertFalse; 21 import static org.junit.Assert.assertTrue; 22 23 import android.car.Car; 24 import android.car.VehicleAreaType; 25 import android.car.vms.VmsAssociatedLayer; 26 import android.car.vms.VmsAvailableLayers; 27 import android.car.vms.VmsLayer; 28 import android.car.vms.VmsSubscriberManager; 29 import android.car.vms.VmsSubscriberManager.VmsSubscriberClientCallback; 30 import android.hardware.automotive.vehicle.V2_0.VehiclePropValue; 31 import android.hardware.automotive.vehicle.V2_0.VehicleProperty; 32 import android.hardware.automotive.vehicle.V2_0.VehiclePropertyAccess; 33 import android.hardware.automotive.vehicle.V2_0.VehiclePropertyChangeMode; 34 import android.hardware.automotive.vehicle.V2_0.VmsAvailabilityStateIntegerValuesIndex; 35 import android.hardware.automotive.vehicle.V2_0.VmsMessageType; 36 import android.os.SystemClock; 37 import android.support.test.filters.MediumTest; 38 import android.support.test.runner.AndroidJUnit4; 39 import android.util.Log; 40 41 import com.android.car.vehiclehal.VehiclePropValueBuilder; 42 import com.android.car.vehiclehal.test.MockedVehicleHal.VehicleHalPropertyHandler; 43 44 import org.junit.Test; 45 import org.junit.runner.RunWith; 46 47 import java.util.ArrayList; 48 import java.util.Arrays; 49 import java.util.HashSet; 50 import java.util.Set; 51 import java.util.concurrent.Executor; 52 import java.util.concurrent.Semaphore; 53 import java.util.concurrent.TimeUnit; 54 55 @RunWith(AndroidJUnit4.class) 56 @MediumTest 57 public class VmsSubscriberManagerTest extends MockedCarTestBase { 58 private static final String TAG = "VmsSubscriberManagerTest"; 59 private static final int PUBLISHER_ID = 17; 60 private static final int WRONG_PUBLISHER_ID = 26; 61 private static final Set<Integer> PUBLISHERS_LIST = new HashSet<Integer>(Arrays.asList(PUBLISHER_ID)); 62 63 private static final int SUBSCRIPTION_LAYER_ID = 2; 64 private static final int SUBSCRIPTION_LAYER_VERSION = 3; 65 private static final int MOCK_PUBLISHER_LAYER_SUBTYPE = 444; 66 private static final VmsLayer SUBSCRIPTION_LAYER = new VmsLayer(SUBSCRIPTION_LAYER_ID, 67 MOCK_PUBLISHER_LAYER_SUBTYPE, 68 SUBSCRIPTION_LAYER_VERSION); 69 private static final VmsAssociatedLayer SUBSCRIPTION_ASSOCIATED_LAYER = 70 new VmsAssociatedLayer(SUBSCRIPTION_LAYER, PUBLISHERS_LIST); 71 72 private static final int SUBSCRIPTION_DEPENDANT_LAYER_ID_1 = 4; 73 private static final int SUBSCRIPTION_DEPENDANT_LAYER_VERSION_1 = 5; 74 private static final VmsLayer SUBSCRIPTION_DEPENDANT_LAYER_1 = 75 new VmsLayer(SUBSCRIPTION_DEPENDANT_LAYER_ID_1, 76 MOCK_PUBLISHER_LAYER_SUBTYPE, 77 SUBSCRIPTION_DEPENDANT_LAYER_VERSION_1); 78 79 private static final VmsAssociatedLayer SUBSCRIPTION_DEPENDANT_ASSOCIATED_LAYER_1 = 80 new VmsAssociatedLayer(SUBSCRIPTION_DEPENDANT_LAYER_1, PUBLISHERS_LIST); 81 82 private static final int SUBSCRIPTION_DEPENDANT_LAYER_ID_2 = 6; 83 private static final int SUBSCRIPTION_DEPENDANT_LAYER_VERSION_2 = 7; 84 private static final VmsLayer SUBSCRIPTION_DEPENDANT_LAYER_2 = 85 new VmsLayer(SUBSCRIPTION_DEPENDANT_LAYER_ID_2, 86 MOCK_PUBLISHER_LAYER_SUBTYPE, 87 SUBSCRIPTION_DEPENDANT_LAYER_VERSION_2); 88 89 private static final VmsAssociatedLayer SUBSCRIPTION_DEPENDANT_ASSOCIATED_LAYER_2 = 90 new VmsAssociatedLayer(SUBSCRIPTION_DEPENDANT_LAYER_2, PUBLISHERS_LIST); 91 92 private static final int SUBSCRIPTION_UNSUPPORTED_LAYER_ID = 100; 93 private static final int SUBSCRIPTION_UNSUPPORTED_LAYER_VERSION = 200; 94 95 96 private HalHandler mHalHandler; 97 // Used to block until the HAL property is updated in HalHandler.onPropertySet. 98 private Semaphore mHalHandlerSemaphore; 99 // Used to block until a value is propagated to the TestClientCallback.onVmsMessageReceived. 100 private Semaphore mSubscriberSemaphore; 101 private Executor mExecutor; 102 103 private class ThreadPerTaskExecutor implements Executor { execute(Runnable r)104 public void execute(Runnable r) { 105 new Thread(r).start(); 106 } 107 } 108 109 110 @Override configureMockedHal()111 protected synchronized void configureMockedHal() { 112 mHalHandler = new HalHandler(); 113 addProperty(VehicleProperty.VEHICLE_MAP_SERVICE, mHalHandler) 114 .setChangeMode(VehiclePropertyChangeMode.ON_CHANGE) 115 .setAccess(VehiclePropertyAccess.READ_WRITE) 116 .addAreaConfig(VehicleAreaType.VEHICLE_AREA_TYPE_GLOBAL, 0, 0); 117 } 118 119 @Override setUp()120 public void setUp() throws Exception { 121 mExecutor = new ThreadPerTaskExecutor(); 122 super.setUp(); 123 mSubscriberSemaphore = new Semaphore(0); 124 mHalHandlerSemaphore = new Semaphore(0); 125 } 126 127 // Test injecting a value in the HAL and verifying it propagates to a subscriber. 128 @Test testSubscribe()129 public void testSubscribe() throws Exception { 130 VmsSubscriberManager vmsSubscriberManager = (VmsSubscriberManager) getCar().getCarManager( 131 Car.VMS_SUBSCRIBER_SERVICE); 132 TestClientCallback clientCallback = new TestClientCallback(); 133 vmsSubscriberManager.setVmsSubscriberClientCallback(mExecutor, clientCallback); 134 vmsSubscriberManager.subscribe(SUBSCRIPTION_LAYER); 135 136 // Inject a value and wait for its callback in TestClientCallback.onVmsMessageReceived. 137 VehiclePropValue v = VehiclePropValueBuilder.newBuilder(VehicleProperty.VEHICLE_MAP_SERVICE) 138 .setAreaId(VehicleAreaType.VEHICLE_AREA_TYPE_GLOBAL) 139 .setTimestamp(SystemClock.elapsedRealtimeNanos()) 140 .build(); 141 v.value.int32Values.add(VmsMessageType.DATA); // MessageType 142 v.value.int32Values.add(SUBSCRIPTION_LAYER_ID); 143 v.value.int32Values.add(MOCK_PUBLISHER_LAYER_SUBTYPE); 144 v.value.int32Values.add(SUBSCRIPTION_LAYER_VERSION); 145 v.value.int32Values.add(PUBLISHER_ID); 146 v.value.bytes.add((byte) 0xa); 147 v.value.bytes.add((byte) 0xb); 148 assertEquals(0, mSubscriberSemaphore.availablePermits()); 149 150 getMockedVehicleHal().injectEvent(v); 151 assertTrue(mSubscriberSemaphore.tryAcquire(2L, TimeUnit.SECONDS)); 152 assertEquals(SUBSCRIPTION_LAYER, clientCallback.getLayer()); 153 byte[] expectedPayload = {(byte) 0xa, (byte) 0xb}; 154 assertTrue(Arrays.equals(expectedPayload, clientCallback.getPayload())); 155 } 156 157 // Test injecting a value in the HAL and verifying it propagates to a subscriber. 158 @Test testSubscribeToPublisher()159 public void testSubscribeToPublisher() throws Exception { 160 VmsSubscriberManager vmsSubscriberManager = (VmsSubscriberManager) getCar().getCarManager( 161 Car.VMS_SUBSCRIBER_SERVICE); 162 TestClientCallback clientCallback = new TestClientCallback(); 163 vmsSubscriberManager.setVmsSubscriberClientCallback(mExecutor, clientCallback); 164 vmsSubscriberManager.subscribe(SUBSCRIPTION_LAYER, PUBLISHER_ID); 165 166 // Inject a value and wait for its callback in TestClientCallback.onVmsMessageReceived. 167 VehiclePropValue v = VehiclePropValueBuilder.newBuilder(VehicleProperty.VEHICLE_MAP_SERVICE) 168 .setAreaId(VehicleAreaType.VEHICLE_AREA_TYPE_GLOBAL) 169 .setTimestamp(SystemClock.elapsedRealtimeNanos()) 170 .build(); 171 v.value.int32Values.add(VmsMessageType.DATA); // MessageType 172 v.value.int32Values.add(SUBSCRIPTION_LAYER_ID); 173 v.value.int32Values.add(MOCK_PUBLISHER_LAYER_SUBTYPE); 174 v.value.int32Values.add(SUBSCRIPTION_LAYER_VERSION); 175 v.value.int32Values.add(WRONG_PUBLISHER_ID); 176 v.value.bytes.add((byte) 0xa); 177 v.value.bytes.add((byte) 0xb); 178 assertEquals(0, mSubscriberSemaphore.availablePermits()); 179 180 getMockedVehicleHal().injectEvent(v); 181 182 assertFalse(mSubscriberSemaphore.tryAcquire(2L, TimeUnit.SECONDS)); 183 } 184 185 // Test injecting a value in the HAL and verifying it propagates to a subscriber. 186 @Test testSubscribeFromPublisher()187 public void testSubscribeFromPublisher() throws Exception { 188 VmsSubscriberManager vmsSubscriberManager = (VmsSubscriberManager) getCar().getCarManager( 189 Car.VMS_SUBSCRIBER_SERVICE); 190 TestClientCallback clientCallback = new TestClientCallback(); 191 vmsSubscriberManager.setVmsSubscriberClientCallback(mExecutor, clientCallback); 192 vmsSubscriberManager.subscribe(SUBSCRIPTION_LAYER, PUBLISHER_ID); 193 194 // Inject a value and wait for its callback in TestClientCallback.onVmsMessageReceived. 195 VehiclePropValue v = VehiclePropValueBuilder.newBuilder(VehicleProperty.VEHICLE_MAP_SERVICE) 196 .setAreaId(VehicleAreaType.VEHICLE_AREA_TYPE_GLOBAL) 197 .setTimestamp(SystemClock.elapsedRealtimeNanos()) 198 .build(); 199 v.value.int32Values.add(VmsMessageType.DATA); // MessageType 200 v.value.int32Values.add(SUBSCRIPTION_LAYER_ID); 201 v.value.int32Values.add(MOCK_PUBLISHER_LAYER_SUBTYPE); //<- 202 v.value.int32Values.add(SUBSCRIPTION_LAYER_VERSION); 203 v.value.int32Values.add(PUBLISHER_ID); 204 v.value.bytes.add((byte) 0xa); 205 v.value.bytes.add((byte) 0xb); 206 assertEquals(0, mSubscriberSemaphore.availablePermits()); 207 208 getMockedVehicleHal().injectEvent(v); 209 assertTrue(mSubscriberSemaphore.tryAcquire(2L, TimeUnit.SECONDS)); 210 assertEquals(SUBSCRIPTION_LAYER, clientCallback.getLayer()); 211 byte[] expectedPayload = {(byte) 0xa, (byte) 0xb}; 212 assertTrue(Arrays.equals(expectedPayload, clientCallback.getPayload())); 213 } 214 215 // Test injecting a value in the HAL and verifying it does not propagate to a subscriber. 216 @Test testUnsubscribe()217 public void testUnsubscribe() throws Exception { 218 VmsSubscriberManager vmsSubscriberManager = (VmsSubscriberManager) getCar().getCarManager( 219 Car.VMS_SUBSCRIBER_SERVICE); 220 TestClientCallback clientCallback = new TestClientCallback(); 221 vmsSubscriberManager.setVmsSubscriberClientCallback(mExecutor, clientCallback); 222 vmsSubscriberManager.subscribe(SUBSCRIPTION_LAYER); 223 vmsSubscriberManager.unsubscribe(SUBSCRIPTION_LAYER); 224 225 // Inject a value and wait for its callback in TestClientCallback.onVmsMessageReceived. 226 VehiclePropValue v = VehiclePropValueBuilder.newBuilder(VehicleProperty.VEHICLE_MAP_SERVICE) 227 .setAreaId(VehicleAreaType.VEHICLE_AREA_TYPE_GLOBAL) 228 .setTimestamp(SystemClock.elapsedRealtimeNanos()) 229 .build(); 230 v.value.int32Values.add(VmsMessageType.DATA); // MessageType 231 v.value.int32Values.add(SUBSCRIPTION_LAYER_ID); 232 v.value.int32Values.add(MOCK_PUBLISHER_LAYER_SUBTYPE); 233 v.value.int32Values.add(SUBSCRIPTION_LAYER_VERSION); 234 v.value.int32Values.add(PUBLISHER_ID); 235 v.value.bytes.add((byte) 0xa); 236 v.value.bytes.add((byte) 0xb); 237 assertEquals(0, mSubscriberSemaphore.availablePermits()); 238 239 getMockedVehicleHal().injectEvent(v); 240 assertFalse(mSubscriberSemaphore.tryAcquire(2L, TimeUnit.SECONDS)); 241 } 242 243 // Test injecting a value in the HAL and verifying it does not propagate to a subscriber. 244 @Test testSubscribeFromWrongPublisher()245 public void testSubscribeFromWrongPublisher() throws Exception { 246 VmsSubscriberManager vmsSubscriberManager = (VmsSubscriberManager) getCar().getCarManager( 247 Car.VMS_SUBSCRIBER_SERVICE); 248 TestClientCallback clientCallback = new TestClientCallback(); 249 vmsSubscriberManager.setVmsSubscriberClientCallback(mExecutor, clientCallback); 250 vmsSubscriberManager.subscribe(SUBSCRIPTION_LAYER, PUBLISHER_ID); 251 252 // Inject a value and wait for its callback in TestClientCallback.onVmsMessageReceived. 253 VehiclePropValue v = VehiclePropValueBuilder.newBuilder(VehicleProperty.VEHICLE_MAP_SERVICE) 254 .setAreaId(VehicleAreaType.VEHICLE_AREA_TYPE_GLOBAL) 255 .setTimestamp(SystemClock.elapsedRealtimeNanos()) 256 .build(); 257 v.value.int32Values.add(VmsMessageType.DATA); // MessageType 258 v.value.int32Values.add(SUBSCRIPTION_LAYER_ID); 259 v.value.int32Values.add(MOCK_PUBLISHER_LAYER_SUBTYPE); 260 v.value.int32Values.add(SUBSCRIPTION_LAYER_VERSION); 261 v.value.int32Values.add(WRONG_PUBLISHER_ID); 262 v.value.bytes.add((byte) 0xa); 263 v.value.bytes.add((byte) 0xb); 264 assertEquals(0, mSubscriberSemaphore.availablePermits()); 265 266 getMockedVehicleHal().injectEvent(v); 267 assertFalse(mSubscriberSemaphore.tryAcquire(2L, TimeUnit.SECONDS)); 268 } 269 270 // Test injecting a value in the HAL and verifying it does not propagate to a subscriber. 271 @Test testUnsubscribeFromPublisher()272 public void testUnsubscribeFromPublisher() throws Exception { 273 VmsSubscriberManager vmsSubscriberManager = (VmsSubscriberManager) getCar().getCarManager( 274 Car.VMS_SUBSCRIBER_SERVICE); 275 TestClientCallback clientCallback = new TestClientCallback(); 276 vmsSubscriberManager.setVmsSubscriberClientCallback(mExecutor, clientCallback); 277 vmsSubscriberManager.subscribe(SUBSCRIPTION_LAYER, PUBLISHER_ID); 278 vmsSubscriberManager.unsubscribe(SUBSCRIPTION_LAYER, PUBLISHER_ID); 279 280 // Inject a value and wait for its callback in TestClientCallback.onVmsMessageReceived. 281 VehiclePropValue v = VehiclePropValueBuilder.newBuilder(VehicleProperty.VEHICLE_MAP_SERVICE) 282 .setAreaId(VehicleAreaType.VEHICLE_AREA_TYPE_GLOBAL) 283 .setTimestamp(SystemClock.elapsedRealtimeNanos()) 284 .build(); 285 v.value.int32Values.add(VmsMessageType.DATA); // MessageType 286 v.value.int32Values.add(SUBSCRIPTION_LAYER_ID); 287 v.value.int32Values.add(MOCK_PUBLISHER_LAYER_SUBTYPE); 288 v.value.int32Values.add(SUBSCRIPTION_LAYER_VERSION); 289 v.value.int32Values.add(PUBLISHER_ID); 290 v.value.bytes.add((byte) 0xa); 291 v.value.bytes.add((byte) 0xb); 292 assertEquals(0, mSubscriberSemaphore.availablePermits()); 293 294 getMockedVehicleHal().injectEvent(v); 295 assertFalse(mSubscriberSemaphore.tryAcquire(2L, TimeUnit.SECONDS)); 296 } 297 298 // Test injecting a value in the HAL and verifying it propagates to a subscriber. 299 @Test testSubscribeAll()300 public void testSubscribeAll() throws Exception { 301 VmsSubscriberManager vmsSubscriberManager = (VmsSubscriberManager) getCar().getCarManager( 302 Car.VMS_SUBSCRIBER_SERVICE); 303 TestClientCallback clientCallback = new TestClientCallback(); 304 vmsSubscriberManager.setVmsSubscriberClientCallback(mExecutor, clientCallback); 305 vmsSubscriberManager.startMonitoring(); 306 307 // Inject a value and wait for its callback in TestClientCallback.onVmsMessageReceived. 308 VehiclePropValue v = VehiclePropValueBuilder.newBuilder(VehicleProperty.VEHICLE_MAP_SERVICE) 309 .setAreaId(VehicleAreaType.VEHICLE_AREA_TYPE_GLOBAL) 310 .setTimestamp(SystemClock.elapsedRealtimeNanos()) 311 .build(); 312 v.value.int32Values.add(VmsMessageType.DATA); // MessageType 313 v.value.int32Values.add(SUBSCRIPTION_LAYER_ID); 314 v.value.int32Values.add(MOCK_PUBLISHER_LAYER_SUBTYPE); 315 v.value.int32Values.add(SUBSCRIPTION_LAYER_VERSION); 316 v.value.int32Values.add(PUBLISHER_ID); 317 v.value.bytes.add((byte) 0xa); 318 v.value.bytes.add((byte) 0xb); 319 assertEquals(0, mSubscriberSemaphore.availablePermits()); 320 321 getMockedVehicleHal().injectEvent(v); 322 assertTrue(mSubscriberSemaphore.tryAcquire(2L, TimeUnit.SECONDS)); 323 assertEquals(SUBSCRIPTION_LAYER, clientCallback.getLayer()); 324 byte[] expectedPayload = {(byte) 0xa, (byte) 0xb}; 325 assertTrue(Arrays.equals(expectedPayload, clientCallback.getPayload())); 326 } 327 328 // Test injecting a value in the HAL and verifying it propagates to a subscriber. 329 @Test testSimpleAvailableLayers()330 public void testSimpleAvailableLayers() throws Exception { 331 VmsSubscriberManager vmsSubscriberManager = (VmsSubscriberManager) getCar().getCarManager( 332 Car.VMS_SUBSCRIBER_SERVICE); 333 TestClientCallback clientCallback = new TestClientCallback(); 334 vmsSubscriberManager.setVmsSubscriberClientCallback(mExecutor, clientCallback); 335 336 // Inject a value and wait for its callback in TestClientCallback.onLayersAvailabilityChanged. 337 VehiclePropValue v = VehiclePropValueBuilder.newBuilder(VehicleProperty.VEHICLE_MAP_SERVICE) 338 .setAreaId(VehicleAreaType.VEHICLE_AREA_TYPE_GLOBAL) 339 .setTimestamp(SystemClock.elapsedRealtimeNanos()) 340 .build(); 341 // 342 // Offering: 343 // Layer | Dependency 344 // =============================== 345 // (2, 3, 444), [17] | {} 346 347 // Expected availability: 348 // {(2, 3, 444 [17])} 349 // 350 v.value.int32Values.addAll( 351 Arrays.asList( 352 VmsMessageType.OFFERING, // MessageType 353 PUBLISHER_ID, 354 1, // Number of offered layers 355 356 SUBSCRIPTION_LAYER_ID, 357 MOCK_PUBLISHER_LAYER_SUBTYPE, 358 SUBSCRIPTION_LAYER_VERSION, 359 0 // number of dependencies for layer 360 ) 361 ); 362 363 assertEquals(0, mSubscriberSemaphore.availablePermits()); 364 365 getMockedVehicleHal().injectEvent(v); 366 assertTrue(mSubscriberSemaphore.tryAcquire(2L, TimeUnit.SECONDS)); 367 Set<VmsAssociatedLayer> associatedLayers = 368 new HashSet<>(Arrays.asList(SUBSCRIPTION_ASSOCIATED_LAYER)); 369 assertEquals(associatedLayers, clientCallback.getAvailableLayers().getAssociatedLayers()); 370 } 371 372 // Test injecting a value in the HAL and verifying it propagates to a subscriber after it has 373 // subscribed to a layer. 374 @Test testSimpleAvailableLayersAfterSubscription()375 public void testSimpleAvailableLayersAfterSubscription() throws Exception { 376 VmsSubscriberManager vmsSubscriberManager = (VmsSubscriberManager) getCar().getCarManager( 377 Car.VMS_SUBSCRIBER_SERVICE); 378 TestClientCallback clientCallback = new TestClientCallback(); 379 vmsSubscriberManager.setVmsSubscriberClientCallback(mExecutor, clientCallback); 380 vmsSubscriberManager.subscribe(SUBSCRIPTION_LAYER); 381 382 // Inject a value and wait for its callback in TestClientCallback.onLayersAvailabilityChanged. 383 VehiclePropValue v = VehiclePropValueBuilder.newBuilder(VehicleProperty.VEHICLE_MAP_SERVICE) 384 .setAreaId(VehicleAreaType.VEHICLE_AREA_TYPE_GLOBAL) 385 .setTimestamp(SystemClock.elapsedRealtimeNanos()) 386 .build(); 387 // 388 // Offering: 389 // Layer | Dependency 390 // =============================== 391 // (2, 3, 444), [17] | {} 392 393 // Expected availability: 394 // {(2, 3, 444 [17])} 395 // 396 v.value.int32Values.addAll( 397 Arrays.asList( 398 VmsMessageType.OFFERING, // MessageType 399 PUBLISHER_ID, 400 1, // Number of offered layers 401 402 SUBSCRIPTION_LAYER_ID, 403 MOCK_PUBLISHER_LAYER_SUBTYPE, 404 SUBSCRIPTION_LAYER_VERSION, 405 0 // number of dependencies for layer 406 ) 407 ); 408 409 assertEquals(0, mSubscriberSemaphore.availablePermits()); 410 411 getMockedVehicleHal().injectEvent(v); 412 assertTrue(mSubscriberSemaphore.tryAcquire(2L, TimeUnit.SECONDS)); 413 Set<VmsAssociatedLayer> associatedLayers = 414 new HashSet<>(Arrays.asList(SUBSCRIPTION_ASSOCIATED_LAYER)); 415 assertEquals(associatedLayers, clientCallback.getAvailableLayers().getAssociatedLayers()); 416 } 417 418 // Test injecting a value in the HAL and verifying it does not propagates to a subscriber after 419 // it has cleared its callback. 420 @Test testSimpleAvailableLayersAfterClear()421 public void testSimpleAvailableLayersAfterClear() throws Exception { 422 VmsSubscriberManager vmsSubscriberManager = (VmsSubscriberManager) getCar().getCarManager( 423 Car.VMS_SUBSCRIBER_SERVICE); 424 TestClientCallback clientCallback = new TestClientCallback(); 425 vmsSubscriberManager.setVmsSubscriberClientCallback(mExecutor, clientCallback); 426 vmsSubscriberManager.clearVmsSubscriberClientCallback(); 427 428 429 // Inject a value and wait for its callback in TestClientCallback.onLayersAvailabilityChanged. 430 VehiclePropValue v = VehiclePropValueBuilder.newBuilder(VehicleProperty.VEHICLE_MAP_SERVICE) 431 .setAreaId(VehicleAreaType.VEHICLE_AREA_TYPE_GLOBAL) 432 .setTimestamp(SystemClock.elapsedRealtimeNanos()) 433 .build(); 434 // 435 // Offering: 436 // Layer | Dependency 437 // =============================== 438 // (2, 3, 444), [17] | {} 439 440 // Expected availability: 441 // {(2, 3, 444 [17])} 442 // 443 v.value.int32Values.addAll( 444 Arrays.asList( 445 VmsMessageType.OFFERING, // MessageType 446 PUBLISHER_ID, 447 1, // Number of offered layers 448 449 SUBSCRIPTION_LAYER_ID, 450 SUBSCRIPTION_LAYER_VERSION, 451 MOCK_PUBLISHER_LAYER_SUBTYPE, 452 0 // number of dependencies for layer 453 ) 454 ); 455 456 assertEquals(0, mSubscriberSemaphore.availablePermits()); 457 getMockedVehicleHal().injectEvent(v); 458 assertFalse(mSubscriberSemaphore.tryAcquire(2L, TimeUnit.SECONDS)); 459 } 460 461 // Test injecting a value in the HAL and verifying it propagates to a subscriber. 462 @Test testComplexAvailableLayers()463 public void testComplexAvailableLayers() throws Exception { 464 VmsSubscriberManager vmsSubscriberManager = (VmsSubscriberManager) getCar().getCarManager( 465 Car.VMS_SUBSCRIBER_SERVICE); 466 TestClientCallback clientCallback = new TestClientCallback(); 467 vmsSubscriberManager.setVmsSubscriberClientCallback(mExecutor, clientCallback); 468 469 // Inject a value and wait for its callback in TestClientCallback.onLayersAvailabilityChanged. 470 VehiclePropValue v = VehiclePropValueBuilder.newBuilder(VehicleProperty.VEHICLE_MAP_SERVICE) 471 .setAreaId(VehicleAreaType.VEHICLE_AREA_TYPE_GLOBAL) 472 .setTimestamp(SystemClock.elapsedRealtimeNanos()) 473 .build(); 474 // 475 // Offering: 476 // Layer | Dependency 477 // ===================================== 478 // (2, 3, 444), [17] | {} 479 // (4, 5, 444), [17] | {(2, 3)} 480 // (6, 7, 444), [17] | {(2, 3), (4, 5)} 481 // (6, 7, 444), [17] | {(100, 200)} 482 483 // Expected availability: 484 // {(2, 3, 444 [17]), (4, 5, 444 [17]), (6, 7, 444 [17])} 485 // 486 487 v.value.int32Values.addAll( 488 Arrays.asList( 489 VmsMessageType.OFFERING, // MessageType 490 PUBLISHER_ID, 491 4, // Number of offered layers 492 493 SUBSCRIPTION_LAYER_ID, 494 MOCK_PUBLISHER_LAYER_SUBTYPE, 495 SUBSCRIPTION_LAYER_VERSION, 496 0, // number of dependencies for layer 497 498 SUBSCRIPTION_DEPENDANT_LAYER_ID_1, 499 MOCK_PUBLISHER_LAYER_SUBTYPE, 500 SUBSCRIPTION_DEPENDANT_LAYER_VERSION_1, 501 1, // number of dependencies for layer 502 SUBSCRIPTION_LAYER_ID, 503 MOCK_PUBLISHER_LAYER_SUBTYPE, 504 SUBSCRIPTION_LAYER_VERSION, 505 506 SUBSCRIPTION_DEPENDANT_LAYER_ID_2, 507 MOCK_PUBLISHER_LAYER_SUBTYPE, 508 SUBSCRIPTION_DEPENDANT_LAYER_VERSION_2, 509 2, // number of dependencies for layer 510 SUBSCRIPTION_LAYER_ID, 511 MOCK_PUBLISHER_LAYER_SUBTYPE, 512 SUBSCRIPTION_LAYER_VERSION, 513 SUBSCRIPTION_DEPENDANT_LAYER_ID_1, 514 MOCK_PUBLISHER_LAYER_SUBTYPE, 515 SUBSCRIPTION_DEPENDANT_LAYER_VERSION_1, 516 517 SUBSCRIPTION_DEPENDANT_LAYER_ID_2, 518 MOCK_PUBLISHER_LAYER_SUBTYPE, 519 SUBSCRIPTION_DEPENDANT_LAYER_VERSION_2, 520 1, // number of dependencies for layer 521 SUBSCRIPTION_UNSUPPORTED_LAYER_ID, 522 MOCK_PUBLISHER_LAYER_SUBTYPE, 523 SUBSCRIPTION_UNSUPPORTED_LAYER_VERSION 524 ) 525 ); 526 527 assertEquals(0, mSubscriberSemaphore.availablePermits()); 528 529 Set<VmsAssociatedLayer> associatedLayers = 530 new HashSet<>(Arrays.asList( 531 SUBSCRIPTION_ASSOCIATED_LAYER, 532 SUBSCRIPTION_DEPENDANT_ASSOCIATED_LAYER_1, 533 SUBSCRIPTION_DEPENDANT_ASSOCIATED_LAYER_2 534 )); 535 536 getMockedVehicleHal().injectEvent(v); 537 assertTrue(mSubscriberSemaphore.tryAcquire(2L, TimeUnit.SECONDS)); 538 539 // Verify applications API. 540 assertEquals(associatedLayers, clientCallback.getAvailableLayers().getAssociatedLayers()); 541 assertEquals(1, clientCallback.getAvailableLayers().getSequence()); 542 543 // Verify HAL API. 544 ArrayList<Integer> values = mHalHandler.getValue().value.int32Values; 545 int messageType = values.get(VmsAvailabilityStateIntegerValuesIndex.MESSAGE_TYPE); 546 int sequenceNumber = values.get(VmsAvailabilityStateIntegerValuesIndex.SEQUENCE_NUMBER); 547 int numberLayers = 548 values.get(VmsAvailabilityStateIntegerValuesIndex.NUMBER_OF_ASSOCIATED_LAYERS); 549 550 assertEquals(messageType, VmsMessageType.AVAILABILITY_CHANGE); 551 assertEquals(1, sequenceNumber); 552 assertEquals(3, numberLayers); 553 } 554 555 // Test injecting a value in the HAL twice the sequence for availability is incremented. 556 @Test testDoubleOfferingAvailableLayers()557 public void testDoubleOfferingAvailableLayers() throws Exception { 558 VmsSubscriberManager vmsSubscriberManager = (VmsSubscriberManager) getCar().getCarManager( 559 Car.VMS_SUBSCRIBER_SERVICE); 560 TestClientCallback clientCallback = new TestClientCallback(); 561 vmsSubscriberManager.setVmsSubscriberClientCallback(mExecutor, clientCallback); 562 563 // Inject a value and wait for its callback in TestClientCallback.onLayersAvailabilityChanged. 564 VehiclePropValue v = VehiclePropValueBuilder.newBuilder(VehicleProperty.VEHICLE_MAP_SERVICE) 565 .setAreaId(VehicleAreaType.VEHICLE_AREA_TYPE_GLOBAL) 566 .setTimestamp(SystemClock.elapsedRealtimeNanos()) 567 .build(); 568 // 569 // Offering: 570 // Layer | Dependency 571 // =============================== 572 // (2, 3, 444), [17] | {} 573 574 // Expected availability: 575 // {(2, 3, 444 [17])} 576 // 577 v.value.int32Values.addAll( 578 Arrays.asList( 579 VmsMessageType.OFFERING, // MessageType 580 PUBLISHER_ID, 581 1, // Number of offered layers 582 583 SUBSCRIPTION_LAYER_ID, 584 MOCK_PUBLISHER_LAYER_SUBTYPE, 585 SUBSCRIPTION_LAYER_VERSION, 586 0 // number of dependencies for layer 587 ) 588 ); 589 590 assertEquals(0, mSubscriberSemaphore.availablePermits()); 591 592 // Inject first offer. 593 getMockedVehicleHal().injectEvent(v); 594 assertTrue(mSubscriberSemaphore.tryAcquire(2L, TimeUnit.SECONDS)); 595 596 // Verify applications API. 597 Set<VmsAssociatedLayer> associatedLayers = 598 new HashSet<>(Arrays.asList(SUBSCRIPTION_ASSOCIATED_LAYER)); 599 assertEquals(associatedLayers, clientCallback.getAvailableLayers().getAssociatedLayers()); 600 assertEquals(1, clientCallback.getAvailableLayers().getSequence()); 601 602 // Verify HAL API. 603 ArrayList<Integer> values = mHalHandler.getValue().value.int32Values; 604 int messageType = values.get(VmsAvailabilityStateIntegerValuesIndex.MESSAGE_TYPE); 605 int sequenceNumber = values.get(VmsAvailabilityStateIntegerValuesIndex.SEQUENCE_NUMBER); 606 int numberLayers = 607 values.get(VmsAvailabilityStateIntegerValuesIndex.NUMBER_OF_ASSOCIATED_LAYERS); 608 609 assertEquals(messageType, VmsMessageType.AVAILABILITY_CHANGE); 610 assertEquals(1, sequenceNumber); 611 assertEquals(1, numberLayers); 612 613 // Inject second offer. 614 getMockedVehicleHal().injectEvent(v); 615 assertTrue(mSubscriberSemaphore.tryAcquire(2L, TimeUnit.SECONDS)); 616 617 // Verify applications API. 618 assertEquals(2, clientCallback.getAvailableLayers().getSequence()); 619 620 // Verify HAL API. 621 values = mHalHandler.getValue().value.int32Values; 622 messageType = values.get(VmsAvailabilityStateIntegerValuesIndex.MESSAGE_TYPE); 623 sequenceNumber = values.get(VmsAvailabilityStateIntegerValuesIndex.SEQUENCE_NUMBER); 624 numberLayers = 625 values.get(VmsAvailabilityStateIntegerValuesIndex.NUMBER_OF_ASSOCIATED_LAYERS); 626 627 assertEquals(messageType, VmsMessageType.AVAILABILITY_CHANGE); 628 assertEquals(2, sequenceNumber); 629 assertEquals(1, numberLayers); 630 631 } 632 633 // Test GetAvailableLayers(). 634 @Test testGetAvailableLayers()635 public void testGetAvailableLayers() throws Exception { 636 VmsSubscriberManager vmsSubscriberManager = (VmsSubscriberManager) getCar().getCarManager( 637 Car.VMS_SUBSCRIBER_SERVICE); 638 TestClientCallback clientCallback = new TestClientCallback(); 639 vmsSubscriberManager.setVmsSubscriberClientCallback(mExecutor, clientCallback); 640 641 // Inject a value and wait for its callback in TestClientCallback.onLayersAvailabilityChanged. 642 VehiclePropValue v = VehiclePropValueBuilder.newBuilder(VehicleProperty.VEHICLE_MAP_SERVICE) 643 .setAreaId(VehicleAreaType.VEHICLE_AREA_TYPE_GLOBAL) 644 .setTimestamp(SystemClock.elapsedRealtimeNanos()) 645 .build(); 646 // 647 // Offering: 648 // Layer | Dependency 649 // =============================== 650 // (2, 3, 444), [17] | {} 651 652 // Expected availability: 653 // {(2, 3, 444 [17])} 654 // 655 v.value.int32Values.addAll( 656 Arrays.asList( 657 VmsMessageType.OFFERING, // MessageType 658 PUBLISHER_ID, 659 1, // Number of offered layers 660 661 SUBSCRIPTION_LAYER_ID, 662 MOCK_PUBLISHER_LAYER_SUBTYPE, 663 SUBSCRIPTION_LAYER_VERSION, 664 0 // number of dependencies for layer 665 ) 666 ); 667 668 assertEquals(0, mSubscriberSemaphore.availablePermits()); 669 670 getMockedVehicleHal().injectEvent(v); 671 assertTrue(mSubscriberSemaphore.tryAcquire(2L, TimeUnit.SECONDS)); 672 Set<VmsAssociatedLayer> associatedLayers = 673 new HashSet<>(Arrays.asList(SUBSCRIPTION_ASSOCIATED_LAYER)); 674 assertEquals(associatedLayers, clientCallback.getAvailableLayers().getAssociatedLayers()); 675 assertEquals(1, clientCallback.getAvailableLayers().getSequence()); 676 677 assertEquals(associatedLayers, vmsSubscriberManager.getAvailableLayers().getAssociatedLayers()); 678 assertEquals(1, vmsSubscriberManager.getAvailableLayers().getSequence()); 679 } 680 681 private class HalHandler implements VehicleHalPropertyHandler { 682 private VehiclePropValue mValue; 683 684 @Override onPropertySet(VehiclePropValue value)685 public synchronized void onPropertySet(VehiclePropValue value) { 686 mValue = value; 687 mHalHandlerSemaphore.release(); 688 } 689 690 @Override onPropertyGet(VehiclePropValue value)691 public synchronized VehiclePropValue onPropertyGet(VehiclePropValue value) { 692 return mValue != null ? mValue : value; 693 } 694 695 @Override onPropertySubscribe(int property, float sampleRate)696 public synchronized void onPropertySubscribe(int property, float sampleRate) { 697 Log.d(TAG, "onPropertySubscribe property " + property + " sampleRate " + sampleRate); 698 } 699 700 @Override onPropertyUnsubscribe(int property)701 public synchronized void onPropertyUnsubscribe(int property) { 702 Log.d(TAG, "onPropertyUnSubscribe property " + property); 703 } 704 getValue()705 public VehiclePropValue getValue() { 706 return mValue; 707 } 708 } 709 710 private class TestClientCallback implements VmsSubscriberClientCallback { 711 private VmsLayer mLayer; 712 private byte[] mPayload; 713 private VmsAvailableLayers mAvailableLayers; 714 715 @Override onVmsMessageReceived(VmsLayer layer, byte[] payload)716 public void onVmsMessageReceived(VmsLayer layer, byte[] payload) { 717 Log.d(TAG, "onVmsMessageReceived: layer: " + layer + " Payload: " + payload); 718 mLayer = layer; 719 mPayload = payload; 720 mSubscriberSemaphore.release(); 721 } 722 723 @Override onLayersAvailabilityChanged(VmsAvailableLayers availableLayers)724 public void onLayersAvailabilityChanged(VmsAvailableLayers availableLayers) { 725 Log.d(TAG, "onLayersAvailabilityChanged: Layers: " + availableLayers); 726 mAvailableLayers = availableLayers; 727 mSubscriberSemaphore.release(); 728 } 729 getLayer()730 public VmsLayer getLayer() { 731 return mLayer; 732 } 733 getPayload()734 public byte[] getPayload() { 735 return mPayload; 736 } 737 getAvailableLayers()738 public VmsAvailableLayers getAvailableLayers() { 739 return mAvailableLayers; 740 } 741 } 742 } 743