airbridge-react-native-sdk-restricted 2.5.2

package/android/src/main/java/co/ab180/airbridge/reactnative/AirbridgeRN.java

@@ -0,0 +1,82 @@
+package co.ab180.airbridge.reactnative;
+
+import android.app.Application;
+import android.content.Intent;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.JavaScriptModule;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import javax.annotation.Nonnull;
+
+import co.ab180.airbridge.Airbridge;
+
+public class AirbridgeRN implements ReactPackage {
+
+    //
+    // init
+    //
+
+    /**
+     * Initialize Airbridge SDK
+     * <p>
+     * You should call this method on MainApplication#onCreate
+     *
+     * @param   application
+     *              context from MainApplication#onCreate
+     * @param   appName
+     *              App Name in English
+     * @param   appToken
+     *              App Token
+     */
+    public static void init(@Nonnull Application application, @Nonnull String appName, @Nonnull String appToken) {
+        Airbridge.init(application, ConfigReader.build(appName, appToken, application));
+    }
+
+    //
+    // deeplink
+    //
+
+    /**
+     * You can give deeplink information to Airbridge SDK with this method
+     *
+     * @param   intent
+     *              intent from MainActivity#onResume
+     */
+    public static void processDeeplinkData(final Intent intent) {
+        AirbridgeDeeplink.processDeeplinkData(intent);
+    }
+
+    //
+    // override
+    //
+
+    @Override
+    @Nonnull
+    public List<NativeModule> createNativeModules(@Nonnull ReactApplicationContext reactContext) {
+        return Arrays.<NativeModule>asList(
+                new AirbridgeEvent(reactContext),
+                new AirbridgeDeeplink(reactContext),
+                new AirbridgeState(reactContext),
+                new AirbridgePlacement(reactContext),
+                new AirbridgeAttribution(reactContext)
+        );
+    }
+
+    // Deprecated from RN 0.47
+    public List<Class<? extends JavaScriptModule>> createJSModules() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    @Nonnull
+    public List<ViewManager> createViewManagers(@Nonnull ReactApplicationContext reactContext) {
+        return Collections.emptyList();
+    }
+}

package/android/src/main/java/co/ab180/airbridge/reactnative/AirbridgeState.java

@@ -0,0 +1,174 @@
+package co.ab180.airbridge.reactnative;
+
+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 java.util.HashMap;
+import java.util.Map;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+import co.ab180.airbridge.Airbridge;
+import co.ab180.airbridge.AirbridgeCallback;
+
+public class AirbridgeState extends ReactContextBaseJavaModule {
+    public AirbridgeState(ReactApplicationContext reactContext) {
+        super(reactContext);
+    }
+
+    //
+    // react native method
+    //
+
+    @ReactMethod
+    public void setUser(@Nullable ReadableMap user) {
+        HashMap userMap = null;
+        if (user != null) {
+            userMap = user.toHashMap();
+        }
+
+        String id = Get.type(String.class, userMap, "ID");
+        String email = Get.type(String.class, userMap, "email");
+        String phone = Get.type(String.class, userMap, "phone");
+        Map<String, String> alias = Get.type(HashMap.class, userMap, "alias");
+        Map<String, ?> attributes = Get.type(HashMap.class, userMap, "attributes");
+
+        Airbridge.getCurrentUser().setId(id);
+        Airbridge.getCurrentUser().setEmail(email);
+        Airbridge.getCurrentUser().setPhone(phone);
+
+        if (alias != null) {
+            for (Map.Entry<String, String> entry : alias.entrySet()) {
+                Airbridge.getCurrentUser().setAlias(entry.getKey(), entry.getValue());
+            }
+        } else {
+            Airbridge.getCurrentUser().clearAlias();
+        }
+
+        if (attributes != null) {
+            for (Map.Entry<String, ?> entry : attributes.entrySet()) {
+                String key = entry.getKey();
+                Object value = entry.getValue();
+
+                if (value instanceof String) {
+                    Airbridge.getCurrentUser().setAttribute(key, (String) value);
+                } else if (value instanceof Long) {
+                    Airbridge.getCurrentUser().setAttribute(key, (Long) value);
+                } else if (value instanceof Integer) {
+                    Airbridge.getCurrentUser().setAttribute(key, (Integer) value);
+                } else if (value instanceof Double || value instanceof Float) {
+                    Airbridge.getCurrentUser().setAttribute(key, ((Number) value).floatValue());
+                } else if (value instanceof Boolean) {
+                    Airbridge.getCurrentUser().setAttribute(key, (Boolean) value);
+                }
+            }
+        } else {
+            Airbridge.getCurrentUser().clearAttributes();
+        }
+    }
+
+    @ReactMethod
+    public void updateUser(@Nullable ReadableMap user) {
+        HashMap userMap = null;
+        if (user != null) {
+            userMap = user.toHashMap();
+        }
+
+        String id = Get.type(String.class, userMap, "ID");
+        String email = Get.type(String.class, userMap, "email");
+        String phone = Get.type(String.class, userMap, "phone");
+        Map<String, String> alias = Get.type(HashMap.class, userMap, "alias");
+        Map<String, ?> attributes = Get.type(HashMap.class, userMap, "attributes");
+
+        if (id != null) {
+            Airbridge.getCurrentUser().setId(id);
+        }
+
+        if (email != null) {
+            Airbridge.getCurrentUser().setEmail(email);
+        }
+
+        if (phone != null) {
+            Airbridge.getCurrentUser().setPhone(phone);
+        }
+
+        if (alias != null) {
+            for (Map.Entry<String, String> entry : alias.entrySet()) {
+                Airbridge.getCurrentUser().setAlias(entry.getKey(), entry.getValue());
+            }
+        }
+
+        if (attributes != null) {
+            for (Map.Entry<String, ?> entry : attributes.entrySet()) {
+                String key = entry.getKey();
+                Object value = entry.getValue();
+
+                if (value instanceof String) {
+                    Airbridge.getCurrentUser().setAttribute(key, (String) value);
+                } else if (value instanceof Long) {
+                    Airbridge.getCurrentUser().setAttribute(key, (Long) value);
+                } else if (value instanceof Integer) {
+                    Airbridge.getCurrentUser().setAttribute(key, (Integer) value);
+                } else if (value instanceof Double || value instanceof Float) {
+                    Airbridge.getCurrentUser().setAttribute(key, ((Number) value).floatValue());
+                } else if (value instanceof Boolean) {
+                    Airbridge.getCurrentUser().setAttribute(key, (Boolean) value);
+                }
+            }
+        }
+    }
+
+    @ReactMethod
+    public void startTracking() {
+        Airbridge.startTracking();
+    }
+
+    @ReactMethod
+    public void deviceUUID(final Promise promise) {
+        Airbridge.getDeviceInfo().getUUID(new AirbridgeCallback.SimpleCallback<String>() {
+            @Override
+            public void onSuccess(String uuid) {
+                promise.resolve(uuid);
+            }
+
+            @Override
+            public void onFailure(Throwable throwable) {
+                promise.reject(throwable);
+            }
+        });
+    }
+
+    @ReactMethod
+    public void setDeviceAlias(String key, String value) {
+        Airbridge.setDeviceAlias(key, value);
+    }
+
+    @ReactMethod
+    public void removeDeviceAlias(String key) {
+        Airbridge.removeDeviceAlias(key);
+    }
+
+    @ReactMethod
+    public void clearDeviceAlias() {
+        Airbridge.clearDeviceAlias();
+    }
+
+    @ReactMethod
+    public void registerPushToken(String token) {
+        Airbridge.registerPushToken(token);
+    }
+
+    //
+    // override
+    //
+
+    @Override
+    @Nonnull
+    public String getName() {
+        return "AirbridgeState";
+    }
+}

package/android/src/main/java/co/ab180/airbridge/reactnative/ConfigReader.java

@@ -0,0 +1,108 @@
+package co.ab180.airbridge.reactnative;
+
+import android.content.Context;
+import android.content.res.AssetManager;
+import android.util.Log;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Map;
+import java.util.HashMap;
+
+import co.ab180.airbridge.AirbridgeConfig;
+import co.ab180.airbridge.OnAttributionResultReceiveListener;
+
+class ConfigReader {
+    private ConfigReader() {}
+
+    static AirbridgeConfig build(String appName, String appToken, Context context) {
+        AirbridgeConfig.Builder configBuilder = new AirbridgeConfig.Builder(appName, appToken);
+
+        JSONObject configObject = null;
+        AssetManager assetManager = context.getAssets();
+        try {
+            BufferedReader reader = new BufferedReader(
+                    new InputStreamReader(
+                            assetManager.open("airbridge.json")
+                    )
+            );
+            
+            StringBuilder builder = new StringBuilder();
+
+            String line = reader.readLine();
+            while (line != null) {
+                builder.append(line);
+                line = reader.readLine();
+            }
+
+            configObject = new JSONObject(builder.toString());
+        } catch (IOException ignored) {
+            // when do not use airbridge.json file
+        } catch (JSONException e) {
+            Log.w("AirbridgeRN", "airbridge.json is not json format");
+        }
+
+        Number sessionTimeoutSeconds = Get.type(Number.class, configObject, "sessionTimeoutSeconds");
+        if (sessionTimeoutSeconds != null) {
+            configBuilder.setSessionTimeoutSeconds(sessionTimeoutSeconds.longValue());
+        }
+
+        Boolean autoStartTrackingEnabled = Get.type(Boolean.class, configObject, "autoStartTrackingEnabled");
+        if (autoStartTrackingEnabled != null) {
+            configBuilder.setAutoStartTrackingEnabled(autoStartTrackingEnabled);
+        }
+
+        Boolean userInfoHashEnabled = Get.type(Boolean.class, configObject, "userInfoHashEnabled");
+        if (userInfoHashEnabled != null) {
+            configBuilder.setUserInfoHashEnabled(userInfoHashEnabled);
+        }
+
+        Boolean trackAirbridgeLinkOnly = Get.type(Boolean.class, configObject, "trackAirbridgeLinkOnly");
+        if (trackAirbridgeLinkOnly != null) {
+            configBuilder.setTrackAirbridgeLinkOnly(trackAirbridgeLinkOnly);
+        }
+
+        Boolean locationCollectionEnabled = Get.type(Boolean.class, configObject, "locationCollectionEnabled");
+        if (locationCollectionEnabled != null) {
+            configBuilder.setLocationCollectionEnabled(locationCollectionEnabled);
+        }
+
+        Boolean facebookDeferredAppLinkEnabled = Get.type(Boolean.class, configObject, "facebookDeferredAppLinkEnabled");
+        if (facebookDeferredAppLinkEnabled != null) {
+            configBuilder.setFacebookDeferredAppLinkEnabled(facebookDeferredAppLinkEnabled);
+        }
+
+        String secretId = Get.type(String.class, configObject, "sdkSignatureSecretID");
+        String secretKey = Get.type(String.class, configObject, "sdkSignatureSecret");
+        if (secretId != null && secretKey != null) {
+            configBuilder.setSDKSignatureSecret(secretId, secretKey);
+        }
+
+        String logLevel = Get.type(String.class, configObject, "logLevel");
+        Map<String, Integer> logLevelMap = new HashMap<String, Integer>() {{
+            put("debug", Log.VERBOSE);
+            put("info", Log.INFO);
+            put("warning", Log.WARN);
+            put("error", Log.ERROR);
+            put("fault", Log.ASSERT);
+        }};
+        Integer resultLogLevel = logLevelMap.get(logLevel != null ? logLevel.toLowerCase() : null);
+        resultLogLevel = resultLogLevel != null ? resultLogLevel : Log.WARN;
+        configBuilder.setLogLevel(resultLogLevel);
+
+        configBuilder.setPlatform("react_native");
+
+        configBuilder.setOnAttributionResultReceiveListener(new OnAttributionResultReceiveListener() {
+            @Override
+            public void onAttributionResultReceived(Map<String, String> attribution) {
+                AirbridgeAttribution.processAttribution(attribution);
+            }
+        });
+        
+        return configBuilder.build();
+    }
+}

package/android/src/main/java/co/ab180/airbridge/reactnative/Get.java

@@ -0,0 +1,84 @@
+package co.ab180.airbridge.reactnative;
+
+import org.json.JSONObject;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+
+public class Get {
+    static <T> T type(Class<T> type, Object object) {
+        if (object == null || type.isInstance(object)) {
+            return type.cast(object);
+        } else {
+            return null;
+        }
+    }
+
+    static <T> T type(Class<T> type, HashMap map, String key) {
+        if (map == null) {
+            return null;
+        }
+
+        Object value = map.get(key);
+
+        return Get.type(type, value);
+    }
+
+    static <T> T type(Class<T> type, ArrayList array, int index) {
+        if (array == null || index < 0 || index > array.size()) {
+            return null;
+        }
+
+        Object object = array.get(index);
+
+        return Get.type(type, object);
+    }
+
+    static <T> T type(Class<T> type, JSONObject object, String key) {
+        if (object == null) {
+            return null;
+        }
+
+        Object value = object.opt(key);
+
+        return Get.type(type, value);
+    }
+
+    static <T extends Number> T type(Class<T> type, Number number) {
+        if (number == null) {
+            return null;
+        }
+
+        if (type.isAssignableFrom(Number.class)) {
+            return type.cast(number);
+        }
+
+        if(type.isAssignableFrom(Byte.class)) {
+
+            return type.cast(number.byteValue());
+
+        } else if (type.isAssignableFrom(Short.class)) {
+
+            return type.cast(number.shortValue());
+
+        } else if (type.isAssignableFrom(Integer.class)) {
+
+            return type.cast(number.intValue());
+
+        } else if (type.isAssignableFrom(Long.class)) {
+
+            return type.cast(number.longValue());
+
+        } else if (type.isAssignableFrom(Float.class)) {
+
+            return type.cast(number.floatValue());
+
+        } else if (type.isAssignableFrom(Double.class)) {
+
+            return type.cast(number.doubleValue());
+
+        }
+
+        return null;
+    }
+}

package/changelog.md

@@ -0,0 +1,56 @@
+## Unreleased
+
+**ADDED**
+* Add restricted version
+
+## 2.5.2
+
+**FIXED**
+* Solve issue that ABUser’s copy method may crash App in edge case for iOS
+* Update `Airbridge iOS SDK` to 1.34.9
+
+## 2.5.1
+
+**FIXED**
+* Update `Airbridge Android SDK` to 2.22.0
+* Update `Airbridge iOS SDK` to 1.34.0
+
+## 2.5.0
+
+**FIXED**
+* Update `Airbridge Android SDK` to 2.21.5
+* Update `Airbridge iOS SDK` to 1.32.1
+
+## 2.4.0
+
+**ADDED**
+* Add SDK logLevel interface
+
+## 2.3.0
+
+**ADDED**
+* Add SDK Signature feature that protect Airbridge SDK from SDK spoofing.
+
+**FIXED**
+* Update `Airbridge Android SDK` to 2.21.0
+* Update `Airbridge iOS SDK` to 1.32.0
+
+## 2.2.0
+
+**ADDED**
+* Add WebInterface for Hybrid App web interface
+
+## 2.1.3
+
+**FIXED**
+* solve issue that deeplink event can be lost when open app with deeplink when app is closed not on background with using uninstall tracking.
+
+## 2.1.2
+
+**FIXED**
+- solve issue that open event may be lost if registerPushToken method is used
+
+## 2.1.1
+
+**FIXED**
+- solve issue that npm package is unnecessary big