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

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

import { NativeEventEmitter, NativeModules, Image } from "react-native";
const { RNSlangFitnessAssistant } = NativeModules;

const NativeSlangFitnessAssistant = RNSlangFitnessAssistant;
const SlangFitnessAssistant = RNSlangFitnessAssistant;

const DeviceEventEmitter = new NativeEventEmitter(NativeModules.RNSlangFitnessAssistant);

const checkFunc = (cb, func) => {
    if (typeof cb === "function") {
        return true;
    }
    return false;
};

const foodLoggingUserJourney = {
    notifyAppState: (values) => {
        SlangFitnessAssistant.notifyFoodLoggingActionCompleted(values[0], values[1]);
    }
}

const sugarLoggingUserJourney = {
    notifyAppState: (values) => {
        SlangFitnessAssistant.notifySugarLoggingActionCompleted(values[0], values[1]);
    }
}


const navigationUserJourney = {
}

const weightLoggingUserJourney = {
    notifyAppState: (values) => {
        SlangFitnessAssistant.notifyWeightLoggingActionCompleted(values[0], values[1]);
    }
}

class FitnessAssistantBridge {
    foodLoggingActionHandler = (foodInfo, foodLoggingUserJourney) => { };
    sugarLoggingActionHandler = (sugarInfo, sugarLoggingUserJourney) => { };
    navigationUserJourney = (navigationInfo, navigationUserJourney) => { };
    weightLoggingActionHandler = (weightInfo, weightLoggingUserJourney) => { };
    lifecycleObserver = {}

    constructor() {
        DeviceEventEmitter.addListener(
            "onFoodLog",
            async (foodInfo) => {
                try {
                    const values = await this.foodLoggingActionHandler(foodInfo, foodLoggingUserJourney);
                    if (values[0] != null) {
                        console.debug(values[0], values[1]);
                        NativeSlangFitnessAssistant.notifyFoodLoggingActionCompleted(values[0], values[1]);
                    }
                } catch (e) {
                    console.error("Error while executing Fitness action handler", e);
                    NativeSlangFitnessAssistant.notifyFoodLoggingActionCompleted("UNSUPPORTED", "");
                }
            }
        );
        DeviceEventEmitter.addListener(
            "onSugarLog",
            async (sugarInfo) => {
                try {
                    const values = await this.sugarLoggingActionHandler(sugarInfo, sugarLoggingUserJourney);
                    if (values[0] != null) {
                        console.debug(values[0], values[1]);
                        NativeSlangFitnessAssistant.notifySugarLoggingActionCompleted(values[0], values[1]);
                    }
                } catch (e) {
                    console.error("Error while executing Fitness action handler", e);
                    NativeSlangFitnessAssistant.notifySugarLoggingActionCompleted("UNSUPPORTED", "");
                }
            }
        );
        DeviceEventEmitter.addListener(
            "onNavigation",
            async (navigationInfo) => {
                try {
                    const status = await this.navigationActionHandler(navigationInfo, navigationUserJourney);
                    if (status != null) {
                        NativeSlangFitnessAssistant.notifyNavigationActionCompleted(status);
                    }
                } catch (e) {
                    console.error("Error while executing Fitness action handler", e);
                    NativeSlangFitnessAssistant.notifyNavigationActionCompleted(false);
                }
            }
        );
        DeviceEventEmitter.addListener(
            "onWeightLog",
            async (weightInfo) => {
                try {
                    const values = await this.weightLoggingActionHandler(weightInfo, weightLoggingUserJourney);
                    if (values[0] != null) {
                        console.debug(values[0], values[1]);
                        NativeSlangFitnessAssistant.notifyWeightLoggingActionCompleted(values[0], values[1]);
                    }
                } catch (e) {
                    console.error("Error while executing Fitness action handler", e);
                    NativeSlangFitnessAssistant.notifyWeightLoggingActionCompleted("UNSUPPORTED", "");
                }
            }
        );
        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();
                }
            }
        });
    }

    // General Methods 
    initialize(config) {
        if (!config) config = {};
        if (NativeSlangFitnessAssistant == null) {
            console.log("Native is null");
        } else
            NativeSlangFitnessAssistant.initialize(config);
    }

    showTrigger() {
        NativeSlangFitnessAssistant.showTrigger();
    }

    hideTrigger() {
        NativeSlangFitnessAssistant.hideTrigger();
    }

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

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

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

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

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

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

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

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

    disableLocaleSelection(disable) {
        NativeSlangFitnessAssistant.disableLocaleSelection(disable);
    }

    setWaveVelocity(velocity) {
        NativeSlangFitnessAssistant.setWaveVelocity(velocity);
    }

    setTriggerSize(width, height) {
        NativeSlangFitnessAssistant.setTriggerSize(width, height);
    }

    setAppTrigger() {
        NativeSlangFitnessAssistant.setAppTrigger();
    }

    setAction(foodLoggingActionHandler, sugarLoggingActionHandler, navigationActionHandler, weightLoggingActionHandler) {
        NativeSlangFitnessAssistant.setAction();
        this.foodLoggingActionHandler = foodLoggingActionHandler;
        this.sugarLoggingActionHandler = sugarLoggingActionHandler;
        this.navigationActionHandler = navigationActionHandler;
        this.weightLoggingActionHandler = weightLoggingActionHandler;
    }

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

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

    setUserProperties(userId, userProperties) {
        NativeSlangFitnessAssistant.setUserProperties(userId, userProperties);
    }

    trackCustomEvent(eventName, eventMetaData){
        NativeSlangFitnessAssistant.trackCustomEvent(eventName, eventMetaData);
    }

    setTriggerImageResource(image) {
        const resolvedImage = Image.resolveAssetSource(image);
        console.log(resolvedImage); 
        NativeSlangFitnessAssistant.setTriggerImageResource(resolvedImage.uri);
    }

    // Food Logging UJ context Methods
    setDisambiguationIndexInContext(index) {
        NativeSlangFitnessAssistant.setDisambiguationIndexInContext(index);
    }

    setFoodInfoAtIndexInContext(index, foodInfo) {
        NativeSlangFitnessAssistant.setFoodInfoAtIndexInContext(index, foodInfo);
    }

    // Navigation UJ context methods


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

    cancelSession() {
        NativeSlangFitnessAssistant.cancelSession();
    }

    getActiveFoodLoggingJourney() {
        //This method is called to obtain the current food logging journey object in the native layer.
        NativeSlangFitnessAssistant.prepareActiveFoodLoggingUserJourney();
        return foodLoggingUserJourney;
      }
     
      getActiveSugarLoggingJourney() {
        //This method is called to obtain the current food logging journey object in the native layer.
        NativeSlangFitnessAssistant.prepareActiveSugarLoggingUserJourney();
        return sugarLoggingUserJourney;
      }  
      getActiveWeightLoggingJourney() {
        //This method is called to obtain the current weight logging journey object in the native layer.
        NativeSlangFitnessAssistant.prepareActiveWeightLoggingUserJourney();
        return weightLoggingUserJourney;
      }
}

export const SlangFitnessAssistantBridge = new FitnessAssistantBridge();