react-native-altibbi 0.1.0

package/src/video/helpers/OTSessionHelper.js

@@ -0,0 +1,233 @@
+import { Platform } from 'react-native';
+import { reassignEvents } from './OTHelper';
+import { handleSignalError, handleError } from '../OTError';
+import {
+  each,
+  isNull,
+  isEmpty,
+  isString,
+  isBoolean,
+  isObject,
+  isArray
+} from 'underscore';
+
+const validateString = (value) => (isString(value) ? value : '');
+
+const validateBoolean = (value) => (isBoolean(value) ? value : false);
+
+const validateObject = (value) => (isObject(value) ? value : {});
+
+const validateArray = (value) => (isArray(value) ? value : []);
+
+const sanitizeSessionEvents = (sessionId, events) => {
+  if (typeof events !== 'object') {
+    return {};
+  }
+  const customEvents = {
+    ios: {
+      streamCreated: 'streamCreated',
+      streamDestroyed: 'streamDestroyed',
+      sessionConnected: 'sessionDidConnect',
+      sessionDisconnected: 'sessionDidDisconnect',
+      signal: 'signal',
+      connectionCreated: 'connectionCreated',
+      connectionDestroyed: 'connectionDestroyed',
+      error: 'didFailWithError',
+      sessionReconnected: 'sessionDidReconnect',
+      sessionReconnecting: 'sessionDidBeginReconnecting',
+      archiveStarted: 'archiveStartedWithId',
+      archiveStopped: 'archiveStoppedWithId',
+      streamPropertyChanged: 'streamPropertyChanged',
+      muteForced: 'muteForced',
+    },
+    android: {
+      streamCreated: 'onStreamReceived',
+      streamDestroyed: 'onStreamDropped',
+      sessionConnected: 'onConnected',
+      sessionDisconnected: 'onDisconnected',
+      signal: 'onSignalReceived',
+      connectionCreated: 'onConnectionCreated',
+      connectionDestroyed: 'onConnectionDestroyed',
+      error: 'onError',
+      sessionReconnected: 'onReconnected',
+      sessionReconnecting: 'onReconnecting',
+      archiveStarted: 'onArchiveStarted',
+      archiveStopped: 'onArchiveStopped',
+      streamPropertyChanged: 'onStreamPropertyChanged',
+      muteForced: 'onMuteForced',
+    }
+  };
+  return reassignEvents('session', customEvents, events, sessionId);
+};
+
+const sanitizeCustomTurnOptions = (options) => {
+  let sessionOptions = {};
+  if (typeof options !== 'object') {
+    return {};
+  }
+  const validCustomTurnOptions = {
+    includeServers: 'string',
+    transportPolicy: 'string',
+    customServers: 'Array'
+  };
+
+  const customTurnOptions = {
+    includeServers: 'all',
+    transportPolicy: 'all',
+    customServers: []
+  };
+
+  each(options, (value, key) => {
+    const optionType = validCustomTurnOptions[key];
+    if (optionType !== undefined) {
+      if (optionType === 'string') {
+        sessionOptions[key] = validateString(value);
+      } else if (optionType === 'Array') {
+        sessionOptions[key] = validateArray(value);
+      }
+    } else {
+      handleError(`${key} is not a valid option`);
+    }
+  });
+  return sessionOptions;
+};
+
+const sanitizeSessionOptions = (options) => {
+  const platform = Platform.OS;
+  let sessionOptions;
+
+  if (platform === 'android') {
+    sessionOptions = {
+      connectionEventsSuppressed: false,
+      ipWhitelist: false,
+      iceConfig: {},
+      proxyUrl: '',
+      useTextureViews: false,
+      enableStereoOutput: false,
+      androidOnTop: '', // 'publisher' || 'subscriber'
+      androidZOrder: '', // 'mediaOverlay' || 'onTop'
+    };
+  } else {
+    sessionOptions = {
+      connectionEventsSuppressed: false,
+      ipWhitelist: false,
+      iceConfig: {},
+      proxyUrl: '',
+      enableStereoOutput: false,
+    };
+  }
+
+  if (typeof options !== 'object') {
+    return sessionOptions;
+  }
+
+  const validSessionOptions = {
+    ios: {
+      connectionEventsSuppressed: 'boolean',
+      ipWhitelist: 'boolean',
+      iceConfig: 'object',
+      proxyUrl: 'string',
+      enableStereoOutput: 'boolean',
+    },
+    android: {
+      connectionEventsSuppressed: 'boolean',
+      useTextureViews: 'boolean',
+      androidOnTop: 'string',
+      androidZOrder: 'string',
+      ipWhitelist: 'boolean',
+      iceConfig: 'object',
+      proxyUrl: 'string',
+      enableStereoOutput: 'boolean',
+    },
+  };
+
+  each(options, (value, key) => {
+    const optionType = validSessionOptions[platform][key];
+    if (optionType !== undefined) {
+      if (optionType === 'boolean') {
+        sessionOptions[key] = validateBoolean(value);
+      } else if (optionType === 'string') {
+        sessionOptions[key] = validateString(value);
+      } else if (optionType === 'object') {
+        sessionOptions[key] = validateObject(value);
+      }
+    } else {
+      handleError(`${key} is not a valid option`);
+    }
+  });
+
+  if (sessionOptions.iceConfig) {
+    const customTurnOptions = sanitizeCustomTurnOptions(
+      sessionOptions.iceConfig
+    );
+    each(customTurnOptions, (value, key) => {
+      sessionOptions[key] = customTurnOptions[key];
+    });
+  }
+  return sessionOptions;
+};
+
+const sanitizeSignalData = (signal) => {
+  if (typeof signal !== 'object') {
+    return {
+      signal: {
+        type: '',
+        data: '',
+        to: ''
+      },
+      errorHandler: handleSignalError
+    };
+  }
+  return {
+    signal: {
+      type: validateString(signal.type),
+      data: validateString(signal.data),
+      to: validateString(signal.to)
+    },
+    errorHandler:
+      typeof signal.errorHandler !== 'function'
+        ? handleSignalError
+        : signal.errorHandler,
+  };
+};
+
+const sanitizeCredentials = (credentials) => {
+  const _credentials = {};
+  each(credentials, (value, key) => {
+    if (!isString(value) || isEmpty(value) || isNull(value)) {
+      handleError(`Please add the ${key}`);
+    } else {
+      _credentials[key] = value;
+    }
+  });
+  return _credentials;
+};
+
+const getConnectionStatus = (connectionStatus) => {
+  switch (connectionStatus) {
+    case 0:
+      return 'not connected';
+    case 1:
+      return 'connected';
+    case 2:
+      return 'connecting';
+    case 3:
+      return 'reconnecting';
+    case 4:
+      return 'disconnecting';
+    case 5:
+      return 'failed';
+  }
+};
+
+const isConnected = (connectionStatus) =>
+  getConnectionStatus(connectionStatus) === 'connected';
+
+export {
+  sanitizeSessionEvents,
+  sanitizeSessionOptions,
+  sanitizeSignalData,
+  sanitizeCredentials,
+  getConnectionStatus,
+  isConnected
+};

package/src/video/helpers/OTSubscriberHelper.js

@@ -0,0 +1,125 @@
+import { sanitizeBooleanProperty, reassignEvents } from './OTHelper';
+
+/**
+ * This is the smallest positive int value for 2 bytes. Using Number.MAX_SAFE_INTEGER at JS level,
+ * could drive to problems when coverted to the native layer (Android & iOS).
+ * Since `32767` is a very high value for resolution and frame rate for all use case,
+ * we won't have any problem for the foreseeable future
+ */
+const MAX_SAFE_INTEGER = 32767;
+
+const sanitizeSubscriberEvents = (events) => {
+  if (typeof events !== 'object') {
+    return {};
+  }
+  const customEvents = {
+    ios: {
+      connected: 'subscriberDidConnect',
+      disconnected: 'subscriberDidDisconnect',
+      reconnected: 'subscriberDidReconnect',
+      error: 'didFailWithError',
+      audioNetworkStats: 'audioNetworkStatsUpdated',
+      videoNetworkStats: 'videoNetworkStatsUpdated',
+      audioLevel: 'audioLevelUpdated',
+      rtcStatsReport: 'rtcStatsReport',
+      videoDisabled: 'subscriberVideoDisabled',
+      videoEnabled: 'subscriberVideoEnabled',
+      videoDisableWarning: 'subscriberVideoDisableWarning',
+      videoDisableWarningLifted: 'subscriberVideoDisableWarningLifted',
+      videoDataReceived: 'subscriberVideoDataReceived',
+      captionReceived: 'subscriberCaptionReceived:',
+    },
+    android: {
+      connected: 'onConnected',
+      disconnected: 'onDisconnected',
+      reconnected: 'onReconnected',
+      error: 'onError',
+      audioNetworkStats: 'onAudioStats',
+      rtcStatsReport: 'onRtcStatsReport',
+      videoNetworkStats: 'onVideoStats',
+      audioLevel: 'onAudioLevelUpdated',
+      videoDisabled: 'onVideoDisabled',
+      videoEnabled: 'onVideoEnabled',
+      videoDisableWarning: 'onVideoDisableWarning',
+      videoDisableWarningLifted: 'onVideoDisableWarningLifted',
+      videoDataReceived: 'onVideoDataReceived',
+      captionReceived: 'onCaptionText',
+    },
+  };
+  return reassignEvents('subscriber', customEvents, events);
+};
+
+const sanitizeResolution = (resolution) => {
+  if ((typeof resolution !== 'object') || (resolution &&
+    resolution.width === void 0 &&
+    resolution.height === void 0) ||
+    (resolution === null)) {
+    return { width: MAX_SAFE_INTEGER, height: MAX_SAFE_INTEGER };
+  }
+  const videoDimensions = {};
+  if (resolution && resolution.height) {
+    if (isNaN(parseInt(resolution.height, 10))) {
+      videoDimensions.height = void 0;
+    }
+
+    videoDimensions.height = parseInt(resolution.height, 10);
+  } else {
+    videoDimensions.height = void 0;
+  }
+  if (resolution && resolution.width) {
+    if (isNaN(parseInt(resolution.width, 10))) {
+      videoDimensions.width = void 0;
+    }
+
+    videoDimensions.width = parseInt(resolution.width, 10);
+  } else {
+    videoDimensions.width = void 0;
+  }
+  return videoDimensions;
+};
+
+const sanitizeFrameRate = (frameRate) => {
+  switch (frameRate) {
+    case null:
+      return MAX_SAFE_INTEGER;
+    case 1:
+      return 1;
+    case 7:
+      return 7;
+    case 15:
+      return 15;
+    default:
+      return 30;
+  }
+};
+
+const sanitizeAudioVolume = audioVolume => (typeof audioVolume === 'number') ? audioVolume : 100;
+
+const sanitizeProperties = (properties) => {
+  if (typeof properties !== 'object') {
+    return {
+      subscribeToAudio: true,
+      subscribeToVideo: true,
+      subscribeToCaptions: false,
+      preferredResolution: sanitizeResolution(null),
+      preferredFrameRate: sanitizeFrameRate(null),
+      audioVolume: 100,
+    };
+  }
+  return {
+    subscribeToAudio: sanitizeBooleanProperty(properties.subscribeToAudio),
+    subscribeToVideo: sanitizeBooleanProperty(properties.subscribeToVideo),
+    subscribeToCaptions: sanitizeBooleanProperty(properties.subscribeToCaptions),
+    preferredResolution: sanitizeResolution(properties.preferredResolution),
+    preferredFrameRate: sanitizeFrameRate(properties.preferredFrameRate),
+    audioVolume: sanitizeAudioVolume(properties.audioVolume),
+  };
+};
+
+export {
+  sanitizeSubscriberEvents,
+  sanitizeProperties,
+  sanitizeFrameRate,
+  sanitizeResolution,
+  sanitizeAudioVolume
+};

package/src/video/index.js

@@ -0,0 +1,13 @@
+import OTSession from './OTSession';
+import OTPublisher from './OTPublisher';
+import OTSubscriber from './OTSubscriber';
+import OTSubscriberView from './views/OTSubscriberView';
+import { OT } from './OT';
+
+export {
+  OTSession,
+  OTPublisher,
+  OTSubscriber,
+  OTSubscriberView,
+  OT,
+};

package/src/video/views/OTPublisherView.js

@@ -0,0 +1,19 @@
+import React, { Component } from 'react';
+import { PropTypes } from 'prop-types';
+import { requireNativeComponent, Platform, View } from 'react-native';
+
+class OTPublisherView extends Component {
+  render() {
+    return <ReactPublisher {...this.props} />;
+  }
+}
+const viewPropTypes = View.propTypes;
+OTPublisherView.propTypes = {
+  publisherId: PropTypes.string.isRequired,
+  sessionId: PropTypes.string.isRequired,
+  ...viewPropTypes,
+};
+
+const publisherName = Platform.OS === 'ios' ? 'OTPublisherSwift' : 'OTPublisherViewManager';
+const ReactPublisher = requireNativeComponent(publisherName, OTPublisherView);
+export default OTPublisherView;

package/src/video/views/OTSubscriberView.js

@@ -0,0 +1,18 @@
+import React, { Component } from 'react';
+import { PropTypes } from 'prop-types';
+import { requireNativeComponent, Platform, View } from 'react-native';
+
+class OTSubscriberView extends Component {
+  render() {
+    return <ReactSubscriber {...this.props} />;
+  }
+}
+const viewPropTypes = View.propTypes;
+OTSubscriberView.propTypes = {
+  streamId: PropTypes.string.isRequired,
+  ...viewPropTypes,
+};
+
+const subscriberName = Platform.OS === 'ios' ? 'OTSubscriberSwift' : 'OTSubscriberViewManager';
+const ReactSubscriber = requireNativeComponent(subscriberName, OTSubscriberView);
+export default OTSubscriberView;