@sodyo/react-native-sodyo-sdk 3.1.2

package/.gitattributes

@@ -0,0 +1 @@
+*.pbxproj -text

package/README.md

@@ -0,0 +1,131 @@
+
+# React Native Sodyo SDK Plugin that wraps Sodyo sdk for Android and iOS
+
+[SodyoSDK for iOS](https://github.com/sodyo-ltd/SodyoSDKPod) v3.54.24
+
+[SodyoSDK for Android](https://search.maven.org/search?q=a:sodyo-android-sdk) v3.54.30
+
+
+## Install
+    npm i @sodyo/react-native-sodyo-sdk -E
+
+If you using version of react-native < 60 then you have to make a link
+
+    react-native link
+    
+[Requires multidex support for android](https://medium.com/@aungmt/multidex-on-androidx-for-rn-0-60-x-cbb37c50d85)
+
+## Quick start
+Init the plugin with your Sodyo App Key project token with
+```
+import SodyoSdk from '@sodyo/react-native-sodyo-sdk'
+
+SodyoSDK.init(your-app-key,
+    function(){ /* successful init callback */ },
+    function(){ /* fail init callback */})
+```
+
+Use scanner as fragment (only after initialize SodyoSDK)
+```
+import { Scanner } from '@sodyo/react-native-sodyo-sdk'
+...
+<Scanner isEnabled={true}>
+    <Text>Children on top of the scanner</Text>
+</Scanner>
+```
+`isEnabled toggles the Scanners active / pause status.`
+
+Set the Sodyo error listener
+```
+SodyoSDK.onError(
+    function(err){ /* fail callback */ }
+)
+```
+`For unsubscribing just call the returned function`
+
+Open the Sodyo scanner
+```
+SodyoSDK.start(
+    function(markerData){ /* data content callback */ },
+    function(err){ /* fail */}
+)
+```
+
+Close Sodyo scanner (if scanner run by SodyoSDK.start())
+```
+SodyoSDK.close()
+```
+
+Marker content listener
+```
+SodyoSDK.onMarkerContent(
+    function(markerId, markerData){ /* successfully scanned marker */ },
+)
+```
+`For unsubscribing just call the returned function`
+
+Load marker by Id
+```
+SodyoSDK.performMarker(markerId)
+```
+
+Personal User Information (some object)
+
+```
+SodyoSDK.setUserInfo(userInfo)
+```
+
+
+User Identification (ID)
+```
+SodyoSDK.setAppUserId(userId)
+```
+
+Setting Scanner Preferences (some flat object)
+```
+SodyoSDK.setScannerParams(scannerPreferences)
+```
+
+Personalized Content
+```
+SodyoSDK.setCustomAdLabel(label)
+```
+`The label may include one or more tags in comma-separated values (CSV) format as follows: “label1,label2,label3”`
+
+Remove all listeners
+```
+SodyoSDK.removeAllListeners()
+```
+
+If you get an error similar to this when building Android:
+```
+More than one file was found with OS independent path 'META-INF/DEPENDENCIES'
+```
+
+then add in your `android/app/build.gradle` file add the following:
+```
+android {
+    ...
+
+    packagingOptions {
+        ...
+
+        exclude "META-INF/DEPENDENCIES.txt"
+        exclude "META-INF/LICENSE.txt"
+        exclude "META-INF/NOTICE.txt"
+        exclude "META-INF/NOTICE"
+        exclude "META-INF/LICENSE"
+        exclude "META-INF/DEPENDENCIES"
+        exclude "META-INF/notice.txt"
+        exclude "META-INF/license.txt"
+        exclude "META-INF/dependencies.txt"
+        exclude "META-INF/LGPL2.1"
+        exclude "META-INF/ASL2.0"
+        exclude "META-INF/maven/com.google.guava/guava/pom.properties"
+        exclude "META-INF/maven/com.google.guava/guava/pom.xml"
+    }
+}
+```
+
+
+For more examples see [the sample app](https://github.com/sodyo-ltd/react-native-sample-app)

package/RNSodyoSdk.podspec

@@ -0,0 +1,22 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+
+Pod::Spec.new do |s|
+  s.name         = "RNSodyoSdk"
+  s.version        = package['version']
+  s.summary        = package['description']
+  s.description    = package['description']
+  s.license        = package['license']
+  s.author         = package['author']
+  s.homepage       = package['homepage']
+  s.platform     = :ios, "11.0"
+  s.source       = { :git => "https://github.com/sodyo-ltd/SodyoSDKPod", :tag => "3.54.24" }
+  s.source_files  = "ios/**/*.{h,m}"
+  s.requires_arc = true
+
+  s.dependency "React"
+  s.dependency "SodyoSDK", "3.54.24"
+end
+

package/android/build.gradle

@@ -0,0 +1,62 @@
+apply plugin: 'com.android.library'
+
+def DEFAULT_COMPILE_SDK_VERSION             = 24
+def DEFAULT_BUILD_TOOLS_VERSION             = "25.0.2"
+def DEFAULT_TARGET_SDK_VERSION              = 22
+def DEFAULT_GOOGLE_PLAY_SERVICES_VERSION    = "+"
+
+buildscript {
+    repositories {
+        jcenter()
+        mavenCentral()
+    }
+
+    dependencies {
+        classpath 'com.android.tools.build:gradle:1.3.1'
+    }
+}
+
+
+android {
+    compileSdkVersion project.hasProperty('compileSdkVersion') ? project.compileSdkVersion : DEFAULT_COMPILE_SDK_VERSION
+    buildToolsVersion project.hasProperty('buildToolsVersion') ? project.buildToolsVersion : DEFAULT_BUILD_TOOLS_VERSION
+
+    defaultConfig {
+        minSdkVersion 16
+        targetSdkVersion project.hasProperty('targetSdkVersion') ? project.targetSdkVersion : DEFAULT_TARGET_SDK_VERSION
+        versionCode 2
+        versionName "1.1"
+        multiDexEnabled true
+    }
+    lintOptions {
+        abortOnError false
+    }
+
+    packagingOptions {
+      exclude "META-INF/DEPENDENCIES.txt"
+      exclude "META-INF/LICENSE.txt"
+      exclude "META-INF/NOTICE.txt"
+      exclude "META-INF/NOTICE"
+      exclude "META-INF/LICENSE"
+      exclude "META-INF/DEPENDENCIES"
+      exclude "META-INF/notice.txt"
+      exclude "META-INF/license.txt"
+      exclude "META-INF/dependencies.txt"
+      exclude "META-INF/LGPL2.1"
+      exclude "META-INF/ASL2.0"
+      exclude "META-INF/maven/com.google.guava/guava/pom.properties"
+      exclude "META-INF/maven/com.google.guava/guava/pom.xml"
+    }
+}
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    implementation ('com.facebook.react:react-native:+')
+    implementation ('com.sodyo:sodyo-android-sdk:3.54.30') {
+      transitive = true
+      exclude group: 'com.parse.bolts', module: 'bolts-android'
+    }
+}

package/android/src/main/AndroidManifest.xml

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

package/android/src/main/java/com/sodyo/RNSodyoSdk/ConversionUtil.java

@@ -0,0 +1,169 @@
+/**
+ * ConversionUtil.java
+ * react-native-eval
+ * <p>
+ * Created by Andy Prock on 9/24/15.
+ */
+
+package com.sodyo.RNSodyoSDK;
+
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableType;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.annotation.Nullable;
+
+/**
+ * Helper utilities to convert from react-native types to POJOs
+ */
+public final class ConversionUtil {
+    /**
+     * toObject extracts a value from a {@link ReadableMap} by its key,
+     * and returns a POJO representing that object.
+     *
+     * @param readableMap The Map to containing the value to be converted
+     * @param key The key for the value to be converted
+     * @return The converted POJO
+     */
+    public static  Object toObject(@Nullable ReadableMap readableMap, String key) {
+        if (readableMap == null) {
+            return null;
+        }
+
+        Object result;
+
+        ReadableType readableType = readableMap.getType(key);
+        switch (readableType) {
+            case Null:
+                result = key;
+                break;
+            case Boolean:
+                result = readableMap.getBoolean(key);
+                break;
+            case Number:
+                // Can be int or double.
+                double tmp = readableMap.getDouble(key);
+                if (tmp == (int) tmp) {
+                    result = (int) tmp;
+                } else {
+                    result = tmp;
+                }
+                break;
+            case String:
+                result = readableMap.getString(key);
+                break;
+            case Map:
+                result = toMap(readableMap.getMap(key));
+                break;
+            case Array:
+                result = toList(readableMap.getArray(key));
+                break;
+            default:
+                throw new IllegalArgumentException("Could not convert object with key: " + key + ".");
+        }
+
+        return result;
+    }
+
+    /**
+     * toMap converts a {@link ReadableMap} into a HashMap.
+     *
+     * @param readableMap The ReadableMap to be conveted.
+     * @return A HashMap containing the data that was in the ReadableMap.
+     */
+    public static  Map<String, Object> toMap(@Nullable ReadableMap readableMap) {
+        if (readableMap == null) {
+            return null;
+        }
+
+        com.facebook.react.bridge.ReadableMapKeySetIterator iterator = readableMap.keySetIterator();
+        if (!iterator.hasNextKey()) {
+            return null;
+        }
+
+        Map<String, Object> result = new HashMap<>();
+        while (iterator.hasNextKey()) {
+            String key = iterator.nextKey();
+            result.put(key, toObject(readableMap, key));
+        }
+
+        return result;
+    }
+
+    /**
+     * toFlatMap converts a {@link ReadableMap} into a HashMap<string, string>.
+     *
+     * @param readableMap The ReadableMap to be conveted.
+     * @return A HashMap containing the data that was in the ReadableMap.
+     */
+    public static  Map<String, String> toFlatMap(@Nullable ReadableMap readableMap) {
+        if (readableMap == null) {
+            return null;
+        }
+
+        com.facebook.react.bridge.ReadableMapKeySetIterator iterator = readableMap.keySetIterator();
+        if (!iterator.hasNextKey()) {
+            return null;
+        }
+
+        Map<String, String> result = new HashMap<>();
+        while (iterator.hasNextKey()) {
+            String key = iterator.nextKey();
+            result.put(key, readableMap.getString(key));
+        }
+
+        return result;
+    }
+
+    /**
+     * toList converts a {@link ReadableArray} into an ArrayList.
+     *
+     * @param readableArray The ReadableArray to be conveted.
+     * @return An ArrayList containing the data that was in the ReadableArray.
+     */
+    public static  List<Object> toList(@Nullable ReadableArray readableArray) {
+        if (readableArray == null) {
+            return null;
+        }
+
+        List<Object> result = new ArrayList<>(readableArray.size());
+        for (int index = 0; index < readableArray.size(); index++) {
+            ReadableType readableType = readableArray.getType(index);
+            switch (readableType) {
+                case Null:
+                    result.add(String.valueOf(index));
+                    break;
+                case Boolean:
+                    result.add(readableArray.getBoolean(index));
+                    break;
+                case Number:
+                    // Can be int or double.
+                    double tmp = readableArray.getDouble(index);
+                    if (tmp == (int) tmp) {
+                        result.add((int) tmp);
+                    } else {
+                        result.add(tmp);
+                    }
+                    break;
+                case String:
+                    result.add(readableArray.getString(index));
+                    break;
+                case Map:
+                    result.add(toMap(readableArray.getMap(index)));
+                    break;
+                case Array:
+                    result = toList(readableArray.getArray(index));
+                    break;
+                default:
+                    throw new IllegalArgumentException("Could not convert object with index: " + index + ".");
+            }
+        }
+
+        return result;
+    }
+}

package/android/src/main/java/com/sodyo/RNSodyoSdk/RNSodyoSdkModule.java

@@ -0,0 +1,293 @@
+package com.sodyo.RNSodyoSDK;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.Callback;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ActivityEventListener;
+import com.facebook.react.bridge.BaseActivityEventListener;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.facebook.react.bridge.UiThreadUtil;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.annotation.Nullable;
+
+import android.util.Log;
+import android.content.Intent;
+import android.app.Application;
+import android.app.Activity;
+import android.graphics.Color;
+
+import org.json.JSONObject;
+
+import com.sodyo.sdk.Sodyo;
+import com.sodyo.sdk.SodyoInitCallback;
+import com.sodyo.sdk.SodyoScannerActivity;
+import com.sodyo.sdk.SodyoScannerCallback;
+import com.sodyo.sdk.SodyoMarkerContentCallback;
+
+public class RNSodyoSdkModule extends ReactContextBaseJavaModule {
+  public static enum SodyoEnv {
+    DEV(3),
+    QA(0),
+    PROD(1);
+
+    private int value;
+
+    private SodyoEnv(int value) {
+      this.value = value;
+    }
+
+    public int getValue() {
+      return value;
+    }
+  }
+
+  private static final int SODYO_SCANNER_REQUEST_CODE = 2222;
+
+  private static final String TAG = "SodyoSDK";
+
+  private final ReactApplicationContext reactContext;
+
+  private final ActivityEventListener mActivityEventListener = new BaseActivityEventListener() {
+
+    @Override
+    public void onActivityResult(Activity activity, int requestCode, int resultCode, Intent intent) {
+      Log.i(TAG, "onActivityResult()");
+
+      if (requestCode == SODYO_SCANNER_REQUEST_CODE) {
+        sendEvent("EventCloseSodyoScanner", null);
+      }
+    }
+  };
+
+  public RNSodyoSdkModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+    this.reactContext = reactContext;
+    this.reactContext.addActivityEventListener(mActivityEventListener);
+  }
+
+  @Override
+  public String getName() {
+    return "RNSodyoSdk";
+  }
+
+  private class SodyoCallback implements SodyoScannerCallback, SodyoInitCallback, SodyoMarkerContentCallback {
+
+      private Callback successCallback;
+      private Callback errorCallback;
+      private boolean isCallbackUsed;
+
+      public SodyoCallback(Callback successCallback, Callback errorCallback) {
+          this.successCallback = successCallback;
+          this.errorCallback = errorCallback;
+      }
+
+      /**
+       * SodyoInitCallback implementation
+       */
+      public void onSodyoAppLoadSuccess() {
+          String message = "onSodyoAppLoadSuccess";
+          Log.i(TAG, message);
+
+          if (this.successCallback == null || this.isCallbackUsed) {
+            return;
+          }
+
+          this.successCallback.invoke();
+          this.isCallbackUsed = true;
+
+          SodyoCallback callbackClosure = new SodyoCallback(null, null);
+          Sodyo.getInstance().setSodyoScannerCallback(callbackClosure);
+          Sodyo.getInstance().setSodyoMarkerContentCallback(callbackClosure);
+      }
+
+      /**
+       * SodyoInitCallback implementation
+       */
+      public void onSodyoAppLoadFailed(String error) {
+          String message = "onSodyoAppLoadFailed. Error=\"" + error + "\"";
+          Log.e(TAG, message);
+
+          if (this.errorCallback == null || this.isCallbackUsed) {
+            return;
+          }
+
+          this.errorCallback.invoke(error);
+          this.isCallbackUsed = true;
+      }
+
+      /**
+       * SodyoInitCallback implementation
+       */
+      @Override
+      public void sodyoError(Error err) {
+          String message = "sodyoError. Error=\"" + err + "\"";
+          Log.e(TAG, message);
+
+          WritableMap params = Arguments.createMap();
+          params.putString("error", err.getMessage());
+          sendEvent("EventSodyoError", params);
+      }
+
+      /**
+       * SodyoScannerCallback implementation
+       */
+      @Override
+      public void onMarkerDetect(String markerType, String data, String error) {
+          Log.i(TAG, "onMarkerDetect()");
+
+          if (data == null) {
+              data = "null";
+          }
+
+          String message;
+
+          if (error == null) {
+              message = "SodyoScannerCallback.onMarkerDetect  data=\"" + data + "\"";
+              Log.i(TAG, message);
+              WritableMap params = Arguments.createMap();
+              params.putString("data", data);
+              sendEvent("EventMarkerDetectSuccess", params);
+          } else {
+              message = "SodyoScannerCallback.onMarkerDetect  data=\"" + data + "\" error=\"" + error + "\"";
+              Log.e(TAG, message);
+              WritableMap params = Arguments.createMap();
+              params.putString("error", error);
+              sendEvent("EventMarkerDetectError", params);
+          }
+      }
+
+      /**
+       * SodyoMarkerContentCallback implementation
+       */
+      @Override
+      public void onMarkerContent(String markerId, JSONObject data) {
+        Log.i(TAG, "onMarkerContent()");
+
+        WritableMap params = Arguments.createMap();
+        params.putString("markerId", markerId);
+
+        if (data == null) {
+          params.putString("data", "{}");
+        } else {
+          params.putString("data", data.toString());
+        }
+
+        sendEvent("EventMarkerContent", params);
+      }
+  }
+
+  @ReactMethod
+  public void init(final String apiKey, Callback successCallback, Callback errorCallback) {
+      Log.i(TAG, "init()");
+
+      if (Sodyo.isInitialized()) {
+          Log.i(TAG, "init(): already initialized, ignore");
+          return;
+      }
+
+      final SodyoCallback callbackClosure = new SodyoCallback(successCallback, errorCallback);
+
+      UiThreadUtil.runOnUiThread(new Runnable() {
+          @Override
+          public void run() {
+              Sodyo.init(
+                      (Application) reactContext.getApplicationContext(),
+                      apiKey,
+                      callbackClosure
+              );
+          }
+      });
+  }
+
+  @ReactMethod
+  public void start() {
+      Log.i(TAG, "start()");
+      Intent intent = new Intent(this.reactContext, SodyoScannerActivity.class);
+      Activity activity = getCurrentActivity();
+      activity.startActivityForResult(intent, SODYO_SCANNER_REQUEST_CODE);
+  }
+
+  @ReactMethod
+  public void close() {
+      Log.i(TAG, "close()");
+      Activity activity = getCurrentActivity();
+      activity.finishActivity(SODYO_SCANNER_REQUEST_CODE);
+  }
+
+  @ReactMethod
+  public void setUserInfo(ReadableMap userInfo) {
+      Log.i(TAG, "setUserInfo()");
+
+      if(userInfo != null) {
+        Sodyo.getInstance().setUserInfo(ConversionUtil.toMap(userInfo));
+      }
+  }
+
+  @ReactMethod
+  public void setCustomAdLabel(String label) {
+      Log.i(TAG, "setCustomAdLabel()");
+      Sodyo.setCustomAdLabel(label);
+  }
+
+  @ReactMethod
+  public void setAppUserId(String userId) {
+      Log.i(TAG, "setAppUserId()");
+      Sodyo.setAppUserId(userId);
+  }
+
+  @ReactMethod
+  public void setScannerParams(ReadableMap scannerPreferences) {
+      Log.i(TAG, "setScannerParams()");
+      Sodyo.setScannerParams(ConversionUtil.toFlatMap(scannerPreferences));
+  }
+
+  @ReactMethod
+  public void addScannerParam(String key, String value) {
+      Log.i(TAG, "addScannerParam()");
+      Sodyo.addScannerParams(key, value);
+  }
+
+  @ReactMethod
+    public void setDynamicProfileValue(String key, String value) {
+        Log.i(TAG, "setDynamicProfileValue()");
+        Sodyo.setDynamicProfileValue(key, value);
+    }
+
+  @ReactMethod
+  public void performMarker(String markerId) {
+      Log.i(TAG, "performMarker()");
+      Activity activity = getCurrentActivity();
+      Sodyo.performMarker(markerId, activity);
+  }
+
+  @ReactMethod
+  public void setSodyoLogoVisible(Boolean isVisible) {
+    Log.i(TAG, "setSodyoLogoVisible()");
+    Sodyo.setSodyoLogoVisible(isVisible);
+  }
+
+  @ReactMethod
+  private void setEnv(String env) {
+      Log.i(TAG, "setEnv:" + env);
+
+      Map<String, String> params = new HashMap<>();
+      String value = String.valueOf(SodyoEnv.valueOf(env.trim().toUpperCase()).getValue());
+      params.put("webad_env", value);
+      params.put("scanner_QR_code_enabled", "false");
+      Sodyo.setScannerParams(params);
+  }
+
+  private void sendEvent(String eventName, @Nullable WritableMap params) {
+    this.reactContext
+        .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+        .emit(eventName, params);
+  }
+}