shakebug-react-native 1.0.14

package/android/src/main/java/com/shakebug/interfaces/VideoTrimListener.java

@@ -0,0 +1,10 @@
+package com.shakebug.interfaces;
+
+public interface VideoTrimListener {
+  void onStartTrim();
+  void onTrimmingProgress(int percentage);
+  void onFinishTrim(String url);
+  void onError(String errorMessage);
+  void onCancel();
+  void onSave();
+}

package/android/src/main/java/com/shakebug/resolver/DeviceIdResolver.java

@@ -0,0 +1,87 @@
+package com.shakebug.resolver;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.os.Build;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.UUID;
+
+import com.shakebug.RNDeviceModule;
+
+/**
+ * Instance Id resolver's single purpose is to get the device's Instance Id
+ * author: Andres Aguilar
+ */
+public class DeviceIdResolver {
+
+  private final Context context;
+
+  public DeviceIdResolver(Context context) {
+    this.context = context;
+  }
+
+  public String getInstanceIdSync() {
+    String instanceId = getInstanceIdFromPrefs();
+
+    if (instanceId != Build.UNKNOWN) {
+      return instanceId;
+    }
+
+    try {
+      instanceId = getFirebaseInstanceId();
+      setInstanceIdInPrefs(instanceId);
+      return instanceId;
+    } catch (ClassNotFoundException ignored) {
+    } catch (NoSuchMethodException | SecurityException | IllegalAccessException | InvocationTargetException e) {
+      System.err.println("N/A: Unsupported version of com.google.firebase:firebase-iid in your project.");
+    }
+
+    try {
+      instanceId = getGmsInstanceId();
+      setInstanceIdInPrefs(instanceId);
+      return instanceId;
+    } catch (ClassNotFoundException ignored) {
+    } catch (NoSuchMethodException | SecurityException | IllegalAccessException | InvocationTargetException e) {
+      System.err.println("N/A: Unsupported version of com.google.android.gms.iid in your project.");
+    }
+
+    instanceId = getUUIDInstanceId();
+    setInstanceIdInPrefs(instanceId);
+    return instanceId;
+  }
+
+  String getUUIDInstanceId() {
+    String uuidInstanceId = UUID.randomUUID().toString();
+    return uuidInstanceId;
+  }
+
+  String getInstanceIdFromPrefs() {
+    SharedPreferences prefs = RNDeviceModule.getRNDISharedPreferences(context);
+    String instanceId = prefs.getString("instanceId", Build.UNKNOWN);
+    return instanceId;
+  }
+
+  void setInstanceIdInPrefs(String instanceId) {
+    SharedPreferences.Editor editor = RNDeviceModule.getRNDISharedPreferences(context).edit();
+    editor.putString("instanceId", instanceId);
+    editor.apply();
+  }
+
+  String getGmsInstanceId() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException {
+    Class<?> clazz = Class.forName("com.google.android.gms.iid.InstanceID");
+    Method method = clazz.getDeclaredMethod("getInstance", Context.class);
+    Object obj = method.invoke(null, context.getApplicationContext());
+    Method method1 = obj.getClass().getMethod("getId");
+    return (String) method1.invoke(obj);
+  }
+
+  String getFirebaseInstanceId() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException {
+    Class<?> clazz = Class.forName("com.google.firebase.iid.FirebaseInstanceId");
+    Method method = clazz.getDeclaredMethod("getInstance");
+    Object obj = method.invoke(null);
+    Method method1 = obj.getClass().getMethod("getId");
+    return (String) method1.invoke(obj);
+  }
+}

package/android/src/main/java/com/shakebug/resolver/DeviceTypeResolver.java

@@ -0,0 +1,94 @@
+package com.shakebug.resolver;
+
+import android.app.UiModeManager;
+import android.content.Context;
+import android.content.res.Configuration;
+import android.os.Build;
+import android.util.DisplayMetrics;
+import android.view.WindowManager;
+
+import com.shakebug.DeviceType;
+
+/**
+ * Utility class used to get the device type, it's not dependant of React Native, allowing it to
+ * be shared with native code as well as RN through RNDeviceModule
+ * author: Andres Aguilar
+ */
+public class DeviceTypeResolver {
+
+  private final Context context;
+
+  public DeviceTypeResolver(Context context) {
+    this.context = context;
+  }
+
+  public boolean isTablet() {
+    return getDeviceType() == DeviceType.TABLET;
+  }
+
+  public DeviceType getDeviceType() {
+    // Detect TVs via ui mode (Android TVs) or system features (Fire TV).
+    if (context.getPackageManager().hasSystemFeature("amazon.hardware.fire_tv")) {
+      return DeviceType.TV;
+    }
+
+    UiModeManager uiManager = (UiModeManager) context.getSystemService(Context.UI_MODE_SERVICE);
+    if (uiManager != null && uiManager.getCurrentModeType() == Configuration.UI_MODE_TYPE_TELEVISION) {
+      return DeviceType.TV;
+    }
+
+    DeviceType deviceTypeFromConfig = getDeviceTypeFromResourceConfiguration();
+
+    if (deviceTypeFromConfig != null && deviceTypeFromConfig != DeviceType.UNKNOWN) {
+      return deviceTypeFromConfig;
+    }
+
+    return getDeviceTypeFromPhysicalSize();
+  }
+
+  // Use `smallestScreenWidthDp` to determine the screen size
+  // https://android-developers.googleblog.com/2011/07/new-tools-for-managing-screen-sizes.html
+  private DeviceType getDeviceTypeFromResourceConfiguration() {
+    int smallestScreenWidthDp = context.getResources().getConfiguration().smallestScreenWidthDp;
+
+    if (smallestScreenWidthDp == Configuration.SMALLEST_SCREEN_WIDTH_DP_UNDEFINED) {
+      return DeviceType.UNKNOWN;
+    }
+
+    return smallestScreenWidthDp >= 600 ? DeviceType.TABLET : DeviceType.HANDSET;
+  }
+
+  private DeviceType getDeviceTypeFromPhysicalSize() {
+    // Find the current window manager, if none is found we can't measure the device physical size.
+    WindowManager windowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
+
+    if (windowManager == null) {
+      return DeviceType.UNKNOWN;
+    }
+
+    // Get display metrics to see if we can differentiate handsets and tablets.
+    // NOTE: for API level 16 the metrics will exclude window decor.
+    DisplayMetrics metrics = new DisplayMetrics();
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
+      windowManager.getDefaultDisplay().getRealMetrics(metrics);
+    } else {
+      windowManager.getDefaultDisplay().getMetrics(metrics);
+    }
+
+    // Calculate physical size.
+    double widthInches = metrics.widthPixels / (double) metrics.xdpi;
+    double heightInches = metrics.heightPixels / (double) metrics.ydpi;
+    double diagonalSizeInches = Math.sqrt(Math.pow(widthInches, 2) + Math.pow(heightInches, 2));
+
+    if (diagonalSizeInches >= 3.0 && diagonalSizeInches <= 6.9) {
+      // Devices in a sane range for phones are considered to be Handsets.
+      return DeviceType.HANDSET;
+    } else if (diagonalSizeInches > 6.9 && diagonalSizeInches <= 18.0) {
+      // Devices larger than handset and in a sane range for tablets are tablets.
+      return DeviceType.TABLET;
+    } else {
+      // Otherwise, we don't know what device type we're on/
+      return DeviceType.UNKNOWN;
+    }
+  }
+}

package/android/src/main/java/com/shakebug/thread/BackgroundExecutor.java

@@ -0,0 +1,246 @@
+/**
+ * Copyright (C) 2010-2016 eBusiness Information, Excilys Group
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed To in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.shakebug.thread;
+
+import android.util.Log;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public final class BackgroundExecutor {
+
+  private static final String TAG = "BackgroundExecutor";
+
+  public static final Executor DEFAULT_EXECUTOR = Executors.newScheduledThreadPool(2 * Runtime.getRuntime().availableProcessors());
+  private static Executor executor = DEFAULT_EXECUTOR;
+  private static final List<Task> TASKS = new ArrayList<>();
+  private static final ThreadLocal<String> CURRENT_SERIAL = new ThreadLocal<>();
+
+  private BackgroundExecutor() {
+  }
+
+  /**
+   * Execute a runnable after the given delay.
+   *
+   * @param runnable the task to execute
+   * @param delay    the time from now to delay execution, in milliseconds
+   *                 <p>
+   *                 if <code>delay</code> is strictly positive and the current
+   *                 executor does not support scheduling (if
+   *                 Executor has been called with such an
+   *                 executor)
+   * @return Future associated to the running task
+   * @throws IllegalArgumentException if the current executor set by Executor
+   *                                  does not support scheduling
+   */
+  private static Future<?> directExecute(Runnable runnable, long delay) {
+    Future<?> future = null;
+    if (delay > 0) {
+      /* no serial, but a delay: schedule the task */
+      if (!(executor instanceof ScheduledExecutorService)) {
+        throw new IllegalArgumentException("The executor set does not support scheduling");
+      }
+      ScheduledExecutorService scheduledExecutorService = (ScheduledExecutorService) executor;
+      future = scheduledExecutorService.schedule(runnable, delay, TimeUnit.MILLISECONDS);
+    } else {
+      if (executor instanceof ExecutorService) {
+        ExecutorService executorService = (ExecutorService) executor;
+        future = executorService.submit(runnable);
+      } else {
+        /* non-cancellable task */
+        executor.execute(runnable);
+      }
+    }
+    return future;
+  }
+
+  /**
+   * Execute a task after (at least) its delay <strong>and</strong> after all
+   * tasks added with the same non-null <code>serial</code> (if any) have
+   * completed execution.
+   *
+   * @param task the task to execute
+   * @throws IllegalArgumentException if <code>task.delay</code> is strictly positive and the
+   *                                  current executor does not support scheduling (if
+   *                                  Executor has been called with such an
+   *                                  executor)
+   */
+  public static synchronized void execute(Task task) {
+    Future<?> future = null;
+    if (task.serial == null || !hasSerialRunning(task.serial)) {
+      task.executionAsked = true;
+      future = directExecute(task, task.remainingDelay);
+    }
+    if ((task.id != null || task.serial != null) && !task.managed.get()) {
+      /* keep task */
+      task.future = future;
+      TASKS.add(task);
+    }
+  }
+
+  /**
+   * Indicates whether a task with the specified <code>serial</code> has been
+   * submitted to the executor.
+   *
+   * @param serial the serial queue
+   * @return <code>true</code> if such a task has been submitted,
+   * <code>false</code> otherwise
+   */
+  private static boolean hasSerialRunning(String serial) {
+    for (Task task : TASKS) {
+      if (task.executionAsked && serial.equals(task.serial)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Retrieve and remove the first task having the specified
+   * <code>serial</code> (if any).
+   *
+   * @param serial the serial queue
+   * @return task if found, <code>null</code> otherwise
+   */
+  private static Task take(String serial) {
+    int len = TASKS.size();
+    for (int i = 0; i < len; i++) {
+      if (serial.equals(TASKS.get(i).serial)) {
+        return TASKS.remove(i);
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Cancel all tasks having the specified <code>id</code>.
+   *
+   * @param id                    the cancellation identifier
+   * @param mayInterruptIfRunning <code>true</code> if the thread executing this task should be
+   *                              interrupted; otherwise, in-progress tasks are allowed to
+   *                              complete
+   */
+  public static synchronized void cancelAll(String id, boolean mayInterruptIfRunning) {
+    for (int i = TASKS.size() - 1; i >= 0; i--) {
+      Task task = TASKS.get(i);
+      if (id.equals(task.id)) {
+        if (task.future != null) {
+          task.future.cancel(mayInterruptIfRunning);
+          if (!task.managed.getAndSet(true)) {
+            /*
+             * the task has been submitted to the executor, but its
+             * execution has not started yet, so that its run()
+             * method will never call postExecute()
+             */
+            task.postExecute();
+          }
+        } else if (task.executionAsked) {
+          Log.w(TAG, "A task with id " + task.id + " cannot be cancelled (the executor set does not support it)");
+        } else {
+          /* this task has not been submitted to the executor */
+          TASKS.remove(i);
+        }
+      }
+    }
+  }
+
+  public static abstract class Task implements Runnable {
+
+    private String id;
+    private long remainingDelay;
+    private long targetTimeMillis; /* since epoch */
+    private String serial;
+    private boolean executionAsked;
+    private Future<?> future;
+
+    /*
+     * A task can be cancelled after it has been submitted to the executor
+     * but before its run() method is called. In that case, run() will never
+     * be called, hence neither will postExecute(): the tasks with the same
+     * serial identifier (if any) will never be submitted.
+     *
+     * Therefore, cancelAll() *must* call postExecute() if run() is not
+     * started.
+     *
+     * This flag guarantees that either cancelAll() or run() manages this
+     * task post execution, but not both.
+     */
+    private AtomicBoolean managed = new AtomicBoolean();
+
+    public Task(String id, long delay, String serial) {
+      if (!"".equals(id)) {
+        this.id = id;
+      }
+      if (delay > 0) {
+        remainingDelay = delay;
+        targetTimeMillis = System.currentTimeMillis() + delay;
+      }
+      if (!"".equals(serial)) {
+        this.serial = serial;
+      }
+    }
+
+    @Override
+    public void run() {
+      if (managed.getAndSet(true)) {
+        /* cancelled and postExecute() already called */
+        return;
+      }
+
+      try {
+        CURRENT_SERIAL.set(serial);
+        execute();
+      } finally {
+        /* handle next tasks */
+        postExecute();
+      }
+    }
+
+    public abstract void execute();
+
+    private void postExecute() {
+      if (id == null && serial == null) {
+        /* nothing to do */
+        return;
+      }
+      CURRENT_SERIAL.set(null);
+      synchronized (BackgroundExecutor.class) {
+        /* execution complete */
+        TASKS.remove(this);
+
+        if (serial != null) {
+          Task next = take(serial);
+          if (next != null) {
+            if (next.remainingDelay != 0) {
+              /* the delay may not have elapsed yet */
+              next.remainingDelay = Math.max(0L, targetTimeMillis - System.currentTimeMillis());
+            }
+            /* a task having the same serial was queued, execute it */
+            BackgroundExecutor.execute(next);
+          }
+        }
+      }
+    }
+  }
+}
+

package/android/src/main/java/com/shakebug/thread/UiThreadExecutor.java

@@ -0,0 +1,120 @@
+/**
+ * Copyright (C) 2010-2016 eBusiness Information, Excilys Group
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed To in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.shakebug.thread;
+
+import android.os.Handler;
+import android.os.Looper;
+import android.os.Message;
+import android.os.SystemClock;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * This class provide operations for
+ * UiThread tasks.
+ */
+public final class UiThreadExecutor {
+
+  private static final Handler HANDLER = new Handler(Looper.getMainLooper()) {
+    @Override
+    public void handleMessage(Message msg) {
+      Runnable callback = msg.getCallback();
+      if (callback != null) {
+        callback.run();
+        decrementToken((Token) msg.obj);
+      } else {
+        super.handleMessage(msg);
+      }
+    }
+  };
+
+  private static final Map<String, Token> TOKENS = new HashMap<>();
+
+  private UiThreadExecutor() {
+    // should not be instantiated
+  }
+
+  /**
+   * Store a new task in the map for providing cancellation. This method is
+   * used by AndroidAnnotations and not intended to be called by clients.
+   *
+   * @param id    the identifier of the task
+   * @param task  the task itself
+   * @param delay the delay or zero to run immediately
+   */
+  public static void runTask(String id, Runnable task, long delay) {
+    if ("".equals(id)) {
+      HANDLER.postDelayed(task, delay);
+      return;
+    }
+    long time = SystemClock.uptimeMillis() + delay;
+    HANDLER.postAtTime(task, nextToken(id), time);
+  }
+
+  private static Token nextToken(String id) {
+    synchronized (TOKENS) {
+      Token token = TOKENS.get(id);
+      if (token == null) {
+        token = new Token(id);
+        TOKENS.put(id, token);
+      }
+      token.runnablesCount++;
+      return token;
+    }
+  }
+
+  private static void decrementToken(Token token) {
+    synchronized (TOKENS) {
+      if (--token.runnablesCount == 0) {
+        String id = token.id;
+        Token old = TOKENS.remove(id);
+        if (old != token) {
+          // a runnable finished after cancelling, we just removed a
+          // wrong token, lets put it back
+          TOKENS.put(id, old);
+        }
+      }
+    }
+  }
+
+  /**
+   * Cancel all tasks having the specified <code>id</code>.
+   *
+   * @param id the cancellation identifier
+   */
+  public static void cancelAll(String id) {
+    Token token;
+    synchronized (TOKENS) {
+      token = TOKENS.remove(id);
+    }
+    if (token == null) {
+      // nothing to cancel
+      return;
+    }
+    HANDLER.removeCallbacksAndMessages(token);
+  }
+
+  private static final class Token {
+    int runnablesCount = 0;
+    final String id;
+
+    private Token(String id) {
+      this.id = id;
+    }
+  }
+
+}

package/android/src/main/java/com/shakebug/types/CellularGeneration.java

@@ -0,0 +1,60 @@
+/**
+ * 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.types;
+
+import android.net.NetworkInfo;
+import android.telephony.TelephonyManager;
+import javax.annotation.Nullable;
+
+// Based on the EffectiveConnectionType enum described in the W3C Network Information API spec
+// (https://wicg.github.io/netinfo/).
+public enum CellularGeneration {
+    // We need to prefix these with "CG_" because they cannot start with numbers
+    CG_2G("2g"),
+    CG_3G("3g"),
+    CG_4G("4g"),
+    CG_5G("5g");
+
+    public final String label;
+
+    CellularGeneration(String label) {
+        this.label = label;
+    }
+
+    @Nullable
+    public static CellularGeneration fromNetworkInfo(@Nullable NetworkInfo networkInfo) {
+        if (networkInfo == null) {
+            return null;
+        }
+
+        switch (networkInfo.getSubtype()) {
+            case TelephonyManager.NETWORK_TYPE_1xRTT:
+            case TelephonyManager.NETWORK_TYPE_CDMA:
+            case TelephonyManager.NETWORK_TYPE_EDGE:
+            case TelephonyManager.NETWORK_TYPE_GPRS:
+            case TelephonyManager.NETWORK_TYPE_IDEN:
+                return CellularGeneration.CG_2G;
+            case TelephonyManager.NETWORK_TYPE_EHRPD:
+            case TelephonyManager.NETWORK_TYPE_EVDO_0:
+            case TelephonyManager.NETWORK_TYPE_EVDO_A:
+            case TelephonyManager.NETWORK_TYPE_EVDO_B:
+            case TelephonyManager.NETWORK_TYPE_HSDPA:
+            case TelephonyManager.NETWORK_TYPE_HSPA:
+            case TelephonyManager.NETWORK_TYPE_HSUPA:
+            case TelephonyManager.NETWORK_TYPE_UMTS:
+                return CellularGeneration.CG_3G;
+            case TelephonyManager.NETWORK_TYPE_HSPAP:
+            case TelephonyManager.NETWORK_TYPE_LTE:
+                return CellularGeneration.CG_4G;
+            case TelephonyManager.NETWORK_TYPE_NR:
+                return CellularGeneration.CG_5G;
+            case TelephonyManager.NETWORK_TYPE_UNKNOWN:
+            default:
+                return null;
+        }
+    }
+}

package/android/src/main/java/com/shakebug/types/ConnectionType.java

@@ -0,0 +1,26 @@
+/**
+ * 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.types;
+
+// Based on the ConnectionType enum described in the W3C Network Information API spec
+// (https://wicg.github.io/netinfo/).
+public enum ConnectionType {
+    BLUETOOTH("bluetooth"),
+    CELLULAR("cellular"),
+    ETHERNET("ethernet"),
+    NONE("none"),
+    UNKNOWN("unknown"),
+    WIFI("wifi"),
+    WIMAX("wimax"),
+    VPN("vpn");
+
+    public final String label;
+
+    ConnectionType(String label) {
+        this.label = label;
+    }
+}