react-native-altibbi 0.1.0

package/android/src/main/java/com/altibbi/OTSubscriberLayout.java

@@ -0,0 +1,68 @@
+package com.altibbi;
+
+import android.opengl.GLSurfaceView;
+import android.view.ViewGroup;
+import android.widget.FrameLayout;
+
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.opentok.android.BaseVideoRenderer;
+import com.opentok.android.Session;
+import com.opentok.android.Subscriber;
+
+import java.util.concurrent.ConcurrentHashMap;
+
+
+
+public class OTSubscriberLayout extends FrameLayout{
+
+    public OTRN sharedState;
+
+    public OTSubscriberLayout(ThemedReactContext reactContext) {
+
+        super(reactContext);
+        sharedState = OTRN.getSharedState();
+    }
+
+    public void createSubscriberView(String streamId) {
+
+        ConcurrentHashMap<String, Subscriber> mSubscribers = sharedState.getSubscribers();
+        ConcurrentHashMap<String, String> androidOnTopMap = sharedState.getAndroidOnTopMap();
+        ConcurrentHashMap<String, String> androidZOrderMap = sharedState.getAndroidZOrderMap();
+        Subscriber mSubscriber = mSubscribers.get(streamId);
+        FrameLayout mSubscriberViewContainer = new FrameLayout(getContext());
+        String pubOrSub = "";
+        String zOrder = "";
+        if (mSubscriber != null) {
+            Session session = mSubscriber.getSession();
+            if (session != null) {
+                String sessionId = session.getSessionId();
+                if (sessionId != null) {
+                    if (androidOnTopMap.get(sessionId) != null) {
+                        pubOrSub = androidOnTopMap.get(sessionId);
+                    }
+                    if (androidZOrderMap.get(sessionId) != null) {
+                        zOrder = androidZOrderMap.get(sessionId);
+                    }
+                }
+            }
+            if (mSubscriber.getView().getParent() != null) {
+                ((ViewGroup)mSubscriber.getView().getParent()).removeView(mSubscriber.getView());
+            }
+            mSubscriber.setStyle(BaseVideoRenderer.STYLE_VIDEO_SCALE,
+                BaseVideoRenderer.STYLE_VIDEO_FILL);
+            if (pubOrSub.equals("subscriber") && mSubscriber.getView() instanceof GLSurfaceView) {
+                if (zOrder.equals("mediaOverlay")) {
+                    ((GLSurfaceView) mSubscriber.getView()).setZOrderMediaOverlay(true);
+                } else {
+                    ((GLSurfaceView) mSubscriber.getView()).setZOrderOnTop(true);
+                }
+            }
+            ConcurrentHashMap<String, FrameLayout> mSubscriberViewContainers = sharedState.getSubscriberViewContainers();
+            mSubscriberViewContainers.put(streamId, mSubscriberViewContainer);
+            addView(mSubscriberViewContainer, 0);
+            mSubscriberViewContainer.addView(mSubscriber.getView());
+            requestLayout();
+        }
+    }
+
+}

package/android/src/main/java/com/altibbi/OTSubscriberViewManager.java

@@ -0,0 +1,30 @@
+package com.altibbi;
+
+
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.ViewGroupManager;
+import com.facebook.react.uimanager.annotations.ReactProp;
+
+
+public class OTSubscriberViewManager extends ViewGroupManager<OTSubscriberLayout> {
+
+    @Override
+    public String getName() {
+
+        return this.getClass().getSimpleName();
+    }
+
+    @Override
+    protected OTSubscriberLayout createViewInstance(ThemedReactContext reactContext) {
+
+        return new OTSubscriberLayout(reactContext);
+    }
+
+    @ReactProp(name = "streamId")
+    public void setStreamId(OTSubscriberLayout view, String streamId) {
+        if (streamId != null) {
+            view.createSubscriberView(streamId);
+        }
+    }
+
+}

package/android/src/main/java/com/altibbi/Socket.kt

@@ -0,0 +1,294 @@
+package com.altibbi
+
+import android.util.Log
+import com.facebook.react.bridge.*
+import com.google.gson.Gson
+import com.pusher.client.ChannelAuthorizer
+import com.pusher.client.Pusher
+import com.pusher.client.PusherOptions
+import com.pusher.client.channel.*
+import com.pusher.client.connection.ConnectionEventListener
+import com.pusher.client.connection.ConnectionState
+import com.pusher.client.connection.ConnectionStateChange
+import com.pusher.client.util.HttpChannelAuthorizer
+import java.net.InetSocketAddress
+import java.net.Proxy
+import java.util.concurrent.Semaphore
+
+class Socket(reactContext: ReactApplicationContext) :
+  ReactContextBaseJavaModule(reactContext),
+  ConnectionEventListener, ChannelEventListener, SubscriptionEventListener,
+  PrivateChannelEventListener, PrivateEncryptedChannelEventListener, PresenceChannelEventListener,
+  ChannelAuthorizer {
+
+  private var pusher: Pusher? = null
+  private val TAG = "SocketReactNative"
+  private val authorizerMutex = mutableMapOf<String, Semaphore>()
+  private val authorizerResult = mutableMapOf<String, ReadableMap>()
+
+  private val socketEventEmitter = SocketEventEmitter(reactContext)
+
+  override fun getName(): String {
+    return "SocketReactNative"
+  }
+
+  @ReactMethod
+  fun addListener(eventName: String?) {
+
+  }
+
+  @ReactMethod
+  fun removeListeners(count: Int?) {
+
+  }
+
+  @ReactMethod
+  fun initialize(
+    arguments: ReadableMap,
+    promise:Promise
+  ){
+    try {
+      if (pusher != null) {
+        pusher!!.disconnect()
+      }
+      val options = PusherOptions()
+      if (arguments.hasKey("cluster")) options.setCluster(arguments.getString("cluster"))
+      if (arguments.hasKey("useTLS")) options.isUseTLS =
+        arguments.getBoolean("useTLS")
+      if (arguments.hasKey("activityTimeout")) options.activityTimeout =
+        arguments.getInt("activityTimeout").toLong()
+      if (arguments.hasKey("pongTimeout")) options.pongTimeout =
+        arguments.getInt("pongTimeout").toLong()
+      if (arguments.hasKey("maxReconnectionAttempts")) options.maxReconnectionAttempts =
+        arguments.getInt("maxReconnectionAttempts")
+      if (arguments.hasKey("maxReconnectGapInSeconds")) options.maxReconnectGapInSeconds =
+        arguments.getInt("maxReconnectGapInSeconds")
+      if (arguments.hasKey("authEndpoint")) options.channelAuthorizer =
+        HttpChannelAuthorizer(arguments.getString("authEndpoint"))
+      if (arguments.hasKey("authorizer") && arguments.getBoolean("authorizer")) options.channelAuthorizer =
+        this
+      if (arguments.hasKey("proxy")) {
+        val (host, port) = arguments.getString("proxy")!!.split(':')
+        options.proxy = Proxy(Proxy.Type.HTTP, InetSocketAddress(host, port.toInt()))
+      }
+      pusher = Pusher(arguments.getString("apiKey"), options)
+      Log.i(TAG, "Start $pusher")
+      promise.resolve(null)
+    }catch (e : Exception){
+      promise.reject(TAG,e.message,null)
+    }
+  }
+
+  @ReactMethod
+  fun connect(promise: Promise) {
+    pusher!!.connect(this, ConnectionState.ALL)
+    promise.resolve(null)
+  }
+
+  @ReactMethod
+  fun disconnect(promise: Promise) {
+    pusher!!.disconnect()
+    promise.resolve(null)
+  }
+
+  @ReactMethod
+  fun subscribe(channelName: String, promise: Promise) {
+    try{
+      val channel = when {
+        channelName.startsWith("private-encrypted-") -> pusher!!.subscribePrivateEncrypted(
+          channelName, this
+        )
+        channelName.startsWith("private-") -> pusher!!.subscribePrivate(channelName, this)
+        channelName.startsWith("presence-") -> pusher!!.subscribePresence(
+          channelName, this
+        )
+        else -> pusher!!.subscribe(channelName, this)
+      }
+      channel.bindGlobal(this)
+      promise.resolve(null)
+    }catch (e: Exception){
+      promise.reject("Error", "Failed to subscribe to channel: $channelName", e)
+    }
+  }
+
+  @ReactMethod
+  fun unsubscribe(channelName: String, promise: Promise) {
+    pusher!!.unsubscribe(channelName)
+    promise.resolve(null)
+  }
+
+  @ReactMethod
+  fun trigger(channelName: String, eventName: String, data: String, promise: Promise) {
+    try {
+      when {
+        channelName.startsWith("private-encrypted-") -> throw Exception("It's not currently possible to send a message using private encrypted channels.")
+        channelName.startsWith("private-") -> pusher!!.getPrivateChannel(channelName)
+          .trigger(eventName, data)
+        channelName.startsWith("presence-") -> pusher!!.getPresenceChannel(channelName)
+          .trigger(eventName, data)
+        else -> throw Exception("Messages can only be sent to private and presence channels.")
+      }
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.reject(e)
+    }
+  }
+
+  @ReactMethod
+  fun getSocketId(promise: Promise) {
+    val socketId = pusher!!.connection.socketId
+    promise.resolve(socketId)
+  }
+
+
+  override fun authorize(channelName: String, socketId: String): String? {
+    socketEventEmitter.emit(
+      "onAuthorizer", mapOf(
+        "channelName" to channelName,
+        "socketId" to socketId
+      )
+    )
+    val key = channelName + socketId
+    authorizerMutex[key] = Semaphore(0)
+    authorizerMutex[key]!!.acquire()
+    val authParams = authorizerResult.remove(key)!!
+    val gson = Gson()
+    return gson.toJson(authParams.toHashMap())
+  }
+
+  @ReactMethod
+  fun onAuthorizer(channelName: String, socketId: String, data: ReadableMap, promise: Promise) {
+    val key = channelName + socketId
+    authorizerResult[key] = data
+    authorizerMutex[key]!!.release()
+    authorizerMutex.remove(key)
+    promise.resolve(null)
+  }
+
+
+  override fun onConnectionStateChange(change: ConnectionStateChange?) {
+    socketEventEmitter.emit("onConnectionStateChange",  mapOf(
+      "previousState" to change?.previousState.toString(),
+      "currentState" to change?.currentState.toString()
+    ))
+  }
+
+  override fun onError(message: String?, code: String?, e: Exception?) {
+    socketEventEmitter.emit(
+      "onError", mapOf(
+        "message" to message,
+        "code" to code,
+        "error" to e.toString()
+      )
+    )
+  }
+
+  override fun onError(message: String, e: Exception) {
+    onError(message, "", e)
+  }
+
+  override fun onEvent(event: PusherEvent) {
+    // The java sdk transforms some events from pusher_internal
+    // to pusher:... events, we translate them back.
+    val finalEvent = if (event.eventName === "pusher:subscription_count") {
+      PusherEvent(
+        "pusher_internal:subscription_count",
+        event.channelName,
+        event.userId,
+        event.data)
+    } else {
+      event
+    }
+    socketEventEmitter.emit(
+      "onEvent", mapOf(
+        "channelName" to finalEvent.channelName,
+        "eventName" to finalEvent.eventName,
+        "userId" to finalEvent.userId,
+        "data" to finalEvent.data
+      )
+    )
+  }
+
+  override fun onSubscriptionSucceeded(channelName: String) {
+    // For presence channels we wait for the onUsersInformationReceived event.
+    if (!channelName.startsWith("presence-")) {
+      socketEventEmitter.emit(
+        "onEvent", mapOf(
+          "channelName" to channelName,
+          "eventName" to "pusher_internal:subscription_succeeded",
+          "data" to emptyMap<String, String>()
+        )
+      )
+    }
+  }
+
+  override fun onAuthenticationFailure(message: String, e: Exception) {
+    socketEventEmitter.emit(
+      "onSubscriptionError", mapOf(
+        "message" to message,
+        "error" to e.toString()
+      )
+    )
+  }
+
+  override fun onUsersInformationReceived(channelName: String?, users: MutableSet<User>?) {
+    val gson = Gson()
+    val channel = pusher!!.getPresenceChannel(channelName)
+    val hash = mutableMapOf<String, Any?>()
+    // convert users back to original structure.
+    for (user in users!!) {
+      hash[user.id] = gson.fromJson(user.info, Map::class.java)
+    }
+    val data = mapOf(
+      "presence" to mapOf(
+        "count" to users.size,
+        "ids" to users.map { it.id },
+        "hash" to hash
+      )
+    )
+    socketEventEmitter.emit(
+      "onEvent", mapOf(
+        "channelName" to channelName,
+        "eventName" to "pusher_internal:subscription_succeeded",
+        "userId" to channel.me.id,
+        "data" to data
+      )
+    )
+  }
+
+  override fun userSubscribed(channelName: String, user: User) {
+    val gson = Gson()
+    socketEventEmitter.emit(
+      "onMemberAdded", mapOf(
+        "channelName" to channelName,
+        "user" to mapOf(
+          "userId" to user.id,
+          "userInfo" to gson.fromJson(user.info, Map::class.java)
+        )
+      )
+    )
+  }
+
+  override fun userUnsubscribed(channelName: String, user: User) {
+    val gson = Gson()
+    socketEventEmitter.emit(
+      "onMemberRemoved", mapOf(
+        "channelName" to channelName,
+        "user" to mapOf(
+          "userId" to user.id,
+          "userInfo" to gson.fromJson(user.info, Map::class.java)
+        )
+      )
+    )
+  }
+
+  override fun onDecryptionFailure(event: String?, reason: String?) {
+    socketEventEmitter.emit(
+      "onDecryptionFailure", mapOf(
+        "event" to event,
+        "reason" to reason
+      )
+    )
+  }
+
+}

package/android/src/main/java/com/altibbi/SocketEventEmitter.kt

@@ -0,0 +1,25 @@
+package com.altibbi
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.modules.core.DeviceEventManagerModule
+
+class SocketEventEmitter (private val context: ReactApplicationContext) {
+
+  companion object {
+    private const val EVENT_PREFIX = "SocketReactNative"
+  }
+
+  fun emit(eventName: String, params: Any?) {
+    val jsModule = this.context.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+    val socketEventName = "${EVENT_PREFIX}:${eventName}"
+
+    if (params is Map<*, *>) {
+      jsModule.emit(socketEventName, Arguments.makeNativeMap(params as Map<String, Any>))
+    }
+
+    if (params is String) {
+      jsModule.emit(socketEventName, params)
+    }
+  }
+}

package/android/src/main/java/com/altibbi/utils/EventUtils.java

@@ -0,0 +1,189 @@
+package com.altibbi.utils;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.opentok.android.Connection;
+import com.opentok.android.MediaUtils;
+import com.opentok.android.OpentokError;
+import com.opentok.android.PublisherKit;
+import com.opentok.android.Session;
+import com.opentok.android.Stream;
+import com.opentok.android.SubscriberKit;
+
+public final class EventUtils {
+
+    public static WritableMap prepareJSConnectionMap(Connection connection) {
+
+        WritableMap connectionInfo = Arguments.createMap();
+        if (connection != null) {
+            connectionInfo.putString("connectionId", connection.getConnectionId());
+            connectionInfo.putString("creationTime", connection.getCreationTime().toString());
+            connectionInfo.putString("data", connection.getData());
+        }
+        return connectionInfo;
+    }
+
+    public static WritableMap prepareJSStreamMap(Stream stream, Session session) {
+
+        WritableMap streamInfo = Arguments.createMap();
+        if (stream != null) {
+            streamInfo.putString("streamId", stream.getStreamId());
+            streamInfo.putInt("height", stream.getVideoHeight());
+            streamInfo.putInt("width", stream.getVideoWidth());
+            streamInfo.putString("creationTime", stream.getCreationTime().toString());
+            streamInfo.putString("connectionId", stream.getConnection().getConnectionId());
+            streamInfo.putString("sessionId", session.getSessionId());
+            streamInfo.putMap("connection", prepareJSConnectionMap(stream.getConnection()));
+            streamInfo.putString("name", stream.getName());
+            streamInfo.putBoolean("hasAudio", stream.hasAudio());
+            streamInfo.putBoolean("hasVideo", stream.hasVideo());
+            if (stream.getStreamVideoType().equals(Stream.StreamVideoType.StreamVideoTypeScreen)) {
+                streamInfo.putString("videoType", "screen");
+            } else {
+                streamInfo.putString("videoType", "camera");
+            }
+        }
+        return streamInfo;
+    }
+
+    public static WritableMap prepareJSErrorMap(OpentokError error) {
+
+        WritableMap errorInfo = Arguments.createMap();
+        errorInfo.putString("message", error.getMessage());
+        errorInfo.putString("code", error.getErrorCode().toString());
+        return errorInfo;
+    }
+
+    public static WritableMap prepareJSSessionMap(Session session) {
+
+        WritableMap sessionInfo = Arguments.createMap();
+        sessionInfo.putString("sessionId", session.getSessionId());
+        if (session.getConnection() != null) {
+            WritableMap connectionInfo = prepareJSConnectionMap(session.getConnection());
+            sessionInfo.putMap("connection", connectionInfo);
+        }
+        return sessionInfo;
+    }
+
+    public static WritableMap prepareStreamPropertyChangedEventData(String changedProperty, String oldValue, String newValue, Stream stream, Session session) {
+
+        WritableMap streamPropertyEventData = Arguments.createMap();
+        streamPropertyEventData.putString("changedProperty", changedProperty);
+        streamPropertyEventData.putString("oldValue", oldValue);
+        streamPropertyEventData.putString("newValue", newValue);
+        streamPropertyEventData.putMap("stream", prepareJSStreamMap(stream, session));
+        return streamPropertyEventData;
+    }
+
+    public static WritableMap prepareStreamPropertyChangedEventData(String changedProperty, WritableMap oldValue, WritableMap newValue, Stream stream, Session session) {
+
+        WritableMap streamPropertyEventData = Arguments.createMap();
+        streamPropertyEventData.putString("changedProperty", changedProperty);
+        streamPropertyEventData.putMap("oldValue", oldValue);
+        streamPropertyEventData.putMap("newValue", newValue);
+        streamPropertyEventData.putMap("stream", prepareJSStreamMap(stream, session));
+        return streamPropertyEventData;
+    }
+
+    public static WritableMap prepareStreamPropertyChangedEventData(String changedProperty, Boolean oldValue, Boolean newValue, Stream stream, Session session) {
+
+        WritableMap streamPropertyEventData = Arguments.createMap();
+        streamPropertyEventData.putString("changedProperty", changedProperty);
+        streamPropertyEventData.putBoolean("oldValue", oldValue);
+        streamPropertyEventData.putBoolean("newValue", newValue);
+        streamPropertyEventData.putMap("stream", prepareJSStreamMap(stream, session));
+        return streamPropertyEventData;
+    }
+
+    public static WritableMap prepareAudioNetworkStats(SubscriberKit.SubscriberAudioStats stats) {
+
+        WritableMap audioStats = Arguments.createMap();
+        audioStats.putInt("audioPacketsLost", stats.audioPacketsLost);
+        audioStats.putInt("audioBytesReceived", stats.audioBytesReceived);
+        audioStats.putInt("audioPacketsReceived", stats.audioPacketsReceived);
+        audioStats.putDouble("timestamp", stats.timeStamp);
+        return audioStats;
+    }
+
+    public static WritableMap prepareVideoNetworkStats(SubscriberKit.SubscriberVideoStats stats) {
+
+        WritableMap videoStats = Arguments.createMap();
+        videoStats.putInt("videoPacketsLost", stats.videoPacketsLost);
+        videoStats.putInt("videoBytesReceived", stats.videoBytesReceived);
+        videoStats.putInt("videoPacketsReceived", stats.videoPacketsReceived);
+        videoStats.putDouble("timestamp", stats.timeStamp);
+        return videoStats;
+    }
+
+    public static WritableArray preparePublisherRtcStats(PublisherKit.PublisherRtcStats[] stats) {
+        WritableArray statsArrayMap = Arguments.createArray();
+        for (PublisherKit.PublisherRtcStats stat : stats) {
+          WritableMap statMap = Arguments.createMap();
+          statMap.putString("connectionId", stat.connectionId);
+          statMap.putString("jsonArrayOfReports", stat.jsonArrayOfReports);
+          statsArrayMap.pushMap(statMap);
+        }
+        return statsArrayMap;
+    }
+
+    public static WritableArray preparePublisherAudioStats(PublisherKit.PublisherAudioStats[] stats) {
+        WritableArray statsArrayMap = Arguments.createArray();
+        for (PublisherKit.PublisherAudioStats stat : stats) {
+          WritableMap audioStats = Arguments.createMap();
+          audioStats.putString("connectionId", stat.connectionId);
+          audioStats.putString("subscriberId", stat.subscriberId);
+          audioStats.putDouble("audioBytesSent", stat.audioBytesSent);
+          audioStats.putDouble("audioPacketsLost", stat.audioPacketsLost);
+          audioStats.putDouble("audioPacketsSent", stat.audioPacketsSent);
+          audioStats.putDouble("startTime", stat.startTime);
+          statsArrayMap.pushMap(audioStats);
+        }
+        return statsArrayMap;
+    }
+
+    public static WritableArray preparePublisherVideoStats(PublisherKit.PublisherVideoStats[] stats) {
+        WritableArray statsArrayMap = Arguments.createArray();
+        for (PublisherKit.PublisherVideoStats stat : stats) {
+          WritableMap videoStats = Arguments.createMap();
+          videoStats.putString("connectionId", stat.connectionId);
+          videoStats.putString("subscriberId", stat.subscriberId);
+          videoStats.putDouble("videoBytesSent", stat.videoBytesSent);
+          videoStats.putDouble("videoPacketsLost", stat.videoPacketsLost);
+          videoStats.putDouble("videoPacketsSent", stat.videoPacketsSent);
+          videoStats.putDouble("startTime", stat.startTime);
+          statsArrayMap.pushMap(videoStats);
+        }
+        return statsArrayMap;
+    }
+
+    public static WritableMap prepareMediaCodecsMap(MediaUtils.SupportedCodecs supportedCodecs) {
+        WritableMap codecsMap = Arguments.createMap();
+        WritableArray videoDecoderCodecsArray = Arguments.createArray();
+        WritableArray videoEncoderCodecsArray = Arguments.createArray();
+        for (MediaUtils.VideoCodecType decoderCodec : supportedCodecs.videoDecoderCodecs ) {
+            if (decoderCodec.equals(MediaUtils.VideoCodecType.VIDEO_CODEC_H264)) {
+                videoDecoderCodecsArray.pushString("H.264");
+            } else {
+                videoDecoderCodecsArray.pushString("VP8");
+            }
+        }
+        for (MediaUtils.VideoCodecType encoderCodec : supportedCodecs.videoEncoderCodecs ) {
+            if (encoderCodec.equals(MediaUtils.VideoCodecType.VIDEO_CODEC_H264)) {
+                videoEncoderCodecsArray.pushString("H.264");
+            } else {
+                videoEncoderCodecsArray.pushString("VP8");
+            }
+        }
+        codecsMap.putArray("videoDecoderCodecs", videoDecoderCodecsArray);
+        codecsMap.putArray("videoEncoderCodecs", videoEncoderCodecsArray);
+        return codecsMap;
+    }
+
+    public static WritableMap createError(String message) {
+
+        WritableMap errorInfo = Arguments.createMap();
+        errorInfo.putString("message", message);
+        return errorInfo;
+    }
+}