shakebug-react-native 1.0.14

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

@@ -0,0 +1,318 @@
+/**
+ * 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.content.Context;
+import android.net.ConnectivityManager;
+import android.net.wifi.WifiInfo;
+import android.net.wifi.WifiManager;
+import android.telephony.TelephonyManager;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.shakebug.types.CellularGeneration;
+import com.shakebug.types.ConnectionType;
+
+import java.math.BigInteger;
+import java.net.Inet4Address;
+import java.net.InetAddress;
+import java.net.InterfaceAddress;
+import java.net.NetworkInterface;
+import java.net.SocketException;
+import java.util.Enumeration;
+import java.util.List;
+import java.util.Locale;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+public abstract class ConnectivityReceiver {
+
+    private final ConnectivityManager mConnectivityManager;
+    private final WifiManager mWifiManager;
+    private final TelephonyManager mTelephonyManager;
+    private final ReactApplicationContext mReactContext;
+    public boolean hasListener = false;
+
+    @Nonnull
+    private ConnectionType mConnectionType = ConnectionType.UNKNOWN;
+    @Nullable
+    private CellularGeneration mCellularGeneration = null;
+    private boolean mIsInternetReachable = false;
+    private Boolean mIsInternetReachableOverride;
+
+    private static String getSubnet(InetAddress inetAddress) throws SocketException {
+        NetworkInterface netAddress = NetworkInterface.getByInetAddress(inetAddress);
+        List<InterfaceAddress> addresses = netAddress.getInterfaceAddresses();
+
+        short networkPrefixLength = 0;
+        for (InterfaceAddress address : addresses) {
+            boolean isIpV4 = address.getAddress().getAddress().length == 4;
+            if (isIpV4) {
+                networkPrefixLength = address.getNetworkPrefixLength();
+                break;
+            }
+        }
+
+        int mask = 0xffffffff << (32 - networkPrefixLength);
+        return String.format(
+                Locale.US,
+                "%d.%d.%d.%d",
+                (mask >> 24 & 0xff),
+                (mask >> 16 & 0xff),
+                (mask >> 8 & 0xff),
+                (mask & 0xff));
+    }
+
+    ConnectivityReceiver(ReactApplicationContext reactContext) {
+        mReactContext = reactContext;
+        mConnectivityManager =
+                (ConnectivityManager) reactContext.getSystemService(Context.CONNECTIVITY_SERVICE);
+        mWifiManager =
+                (WifiManager)
+                        reactContext.getApplicationContext().getSystemService(Context.WIFI_SERVICE);
+        mTelephonyManager =
+                (TelephonyManager) reactContext.getSystemService(Context.TELEPHONY_SERVICE);
+    }
+
+    public abstract void register();
+
+    public abstract void unregister();
+
+    public void getCurrentState(@Nullable final String requestedInterface, final Promise promise) {
+        promise.resolve(createConnectivityEventMap(requestedInterface));
+    }
+
+    public void setIsInternetReachableOverride(boolean isInternetReachableOverride) {
+        this.mIsInternetReachableOverride = isInternetReachableOverride;
+        updateConnectivity(mConnectionType, mCellularGeneration, mIsInternetReachable);
+    }
+
+    public void clearIsInternetReachableOverride() {
+        this.mIsInternetReachableOverride = null;
+    }
+
+    ReactApplicationContext getReactContext() {
+        return mReactContext;
+    }
+
+    ConnectivityManager getConnectivityManager() {
+        return mConnectivityManager;
+    }
+
+    void updateConnectivity(
+            @Nonnull ConnectionType connectionType,
+            @Nullable CellularGeneration cellularGeneration,
+            boolean isInternetReachableRaw) {
+        boolean isInternetReachable = mIsInternetReachableOverride == null
+                ? isInternetReachableRaw
+                : mIsInternetReachableOverride;
+
+        // It is possible to get multiple broadcasts for the same connectivity change, so we only
+        // update and send an event when the connectivity has indeed changed.
+        boolean connectionTypeChanged = connectionType != mConnectionType;
+        boolean cellularGenerationChanged = cellularGeneration != mCellularGeneration;
+        boolean isInternetReachableChanged = isInternetReachable != mIsInternetReachable;
+
+        if (connectionTypeChanged || cellularGenerationChanged || isInternetReachableChanged) {
+            mConnectionType = connectionType;
+            mCellularGeneration = cellularGeneration;
+            mIsInternetReachable = isInternetReachable;
+            if (hasListener) {
+                sendConnectivityChangedEvent();
+            }
+        }
+    }
+
+    protected void sendConnectivityChangedEvent() {
+        getReactContext()
+                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                .emit("netInfo.networkStatusDidChange", createConnectivityEventMap(null));
+    }
+
+    protected WritableMap createConnectivityEventMap(@Nullable final String requestedInterface) {
+        WritableMap event = Arguments.createMap();
+
+        // Add if WiFi is ON or OFF
+        if (NetInfoUtils.isAccessWifiStatePermissionGranted(getReactContext())) {
+            boolean isEnabled = false;
+            if (mWifiManager != null) {
+              isEnabled = mWifiManager.isWifiEnabled();
+            }
+            event.putBoolean("isWifiEnabled", isEnabled);
+        }
+
+        // Add the connection type information
+        event.putString("type", requestedInterface != null ? requestedInterface : mConnectionType.label);
+
+        // Add the connection state information
+        boolean isConnected =
+                !mConnectionType.equals(ConnectionType.NONE)
+                && !mConnectionType.equals(ConnectionType.UNKNOWN);
+        event.putBoolean("isConnected", isConnected);
+
+        // Add the internet reachable information
+        event.putBoolean(
+                "isInternetReachable",
+                mIsInternetReachable && (requestedInterface == null || requestedInterface.equals(mConnectionType.label)));
+
+        // Add the details, if there are any
+        String detailsInterface = requestedInterface != null ? requestedInterface : mConnectionType.label;
+        WritableMap details = createDetailsMap(detailsInterface);
+        if (isConnected) {
+            boolean isConnectionExpensive =
+                    getConnectivityManager() == null ? true : getConnectivityManager().isActiveNetworkMetered();
+            details.putBoolean("isConnectionExpensive", isConnectionExpensive);
+        }
+        event.putMap("details", details);
+
+        return event;
+    }
+
+    private WritableMap createDetailsMap(@Nonnull String detailsInterface) {
+        WritableMap details = Arguments.createMap();
+        switch (detailsInterface) {
+            case "cellular":
+                // Add the cellular generation, if we have one
+                if (mCellularGeneration != null) {
+                    details.putString("cellularGeneration", mCellularGeneration.label);
+                }
+
+                // Add the network operator name, if there is one
+                String carrier = mTelephonyManager.getNetworkOperatorName();
+                if (carrier != null) {
+                    details.putString("carrier", carrier);
+                }
+                break;
+            case "ethernet":
+                try {
+                    for (Enumeration<NetworkInterface> en = NetworkInterface.getNetworkInterfaces(); en.hasMoreElements(); ) {
+                        NetworkInterface netInterface = en.nextElement();
+
+                        for (Enumeration<InetAddress> ea = netInterface.getInetAddresses(); ea.hasMoreElements(); ) {
+                            InetAddress inetAddress = ea.nextElement();
+                            if (!inetAddress.isLoopbackAddress() && inetAddress instanceof Inet4Address) {
+                                String ipAddress = inetAddress.getHostAddress();
+                                details.putString("ipAddress", ipAddress);
+                                details.putString("subnet", getSubnet(inetAddress));
+                                return details;
+                            }
+                        }
+                    }
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+                break;
+            case "wifi":
+                if (NetInfoUtils.isAccessWifiStatePermissionGranted(getReactContext()) && mWifiManager != null) {
+                    WifiInfo wifiInfo = mWifiManager.getConnectionInfo();
+                    if (wifiInfo != null) {
+                        // Get the SSID
+                        try {
+                            String initialSSID = wifiInfo.getSSID();
+                            if (initialSSID != null && !initialSSID.contains("<unknown ssid>")) {
+                                // Strip the quotes, if any
+                                String ssid = initialSSID.replace("\"", "");
+                                details.putString("ssid", ssid);
+                            }
+                        } catch (Exception e) {
+                            // Ignore errors
+                        }
+
+                        // Get the BSSID
+                        try {
+                            String bssid = wifiInfo.getBSSID();
+                            if (bssid != null) {
+                                details.putString("bssid", bssid);
+                            }
+                        } catch (Exception e) {
+                            // Ignore errors
+                        }
+
+
+                        // Get/parse the wifi signal strength
+                        try {
+                            int signalStrength =
+                                    WifiManager.calculateSignalLevel(wifiInfo.getRssi(), 100);
+                            details.putInt("strength", signalStrength);
+                        } catch (Exception e) {
+                            // Ignore errors
+                        }
+
+                        // Get WiFi frequency
+                        try {
+                            if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.LOLLIPOP) {
+                                int frequency = wifiInfo.getFrequency();
+                                details.putInt("frequency", frequency);
+                            }
+                        } catch (Exception e) {
+                            // Ignore errors
+                        }
+
+                        // Get the IP address
+                        try {
+                            byte[] ipAddressByteArray =
+                                    BigInteger.valueOf(wifiInfo.getIpAddress()).toByteArray();
+                            NetInfoUtils.reverseByteArray(ipAddressByteArray);
+                            InetAddress inetAddress = InetAddress.getByAddress(ipAddressByteArray);
+                            String ipAddress = inetAddress.getHostAddress();
+                            details.putString("ipAddress", ipAddress);
+                        } catch (Exception e) {
+                            // Ignore errors
+                        }
+
+                        // Get the subnet mask
+                        try {
+                            byte[] ipAddressByteArray =
+                                    BigInteger.valueOf(wifiInfo.getIpAddress()).toByteArray();
+                            NetInfoUtils.reverseByteArray(ipAddressByteArray);
+                            InetAddress inetAddress = InetAddress.getByAddress(ipAddressByteArray);
+                            details.putString("subnet", getSubnet(inetAddress));
+                        } catch (Exception e) {
+                            // Ignore errors
+                        }
+
+                        // Get the link speed
+                        try {
+                            int linkSpeed =
+                                    wifiInfo.getLinkSpeed();
+                            details.putInt("linkSpeed", linkSpeed);
+                        } catch (Exception e) {
+                            // Ignore errors
+                        }
+
+                        // Get the current receive link speed in Mbps
+                        try {
+                            if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.Q) {
+                                int rxLinkSpeed =
+                                        wifiInfo.getRxLinkSpeedMbps();
+                                details.putInt("rxLinkSpeed", rxLinkSpeed);
+                            }
+                        } catch (Exception e) {
+                            // Ignore errors
+                        }
+
+                        // Get the current transmit link speed in Mbps
+                        try {
+                            if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.Q) {
+                                int txLinkSpeed =
+                                        wifiInfo.getTxLinkSpeedMbps();
+                                details.putInt("txLinkSpeed", txLinkSpeed);
+                            }
+                        } catch (Exception e) {
+                            // Ignore errors
+                        }
+                    }
+                }
+                break;
+        }
+        return details;
+    }
+}

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

@@ -0,0 +1,48 @@
+package com.shakebug;
+
+import android.util.Log;
+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 CrashLoggerModule extends ReactContextBaseJavaModule implements Thread.UncaughtExceptionHandler {
+
+    private final ReactApplicationContext reactContext;
+    private Thread.UncaughtExceptionHandler defaultUEH;
+
+    public CrashLoggerModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+    this.reactContext = reactContext;
+    defaultUEH = Thread.getDefaultUncaughtExceptionHandler(); // Save default handler
+    Thread.setDefaultUncaughtExceptionHandler(this); // Set this class as the default handler
+    Log.d("CrashLogger", "Custom UncaughtExceptionHandler set.");
+}
+
+    @Override
+    public String getName() {
+        return "ShakebugSDKCrashLogger";
+    }
+
+    @Override
+    public void uncaughtException(Thread thread, Throwable e) {
+        // Handle the exception, prepare and send it to React Native
+        try {
+            String errorMessage = e.toString();
+            // Here, we simply log the error, but you can format it as needed
+            Log.e("CrashLogger", "Uncaught exception: " + errorMessage);
+            sendEvent(errorMessage);
+        } catch (Exception exception) {
+            Log.e("CrashLogger", "Error sending crash log to RN", exception);
+        }
+
+        defaultUEH.uncaughtException(thread, e); // Ensure default handler is called
+    }
+
+    private void sendEvent(String errorMessage) {
+        // Send error message to React Native
+        reactContext
+    .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+    .emit("CrashLog", errorMessage);
+    }
+}

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

@@ -0,0 +1,64 @@
+package com.shakebug;
+
+import android.text.TextUtils;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.Locale;
+
+/**
+ * Author：J.Chou
+ * Date：  2016.07.21 11:43.
+ * Email： who_know_me@163.com
+ * Describe:
+ */
+public final class DateUtil {
+
+  /**
+   * second to HH:MM:ss
+   * @param seconds
+   * @return
+   */
+  public static String convertSecondsToTime(long seconds) {
+    String timeStr = null;
+    int hour = 0;
+    int minute = 0;
+    int second = 0;
+    if (seconds <= 0)
+      return "00:00";
+    else {
+      minute = (int)seconds / 60;
+      if (minute < 60) {
+        second = (int)seconds % 60;
+        timeStr = unitFormat(minute) + ":" + unitFormat(second);
+      } else {
+        hour = minute / 60;
+        if (hour > 99)
+          return "99:59:59";
+        minute = minute % 60;
+        second = (int)(seconds - hour * 3600 - minute * 60);
+        timeStr = unitFormat(hour) + ":" + unitFormat(minute) + ":" + unitFormat(second);
+      }
+    }
+    return timeStr;
+  }
+
+  public static String convertSecondsToFormat(long seconds,String format){
+
+    if(TextUtils.isEmpty(format))
+      return "";
+
+    Date date = new Date(seconds);
+    SimpleDateFormat sdf = new SimpleDateFormat(format, Locale.getDefault());
+    return sdf.format(date);
+  }
+
+  private static String unitFormat(int i) {
+    String retStr = null;
+    if (i >= 0 && i < 10)
+      retStr = "0" + Integer.toString(i);
+    else
+      retStr = "" + i;
+    return retStr;
+  }
+}

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

@@ -0,0 +1,18 @@
+package com.shakebug;
+
+public enum DeviceType {
+    HANDSET ("Handset"),
+    TABLET ("Tablet"),
+    TV ("Tv"),
+    UNKNOWN ("unknown");
+
+    private final String value;
+
+    DeviceType(String value) {
+        this.value = value;
+    }
+
+    public String getValue() {
+        return value;
+    }
+}

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

@@ -0,0 +1,46 @@
+package com.shakebug;
+
+import android.app.ActivityManager;
+import android.content.Context;
+import android.content.pm.PackageManager;
+
+import java.util.List;
+
+/**
+ * Author：J.Chou
+ * Date：  2016.07.19 11:40.
+ * Email： who_know_me@163.com
+ * Describe:
+ */
+public final class DeviceUtil {
+
+  public static int getDeviceWidth() {
+    return BaseUtils.getContext().getResources().getDisplayMetrics().widthPixels;
+  }
+
+  public static int getDeviceHeight(){
+    return BaseUtils.getContext().getResources().getDisplayMetrics().heightPixels;
+  }
+
+  public static boolean hasAppInstalled(String pkgName) {
+    try {
+      BaseUtils.getContext().getPackageManager().getPackageInfo(pkgName, PackageManager.PERMISSION_GRANTED);
+      return true;
+    } catch (PackageManager.NameNotFoundException e) {
+      return false;
+    }
+  }
+
+  public static boolean isAppRunInBackground() {
+    ActivityManager activityManager = (ActivityManager) BaseUtils.getContext().getSystemService(Context.ACTIVITY_SERVICE);
+    List<ActivityManager.RunningAppProcessInfo> appProcesses = activityManager.getRunningAppProcesses();
+    for (ActivityManager.RunningAppProcessInfo appProcess : appProcesses) {
+      if (appProcess.processName.equals(BaseUtils.getContext().getPackageName())) {
+        // return true -> Run in background
+        // return false - > Run in foreground
+        return appProcess.importance != ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND;
+      }
+    }
+    return false;
+  }
+}

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

@@ -0,0 +1,90 @@
+package com.shakebug;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.view.MotionEvent;
+import android.view.View;
+
+public class DrawingView extends View {
+    private Bitmap bitmap;
+    private Canvas canvas;
+    private Paint paint;
+    private float lastX, lastY;
+
+    public DrawingView(Context context) {
+        super(context);
+        init();
+    }
+
+    private void init() {
+        // Initial paint setup
+        paint = new Paint();
+        paint.setColor(android.graphics.Color.BLACK);
+        paint.setStrokeWidth(10);
+        paint.setStyle(Paint.Style.STROKE);
+        paint.setAntiAlias(true);
+    }
+
+    @Override
+    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
+        super.onSizeChanged(w, h, oldw, oldh);
+        // Recreate the bitmap and canvas with the new dimensions
+        if (bitmap != null) {
+            bitmap.recycle();
+        }
+        bitmap = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888);
+        canvas = new Canvas(bitmap);
+    }
+
+    @Override
+    protected void onDraw(Canvas canvas) {
+        super.onDraw(canvas);
+        if (bitmap != null) {
+            canvas.drawBitmap(bitmap, 0, 0, null);
+        }
+    }
+
+    @Override
+    public boolean onTouchEvent(MotionEvent event) {
+        float x = event.getX();
+        float y = event.getY();
+
+        switch (event.getAction()) {
+            case MotionEvent.ACTION_DOWN:
+                lastX = x;
+                lastY = y;
+                return true;
+            case MotionEvent.ACTION_MOVE:
+                float dx = Math.abs(x - lastX);
+                float dy = Math.abs(y - lastY);
+                if (dx >= 4 || dy >= 4) {
+                    // Draw on the internal bitmap canvas
+                    canvas.drawLine(lastX, lastY, x, y, paint);
+                    invalidate();
+                    lastX = x;
+                    lastY = y;
+                }
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    public void setColor(int color) {
+        paint.setColor(color);
+    }
+
+    public void setStrokeWidth(float width) {
+        paint.setStrokeWidth(width);
+    }
+
+    public void clearCanvas() {
+        if (canvas != null) {
+            bitmap = Bitmap.createBitmap(bitmap.getWidth(), bitmap.getHeight(), Bitmap.Config.ARGB_8888);
+            canvas = new Canvas(bitmap);
+            invalidate();
+        }
+    }
+}

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

@@ -0,0 +1,38 @@
+package com.shakebug;
+
+import android.graphics.Color;
+
+import com.facebook.react.uimanager.SimpleViewManager;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.annotations.ReactProp;
+
+public class DrawingViewManager extends SimpleViewManager<DrawingView> {
+
+    @Override
+    public String getName() {
+        return "ShakebugSDKDrawingView";
+    }
+
+    @Override
+    protected DrawingView createViewInstance(ThemedReactContext context) {
+        return new DrawingView(context);
+    }
+
+    @ReactProp(name = "color", customType = "Color")
+    public void setColor(DrawingView view, int color) {
+        view.setColor(color);
+    }
+
+    @ReactProp(name = "strokeWidth")
+    public void setStrokeWidth(DrawingView view, float width) {
+        view.setStrokeWidth(width);
+    }
+
+    @ReactProp(name = "clearCanvas")
+    public void clearCanvas(DrawingView view, boolean clear) {
+        if (clear) {
+            view.clearCanvas();
+        }
+    }
+    
+}