@slanglabs/slang-conva-react-native-retail-assistant/rn-bridge.js

The client library for adding and interacting with Slang CONVA's Retail In-App Voice Assistant.

import {
  NativeModules,
  DeviceEventEmitter
} from "react-native";
import { NavigationUserJourney, OrderManagementUserJourney, SearchUserJourney } from ".";
const {
  SlangRetailAssistant
} = NativeModules;

const NativeSlangRetailAssistant = SlangRetailAssistant;

const AssistantUserJourney = {
  SEARCH: "retail_search",
  ORDER_MANAGEMENT: "retail_order_management",
  NAVIGATION: "retail_navigation"
}

const checkFunc = (cb, func) => {

  if (typeof cb === "function") {
      return true;
  }

  return false;
};

const searchUserJourney = {
  notifyAppState: (appState) => {
      SlangRetailAssistant.notifySearchActionCompleted(appState);
  },
  setSuccess: () => {
      SlangRetailAssistant.setSearchSuccess();
  },
  setFailure: () => {
      SlangRetailAssistant.setSearchFailure();
  },
  setItemNotFound: () => {
      SlangRetailAssistant.setItemNotFound();
  },
  setItemOutOfStock: () => {
      SlangRetailAssistant.setItemOutOfStock();
  },
  setItemNotSpecified: () => {
      SlangRetailAssistant.setItemNotSpecified();
  },
  setNeedItemQuantity: () => {
      SlangRetailAssistant.setNeedItemQuantity();
  },
  setNeedDisambiguation: () => {
      SlangRetailAssistant.setNeedDisambiguation();
  },
  setStopDisambiguation: () => {
      SlangRetailAssistant.setStopDisambiguation();
  },
  setUserJourneyToContinue: (assistantUserJourney, isSpoken) => {
      SlangRetailAssistant.setUserJourneyToContinue(AssistantUserJourney.SEARCH, assistantUserJourney, isSpoken);
  },
  clearUserJourneyToContinue: () => {
      SlangRetailAssistant.clearUserJourneyToContinue();
  }
}

const navigationUserJourney = {
  notifyAppState: (appState) => {
      SlangRetailAssistant.notifyNavigationActionCompleted(appState);
  },
  setNavigationSuccess: () => {
      SlangRetailAssistant.setNavigationSuccess();
  },
  setNavigationFailure: () => {
      SlangRetailAssistant.setNavigationFailure();
  },
  setUserJourneyToContinue: (assistantUserJourney, isSpoken) => {
      SlangRetailAssistant.setUserJourneyToContinue(AssistantUserJourney.NAVIGATION, assistantUserJourney, isSpoken);
  },
  clearUserJourneyToContinue: () => {
      SlangRetailAssistant.clearUserJourneyToContinue();
  }
}

const orderUserJourney = {
  notifyAppState: (appState) => {
      SlangRetailAssistant.notifyOrderActionCompleted(appState);
  },
  setSuccess: () => {
      SlangRetailAssistant.setOrderSuccess();
  },
  setFailure: () => {
      SlangRetailAssistant.setOrderFailure(appState);
  },
  setOrdersEmpty: () => {
      SlangRetailAssistant.setOrdersEmpty();
  },
  setOrderNotFound: (index) => {
      SlangRetailAssistant.setOrderNotFound(index);
  },
  setConfirmationRequired: () => {
      SlangRetailAssistant.setOrderConfirmationRequired();
  },
  setUserConfirmedCancel: () => {
      SlangRetailAssistant.setOrderUserConfirmedCancel();
  },
  setUserDeniedCancel: () => {
      SlangRetailAssistant.setOrderUserDeniedCancel();
  },
  setUserJourneyToContinue: (assistantUserJourney, isSpoken) => {
      SlangRetailAssistant.setUserJourneyToContinue(AssistantUserJourney.ORDER_MANAGEMENT, assistantUserJourney, isSpoken);
  },
  clearUserJourneyToContinue: () => {
      SlangRetailAssistant.clearUserJourneyToContinue();
  }
}

class RetailAssistantBridge {
  searchActionHandler = (searchInfo, searchUserJourney) => {
    searchUserJourney.setSuccess();
    return SearchUserJourney.AppState.SEARCH_RESULTS;
  };
  orderActionHandler = (orderInfo, orderUserJourney) => {
    orderUserJourney.setSuccess();
    return OrderManagementUserJourney.AppState.VIEW_ORDER;
  };
  navigationActionHandler = (navigationInfo, navigationUserJourney) => {
    navigationUserJourney.setSuccess();
    return NavigationUserJourney.AppState.NAVIGATION;
  };

  lifecycleObserver = {}

  constructor() {
      DeviceEventEmitter.addListener(
          "onSearch",
          async (searchInfo) => {
              try {
                  const status = await this.searchActionHandler(searchInfo, searchUserJourney);
                  console.log("Status is", status);
                  if (status != null) {
                      NativeSlangRetailAssistant.notifySearchActionCompleted(status);
                  }
              } catch (e) {
                  console.error("Error while executing Retail action handler", e);
                  NativeSlangRetailAssistant.notifySearchActionCompleted(false);
              }
          }
      );
      DeviceEventEmitter.addListener(
          "onOrderManagement",
          async (orderInfo) => {
              try {
                  const status = await this.orderActionHandler(orderInfo, orderUserJourney);
                  if (status != null) {
                      NativeSlangRetailAssistant.notifyOrderActionCompleted(status);
                  }
              } catch (e) {
                  console.error("Error while executing Retail action handler", e);
                  NativeSlangRetailAssistant.notifyOrderActionCompleted(false);
              }
          }
      );
      DeviceEventEmitter.addListener(
          "onNavigation",
          async (navigationInfo) => {
              try {
                  const status = await this.navigationActionHandler(navigationInfo, navigationUserJourney);
                  if (status != null) {
                      NativeSlangRetailAssistant.notifyNavigationActionCompleted(status);
                  }
              } catch (e) {
                  console.error("Error while executing Retail action handler", e);
                  NativeSlangRetailAssistant.notifyNavigationActionCompleted(false);
              }
          }
      );
      DeviceEventEmitter.addListener("onAssistantInitSuccess", (params) => {
          if (this.lifecycleObserver != null) {
              if (checkFunc(this.lifecycleObserver.onAssistantInitSuccess, "onAssistantInitSuccess")) {
                  this.lifecycleObserver.onAssistantInitSuccess();
              }
          }
      });
      DeviceEventEmitter.addListener("onAssistantInitFailure", (params) => {
          if (this.lifecycleObserver != null) {
              if (checkFunc(this.lifecycleObserver.onAssistantInitFailure, "onAssistantInitFailure")) {
                  if (params && "type" in params) {
                      this.lifecycleObserver.onAssistantInitFailure(params.type);
                  }
              }
          }
      });
      DeviceEventEmitter.addListener("onAssistantInvoked", (params) => {
          if (this.lifecycleObserver != null) {
              if (checkFunc(this.lifecycleObserver.onAssistantInvoked, "onAssistantInvoked")) {
                  this.lifecycleObserver.onAssistantInvoked();
              }
          }
      });
      DeviceEventEmitter.addListener("onAssistantClosed", (params) => {
          if (this.lifecycleObserver != null) {
              if (checkFunc(this.lifecycleObserver.onAssistantClosed, "onAssistantClosed")) {
                  if (params && "isCancelled" in params) {
                      this.lifecycleObserver.onAssistantClosed(params.isCancelled);
                  }
              }
          }
      });
      DeviceEventEmitter.addListener("onAssistantLocaleChanged", (locale) => {
          if (this.lifecycleObserver != null) {
              if (checkFunc(this.lifecycleObserver.onAssistantLocaleChanged, "onAssistantLocaleChanged")) {
                  this.lifecycleObserver.onAssistantLocaleChanged(locale);
              }
          }
      });
      DeviceEventEmitter.addListener("onUnrecognisedUtterance", (params) => {
          if (this.lifecycleObserver != null) {
              if (checkFunc(this.lifecycleObserver.onUnrecognisedUtterance, "onUnrecognisedUtterance")) {
                  if (params && "utterance" in params) {
                      this.lifecycleObserver.onUnrecognisedUtterance(params.utterance);
                  }
              }
          }
      });
      DeviceEventEmitter.addListener("onUtteranceDetected", (params) => {
          if (this.lifecycleObserver != null) {
              if (checkFunc(this.lifecycleObserver.onUtteranceDetected, "onUtteranceDetected")) {
                  if (params && "utterance" in params) {
                      this.lifecycleObserver.onUtteranceDetected(params.utterance);
                  }
              }
          }
      });
      DeviceEventEmitter.addListener("onOnboardingSuccess", (params) => {
          if (this.lifecycleObserver != null) {
              if (checkFunc(this.lifecycleObserver.onOnboardingSuccess, "onOnboardingSuccess")) {
                  this.lifecycleObserver.onOnboardingSuccess();
              }
          }
      });
      DeviceEventEmitter.addListener("onOnboardingFailure", (params) => {
          if (this.lifecycleObserver != null) {
              if (checkFunc(this.lifecycleObserver.onOnboardingFailure, "onOnboardingFailure")) {
                  this.lifecycleObserver.onOnboardingFailure();
              }
          }
      });
      DeviceEventEmitter.addListener("onMicPermissionDenied", (params) => {
          if (this.lifecycleObserver != null) {
              if (checkFunc(this.lifecycleObserver.onMicPermissionDenied, "onMicPermissionDenied")) {
                  this.lifecycleObserver.onMicPermissionDenied();
              }
          }
      });
      DeviceEventEmitter.addListener("onMicPermissionGranted", (params) => {
          if (this.lifecycleObserver != null) {
              if (checkFunc(this.lifecycleObserver.onMicPermissionGranted, "onMicPermissionGranted")) {
                  this.lifecycleObserver.onMicPermissionGranted();
              }
          }
      });
      DeviceEventEmitter.addListener("onCoachmarkAction", (params) => {
          if (this.lifecycleObserver != null) {
              if (checkFunc(this.lifecycleObserver.onCoachmarkAction, "onCoachmarkAction")) {
                  this.lifecycleObserver.onCoachmarkAction(params);
              }
          }
      });
  }

  //Initializes Slang Retail Assistant
  initialize(config) {
      if (!config) config = {};
      NativeSlangRetailAssistant.initialize(config);
  }

  showTrigger() {
      NativeSlangRetailAssistant.showTrigger();
  }

  hideTrigger() {
      NativeSlangRetailAssistant.hideTrigger();
  }

  setGlobalTrigger() {
    NativeSlangRetailAssistant.setGlobalTrigger();
  }

  setTheme(theme) {
      NativeSlangRetailAssistant.setTheme(theme);
  }

  setBackgroundColorGradient(colors) {
      NativeSlangRetailAssistant.setBackgroundColorGradient(colors);
  }

  setWaveColorGradient(colors) {
      NativeSlangRetailAssistant.setWaveColorGradient(colors);
  }

  setTextColor(color) {
      NativeSlangRetailAssistant.setTextColor(color);
  }

  setSecondaryTextColor(color) {
      NativeSlangRetailAssistant.setSecondaryTextColor(color);
  }

  setTextHighlightColor(color) {
      NativeSlangRetailAssistant.setTextHighlightColor(color);
  }

  setSettingsButtonBackgroundColor(color) {
      NativeSlangRetailAssistant.setSettingsButtonBackgroundColor(color);
  }

  setControlButtonBackgroundColor(color) {
      NativeSlangRetailAssistant.setControlButtonBackgroundColor(color);
  }

  setAppTrigger() {
      NativeSlangRetailAssistant.setAppTrigger();
  }

  setAction(searchActionHandler, orderActionHandler, navigationActionHandler) {
    if (searchActionHandler != null) {
        NativeSlangRetailAssistant.setSearchAction();
        this.searchActionHandler = searchActionHandler;
    }
    if (orderActionHandler != null || navigationActionHandler != null) {
        NativeSlangRetailAssistant.setAction();
        this.orderActionHandler = orderActionHandler;
        this.navigationActionHandler = navigationActionHandler;
    }
  }

  setLifecycleObserver(lifecycleObserver) {
      NativeSlangRetailAssistant.setLifecycleObserver();
      this.lifecycleObserver = lifecycleObserver
  }

  getActiveSearchJourney() {
      //This method is called to obtain the current search journey object in the native layer.
      NativeSlangRetailAssistant.prepareActiveSearchUserJourney();
      return searchUserJourney;
  }

  getActiveOrderManagementUserJourney() {
      //This method is called to obtain the current order management journey object in the native layer.
      NativeSlangRetailAssistant.prepareActiveOrderManagementUserJourney();
      return orderUserJourney;
  }

  getActiveNavigationUserJourney() {
      //This method is called to obtain the current active navigation journey object in the native layer.
      NativeSlangRetailAssistant.prepareActiveNavigationUserJourney();
      return navigationUserJourney;
  }

  notifyNonVoiceUserJourney(userJourney, retailItem) {
      NativeSlangRetailAssistant.notifyNonVoiceUserJourney(userJourney, retailItem);
  }

  notifyTextSearch(itemName) {
      NativeSlangRetailAssistant.notifyTextSearch(itemName);
  }

  notifyCTREvent(eventInfo) {
      NativeSlangRetailAssistant.notifyCTREvent(eventInfo);
  }

  triggerCoachmark() {
      NativeSlangRetailAssistant.triggerCoachmark();
  }

  setAppDefaultUserJourney(userJourney) {
      NativeSlangRetailAssistant.setAppDefaultUserJourney(userJourney);
  }

  setAppDefaultSubDomain(appSubDomain) {
      NativeSlangRetailAssistant.setAppDefaultSubDomain(appSubDomain);
  }

  setUserId(userId) {
      NativeSlangRetailAssistant.setUserId(userId);
  }

  setUserProperties(userProperties) {
      NativeSlangRetailAssistant.setUserProperties(userProperties);
  }

  setSearchUserJourneyContextItemBrand(brand) {
      NativeSlangRetailAssistant.setSearchUserJourneyContextItemBrand(brand);
  }

  getSearchUserJourneyContextItemBrand(brand) {
      return NativeSlangRetailAssistant.getSearchUserJourneyContextItemBrand();
  }

  setSearchUserJourneyContextItemId(itemId) {
      NativeSlangRetailAssistant.setSearchUserJourneyContextItemId(itemId);
  }

  getSearchUserJourneyContextItemId() {
      return NativeSlangRetailAssistant.getSearchUserJourneyContextItemId();
  }

  setSearchUserJourneyContextItemDescription(itemDescription) {
      NativeSlangRetailAssistant.setSearchUserJourneyContextItemDescription(itemDescription);
  }

  setSearchUserJourneyContextSelectedItemDescription(itemDescription) {
      NativeSlangRetailAssistant.setSearchUserJourneyContextSelectedItemDescription(itemDescription);
  }

  getSearchUserJourneyContextItemDescription() {
      return NativeSlangRetailAssistant.getSearchUserJourneyContextItemDescription();
  }

  setSearchUserJourneyContextItemCategory(itemCategory) {
      NativeSlangRetailAssistant.setSearchUserJourneyContextItemCategory(itemCategory);
  }

  getSearchUserJourneyContextItemCategory() {
      return NativeSlangRetailAssistant.getSearchUserJourneyContextItemCategory();
  }

  setSearchUserJourneyContextItemVariant(variants) {
      NativeSlangRetailAssistant.setSearchUserJourneyContextItemVariant(variants);
  }

  getSearchUserJourneyContextItemVariant() {
      return NativeSlangRetailAssistant.getSearchUserJourneyContextItemVariant();
  }

  setSearchUserJourneyContextItemPrice(minAmount, maxAmount, currency) {
      NativeSlangRetailAssistant.setSearchUserJourneyContextItemPrice(minAmount, maxAmount, currency);
  }

  getSearchUserJourneyContextItemPrice() {
      return NativeSlangRetailAssistant.getSearchUserJourneyContextItemPrice();
  }

  setSearchUserJourneyContextItemQuantity(amount, unit) {
      NativeSlangRetailAssistant.setSearchUserJourneyContextItemQuantity(amount, unit);
  }

  getSearchUserJourneyContextItemQuantity() {
      return NativeSlangRetailAssistant.getSearchUserJourneyContextItemQuantity();
  }

  setSearchUserJourneyContextItemSize(amount, unit) {
      NativeSlangRetailAssistant.setSearchUserJourneyContextItemSize(amount, unit);
  }

  getSearchUserJourneyContextItemSize() {
      return NativeSlangRetailAssistant.getSearchUserJourneyContextItemSize();
  }

  clearSearchUserJourneyContext() {
      NativeSlangRetailAssistant.clearSearchUserJourneyContext();
  }

  setOrderManagementUserJourneyContextOrderIndex(index) {
      NativeSlangRetailAssistant.setOrderManagementUserJourneyContextOrderIndex(index);
  }

  getOrderManagementUserJourneyContextOrderIndex() {
      NativeSlangRetailAssistant.getOrderManagementUserJourneyContextOrderIndex();
  }

  clearOrderManagementUserJourneyContext() {
      NativeSlangRetailAssistant.clearOrderManagementUserJourneyContext();
  }

  clearNavigationUserJourneyContext() {
      NativeSlangRetailAssistant.clearNavigationUserJourneyContext();
  }

  startConversation() {
      NativeSlangRetailAssistant.startConversation();
  }

  startConversation(userJourney) {
      NativeSlangRetailAssistant.startConversation(userJourney);
  }

  cancelSession() {
      NativeSlangRetailAssistant.cancelSession();
  }

  setLocale(locale) {
    NativeSlangRetailAssistant.setLocale(locale);
  }

  disableSearchUserJourneyContext() {
      NativeSlangRetailAssistant.disableSearchUserJourneyContext();
  }

  enableSearchUserJourneyContext() {
    NativeSlangRetailAssistant.enableSearchUserJourneyContext();
}

  disableOrderManagementUserJourneyContext() {
      NativeSlangRetailAssistant.disableOrderManagementUserJourneyContext();
  }

  disableNavigationUserJourneyContext() {
      NativeSlangRetailAssistant.disableNavigationUserJourneyContext();
  }

  nudgeUserWithParameters(title, description) {
    NativeSlangRetailAssistant.nudgeUserWithParameters(title, description);
  }

  nudgeUser() {
    NativeSlangRetailAssistant.nudgeUser();
  }

  removeNudge() {
    NativeSlangRetailAssistant.removeNudge();
  }

}

export const SlangRetailAssistantBridge = new RetailAssistantBridge();