shakebug-react-native 1.0.14

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

@@ -0,0 +1,124 @@
+package com.shakebug;
+
+import android.content.SharedPreferences;
+import android.content.Context;
+import android.util.Log;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+
+
+public class RNInstallReferrerClient {
+  private static Class<?> InstallReferrerClientClazz;
+  private static Class<?> InstallReferrerStateListenerClazz;
+  private static Class<?> ReferrerDetailsClazz;
+
+  static {
+    try {
+      InstallReferrerClientClazz = Class.forName("com.android.installreferrer.api.InstallReferrerClient");
+      InstallReferrerStateListenerClazz = Class.forName("com.android.installreferrer.api.InstallReferrerStateListener");
+      ReferrerDetailsClazz = Class.forName("com.android.installreferrer.api.ReferrerDetails");
+    } catch (Exception e) {
+      System.err.println("RNInstallReferrerClient exception. 'installreferrer' APIs are unavailable.");
+    }
+  }
+
+  private final SharedPreferences sharedPreferences;
+  private Object mReferrerClient;
+  private Object installReferrerStateListener;
+
+  // From InstallReferrerClient.InstallReferrerResponse
+  private static final int R_RESPONSE_OK                    = 0;
+  private static final int R_RESPONSE_SERVICE_UNAVAILABLE   = 1;
+  private static final int R_RESPONSE_FEATURE_NOT_SUPPORTED = 2;
+
+  RNInstallReferrerClient(Context context) {
+    sharedPreferences = context.getSharedPreferences("react-native-device-info", Context.MODE_PRIVATE);
+
+    if (InstallReferrerClientClazz == null || InstallReferrerStateListenerClazz == null || ReferrerDetailsClazz == null) {
+      return;
+    }
+
+    try {
+      // Build the InstallReferrerClient instance.
+      Method newBuilderMethod = InstallReferrerClientClazz.getMethod("newBuilder", Context.class);
+      Object builder = newBuilderMethod.invoke(null, context);
+      Method buildMethod = builder.getClass().getMethod("build");
+      mReferrerClient = buildMethod.invoke(builder);
+
+      // Create the InstallReferrerStateListener instance using a Proxy.
+      installReferrerStateListener = Proxy.newProxyInstance(
+          InstallReferrerStateListenerClazz.getClassLoader(),
+          new Class[]{InstallReferrerStateListenerClazz},
+          new InstallReferrerStateListenerProxy());
+
+      // Call startConnection on the client instance.
+      Method startConnectionMethod = InstallReferrerClientClazz.getMethod("startConnection", InstallReferrerStateListenerClazz);
+      startConnectionMethod.invoke(mReferrerClient, installReferrerStateListener);
+    } catch (Exception e) {
+      System.err.println("RNInstallReferrerClient exception. getInstallReferrer will be unavailable: " + e.getMessage());
+      e.printStackTrace(System.err);
+    }
+  }
+
+  private class InstallReferrerStateListenerProxy implements InvocationHandler {
+    @Override
+    public Object invoke(Object o, Method method, Object[] args) throws Throwable {
+      String methodName = method.getName();
+      try {
+          if (methodName.equals("onInstallReferrerSetupFinished") && args != null && args[0] instanceof Integer) {
+            onInstallReferrerSetupFinished((Integer) args[0]);
+          } else if (methodName.equals("onInstallReferrerServiceDisconnected")) {
+            onInstallReferrerServiceDisconnected();
+          }
+      } catch (Exception e) {
+        throw new RuntimeException("unexpected invocation exception: " + e.getMessage());
+      }
+
+      return null;
+    }
+
+    public void onInstallReferrerSetupFinished(int responseCode) {
+      switch (responseCode) {
+        case R_RESPONSE_OK:
+          // Connection established
+          try {
+            //if (BuildConfig.DEBUG)
+            Log.d("InstallReferrerState", "OK");
+            Method getInstallReferrerMethod = InstallReferrerClientClazz.getMethod("getInstallReferrer");
+            Object response = getInstallReferrerMethod.invoke(mReferrerClient);
+            Method getInstallReferrerMethod2 = ReferrerDetailsClazz.getMethod("getInstallReferrer");
+            String referrer = (String) getInstallReferrerMethod2.invoke(response);
+            SharedPreferences.Editor editor = sharedPreferences.edit();
+            editor.putString("installReferrer", referrer);
+            editor.apply();
+
+            Method endConnectionMethod = InstallReferrerClientClazz.getMethod("endConnection");
+            endConnectionMethod.invoke(mReferrerClient);
+          } catch (Exception e) {
+            System.err.println("RNInstallReferrerClient exception. getInstallReferrer will be unavailable: " + e.getMessage());
+            e.printStackTrace(System.err);
+          }
+          break;
+        case R_RESPONSE_FEATURE_NOT_SUPPORTED:
+          //if (BuildConfig.DEBUG)
+          Log.d("InstallReferrerState", "FEATURE_NOT_SUPPORTED");
+          // API not available on the current Play Store app
+          break;
+        case R_RESPONSE_SERVICE_UNAVAILABLE:
+          //if (BuildConfig.DEBUG)
+          Log.d("InstallReferrerState", "SERVICE_UNAVAILABLE");
+          // Connection could not be established
+          break;
+      }
+    }
+
+    public void onInstallReferrerServiceDisconnected() {
+      // Documentation indicates the InstallReferrer connection will be maintained
+      // So there is really nothing to do here
+      //if (BuildConfig.DEBUG)
+      Log.d("RNInstallReferrerClient", "InstallReferrerService disconnected");
+    }
+  }
+}

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

@@ -0,0 +1,79 @@
+package com.shakebug;
+
+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.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.module.annotations.ReactModule;
+
+@ReactModule(name = RNLocalizeModuleImpl.NAME)
+public class RNLocalizeModule extends ReactContextBaseJavaModule {
+
+  public RNLocalizeModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+  }
+
+  @NonNull
+  @Override
+  public String getName() {
+    return RNLocalizeModuleImpl.NAME;
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public String getCalendar() {
+    return RNLocalizeModuleImpl.getCalendar();
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public String getCountry() {
+    return RNLocalizeModuleImpl.getCountry(getReactApplicationContext());
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public WritableArray getCurrencies() {
+    return RNLocalizeModuleImpl.getCurrencies(getReactApplicationContext());
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public WritableArray getLocales() {
+    return RNLocalizeModuleImpl.getLocales(getReactApplicationContext());
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public WritableMap getNumberFormatSettings() {
+    return RNLocalizeModuleImpl.getNumberFormatSettings(getReactApplicationContext());
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public String getTemperatureUnit() {
+    return RNLocalizeModuleImpl.getTemperatureUnit(getReactApplicationContext());
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public String getTimeZone() {
+    return RNLocalizeModuleImpl.getTimeZone();
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public boolean uses24HourClock() {
+    return RNLocalizeModuleImpl.uses24HourClock(getReactApplicationContext());
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public boolean usesMetricSystem() {
+    return RNLocalizeModuleImpl.usesMetricSystem(getReactApplicationContext());
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public Boolean usesAutoDateAndTime() {
+    return RNLocalizeModuleImpl.usesAutoDateAndTime(getReactApplicationContext());
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public Boolean usesAutoTimeZone() {
+    return RNLocalizeModuleImpl.usesAutoTimeZone(getReactApplicationContext());
+  }
+}

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

@@ -0,0 +1,258 @@
+package com.shakebug;
+
+import android.annotation.SuppressLint;
+import android.content.ContentResolver;
+import android.content.res.Configuration;
+import android.os.Build;
+import android.provider.Settings;
+import android.text.TextUtils;
+import android.text.format.DateFormat;
+import android.view.View;
+
+import androidx.annotation.NonNull;
+import androidx.core.os.LocaleListCompat;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+
+import java.lang.reflect.Method;
+import java.text.DecimalFormatSymbols;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Currency;
+import java.util.List;
+import java.util.Locale;
+import java.util.Objects;
+import java.util.TimeZone;
+
+public class RNLocalizeModuleImpl {
+
+  public static final String NAME = "ShakebugSDKRNLocalize";
+
+  private static final List<String> USES_FAHRENHEIT =
+    Arrays.asList("BS", "BZ", "KY", "PR", "PW", "US");
+  private static final List<String> USES_IMPERIAL=
+    Arrays.asList("LR", "MM", "US");
+
+  // Internal
+
+  private static @NonNull String createLanguageTag(@NonNull String languageCode,
+                                                   @NonNull String scriptCode,
+                                                   @NonNull String countryCode) {
+    String languageTag = languageCode;
+
+    if (!TextUtils.isEmpty(scriptCode)) {
+      languageTag += "-" + scriptCode;
+    }
+
+    return languageTag + "-" + countryCode;
+  }
+
+  private static @NonNull String getCountryCodeForLocale(Locale locale) {
+    try {
+      String countryCode = locale.getCountry();
+
+      if (countryCode.equals("419")) {
+        return "UN";
+      }
+
+      return TextUtils.isEmpty(countryCode) ? "" : countryCode.toUpperCase();
+    } catch (Exception ignored) {
+      return "";
+    }
+  }
+
+  private static @NonNull String getCurrencyCodeForLocale(@NonNull Locale locale) {
+    try {
+      Currency currency = Currency.getInstance(locale);
+      return currency == null ? "" : currency.getCurrencyCode();
+    } catch (Exception ignored) {
+      return "";
+    }
+  }
+
+  private static @NonNull String getLanguageCodeForLocale(@NonNull Locale locale) {
+    String language = locale.getLanguage();
+
+    switch (language) {
+      case "iw":
+        return "he";
+      case "in":
+        return "id";
+      case "ji":
+        return "yi";
+    }
+
+    return language;
+  }
+
+  private static @NonNull String getScriptCodeForLocale(@NonNull Locale locale) {
+    String script = locale.getScript();
+    return TextUtils.isEmpty(script) ? "" : script;
+  }
+
+  private static @NonNull Locale getSystemLocale(ReactApplicationContext reactContext) {
+    Configuration config = reactContext
+      .getResources()
+      .getConfiguration();
+
+    return Build.VERSION.SDK_INT >= Build.VERSION_CODES.N
+      ? config.getLocales().get(0)
+      : config.locale;
+  }
+
+  private static @NonNull List<Locale> getSystemLocales(ReactApplicationContext reactContext) {
+    List<Locale> locales = new ArrayList<>();
+
+    Configuration config = reactContext
+      .getResources()
+      .getConfiguration();
+
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N) {
+      locales.add(config.locale);
+      return locales;
+    }
+
+    LocaleListCompat list = LocaleListCompat.getDefault();
+
+    for (int i = 0; i < list.size(); i++) {
+      locales.add(list.get(i));
+    }
+
+    return locales;
+  }
+
+  private static @NonNull String getMiuiRegionCode() {
+    try {
+      @SuppressLint("PrivateApi")
+      Class<?> systemProperties = Class.forName("android.os.SystemProperties");
+      Method get = systemProperties.getMethod("get", String.class);
+
+      return (String) Objects.requireNonNull(get.invoke(systemProperties, "ro.miui.region"));
+    } catch (Exception ignored) {
+      return "";
+    }
+  }
+
+  // Implementation
+
+  public static @NonNull String getCalendar() {
+    return "gregorian";
+  }
+
+  public static @NonNull String getCountry(ReactApplicationContext reactContext) {
+    String miuiRegionCode = getMiuiRegionCode();
+
+    if (!TextUtils.isEmpty((miuiRegionCode))) {
+      return miuiRegionCode;
+    }
+
+    Locale systemLocale = getSystemLocale(reactContext);
+    String countryCode = getCountryCodeForLocale(systemLocale);
+
+    if (TextUtils.isEmpty(countryCode)) {
+      return "US";
+    }
+
+    return countryCode;
+  }
+
+  public static @NonNull WritableArray getCurrencies(ReactApplicationContext reactContext) {
+    List<Locale> systemLocales = getSystemLocales(reactContext);
+    List<String> currenciesList = new ArrayList<>();
+    WritableArray currencies = Arguments.createArray();
+
+    for (Locale systemLocale: systemLocales) {
+      String currencyCode = getCurrencyCodeForLocale(systemLocale);
+
+      if (!TextUtils.isEmpty(currencyCode) && !currenciesList.contains(currencyCode)) {
+        currenciesList.add(currencyCode);
+        currencies.pushString(currencyCode);
+      }
+    }
+
+    if (currencies.size() == 0) {
+      currencies.pushString("USD");
+    }
+
+    return currencies;
+  }
+
+  public static @NonNull WritableArray getLocales(ReactApplicationContext reactContext) {
+    List<Locale> systemLocales = getSystemLocales(reactContext);
+    List<String> languageTagsList = new ArrayList<>();
+    WritableArray locales = Arguments.createArray();
+    String currentCountryCode = getCountry(reactContext);
+
+    for (Locale systemLocale: systemLocales) {
+      String languageCode = getLanguageCodeForLocale(systemLocale);
+      String scriptCode = getScriptCodeForLocale(systemLocale);
+      String countryCode = getCountryCodeForLocale(systemLocale);
+
+      if (TextUtils.isEmpty(countryCode)) {
+        countryCode = currentCountryCode;
+      }
+
+      String languageTag = createLanguageTag(languageCode, scriptCode, countryCode);
+      WritableMap locale = Arguments.createMap();
+
+      locale.putString("languageCode", languageCode);
+      locale.putString("countryCode", countryCode);
+      locale.putString("languageTag", languageTag);
+      locale.putBoolean("isRTL",
+        TextUtils.getLayoutDirectionFromLocale(systemLocale) == View.LAYOUT_DIRECTION_RTL);
+
+      if (!TextUtils.isEmpty(scriptCode)) {
+        locale.putString("scriptCode", scriptCode);
+      }
+
+      if (!languageTagsList.contains(languageTag)) {
+        languageTagsList.add(languageTag);
+        locales.pushMap(locale);
+      }
+    }
+
+    return locales;
+  }
+
+  public static @NonNull WritableMap getNumberFormatSettings(ReactApplicationContext reactContext) {
+    Locale systemLocale = getSystemLocale(reactContext);
+    DecimalFormatSymbols symbols = new DecimalFormatSymbols(systemLocale);
+    WritableMap settings = Arguments.createMap();
+
+    settings.putString("decimalSeparator", String.valueOf(symbols.getDecimalSeparator()));
+    settings.putString("groupingSeparator", String.valueOf(symbols.getGroupingSeparator()));
+
+    return settings;
+  }
+
+  public static @NonNull String getTemperatureUnit(ReactApplicationContext reactContext) {
+    String currentCountryCode = getCountry(reactContext);
+    return USES_FAHRENHEIT.contains(currentCountryCode) ? "fahrenheit" : "celsius";
+  }
+
+  public static @NonNull String getTimeZone() {
+    return TimeZone.getDefault().getID();
+  }
+
+  public static boolean uses24HourClock(ReactApplicationContext reactContext) {
+    return DateFormat.is24HourFormat(reactContext);
+  }
+
+  public static boolean usesMetricSystem(ReactApplicationContext reactContext) {
+    String currentCountryCode = getCountry(reactContext);
+    return !USES_IMPERIAL.contains(currentCountryCode);
+  }
+
+  public static boolean usesAutoDateAndTime(ReactApplicationContext reactContext) {
+    ContentResolver resolver = reactContext.getContentResolver();
+    return Settings.Global.getInt(resolver, Settings.Global.AUTO_TIME, 0) != 0;
+  }
+
+  public static boolean usesAutoTimeZone(ReactApplicationContext reactContext) {
+    ContentResolver resolver = reactContext.getContentResolver();
+    return Settings.Global.getInt(resolver, Settings.Global.AUTO_TIME_ZONE, 0) != 0;
+  }
+}

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

@@ -0,0 +1,95 @@
+package com.shakebug;
+
+import android.content.Context;
+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 androidx.annotation.RequiresPermission;
+import android.util.Log;
+
+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.WritableNativeMap;
+import com.shakebug.GetLocation;
+import com.shakebug.SettingsUtil;
+
+import java.util.Timer;
+import java.util.TimerTask;
+
+public class ReactNativeGetLocationModule extends ReactContextBaseJavaModule {
+
+    public static final String NAME = "ShakebugSDKReactNativeGetLocation";
+
+    private LocationManager locationManager;
+    private GetLocation getLocation;
+
+    public ReactNativeGetLocationModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+        try {
+            locationManager = (LocationManager) reactContext.getApplicationContext().getSystemService(Context.LOCATION_SERVICE);
+        } catch (Exception ex) {
+            ex.printStackTrace();
+        }
+    }
+
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
+    @ReactMethod
+    public void openWifiSettings(final Promise primise) {
+        try {
+            SettingsUtil.openWifiSettings(getReactApplicationContext());
+            primise.resolve(null);
+        } catch (Throwable ex) {
+            primise.reject(ex);
+        }
+    }
+
+    @ReactMethod
+    public void openCelularSettings(final Promise primise) {
+        try {
+            SettingsUtil.openCelularSettings(getReactApplicationContext());
+            primise.resolve(null);
+        } catch (Throwable ex) {
+            primise.reject(ex);
+        }
+    }
+
+    @ReactMethod
+    public void openGpsSettings(final Promise primise) {
+        try {
+            SettingsUtil.openGpsSettings(getReactApplicationContext());
+            primise.resolve(null);
+        } catch (Throwable ex) {
+            primise.reject(ex);
+        }
+    }
+
+    @ReactMethod
+    public void openAppSettings(final Promise promise) {
+        try {
+            SettingsUtil.openAppSettings(getReactApplicationContext());
+            promise.resolve(null);
+        } catch (Throwable ex) {
+            promise.reject(ex);
+        }
+    }
+
+    @ReactMethod
+    public void getCurrentPosition(ReadableMap options, Promise promise) {
+        if (getLocation != null) {
+            getLocation.cancel();
+        }
+        getLocation = new GetLocation(locationManager);
+        getLocation.get(options, promise);
+    }
+
+}