shakebug-react-native 1.0.14

package/android/build.gradle

@@ -0,0 +1,235 @@
+// android/build.gradle
+
+// based on:
+//
+// * https://github.com/facebook/react-native/blob/0.60-stable/template/android/build.gradle
+//   previous location:
+//   - https://github.com/facebook/react-native/blob/0.58-stable/local-cli/templates/HelloWorld/android/build.gradle
+//
+// * https://github.com/facebook/react-native/blob/0.60-stable/template/android/app/build.gradle
+//   previous location:
+//   - https://github.com/facebook/react-native/blob/0.58-stable/local-cli/templates/HelloWorld/android/app/build.gradle
+
+// These defaults should reflect the SDK versions used by
+// the minimum React Native version supported.
+def DEFAULT_COMPILE_SDK_VERSION = 34
+def DEFAULT_BUILD_TOOLS_VERSION = '34.0.0'
+def DEFAULT_MIN_SDK_VERSION = 24
+def DEFAULT_TARGET_SDK_VERSION = 34
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+
+import java.nio.file.Paths
+
+apply plugin: "com.android.library"
+
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: "com.facebook.react"
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["AwesomeLibrary_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["AwesomeLibrary_" + name]).toInteger()
+}
+
+
+def supportsNamespace() {
+  def parsed = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')
+  def major = parsed[0].toInteger()
+  def minor = parsed[1].toInteger()
+
+  // Namespace support was added in 7.3.0
+  return (major == 7 && minor >= 3) || major >= 8
+}
+
+static def safePackageName(String packageName) {
+  packageName.replace("-lts", "")
+}
+
+def safePackageVersion(String packageName) {
+  def version = project.properties['ffmpegKit.android.main.version']
+  def ltsVersion = project.properties['ffmpegKit.android.lts.version']
+
+  // try to get ffmpegKitPackageVersion if possible
+  safeExtGet("ffmpegKitPackageVersion", packageName.contains("-lts") ? ltsVersion + ".LTS" : version)
+}
+
+
+
+buildscript {
+    // The Android Gradle plugin is only required when opening the android folder stand-alone.
+    // This avoids unnecessary downloads and potential conflicts when the library is included as a
+    // module dependency in an application project.
+    // ref: https://docs.gradle.org/current/userguide/tutorial_using_tasks.html#sec:build_script_external_dependencies
+      ext {
+        ffmpegKitPackage = "min"
+        ext.kotlin_version = '1.4.10'
+
+    }
+
+    if (project == rootProject) {
+        repositories {
+            google()
+        }
+        dependencies {
+            // This should reflect the Gradle plugin version used by
+            // the minimum React Native version supported.
+            classpath 'com.android.tools.build:gradle:3.4.1'
+            classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:1.4.10"
+        }
+    }
+}
+
+
+android {
+
+      if (supportsNamespace()) {
+    namespace "com.shakebug"
+
+    sourceSets {
+      main {
+        manifest.srcFile 'src/main/AndroidManifest.xml'
+
+        if (isNewArchitectureEnabled()) {
+              java.srcDirs += ["src/newarch",
+                              "${project.buildDir}/generated/source/codegen/java"]
+          } else {
+              java.srcDirs += ["src/oldarch"]
+          }
+      }
+    }
+  }
+
+    compileSdkVersion safeExtGet('compileSdkVersion', DEFAULT_COMPILE_SDK_VERSION)
+    buildToolsVersion safeExtGet('buildToolsVersion', DEFAULT_BUILD_TOOLS_VERSION)
+    defaultConfig {
+        minSdkVersion safeExtGet('minSdkVersion', DEFAULT_MIN_SDK_VERSION)
+        targetSdkVersion safeExtGet('targetSdkVersion', DEFAULT_TARGET_SDK_VERSION)
+        versionCode 1
+        versionName "1.0"
+    }
+
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+    lintOptions {
+        abortOnError false
+        disable "GradleCompatible"
+    }
+}
+
+repositories {
+    // ref: https://www.baeldung.com/maven-local-repository
+    mavenLocal()
+    maven {
+        // All of React Native (JS, Obj-C sources, Android binaries) is installed from npm
+        url "$rootDir/../node_modules/react-native/android"
+    }
+    maven {
+        // Android JSC is installed from npm
+        url "$rootDir/../node_modules/jsc-android/dist"
+    }
+    google()
+}
+
+dependencies {
+    //noinspection GradleDynamicVersion
+    implementation "com.github.HBiSoft:HBRecorder:3.0.3"
+
+    implementation 'commons-io:commons-io:2.11.0'
+    
+    implementation 'com.facebook.react:react-native:+'  // From node_modules
+    implementation 'androidx.appcompat:appcompat:1.0.2'
+    implementation 'androidx.annotation:annotation:1.0.2'
+    implementation "androidx.core:core:1.3.1"
+    implementation "androidx.exifinterface:exifinterface:1.3.3"
+    implementation 'androidx.recyclerview:recyclerview:1.3.2'
+    implementation 'com.arthenica:ffmpeg-kit-full:6.0-2'
+
+
+    def firebaseBomVersion = safeExtGet("firebaseBomVersion", null)
+  def firebaseIidVersion = safeExtGet('firebaseIidVersion', null)
+  if (firebaseBomVersion) {
+      implementation platform("com.google.firebase:firebase-bom:${firebaseBomVersion}")
+      implementation "com.google.firebase:firebase-iid"
+  } else if(firebaseIidVersion){
+      implementation "com.google.firebase:firebase-iid:${firebaseIidVersion}"
+  }else{
+      def iidVersion = safeExtGet('googlePlayServicesIidVersion', safeExtGet('googlePlayServicesVersion', '17.0.0'))
+      implementation "com.google.android.gms:play-services-iid:$iidVersion"
+  }
+}
+
+static def findNodeModulePath(baseDir, packageName) {
+  def basePath = baseDir.toPath().normalize()
+  // Node's module resolution algorithm searches up to the root directory,
+  // after which the base path will be null
+  while (basePath) {
+    def candidatePath = Paths.get(basePath.toString(), "node_modules", packageName)
+    if (candidatePath.toFile().exists()) {
+      return candidatePath.toString()
+    }
+    basePath = basePath.getParent()
+  }
+  return null
+}
+
+def findNodeModulePath(packageName) {
+  // Don't start in the project dir, as its path ends with node_modules/react-native-mlkit-ocr/android
+  // we want to go two levels up, so we end up in the first_node modules and eventually
+  // search upwards if the package is not found there
+  return findNodeModulePath(projectDir.toPath().parent.parent.toFile(), packageName)
+}
+
+def safeExtGet(prop, fallback) {
+    rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+}
+
+def resolveReactNativeDirectory() {
+    def reactNativeLocation = safeExtGet("REACT_NATIVE_NODE_MODULES_DIR", null)
+    if (reactNativeLocation != null) {
+        return file(reactNativeLocation)
+    }
+
+    // monorepo workaround
+    // react-native can be hoisted or in project's own node_modules
+    def reactNativeFromProjectNodeModules = file("${rootProject.projectDir}/../node_modules/react-native")
+    if (reactNativeFromProjectNodeModules.exists()) {
+        return reactNativeFromProjectNodeModules
+    }
+
+    def reactNativeFromNodeModulesWithImagePicker = file("${projectDir}/../../react-native")
+    if (reactNativeFromNodeModulesWithImagePicker.exists()) {
+        return reactNativeFromNodeModulesWithImagePicker
+    }
+
+    throw new Exception(
+            "[react-native-image-picker] Unable to resolve react-native location in " +
+                    "node_modules. You should add project extension property (in app/build.gradle) " +
+                    "`REACT_NATIVE_NODE_MODULES_DIR` with path to react-native."
+    )
+}
+
+def getReactNativeMinorVersion() {
+    def REACT_NATIVE_DIR = resolveReactNativeDirectory()
+
+    def reactProperties = new Properties()
+    file("$REACT_NATIVE_DIR/ReactAndroid/gradle.properties").withInputStream { reactProperties.load(it) }
+
+    def REACT_NATIVE_VERSION = reactProperties.getProperty("VERSION_NAME")
+    def REACT_NATIVE_MINOR_VERSION = REACT_NATIVE_VERSION.startsWith("0.0.0-") ? 1000 : REACT_NATIVE_VERSION.split("\\.")[1].toInteger()
+
+    return REACT_NATIVE_MINOR_VERSION
+}
+

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,40 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.shakebug">
+
+    <uses-permission android:name="android.permission.INTERNET" />
+
+
+
+    <!-- If you intend to use the microphone -->
+    <uses-permission android:name="android.permission.RECORD_AUDIO"/>
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE"/>
+    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
+    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
+
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
+
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PROJECTION" />
+
+    <application
+      android:hardwareAccelerated="true"
+    >
+        <provider
+            android:name=".ImagePickerProvider"
+            android:authorities="${applicationId}.imagepickerprovider"
+            android:exported="false"
+            android:grantUriPermissions="true">
+            <meta-data
+                android:name="android.support.FILE_PROVIDER_PATHS"
+                android:resource="@xml/imagepicker_provider_paths" />
+        </provider>
+
+<receiver android:name=".ScreenshotReceiver"
+          android:exported="true"> <!-- Specify android:exported="true" -->
+    <intent-filter>
+        <action android:name="android.intent.action.SCREENSHOT" />
+    </intent-filter>
+</receiver>
+    </application>
+</manifest>
+

package/android/src/main/java/com/shakebug/AmazonFireDeviceConnectivityPoller.java

@@ -0,0 +1,170 @@
+package com.shakebug;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.os.Build;
+import android.os.Handler;
+
+/**
+ * A component similar to ConnectivityReceiver (and its implementations) that goes through
+ * register/unregister cycles. It is only active on an Amazon Fire device (e.g. FireTV Stick). It
+ * will continuously issue an intent to FireOS to check for internet connectivity and listen to the
+ * response via broadcast receiver.
+ *
+ * <p>This is required since FireOs does not report network capabilities correctly
+ * (NetworkCapabilities.NET_CAPABILITY_VALIDATED is true when offline) even when the OS knows that
+ * the internet is not reachable.
+ *
+ * <p>The caller component is responsible to responding to callbacks of the device going online or
+ * offline.
+ */
+public class AmazonFireDeviceConnectivityPoller {
+    /** Intent action for triggering FireOS connectivity checking. */
+    private static final String ACTION_CONNECTIVITY_CHECK =
+            "com.amazon.tv.networkmonitor.CONNECTIVITY_CHECK";
+
+    /** Broadcast sent by NetMon FireOS component when the device cannot reach the internet. */
+    private static final String ACTION_INTERNET_DOWN = "com.amazon.tv.networkmonitor.INTERNET_DOWN";
+
+    /** Broadcast sent by NetMon FireOS component when the can reach the internet. */
+    private static final String ACTION_INTERNET_UP = "com.amazon.tv.networkmonitor.INTERNET_UP";
+
+    /** Interval (in milliseconds) of how often to check for connectivity. */
+    private static final long POLLING_INTERVAL_MS = 10 * 1000;
+
+    private final Receiver receiver = new Receiver();
+    private final Context context;
+    private final ConnectivityChangedCallback callback;
+
+    private final Runnable checker = new PollerTask();
+    private Handler handler;
+    private boolean pollerRunning = false;
+
+    /** Callback interface that will be invoked when internet connectivity status changes. */
+    public interface ConnectivityChangedCallback {
+        /**
+         * Called when internet connectivity status changes.
+         *
+         * @param isConnected
+         */
+        void onAmazonFireDeviceConnectivityChanged(boolean isConnected);
+    }
+
+    AmazonFireDeviceConnectivityPoller(Context context, ConnectivityChangedCallback callback) {
+        this.context = context;
+        this.callback = callback;
+    }
+
+    public void register() {
+        if (!isFireOsDevice()) {
+            return;
+        }
+
+        registerReceiver();
+        startPoller();
+    }
+
+    public void unregister() {
+        if (!isFireOsDevice()) {
+            return;
+        }
+
+        stopPoller();
+        unregisterReceiver();
+    }
+
+    private boolean isFireOsDevice() {
+        // https://developer.amazon.com/docs/fire-tv/identify-amazon-fire-tv-devices.html
+        // https://developer.amazon.com/docs/fire-tablets/ft-specs-custom.html
+        return Build.MANUFACTURER.equals("Amazon")
+                && (Build.MODEL.startsWith("AF") || Build.MODEL.startsWith("KF"));
+    }
+
+    private void registerReceiver() {
+        if (receiver.registered) {
+            return;
+        }
+
+        IntentFilter filter = new IntentFilter();
+        filter.addAction(ACTION_INTERNET_DOWN);
+        filter.addAction(ACTION_INTERNET_UP);
+        NetInfoUtils.compatRegisterReceiver(context, receiver, filter, false);
+
+        receiver.registered = true;
+    }
+
+    private void startPoller() {
+        if (pollerRunning) {
+            return;
+        }
+
+        // NOTE: since this is usually called on the right thread, we construct
+        //       the handler here rather than in the constructor.
+        handler = new Handler();
+        pollerRunning = true;
+        handler.post(checker);
+
+        // NOTE: In the future, WorkManager or another approach to the polling task
+        //       would work better. For now though this is the simpler way to keep
+        //       checking for connectivity.
+    }
+
+    private void unregisterReceiver() {
+        if (!receiver.registered) {
+            return;
+        }
+
+        context.unregisterReceiver(receiver);
+        receiver.registered = false;
+    }
+
+    private void stopPoller() {
+        if (!pollerRunning) {
+            return;
+        }
+
+        pollerRunning = false;
+        handler.removeCallbacksAndMessages(null);
+        handler = null;
+    }
+
+    private class Receiver extends BroadcastReceiver {
+        boolean registered = false;
+
+        private Boolean lastIsConnected;
+
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            String action = intent == null ? null : intent.getAction();
+            boolean isConnected;
+            if (ACTION_INTERNET_DOWN.equals(action)) {
+                isConnected = false;
+            } else if (ACTION_INTERNET_UP.equals(action)) {
+                isConnected = true;
+            } else {
+                return;
+            }
+
+            if (lastIsConnected == null || lastIsConnected != isConnected) {
+                lastIsConnected = isConnected;
+                callback.onAmazonFireDeviceConnectivityChanged(isConnected);
+            }
+        }
+    }
+
+    private class PollerTask implements Runnable {
+        @Override
+        public void run() {
+            if (!pollerRunning) {
+                return;
+            }
+
+            Intent checkIntent = new Intent(ACTION_CONNECTIVITY_CHECK);
+            context.sendBroadcast(checkIntent);
+
+            handler.postDelayed(checker, POLLING_INTERVAL_MS);
+        }
+    }
+}

package/android/src/main/java/com/shakebug/BaseUtils.java

@@ -0,0 +1,33 @@
+package com.shakebug;
+
+import android.content.Context;
+
+import java.lang.ref.WeakReference;
+
+/**
+ * Author：J.Chou
+ * Date：  2016.07.21 11:45.
+ * Email： who_know_me@163.com
+ * Describe:
+ */
+public class BaseUtils {
+
+  private static final String ERROR_INIT = "Initialize BaseUtils with invoke init()";
+
+  private static WeakReference<Context> mWeakReferenceContext;
+
+  /**
+   * init in Application
+   */
+  public static void init(Context ctx){
+    mWeakReferenceContext = new WeakReference<>(ctx);
+    //something to do...
+  }
+
+  public static Context getContext() {
+    if (mWeakReferenceContext == null) {
+      throw new IllegalArgumentException(ERROR_INIT);
+    }
+    return mWeakReferenceContext.get().getApplicationContext();
+  }
+}

package/android/src/main/java/com/shakebug/BroadcastReceiverConnectivityReceiver.java

@@ -0,0 +1,131 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+package com.shakebug;
+
+import android.annotation.SuppressLint;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.net.ConnectivityManager;
+import android.net.NetworkInfo;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.shakebug.types.CellularGeneration;
+import com.shakebug.types.ConnectionType;
+
+/**
+ * This gets the connectivity status using a BroadcastReceiver. This method was deprecated on
+ * Android from API level 24 (N) but we use this method still for any devices running below level
+ * 24.
+ *
+ * <p>It has a few differences from the new NetworkCallback method: - Changes to the cellular
+ * network effective type (eg. from 2g to 3g) will not trigger a callback
+ */
+@SuppressWarnings("deprecation")
+public class BroadcastReceiverConnectivityReceiver extends ConnectivityReceiver {
+    private final ConnectivityBroadcastReceiver mConnectivityBroadcastReceiver;
+    public static final String CONNECTIVITY_ACTION = "android.net.conn.CONNECTIVITY_CHANGE";
+
+    public BroadcastReceiverConnectivityReceiver(ReactApplicationContext reactContext) {
+        super(reactContext);
+        mConnectivityBroadcastReceiver = new ConnectivityBroadcastReceiver();
+    }
+
+    @Override
+    public void register() {
+        IntentFilter filter = new IntentFilter();
+        filter.addAction(CONNECTIVITY_ACTION);
+        NetInfoUtils.compatRegisterReceiver(
+                getReactContext(),
+                mConnectivityBroadcastReceiver,
+                filter,
+                false
+        );
+        mConnectivityBroadcastReceiver.setRegistered(true);
+        updateAndSendConnectionType();
+    }
+
+    @Override
+    public void unregister() {
+        if (mConnectivityBroadcastReceiver.isRegistered()) {
+            getReactContext().unregisterReceiver(mConnectivityBroadcastReceiver);
+            mConnectivityBroadcastReceiver.setRegistered(false);
+        }
+    }
+
+    @SuppressLint("MissingPermission")
+    private void updateAndSendConnectionType() {
+        ConnectionType connectionType = ConnectionType.UNKNOWN;
+        CellularGeneration cellularGeneration = null;
+        boolean isInternetReachable = false;
+
+        try {
+            NetworkInfo networkInfo = getConnectivityManager().getActiveNetworkInfo();
+            if (networkInfo == null || !networkInfo.isConnected()) {
+                connectionType = ConnectionType.NONE;
+            } else {
+                // Check if the internet is reachable
+                isInternetReachable = networkInfo.isConnected();
+
+                // Get the connection type
+                int networkType = networkInfo.getType();
+                switch (networkType) {
+                    case ConnectivityManager.TYPE_BLUETOOTH:
+                        connectionType = ConnectionType.BLUETOOTH;
+                        break;
+                    case ConnectivityManager.TYPE_ETHERNET:
+                        connectionType = ConnectionType.ETHERNET;
+                        break;
+                    case ConnectivityManager.TYPE_MOBILE:
+                    case ConnectivityManager.TYPE_MOBILE_DUN:
+                        connectionType = ConnectionType.CELLULAR;
+                        cellularGeneration = CellularGeneration.fromNetworkInfo(networkInfo);
+                        break;
+                    case ConnectivityManager.TYPE_WIFI:
+                        connectionType = ConnectionType.WIFI;
+                        break;
+                    case ConnectivityManager.TYPE_WIMAX:
+                        connectionType = ConnectionType.WIMAX;
+                        break;
+                    case ConnectivityManager.TYPE_VPN:
+                        connectionType = ConnectionType.VPN;
+                        break;
+                }
+            }
+        } catch (SecurityException e) {
+            connectionType = ConnectionType.UNKNOWN;
+        }
+
+        updateConnectivity(connectionType, cellularGeneration, isInternetReachable);
+    }
+
+    /**
+     * Class that receives intents whenever the connection type changes. NB: It is possible on some
+     * devices to receive certain connection type changes multiple times.
+     */
+    private class ConnectivityBroadcastReceiver extends BroadcastReceiver {
+
+        // TODO: Remove registered check when source of crash is found. t9846865
+        private boolean isRegistered = false;
+
+        public void setRegistered(boolean registered) {
+            isRegistered = registered;
+        }
+
+        public boolean isRegistered() {
+            return isRegistered;
+        }
+
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            String action = intent.getAction();
+            if (action != null && action.equals(CONNECTIVITY_ACTION)) {
+                updateAndSendConnectionType();
+            }
+        }
+    }
+}