react-native-slang/index.js

React native interface for Slang

import { NativeModules, DeviceEventEmitter } from 'react-native';
const { SlangBuddy, SlangPharmacyAssistant } = NativeModules;
const NativeSlangPharmacyAssistant = SlangPharmacyAssistant;

// RN wrapper for SlangBuddy. All the SlangBuddy integrations exposed over the native bridge are available here.
class Slang {
  // Initializes Slang
  initialize(buddyId, apiKey, config, callback) {
    SlangBuddy.initialize(buddyId, apiKey, config, callback);
    DeviceEventEmitter.addListener('slang_action', (slangIntentFromSDK) => {
      const intent = createSlangIntent(slangIntentFromSDK);
      this.intentActionHandler(intent);
    });
    DeviceEventEmitter.addListener('utterance_detected', (params) => {
      const userUtterance = params.userUtterance;
      this.onUtteranceDetected(userUtterance);
    });
    DeviceEventEmitter.addListener('utterance_unresolved', (params) => {
      const userUtterance = params.userUtterance;
      this.onUtteranceUnresolved(userUtterance);
    });
  }

  async isInitialized() {
    const isInitialized = await SlangBuddy.isInitialized();
    return Boolean(isInitialized.isInitialized);
  }

  setIntentActionHandler(actionHandler) {
    this.internalActionHandler = actionHandler;
  }

  setOnUtteranceDetected(utteranceHandler) {
    this.onUtteranceDetected = utteranceHandler;
  }

  setOnUtteranceUnresolved(utteranceHandler) {
    SlangBuddy.setOnUtteranceUnresolved();
    this.onUtteranceUnresolved = utteranceHandler;
  }

  ui = {
    show: () => {
      SlangBuddy.showUI();
    },
    hide: () => {
      SlangBuddy.hideUI();
    },
    cancel: () => {
      SlangBuddy.cancel();
    },
    setTriggerImageResource: (imageName) => {
      SlangBuddy.setTriggerImageResource(imageName);
    },
    setTriggerSize: (triggerWidth, triggerHeight) => {
      SlangBuddy.setTriggerSize(triggerWidth, triggerHeight);
    },
    setTriggerPosition: (
      definedPosition,
      offsetX,
      offsetY,
      forceStartPosition
    ) => {
      SlangBuddy.setTriggerPosition(
        definedPosition,
        offsetX,
        offsetY,
        forceStartPosition
      );
    },
    setSurfacePrimaryTextColor: (color) => {
      SlangBuddy.setSurfacePrimaryTextColor(color);
    },
    setSurfaceSecondaryTextColor: (color) => {
      SlangBuddy.setSurfaceSecondaryTextColor(color);
    },
    setSettingsButtonBackgroundColor: (color) => {
      SlangBuddy.setSettingsButtonBackgroundColor(color);
    },
    setControlButtonBackgroundColor: (color) => {
      SlangBuddy.setControlButtonBackgroundColor(color);
    },
    setUIBackgroundColorGradient: (colors) => {
      SlangBuddy.setUIBackgroundColorGradient(colors);
    },
    setUIForegroundColorGradient: (colors) => {
      SlangBuddy.setUIForegroundColorGradient(colors);
    },
    setTheme: (theme) => {
      SlangBuddy.setUITheme(theme);
    },
  };

  tts = {
    mute: () => {
      SlangBuddy.mute();
    },
    unmute: () => {
      SlangBuddy.unmute();
    },
  };

  startConversation = (welcomeStatement, isSpoken) => {
    SlangBuddy.startConversation(welcomeStatement, !!isSpoken);
  };

  notifyUser = (message) => {
    SlangBuddy.notifyUser(message);
  };

  trackAppEvent = (eventName, eventData) => {
    SlangBuddy.trackAppEvent(eventName, eventData);
  };

  setAssistanceHints = (jsHints) => {
    SlangBuddy.setAssistanceHints(jsHints);
  };

  setSpeechRecognitionHints = (hints) => {
    SlangBuddy.setSpeechRecognitionHints(hints);
  };

  intentActionHandler = async (intent) => {
    intent.overrideAffirmative = SlangBuddy.overrideAffirmative;
    try {
      const status = await this.internalActionHandler(intent);
      if (status === false) {
        SlangBuddy.notifyActionCompleted(false);
      } else {
        SlangBuddy.notifyActionCompleted(true);
      }
    } catch (e) {
      SlangBuddy.notifyActionCompleted(false);
    }
  };

  internalActionHandler = (intent) => {};
  onUtteranceDetected = (intent) => {};
  onUtteranceUnresolved = (intent) => {};
}

class PharmacyAssistantBridge {
  // Initializes Slang Pharmacy Assistant
  initialize(buddyId, apiKey, config) {
    if (!config) config = {};
    config['buddyId'] = buddyId;
    config['apiKey'] = apiKey;
    NativeSlangPharmacyAssistant.initialize(config);
    DeviceEventEmitter.addListener(
      'onPharmacyItemSearched',
      async (pharmacyItem) => {
        try {
          const status = await this.pharmacyActionHandler(pharmacyItem);
          if (status === false) {
            NativeSlangPharmacyAssistant.notifyActionCompleted(false);
          } else {
            NativeSlangPharmacyAssistant.notifyActionCompleted(true);
          }
        } catch (e) {
          console.log('Error while executing Pharmacy action handler', e);
          NativeSlangPharmacyAssistant.notifyActionCompleted(false);
        }
      }
    );
    DeviceEventEmitter.addListener('onError', (params) => {
      if (params && 'type' in params) {
        this.pharmacyErrorHandler(params['type']);
      }
    });
  }

  setActionHandler(actionHandler) {
    this.pharmacyActionHandler = actionHandler;
  }

  setErrorHandler(errorHandler) {
    this.pharmacyErrorHandler = errorHandler;
  }

  show() {
    NativeSlangPharmacyAssistant.show();
  }

  hide() {
    NativeSlangPharmacyAssistant.hide();
  }

  notifyNonVoiceSearch(pharmacyItemDetails) {
    NativeSlangPharmacyAssistant.notifyNonVoiceSearch(pharmacyItemDetails);
  }

  startSearchConversation() {
    NativeSlangPharmacyAssistant.startConversation();
  }

  setUserProperties(userId, propertiesDictionary) {
    NativeSlangPharmacyAssistant.setUserProperties(
      userId,
      propertiesDictionary
    );
  }

  setTriggerPosition(
    definedPosition,
    triggerOffsetX,
    triggerOffsetY,
    triggerForceStartingPosition
  ) {
    SlangBuddy.setTriggerPosition(
      definedPosition,
      triggerOffsetX,
      triggerOffsetY,
      triggerForceStartingPosition
    );
  }

  setTriggerDraggable(isDraggable) {
    SlangBuddy.setTriggerDraggable(isDraggable);
  }

  setTriggerSize(triggerWidth, triggerHeight) {
    SlangBuddy.setTriggerSize(triggerWidth, triggerHeight);
  }

  pharmacyActionHandler = (PharmacyItem) => {};
  pharmacyErrorHandler = (params) => {};
}

export const slangBuddy = new Slang();
export const SlangPharmacyAssistantBridge = new PharmacyAssistantBridge();