Add a class to calculate the available layers out of the publishers offerings
Change-Id: I053a1d45e197f78891168269f2d4fbff258e2e29
Test: created a new test and all VMS 4 tests are passing.
diff --git a/car-lib/src/android/car/vms/VmsLayerDependency.java b/car-lib/src/android/car/vms/VmsLayerDependency.java
index a6c513d..bb588eb 100644
--- a/car-lib/src/android/car/vms/VmsLayerDependency.java
+++ b/car-lib/src/android/car/vms/VmsLayerDependency.java
@@ -20,8 +20,11 @@
import android.os.Parcel;
import android.os.Parcelable;
import java.util.ArrayList;
+import java.util.Arrays;
import java.util.Collections;
+import java.util.HashSet;
import java.util.List;
+import java.util.Set;
/**
* A dependency for a VMS layer on other VMS layers.
@@ -31,14 +34,14 @@
@FutureFeature
public final class VmsLayerDependency implements Parcelable {
private final VmsLayer mLayer;
- private final List<VmsLayer> mDependency;
+ private final Set<VmsLayer> mDependency;
/**
* Construct a dependency for layer on other layers.
*/
- public VmsLayerDependency(VmsLayer layer, List<VmsLayer> dependencies) {
+ public VmsLayerDependency(VmsLayer layer, Set<VmsLayer> dependencies) {
mLayer = layer;
- mDependency = Collections.unmodifiableList(dependencies);
+ mDependency = Collections.unmodifiableSet(dependencies);
}
/**
@@ -46,7 +49,7 @@
*/
public VmsLayerDependency(VmsLayer layer) {
mLayer = layer;
- mDependency = Collections.emptyList();
+ mDependency = Collections.emptySet();
}
/**
@@ -63,7 +66,7 @@
/**
* Returns the dependencies.
*/
- public List<VmsLayer> getDependencies() {
+ public Set<VmsLayer> getDependencies() {
return mDependency;
}
@@ -80,7 +83,7 @@
@Override
public void writeToParcel(Parcel out, int flags) {
out.writeParcelable(mLayer, flags);
- out.writeParcelableList(mDependency, flags);
+ out.writeParcelableList(new ArrayList<VmsLayer>(mDependency), flags);
}
@Override
@@ -92,6 +95,6 @@
mLayer = in.readParcelable(VmsLayer.class.getClassLoader());
List<VmsLayer> dependency = new ArrayList<>();
in.readParcelableList(dependency, VmsLayer.class.getClassLoader());
- mDependency = Collections.unmodifiableList(dependency);
+ mDependency = Collections.unmodifiableSet(new HashSet<VmsLayer>(dependency));
}
}
\ No newline at end of file
diff --git a/service/src/com/android/car/VmsLayersAvailability.java b/service/src/com/android/car/VmsLayersAvailability.java
new file mode 100644
index 0000000..5f5ac30
--- /dev/null
+++ b/service/src/com/android/car/VmsLayersAvailability.java
@@ -0,0 +1,172 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.car;
+
+import android.car.annotation.FutureFeature;
+import android.car.vms.VmsLayer;
+import android.car.vms.VmsLayerDependency;
+import android.car.vms.VmsLayersOffering;
+import android.util.Log;
+import com.android.internal.annotations.GuardedBy;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+/**
+ * Manages VMS availability for layers.
+ *
+ * Each VMS publisher sets its layers offering which are a list of layers the publisher claims
+ * it might publish. VmsLayersAvailability calculates from all the offering what are the
+ * available layers.
+ */
+
+@FutureFeature
+public class VmsLayersAvailability {
+
+ private static final boolean DBG = true;
+ private static final String TAG = "VmsLayersAvailability";
+
+ private final Object mLock = new Object();
+ @GuardedBy("mLock")
+ private final Map<VmsLayer, Set<Set<VmsLayer>>> mPotentialLayersAndDependencies =
+ new HashMap<>();
+ @GuardedBy("mLock")
+ private final Set<VmsLayer> mCyclicAvoidanceSet = new HashSet<>();
+ @GuardedBy("mLock")
+ private Set<VmsLayer> mAvailableLayers = Collections.EMPTY_SET;
+ @GuardedBy("mLock")
+ private Set<VmsLayer> mUnavailableLayers = Collections.EMPTY_SET;
+
+ /**
+ * Setting the current layers offerings as reported by publishers.
+ */
+ public void setPublishersOffering(Collection<VmsLayersOffering> publishersLayersOfferings) {
+ synchronized (mLock) {
+ reset();
+
+ for (VmsLayersOffering offering : publishersLayersOfferings) {
+ for (VmsLayerDependency dependency : offering.getDependencies()) {
+ VmsLayer layer = dependency.getLayer();
+ Set<Set<VmsLayer>> curDependencies =
+ mPotentialLayersAndDependencies.get(layer);
+ if (curDependencies == null) {
+ curDependencies = new HashSet<>();
+ mPotentialLayersAndDependencies.put(layer, curDependencies);
+ }
+ curDependencies.add(dependency.getDependencies());
+ }
+ }
+ calculateLayers();
+ }
+ }
+
+ /**
+ * Returns a collection of all the layers which may be published.
+ */
+ public Collection<VmsLayer> getAvailableLayers() {
+ synchronized (mLock) {
+ return mAvailableLayers;
+ }
+ }
+
+ /**
+ * Returns a collection of all the layers which publishers could have published if the
+ * dependencies were satisfied.
+ */
+ public Collection<VmsLayer> getUnavailableLayers() {
+ synchronized (mLock) {
+ return mUnavailableLayers;
+ }
+ }
+
+ private void reset() {
+ synchronized (mLock) {
+ mCyclicAvoidanceSet.clear();
+ mPotentialLayersAndDependencies.clear();
+ mAvailableLayers = Collections.EMPTY_SET;
+ mUnavailableLayers = Collections.EMPTY_SET;
+ }
+ }
+
+ private void calculateLayers() {
+ synchronized (mLock) {
+ final Set<VmsLayer> availableLayers = new HashSet<>();
+
+ availableLayers.addAll(
+ mPotentialLayersAndDependencies.keySet()
+ .stream()
+ .filter(layer -> isLayerSupportedLocked(layer, availableLayers))
+ .collect(Collectors.toSet()));
+
+ mAvailableLayers = Collections.unmodifiableSet(availableLayers);
+ mUnavailableLayers = Collections.unmodifiableSet(
+ mPotentialLayersAndDependencies.keySet()
+ .stream()
+ .filter(layer -> !availableLayers.contains(layer))
+ .collect(Collectors.toSet()));
+ }
+ }
+
+ private boolean isLayerSupportedLocked(VmsLayer layer, Set<VmsLayer> currentAvailableLayers) {
+ if (DBG) {
+ Log.d(TAG, "isLayerSupported: checking layer: " + layer);
+ }
+ // If we already know that this layer is supported then we are done.
+ if (currentAvailableLayers.contains(layer)) {
+ return true;
+ }
+ // If there is no offering for this layer we're done.
+ if (!mPotentialLayersAndDependencies.containsKey(layer)) {
+ return false;
+ }
+ // Avoid cyclic dependency.
+ if (mCyclicAvoidanceSet.contains(layer)) {
+ Log.e(TAG, "Detected a cyclic dependency: " + mCyclicAvoidanceSet + " -> " + layer);
+ return false;
+ }
+ for (Set<VmsLayer> dependencies : mPotentialLayersAndDependencies.get(layer)) {
+ // If layer does not have any dependencies then add to supported.
+ if (dependencies == null || dependencies.isEmpty()) {
+ currentAvailableLayers.add(layer);
+ return true;
+ }
+ // Add the layer to cyclic avoidance set
+ mCyclicAvoidanceSet.add(layer);
+
+ boolean isSupported = true;
+ for (VmsLayer dependency : dependencies) {
+ if (!isLayerSupportedLocked(dependency, currentAvailableLayers)) {
+ isSupported = false;
+ break;
+ }
+ }
+ mCyclicAvoidanceSet.remove(layer);
+
+ if (isSupported) {
+ currentAvailableLayers.add(layer);
+ return true;
+ }
+ }
+ return false;
+ }
+}
diff --git a/tests/carservice_unit_test/src/com/android/car/VmsLayersAvailabilityTest.java b/tests/carservice_unit_test/src/com/android/car/VmsLayersAvailabilityTest.java
new file mode 100644
index 0000000..07a0122
--- /dev/null
+++ b/tests/carservice_unit_test/src/com/android/car/VmsLayersAvailabilityTest.java
@@ -0,0 +1,246 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.car;
+
+import android.car.vms.VmsLayer;
+import android.car.vms.VmsLayerDependency;
+import android.car.vms.VmsLayersOffering;
+import android.test.AndroidTestCase;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+
+public class VmsLayersAvailabilityTest extends AndroidTestCase {
+
+ private static final VmsLayer LAYER_X = new VmsLayer(1, 2);
+ private static final VmsLayer LAYER_Y = new VmsLayer(3, 4);
+ private static final VmsLayer LAYER_Z = new VmsLayer(5, 6);
+
+ private static final VmsLayerDependency X_DEPENDS_ON_Y =
+ new VmsLayerDependency(LAYER_X, new HashSet<VmsLayer>(Arrays.asList(LAYER_Y)));
+
+ private static final VmsLayerDependency X_DEPENDS_ON_Z =
+ new VmsLayerDependency(LAYER_X, new HashSet<VmsLayer>(Arrays.asList(LAYER_Z)));
+
+ private static final VmsLayerDependency Y_DEPENDS_ON_Z =
+ new VmsLayerDependency(LAYER_Y, new HashSet<VmsLayer>(Arrays.asList(LAYER_Z)));
+
+ private static final VmsLayerDependency Y_DEPENDS_ON_X =
+ new VmsLayerDependency(LAYER_Y, new HashSet<VmsLayer>(Arrays.asList(LAYER_X)));
+
+ private static final VmsLayerDependency Z_DEPENDS_ON_X =
+ new VmsLayerDependency(LAYER_Z, new HashSet<VmsLayer>(Arrays.asList(LAYER_X)));
+
+ private static final VmsLayerDependency Z_DEPENDS_ON_NOTHING =
+ new VmsLayerDependency(LAYER_Z);
+
+ private static final VmsLayerDependency X_DEPENDS_ON_SELF =
+ new VmsLayerDependency(LAYER_X, new HashSet<VmsLayer>(Arrays.asList(LAYER_X)));
+
+ private Set<VmsLayersOffering> mOfferings;
+ private VmsLayersAvailability mLayersAvailability;
+
+ @Override
+ protected void setUp() throws Exception {
+ mLayersAvailability = new VmsLayersAvailability();
+ mOfferings = new HashSet<>();
+ super.setUp();
+ }
+
+ public void testSingleLayerNoDeps() throws Exception {
+ Set<VmsLayer> expectedAvailableLayers = new HashSet<>();
+ expectedAvailableLayers.add(LAYER_X);
+
+ VmsLayersOffering offering =
+ new VmsLayersOffering(Arrays.asList(new VmsLayerDependency(LAYER_X)));
+
+ mOfferings.add(offering);
+ mLayersAvailability.setPublishersOffering(mOfferings);
+
+ assertEquals(expectedAvailableLayers, mLayersAvailability.getAvailableLayers());
+ }
+
+ public void testChainOfDependenciesSatisfied() throws Exception {
+ Set<VmsLayer> expectedAvailableLayers = new HashSet<>();
+ expectedAvailableLayers.add(LAYER_X);
+ expectedAvailableLayers.add(LAYER_Y);
+ expectedAvailableLayers.add(LAYER_Z);
+
+ VmsLayersOffering offering =
+ new VmsLayersOffering(Arrays.asList(
+ X_DEPENDS_ON_Y,
+ Y_DEPENDS_ON_Z,
+ Z_DEPENDS_ON_NOTHING));
+
+ mOfferings.add(offering);
+ mLayersAvailability.setPublishersOffering(mOfferings);
+
+ assertEquals(expectedAvailableLayers,
+ new HashSet<VmsLayer>(mLayersAvailability.getAvailableLayers()));
+ }
+
+ public void testChainOfDependenciesSatisfiedTwoOfferings() throws Exception {
+ Set<VmsLayer> expectedAvailableLayers = new HashSet<>();
+ expectedAvailableLayers.add(LAYER_X);
+ expectedAvailableLayers.add(LAYER_Y);
+ expectedAvailableLayers.add(LAYER_Z);
+
+ VmsLayersOffering offering1 =
+ new VmsLayersOffering(Arrays.asList(
+ X_DEPENDS_ON_Y,
+ Y_DEPENDS_ON_Z));
+
+ VmsLayersOffering offering2 =
+ new VmsLayersOffering(Arrays.asList(
+ Z_DEPENDS_ON_NOTHING));
+
+ mOfferings.add(offering1);
+ mOfferings.add(offering2);
+ mLayersAvailability.setPublishersOffering(mOfferings);
+
+ assertEquals(expectedAvailableLayers,
+ new HashSet<VmsLayer>(mLayersAvailability.getAvailableLayers()));
+ }
+
+ public void testChainOfDependencieNotSatisfied() throws Exception {
+ Set<VmsLayer> expectedAvailableLayers = new HashSet<>();
+ VmsLayersOffering offering =new VmsLayersOffering(Arrays.asList(
+ X_DEPENDS_ON_Y,
+ Y_DEPENDS_ON_Z));
+
+ mOfferings.add(offering);
+ mLayersAvailability.setPublishersOffering(mOfferings);
+
+ assertEquals(expectedAvailableLayers,
+ new HashSet<VmsLayer>(mLayersAvailability.getAvailableLayers()));
+
+ Set<VmsLayer> expectedUnavailableLayers = new HashSet<>();
+ expectedUnavailableLayers.add(LAYER_X);
+ expectedUnavailableLayers.add(LAYER_Y);
+
+ assertEquals(expectedUnavailableLayers ,
+ new HashSet<VmsLayer>(mLayersAvailability.getUnavailableLayers()));
+ }
+
+ public void testOneOfMultipleDependencySatisfied() throws Exception {
+ Set<VmsLayer> expectedAvailableLayers = new HashSet<>();
+ expectedAvailableLayers.add(LAYER_X);
+ expectedAvailableLayers.add(LAYER_Z);
+
+ VmsLayersOffering offering =
+ new VmsLayersOffering(Arrays.asList(
+ X_DEPENDS_ON_Y,
+ X_DEPENDS_ON_Z,
+ Z_DEPENDS_ON_NOTHING));
+
+ mOfferings.add(offering);
+ mLayersAvailability.setPublishersOffering(mOfferings);
+
+ assertEquals(expectedAvailableLayers,
+ new HashSet<VmsLayer>(mLayersAvailability.getAvailableLayers()));
+ }
+
+ public void testCyclicDependency() throws Exception {
+ Set<VmsLayer> expectedAvailableLayers = new HashSet<>();
+
+ VmsLayersOffering offering =
+ new VmsLayersOffering(Arrays.asList(
+ X_DEPENDS_ON_Y,
+ Y_DEPENDS_ON_Z,
+ Z_DEPENDS_ON_X));
+
+ mOfferings.add(offering);
+ mLayersAvailability.setPublishersOffering(mOfferings);
+
+ assertEquals(expectedAvailableLayers,
+ new HashSet<VmsLayer>(mLayersAvailability.getAvailableLayers()));
+ }
+
+ public void testAlmostCyclicDependency() throws Exception {
+ Set<VmsLayer> expectedAvailableLayers = new HashSet<>();
+ expectedAvailableLayers.add(LAYER_X);
+ expectedAvailableLayers.add(LAYER_Y);
+ expectedAvailableLayers.add(LAYER_Z);
+
+ VmsLayersOffering offering1 =
+ new VmsLayersOffering(Arrays.asList(
+ X_DEPENDS_ON_Y,
+ Z_DEPENDS_ON_NOTHING));
+
+ VmsLayersOffering offering2 =
+ new VmsLayersOffering(Arrays.asList(
+ Y_DEPENDS_ON_Z,
+ Z_DEPENDS_ON_X));
+
+ mOfferings.add(offering1);
+ mOfferings.add(offering2);
+ mLayersAvailability.setPublishersOffering(mOfferings);
+
+ assertEquals(expectedAvailableLayers,
+ new HashSet<VmsLayer>(mLayersAvailability.getAvailableLayers()));
+ }
+
+ public void testCyclicDependencyAndLayerWithoutDependency() throws Exception {
+ Set<VmsLayer> expectedAvailableLayers = new HashSet<>();
+ expectedAvailableLayers.add(LAYER_Z);
+
+ VmsLayersOffering offering1 =
+ new VmsLayersOffering(Arrays.asList(
+ X_DEPENDS_ON_Y,
+ Z_DEPENDS_ON_NOTHING));
+
+ VmsLayersOffering offering2 =
+ new VmsLayersOffering(Arrays.asList(
+ Y_DEPENDS_ON_X));
+
+ mOfferings.add(offering1);
+ mOfferings.add(offering2);
+ mLayersAvailability.setPublishersOffering(mOfferings);
+
+ assertEquals(expectedAvailableLayers,
+ new HashSet<VmsLayer>(mLayersAvailability.getAvailableLayers()));
+
+
+ Set<VmsLayer> expectedUnavailableLayers = new HashSet<>();
+ expectedUnavailableLayers.add(LAYER_Y);
+ expectedUnavailableLayers.add(LAYER_X);
+
+ assertEquals(expectedUnavailableLayers,
+ new HashSet<VmsLayer>(mLayersAvailability.getUnavailableLayers()));
+ }
+
+ public void testSelfDependency() throws Exception {
+ Set<VmsLayer> expectedAvailableLayers = new HashSet<>();
+
+ VmsLayersOffering offering =
+ new VmsLayersOffering(Arrays.asList(
+ X_DEPENDS_ON_SELF));
+
+ mOfferings.add(offering);
+ mLayersAvailability.setPublishersOffering(mOfferings);
+
+ assertEquals(expectedAvailableLayers,
+ new HashSet<VmsLayer>(mLayersAvailability.getAvailableLayers()));
+
+ Set<VmsLayer> expectedUnavailableLayers = new HashSet<>();
+ expectedUnavailableLayers.add(LAYER_X);
+
+ assertEquals(expectedUnavailableLayers,
+ new HashSet<VmsLayer>(mLayersAvailability.getUnavailableLayers()));
+ }
+}
\ No newline at end of file