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

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

import { DeviceEventEmitter, NativeModules, Image } from "react-native";
const { SlangPaymentsAssistant } = NativeModules;

const NativeSlangPaymentsAssistant = SlangPaymentsAssistant;

const AssistantUserJourney = {
  TRANSACTION: "payments_transactions",
  BILL_PAYMENT: "payments_bill",
  NAVIGATION: "payments_navigation"
}

const checkFunc = (cb, func) => {

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

  return false;
};

const transactionUserJourney = {
  notifyAppState: (appState) => {
    SlangPaymentsAssistant.notifyTransactionActionCompleted(appState);
  },
  setSuccess: () => {
    SlangPaymentsAssistant.setTransactionSuccess();
  },
  setFailure: () => {
    SlangPaymentsAssistant.setTransactionFailure();
  },
  setNameRequired: () => {
    SlangPaymentsAssistant.setTransactionNameRequired();
  },
  setAmountRequired: () => {
    SlangPaymentsAssistant.setTransactionAmountRequired();
  },
  setNameAmbiguous: () => {
    SlangPaymentsAssistant.setTransactionNameAmbiguous();
  },
  setNameNotFound: () => {
    SlangPaymentsAssistant.setTransactionNameNotFound();
  },
  setTransactionAction: () => {
    SlangPaymentsAssistant.setTransactionActionRequired();
  },
  setUserJourneyToContinue: (assistantUserJourney, isSpoken) => {
    SlangPaymentsAssistant.setUserJourneyToContinue(AssistantUserJourney.TRANSACTION, assistantUserJourney, isSpoken);
  },
  clearUserJourneyToContinue: () => {
    SlangPaymentsAssistant.clearUserJourneyToContinue();
  }
}

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

const billPaymentUserJourney = {
  notifyAppState: (appState) => {
    SlangPaymentsAssistant.notifyBillPaymentActionCompleted(appState);
  },
  setSuccess: () => {
    SlangPaymentsAssistant.setBillPaymentSuccess();
  },
  setFailure: () => {
    SlangPaymentsAssistant.setBillPaymentFailure();
  },
  setBillTypeRequired: () => {
    SlangPaymentsAssistant.setBillPaymentBillTypeRequired();
  },
  setBillTypeNotFound: () => {
    SlangPaymentsAssistant.setBillPaymentBillTypeNotFound();
  },
  setUserJourneyToContinue: (assistantUserJourney, isSpoken) => {
    SlangPaymentsAssistant.setUserJourneyToContinue(AssistantUserJourney.ORDER_MANAGEMENT, assistantUserJourney, isSpoken);
  },
  clearUserJourneyToContinue: () => {
    SlangPaymentsAssistant.clearUserJourneyToContinue();
  }
}

class PaymentsAssistantBridge {

  transactionActionHandler = (transactionInfo, transactionUserJourney) => { };
  billPaymentsActionHandler = (billInfo, billPaymentUserJourney) => { };
  navigationActionHandler = (navigationInfo, navigationUserJourney) => { };
  
  lifecycleObserver = {}

  constructor() {
    DeviceEventEmitter.addListener(
      "onTransaction",
      async (transactionInfo) => {
        try {
          const status = await this.transactionActionHandler(transactionInfo, transactionUserJourney);
          if (status != null) {
            NativeSlangPaymentsAssistant.notifyTransactionActionCompleted(status);
          }
        } catch (e) {
          console.error("Error while executing Payments action handler", e);
          NativeSlangPaymentsAssistant.notifyTransactionActionCompleted(false);
        }
      }
    );
    DeviceEventEmitter.addListener(
      "onBillPayment",
      async (billInfo) => {
        try {
          const status = await this.billPaymentsActionHandler(billInfo, billPaymentUserJourney);
          if (status != null) {
            NativeSlangPaymentsAssistant.notifyBillPaymentActionCompleted(status);
          }
        } catch (e) {
          console.error("Error while executing Payments action handler", e);
          NativeSlangPaymentsAssistant.notifyBillPaymentActionCompleted(false);
        }
      }
    );
    DeviceEventEmitter.addListener(
      "onNavigation",
      async (navigationInfo) => {
        try {
          const status = await this.navigationActionHandler(navigationInfo, navigationUserJourney);
          if (status != null) {
            NativeSlangPaymentsAssistant.notifyNavigationActionCompleted(status);
          }
        } catch (e) {
          console.error("Error while executing Payments action handler", e);
          NativeSlangPaymentsAssistant.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();
        }
      }
    });
  }

  //Initializes Slang Payments Assistant
  initialize(config) {
    if (!config) config = {};
    NativeSlangPaymentsAssistant.initialize(config);
  }

  showTrigger() {
    NativeSlangPaymentsAssistant.showTrigger();
  }

  hideTrigger() {
    NativeSlangPaymentsAssistant.hideTrigger();
  }

  expandTrigger() {
    NativeSlangPaymentsAssistant.expandTrigger();
  }

  collapseTrigger() {
    NativeSlangPaymentsAssistant.collapseTrigger();
  }

  setTriggerText(triggerText) {
    NativeSlangPaymentsAssistant.setTriggerText(triggerText);
  }

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

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

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

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

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

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

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

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

  setAppTrigger() {
    NativeSlangPaymentsAssistant.setAppTrigger();
  }

  setAction(transactionActionHandler, billPaymentsActionHandler, navigationActionHandler) {
    NativeSlangPaymentsAssistant.setAction();
    this.transactionActionHandler = transactionActionHandler;
    this.billPaymentsActionHandler = billPaymentsActionHandler;
    this.navigationActionHandler = navigationActionHandler;
  }

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

  setTriggerImageResource(image) {
    const resolvedImage = Image.resolveAssetSource(image);
    NativeSlangPaymentsAssistant.setTriggerImageResource(resolvedImage.uri);
  }

  getActiveTransactionUserJourney() {
    //This method is called to obtain the current transaction journey object in the native layer.
    NativeSlangPaymentsAssistant.prepareActiveTransactionUserJourney();
    return transactionUserJourney;
  }

  getActiveBillPaymentUserJourney() {
    //This method is called to obtain the current bill payment journey object in the native layer.
    NativeSlangPaymentsAssistant.prepareActiveBillPaymentUserJourney();
    return billPaymentUserJourney;
  }

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

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

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

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

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

  disableTransactionUserJourneyContext() {
    NativeSlangPaymentsAssistant.disableTransactionUserJourneyContext();
  }

  disableBillPaymentUserJourneyContext() {
    NativeSlangPaymentsAssistant.disableBillPaymentUserJourneyContext();
  }

  disableNavigationUserJourneyContext() {
    NativeSlangPaymentsAssistant.disableNavigationUserJourneyContext();
  }

  notifyNonVoiceTransaction(name, amount, action) {
    NativeSlangPaymentsAssistant.notifyNonVoiceTransaction(name, amount, action);
  }

}

export const SlangPaymentsAssistantBridge = new PaymentsAssistantBridge();