react-native-altibbi 0.1.0

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

@@ -0,0 +1,61 @@
+package com.altibbi;
+
+import android.opengl.GLSurfaceView;
+import android.widget.FrameLayout;
+
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.opentok.android.BaseVideoRenderer;
+import com.opentok.android.Publisher;
+
+import java.util.concurrent.ConcurrentHashMap;
+
+
+
+public class OTPublisherLayout extends FrameLayout{
+
+    public OTRN sharedState;
+
+    public OTPublisherLayout(ThemedReactContext reactContext) {
+
+        super(reactContext);
+        sharedState = OTRN.getSharedState();
+    }
+
+    public void createPublisherView(String publisherId) {
+
+        ConcurrentHashMap<String, Publisher> mPublishers = sharedState.getPublishers();
+        ConcurrentHashMap<String, String> androidOnTopMap = sharedState.getAndroidOnTopMap();
+        ConcurrentHashMap<String, String> androidZOrderMap = sharedState.getAndroidZOrderMap();
+        String pubOrSub = "";
+        String zOrder = "";
+        Publisher mPublisher = mPublishers.get(publisherId);
+        if (mPublisher != null) {
+            String sessionId = mPublisher.getSession().getSessionId();
+            if (sessionId != null) {
+                if (androidOnTopMap.get(sessionId) != null) {
+                    pubOrSub = androidOnTopMap.get(sessionId);
+                }
+                if (androidZOrderMap.get(sessionId) != null) {
+                    zOrder = androidZOrderMap.get(sessionId);
+                }
+            }
+            mPublisher.setStyle(BaseVideoRenderer.STYLE_VIDEO_SCALE,
+                    BaseVideoRenderer.STYLE_VIDEO_FILL);
+            FrameLayout mPublisherViewContainer = new FrameLayout(getContext());
+            if (pubOrSub.equals("publisher") && mPublisher.getView() instanceof GLSurfaceView) {
+                if (zOrder.equals("mediaOverlay")) {
+                    ((GLSurfaceView) mPublisher.getView()).setZOrderMediaOverlay(true);
+                } else {
+                    ((GLSurfaceView) mPublisher.getView()).setZOrderOnTop(true);
+                }
+            }
+            ConcurrentHashMap<String, FrameLayout> mPublisherViewContainers = sharedState.getPublisherViewContainers();
+            mPublisherViewContainers.put(publisherId, mPublisherViewContainer);
+            addView(mPublisherViewContainer, 0);
+            mPublisherViewContainer.addView(mPublisher.getView());
+            requestLayout();
+        }
+
+    }
+
+}

package/android/src/main/java/com/altibbi/OTPublisherViewManager.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 OTPublisherViewManager extends ViewGroupManager<OTPublisherLayout> {
+
+    @Override
+    public String getName() {
+
+        return this.getClass().getSimpleName();
+    }
+
+    @Override
+    protected OTPublisherLayout createViewInstance(ThemedReactContext reactContext) {
+
+        return new OTPublisherLayout(reactContext);
+    }
+
+    @ReactProp(name = "publisherId")
+    public void setPublisherId(OTPublisherLayout view, String publisherId) {
+
+        view.createPublisherView(publisherId);
+    }
+
+}

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

@@ -0,0 +1,101 @@
+package com.altibbi;
+
+import android.widget.FrameLayout;
+
+import com.facebook.react.bridge.Callback;
+import com.opentok.android.Connection;
+import com.opentok.android.Publisher;
+import com.opentok.android.Session;
+import com.opentok.android.Stream;
+import com.opentok.android.Subscriber;
+
+import java.util.concurrent.ConcurrentHashMap;
+
+
+public class OTRN {
+
+    public static OTRN sharedState;
+
+    private ConcurrentHashMap<String, Stream> subscriberStreams = new ConcurrentHashMap<>();
+    private ConcurrentHashMap<String, Subscriber> subscribers = new ConcurrentHashMap<>();
+    private ConcurrentHashMap<String, Publisher> publishers = new ConcurrentHashMap<>();
+    private ConcurrentHashMap<String, Session> sessions = new ConcurrentHashMap<>();
+    private ConcurrentHashMap<String, String> androidOnTopMap = new ConcurrentHashMap<>();
+    private ConcurrentHashMap<String, String> androidZOrderMap = new ConcurrentHashMap<>();
+    private ConcurrentHashMap<String, FrameLayout> subscriberViewContainers = new ConcurrentHashMap<>();
+    private ConcurrentHashMap<String, FrameLayout> publisherViewContainers = new ConcurrentHashMap<>();
+    private ConcurrentHashMap<String, Callback> publisherDestroyedCallbacks = new ConcurrentHashMap<>();
+    private ConcurrentHashMap<String, Callback> sessionConnectCallbacks = new ConcurrentHashMap<>();
+    private ConcurrentHashMap<String, Callback> sessionDisconnectCallbacks = new ConcurrentHashMap<>();
+    private ConcurrentHashMap<String, Connection> connections = new ConcurrentHashMap<>();
+
+    public static synchronized OTRN getSharedState() {
+
+        if (sharedState == null) {
+            sharedState = new OTRN();
+        }
+        return sharedState;
+    }
+
+    public ConcurrentHashMap<String, String> getAndroidOnTopMap() {
+
+        return this.androidOnTopMap;
+    }
+
+    public ConcurrentHashMap<String, String> getAndroidZOrderMap() {
+
+        return this.androidZOrderMap;
+    }
+
+    public ConcurrentHashMap<String, Stream> getSubscriberStreams() {
+
+        return this.subscriberStreams;
+    }
+
+    public ConcurrentHashMap<String, Subscriber> getSubscribers() {
+
+        return this.subscribers;
+    }
+
+    public ConcurrentHashMap<String, FrameLayout> getSubscriberViewContainers() {
+
+        return this.subscriberViewContainers;
+    }
+
+    public ConcurrentHashMap<String, Publisher> getPublishers() {
+
+        return this.publishers;
+    }
+
+    public ConcurrentHashMap<String, FrameLayout> getPublisherViewContainers() {
+
+        return this.publisherViewContainers;
+    }
+
+    public ConcurrentHashMap<String, Callback> getPublisherDestroyedCallbacks() {
+
+        return this.publisherDestroyedCallbacks;
+    }
+
+    public ConcurrentHashMap<String, Callback> getSessionConnectCallbacks() {
+
+        return this.sessionConnectCallbacks;
+    }
+
+    public ConcurrentHashMap<String, Callback> getSessionDisconnectCallbacks() {
+
+        return this.sessionDisconnectCallbacks;
+    }
+
+    public ConcurrentHashMap<String, Connection> getConnections() {
+
+        return this.connections;
+    }
+
+    public ConcurrentHashMap<String, Session> getSessions() {
+
+        return this.sessions;
+    }
+
+    private OTRN() {}
+}

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

@@ -0,0 +1,120 @@
+package com.altibbi;
+
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.os.Handler;
+import android.view.View;
+
+import com.opentok.android.BaseVideoCapturer;
+
+public class OTScreenCapturer extends BaseVideoCapturer {
+
+    private boolean capturing = false;
+    private View contentView;
+
+    private int fps = 15;
+    private int width = 20;
+    private int height = 20;
+    private int[] frame;
+
+    private Bitmap bmp;
+    private Canvas canvas;
+
+    private Handler mHandler = new Handler();
+
+    private Runnable newFrame = new Runnable() {
+        @Override
+        public void run() {
+            if (capturing) {
+                int width = contentView.getWidth();
+                int height = contentView.getHeight();
+
+                if (frame == null ||
+                        OTScreenCapturer.this.width != width ||
+                        OTScreenCapturer.this.height != height) {
+
+                    OTScreenCapturer.this.width = width;
+                    OTScreenCapturer.this.height = height;
+
+                    if (bmp != null) {
+                        bmp.recycle();
+                        bmp = null;
+                    }
+                    bmp = Bitmap.createBitmap(width,
+                            height, Bitmap.Config.ARGB_8888);
+
+                    canvas = new Canvas(bmp);
+                    frame = new int[width * height];
+                }
+                canvas.save();
+                canvas.translate(-contentView.getScrollX(), - contentView.getScrollY());
+                contentView.draw(canvas);
+
+                bmp.getPixels(frame, 0, width, 0, 0, width, height);
+
+                provideIntArrayFrame(frame, ARGB, width, height, 0, false);
+
+                canvas.restore();
+
+                mHandler.postDelayed(newFrame, 1000 / fps);
+
+            }
+        }
+    };
+
+    public OTScreenCapturer(View view) {
+        this.contentView = view;
+    }
+
+    @Override
+    public void init() {
+
+    }
+
+    @Override
+    public int startCapture() {
+        capturing = true;
+
+        mHandler.postDelayed(newFrame, 1000 / fps);
+        return 0;
+    }
+
+    @Override
+    public int stopCapture() {
+        capturing = false;
+        mHandler.removeCallbacks(newFrame);
+        return 0;
+    }
+
+    @Override
+    public boolean isCaptureStarted() {
+        return capturing;
+    }
+
+    @Override
+    public CaptureSettings getCaptureSettings() {
+
+        CaptureSettings settings = new CaptureSettings();
+        settings.fps = fps;
+        settings.width = width;
+        settings.height = height;
+        settings.format = ARGB;
+        return settings;
+    }
+
+    @Override
+    public void destroy() {
+
+    }
+
+    @Override
+    public void onPause() {
+
+    }
+
+    @Override
+    public void onResume() {
+
+    }
+
+}