Feature/choice set manager (#371)

* Implementing SDL 0274: Add preferred FPS to VideoStreamingCapability.

* Added preferredFPS to ideoStreamingParametersTest.

* Set up foundational APIs and classes

* Finish main implementation of choice set manager

* Fix linter issues

* Fix reference issues

* Add unit tests and update files based on test results

* Fix more bugs found during testing

* Update rpc_spec, .gitmodules, some JSs in accordance with code review at #357.

* Apply suggestions from code review

Co-authored-by: renonick87 <[email protected]>

* Apply feedback from review

* Resolve merge conflicts

* Revert "Merge branch 'feature/issue-115' of https://github.com/shiniwat/sdl_javascript_suite into feature/choice-set-manager"

This reverts commit 4c2ee61, reversing
changes made to e692b28.

* Finish review revisions

* Fix test failures

Co-authored-by: Shinichi Watanabe <[email protected]>
Co-authored-by: renonick87 <[email protected]>

Author: 3 people

lib/js/src/manager/_SubManagerBase.js

@@ -35,6 +35,7 @@ import { _Task } from './_Task.js';
 import { FunctionID } from '../rpc/enums/FunctionID.js';
 import { PredefinedWindows } from '../rpc/enums/PredefinedWindows.js';
 import { SystemCapabilityType } from '../rpc/enums/SystemCapabilityType.js';
+import { SystemContext } from '../rpc/enums/SystemContext.js';
 
 /**
  * _SubManagerBase handles the basic state transitions from
@@ -58,6 +59,7 @@ class _SubManagerBase {
         this._canRunTasks = false; // whether the task queue can run
         this._isTaskRunning = false; // whether tasks are running
         this._taskQueue = [];
+        this._currentSystemContext = SystemContext.SYSCTXT_MAIN;
         this._transitionToState(SETTING_UP);
     }
 
@@ -94,6 +96,7 @@ class _SubManagerBase {
 
         if (this._isHandlingTasks) {
             this._currentHmiLevel = HMILevel.HMI_NONE;
+            this._currentSystemContext = null;
             this._taskQueue.splice(0, this._taskQueue.length);
             this._canRunTasks = false;
             if (typeof this._hmiListener === 'function') {
@@ -102,6 +105,7 @@ class _SubManagerBase {
             this._isHandlingTasks = false;
         }
 
+
         this._transitionToState(SHUTDOWN);
     }
 
@@ -185,8 +189,9 @@ class _SubManagerBase {
      * Sets up a listener to the OnHMIStatus and manages the task queue
      * Uses the HMI level state to determine whether the task queue should be run
      * @private
+     * @param {Boolean} readSystemContext - Whether to use OnHMIStatus's system context value to pause and resume the task queue
      */
-    _handleTaskQueue () {
+    _handleTaskQueue (readSystemContext = false) {
         this._isHandlingTasks = true;
         this._hmiListener = (onHmiStatus) => {
             if (onHmiStatus.getWindowID() !== null && onHmiStatus.getWindowID() !== PredefinedWindows.DEFAULT_WINDOW) {
@@ -203,6 +208,17 @@ class _SubManagerBase {
             if (oldHmiLevel !== HMILevel.HMI_NONE && this._currentHmiLevel === HMILevel.HMI_NONE) {
                 this._canRunTasks = false;
             }
+
+            // used when we want to read system context to determine the queue status
+            if (readSystemContext) {
+                this._currentSystemContext = onHmiStatus.getSystemContext();
+                if (this._currentSystemContext === SystemContext.SYSCTXT_HMI_OBSCURED || this._currentSystemContext === SystemContext.SYSCTXT_ALERT) {
+                    this._canRunTasks = false;
+                }
+                if (this._currentSystemContext === SystemContext.SYSCTXT_MAIN && this._currentHmiLevel !== HMILevel.HMI_NONE) {
+                    this._canRunTasks = true;
+                }
+            }
         };
 
         this._lifecycleManager.addRpcListener(FunctionID.OnHMIStatus, this._hmiListener);
@@ -257,6 +273,7 @@ class _SubManagerBase {
     /**
      * Execute the task queue if there are tasks and if tasks can be run. Will recurse until all tasks are completed
      * @private
+     * @returns {Promise} - No value returned from the promise
      */
     async _invokeTaskQueue () {
         if (!this._isHandlingTasks) {

lib/js/src/manager/file/filetypes/SdlFile.js

@@ -177,6 +177,44 @@ class SdlFile {
     getOverwrite () {
         return this._overwrite;
     }
+
+    /**
+     * Checks whether two SdlFiles can be considered equivalent
+     * @param {SdlFile} other - The object to compare
+     * @returns {Boolean} - Whether the objects are the same or not
+     */
+    equals (other) {
+        if (other === null || other === undefined) {
+            return false;
+        }
+        if (this === other) {
+            return true;
+        }
+        if (!(other instanceof SdlFile)) {
+            return false;
+        }
+
+        // main comparison check
+        if (this.getName() !== other.getName()) {
+            return false;
+        }
+        if (this.getFilePath() !== other.getFilePath()) {
+            return false;
+        }
+        if (this.getFileData() !== other.getFileData()) {
+            return false;
+        }
+        if (this.getType() !== other.getType()) {
+            return false;
+        }
+        if (this.isPersistent() !== other.isPersistent()) {
+            return false;
+        }
+        if (this.isStaticIcon() !== other.isStaticIcon()) {
+            return false;
+        }
+        return true;
+    }
 }
 
 

lib/js/src/manager/screen/_ScreenManagerBase.js

@@ -35,6 +35,7 @@ import { _SoftButtonManager } from './_SoftButtonManager.js';
 import { _TextAndGraphicManager } from './_TextAndGraphicManager.js';
 import { _VoiceCommandManager } from './_VoiceCommandManager.js';
 import { _SubscribeButtonManager } from './_SubscribeButtonManager';
+import { _ChoiceSetManagerBase } from './choiceset/_ChoiceSetManagerBase';
 
 class _ScreenManagerBase extends _SubManagerBase {
     /**
@@ -51,6 +52,7 @@ class _ScreenManagerBase extends _SubManagerBase {
         if (this._fileManager !== null) {
             this._softButtonManager = new _SoftButtonManager(lifecycleManager, this._fileManager);
             this._textAndGraphicManager = new _TextAndGraphicManager(lifecycleManager, this._fileManager, this._softButtonManager);
+            this._choiceSetManagerBase = new _ChoiceSetManagerBase(lifecycleManager, this._fileManager);
         }
         this._voiceCommandManager = new _VoiceCommandManager(lifecycleManager);
         this._subscribeButtonManager = new _SubscribeButtonManager(lifecycleManager);
@@ -66,6 +68,7 @@ class _ScreenManagerBase extends _SubManagerBase {
             this._textAndGraphicManager.start(),
             this._voiceCommandManager.start(),
             this._subscribeButtonManager.start(),
+            this._choiceSetManagerBase.start(),
         ]);
         this._transitionToState(_SubManagerBase.READY);
         await super.start();
@@ -79,6 +82,7 @@ class _ScreenManagerBase extends _SubManagerBase {
         this._textAndGraphicManager.dispose();
         this._voiceCommandManager.dispose();
         this._subscribeButtonManager.dispose();
+        this._choiceSetManagerBase.dispose();
         super.dispose();
     }
 
@@ -442,6 +446,78 @@ class _ScreenManagerBase extends _SubManagerBase {
         return this._voiceCommandManager.setVoiceCommands(voiceCommands);
     }
 
+    /**
+     * Deletes choices that were sent previously
+     * @param {ChoiceCell[]} choices - A list of ChoiceCell objects
+     * @returns {Promise} - A promise that resolves to a Boolean of whether the operation is a success
+     */
+    async deleteChoices (choices) {
+        return this._choiceSetManagerBase.deleteChoices(choices);
+    }
+
+    /**
+     * Preload choices to improve performance while presenting a choice set at a later time
+     * @param {ChoiceCell[]} choices  - a list of ChoiceCell objects that will be part of a choice set later
+     * @returns {Promise} - A promise.
+     */
+    async preloadChoices (choices) {
+        return this._choiceSetManagerBase.preloadChoices(choices);
+    }
+
+    /**
+     * Presents a searchable choice set
+     * @param {ChoiceSet} choiceSet - The choice set to be presented. This can include Choice Cells that were preloaded or not
+     * @param {InteractionMode} mode - The intended interaction mode
+     * @param {KeyboardListener} keyboardListener - A keyboard listener to capture user input
+     */
+    presentSearchableChoiceSet (choiceSet, mode, keyboardListener) {
+        this._choiceSetManagerBase.presentChoiceSet(choiceSet, mode, keyboardListener);
+    }
+
+    /**
+     * Presents a choice set
+     * @param {ChoiceSet} choiceSet - The choice set to be presented. This can include Choice Cells that were preloaded or not
+     * @param {InteractionMode} mode - The intended interaction mode
+     */
+    presentChoiceSet (choiceSet, mode) {
+        this._choiceSetManagerBase.presentChoiceSet(choiceSet, mode, null);
+    }
+
+    /**
+     * Presents a keyboard on the Head unit to capture user input
+     * @param {String} initialText - The initial text that is used as a placeholder text. It might not work on some head units.
+     * @param {KeyboardProperties} customKeyboardProperties - the custom keyboard configuration to be used when the keyboard is displayed
+     * @param {KeyboardListener} keyboardListener - A keyboard listener to capture user input
+     * @returns {Number|null} - A unique cancel ID that can be used to cancel this keyboard. If `null`, no keyboard was created.
+     */
+    presentKeyboard (initialText, customKeyboardProperties, keyboardListener) {
+        return this._choiceSetManagerBase.presentKeyboard(initialText, customKeyboardProperties, keyboardListener);
+    }
+
+    /**
+     * Set a custom keyboard configuration for this session. If set to null, it will reset to default keyboard configuration.
+     * @param {KeyboardProperties} keyboardConfiguration - the custom keyboard configuration to be used when the keyboard is displayed
+     */
+    setKeyboardConfiguration (keyboardConfiguration) {
+        this._choiceSetManagerBase.setKeyboardConfiguration(keyboardConfiguration);
+    }
+
+    /**
+     * Get the preloaded choices
+     * @returns {ChoiceCell[]} - A set of choice cells that have been preloaded to the head unit
+     */
+    getPreloadedChoices () {
+        return this._choiceSetManagerBase.getPreloadedChoices();
+    }
+
+    /**
+     * Dismisses a currently presented keyboard with the associated ID. Canceling a keyboard only works when connected to SDL Core v.6.0+. When connected to older versions of SDL Core the keyboard will not be dismissed.
+     * @param {Number} cancelId - The unique ID assigned to the keyboard
+     */
+    dismissKeyboard (cancelId) {
+        this._choiceSetManagerBase.dismissKeyboard(cancelId);
+    }
+
     /**
      * Begin a multiple updates transaction. The updates will be applied when commit() is called. Note: if we don't use beginTransaction & commit, every update will be sent individually.
      */