add support for linked services

Some services require linked services to work, for example, the Television service which requires each input to be a linked service.
With this change, support to link services is added, though it's not used in any existing service, as they don't need linking.

This change also centralizes the generation of interface ids. They are now only generated in the registry.
We were previously also generating them in the accessory controller, relying on an identical processing sequence.

Author: dfrommi

Diff for: CHANGES.md

@@ -7,6 +7,7 @@
     * `services` package consists of services, which grouping characteristics. e.g. `WindowCoveringService` defines mandatory and optional characteristics for a window covering service as it is defined in HAP spec.
     * `server` package consists classes to run HomeKit server and handle communication
 * the process is following: client, e.g. openHAB bindings, extends accessory classes, e.g. `WindowCoveringAccessory` and implements all required methods. WindowCoveringAccessory is linked already to WindowCoveringService, that in turn is link to single characteristics. 
+* linked service support
 
 # HAP-Java 1.1.5
 

Diff for: src/main/java/io/github/hapjava/server/impl/HomekitRegistry.java

@@ -4,7 +4,12 @@
 import io.github.hapjava.characteristics.Characteristic;
 import io.github.hapjava.services.Service;
 import io.github.hapjava.services.impl.AccessoryInformationService;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -15,7 +20,7 @@ public class HomekitRegistry {
 
   private final String label;
   private final Map<Integer, HomekitAccessory> accessories;
-  private final Map<HomekitAccessory, List<Service>> services = new HashMap<>();
+  private final Map<HomekitAccessory, Map<Integer, Service>> services = new HashMap<>();
   private final Map<HomekitAccessory, Map<Integer, Characteristic>> characteristics =
       new HashMap<>();
   private boolean isAllowUnauthenticatedRequests = false;
@@ -35,21 +40,26 @@ public synchronized void reset() {
       try {
         newServices = new ArrayList<>(2);
         newServices.add(new AccessoryInformationService(accessory));
-        newServices.addAll(accessory.getServices());
+        for (Service service : accessory.getServices()) {
+          newServices.add(service);
+          newServices.addAll(service.getLinkedServices());
+        }
       } catch (Exception e) {
         logger.warn("Could not instantiate services for accessory " + accessory.getName(), e);
-        services.put(accessory, Collections.emptyList());
+        services.put(accessory, Collections.emptyMap());
         continue;
       }
-      Map<Integer, Characteristic> newCharacteristics = new HashMap<>();
-      services.put(accessory, newServices);
+
+      Map<Integer, Characteristic> newCharacteristicsByInterfaceId = new HashMap<>();
+      Map<Integer, Service> newServicesByInterfaceId = new HashMap<>();
       for (Service service : newServices) {
-        iid++;
+        newServicesByInterfaceId.put(++iid, service);
         for (Characteristic characteristic : service.getCharacteristics()) {
-          newCharacteristics.put(++iid, characteristic);
+          newCharacteristicsByInterfaceId.put(++iid, characteristic);
         }
       }
-      characteristics.put(accessory, newCharacteristics);
+      services.put(accessory, newServicesByInterfaceId);
+      characteristics.put(accessory, newCharacteristicsByInterfaceId);
     }
   }
 
@@ -61,8 +71,8 @@ public Collection<HomekitAccessory> getAccessories() {
     return accessories.values();
   }
 
-  public List<Service> getServices(Integer aid) {
-    return Collections.unmodifiableList(services.get(accessories.get(aid)));
+  public Map<Integer, Service> getServices(Integer aid) {
+    return Collections.unmodifiableMap(services.get(accessories.get(aid)));
   }
 
   public Map<Integer, Characteristic> getCharacteristics(Integer aid) {

Diff for: src/main/java/io/github/hapjava/server/impl/json/AccessoryController.java

@@ -13,6 +13,7 @@
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.concurrent.CompletableFuture;
+import java.util.stream.Collectors;
 import javax.json.Json;
 import javax.json.JsonArrayBuilder;
 import javax.json.JsonObject;
@@ -31,12 +32,18 @@ public HttpResponse listing() throws Exception {
 
     Map<Integer, List<CompletableFuture<JsonObject>>> accessoryServiceFutures = new HashMap<>();
     for (HomekitAccessory accessory : registry.getAccessories()) {
-      int iid = 0;
       List<CompletableFuture<JsonObject>> serviceFutures = new ArrayList<>();
-      for (Service service : registry.getServices(accessory.getId())) {
-        serviceFutures.add(toJson(service, iid));
-        iid += service.getCharacteristics().size() + 1;
+
+      Map<Integer, Service> servicesByInterfaceId = registry.getServices(accessory.getId());
+
+      Map<Object, Integer> iidLookup = new HashMap<>();
+      iidLookup.putAll(swapKeyAndValue(servicesByInterfaceId));
+      iidLookup.putAll(swapKeyAndValue(registry.getCharacteristics(accessory.getId())));
+
+      for (Service service : servicesByInterfaceId.values()) {
+        serviceFutures.add(toJson(service, iidLookup));
       }
+
       accessoryServiceFutures.put(accessory.getId(), serviceFutures);
     }
 
@@ -64,16 +71,18 @@ public HttpResponse listing() throws Exception {
     }
   }
 
-  private CompletableFuture<JsonObject> toJson(Service service, int interfaceId) throws Exception {
+  private CompletableFuture<JsonObject> toJson(Service service, Map<Object, Integer> iidLookup)
+      throws Exception {
     String shortType =
         service.getType().replaceAll("^0*([0-9a-fA-F]+)-0000-1000-8000-0026BB765291$", "$1");
     JsonObjectBuilder builder =
-        Json.createObjectBuilder().add("iid", ++interfaceId).add("type", shortType);
+        Json.createObjectBuilder().add("iid", iidLookup.get(service)).add("type", shortType);
     List<Characteristic> characteristics = service.getCharacteristics();
     Collection<CompletableFuture<JsonObject>> characteristicFutures =
         new ArrayList<>(characteristics.size());
     for (Characteristic characteristic : characteristics) {
-      characteristicFutures.add(characteristic.toJson(++interfaceId));
+      Integer iid = iidLookup.get(characteristic);
+      characteristicFutures.add(characteristic.toJson(iid));
     }
 
     return CompletableFuture.allOf(
@@ -85,7 +94,20 @@ private CompletableFuture<JsonObject> toJson(Service service, int interfaceId) t
                   .map(future -> future.join())
                   .forEach(c -> jsonCharacteristics.add(c));
               builder.add("characteristics", jsonCharacteristics);
+
+              if (!service.getLinkedServices().isEmpty()) {
+                JsonArrayBuilder jsonLinkedServices = Json.createArrayBuilder();
+                service.getLinkedServices().stream()
+                    .map(iidLookup::get)
+                    .forEach(jsonLinkedServices::add);
+                builder.add("linked", jsonLinkedServices);
+              }
+
               return builder.build();
             });
   }
+
+  private <K, V> Map<V, K> swapKeyAndValue(Map<K, V> map) {
+    return map.entrySet().stream().collect(Collectors.toMap(Entry::getValue, Entry::getKey));
+  }
 }

Diff for: src/main/java/io/github/hapjava/services/Service.java

@@ -29,4 +29,11 @@ public interface Service {
    *     ########-####-####-####-############.
    */
   String getType();
+
+  /**
+   * List of all the services to which the service links
+   *
+   * @return the list of linked services.
+   */
+  List<Service> getLinkedServices();
 }

Diff for: src/main/java/io/github/hapjava/services/impl/AbstractServiceImpl.java

@@ -12,6 +12,7 @@ abstract class AbstractServiceImpl implements Service {
   private final Logger logger = LoggerFactory.getLogger(this.getClass());
   private final String type;
   private final List<Characteristic> characteristics = new LinkedList<>();
+  private final List<Service> linkedServices = new LinkedList<>();
 
   /** @param type unique UUID of the service according to HAP specification. */
   public AbstractServiceImpl(String type) {
@@ -28,7 +29,16 @@ public String getType() {
     return type;
   }
 
+  @Override
+  public List<Service> getLinkedServices() {
+    return Collections.unmodifiableList(linkedServices);
+  }
+
   public void addCharacteristic(Characteristic characteristic) {
     this.characteristics.add(characteristic);
   }
+
+  public void addLinkedService(Service service) {
+    this.linkedServices.add(service);
+  }
 }