Merge pull request #566 from smartdevicelink/bugfix/missing-scm-tests

Bugfix/missing scm tests

Author: crokita

lib/js/src/manager/SystemCapabilityManager.js

@@ -39,6 +39,13 @@ import { WindowType } from '../rpc/enums/WindowType.js';
 import { WindowTypeCapabilities } from '../rpc/structs/WindowTypeCapabilities.js';
 import { DisplayCapability } from '../rpc/structs/DisplayCapability.js';
 import { DisplayCapabilities } from '../rpc/structs/DisplayCapabilities.js';
+import { TextField } from '../rpc/structs/TextField.js';
+import { ImageField } from '../rpc/structs/ImageField.js';
+import { SoftButtonCapabilities } from '../rpc/structs/SoftButtonCapabilities.js';
+import { ButtonCapabilities } from '../rpc/structs/ButtonCapabilities.js';
+import { DynamicUpdateCapabilities } from '../rpc/structs/DynamicUpdateCapabilities.js';
+import { KeyboardCapabilities } from '../rpc/structs/KeyboardCapabilities.js';
+import { ImageResolution } from '../rpc/structs/ImageResolution.js';
 import { ImageType } from '../rpc/enums/ImageType.js';
 import { MessageType } from '../rpc/enums/MessageType.js';
 import { DisplayType } from '../rpc/enums/DisplayType.js';
@@ -68,6 +75,8 @@ class SystemCapabilityManager extends _SubManagerBase {
         this._seatLocationCapability = null;
         this._displays = null;
         this._driverDistractionCapability = null;
+        this._systemCapabilitiesSubscriptionStatus = new Set(); // Set<SystemCapabilityType>
+        this._systemCapabilitiesSubscriptionStatus.add(SystemCapabilityType.DISPLAYS); // subscribe to displays by default
 
         // capabilities not in the spec
         this._hmiCapabilities = null;
@@ -196,6 +205,37 @@ class SystemCapabilityManager extends _SubManagerBase {
             if (currentWindowId === windowId) {
                 // Clone WindowCapability to prevent modification of stored WindowCapability in SystemCapabilityManager
                 const windowCapabilityCopy = new WindowCapability(JSON.parse(JSON.stringify(windowCapability.getParameters())));
+                if (windowCapability.getTextFields() !== null && windowCapability.getTextFields() !== undefined) {
+                    windowCapabilityCopy.setTextFields(windowCapability.getTextFields().map(textField => {
+                        return new TextField(JSON.parse(JSON.stringify(textField.getParameters())));
+                    }));
+                }
+                if (windowCapability.getImageFields() !== null && windowCapability.getImageFields() !== undefined) {
+                    windowCapabilityCopy.setImageFields(windowCapability.getImageFields().map(imageField => {
+                        return new ImageField(JSON.parse(JSON.stringify(imageField.getParameters())))
+                            .setImageResolution(new ImageResolution(JSON.parse(JSON.stringify(imageField.getImageResolution().getParameters()))));
+                    }));
+                }
+                if (windowCapability.getSoftButtonCapabilities() !== null && windowCapability.getSoftButtonCapabilities() !== undefined) {
+                    windowCapabilityCopy.setSoftButtonCapabilities(windowCapability.getSoftButtonCapabilities().map(capability => {
+                        return new SoftButtonCapabilities(JSON.parse(JSON.stringify(capability.getParameters())));
+                    }));
+                }
+                if (windowCapability.getButtonCapabilities() !== null && windowCapability.getButtonCapabilities() !== undefined) {
+                    windowCapabilityCopy.setButtonCapabilities(windowCapability.getButtonCapabilities().map(capability => {
+                        return new ButtonCapabilities(JSON.parse(JSON.stringify(capability.getParameters())));
+                    }));
+                }
+                if (windowCapability.getDynamicUpdateCapabilities() !== null && windowCapability.getDynamicUpdateCapabilities() !== undefined) {
+                    windowCapabilityCopy.setDynamicUpdateCapabilities(new DynamicUpdateCapabilities(
+                        JSON.parse(JSON.stringify(windowCapability.getDynamicUpdateCapabilities().getParameters()))
+                    ));
+                }
+                if (windowCapability.getKeyboardCapabilities() !== null && windowCapability.getKeyboardCapabilities() !== undefined) {
+                    windowCapabilityCopy.setKeyboardCapabilities(new KeyboardCapabilities(
+                        JSON.parse(JSON.stringify(windowCapability.getKeyboardCapabilities().getParameters()))
+                    ));
+                }
                 // A null windowID is assumed to be the DefaultWindow according to the spec, but that can be hard for developers to check, so set it explicitly.
                 windowCapabilityCopy.setWindowID(windowId);
                 return windowCapabilityCopy;
@@ -258,6 +298,15 @@ class SystemCapabilityManager extends _SubManagerBase {
             return [displayCapability];
         }
 
+        // Ford Sync bug returning incorrect template name for "NON-MEDIA" https://github.com/smartdevicelink/sdl_javascript_suite/issues/450
+        const templatesAvailable = displayCapabilities.getTemplatesAvailable() !== null ? displayCapabilities.getTemplatesAvailable() : [];
+        for (let index = 0; index < templatesAvailable.length; index++) {
+            if (templatesAvailable[index] === 'NON_MEDIA') {
+                templatesAvailable[index] = 'NON-MEDIA';
+                break;
+            }
+        }
+
         // copy all available display capabilities
         defaultWindowCapability.setTemplatesAvailable(displayCapabilities.getTemplatesAvailable())
             .setNumCustomPresetsAvailable(displayCapabilities.getNumCustomPresetsAvailable())
@@ -498,15 +547,66 @@ class SystemCapabilityManager extends _SubManagerBase {
      * @returns {Promise} - Promise returning either the capability Object or null if not found
      */
     async updateCapability (systemCapabilityType) {
+        return await this._updateCapabilityPrivate(systemCapabilityType, null, true);
+    }
+
+    /**
+     * Checks if the supplied capability type is currently subscribed for or not
+     * @param {SystemCapabilityType} systemCapabilityType - type of capability desired
+     * @returns {Boolean} - true if subscribed and false if not
+     */
+    _isSubscribedToSystemCapability (systemCapabilityType) {
+        return this._systemCapabilitiesSubscriptionStatus.has(systemCapabilityType);
+    }
+
+    /**
+     * Sends a request to core for the capability, instead of checking cached capabilities
+     * @param {SystemCapabilityType} systemCapabilityType - A SystemCapabilityType enum value.
+     * @param {Boolean} subscribe - Whether to attempt to subscribe to a capability. Null means no change to the subscription status. Defaults to null
+     * @param {Boolean} forceUpdate - Whether to force a query to the head unit to retrieve a capability anyway
+     * @param {Function} listener - A newly subscribed listener that may want to receive the updated capability object. Defaults to null
+     * @returns {Promise} - Promise returning either the capability Object or null if not found
+     */
+    async _updateCapabilityPrivate (systemCapabilityType, subscribe = null, forceUpdate, listener = null) {
+        const cachedCapability = this.getCapability(systemCapabilityType);
+
+        // NOTE: subscription has always been supported within the lifespan of this library (5.2.0+)
+        const shouldForceUpdate = forceUpdate && !this._isSubscribedToSystemCapability(systemCapabilityType);
+        const shouldUpdateSystemCapabilitySubscription = (subscribe !== null) && (subscribe !== this._isSubscribedToSystemCapability(systemCapabilityType));
+        const shouldSendGetCapabilityRequest = shouldForceUpdate || (cachedCapability === null) || shouldUpdateSystemCapabilitySubscription;
+        const shouldCallListenerWithCachedValue = (cachedCapability !== null) && (listener !== null) && !shouldSendGetCapabilityRequest;
+
+        if (shouldCallListenerWithCachedValue) {
+            listener(cachedCapability);
+        }
+
+        if (!shouldSendGetCapabilityRequest) {
+            return cachedCapability;
+        }
+
+        // non-cached capability get
+
         // don't bother getting a capability if it isn't queryable
         const getCapabilityMethodName = this._getCapabilityMethodForType(systemCapabilityType);
         if (getCapabilityMethodName === null) {
             console.error(`The systemCapabilityType ${systemCapabilityType} cannot be queried for`);
             return null;
         }
 
+        /*
+            The subscription flag in the request should be set based on multiple variables:
+            - if subscribe is null (no change), willSubscribe = current subscription status, or false if the HU does not support subscriptions
+            - if subscribe is false, then willSubscribe = false
+            - if subscribe is true and the HU supports subscriptions, then willSubscribe = true
+            NOTE: subscription has always been supported within the lifespan of this library (5.2.0+)
+        */
+        const shouldSubscribe = (subscribe !== null) ? subscribe : this._isSubscribedToSystemCapability(systemCapabilityType);
+
         const request = new GetSystemCapability()
             .setSystemCapabilityType(systemCapabilityType);
+        if (subscribe !== null) {
+            request.setSubscribe(shouldSubscribe);
+        }
 
         if (this._lifecycleManager === null) {
             return null;
@@ -526,11 +626,18 @@ class SystemCapabilityManager extends _SubManagerBase {
             return null;
         }
 
+        // RPC get succeeded
+        if (shouldSubscribe) {
+            this._systemCapabilitiesSubscriptionStatus.add(systemCapabilityType);
+        } else {
+            this._systemCapabilitiesSubscriptionStatus.delete(systemCapabilityType);
+        }
+
         // invoke the correct get capability method
         const retrievedCapability = response.getSystemCapability()[getCapabilityMethodName]();
         this._setCapability(systemCapabilityType, retrievedCapability);
         // get the capability back through this method, because it may have changed the output
-        return this.getCapability(systemCapabilityType, retrievedCapability);
+        return this.getCapability(systemCapabilityType);
     }
 
     /**
@@ -547,7 +654,7 @@ class SystemCapabilityManager extends _SubManagerBase {
             this._onSystemCapabilityListeners[systemCapabilityType] = [];
         }
         this._onSystemCapabilityListeners[systemCapabilityType].push(listener);
-        this.updateCapability(systemCapabilityType); // send out a query, since the caller wants an update for this capability
+        this._updateCapabilityPrivate(systemCapabilityType, true, false, listener); // send out a query, since the caller wants an update for this capability
     }
 
     /**
@@ -573,6 +680,11 @@ class SystemCapabilityManager extends _SubManagerBase {
             }
             return listener !== listenerCheck;
         });
+        // If the last listener for the supplied capability type is removed, unsubscribe from the capability type
+        // always stay subscribied to DISPLAYS
+        if (removed && this._onSystemCapabilityListeners[systemCapabilityType].length === 0 && this._isSubscribedToSystemCapability(systemCapabilityType) && systemCapabilityType !== SystemCapabilityType.DISPLAYS) {
+            this._updateCapabilityPrivate(systemCapabilityType, false, false);
+        }
         return removed;
     }
 
@@ -618,7 +730,18 @@ class SystemCapabilityManager extends _SubManagerBase {
                                 if (this.getCapability(systemCapabilityType) !== null) { // The capability already exists
                                     switch (systemCapabilityType) {
                                         case SystemCapabilityType.APP_SERVICES: {
-                                            // setCapability handles updating the local app service state
+                                            // App services only updates what was changed so we need
+                                            // to update the capability rather than override it
+                                            const appServicesCapabilities = capability;
+                                            if (capability !== null) {
+                                                const appServicesCapabilitiesList = appServicesCapabilities.getAppServices();
+                                                const cachedAppServicesCapabilities = this._appServicesCapabilities;
+                                                // Update the cached app services
+                                                if (cachedAppServicesCapabilities !== null) {
+                                                    capability.setAppServices(this._updateAppServices(cachedAppServicesCapabilities, appServicesCapabilitiesList));
+                                                }
+                                                // Set the new capability object to the updated cached capabilities
+                                            }
                                             break;
                                         }
                                         case SystemCapabilityType.DISPLAYS: {
@@ -739,15 +862,7 @@ class SystemCapabilityManager extends _SubManagerBase {
             convertedCapabilities.setImageFields(defaultMainWindow.getImageFields());
         }
 
-        // Ford Sync bug returning incorrect template name for "NON-MEDIA" https://github.com/smartdevicelink/sdl_javascript_suite/issues/450
-        const templatesAvailable = defaultMainWindow.getTemplatesAvailable() !== null ? defaultMainWindow.getTemplatesAvailable() : [];
-        for (let index = 0; index < templatesAvailable.length; index++) {
-            if (templatesAvailable[index] === 'NON_MEDIA') {
-                templatesAvailable[index] = 'NON-MEDIA';
-                break;
-            }
-        }
-        convertedCapabilities.setTemplatesAvailable(templatesAvailable);
+        convertedCapabilities.setTemplatesAvailable(defaultMainWindow.getTemplatesAvailable());
         convertedCapabilities.setNumCustomPresetsAvailable(defaultMainWindow.getNumCustomPresetsAvailable());
         convertedCapabilities.setMediaClockFormats([]); // mandatory field but allows empty array
         // if there are imageTypes in the response, we must assume graphics are supported
@@ -767,6 +882,79 @@ class SystemCapabilityManager extends _SubManagerBase {
 
         return convertedCapabilities;
     }
+
+    /**
+     * This method will update the current List<AppServiceCapability> with the updated items. If the
+     * items don't exist in the original ist they will be added. If the original list is null or
+     * empty, the new list will simply be set as the list.
+     *
+     * @param {AppServicesCapabilities} appServicesCapabilities - the AppServicesCapabilities instance
+     * @param {AppServiceCapability[]} updatedAppServiceCapabilities - the array that have been updated
+     * @returns {AppServiceCapability[]} the array of capabilities with old duplicate services removed
+     */
+    _updateAppServices (appServicesCapabilities, updatedAppServiceCapabilities) {
+        if (updatedAppServiceCapabilities === null) {
+            return false;
+        }
+
+        let appServiceCapabilities = appServicesCapabilities;
+
+        if (appServiceCapabilities === null) {
+            // If there are currently no app services, create one to iterate over with no entries
+            appServiceCapabilities = new Map();
+        }
+
+        // Create a shallow copy for us to alter while iterating through the original list
+        const tempList = new Map(appServiceCapabilities);
+
+        for (const updatedAppServiceCapability of updatedAppServiceCapabilities) {
+            if (updatedAppServiceCapability !== null) {
+                // First search if the record exists in the current list and remove it if so
+                for (const appServiceCapability of appServiceCapabilities.values()) {
+                    if (this._matchesAppService(updatedAppServiceCapability, appServiceCapability)) {
+                        tempList.delete(appServiceCapability.getUpdatedAppServiceRecord().getServiceID()); // Remove the old entry
+                        break;
+                    }
+                }
+
+                // Add the app service regardless of whether it was removed or not, the setCapability method will handle removals
+                tempList.set(updatedAppServiceCapability.getUpdatedAppServiceRecord().getServiceID(), updatedAppServiceCapability);
+            }
+        }
+
+        return Array.from(tempList.values());
+    }
+
+    /**
+     * Helper method to compare AppServiceCapability instances
+     * @param {AppServiceCapability} capability - an AppServiceCapability
+     * @param {AppServiceCapability} capability2 - the AppServiceCapability to compare to the first
+     * @returns {Boolean} if both AppServiceCapability objects refer to the same service
+     */
+    _matchesAppService (capability = null, capability2 = null) {
+        if (capability !== null && capability2 !== null) {
+            const appServiceRecord = capability.getUpdatedAppServiceRecord();
+            const otherASR = capability2.getUpdatedAppServiceRecord();
+
+            if (appServiceRecord !== null && otherASR !== null) {
+                // If both service IDs exists we can compare them. If either is null we can't use
+                // only this check.
+                if (appServiceRecord.getServiceID() !== null && otherASR.getServiceID() !== null) {
+                    // return whether the app service IDs are equal or not
+                    return appServiceRecord.getServiceID().toLowerCase() === otherASR.getServiceID().toLowerCase();
+                } else {
+                    const manifest = appServiceRecord.getServiceManifest();
+                    const otherManifest = otherASR.getServiceManifest();
+                    if (manifest !== null && otherManifest !== null) {
+                        // Check the service names, if they are the same it can be assumed they are the same service
+                        return (manifest.getServiceName() !== null && otherManifest.getServiceName() !== null
+                            && manifest.getServiceName().toLowerCase() === otherManifest.getServiceName().toLowerCase());
+                    }
+                }
+            }
+        }
+        return false;
+    }
 }
 
 export { SystemCapabilityManager };