react-native-gleapsdk 6.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 gleap
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,27 @@
+# Gleap ReactNative SDK
+
+![Gleap ReactNative SDK Intro](https://raw.githubusercontent.com/GleapSDK/iOS-SDK/main/imgs/gleapheader.png)
+
+The Gleap SDK for ReactNative is the easiest way to integrate Gleap into your apps!
+
+You have two ways to set up the Gleap SDK for ReactNative. The easiest way ist to use the maven repository to add Gleap SDK to your project.  (it's super easy to get started & worth using 😍)
+
+## Installation
+
+```sh
+npm install react-native-gleapsdk
+```
+
+## Usage
+
+```js
+// Import the SDK
+import Gleap from "react-native-gleapsdk";
+
+// Initialize it
+Gleap.initialize('ogWhNhuiZcGWrva5nlDS8l7a78OfaLlV');
+```
+
+## Need help?
+
+Checkout our full [documentation](https://docs.gleap.io/react-native/getting-started) or [contact us](https://gleap.io/) - we are always here to help 👋.

package/android/build.gradle

@@ -0,0 +1,61 @@
+buildscript {
+    if (project == rootProject) {
+        repositories {
+            google()
+            mavenCentral()
+            jcenter()
+        }
+
+        dependencies {
+            classpath 'com.android.tools.build:gradle:3.5.3'
+        }
+    }
+}
+
+apply plugin: 'com.android.library'
+
+def safeExtGet(prop, fallback) {
+    rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+}
+
+android {
+    compileSdkVersion safeExtGet('Gleapsdk_compileSdkVersion', 29)
+    defaultConfig {
+        minSdkVersion safeExtGet('Gleapsdk_minSdkVersion', 16)
+        targetSdkVersion safeExtGet('Gleapsdk_targetSdkVersion', 29)
+        versionCode 1
+        versionName "1.0"
+
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled false
+        }
+    }
+    lintOptions {
+        disable 'GradleCompatible'
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+}
+
+repositories {
+    mavenLocal()
+    maven {
+        // All of React Native (JS, Obj-C sources, Android binaries) is installed from npm
+        url("$rootDir/../node_modules/react-native/android")
+    }
+    google()
+    mavenCentral()
+}
+
+dependencies {
+    //noinspection GradleDynamicVersion
+    implementation "com.facebook.react:react-native:+"  // From node_modules
+    // https://mvnrepository.com/artifact/io.gleap/gleap-android-sdk
+    implementation group: 'io.gleap', name: 'gleap-android-sdk', version: '6.0.52'
+
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,4 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.reactnativegleapsdk">
+
+</manifest>

package/android/src/main/java/com/reactnativegleapsdk/GleapUtil.java

@@ -0,0 +1,66 @@
+package com.reactnativegleapsdk;
+
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableMapKeySetIterator;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+public class GleapUtil {
+  protected static JSONObject convertMapToJson(ReadableMap readableMap) throws JSONException {
+    JSONObject object = new JSONObject();
+    ReadableMapKeySetIterator iterator = readableMap.keySetIterator();
+    while (iterator.hasNextKey()) {
+      String key = iterator.nextKey();
+      switch (readableMap.getType(key)) {
+        case Null:
+          object.put(key, JSONObject.NULL);
+          break;
+        case Boolean:
+          object.put(key, readableMap.getBoolean(key));
+          break;
+        case Number:
+          object.put(key, readableMap.getDouble(key));
+          break;
+        case String:
+          object.put(key, readableMap.getString(key));
+          break;
+        case Map:
+          object.put(key, convertMapToJson(readableMap.getMap(key)));
+          break;
+        case Array:
+          object.put(key, convertArrayToJson(readableMap.getArray(key)));
+          break;
+      }
+    }
+    return object;
+  }
+
+  protected static JSONArray convertArrayToJson(ReadableArray readableArray) throws JSONException {
+    JSONArray array = new JSONArray();
+    for (int i = 0; i < readableArray.size(); i++) {
+      switch (readableArray.getType(i)) {
+        case Null:
+          break;
+        case Boolean:
+          array.put(readableArray.getBoolean(i));
+          break;
+        case Number:
+          array.put(readableArray.getDouble(i));
+          break;
+        case String:
+          array.put(readableArray.getString(i));
+          break;
+        case Map:
+          array.put(convertMapToJson(readableArray.getMap(i)));
+          break;
+        case Array:
+          array.put(convertArrayToJson(readableArray.getArray(i)));
+          break;
+      }
+    }
+    return array;
+  }
+}

package/android/src/main/java/com/reactnativegleapsdk/GleapsdkModule.java

@@ -0,0 +1,450 @@
+package com.reactnativegleapsdk;
+
+import static com.reactnativegleapsdk.GleapUtil.convertMapToJson;
+
+import android.app.Activity;
+import android.os.Build;
+import android.os.Handler;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+
+import com.facebook.react.ReactApplication;
+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.module.annotations.ReactModule;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.OutputStream;
+import java.util.Base64;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import io.gleap.APPLICATIONTYPE;
+import io.gleap.ConfigLoadedCallback;
+import io.gleap.CustomActionCallback;
+import io.gleap.FeedbackSentCallback;
+import io.gleap.FeedbackWillBeSentCallback;
+import io.gleap.Gleap;
+import io.gleap.GleapUserProperties;
+import io.gleap.RequestType;
+
+@ReactModule(name = GleapsdkModule.NAME)
+public class GleapsdkModule extends ReactContextBaseJavaModule {
+  public static final String NAME = "Gleapsdk";
+  private boolean isSilentBugReport = false;
+
+  public GleapsdkModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+  }
+
+  @Override
+  @NonNull
+  public String getName() {
+    return NAME;
+  }
+
+  /**
+   * Auto-configures the Gleap SDK from the remote config.
+   *
+   * @param sdkKey The SDK key, which can be found on dashboard.Gleap.io
+   */
+  @ReactMethod
+  public void initialize(String sdkKey) {
+    try {
+      Activity activity = getReactApplicationContext()
+        .getCurrentActivity();
+      if (activity != null) {
+        Gleap.getInstance().setApplicationType(APPLICATIONTYPE.REACTNATIVE);
+        Gleap.getInstance().setFeedbackWillBeSentCallback(new FeedbackWillBeSentCallback() {
+          @Override
+          public void flowInvoced() {
+            getReactApplicationContext().getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class).emit("feedbackWillBeSent", null);
+          }
+        });
+        Gleap.initialize(sdkKey, activity.getApplication());
+        Gleap.getInstance().setConfigLoadedCallback(new ConfigLoadedCallback() {
+          @Override
+          public void configLoaded(JSONObject jsonObject) {
+            System.out.println(jsonObject);
+            getReactApplicationContext().getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class).emit("configLoaded", jsonObject.toString());
+          }
+        });
+
+        Gleap.getInstance().registerCustomAction(new CustomActionCallback() {
+          @Override
+          public void invoke(String message) {
+            JSONObject obj = new JSONObject();
+            try {
+              obj.put("name", message);
+            } catch (JSONException e) {
+              e.printStackTrace();
+            }
+
+            getReactApplicationContext().getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class).emit("customActionTriggered", obj.toString());
+          }
+        });
+        Gleap.getInstance().setFeedbackSentCallback(new FeedbackSentCallback() {
+          @Override
+          public void close() {
+            new java.util.Timer().schedule(
+              new java.util.TimerTask() {
+                @Override
+                public void run() {
+                  showDevMenu();
+                }
+              },
+              500
+            );
+          }
+        });
+      }
+    } catch (Exception ex) {
+    }
+  }
+
+  /**
+   * Start bug report manually by calling this function.
+   */
+  @ReactMethod
+  public void startFeedbackFlow() {
+    try {
+      Gleap.getInstance().startFeedbackFlow();
+      Gleap.getInstance().setFeedbackSentCallback(new FeedbackSentCallback() {
+        @Override
+        public void close() {
+          new java.util.Timer().schedule(
+            new java.util.TimerTask() {
+              @Override
+              public void run() {
+                if (!isSilentBugReport) {
+                  showDevMenu();
+                } else {
+                  isSilentBugReport = false;
+                }
+              }
+            },
+            500
+          );
+        }
+      });
+    } catch (Exception e) {
+      System.out.println(e);
+    }
+  }
+
+  /**
+   * Manually start a silent bug reporting workflow.
+   */
+  @ReactMethod
+  public void sendSilentBugReport(
+    String description,
+    String priority
+  ) {
+    isSilentBugReport = true;
+    Gleap.SEVERITY severity = Gleap.SEVERITY.LOW;
+    if (priority == "MEDIUM") {
+      severity = Gleap.SEVERITY.MEDIUM;
+    }
+    if (priority == "HIGH") {
+      severity = Gleap.SEVERITY.HIGH;
+    }
+    Gleap.getInstance().sendSilentBugReport(description, severity);
+  }
+
+  @ReactMethod
+  public void setLanguage(String language) {
+    Gleap.getInstance().setLanguage(language);
+  }
+
+  @ReactMethod
+  public void identify(String userid, ReadableMap data) {
+    JSONObject jsonObject = null;
+    String name = "";
+    String email ="";
+    try {
+      jsonObject = convertMapToJson(data);
+      if(jsonObject.has("name")) {
+        name = jsonObject.getString("name");
+      }
+      if(jsonObject.has("email")) {
+        email = jsonObject.getString("email");
+      }
+    } catch (JSONException e) {
+      e.printStackTrace();
+    }
+    GleapUserProperties gleapUserSession = new GleapUserProperties(name, email);
+    Gleap.getInstance().identifyUser(userid, gleapUserSession);
+  }
+
+  @ReactMethod
+  public void clearIdentity() {
+    Gleap.getInstance().clearIdentity();
+  }
+
+  /**
+   * Attaches custom data, which can be viewed in the BugBattle dashboard. New data will be merged with existing custom data.
+   *
+   * @param customData The data to attach to a bug report.
+   * @author BugBattle
+   */
+  @ReactMethod
+  public void attachCustomData(ReadableMap customData) {
+    try {
+      JSONObject jsonObject = convertMapToJson(customData);
+      Gleap.getInstance().appendCustomData(jsonObject);
+    } catch (Exception e) {
+      System.out.println(e);
+    }
+
+  }
+
+  /**
+   * Used for dedicated server. Set the url, where bugs are reported to.
+   *
+   * @param apiUrl Url to the dedicated server.
+   */
+  @ReactMethod
+  public void setApiUrl(String apiUrl) {
+    try {
+      Gleap.getInstance().setApiUrl(apiUrl);
+    } catch (Exception e) {
+      System.out.println(e);
+    }
+  }
+
+  /**
+   * Used for dedicated server. Set the url, where the widget is loaded from.
+   *
+   * @param widgetUrl Url to the dedicated server.
+   */
+  @ReactMethod
+  public void setWidgetUrl(String widgetUrl) {
+    try {
+      Gleap.getInstance().setApiUrl(widgetUrl);
+    } catch (Exception e) {
+      System.out.println(e);
+    }
+  }
+
+  /**
+   * Attaches custom data, which can be viewed in the Gleap dashboard. New data will be merged with existing custom data.
+   *
+   * @param customData The data to attach to a bug report.
+   * @author Gleap
+   */
+  @ReactMethod
+  public void appendCustomData(ReadableMap customData) {
+    try {
+      JSONObject jsonObject = convertMapToJson(customData);
+      Gleap.getInstance().appendCustomData(jsonObject);
+    } catch (Exception e) {
+      System.out.println(e);
+    }
+  }
+
+  /**
+   * Attach one key value pair to existing custom data.
+   *
+   * @param value The value you want to add
+   * @param key   The key of the attribute
+   * @author Gleap
+   */
+  @ReactMethod
+  public void setCustomData(String key, String value) {
+    Gleap.getInstance().setCustomData(key, value);
+  }
+
+
+  /**
+   * Removes one key from existing custom data.
+   *
+   * @param key The key of the attribute
+   * @author Gleap
+   */
+  @ReactMethod
+  public void removeCustomDataForKey(String key) {
+    Gleap.getInstance().removeCustomDataForKey(key);
+  }
+
+  /**
+   * Clears all custom data.
+   */
+  @ReactMethod
+  public void clearCustomData() {
+    Gleap.getInstance().clearCustomData();
+  }
+
+  /**
+   * Log network traffic by logging it manually.
+   *
+   * @param networkLog Logs collected by rn
+   */
+  @ReactMethod
+  public void attachNetworkLog(String networkLog) {
+    try {
+      JSONArray object = new JSONArray(networkLog);
+      for (int i = 0; i < object.length(); i++) {
+        JSONObject currentRequest = (JSONObject) object.get(i);
+        JSONObject response = (JSONObject) currentRequest.get("response");
+        JSONObject request = new JSONObject();
+        if (currentRequest.has("request")) {
+          request = (JSONObject) currentRequest.get("request");
+        }
+        Gleap.getInstance().logNetwork(currentRequest.getString("url"), RequestType.valueOf(currentRequest.getString("type")), response.getInt("status"), currentRequest.getInt("duration"), request, response);
+      }
+
+    } catch (Exception ex) {
+      System.out.println(ex);
+    }
+  }
+
+  /**
+   * Logs a custom event
+   *
+   * @param name Name of the event
+   * @author Gleap
+   */
+  @ReactMethod
+  void logEvent(String name) {
+    Gleap.getInstance().logEvent(name);
+  }
+
+  /**
+   * Logs a custom event with data
+   *
+   * @param name Name of the event
+   * @param data Data passed with the event.
+   * @author Gleap
+   */
+  @ReactMethod
+  void logEvent(String name, ReadableMap data) {
+    JSONObject jsonObject = null;
+    try {
+      jsonObject = convertMapToJson(data);
+      Gleap.getInstance().logEvent(name, jsonObject);
+    } catch (JSONException e) {
+      e.printStackTrace();
+    }
+  }
+
+
+  @RequiresApi(api = Build.VERSION_CODES.O)
+  @ReactMethod
+  /**
+   * Attaches a file to the bug report
+   *
+   * @param file The file to attach to the bug report
+   * @author Gleap
+   */
+  void addAttachment(String base64file, String fileName) {
+    try {
+      if (checkAllowedEndings(fileName)) {
+        String[] splittedBase64File = base64file.split(",");
+        byte[] data;
+        if (splittedBase64File.length == 2) {
+          data = Base64.getDecoder().decode(splittedBase64File[1]);
+        } else {
+          data = Base64.getDecoder().decode(splittedBase64File[0]);
+        }
+
+        String mimetype = extractMimeType(base64file);
+        String[] splitted = mimetype.split("/");
+        String fileNameConcated = fileName;
+        if (splitted.length == 2 && !fileName.contains(".")) {
+          fileNameConcated += "." + splitted[1];
+        }
+
+        File file = new File(getReactApplicationContext().getCacheDir() + "/" + fileNameConcated);
+        if (!file.exists()) {
+          file.createNewFile();
+        }
+        try (OutputStream stream = new FileOutputStream(file)) {
+          stream.write(data);
+        } catch (Exception e) {
+          e.printStackTrace();
+        }
+
+        if (file.exists()) {
+          Gleap.getInstance().addAttachment(file);
+        } else {
+          System.err.println("Gleap: The file is not existing.");
+        }
+      }
+
+    } catch (Exception e) {
+      e.printStackTrace();
+    }
+
+  }
+
+  /**
+   * Extract the MIME type from a base64 string
+   *
+   * @param encoded Base64 string
+   * @return MIME type string
+   */
+  private String extractMimeType(final String encoded) {
+    final Pattern mime = Pattern.compile("^data:([a-zA-Z0-9]+/[a-zA-Z0-9]+).*,.*");
+    final Matcher matcher = mime.matcher(encoded);
+    if (!matcher.find())
+      return "";
+    return matcher.group(1).toLowerCase();
+  }
+
+  @ReactMethod
+  public void registerConfigLoadedAction(ConfigLoadedCallback configLoadedCallback) {
+    Gleap.getInstance().setConfigLoadedCallback(configLoadedCallback);
+  }
+
+  ;
+
+  private boolean checkAllowedEndings(String fileName) {
+    String[] fileType = fileName.split("\\.");
+    String[] allowedTypes = {"jpeg", "svg", "png", "mp4", "webp", "xml", "plain", "xml", "json"};
+    if (fileType.length <= 1) {
+      return false;
+    }
+    boolean found = false;
+    for (String type : allowedTypes) {
+      if (type.equals(fileType[1])) {
+        found = true;
+      }
+    }
+
+    return found;
+  }
+
+  /**
+   * Show dev menu after shaking the phone.
+   */
+  private void showDevMenu() {
+    final ReactApplication application = (ReactApplication) getReactApplicationContext()
+      .getCurrentActivity()
+      .getApplication();
+    Handler mainHandler = new Handler(this.getReactApplicationContext().getMainLooper());
+    Runnable myRunnable = new Runnable() {
+      @Override
+      public void run() {
+        try {
+          application
+            .getReactNativeHost()
+            .getReactInstanceManager()
+            .getDevSupportManager()
+            .showDevOptionsDialog();
+        } catch (Exception e) {
+          e.printStackTrace();
+        }
+      }
+    };
+    mainHandler.post(myRunnable);
+  }
+}

package/android/src/main/java/com/reactnativegleapsdk/GleapsdkPackage.java

@@ -0,0 +1,28 @@
+package com.reactnativegleapsdk;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class GleapsdkPackage implements ReactPackage {
+    @NonNull
+    @Override
+    public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
+        List<NativeModule> modules = new ArrayList<>();
+        modules.add(new GleapsdkModule(reactContext));
+        return modules;
+    }
+
+    @NonNull
+    @Override
+    public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
+        return Collections.emptyList();
+    }
+}

package/ios/Gleapsdk.h

@@ -0,0 +1,7 @@
+#import <React/RCTBridgeModule.h>
+#import <Gleap/Gleap.h>
+#import <React/RCTEventEmitter.h>
+
+@interface Gleapsdk : RCTEventEmitter <RCTBridgeModule, GleapDelegate>
+
+@end