react-native-altibbi 0.1.0

package/src/scoket.ts

@@ -0,0 +1,365 @@
+import { NativeModules, NativeEventEmitter, Platform } from 'react-native';
+
+const LINKING_ERROR =
+  `The package 'react-native-altibbi' doesn't seem to be linked. Make sure: \n\n` +
+  Platform.select({ ios: "- You have run 'pod install'\n", default: '' }) +
+  '- You rebuilt the app after installing the package\n' +
+  '- You are not using Expo managed workflow\n';
+
+const SocketReactNative = NativeModules.SocketReactNative
+  ? NativeModules.SocketReactNative
+  : new Proxy(
+      {},
+      {
+        get() {
+          throw new Error(LINKING_ERROR);
+        },
+      }
+    );
+
+enum SocketEventName {
+  ON_AUTHORIZER = 'SocketReactNative:onAuthorizer',
+  ON_CONNECTION_STATE_CHANGE = 'SocketReactNative:onConnectionStateChange',
+  ON_SUBSCRIPTION_ERROR = 'SocketReactNative:onSubscriptionError',
+  ON_EVENT = 'SocketReactNative:onEvent',
+  ON_ERROR = 'SocketReactNative:onError',
+  ON_MEMBER_ADDED = 'SocketReactNative:onMemberAdded',
+  ON_MEMBER_REMOVED = 'SocketReactNative:onMemberRemoved',
+}
+
+export interface TBISocketAuthorizerResult {
+  /** required for private channels */
+  auth?: string;
+  /** required for encrypted channels */
+  shared_secret?: string;
+  /** required for presence channels, should be stringified JSON */
+  channel_data?: string;
+}
+
+export class TBISocketEvent {
+  channelName: string;
+  eventName: string;
+  data: any;
+  userId?: string;
+  constructor(args: {
+    channelName: string;
+    eventName: string;
+    data: any;
+    userId?: string;
+  }) {
+    this.channelName = args.channelName;
+    this.eventName = args.eventName;
+    this.data = args.data;
+    this.userId = args.userId;
+  }
+  toString() {
+    return `{ channelName: ${this.channelName}, eventName: ${this.eventName}, data: ${this.data}, userId: ${this.userId} }`;
+  }
+}
+
+export class TBISocketMember {
+  userId: string;
+  userInfo: any;
+  constructor(userId: string, userInfo: any) {
+    this.userId = userId;
+    this.userInfo = userInfo;
+  }
+
+  toString() {
+    return `{ userId: ${this.userId}, userInfo: ${JSON.stringify(
+      this.userInfo
+    )} }`;
+  }
+}
+
+export class TBISocketChannel {
+  channelName: string;
+  members = new Map<String, TBISocketMember>();
+  me?: TBISocketMember;
+  subscriptionCount?: Number;
+  onSubscriptionSucceeded?: (data: any) => void;
+  onSubscriptionCount?: (subscriptionCount: Number) => void;
+  onEvent?: (event: any) => void;
+  onMemberAdded?: (member: TBISocketMember) => void;
+  onMemberRemoved?: (member: TBISocketMember) => void;
+  constructor(args: {
+    channelName: string;
+    onSubscriptionSucceeded?: (data: any) => void;
+    onSubscriptionCount?: (subscriptionCount: Number) => void;
+    onEvent?: (member: TBISocketEvent) => void;
+    onMemberAdded?: (member: TBISocketMember) => void;
+    onMemberRemoved?: (member: TBISocketMember) => void;
+    me?: TBISocketMember;
+  }) {
+    this.channelName = args.channelName;
+    this.onSubscriptionSucceeded = args.onSubscriptionSucceeded;
+    this.onEvent = args.onEvent;
+    this.onMemberAdded = args.onMemberAdded;
+    this.onMemberRemoved = args.onMemberRemoved;
+    this.onSubscriptionCount = args.onSubscriptionCount;
+    this.me = args.me;
+  }
+
+  async unsubscribe() {
+    return TBISocket.getInstance().unsubscribe({
+      channelName: this.channelName,
+    });
+  }
+
+  async trigger(event: TBISocketEvent) {
+    if (event.channelName !== this.channelName) {
+      throw 'Event is not for this channel';
+    }
+    return TBISocket.getInstance().trigger(event);
+  }
+}
+
+export class TBISocket {
+  private static instance: TBISocket;
+  private socketEventEmitter = new NativeEventEmitter(SocketReactNative);
+  public channels = new Map<String, TBISocketChannel>();
+  public connectionState = 'DISCONNECTED';
+
+  private constructor() {}
+
+  static getInstance(): TBISocket {
+    if (!TBISocket.instance) {
+      TBISocket.instance = new TBISocket();
+    }
+    return TBISocket.instance;
+  }
+
+  private addListener(
+    socketEventName: SocketEventName,
+    callback: (event: any) => void
+  ) {
+    return this.socketEventEmitter.addListener(socketEventName, callback);
+  }
+
+  public init(args: {
+    apiKey: string;
+    cluster: string;
+    authEndpoint?: string;
+    useTLS?: boolean;
+    activityTimeout?: Number;
+    pongTimeout?: Number;
+    maxReconnectionAttempts?: Number;
+    maxReconnectGapInSeconds?: Number;
+    authorizerTimeoutInSeconds?: Number;
+    proxy?: string;
+    onConnectionStateChange?: (
+      currentState: string,
+      previousState: string
+    ) => void;
+    onAuthorizer?: (
+      channelName: string,
+      socketId: string
+    ) => Promise<TBISocketAuthorizerResult>;
+    onError?: (message: string, code: Number, e: any) => void;
+    onEvent?: (event: TBISocketEvent) => void;
+    onSubscriptionSucceeded?: (channelName: string, data: any) => void;
+    onSubscriptionError?: (
+      channelName: string,
+      message: string,
+      e: any
+    ) => void;
+    onSubscriptionCount?: (
+      channelName: string,
+      subscriptionCount: Number
+    ) => void;
+    onDecryptionFailure?: (eventName: string, reason: string) => void;
+    onMemberAdded?: (channelName: string, member: TBISocketMember) => void;
+    onMemberRemoved?: (channelName: string, member: TBISocketMember) => void;
+  }) {
+    this.removeAllListeners();
+
+    this.addListener(
+      SocketEventName.ON_CONNECTION_STATE_CHANGE,
+      (event: any) => {
+        this.connectionState = event.currentState.toUpperCase();
+        args.onConnectionStateChange?.(
+          event.currentState.toUpperCase(),
+          event.previousState.toUpperCase()
+        );
+      }
+    );
+
+    this.addListener(SocketEventName.ON_ERROR, (event: any) =>
+      args.onError?.(event.message, event.code, event.error)
+    );
+
+    this.addListener(SocketEventName.ON_EVENT, (event: any) => {
+      const channelName = event.channelName;
+      const eventName = event.eventName;
+      const data = event.data;
+      const userId = event.userId;
+      const channel = this.channels.get(channelName);
+
+      switch (eventName) {
+        case 'socket_internal:subscription_succeeded':
+          // Depending on the platform implementation we get json or a Map.
+          var decodedData = data instanceof Object ? data : JSON.parse(data);
+          for (const _userId in decodedData?.presence?.hash) {
+            const userInfo = decodedData?.presence?.hash[_userId];
+            var member = new TBISocketMember(_userId, userInfo);
+            channel?.members.set(member.userId, member);
+            if (_userId === userId && channel) {
+              channel.me = member;
+            }
+          }
+          args.onSubscriptionSucceeded?.(channelName, decodedData);
+          channel?.onSubscriptionSucceeded?.(decodedData);
+          break;
+        case 'socket_internal:subscription_count':
+          // Depending on the platform implementation we get json or a Map.
+          var decodedData = data instanceof Object ? data : JSON.parse(data);
+          if (channel) {
+            channel.subscriptionCount = decodedData.subscription_count;
+          }
+          args.onSubscriptionCount?.(
+            channelName,
+            decodedData.subscription_count
+          );
+          channel?.onSubscriptionCount?.(decodedData.subscription_count);
+          break;
+        default:
+          const socketEvent = new TBISocketEvent(event);
+          args.onEvent?.(socketEvent);
+          channel?.onEvent?.(socketEvent);
+          break;
+      }
+    });
+
+    this.addListener(SocketEventName.ON_MEMBER_ADDED, (event) => {
+      const user = event.user;
+      const channelName = event.channelName;
+      var member = new TBISocketMember(user.userId, user.userInfo);
+      const channel = this.channels.get(channelName);
+      channel?.members.set(member.userId, member);
+      args.onMemberAdded?.(channelName, member);
+      channel?.onMemberAdded?.(member);
+    });
+
+    this.addListener(SocketEventName.ON_MEMBER_REMOVED, (event) => {
+      const user = event.user;
+      const channelName = event.channelName;
+      var member = new TBISocketMember(user.userId, user.userInfo);
+      const channel = this.channels.get(channelName);
+      channel?.members.delete(member.userId);
+      args.onMemberRemoved?.(channelName, member);
+      channel?.onMemberRemoved?.(member);
+    });
+
+    this.addListener(
+      SocketEventName.ON_AUTHORIZER,
+      async ({ channelName, socketId }) => {
+        const data = await args.onAuthorizer?.(channelName, socketId);
+        if (data) {
+          await SocketReactNative.onAuthorizer(channelName, socketId, data);
+        }
+      }
+    );
+
+    this.addListener(
+      SocketEventName.ON_SUBSCRIPTION_ERROR,
+      async ({ channelName, message, type }) => {
+        args.onSubscriptionError?.(channelName, message, type);
+      }
+    );
+
+    return SocketReactNative.initialize({
+      apiKey: args.apiKey,
+      cluster: args.cluster,
+      authEndpoint: args.authEndpoint,
+      useTLS: args.useTLS,
+      activityTimeout: args.activityTimeout,
+      pongTimeout: args.pongTimeout,
+      maxReconnectionAttempts: args.maxReconnectionAttempts,
+      maxReconnectGapInSeconds: args.maxReconnectGapInSeconds,
+      authorizerTimeoutInSeconds: args.authorizerTimeoutInSeconds,
+      authorizer: args.onAuthorizer ? true : false,
+      proxy: args.proxy,
+    });
+  }
+
+  public async connect() {
+    return await SocketReactNative.connect();
+  }
+
+  public async disconnect() {
+    return await SocketReactNative.disconnect();
+  }
+
+  private unsubscribeAllChannels() {
+    const channelsCopy = new Map(this.channels);
+    channelsCopy.forEach((channel) => {
+      this.unsubscribe({ channelName: channel.channelName });
+    });
+  }
+
+  private removeAllListeners() {
+    this.socketEventEmitter.removeAllListeners(SocketEventName.ON_AUTHORIZER);
+    this.socketEventEmitter.removeAllListeners(SocketEventName.ON_ERROR);
+    this.socketEventEmitter.removeAllListeners(SocketEventName.ON_EVENT);
+    this.socketEventEmitter.removeAllListeners(SocketEventName.ON_MEMBER_ADDED);
+    this.socketEventEmitter.removeAllListeners(
+      SocketEventName.ON_MEMBER_REMOVED
+    );
+  }
+
+  public async reset() {
+    this.removeAllListeners();
+    this.unsubscribeAllChannels();
+  }
+
+  async subscribe(args: {
+    channelName: string;
+    onSubscriptionSucceeded?: (data: any) => void;
+    onSubscriptionError?: (
+      channelName: string,
+      message: string,
+      e: any
+    ) => void;
+    onMemberAdded?: (member: TBISocketMember) => void;
+    onMemberRemoved?: (member: TBISocketMember) => void;
+    onEvent?: (event: TBISocketEvent) => void;
+  }) {
+    const channel = this.channels.get(args.channelName);
+    if (channel) {
+      return channel;
+    }
+
+    const newChannel = new TBISocketChannel(args);
+    await SocketReactNative.subscribe(args.channelName);
+    this.channels.set(args.channelName, newChannel);
+    return newChannel;
+  }
+
+  public async unsubscribe({ channelName }: { channelName: string }) {
+    await SocketReactNative.unsubscribe(channelName);
+    this.channels.delete(channelName);
+  }
+
+  public async trigger(event: TBISocketEvent) {
+    if (
+      event.channelName.startsWith('private-') ||
+      event.channelName.startsWith('presence-')
+    ) {
+      await SocketReactNative.trigger(
+        event.channelName,
+        event.eventName,
+        event.data
+      );
+    } else {
+      throw 'Trigger event is only for private/presence channels';
+    }
+  }
+
+  public async getSocketId() {
+    return await SocketReactNative.getSocketId();
+  }
+
+  public getChannel(channelName: string): TBISocketChannel | undefined {
+    return this.channels.get(channelName);
+  }
+}

package/src/service.ts

@@ -0,0 +1,20 @@
+interface ConstantObject {
+  domain: string;
+  language: string;
+  token: string;
+}
+
+export let TBIConstants: ConstantObject = {
+  domain: '',
+  language: 'ar',
+  token: '',
+};
+
+export const init = (domain: string, language: string, token: string) => {
+  console.log("init", domain, language, token);
+  TBIConstants = {
+    domain,
+    language,
+    token,
+  };
+};

package/src/types.ts

@@ -0,0 +1,22 @@
+export type MediumType = 'chat' | 'gsm' | 'voip' | 'video';
+export type BloodType = 'A+' | 'B+' | 'AB+' | 'O+' | 'A-' | 'B-' | 'AB-' | 'O-';
+export type MaritalStatus = 'single' | 'married' | 'divorced' | 'widow';
+export type BoolString = 'yes' | 'no';
+export type GenderType = 'male' | 'female';
+export interface UserType {
+  name?: string;
+  phoneNumber?: string;
+  email?: string;
+  dateOfBirth?: string;
+  gender?: GenderType;
+  insuranceId?: string;
+  policyNumber?: string;
+  nationalityNumber?: string;
+  height?: string;
+  weight?: string;
+  bloodType?: BloodType;
+  smoker?: BoolString;
+  alcoholic?: BoolString;
+  maritalStatus?: MaritalStatus;
+}
+

package/src/video/OT.js

@@ -0,0 +1,65 @@
+import { NativeModules, NativeEventEmitter, PermissionsAndroid } from 'react-native';
+import { each } from 'underscore';
+
+const OT = NativeModules.OTSessionManager;
+const nativeEvents = new NativeEventEmitter(OT);
+
+const checkAndroidPermissions = () => new Promise((resolve, reject) => {
+  PermissionsAndroid.requestMultiple([
+    PermissionsAndroid.PERMISSIONS.CAMERA,
+    PermissionsAndroid.PERMISSIONS.RECORD_AUDIO])
+    .then((result) => {
+      const permissionsError = {};
+      permissionsError.permissionsDenied = [];
+      each(result, (permissionValue, permissionType) => {
+        // Check if the permission is denied or set to 'never_ask_again'.
+        if (permissionValue === 'denied' || permissionValue === 'never_ask_again' ) {
+          permissionsError.permissionsDenied.push(permissionType);
+          permissionsError.type = 'Permissions error';
+        }
+      });
+      if (permissionsError.permissionsDenied.length > 0) {
+        reject(permissionsError);
+      } else {
+        resolve();
+      }
+    })
+    .catch((error) => {
+      reject(error);
+    });
+});
+
+const setNativeEvents = (events) => {
+  const eventNames = Object.keys(events);
+  OT.setNativeEvents(eventNames);
+
+  let hasRegisteredEvents;
+  if (nativeEvents.listeners) {
+    const allEvents = nativeEvents.listeners();
+    hasRegisteredEvents = (eventType) => allEvents.includes(eventType);
+  } else {
+    hasRegisteredEvents = (eventType) => nativeEvents.listenerCount(eventType) > 0;
+  }
+
+  each(events, (eventHandler, eventType) => {
+    if (!hasRegisteredEvents(eventType)) {
+      nativeEvents.addListener(eventType, eventHandler);
+    }
+  });
+};
+
+const removeNativeEvents = (events) => {
+  const eventNames = Object.keys(events);
+  OT.removeNativeEvents(eventNames);
+  each(events, (_eventHandler, eventType) => {
+    nativeEvents.removeAllListeners(eventType);
+  });
+};
+
+export {
+  OT,
+  nativeEvents,
+  checkAndroidPermissions,
+  setNativeEvents,
+  removeNativeEvents,
+};

package/src/video/OTError.js

@@ -0,0 +1,14 @@
+const handleError = (error) => {
+  console.log('OTRN JS: There was an error: ', error);
+};
+
+const handleSignalError = (error) => {
+  if (error) {
+    console.log(`OTRN JS: There was an error sending the signal ${error}`);
+  }
+};
+
+export {
+  handleError,
+  handleSignalError,
+};

package/src/video/OTPublisher.js

@@ -0,0 +1,193 @@
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+import { View, Platform } from 'react-native';
+import { isNull } from 'underscore';
+import {
+  checkAndroidPermissions,
+  OT,
+  removeNativeEvents,
+  nativeEvents,
+  setNativeEvents,
+} from './OT';
+import {
+  sanitizeProperties,
+  sanitizePublisherEvents,
+} from './helpers/OTPublisherHelper';
+import OTPublisherView from './views/OTPublisherView';
+import { getOtrnErrorEventHandler } from './helpers/OTHelper';
+import { isConnected } from './helpers/OTSessionHelper';
+import OTContext from './contexts/OTContext';
+const uuid = require('uuid/v4');
+
+class OTPublisher extends Component {
+  constructor(props, context) {
+    super(props, context);
+    this.state = {
+      initError: null,
+      publisher: null,
+      publisherId: uuid(),
+    };
+    this.initComponent();
+  }
+  initComponent = () => {
+    this.componentEvents = {
+      sessionConnected:
+        Platform.OS === 'android'
+          ? 'session:onConnected'
+          : 'session:sessionDidConnect',
+    };
+    this.componentEventsArray = Object.values(this.componentEvents);
+    this.otrnEventHandler = getOtrnErrorEventHandler(this.props.eventHandlers);
+    this.publisherEvents = sanitizePublisherEvents(
+      this.state.publisherId,
+      this.props.eventHandlers
+    );
+    setNativeEvents(this.publisherEvents);
+    OT.setJSComponentEvents(this.componentEventsArray);
+    if (this.context.sessionId) {
+      this.sessionConnected = nativeEvents.addListener(
+        `${this.context.sessionId}:${this.componentEvents.sessionConnected}`,
+        () => this.sessionConnectedHandler()
+      );
+    }
+  };
+  componentDidMount() {
+    this.createPublisher();
+  }
+  componentDidUpdate(previousProps) {
+    const useDefault = (value, defaultValue) =>
+      value === undefined ? defaultValue : value;
+    const shouldUpdate = (key, defaultValue) => {
+      const previous = useDefault(previousProps.properties[key], defaultValue);
+      const current = useDefault(this.props.properties[key], defaultValue);
+      return previous !== current;
+    };
+
+    const updatePublisherProperty = (key, defaultValue) => {
+      if (shouldUpdate(key, defaultValue)) {
+        const value = useDefault(this.props.properties[key], defaultValue);
+        if (key === 'cameraPosition') {
+          OT.changeCameraPosition(this.state.publisherId, value);
+        } else if (key === 'videoContentHint') {
+          OT.changeVideoContentHint(this.state.publisherId, value);
+        } else {
+          OT[key](this.state.publisherId, value);
+        }
+      }
+    };
+
+    updatePublisherProperty('publishAudio', true);
+    updatePublisherProperty('publishVideo', true);
+    updatePublisherProperty('publishCaptions', false);
+    updatePublisherProperty('cameraPosition', 'front');
+    updatePublisherProperty('videoContentHint', '');
+  }
+  componentWillUnmount() {
+    OT.destroyPublisher(this.state.publisherId, (error) => {
+      if (error) {
+        this.otrnEventHandler(error);
+      } else {
+        this.sessionConnected.remove();
+        OT.removeJSComponentEvents(this.componentEventsArray);
+        removeNativeEvents(this.publisherEvents);
+      }
+    });
+  }
+  sessionConnectedHandler = () => {
+    if (isNull(this.state.publisher) && isNull(this.state.initError)) {
+      this.publish();
+    }
+  };
+  createPublisher() {
+    if (Platform.OS === 'android') {
+      checkAndroidPermissions()
+        .then(() => {
+          this.initPublisher();
+        })
+        .catch((error) => {
+          this.otrnEventHandler(error);
+        });
+    } else {
+      this.initPublisher();
+    }
+  }
+  initPublisher() {
+    const publisherProperties = sanitizeProperties(this.props.properties);
+    OT.initPublisher(
+      this.state.publisherId,
+      publisherProperties,
+      (initError) => {
+        if (initError) {
+          this.setState({
+            initError,
+          });
+          this.otrnEventHandler(initError);
+        } else {
+          if (this.context.sessionId) {
+            OT.getSessionInfo(this.context.sessionId, (session) => {
+              if (
+                !isNull(session) &&
+                isNull(this.state.publisher) &&
+                isConnected(session.connectionStatus)
+              ) {
+                this.publish();
+              }
+            });
+          }
+        }
+      }
+    );
+  }
+  publish() {
+    OT.publish(
+      this.context.sessionId,
+      this.state.publisherId,
+      (publishError) => {
+        if (publishError) {
+          this.otrnEventHandler(publishError);
+        } else {
+          this.setState({
+            publisher: true,
+          });
+        }
+      }
+    );
+  }
+  getRtcStatsReport() {
+    OT.getRtcStatsReport(this.state.publisherId);
+  }
+
+  setVideoTransformers(videoTransformers) {
+    OT.setVideoTransformers(this.state.publisherId, videoTransformers);
+  }
+
+  render() {
+    const { publisher, publisherId } = this.state;
+    const { sessionId } = this.context;
+    if (publisher && publisherId) {
+      return (
+        <OTPublisherView
+          publisherId={publisherId}
+          sessionId={sessionId}
+          {...this.props}
+        />
+      );
+    }
+    return <View />;
+  }
+}
+const viewPropTypes = View.propTypes;
+OTPublisher.propTypes = {
+  ...viewPropTypes,
+  properties: PropTypes.object, // eslint-disable-line react/forbid-prop-types
+  eventHandlers: PropTypes.object, // eslint-disable-line react/forbid-prop-types
+  getRtcStatsReport: PropTypes.object, // eslint-disable-line react/forbid-prop-types
+  setVideoTransformers: PropTypes.func, // eslint-disable-line react/forbid-prop-types
+};
+OTPublisher.defaultProps = {
+  properties: {},
+  eventHandlers: {},
+  getRtcStatsReport: {},
+};
+OTPublisher.contextType = OTContext;
+export default OTPublisher;