UIRPC.js

/*
 * Copyright (c) 2013, Ford Motor Company All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met: ·
 * Redistributions of source code must retain the above copyright notice, this
 * list of conditions and the following disclaimer. · Redistributions in binary
 * form must reproduce the above copyright notice, this list of conditions and
 * the following disclaimer in the documentation and/or other materials provided
 * with the distribution. · Neither the name of the Ford Motor Company nor the
 * names of its contributors may be used to endorse or promote products derived
 * from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
/*
 * Reference implementation of UI component.
 *
 * Interface to get or set some essential information sent from SDLCore. UI is
 * responsible for the functionality provided by the application: display
 * graphics and multimedia components, is responsible for the transfer of
 * managed manipulations, generated by the user to the server.
 *
 */

const MS_IN_SEC = 1000;

FFW.UI = FFW.RPCObserver.create(
  {
    /**
     * If true then UI is present and ready to communicate with SDL.
     *
     * @type {Boolean}
     */
    isReady: true,
    /**
     * Contains response codes for request that should be processed but there
     * were some kind of errors Error codes will be injected into response.
     */
    errorResponsePull: {},
    /**
     * access to basic RPC functionality
     */
    client: FFW.RPCClient,
    // temp var for debug
    appID: 1,
    onRecordStartSubscribeRequestID: -1,
    onRecordStartUnsubscribeRequestID: -1,
    // const
    onRecordStartNotification: 'UI.OnRecordStart',
    /**
     * ids for requests AudioPassThru
     */
    performAudioPassThruRequestID: -1,
    endAudioPassThruRequestID: -1,
    componentName: "UI",
    /**
     * connect to RPC bus
     */
    connect: function() {
      this.client.connect(this.componentName, this);
    },

    /**
     * @function sendMessage
     * @param {Em.Object} JSONMessage
     * @desc sending message to SDL
     */

    sendMessage: function(JSONMessage){
      this.client.send(JSONMessage, this.componentName);
    },
    /**
     * @function subscribeToNotification
     * @param {Em.Object} notification
     * @desc subscribe to notifications from SDL
     */

    subscribeToNotification: function(notification){
      this.client.subscribeToNotification(notification, this.componentName);
    },

    /**
     * disconnect from RPC bus
     */
    disconnect: function() {
      this.onRPCUnregistered();
      this.client.disconnect();
    },

    /**
     * Client is registered - we can send request starting from this point
     * of time
     */
    onRPCRegistered: function() {
      Em.Logger.log('FFW.UI.onRPCRegistered');
      this._super();
      // subscribe to notifications
      this.onRecordStartSubscribeRequestID =
        this.subscribeToNotification(this.onRecordStartNotification);
    },
    /**
     * Client is unregistered - no more requests
     */
    onRPCUnregistered: function() {
      Em.Logger.log('FFW.UI.onRPCUnregistered');
      this._super();
      // unsubscribe from notifications
      this.onRecordStartUnsubscribeRequestID =
        this.client.unsubscribeFromNotification(
          this.onRecordStartNotification
        );
    },
    /**
     * Client disconnected.
     */
    onRPCDisconnected: function() {
    },
    /**
     * when result is received from RPC component this function is called It
     * is the propriate place to check results of request execution Please
     * use previously store reuqestID to determine to which request repsonse
     * belongs to
     */
    onRPCResult: function(response) {
      Em.Logger.log('FFW.UI.onRPCResult');
      this._super();
    },
    /**
     * handle RPC erros here
     */
    onRPCError: function(error) {
      Em.Logger.log('FFW.UI.onRPCError');
      this._super();
    },
    /**
     * handle RPC notifications here
     */
    onRPCNotification: function(notification) {
      Em.Logger.log('FFW.UI.onRPCNotification');
      this._super();
      if (notification.method == this.onRecordStartNotification) {
        SDL.AudioPassThruPopUp.StartAudioPassThruTimer();
      }
    },
    /**
     * handle RPC requests here
     */
    onRPCRequest: function(request) {
      Em.Logger.log('FFW.UI.onRPCRequest');
      if (this.validationCheck(request)) {
        switch (request.method) {
          case 'UI.ShowAppMenu':
          {
            SDL.SDLModel.showAppMenu(request);
            break;
          }
          case 'UI.Alert':
          {
            if(SDL.SDLModel.onUIAlert(request)) {
              SDL.SDLController.onSystemContextChange(request.params.appID);
            }

            SDL.SDLModel.data.registeredApps.forEach(app => {
              app.activeWindows.forEach(widget => {
                SDL.SDLController.onSystemContextChange(app.appID, widget.windowID);
              })
            })
            break;
          }
          case 'UI.SubtleAlert':
          {
            if(SDL.SDLModel.onUISubtleAlert(request)) {
              SDL.SDLController.onSystemContextChange(request.params.appID);
            }

            SDL.SDLModel.data.registeredApps.forEach(app => {
              app.activeWindows.forEach(widget => {
                SDL.SDLController.onSystemContextChange(app.appID, widget.windowID);
              })
            })
            break;
          }
          case 'UI.Show':
          {
            SDL.TurnByTurnView.deactivate();
            let appModel = SDL.SDLController.getApplicationModel(request.params.appID);
            const isWindowIDExist = "windowID" in request.params; 
            const isWidgetID = isWindowIDExist && parseInt(request.params.windowID) != 0;
            const windowID = isWindowIDExist ? parseInt(request.params.windowID) : 0;
            let model = isWidgetID ? appModel.getWidgetModel(windowID).content : appModel;
            let sendCapabilityUpdated = false;
            if("templateConfiguration" in request.params) {
              if (model.templateConfiguration.template !== request.params.templateConfiguration.template) {
                if (!SDL.SDLModel.isTemplateSupported(model, request.params.templateConfiguration.template)) {
                  this.sendError(
                    SDL.SDLModel.data.resultCode['REJECTED'], request.id,
                    request.method, 'The requested layout is not supported for this app type'
                  );
                  return;
                }

                model.templateConfiguration.template = request.params.templateConfiguration.template;

                if (model.active) {
                  SDL.SDLModel.data.templateChangeInProgress = true;
                  SDL.States.goToStates('info.apps');
                  model.turnOnSDL();
                  SDL.SDLModel.data.templateChangeInProgress = false;
                }

                sendCapabilityUpdated = true;
              }
              if ("dayColorScheme" in  request.params.templateConfiguration
              && !SDL.SDLController.isColorSchemesEqual(
                model.templateConfiguration.dayColorScheme,
                request.params.templateConfiguration.dayColorScheme)) {
                  sendCapabilityUpdated = true;
              }
              if ("nightColorScheme" in request.params.templateConfiguration
              && !SDL.SDLController.isColorSchemesEqual(
                model.templateConfiguration.nightColorScheme,
                request.params.templateConfiguration.nightColorScheme)) {
                  sendCapabilityUpdated = true;
              }
            }
            if(appModel.onSDLUIShow(request.params) === SDL.SDLModel.data.resultCode.REJECTED) {
              this.sendError(SDL.SDLModel.data.resultCode.REJECTED, request.id, request.method,
                    "Widget is duplicating other window. Rejecting UI.Show request.");
              return;
            }
            SDL.InfoAppsView.showAppList();

            imageList = [];
            if(request.params.graphic) {
              imageList.push(request.params.graphic);
            }
            if(request.params.secondaryGraphic) {
              imageList.push(request.params.secondaryGraphic);
            }
            if(request.params.softButtons) {
              for(var i = 0; i < request.params.softButtons.length; i++) {
                var image = request.params.softButtons[i].image;
                if(image) {
                  imageList.push(image);
                }
              }
            }

            var callback = function(failed, info) {
              var WARNINGS = SDL.SDLModel.data.resultCode.WARNINGS;
              var SUCCESS = SDL.SDLModel.data.resultCode.SUCCESS;

              FFW.UI.sendUIResult(
                failed ? WARNINGS : SUCCESS, 
                request.id, 
                request.method, 
                info);
            }
            SDL.SDLModel.validateImages(request.id, callback, imageList);

            if (sendCapabilityUpdated) {
              let capability = SDL.SDLController.getDisplayCapability(request.params.appID, windowID);
              FFW.BasicCommunication.OnSystemCapabilityUpdated(capability);
            }
            break;
          }
          case 'UI.SetGlobalProperties':
          {
          resultCode = FFW.RPCHelper.getCustomResultCode(request.params.appID, 'uiSetGlobalProperties');
          if ('DO_NOT_RESPOND' == resultCode) {
            Em.Logger.log('Do not respond on this request');
            return;
          }

          let info = null;

          if (FFW.RPCHelper.isSuccessResultCode(resultCode)){
            const setResultCode = SDL.SDLModel.setProperties(request.params);

            if (setResultCode == SDL.SDLModel.data.resultCode.SUCCESS &&
                resultCode == SDL.SDLModel.data.resultCode.SUCCESS) {
                  var callback = function(failed, info) {
                    var WARNINGS = SDL.SDLModel.data.resultCode.WARNINGS;
                    var SUCCESS = SDL.SDLModel.data.resultCode.SUCCESS;

                    FFW.UI.sendUIResult(
                      failed ? WARNINGS : SUCCESS,
                      request.id,
                      request.method,
                      info);
                  }

                  var imageList = [];
                  if(request.params.menuIcon) {
                    imageList.push(request.params.menuIcon);
                  }

                  if(request.params.vrHelp) {
                    for(var i = 0; i < request.params.vrHelp.length; i++) {
                      if(request.params.vrHelp[i].image) {
                        imageList.push(request.params.vrHelp[i].image);
                      }
                    }
                  }

                  SDL.SDLModel.validateImages(request.id, callback, imageList);
            } else {
              FFW.UI.sendUIResult(
                resultCode != SDL.SDLModel.data.resultCode.SUCCESS ? resultCode : setResultCode,
                request.id,
                request.method,
                info);
            }

            break;
          } else {
            info = 'Erroneous response is assigned by settings';
          }

            this.sendUIResult(
              resultCode, request.id, request.method, info
            );
            break;
          }
          case 'UI.AddCommand':
          {
            SDL.SDLController.getApplicationModel(request.params.appID)
              .addCommand(request);
            break;
          }
          case 'UI.DeleteCommand':
          {
            SDL.SDLController.getApplicationModel(request.params.appID)
              .deleteCommand(request.params.cmdID, request.id);
            break;
          }
          case 'UI.AddSubMenu':
          {
            SDL.SDLController.getApplicationModel(request.params.appID)
              .addSubMenu(request);
            break;
          }
          case 'UI.DeleteSubMenu':
          {
            var resultCode = SDL.SDLController.getApplicationModel(
              request.params.appID
            ).deleteSubMenu(request.params.menuID);
            this.sendUIResult(resultCode, request.id, request.method);
            break;
          }
          case 'UI.PerformInteraction':
          {
            if (SDL.SDLModel.uiPerformInteraction(request)) {
              SDL.SDLController.onSystemContextChange();
              SDL.SDLModel.data.registeredApps.forEach(app => {
                app.activeWindows.forEach(widget => {
                  SDL.SDLController.onSystemContextChange(app.appID, widget.windowID);
                })
              })

              if (request.params && request.params.choiceSet == null) {
                SDL.ResetTimeoutPopUp.stopRpcProcessing('UI.PerformInteraction', false, false);
              }

            }
            break;
          }
          case 'UI.CancelInteraction':
          {
            var targetID = request.params.cancelID;
            var typeID = request.params.functionID;

            if (typeID === 10 && (SDL.InteractionChoicesView.active || SDL.Keyboard.active || SDL.VRPopUp.VRActive)
               && (targetID === undefined || targetID === SDL.InteractionChoicesView.cancelID)) {
              if (SDL.Keyboard.active) {
                SDL.Keyboard.deactivate();
                this.OnKeyboardInput('', 'ENTRY_ABORTED');
              }
              if (SDL.VRPopUp.VRActive) {
                SDL.ResetTimeoutPopUp.vrPerformInteractionDisableCheckBox()
                SDL.SDLController.vrInteractionResponse(SDL.SDLModel.data.resultCode.ABORTED);
              }
              SDL.InteractionChoicesView.deactivate('ABORTED');
            } else if (typeID === 12 && SDL.AlertPopUp.active
               && (targetID === undefined || targetID === SDL.AlertPopUp.cancelID)) {
              SDL.AlertPopUp.deactivate("ABORTED");
            } else if (typeID === 25 && SDL.ScrollableMessage.active
               && (targetID === undefined || targetID === SDL.ScrollableMessage.cancelID)) {
              SDL.ScrollableMessage.deactivate(true);
            } else if (typeID === 26 && SDL.SliderView.active
               && (targetID === undefined || targetID === SDL.SliderView.cancelID)) {
              SDL.SliderView.deactivate();
            } else if (typeID === 64 && SDL.SubtleAlertPopUp.active
              && (targetID === undefined || targetID === SDL.SubtleAlertPopUp.cancelID)) {
              SDL.SubtleAlertPopUp.deactivate();
            } else {
              this.sendError(SDL.SDLModel.data.resultCode.IGNORED,
                request.id, request.method,
                'Request is ignored, because the intended result is already in effect.');
              break;
            }

            this.sendUIResult(SDL.SDLModel.data.resultCode.SUCCESS, request.id, request.method);
            break;
          }
          case 'UI.SetMediaClockTimer':
          {
            var resultCode = SDL.SDLController.getApplicationModel(
              request.params.appID
            ).sdlSetMediaClockTimer(request.params);
            if (resultCode === SDL.SDLModel.data.resultCode.SUCCESS) {
              if(request.params.enableSeek) {
                this.OnSeekMediaClockTimer(request.params.startTime, request.params.appID);
              }

              let indicator = (request.params.audioStreamingIndicator) ? request.params.audioStreamingIndicator
                                : "PLAY_PAUSE";
              SDL.SDLController.SetAudioStreamingIndicator(indicator);

              this.sendUIResult(resultCode, request.id, request.method);
            } else {
              this.sendError(
                resultCode,
                request.id,
                request.method,
                'Request is ignored, because the intended result is already in effect.'
              );
            }
            break;
          }
          case 'UI.Slider':
          {
            if (SDL.SDLModel.uiSlider(request)) {
              SDL.SDLController.onSystemContextChange();
              SDL.SDLModel.data.registeredApps.forEach(app => {
                app.activeWindows.forEach(widget => {
                  SDL.SDLController.onSystemContextChange(app.appID, widget.windowID);
                })
              })
            }
            break;
          }
          case 'UI.ScrollableMessage':
          {
            if (SDL.SDLModel.onSDLScrolableMessage(request, request.id)) {
              SDL.SDLController.onSystemContextChange();
              SDL.SDLModel.data.registeredApps.forEach(app => {
                app.activeWindows.forEach(widget => {
                  SDL.SDLController.onSystemContextChange(app.appID, widget.windowID);
                })
              })
            }
            break;
          }
          case 'UI.SendHapticData':
          {
            SDL.SDLController.getApplicationModel(request.params.appID).set(
              'hapticRectData',
              request.params.hapticRectData
            );

            this.sendUIResult(
              SDL.SDLModel.data.resultCode.SUCCESS, request.id, request.method
            );
            break;
          }
          case 'UI.ChangeRegistration':
          {
            if (request.params.appName) {
              SDL.SDLController.getApplicationModel(request.params.appID).set(
                'appName',
                request.params.appName
              );
            }
            SDL.InfoAppsView.showAppList();
            SDL.SDLModel.changeRegistrationUI(
              request.params.language,
              request.params.appID,
              request.params.appName
            );
            this.sendUIResult(
              SDL.SDLModel.data.resultCode.SUCCESS, request.id, request.method
            );
            break;
          }
          case 'UI.SetDisplayLayout':
          {
            let appModel = SDL.SDLController.getApplicationModel(request.params.appID);
            const isWindowIDExist = "windowID" in request.params; 
            const isWidgetID = isWindowIDExist && parseInt(request.params.windowID) != 0;
            const windowID = isWindowIDExist ? parseInt(request.params.windowID) : 0;
            let model = isWidgetID ? appModel.getWidgetModel(windowID).content : appModel;
            var sendResponseFlag = false;

            Em.Logger.log('FFW.' + request.method + 'Response');
            var displayLayout = request.params.displayLayout;

            if (!SDL.SDLModel.isTemplateSupported(model, request.params.displayLayout)) {
              this.sendError(
                SDL.SDLModel.data.resultCode['REJECTED'], request.id,
                request.method, 'The requested layout is not supported for this app type'
              );
              return;
            }

            if (displayLayout === "DEFAULT") {
              for (var i=0; i<model.appType.length; i++) {
                if (model.appType[i] === "NAVIGATION") {
                  displayLayout = "NAV_FULLSCREEN_MAP";
                  break;
                }
              }
              if (displayLayout != "NAV_FULLSCREEN_MAP") {
                if (model.isMedia === true) {
                  displayLayout = "MEDIA"
                } else {
                  displayLayout = "NON-MEDIA"
                }
              }
            }
            // send repsonse
            var JSONMessage = {
              'jsonrpc': '2.0',
              'id': request.id,
              'result': {
                'displayCapabilities': SDL.templateCapabilities[displayLayout].displayCapabilities,
                'buttonCapabilities': SDL.templateCapabilities[displayLayout].buttonCapabilities,
                'softButtonCapabilities': SDL.templateCapabilities[displayLayout].softButtonCapabilities,
                'presetBankCapabilities': SDL.templateCapabilities[displayLayout].presetBankCapabilities,
                'code': SDL.SDLModel.data.resultCode.SUCCESS,
                'method': 'UI.SetDisplayLayout'
              }
            };
            this.sendMessage(JSONMessage);
            let sendCapabilityUpdated = false;
            if ("displayLayout" in request.params && model.templateConfiguration.template !== request.params.displayLayout) {
              model.templateConfiguration.template = request.params.displayLayout

              if (model.active) {
                SDL.SDLModel.data.templateChangeInProgress = true;
                SDL.States.goToStates('info.apps');
                model.turnOnSDL();
                SDL.SDLModel.data.templateChangeInProgress = false;
              }

              sendCapabilityUpdated = true;
            }
            if ("dayColorScheme" in request.params
                && !SDL.SDLController.isColorSchemesEqual(
                  model.templateConfiguration.dayColorScheme,
                  request.params.dayColorScheme)) {
              model.templateConfiguration.dayColorScheme = request.params.dayColorScheme;
              sendCapabilityUpdated = true;
            }
            if ("nightColorScheme" in request.params
                && !SDL.SDLController.isColorSchemesEqual(
                  model.templateConfiguration.nightColorScheme,
                  request.params.nightColorScheme)) {
              model.templateConfiguration.nightColorScheme = request.params.nightColorScheme;
              sendCapabilityUpdated = true;
            }
            if (sendCapabilityUpdated) {
              let capability = SDL.SDLController.getDisplayCapability(request.params.appID, windowID);
              FFW.BasicCommunication.OnSystemCapabilityUpdated(capability);
            }
            break;
          }
          case 'UI.SetAppIcon':
          {
            SDL.SDLModel.onSDLSetAppIcon(
              request.params, request.id, request.method
            );
            break;
          }
          case 'UI.PerformAudioPassThru':
          {
            if (this.performAudioPassThruRequestID > 0) {
              this.sendError(
                SDL.SDLModel.data.resultCode.REJECTED,
                request.id,
                request.method,
                'PerformAudioPassThru request aborted!'
              );
            } else {
              this.performAudioPassThruRequestID = request.id;
              SDL.SDLModel.UIPerformAudioPassThru(request.params);
              SDL.SDLController.onSystemContextChange();
              SDL.SDLModel.data.registeredApps.forEach(app => {
                app.activeWindows.forEach(widget => {
                  SDL.SDLController.onSystemContextChange(app.appID, widget.windowID);
                })
              })
            }
            break;
          }
          case 'UI.EndAudioPassThru':
          {
            this.endAudioPassThruRequestID = request.id;
            SDL.SDLModel.UIEndAudioPassThru();
            break;
          }
          case 'UI.GetSupportedLanguages':
          {
            Em.Logger.log('FFW.' + request.method + 'Response');
            var JSONMessage = {
              'id': request.id,
              'jsonrpc': '2.0',
              'result': {
                'code': SDL.SDLModel.data.resultCode.SUCCESS, // type
                // (enum)
                // from
                // SDL
                'method': 'UI.GetSupportedLanguages',
                'languages': SDL.SDLModel.data.sdlLanguagesList
              }
            };
            this.sendMessage(JSONMessage);
            break;
          }
          case 'UI.GetLanguage':
          {
            Em.Logger.log('FFW.' + request.method + 'Response');
            var JSONMessage = {
              'jsonrpc': '2.0',
              'id': request.id,
              'result': {
                'code': SDL.SDLModel.data.resultCode.SUCCESS, // type
                // (enum)
                // from
                // SDL
                'method': 'UI.GetLanguage',
                'language': SDL.SDLModel.data.hmiUILanguage
              }
            };
            this.sendMessage(JSONMessage);
            break;
          }
          case 'UI.GetCapabilities':
          {
            Em.Logger.log('FFW.' + request.method + 'Response');
            // send repsonse
            var JSONMessage = {
              'jsonrpc': '2.0',
              'id': request.id,
              'result': {
                'displayCapabilities': {
                  'displayType': 'GEN2_8_DMA',
                  'displayName': 'SDL_HMI',
                  'textFields': [
                    {
                      'name': 'mainField1',
                      'characterSet': 'UTF_8',
                      'width': 500,
                      'rows': 1
                    },
                    {
                      'name': 'mainField2',
                      'characterSet': 'UTF_8',
                      'width': 500,
                      'rows': 1
                    },
                    {
                      'name': 'mainField3',
                      'characterSet': 'UTF_8',
                      'width': 500,
                      'rows': 1
                    },
                    {
                      'name': 'mainField4',
                      'characterSet': 'UTF_8',
                      'width': 500,
                      'rows': 1
                    },
                    {
                      'name': 'statusBar',
                      'characterSet': 'UTF_8',
                      'width': 500,
                      'rows': 1
                    },
                    {
                      'name': 'mediaClock',
                      'characterSet': 'UTF_8',
                      'width': 500,
                      'rows': 1
                    },
                    {
                      'name': 'mediaTrack',
                      'characterSet': 'UTF_8',
                      'width': 500,
                      'rows': 1
                    },
                    {
                      "name": "templateTitle",
                      "characterSet": "UTF_8",
                      "width": 100,
                      "rows": 1
                    },
                    {
                      'name': 'alertText1',
                      'characterSet': 'UTF_8',
                      'width': 500,
                      'rows': 1
                    },
                    {
                      'name': 'alertText2',
                      'characterSet': 'UTF_8',
                      'width': 500,
                      'rows': 1
                    },
                    {
                      'name': 'alertText3',
                      'characterSet': 'UTF_8',
                      'width': 500,
                      'rows': 1
                    },
                    {
                      'name': 'scrollableMessageBody',
                      'characterSet': 'UTF_8',
                      'width': 500,
                      'rows': 1
                    },
                    {
                      'name': 'initialInteractionText',
                      'characterSet': 'UTF_8',
                      'width': 500,
                      'rows': 1
                    },
                    {
                      'name': 'navigationText1',
                      'characterSet': 'UTF_8',
                      'width': 500,
                      'rows': 1
                    },
                    {
                      'name': 'navigationText2',
                      'characterSet': 'UTF_8',
                      'width': 500,
                      'rows': 1
                    },
                    {
                      'name': 'ETA',
                      'characterSet': 'UTF_8',
                      'width': 500,
                      'rows': 1
                    },
                    {
                      'name': 'totalDistance',
                      'characterSet': 'UTF_8',
                      'width': 500,
                      'rows': 1
                    },
                    {
                      'name': 'audioPassThruDisplayText1',
                      'characterSet': 'UTF_8',
                      'width': 500,
                      'rows': 1
                    },
                    {
                      'name': 'audioPassThruDisplayText2',
                      'characterSet': 'UTF_8',
                      'width': 500,
                      'rows': 1
                    },
                    {
                      'name': 'sliderHeader',
                      'characterSet': 'UTF_8',
                      'width': 500,
                      'rows': 1
                    },
                    {
                      'name': 'sliderFooter',
                      'characterSet': 'UTF_8',
                      'width': 500,
                      'rows': 1
                    },
                    {
                      'name': 'menuName',
                      'characterSet': 'UTF_8',
                      'width': 500,
                      'rows': 1
                    },
                    {
                      'name': 'secondaryText',
                      'characterSet': 'UTF_8',
                      'width': 500,
                      'rows': 1
                    },
                    {
                      'name': 'tertiaryText',
                      'characterSet': 'UTF_8',
                      'width': 500,
                      'rows': 1
                    },
                    {
                        "name": "timeToDestination",
                        "characterSet": "UTF_8",
                        "width": 500,
                        "rows": 1
                    },
                    {
                        "name": "turnText",
                        "characterSet": "UTF_8",
                        "width": 500,
                        "rows": 1
                    },
                    {
                      'name': 'menuTitle',
                      'characterSet': 'UTF_8',
                      'width': 500,
                      'rows': 1
                    },
                    {
                      'name': 'locationName',
                      'characterSet': 'UTF_8',
                      'width': 500,
                      'rows': 1
                    },
                    {
                      'name': 'locationDescription',
                      'characterSet': 'UTF_8',
                      'width': 500,
                      'rows': 1
                    },
                    {
                      'name': 'addressLines',
                      'characterSet': 'UTF_8',
                      'width': 500,
                      'rows': 1
                    },
                    {
                      'name': 'phoneNumber',
                      'characterSet': 'UTF_8',
                      'width': 500,
                      'rows': 1
                    },
                    {
                      'name': 'subtleAlertText1',
                      'characterSet': 'UTF_8',
                      'width': 500,
                      'rows': 1
                    },
                    {
                      'name': 'subtleAlertText2',
                      'characterSet': 'UTF_8',
                      'width': 500,
                      'rows': 1
                    },
                    {
                      'name': 'subtleAlertSoftButtonText',
                      'characterSet': 'UTF_8',
                      'width': 500,
                      'rows': 1
                    },
                    {
                      'name': 'menuCommandSecondaryText',
                      'characterSet': 'UTF_8',
                      'width': 500,
                      'rows': 1
                    },
                    {
                      'name': 'menuCommandTertiaryText',
                      'characterSet': 'UTF_8',
                      'width': 500,
                      'rows': 1
                    },
                    {
                      'name': 'menuSubMenuSecondaryText',
                      'characterSet': 'UTF_8',
                      'width': 500,
                      'rows': 1
                    },
                    {
                      'name': 'menuSubMenuTertiaryText',
                      'characterSet': 'UTF_8',
                      'width': 500,
                      'rows': 1
                    }
                  ],
                  'imageFields': [
                    {
                      'name': 'softButtonImage',
                      'imageTypeSupported': [
                        'GRAPHIC_BMP',
                        'GRAPHIC_JPEG',
                        'GRAPHIC_PNG'
                      ],
                      'imageResolution': {
                        'resolutionWidth': 64,
                        'resolutionHeight': 64
                      }
                    },
                    {
                      'name': 'choiceImage',
                      'imageTypeSupported': [
                        'GRAPHIC_BMP',
                        'GRAPHIC_JPEG',
                        'GRAPHIC_PNG'
                      ],
                      'imageResolution': {
                        'resolutionWidth': 64,
                        'resolutionHeight': 64
                      }
                    },
                    {
                      'name': 'choiceSecondaryImage',
                      'imageTypeSupported': [
                        'GRAPHIC_BMP',
                        'GRAPHIC_JPEG',
                        'GRAPHIC_PNG'
                      ],
                      'imageResolution': {
                        'resolutionWidth': 64,
                        'resolutionHeight': 64
                      }
                    },
                    {
                      'name': 'vrHelpItem',
                      'imageTypeSupported': [
                        'GRAPHIC_BMP',
                        'GRAPHIC_JPEG',
                        'GRAPHIC_PNG'
                      ],
                      'imageResolution': {
                        'resolutionWidth': 64,
                        'resolutionHeight': 64
                      }
                    },
                    {
                      'name': 'turnIcon',
                      'imageTypeSupported': [
                        'GRAPHIC_BMP',
                        'GRAPHIC_JPEG',
                        'GRAPHIC_PNG'
                      ],
                      'imageResolution': {
                        'resolutionWidth': 64,
                        'resolutionHeight': 64
                      }
                    },
                    {
                      'name': 'menuIcon',
                      'imageTypeSupported': [
                        'GRAPHIC_BMP',
                        'GRAPHIC_JPEG',
                        'GRAPHIC_PNG'
                      ],
                      'imageResolution': {
                        'resolutionWidth': 64,
                        'resolutionHeight': 64
                      }
                    },
                    {
                      'name': 'cmdIcon',
                      'imageTypeSupported': [
                        'GRAPHIC_BMP',
                        'GRAPHIC_JPEG',
                        'GRAPHIC_PNG'
                      ],
                      'imageResolution': {
                        'resolutionWidth': 64,
                        'resolutionHeight': 64
                      }
                    },
                    {
                      'name': 'graphic',
                      'imageTypeSupported': [
                        'GRAPHIC_BMP',
                        'GRAPHIC_JPEG',
                        'GRAPHIC_PNG'
                      ],
                      'imageResolution': {
                        'resolutionWidth': 64,
                        'resolutionHeight': 64
                      }
                    },
                    {
                      'name': 'secondaryGraphic',
                      'imageTypeSupported': [
                        'GRAPHIC_BMP',
                        'GRAPHIC_JPEG',
                        'GRAPHIC_PNG'
                      ],
                      'imageResolution': {
                        'resolutionWidth': 64,
                        'resolutionHeight': 64
                      }
                    },
                    {
                      'name': 'showConstantTBTIcon',
                      'imageTypeSupported': [
                        'GRAPHIC_BMP',
                        'GRAPHIC_JPEG',
                        'GRAPHIC_PNG'
                      ],
                      'imageResolution': {
                        'resolutionWidth': 64,
                        'resolutionHeight': 64
                      }
                    },
                    {
                      'name': 'showConstantTBTNextTurnIcon',
                      'imageTypeSupported': [
                        'GRAPHIC_BMP',
                        'GRAPHIC_JPEG',
                        'GRAPHIC_PNG'
                      ],
                      'imageResolution': {
                        'resolutionWidth': 64,
                        'resolutionHeight': 64
                      }
                    },
                    {
                      'name': 'showConstantTBTNextTurnIcon',
                      'imageTypeSupported': [
                        'GRAPHIC_BMP',
                        'GRAPHIC_JPEG',
                        'GRAPHIC_PNG'
                      ],
                      'imageResolution': {
                        'resolutionWidth': 64,
                        'resolutionHeight': 64
                      }
                    },
                    {
                      'name': 'alertIcon',
                      'imageTypeSupported': [
                        'GRAPHIC_BMP',
                        'GRAPHIC_JPEG',
                        'GRAPHIC_PNG'
                      ],
                      'imageResolution': {
                        'resolutionWidth': 105,
                        'resolutionHeight': 65
                      }
                    },
                    {
                      'name': 'subtleAlertIcon',
                      'imageTypeSupported': [
                        'GRAPHIC_BMP',
                        'GRAPHIC_JPEG',
                        'GRAPHIC_PNG'
                      ],
                      'imageResolution': {
                        'resolutionWidth': 105,
                        'resolutionHeight': 65
                      }
                    },
                    {
                      'name': 'menuCommandSecondaryImage',
                      'imageTypeSupported': [
                        'GRAPHIC_BMP',
                        'GRAPHIC_JPEG',
                        'GRAPHIC_PNG'
                      ],
                      'imageResolution': {
                        'resolutionWidth': 105,
                        'resolutionHeight': 65
                      }
                    },
                    {
                      'name': 'menuSubMenuSecondaryImage',
                      'imageTypeSupported': [
                        'GRAPHIC_BMP',
                        'GRAPHIC_JPEG',
                        'GRAPHIC_PNG'
                      ],
                      'imageResolution': {
                        'resolutionWidth': 105,
                        'resolutionHeight': 65
                      }
                    }
                  ],
                  'mediaClockFormats': [
                    'CLOCK1', 'CLOCK2', 'CLOCK3', 'CLOCKTEXT1', 'CLOCKTEXT2',
                    'CLOCKTEXT3', 'CLOCKTEXT4'
                  ],
                  'graphicSupported': true,
                  'imageCapabilities': ['DYNAMIC', 'STATIC'],
                  'templatesAvailable': ["MEDIA", "NON-MEDIA", "DEFAULT", "NAV_FULLSCREEN_MAP", 'WEB_VIEW'],
                  'screenParams': {
                    'resolution': {
                      'resolutionWidth': 800,
                      'resolutionHeight': 480
                    },
                    'touchEventAvailable': {
                      'pressAvailable': true,
                      'multiTouchAvailable': true,
                      'doublePressAvailable': false
                    }
                  },
                  'numCustomPresetsAvailable': 10
                },
                'audioPassThruCapabilities': {
                  'samplingRate': '44KHZ',
                  'bitsPerSample': '8_BIT',
                  'audioType': 'PCM'
                },
                'audioPassThruCapabilitiesList': [{
                  'samplingRate': '44KHZ',
                  'bitsPerSample': '8_BIT',
                  'audioType': 'PCM'
                }],
                "pcmStreamCapabilities": {
                  "samplingRate"  : "16KHZ",
                  "bitsPerSample" : "16_BIT",
                  "audioType"	: "PCM"
                },
                'hmiZoneCapabilities': 'FRONT',
                'softButtonCapabilities': [
                  {
                    'shortPressAvailable': true,
                    'longPressAvailable': true,
                    'upDownAvailable': true,
                    'imageSupported': true
                  }
                ],
                'hmiCapabilities': {
                  'navigation': true,
                  'phoneCall': true
                },
                'systemCapabilities': SDL.systemCapabilities,
                'code': SDL.SDLModel.data.resultCode.SUCCESS,
                'method': 'UI.GetCapabilities'
              }
            };
            this.sendMessage(JSONMessage);
            break;
          }
          case 'UI.IsReady':
          {
            Em.Logger.log('FFW.' + request.method + 'Response');
            // send repsonse
            var JSONMessage = {
              'jsonrpc': '2.0',
              'id': request.id,
              'result': {
                'available': this.get('isReady'),
                'code': SDL.SDLModel.data.resultCode.SUCCESS,
                'method': 'UI.IsReady'
              }
            };
            this.sendMessage(JSONMessage);
            break;
          }
          case 'UI.ClosePopUp':
          {
            SDL.SDLController.closePopUp(request.params.methodName);
            Em.Logger.log('FFW.' + request.method + 'Response');
            // send repsonse
            var JSONMessage = {
              'jsonrpc': '2.0',
              'id': request.id,
              'result': {
                'code': SDL.SDLModel.data.resultCode.SUCCESS,
                'method': 'UI.ClosePopUp'
              }
            };
            this.sendMessage(JSONMessage);
            break;
          }
          case 'UI.ShowVrHelp':
          {

            //SDL.SDLModel.ShowVrHelp(request.params);
            this.sendUIResult(
              SDL.SDLModel.data.resultCode.SUCCESS, request.id, request.method
            );
            break;
          }
          case 'UI.CreateWindow':
          {
            const resultCode = FFW.RPCHelper.getCustomResultCode(request.params.appID, 'uiCreateWindow');
            if ('DO_NOT_RESPOND' == resultCode) {
              Em.Logger.log('Do not respond on this request');
              return;
            }

            if (FFW.RPCHelper.isSuccessResultCode(resultCode)) {
              var app = SDL.SDLController.getApplicationModel(request.params.appID);
              if (app) {
                app.createWindow(request.params);

                this.sendUIResult(resultCode, request.id, request.method);

                let capabilites = SDL.SDLController.getDisplayCapability(request.params.appID, request.params.windowID);
                FFW.BasicCommunication.OnSystemCapabilityUpdated(capabilites);
              }
            } else {
              this.sendUIResult(resultCode, request.id, request.method, 'Erroneous response is assigned by settings');
            }

            break;
          }
          case 'UI.DeleteWindow':
          {
            var app = SDL.SDLController.getApplicationModel(request.params.appID);
            app.deleteWindow(request.params);
            this.sendUIResult(
              SDL.SDLModel.data.resultCode.SUCCESS, request.id, request.method
            );
            break;
          }
          default:
          {
            // statements_def
            break;
          }
        }
      }
    },
    /**
     * Send error response from onRPCRequest
     *
     * @param {Number}
     *            resultCode
     * @param {Number}
     *            id
     * @param {String}
     *            method
     * @param {String}
     *            message
     */
    sendError: function(resultCode, id, method, message) {
      Em.Logger.log('FFW.' + method + 'Response');
      // send response
      var JSONMessage = {
        'jsonrpc': '2.0',
        'id': id,
        'error': {
          'code': resultCode, // type (enum) from SDL protocol
          'message': message,
          'data': {
            'method': method
          }
        }
      };

      this.sendMessage(JSONMessage);
    },
    /**
     * send response from onRPCRequest
     *
     * @param {Number}
     *            resultCode
     * @param {Number}
     *            id
     * @param {String}
     *            method
     * @param {String}
     *            info
     * @param {Object}
     *            params
     */
    sendUIResult: function(resultCode, id, method, info, params) {
      const is_successful_code = FFW.RPCHelper.isSuccessResultCode(resultCode);
      if (is_successful_code && this.errorResponsePull[id] != null) {
        // If request was successful but some error was observed upon validation
        // Then result code assigned by RPCController should be considered instead
        const errorStruct = this.errorResponsePull[id];
        this.errorResponsePull[id] = null;

        this.sendUIResult(
          errorStruct.code,
          id,
          method,
          `Unsupported ${errorStruct.type} type. Available data in request was processed.`,
          params
        );
        return;
      }

      let is_successful_response_format = function(is_success) {
        // Successful response without params, but with not-empty message
        // should be sent in errorneous format to properly forward info and result code
        if (is_success && info != null && params == null) {
          return false;
        }

        // Error response with not empty params should be sent in regular format
        // to properly forward result code and params (but sacrifice info)
        if (!is_success && params != null) {
          return true;
        }

        // Otherwise use result code calculated according to regular HMI logic
        return is_success;
      };

      Em.Logger.log('FFW.UI.' + method + 'Response');
      if (is_successful_response_format(is_successful_code)) {
        // send response
        var JSONMessage = {
          'jsonrpc': '2.0',
          'id': id,
          'result': {
            'code': resultCode, // type (enum) from SDL protocol
            'method': method,
          }
        };

        if (params != null) {
          Object.assign(JSONMessage.result, params);
        }

        this.sendMessage(JSONMessage);
      } else {
        this.sendError(resultCode, id, method, info);
      }
    },
    /**
     * send response from onRPCRequest
     *
     * @param {Number}
     *            resultCode
     * @param {Number}
     *            id
     */
    alertResponse: function(resultCode, id, info) {
      Em.Logger.log('FFW.UI.AlertResponse');
      switch (resultCode) {
        case SDL.SDLModel.data.resultCode.WARNINGS:
        case SDL.SDLModel.data.resultCode.SUCCESS:
        {
          this.sendUIResult(resultCode, id, 'UI.Alert', info);
          break;
        }
        case SDL.SDLModel.data.resultCode['ABORTED']:
        {
          this.sendError(resultCode, id, 'UI.Alert', 'Alert request aborted.');
          break;
        }
        case SDL.SDLModel.data.resultCode.REJECTED:
        {
          this.sendError(
            resultCode, id, 'UI.Alert', 'Another Alert is active.'
          );
          break;
        }
      }
    },
    /**
     * send response from onRPCRequest
     *
     * @param {Number}
     *            resultCode
     * @param {Number}
     *            rpc id
     * @param {String}
     *            info to send w response
     * @param {Number}
     *            tryAgainTime
     */
    subtleAlertResponse: function(resultCode, id, info, tryAgainTime) {
      switch (resultCode) {
        case SDL.SDLModel.data.resultCode.WARNINGS:
        case SDL.SDLModel.data.resultCode.SUCCESS:
        {
          this.sendUIResult(resultCode, id, 'UI.SubtleAlert', info);
          break;
        }
        case SDL.SDLModel.data.resultCode.REJECTED:
        {
          this.sendUIResult(resultCode, id, 'UI.SubtleAlert', info, { tryAgainTime: tryAgainTime });
          break;
        }
        case SDL.SDLModel.data.resultCode.ABORTED:
        {
          this.sendUIResult(resultCode, id, 'UI.SubtleAlert', 'SubtleAlert request aborted.');
          break;
        }
      }
    },
    /**
     * send notification for OnSubtleAlertPressed
     *
     * @param {Number}
     *            appID
     */
    onSubtleAlertPressed: function(appID) {
      Em.Logger.log('FFW.UI.OnSubtleAlertPressed');
      var JSONMessage = {
        'jsonrpc': '2.0',
        'method': 'UI.OnSubtleAlertPressed',
        'params': {
          'appID': appID
        }
      };
      this.sendMessage(JSONMessage);
    },
    /**
     * send response from onRPCRequest
     *
     * @param {Number}
     *            resultCode
     * @param {Number}
     *            sliderRequestID
     * @param {Number}
     *            sliderPosition
     */
    sendSliderResult: function(resultCode, sliderRequestID, sliderPosition) {
      Em.Logger.log('FFW.UI.SliderResponse');
      if (resultCode === SDL.SDLModel.data.resultCode.SUCCESS || sliderPosition) {
        // send repsonse
        var JSONMessage = {
          'jsonrpc': '2.0',
          'id': sliderRequestID,
          'result': {
            'code': resultCode, // type (enum) from SDL protocol
            'method': 'UI.Slider'
          }
        };
        if (sliderPosition) {
          JSONMessage.result.sliderPosition = sliderPosition;
        }
      } else {
        // send repsonse
        var JSONMessage = {
          'jsonrpc': '2.0',
          'id': sliderRequestID,
          'error': {
            'code': resultCode, // type (enum) from SDL protocol
            'message': 'Slider request failed.',
            'data': {
              'method': 'UI.Slider'
            }
          }
        };
      }
      this.sendMessage(JSONMessage);
    },
    /**
     * send notification when command was triggered
     *
     * @param {Number}
     *            commandID
     * @param {Number}
     *            appID
     */
    onCommand: function(commandID, appID) {
      Em.Logger.log('FFW.UI.onCommand');
      var JSONMessage = {
        'jsonrpc': '2.0',
        'method': 'UI.OnCommand',
        'params': {
          'cmdID': commandID,
          'appID': appID
        }
      };
      this.sendMessage(JSONMessage);
    },
    /**
     * Notification method to send touch event data to SDLCore
     *
     * @param {String} type
     * @param {Object} touchLists
     * @param {Object} info
     */
    onTouchEvent: function(type, event) {
      Em.Logger.log('FFW.UI.OnTouchEvent');
      var JSONMessage = {
        'jsonrpc': '2.0',
        'method': 'UI.OnTouchEvent',
        'params': {
          'type': type,
          'event': event
        }
      };
      this.sendMessage(JSONMessage);
    },
    /**
     * send notification when command was triggered
     *
     * @param {Number}
     *            softButtonID
     * @param {Number}
     *            appID
     */
    onCommandSoftButton: function(softButtonID, appID) {
      Em.Logger.log('FFW.UI.onCommand');
      var JSONMessage = {
        'jsonrpc': '2.0',
        'method': 'UI.OnCommand',
        'params': {
          'commandID': softButtonID,
          'appID': appID
        }
      };
      this.sendMessage(JSONMessage);
    },
    /**
     * send notification when command was triggered
     *
     * @param {Number} requestID
     * @param {Number} resultCode
     * @param {Number} commandID
     * @param {String} manualTextEntry
     * @param {String} info
     */
    interactionResponse: function(requestID, resultCode, commandID,
      manualTextEntry, info) {
      if (FFW.RPCHelper.isSuccessResultCode(resultCode)) {
        var params = {
          'choiceID': commandID
        };

        if (manualTextEntry) {
          params.manualTextEntry = manualTextEntry;
        }

        this.sendUIResult(
          resultCode,
          requestID,
          'UI.PerformInteraction',
          info,
          params
        );
      } else {
        this.sendUIResult(
          resultCode,
          requestID,
          'UI.PerformInteraction',
          info
        );
      }
    },
    /**
     * send notification when DriverDistraction PopUp is visible
     *
     * @param {String}
     *            driverDistractionState
     */
    onDriverDistraction: function(driverDistractionState) {
      Em.Logger.log('FFW.UI.DriverDistraction');
      // send repsonse
      var JSONMessage = {
        'jsonrpc': '2.0',
        'method': 'UI.OnDriverDistraction',
        'params': {
          'state': driverDistractionState
        }
      };
      this.sendMessage(JSONMessage);
    },
    /**
     * Notifies if system context is changed
     *
     * @param {String}
     *            systemContextValue
     */
    OnSystemContext: function(systemContextValue, appID, windowID) {
      Em.Logger.log('FFW.UI.OnSystemContext');

      if (FLAGS.TOUCH_EVENT_STARTED && systemContextValue != 'MAIN'
          && appID == SDL.SDLController.model.appID) {
        FLAGS.TOUCH_EVENT_STARTED = false;
        FFW.UI.onTouchEvent('CANCEL', [{ id: 0, ts: [parseInt(performance.now())], c: [FLAGS.LAST_TOUCH_POINT] }]);
      }

      // send repsonse
      var JSONMessage = {
        'jsonrpc': '2.0',
        'method': 'UI.OnSystemContext',
        'params': {
          'systemContext': systemContextValue
        }
      };
      if (appID) {
        JSONMessage.params.appID = appID;
      }
      if(windowID) {
        JSONMessage.params.windowID = windowID;
      }
      this.sendMessage(JSONMessage);
    },
    /**
     * Notifies if sdl UI components language was changed
     *
     * @param {String}
     *            lang
     */
    OnLanguageChange: function(lang) {
      Em.Logger.log('FFW.UI.OnLanguageChange');
      // send repsonse
      var JSONMessage = {
        'jsonrpc': '2.0',
        'method': 'UI.OnLanguageChange',
        'params': {
          'language': lang
        }
      };
      this.sendMessage(JSONMessage);
    },
    /**
     *  Sends notification on SDL Core display keyboard value
     *
     * @param {String}
     *
     */
    OnKeyboardInput: function(data, event) {
      Em.Logger.log('FFW.UI.OnKeyboardInput');
      // send repsonse
      var JSONMessage = {
        'jsonrpc': '2.0',
        'method': 'UI.OnKeyboardInput',
        'params': {
          'event': event
        }
      };
      if (data) {
        JSONMessage.params.data = data;
      }
      this.sendMessage(JSONMessage);
    },
    /**
     * Callback for the seek media clock timer notification
     *
     * @param {Object}
     *            seekTime
     */
    OnSeekMediaClockTimer: function(seekTime, appID) {
      Em.Logger.log('FFW.UI.OnSeekMediaClockTimer');
      // send repsonse
      var JSONMessage = {
        'jsonrpc': '2.0',
        'method': 'UI.OnSeekMediaClockTimer',
        'params': {
          'seekTime': seekTime,
          'appID': appID
        }
      };
      this.sendMessage(JSONMessage);
    },
    /**
     * Callback for requesting images from mobile application
     *
     * @param {integer}
     *            appID
     * @param {string}
     *            fileName
     */
    OnUpdateFile: function(appID, fileName) {
      var JSONMessage = {
        'jsonrpc': '2.0',
        'method': 'UI.OnUpdateFile',
        'params': {
          'appID': appID,
          'fileName': fileName
        }
      };
      this.sendMessage(JSONMessage);
    },
        /**
     * Callback for requesting submenu contents from mobile application
     *
     * @param {integer}
     *            appID
     * @param {integer}
     *            menuID
     */
    OnUpdateSubMenu: function(appID, menuID) {
      var JSONMessage = {
        'jsonrpc': '2.0',
        'method': 'UI.OnUpdateSubMenu',
        'params': {
          'appID': appID,
          'menuID': menuID,
          'updateSubCells': true
        }
      };
      this.sendMessage(JSONMessage);
    }
  }
);