shakebug-react-native 1.0.14

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

@@ -0,0 +1,202 @@
+package com.shakebug;
+
+import android.app.Activity;
+import android.app.Application;
+import android.content.Context;
+import android.content.Intent;
+import android.media.MediaCodecList;
+import android.media.projection.MediaProjectionManager;
+import android.os.Build;
+import android.util.SparseIntArray;
+import android.view.Surface;
+
+import androidx.annotation.NonNull;
+import androidx.appcompat.app.AppCompatActivity;
+
+import com.facebook.react.bridge.ActivityEventListener;
+import com.facebook.react.bridge.BaseActivityEventListener;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeMap;
+import com.hbisoft.hbrecorder.HBRecorder;
+import com.hbisoft.hbrecorder.HBRecorderListener;
+
+import java.io.File;
+import java.io.IOException;
+
+public class RecordScreenModule extends ReactContextBaseJavaModule implements HBRecorderListener {
+
+    private HBRecorder hbRecorder;
+    private int screenWidth = 0;
+    private int screenHeight = 0;
+    private boolean mic = true;
+    private String currentVersion;
+    private File outputUri;
+    private Promise startPromise;
+    private Promise stopPromise;
+
+    private static final SparseIntArray ORIENTATIONS = new SparseIntArray();
+    public static final int SCREEN_RECORD_REQUEST_CODE = 1000;
+
+    static {
+        ORIENTATIONS.append(Surface.ROTATION_0, 90);
+        ORIENTATIONS.append(Surface.ROTATION_90, 0);
+        ORIENTATIONS.append(Surface.ROTATION_180, 270);
+        ORIENTATIONS.append(Surface.ROTATION_270, 180);
+    }
+
+    public RecordScreenModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+    }
+
+    @NonNull
+    @Override
+    public String getName() {
+        return "ShakebugSDKRecordScreen";
+    }
+
+    private final ActivityEventListener mActivityEventListener = new BaseActivityEventListener() {
+        @Override
+        public void onActivityResult(Activity activity, int requestCode, int resultCode, Intent intent) {
+            if (requestCode == SCREEN_RECORD_REQUEST_CODE) {
+                if (resultCode == AppCompatActivity.RESULT_OK) {
+                    hbRecorder.startScreenRecording(intent, resultCode);
+                } else {
+                    if (startPromise != null) {
+                        startPromise.resolve("permission_error");
+                    }
+                }
+            } else {
+                if (startPromise != null) {
+                    startPromise.reject("404", "cancel!");
+                }
+            }
+            if (startPromise != null) {
+                startPromise.resolve("started");
+            }
+        }
+    };
+
+    @Override
+    public void initialize() {
+        super.initialize();
+        currentVersion = String.valueOf(Build.VERSION.SDK_INT);
+        outputUri = getReactApplicationContext().getExternalFilesDir("ReactNativeRecordScreen");
+    }
+
+    @ReactMethod
+    public void setup(ReadableMap readableMap) {
+        new Application().onCreate();
+        screenWidth = readableMap.hasKey("width") ? (int) Math.ceil(readableMap.getDouble("width")) : 0;
+        screenHeight = readableMap.hasKey("height") ? (int) Math.ceil(readableMap.getDouble("height")) : 0;
+        mic = readableMap.hasKey("mic") && readableMap.getBoolean("mic");
+
+        hbRecorder = new HBRecorder(getReactApplicationContext(), this);
+        hbRecorder.setOutputPath(outputUri.toString());
+
+        if (readableMap.hasKey("fps") || readableMap.hasKey("bitrate")) {
+            hbRecorder.enableCustomSettings();
+
+            if (readableMap.hasKey("fps")) {
+                int fps = readableMap.getInt("fps");
+                hbRecorder.setVideoFrameRate(fps);
+            }
+            if (readableMap.hasKey("bitrate")) {
+                int bitrate = readableMap.getInt("bitrate");
+                hbRecorder.setVideoBitrate(bitrate);
+            }
+        }
+
+        if (doesSupportEncoder("h264")) {
+            hbRecorder.setVideoEncoder("H264");
+        } else {
+            hbRecorder.setVideoEncoder("DEFAULT");
+        }
+        hbRecorder.isAudioEnabled(mic);
+        getReactApplicationContext().addActivityEventListener(mActivityEventListener);
+    }
+
+    private void startRecordingScreen() {
+        MediaProjectionManager mediaProjectionManager = (MediaProjectionManager) getReactApplicationContext().getSystemService(Context.MEDIA_PROJECTION_SERVICE);
+        Intent permissionIntent = mediaProjectionManager.createScreenCaptureIntent();
+        getCurrentActivity().startActivityForResult(permissionIntent, SCREEN_RECORD_REQUEST_CODE);
+    }
+
+    @ReactMethod
+    public void startRecording(Promise promise) {
+        startPromise = promise;
+        try {
+            startRecordingScreen();
+            System.out.println("startRecording");
+        } catch (IllegalStateException e) {
+            promise.reject("404", "error!");
+            System.out.println(e.toString());
+        } 
+    }
+
+    @ReactMethod
+    public void stopRecording(Promise promise) {
+        stopPromise = promise;
+        hbRecorder.stopScreenRecording();
+    }
+
+    @ReactMethod
+    public void clean(Promise promise) {
+        System.out.println("clean!!");
+        System.out.println(outputUri);
+        if (outputUri != null) {
+            outputUri.delete();
+        }
+        promise.resolve("cleaned");
+    }
+
+    @Override
+    public void HBRecorderOnStart() {
+        System.out.println("HBRecorderOnStart");
+    }
+
+    @Override
+    public void HBRecorderOnComplete() {
+        System.out.println("HBRecorderOnComplete");
+        if (stopPromise != null) {
+            String uri = hbRecorder.getFilePath();
+            WritableMap response = new WritableNativeMap();
+            WritableMap result = new WritableNativeMap();
+            result.putString("outputURL", uri);
+            response.putString("status", "success");
+            response.putMap("result", result);
+            stopPromise.resolve(response);
+        }
+    }
+
+    @Override
+    public void HBRecorderOnError(int errorCode, String reason) {
+        System.out.println("HBRecorderOnError");
+        System.out.println("errorCode: " + errorCode);
+        System.out.println("reason: " + reason);
+    }
+
+    @Override
+    public void HBRecorderOnPause() {
+        System.out.println("HBRecorderOnPause");
+    }
+
+    @Override
+    public void HBRecorderOnResume() {
+        System.out.println("HBRecorderOnResume");
+    }
+
+    private boolean doesSupportEncoder(String encoder) {
+        MediaCodecList list = new MediaCodecList(MediaCodecList.ALL_CODECS);
+        for (int i = 0; i < list.getCodecInfos().length; i++) {
+            if (list.getCodecInfos()[i].isEncoder() && list.getCodecInfos()[i].getName().contains(encoder)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

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

@@ -0,0 +1,63 @@
+package com.shakebug;
+
+import android.content.Context;
+import android.database.ContentObserver;
+import android.os.Handler;
+import android.provider.MediaStore;
+import androidx.annotation.NonNull;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+
+public class ScreenshotDetectorModule extends ReactContextBaseJavaModule {
+
+    private final ReactApplicationContext reactContext;
+    private ContentObserver screenShotObserver;
+
+    public ScreenshotDetectorModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+        this.reactContext = reactContext;
+    }
+
+    @NonNull
+    @Override
+    public String getName() {
+        return "ShakebugSDKScreenShotDetector";
+    }
+
+    @ReactMethod
+    public void startObserving() {
+        if (screenShotObserver == null) {
+            screenShotObserver = new ContentObserver(new Handler()) {
+                @Override
+                public void onChange(boolean selfChange) {
+                    super.onChange(selfChange);
+                    sendScreenShotEvent();
+                }
+            };
+            reactContext.getContentResolver().registerContentObserver(
+                MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
+                true,
+                screenShotObserver
+            );
+        }
+    }
+
+    @ReactMethod
+    public void stopObserving() {
+        if (screenShotObserver != null) {
+            reactContext.getContentResolver().unregisterContentObserver(screenShotObserver);
+            screenShotObserver = null;
+        }
+    }
+
+    private void sendScreenShotEvent() {
+        if (reactContext.hasActiveCatalystInstance()) {
+            reactContext
+                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                .emit("ScreenshotTaken", null);
+        }
+    }
+}

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

@@ -0,0 +1,44 @@
+package com.shakebug;
+
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.net.Uri;
+import android.provider.Settings;
+
+public final class SettingsUtil {
+
+    private SettingsUtil() {
+    }
+
+    public static void openWifiSettings(final Context context) {
+        Intent intent = new Intent(Settings.ACTION_WIFI_SETTINGS);
+        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TOP);
+        context.startActivity(intent);
+    }
+
+    public static void openCelularSettings(final Context context) {
+        Intent intent = new Intent(Intent.ACTION_MAIN);
+        intent.setComponent(new ComponentName("com.android.settings",
+                "com.android.settings.Settings$DataUsageSummaryActivity"));
+        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TOP);
+        context.startActivity(intent);
+    }
+
+    public static void openGpsSettings(final Context context) {
+        final String action = Settings.ACTION_LOCATION_SOURCE_SETTINGS;
+        Intent intent = new Intent(action);
+        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TOP);
+        context.startActivity(intent);
+    }
+
+    public static void openAppSettings(final Context context) {
+        Intent intent = new Intent();
+        intent.setAction(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
+        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TOP);
+        Uri uri = Uri.fromParts("package", context.getPackageName(), null);
+        intent.setData(uri);
+        context.startActivity(intent);
+    }
+
+}

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

@@ -0,0 +1,181 @@
+package com.shakebug;
+
+import androidx.annotation.NonNull;
+
+import android.hardware.Sensor;
+import android.hardware.SensorEvent;
+import android.hardware.SensorEventListener;
+import android.hardware.SensorListener;
+import android.hardware.SensorManager;
+import android.os.SystemClock;
+import androidx.annotation.Nullable;
+import android.util.Log;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.module.annotations.ReactModule;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+
+@ReactModule(name = Shakebug.NAME)
+
+public class Shakebug extends ReactContextBaseJavaModule implements SensorEventListener {
+  public static final String NAME = "AwesomeLibrary";
+  private final ReactApplicationContext reactContext;
+  private final SensorManager sensorManager;
+  private final Sensor sensor;
+  private double lastReading = (double) System.currentTimeMillis();
+  private int interval;
+  private Arguments arguments;
+  private int logLevel = 0;
+  private String sensorName;
+  private int sensorType;
+  private float[] rotation = new float[9];
+  private float[] orientation = new float[3];
+  private float[] quaternion = new float[4];
+
+  private Boolean isBeingObserved = false;
+  public Shakebug(ReactApplicationContext reactContext, String sensorName, int sensorType) {
+    super(reactContext);
+    this.reactContext = reactContext;
+    this.sensorType = sensorType;
+    this.sensorName = sensorName;
+    this.sensorManager = (SensorManager)reactContext.getSystemService(reactContext.SENSOR_SERVICE);
+    this.sensor = this.sensorManager.getDefaultSensor(this.sensorType);
+  }
+
+  // @Override
+  // @NonNull
+  // public String getName() {
+  //   return NAME;
+  // }
+
+  // RN Methods
+  @ReactMethod
+  public void isAvailable(Promise promise) {
+    if (this.sensor == null) {
+      // No sensor found, throw error
+      promise.reject(new RuntimeException("No " + this.sensorName + " found"));
+      return;
+    }
+    promise.resolve(null);
+  }
+
+  @ReactMethod
+  public void setUpdateInterval(int newInterval) {
+    this.interval = newInterval;
+  }
+
+  @ReactMethod
+  public void setLogLevel(int newLevel) {
+    this.logLevel = newLevel;
+  }
+
+  @ReactMethod
+  public void startUpdates() {
+    // Milliseconds to Microseconds conversion
+    sensorManager.registerListener((SensorEventListener) this, sensor, this.interval * 1000);
+  }
+
+  @ReactMethod
+  public void stopUpdates() {
+    sensorManager.unregisterListener((SensorEventListener) this);
+  }
+
+  @Override
+  public String getName() {
+    return this.sensorName;
+  }
+
+  private static double sensorTimestampToEpochMilliseconds(long elapsedTime) {
+    // elapsedTime = The time in nanoseconds at which the event happened.
+    return System.currentTimeMillis() + ((elapsedTime-SystemClock.elapsedRealtimeNanos())/1000000L);
+  }
+
+  // SensorEventListener Interface
+  private void sendEvent(String eventName, @Nullable WritableMap params) {
+    try {
+      this.reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+        .emit(eventName, params);
+    } catch (RuntimeException e) {
+      Log.e("ERROR", "java.lang.RuntimeException: Trying to invoke Javascript before CatalystInstance has been set!");
+    }
+  }
+
+  public void onSensorChanged(SensorEvent sensorEvent) {
+    if(!isBeingObserved) {
+      return; // avoid all the computation if there are no observers
+    }
+
+    int currentType = sensorEvent.sensor.getType();
+    if(currentType != this.sensorType) { // not for the current Sensor
+      return;
+    }
+
+    double tempMs = (double) System.currentTimeMillis();
+    if (tempMs - lastReading >= interval) {
+      lastReading = tempMs;
+      WritableMap map = this.arguments.createMap();
+
+      switch (currentType)
+      {
+        case Sensor.TYPE_ACCELEROMETER:
+        case Sensor.TYPE_GRAVITY:
+        case Sensor.TYPE_GYROSCOPE:
+        case Sensor.TYPE_MAGNETIC_FIELD:
+          map.putDouble("x", sensorEvent.values[0]);
+          map.putDouble("y", sensorEvent.values[1]);
+          map.putDouble("z", sensorEvent.values[2]);
+          break;
+
+        case Sensor.TYPE_PRESSURE:
+          map.putDouble("pressure", sensorEvent.values[0]);
+          break;
+
+        case Sensor.TYPE_ROTATION_VECTOR:
+          SensorManager.getQuaternionFromVector(quaternion, sensorEvent.values);
+          SensorManager.getRotationMatrixFromVector(rotation, sensorEvent.values);
+          SensorManager.getOrientation(rotation, orientation);
+
+          map.putDouble("qw", quaternion[0]);
+          map.putDouble("qx", quaternion[1]);
+          map.putDouble("qy", quaternion[2]);
+          map.putDouble("qz", quaternion[3]);
+
+          map.putDouble("yaw", orientation[0]);
+          map.putDouble("pitch", orientation[1]);
+          map.putDouble("roll", orientation[2]);
+          break;
+
+        default:
+          Log.e("ERROR", "Sensor type '" + currentType + "' not implemented!");
+          return;
+      }
+
+      // timestamp is added to all events
+      map.putDouble("timestamp", this.sensorTimestampToEpochMilliseconds(sensorEvent.timestamp));
+      this.sendEvent(this.sensorName, map);
+    }
+  }
+
+  public void onAccuracyChanged(Sensor sensor, int accuracy) {
+  }
+
+  // this is called by RN when the first listener is registered
+  // not implementing this method will cause a warning on RN 0.65 onwards
+  @ReactMethod
+  public void addListener(String eventName) {
+    isBeingObserved = true;
+  }
+
+  // this is called by RN when the last listener is deregistered
+  // not implementing this method will cause a warning on RN 0.65 onwards
+  @ReactMethod
+  public void removeListeners(Integer count) {
+    isBeingObserved = false;
+    stopUpdates(); // maybe only calling `stopUpdates()` is enough
+  }
+}

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

@@ -0,0 +1,75 @@
+package com.shakebug;
+
+import android.hardware.Sensor;
+import android.content.Context;
+import android.view.WindowManager; // Add import statement for WindowManager
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.JavaScriptModule;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.module.model.ReactModuleInfo;
+import com.facebook.react.module.model.ReactModuleInfoProvider;
+import com.facebook.react.uimanager.ViewManager;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+public class ShakebugPackage implements ReactPackage {
+
+ public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
+
+      return Arrays.<NativeModule>asList(
+        new Shakebug(reactContext, "ShakebugSDKRNSensorsGyroscope", Sensor.TYPE_GYROSCOPE),
+        new Shakebug(reactContext, "ShakebugSDKRNSensorsAccelerometer", Sensor.TYPE_ACCELEROMETER),
+        new Shakebug(reactContext, "ShakebugSDKRNSensorsGravity", Sensor.TYPE_GRAVITY),
+        new Shakebug(reactContext, "ShakebugSDKRNSensorsMagnetometer", Sensor.TYPE_MAGNETIC_FIELD),
+        new Shakebug(reactContext, "ShakebugSDKRNSensorsBarometer", Sensor.TYPE_PRESSURE),
+        new Shakebug(reactContext, "ShakebugSDKRNSensorsOrientation", Sensor.TYPE_ROTATION_VECTOR),
+        new ShakebugSDKScreenShotModule(reactContext),
+        new ShakebugSDKImagePickerModule(reactContext),
+        new RecordScreenModule(reactContext),
+        new RNDeviceModule(reactContext),
+        new CrashLoggerModule(reactContext),
+        new ReactNativeGetLocationModule(reactContext),
+        new NetInfoModule(reactContext),
+        new RNLocalizeModule(reactContext),
+        new SharedPreferencesModule(reactContext),
+        new VideoPlayerModule(reactContext),
+        new VideoThumbnailModule(reactContext),
+        new VideoTrimModule(reactContext),
+        new ScreenshotDetectorModule(reactContext)
+      );
+    }
+
+    public List<Class<? extends JavaScriptModule>> createJSModules() {
+      return Collections.emptyList();
+    }
+
+    public ReactModuleInfoProvider getReactModuleInfoProvider() {
+        return () -> {
+            final Map<String, ReactModuleInfo> moduleInfos = new HashMap<>();
+            boolean isTurboModule = false;
+                moduleInfos.put(
+                    ShakebugSDKImagePickerModuleImpl.NAME,
+                    new ReactModuleInfo(
+                            ShakebugSDKImagePickerModuleImpl.NAME,
+                            ShakebugSDKImagePickerModuleImpl.NAME,
+                            false, // canOverrideExistingModule
+                            false, // needsEagerInit
+                            true, // hasConstants
+                            false, // isCxxModule
+                            isTurboModule // isTurboModule,
+                    ));
+            return moduleInfos;
+        };
+    }
+
+    public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+     return Arrays.<ViewManager>asList(
+            new DrawingViewManager()
+        );
+    }
+}

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

@@ -0,0 +1,56 @@
+package com.shakebug;
+
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.Callback;
+import com.facebook.react.bridge.ReadableMap;
+
+import java.util.Map;
+import java.util.HashMap;
+
+public class ShakebugSDKImagePickerModule extends ReactContextBaseJavaModule {
+
+    final ShakebugSDKImagePickerModuleImpl ShakebugSDKImagePickerModuleImpl;
+
+    ShakebugSDKImagePickerModule(ReactApplicationContext context) {
+        super(context);
+        ShakebugSDKImagePickerModuleImpl = new ShakebugSDKImagePickerModuleImpl(context);
+    }
+
+    @Override
+    public String getName() {
+        return ShakebugSDKImagePickerModuleImpl.NAME;
+    }
+
+    @ReactMethod
+    public void launchCamera(final ReadableMap options, final Callback callback) {
+        ShakebugSDKImagePickerModuleImpl.launchCamera(options, new Callback() {
+            @Override
+            public void invoke(Object... args) {
+                if (args.length > 0 && args[0] != null) {
+                    callback.invoke(args);
+                } else {
+                    callback.invoke();
+                }
+            }
+        });
+    }
+
+    @ReactMethod
+    public void launchImageLibrary(final ReadableMap options, final Callback callback) {
+        ShakebugSDKImagePickerModuleImpl.launchImageLibrary(options, new Callback() {
+            @Override
+            public void invoke(Object... args) {
+                if (args.length > 0 && args[0] != null) {
+                    callback.invoke(args);
+                } else {
+                    callback.invoke();
+                }
+            }
+        });
+    }
+}