@cloudflare/realtimekit-react-native 0.0.0 → 0.0.1

package/android/src/main/java/com/reactnativecore/incallmanager/InCallProximityManager.java

@@ -0,0 +1,162 @@
+/*
+ * Copyright (c) 2017 Henry Lin @zxcpoiu
+ * 
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+package com.reactnativecore.incallmanager;
+
+import android.content.Context;
+import android.hardware.Sensor;
+import android.hardware.SensorManager;
+import android.os.PowerManager;
+import android.os.PowerManager.WakeLock;
+import android.util.Log;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.Runnable;
+
+import com.facebook.react.bridge.UiThreadUtil;
+
+import com.reactnativecore.incallmanager.AppRTCProximitySensor;
+
+public class InCallProximityManager {
+    private static final String TAG = "dytesdk:InCallProximity";
+
+    private WakeLock mProximityLock = null;
+    private Method mPowerManagerRelease;
+    private boolean proximitySupported = false;
+    private AppRTCProximitySensor proximitySensor = null;
+
+    /** Construction */
+    static InCallProximityManager create(Context context, final InCallManagerModule inCallManager) {
+        return new InCallProximityManager(context, inCallManager);
+    }
+
+    private InCallProximityManager(Context context, final InCallManagerModule inCallManager) {
+        // Log.d(TAG, "InCallProximityManager");
+        checkProximitySupport(context);
+        if (proximitySupported) {
+            UiThreadUtil.runOnUiThread(() -> {
+                proximitySensor = AppRTCProximitySensor.create(context, () -> {
+                    inCallManager.onProximitySensorChangedState(proximitySensor.sensorReportsNearState());               
+                });
+            });
+        }
+    }
+
+    private void checkProximitySupport(Context context) {
+        SensorManager sensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
+        if (sensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY) == null) {
+            proximitySupported = false;
+            return;
+        }
+
+        PowerManager powerManager = (PowerManager) context.getSystemService(Context.POWER_SERVICE);
+
+        proximitySupported = true;
+
+        // --- Check if PROXIMITY_SCREEN_OFF_WAKE_LOCK is implemented.
+        try {
+            boolean _proximitySupported = false;
+            Field field = PowerManager.class.getDeclaredField("PROXIMITY_SCREEN_OFF_WAKE_LOCK");
+            int proximityScreenOffWakeLock = (Integer) field.get(null);
+
+            if (android.os.Build.VERSION.SDK_INT < 17) {
+                Method method = powerManager.getClass().getDeclaredMethod("getSupportedWakeLockFlags");
+                int powerManagerSupportedFlags = (Integer) method.invoke(powerManager);
+                _proximitySupported = ((powerManagerSupportedFlags & proximityScreenOffWakeLock) != 0x0);
+            } else {
+                // --- android 4.2+
+                Method method = powerManager.getClass().getDeclaredMethod("isWakeLockLevelSupported", int.class);
+                _proximitySupported = (Boolean) method.invoke(powerManager, proximityScreenOffWakeLock);
+            }
+
+            if (_proximitySupported) {
+                mProximityLock = powerManager.newWakeLock(proximityScreenOffWakeLock, TAG);
+                mProximityLock.setReferenceCounted(false);
+            }
+        } catch (Exception e) {
+            // Log.d(TAG, "Failed to get proximity screen locker. exception: ", e);
+        }
+
+        if (mProximityLock != null) {
+            // Log.d(TAG, "use native screen locker...");
+            try {
+                mPowerManagerRelease = mProximityLock.getClass().getDeclaredMethod("release", int.class);
+            } catch (Exception e) {
+                // Log.d(TAG, "failed to get proximity screen locker: `release()`. exception: ", e);
+            }
+        } else {
+            // Log.d(TAG, "fallback to old school screen locker...");
+        }
+    }
+
+    public boolean start() {
+        if (!proximitySupported) {
+            return false;
+        }
+        UiThreadUtil.runOnUiThread(() -> {
+            proximitySensor.start();
+        });
+        return true;
+    }
+
+    public void stop() {
+        UiThreadUtil.runOnUiThread(() -> {
+            proximitySensor.stop();
+        });
+    }
+
+    public boolean isProximitySupported() {
+        return proximitySupported;
+    }
+
+    public boolean isProximityWakeLockSupported() {
+        return mProximityLock != null;
+    }
+
+    public boolean getProximityIsNear() {
+        return (proximitySupported) ? proximitySensor.sensorReportsNearState() : false;
+    }
+
+    public void acquireProximityWakeLock() {
+        if (!isProximityWakeLockSupported()) {
+            return;
+        }
+        synchronized (mProximityLock) {
+            if (!mProximityLock.isHeld()) {
+                // Log.d(TAG, "acquireProximityWakeLock()");
+                mProximityLock.acquire();
+            }
+        }
+    }
+
+    public void releaseProximityWakeLock(final boolean waitForNoProximity) {
+        if (!isProximityWakeLockSupported()) {
+            return;
+        }
+        synchronized (mProximityLock) {
+            if (mProximityLock.isHeld()) {
+                try {
+                    int flags = waitForNoProximity ? PowerManager.RELEASE_FLAG_WAIT_FOR_NO_PROXIMITY : 0;
+                    mPowerManagerRelease.invoke(mProximityLock, flags);
+                    // Log.d(TAG, "releaseProximityWakeLock()");
+                } catch (Exception e) {
+                    // Log.e(TAG, "failed to release proximity lock. e: ", e);
+                }
+            }
+        }
+    }
+}

package/android/src/main/java/com/reactnativecore/incallmanager/InCallWakeLockUtils.java

@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) 2017 Henry Lin @zxcpoiu
+ * 
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+package com.reactnativecore.incallmanager;
+
+import android.content.Context;
+import android.os.PowerManager;
+import android.os.PowerManager.WakeLock;
+import android.util.Log;
+
+public class InCallWakeLockUtils {
+    private static final String TAG = "dytesdk:InCallWakeLock";
+
+    private PowerManager mPowerManager;
+
+    private WakeLock mFullLock = null;
+    private WakeLock mPokeFullLock = null;
+    private WakeLock mPartialLock = null;
+
+
+    public InCallWakeLockUtils(Context context) {
+        mPowerManager = (PowerManager) context.getSystemService(Context.POWER_SERVICE);
+
+        mFullLock = mPowerManager.newWakeLock(PowerManager.FULL_WAKE_LOCK | PowerManager.ACQUIRE_CAUSES_WAKEUP | PowerManager.ON_AFTER_RELEASE, TAG);
+        mFullLock.setReferenceCounted(false);
+
+        mPartialLock = mPowerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, TAG);
+        mPartialLock.setReferenceCounted(false);
+
+        mPokeFullLock = mPowerManager.newWakeLock(PowerManager.FULL_WAKE_LOCK | PowerManager.ACQUIRE_CAUSES_WAKEUP | PowerManager.ON_AFTER_RELEASE, TAG);
+        mPokeFullLock.setReferenceCounted(false);
+    }
+
+    private boolean _acquireWakeLock(WakeLock lock) {
+        return _acquireWakeLock(lock, 0);
+    }
+
+    private boolean _acquireWakeLock(WakeLock lock, long timeout) {
+        synchronized (lock) {
+            if (!lock.isHeld()) {
+                if (timeout > 0) {
+                    lock.acquire(timeout);
+                } else {
+                    lock.acquire();
+                }
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private boolean _releaseWakeLock(WakeLock lock) {
+        synchronized (lock) {
+            if (lock.isHeld()) {
+                lock.release();
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public boolean acquireFullWakeLock() {
+        boolean sta = _acquireWakeLock(mFullLock);
+        // Log.d(TAG, "acquireFullWakeLock(). sta=" + sta);
+        return sta;
+    }
+
+    public boolean releaseFullWakeLock() {
+        boolean sta = _releaseWakeLock(mFullLock);
+        // Log.d(TAG, "releaseFullWakeLock(). sta=" + sta);
+        return sta;
+    }
+
+    public boolean acquirePokeFullWakeLock() {
+        boolean sta = _acquireWakeLock(mPokeFullLock);
+        // Log.d(TAG, "acquirePokeFullWakeLock(). sta=" + sta);
+        return sta;
+    }
+
+    public boolean releasePokeFullWakeLock() {
+        boolean sta = _releaseWakeLock(mPokeFullLock);
+        // Log.d(TAG, "releasePokeFullWakeLock(). sta=" + sta);
+        return sta;
+    }
+
+    public boolean acquirePartialWakeLock() {
+        boolean sta = _acquireWakeLock(mPartialLock);
+        // Log.d(TAG, "acquirePartialWakeLock(). sta=" + sta);
+        return sta;
+    }
+
+    public boolean releasePartialWakeLock() {
+        boolean sta = _releaseWakeLock(mPartialLock);
+        // Log.d(TAG, "releasePartialWakeLock(). sta=" + sta);
+        return sta;
+    }
+
+    public boolean acquirePokeFullWakeLockReleaseAfter(long timeout) {
+        boolean sta = _acquireWakeLock(mPokeFullLock, timeout);
+        // Log.d(TAG, String.format("acquirePokeFullWakeLockReleaseAfter() timeout=%s, sta=%s", timeout, sta));
+        return sta;
+    }
+}

package/android/src/main/java/com/reactnativecore/incallmanager/ThreadUtils.java

@@ -0,0 +1,39 @@
+/*
+ *  Copyright 2015 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+package com.reactnativecore.incallmanager;
+import android.os.Looper;
+import androidx.annotation.Nullable;
+public class ThreadUtils {
+  /**
+   * Utility class to be used for checking that a method is called on the correct thread.
+   */
+  public static class ThreadChecker {
+    @Nullable private Thread thread = Thread.currentThread();
+    public void checkIsOnValidThread() {
+      if (thread == null) {
+        thread = Thread.currentThread();
+      }
+      if (Thread.currentThread() != thread) {
+        throw new IllegalStateException("Wrong thread");
+      }
+    }
+    public void detachThread() {
+      thread = null;
+    }
+  }
+  /**
+   * Throws exception if called from other than main thread.
+   */
+  public static void checkIsOnMainThread() {
+    if (Thread.currentThread() != Looper.getMainLooper().getThread()) {
+      throw new IllegalStateException("Not on main thread!");
+    }
+  }
+}

package/app.plugin.js

@@ -0,0 +1 @@
+module.exports = require('./plugin/build/withDyte');

package/ios/BroadcastEventEmitter.h

@@ -0,0 +1,11 @@
+#import <React/RCTBridgeModule.h>
+#if __has_include(<React/RCTEventEmitter.h>)
+#import <React/RCTEventEmitter.h>
+#else
+#import "RCTEventEmitter.h"
+#endif
+
+
+@interface BroadcastEventEmitter : RCTEventEmitter <RCTBridgeModule>
+
+@end

package/ios/BroadcastEventEmitter.m

@@ -0,0 +1,72 @@
+#import "BroadcastEventEmitter.h"
+#import <React/RCTLog.h>
+
+// Define the notification names
+NSString *const BroadcastStartedNotification = @"iOS_BroadcastStarted";
+NSString *const BroadcastStoppedNotification = @"iOS_BroadcastStopped";
+
+@implementation BroadcastEventEmitter
+
+RCT_EXPORT_MODULE();
+
+- (instancetype)init {
+    self = [super init];
+    if (self) {
+        // Listen for the broadcast started notification
+        CFNotificationCenterAddObserver(
+            CFNotificationCenterGetDarwinNotifyCenter(),
+            (__bridge const void *)(self),
+            broadcastEventCallback,
+            (__bridge CFStringRef)BroadcastStartedNotification,
+            NULL,
+            CFNotificationSuspensionBehaviorDeliverImmediately
+        );
+
+        // Listen for the broadcast stopped notification
+        CFNotificationCenterAddObserver(
+            CFNotificationCenterGetDarwinNotifyCenter(),
+            (__bridge const void *)(self),
+            broadcastEventCallback,
+            (__bridge CFStringRef)BroadcastStoppedNotification,
+            NULL,
+            CFNotificationSuspensionBehaviorDeliverImmediately
+        );
+    }
+    return self;
+}
+
+// Callback for Darwin notifications
+void broadcastEventCallback(CFNotificationCenterRef center,
+                            void *observer,
+                            CFNotificationName name,
+                            const void *object,
+                            CFDictionaryRef userInfo) {
+    BroadcastEventEmitter *eventEmitter = (__bridge BroadcastEventEmitter *)observer;
+    [eventEmitter handleNotification:name];
+}
+
+// Handle incoming notifications and send events to React Native
+- (void)handleNotification:(CFNotificationName)name {
+    NSString *eventName = (__bridge NSString *)name;
+    [self sendEventWithName:eventName body:nil];
+}
+
+// Declare the supported event names
+- (NSArray<NSString *> *)supportedEvents {
+    return @[BroadcastStartedNotification, BroadcastStoppedNotification];
+}
+
+// Ensure setup happens on the main queue
++ (BOOL)requiresMainQueueSetup {
+    return YES;
+}
+
+// Remove observers on deallocation
+- (void)dealloc {
+    CFNotificationCenterRemoveEveryObserver(
+        CFNotificationCenterGetDarwinNotifyCenter(),
+        (__bridge const void *)(self)
+    );
+}
+
+@end

package/ios/Core.h

@@ -0,0 +1,5 @@
+#import <React/RCTBridgeModule.h>
+
+@interface Core : NSObject <RCTBridgeModule>
+-(NSString*)getRandomBase64:(NSUInteger)byteLength;
+@end

package/ios/Core.m

@@ -0,0 +1,28 @@
+#import "Core.h"
+
+@implementation Core
+
+RCT_EXPORT_MODULE()
+
+// Example method
+// See // https://reactnative.dev/docs/native-modules-ios
+RCT_REMAP_METHOD(multiply,
+                 multiplyWithA:(nonnull NSNumber*)a withB:(nonnull NSNumber*)b
+                 withResolver:(RCTPromiseResolveBlock)resolve
+                 withRejecter:(RCTPromiseRejectBlock)reject)
+{
+  NSNumber *result = @([a floatValue] * [b floatValue]);
+
+  resolve(result);
+}
+
+RCT_EXPORT_SYNCHRONOUS_TYPED_METHOD(NSString*, getRandomBase64:(NSUInteger)byteLength) {
+    NSMutableData *data = [NSMutableData dataWithLength:byteLength];
+    int result = SecRandomCopyBytes(kSecRandomDefault, byteLength, data.mutableBytes);
+    if (result != errSecSuccess) {
+        @throw([NSException exceptionWithName:@"NO_RANDOM_BYTES" reason:@"Failed to aquire secure random bytes" userInfo:nil]);
+    }
+    return [data base64EncodedStringWithOptions:0];
+}
+
+@end