shakebug-react-native 1.0.14

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

@@ -0,0 +1,147 @@
+package com.shakebug;
+
+import android.location.Criteria;
+import android.location.Location;
+import android.location.LocationListener;
+import android.location.LocationManager;
+import android.os.Bundle;
+import android.os.Looper;
+import android.util.Log;
+
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableNativeMap;
+
+import java.util.Timer;
+import java.util.TimerTask;
+
+public class GetLocation {
+
+    private final LocationManager locationManager;
+
+    private Timer timer;
+    private LocationListener listener;
+    private Promise promise;
+
+    public GetLocation(LocationManager locationManager) {
+        this.locationManager = locationManager;
+    }
+
+    public void get(ReadableMap options, final Promise promise) {
+        this.promise = promise;
+        try {
+            if (!isLocationEnabled()) {
+                promise.reject("UNAVAILABLE", "Location not available");
+                return;
+            }
+
+            boolean enableHighAccuracy = options.hasKey("enableHighAccuracy") && options.getBoolean("enableHighAccuracy");
+            long timeout = options.hasKey("timeout") ? (long) options.getDouble("timeout") : 0;
+
+            Criteria criteria = new Criteria();
+            criteria.setAccuracy(enableHighAccuracy ? Criteria.ACCURACY_FINE : Criteria.ACCURACY_COARSE);
+
+            listener = new LocationListener() {
+                private boolean locationFound = false;
+
+                @Override
+                public synchronized void onLocationChanged(Location location) {
+                    if (location != null && !locationFound) {
+                        locationFound = true;
+                        WritableNativeMap resultLocation = new WritableNativeMap();
+                        resultLocation.putString("provider", location.getProvider());
+                        resultLocation.putDouble("latitude", location.getLatitude());
+                        resultLocation.putDouble("longitude", location.getLongitude());
+                        resultLocation.putDouble("accuracy", location.getAccuracy());
+                        resultLocation.putDouble("altitude", location.getAltitude());
+                        resultLocation.putDouble("speed", location.getSpeed());
+                        resultLocation.putDouble("bearing", location.getBearing());
+                        resultLocation.putDouble("time", location.getTime());
+                        promise.resolve(resultLocation);
+                        stop();
+                        clearReferences();
+                    }
+                }
+
+                @Override
+                public void onStatusChanged(String provider, int status, Bundle extras) {
+
+                }
+
+                @Override
+                public void onProviderEnabled(String provider) {
+
+                }
+
+                @Override
+                public void onProviderDisabled(String provider) {
+
+                }
+            };
+
+            locationManager.requestLocationUpdates(0L, 0F, criteria, listener, Looper.myLooper());
+
+            if (timeout > 0) {
+                timer = new Timer();
+                timer.schedule(new TimerTask() {
+                    @Override
+                    public void run() {
+                        try {
+                            promise.reject("TIMEOUT", "Location timed out");
+                            stop();
+                            clearReferences();
+                        } catch (Exception ex) {
+                            ex.printStackTrace();
+                        }
+                    }
+                }, timeout);
+            }
+        } catch (SecurityException ex) {
+            ex.printStackTrace();
+            stop();
+            promise.reject("UNAUTHORIZED", "Location permission denied", ex);
+        } catch (Exception ex) {
+            ex.printStackTrace();
+            stop();
+            promise.reject("UNAVAILABLE", "Location not available", ex);
+        }
+    }
+
+    public synchronized void cancel() {
+        if (promise == null) {
+            return;
+        }
+        try {
+            promise.reject("CANCELLED", "Location cancelled by another request");
+            stop();
+            clearReferences();
+        } catch (Exception ex) {
+            ex.printStackTrace();
+        }
+    }
+
+    private void stop() {
+        if (timer != null) {
+            timer.cancel();
+        }
+        if (listener != null) {
+            locationManager.removeUpdates(listener);
+        }
+    }
+
+    private void clearReferences() {
+        promise = null;
+        timer = null;
+        listener = null;
+    }
+
+    private boolean isLocationEnabled() {
+        try {
+            return locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER) ||
+                    locationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER);
+        } catch (Exception ex) {
+            ex.printStackTrace();
+        }
+        return false;
+    }
+}

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

@@ -0,0 +1,42 @@
+package com.shakebug;
+
+import android.content.Context;
+import android.net.Uri;
+import android.util.Log;
+
+import androidx.exifinterface.media.ExifInterface;
+
+import java.io.InputStream;
+
+public class ImageMetadata extends Metadata {
+    public ImageMetadata(Uri uri, Context context) {
+        try (InputStream inputStream = context.getContentResolver().openInputStream(uri)) {
+            ExifInterface exif = new ExifInterface(inputStream);
+            String datetimeTag = exif.getAttribute(ExifInterface.TAG_DATETIME);
+
+            // Extract anymore metadata here...
+            if (datetimeTag != null)
+                this.datetime = getDateTimeInUTC(datetimeTag, "yyyy:MM:dd HH:mm:ss");
+        } catch (Exception e) {
+            // This error does not bubble up to RN as we don't want failed datetime retrieval to prevent selection
+            Log.e("RNIP", "Could not load image metadata: " + e.getMessage());
+        }
+    }
+
+    @Override
+    public String getDateTime() {
+        return datetime;
+    }
+
+    // At the moment we are not using the ImageMetadata class to get width/height
+    // TODO: to use this class for extracting image width and height in the future
+    @Override
+    public int getWidth() {
+        return 0;
+    }
+
+    @Override
+    public int getHeight() {
+        return 0;
+    }
+}

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

@@ -0,0 +1,8 @@
+package com.shakebug;
+
+import androidx.core.content.FileProvider;
+
+// Two FileProvider class with same name will conflict during manifest merger, so we create a class which inherits from FileProvider with different name.
+// This prevents conflict if library users already have used the default FileProvider class.
+public class ImagePickerProvider extends FileProvider {
+}

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

@@ -0,0 +1,46 @@
+package com.shakebug;
+
+import android.util.Log;
+
+import androidx.annotation.Nullable;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.Locale;
+
+abstract class Metadata {
+    protected String datetime;
+    protected int height;
+    protected int width;
+
+    abstract public String getDateTime();
+
+    abstract public int getWidth();
+
+    abstract public int getHeight();
+
+    /**
+     * Converts a timestamp to a UTC timestamp
+     *
+     * @param value  - timestamp
+     * @param format - input format
+     * @return formatted timestamp
+     */
+    protected @Nullable
+    String getDateTimeInUTC(String value, String format) {
+        try {
+            Date datetime = new SimpleDateFormat(format, Locale.US).parse(value);
+            SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ", Locale.US);
+
+            if (datetime != null) {
+                return formatter.format(datetime);
+            }
+
+            return null;
+        } catch (Exception e) {
+            // This error does not bubble up to RN as we don't want failed datetime parsing to prevent selection
+            Log.e("RNIP", "Could not parse image datetime to UTC: " + e.getMessage());
+            return null;
+        }
+    }
+}

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

@@ -0,0 +1,79 @@
+/**
+ * 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.os.Build;
+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;
+
+/** Module that monitors and provides information about the connectivity state of the device. */
+@ReactModule(name = NetInfoModule.NAME)
+public class NetInfoModule extends ReactContextBaseJavaModule implements AmazonFireDeviceConnectivityPoller.ConnectivityChangedCallback {
+    public static final String NAME = "ShakebugSDKRNCNetInfo";
+
+    private final ConnectivityReceiver mConnectivityReceiver;
+    private final AmazonFireDeviceConnectivityPoller mAmazonConnectivityChecker;
+
+    private int numberOfListeners = 0;
+
+    public NetInfoModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+        // Create the connectivity receiver based on the API level we are running on
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+            mConnectivityReceiver = new NetworkCallbackConnectivityReceiver(reactContext);
+        } else {
+            mConnectivityReceiver = new BroadcastReceiverConnectivityReceiver(reactContext);
+        }
+
+        mAmazonConnectivityChecker = new AmazonFireDeviceConnectivityPoller(reactContext, this);
+    }
+
+    @Override
+    public void initialize() {
+        mConnectivityReceiver.register();
+        mAmazonConnectivityChecker.register();
+    }
+
+    @Override
+    public void onCatalystInstanceDestroy() {
+        mAmazonConnectivityChecker.unregister();
+        mConnectivityReceiver.unregister();
+        mConnectivityReceiver.hasListener = false;
+    }
+
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
+    @ReactMethod
+    public void getCurrentState(final String requestedInterface, final Promise promise) {
+        mConnectivityReceiver.getCurrentState(requestedInterface, promise);
+    }
+
+    @Override
+    public void onAmazonFireDeviceConnectivityChanged(boolean isConnected) {
+        mConnectivityReceiver.setIsInternetReachableOverride(isConnected);
+    }
+
+    @ReactMethod
+    public void addListener(String eventName) {
+        numberOfListeners++;
+        mConnectivityReceiver.hasListener = true;
+    }
+
+    @ReactMethod
+    public void removeListeners(Integer count) {
+        numberOfListeners -= count;
+        if (numberOfListeners == 0) {
+            mConnectivityReceiver.hasListener = false;
+        }
+    }
+}

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

@@ -0,0 +1,50 @@
+/**
+ * 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.Manifest;
+import android.annotation.SuppressLint;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.IntentFilter;
+import android.content.pm.PackageManager;
+import android.os.Build;
+
+import androidx.core.content.ContextCompat;
+
+public class NetInfoUtils {
+    public static void reverseByteArray(byte[] array) {
+        for (int i = 0; i < array.length / 2; i++) {
+            byte temp = array[i];
+            array[i] = array[array.length - i - 1];
+            array[array.length - i - 1] = temp;
+        }
+    }
+
+    public static boolean isAccessWifiStatePermissionGranted(Context context) {
+        return ContextCompat.checkSelfPermission(context,
+                Manifest.permission.ACCESS_WIFI_STATE) == PackageManager.PERMISSION_GRANTED;
+    }
+
+
+    /**
+     * Starting with Android 14, apps and services that target Android 14 and use context-registered
+     * receivers are required to specify a flag to indicate whether or not the receiver should be
+     * exported to all other apps on the device: either RECEIVER_EXPORTED or RECEIVER_NOT_EXPORTED
+     * <a href="https://developer.android.com/about/versions/14/behavior-changes-14#runtime-receivers-exported"/>
+     */
+    @SuppressLint("UnspecifiedRegisterReceiverFlag")
+    public static void compatRegisterReceiver(
+            Context context, BroadcastReceiver receiver, IntentFilter filter, boolean exported) {
+        if (Build.VERSION.SDK_INT >= 34 && context.getApplicationInfo().targetSdkVersion >= 34) {
+            context.registerReceiver(
+                    receiver, filter, exported ? Context.RECEIVER_EXPORTED : Context.RECEIVER_NOT_EXPORTED);
+        } else {
+            context.registerReceiver(receiver, filter);
+        }
+    }
+}

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

@@ -0,0 +1,209 @@
+/**
+ * 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.annotation.TargetApi;
+import android.net.ConnectivityManager;
+import android.net.LinkProperties;
+import android.net.Network;
+import android.net.NetworkCapabilities;
+import android.net.NetworkInfo;
+import android.os.Build;
+import android.os.Handler;
+import android.os.Looper;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.shakebug.types.CellularGeneration;
+import com.shakebug.types.ConnectionType;
+
+/**
+ * This gets the connectivity status using a NetworkCallback on the system default network. This
+ * method was added into Android from API level 24 (N) and we use it for all devices which support
+ * it.
+ */
+@TargetApi(Build.VERSION_CODES.N)
+public class NetworkCallbackConnectivityReceiver extends ConnectivityReceiver {
+    private static final int DELAY_MS = 250;
+    private final ConnectivityNetworkCallback mNetworkCallback;
+
+    // from the docs:
+    // "Do NOT call ConnectivityManager.getNetworkCapabilities(android.net.Network)
+    // or ConnectivityManager.getLinkProperties(android.net.Network) or other
+    // synchronous ConnectivityManager methods in this callback as this is
+    // prone to race conditions ; calling these methods while in a callback
+    // may return an outdated or even a null object."
+    // https://developer.android.com/reference/android/net/ConnectivityManager.NetworkCallback
+    // For this reason, we will fetch these values when not provided by the callback
+    // on an asynchronous thread.
+    private Network mNetwork = null;
+    private NetworkCapabilities mCapabilities = null;
+
+    public NetworkCallbackConnectivityReceiver(ReactApplicationContext reactContext) {
+        super(reactContext);
+        mNetworkCallback = new ConnectivityNetworkCallback();
+    }
+
+    @Override
+    @SuppressLint("MissingPermission")
+    public void register() {
+        try {
+            // Similar to BroadcastReceiver implementation, we need to force
+            // an initial callback call in order to get the current network state,
+            // otherwise, an app started without any network connection will
+            // always be reported as "unknown".
+            mNetwork = getConnectivityManager().getActiveNetwork();
+            asyncUpdateAndSend(0);
+
+            getConnectivityManager().registerDefaultNetworkCallback(mNetworkCallback);
+        } catch (SecurityException e) {
+            // TODO: Display a yellow box about this
+        }
+    }
+
+    @Override
+    public void unregister() {
+        try {
+            getConnectivityManager().unregisterNetworkCallback(mNetworkCallback);
+        } catch (SecurityException e) {
+            // TODO: Display a yellow box about this
+        } catch (IllegalArgumentException e) {
+            // ignore this, it is expected when the callback was not registered successfully
+        }
+    }
+
+    @SuppressLint("MissingPermission")
+    void updateAndSend() {
+        ConnectionType connectionType = ConnectionType.UNKNOWN;
+        CellularGeneration cellularGeneration = null;
+        NetworkInfo networkInfo = null;
+        boolean isInternetReachable = false;
+        boolean isInternetSuspended = false;
+
+        final Network network = mNetwork;
+        final NetworkCapabilities capabilities = mCapabilities;
+
+        if (capabilities != null) {
+            // Get the connection type
+            if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_BLUETOOTH)) {
+                connectionType = ConnectionType.BLUETOOTH;
+            } else if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)) {
+                connectionType = ConnectionType.CELLULAR;
+            } else if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_ETHERNET)) {
+                connectionType = ConnectionType.ETHERNET;
+            } else if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)) {
+                connectionType = ConnectionType.WIFI;
+            } else if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_VPN)) {
+                connectionType = ConnectionType.VPN;
+            }
+
+            if (network != null) {
+                // This may return null per API docs, and is deprecated, but for older APIs (< VERSION_CODES.P)
+                // we need it to test for suspended internet
+                try {
+                    networkInfo = getConnectivityManager().getNetworkInfo(network);
+                } catch (SecurityException e) {
+                // Android 11 may throw a 'package does not belong' security exception here.
+                // Google fixed Android 14, 13 and 12 with the issue where Chaland Jean patched those versions.
+                // Android 11 is too old, so that's why we have to catch this exception here to be safe.
+               //  https://android.googlesource.com/platform/frameworks/base/+/249be21013e389837f5b2beb7d36890b25ecfaaf%5E%21/
+                    networkInfo = null;
+                }
+            }
+
+            // Check to see if the network is temporarily unavailable or if airplane mode is toggled on
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+                isInternetSuspended = !capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_NOT_SUSPENDED);
+            } else {
+                if (network != null && networkInfo != null) {
+                    NetworkInfo.DetailedState detailedConnectionState = networkInfo.getDetailedState();
+                    if (!detailedConnectionState.equals(NetworkInfo.DetailedState.CONNECTED)) {
+                        isInternetSuspended = true;
+                    }
+                }
+            }
+
+            isInternetReachable =
+                    capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
+                            && capabilities.hasCapability(
+                            NetworkCapabilities.NET_CAPABILITY_VALIDATED)
+                            && !isInternetSuspended;
+
+            if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_VPN)) {
+                isInternetReachable = isInternetReachable && capabilities.getLinkDownstreamBandwidthKbps() != 0;
+            }
+
+            // Get the cellular network type
+            if (network != null && connectionType == ConnectionType.CELLULAR && isInternetReachable) {
+                cellularGeneration = CellularGeneration.fromNetworkInfo(networkInfo);
+            }
+        } else {
+            connectionType = ConnectionType.NONE;
+        }
+
+        updateConnectivity(connectionType, cellularGeneration, isInternetReachable);
+    }
+
+    private void asyncUpdateAndSend(int delay) {
+        new Handler(Looper.getMainLooper()).postDelayed(() -> {
+            try {
+                mCapabilities = getConnectivityManager().getNetworkCapabilities(mNetwork);
+                updateAndSend();
+            } catch (SecurityException e) {
+                // Android 11 may throw a 'package does not belong' security exception here.
+                // Google fixed Android 14, 13 and 12 with the issue where Chaland Jean patched those versions.
+                // Android 11 is too old, so that's why we have to catch this exception here to be safe.
+               //  https://android.googlesource.com/platform/frameworks/base/+/249be21013e389837f5b2beb7d36890b25ecfaaf%5E%21/
+                // We need to catch this to prevent app crash.
+            }
+        }, delay);
+    }
+
+    private class ConnectivityNetworkCallback extends ConnectivityManager.NetworkCallback {
+        @Override
+        public void onAvailable(Network network) {
+            mNetwork = network;
+            asyncUpdateAndSend(DELAY_MS);
+        }
+
+        @Override
+        public void onLosing(Network network, int maxMsToLive) {
+            mNetwork = network;
+            updateAndSend();
+        }
+
+        @Override
+        public void onLost(Network network) {
+            mNetwork = null;
+            mCapabilities = null;
+            updateAndSend();
+        }
+
+        @Override
+        public void onUnavailable() {
+            mNetwork = null;
+            mCapabilities = null;
+            updateAndSend();
+        }
+
+        @Override
+        public void onCapabilitiesChanged(
+                Network network, NetworkCapabilities networkCapabilities) {
+            mNetwork = network;
+            mCapabilities = networkCapabilities;
+            updateAndSend();
+        }
+
+        @Override
+        public void onLinkPropertiesChanged(Network network, LinkProperties linkProperties) {
+            if (mNetwork != null) {
+                mNetwork = network;
+            }
+            asyncUpdateAndSend(DELAY_MS);
+        }
+    }
+}

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

@@ -0,0 +1,42 @@
+package com.shakebug;
+
+import com.facebook.react.bridge.ReadableMap;
+
+import android.text.TextUtils;
+
+public class Options {
+    int selectionLimit;
+    Boolean includeBase64;
+    Boolean includeExtra;
+    int videoQuality = 1;
+    int quality;
+    int maxWidth;
+    int maxHeight;
+    Boolean saveToPhotos;
+    int durationLimit;
+    Boolean useFrontCamera = false;
+    String mediaType;
+
+
+    Options(ReadableMap options) {
+        mediaType = options.getString("mediaType");
+        selectionLimit = options.getInt("selectionLimit");
+        includeBase64 = options.getBoolean("includeBase64");
+        includeExtra = options.getBoolean("includeExtra");
+
+        String videoQualityString = options.getString("videoQuality");
+        if (!TextUtils.isEmpty(videoQualityString) && !videoQualityString.toLowerCase().equals("high")) {
+            videoQuality = 0;
+        }
+
+        if (options.getString("cameraType").equals("front")) {
+            useFrontCamera = true;
+        }
+
+        quality = (int) (options.getDouble("quality") * 100);
+        maxHeight = options.getInt("maxHeight");
+        maxWidth = options.getInt("maxWidth");
+        saveToPhotos = options.getBoolean("saveToPhotos");
+        durationLimit = options.getInt("durationLimit");
+    }
+}