@capgo/capacitor-rudderstack 8.1.2

package/android/src/main/java/app/capgo/rudderstack/RudderStackBridge.java

@@ -0,0 +1,256 @@
+package app.capgo.rudderstack;
+
+import android.content.Context;
+import androidx.annotation.Nullable;
+import com.getcapacitor.JSObject;
+import com.rudderstack.android.sdk.core.RudderClient;
+import com.rudderstack.android.sdk.core.RudderConfig;
+import com.rudderstack.android.sdk.core.RudderOption;
+import com.rudderstack.android.sdk.core.RudderProperty;
+import com.rudderstack.android.sdk.core.RudderTraits;
+import com.rudderstack.android.sdk.core.RudderTraitsBuilder;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import org.json.JSONArray;
+import org.json.JSONObject;
+
+final class RudderStackBridge {
+
+    private final Context context;
+    private @Nullable RudderClient client;
+
+    RudderStackBridge(final Context context) {
+        this.context = context.getApplicationContext();
+    }
+
+    void initialize(final String writeKey, @Nullable final JSObject configJson, @Nullable final JSObject optionsJson) {
+        final RudderConfig config = getRudderConfig(configJson);
+        final RudderOption options = getRudderOption(optionsJson);
+        client = RudderClient.getInstance(context, writeKey, config, options);
+
+        if (client == null) {
+            throw new IllegalStateException("Failed to initialize RudderStack SDK");
+        }
+    }
+
+    void identify(final String userId, @Nullable final JSObject traitsJson, @Nullable final JSObject optionsJson) {
+        requireClient().identify(userId, getRudderTraits(traitsJson), getRudderOption(optionsJson));
+    }
+
+    void group(final String groupId, @Nullable final JSObject traitsJson, @Nullable final JSObject optionsJson) {
+        requireClient().group(groupId, getRudderTraits(traitsJson), getRudderOption(optionsJson));
+    }
+
+    void track(final String eventName, @Nullable final JSObject propertiesJson, @Nullable final JSObject optionsJson) {
+        requireClient().track(eventName, getRudderProperty(propertiesJson), getRudderOption(optionsJson));
+    }
+
+    void screen(final String screenName, @Nullable final JSObject propertiesJson, @Nullable final JSObject optionsJson) {
+        requireClient().screen(screenName, getRudderProperty(propertiesJson), getRudderOption(optionsJson));
+    }
+
+    void alias(final String newId, @Nullable final JSObject optionsJson) {
+        requireClient().alias(newId, getRudderOption(optionsJson));
+    }
+
+    void reset() {
+        requireClient().reset();
+    }
+
+    void flush() {
+        requireClient().flush();
+    }
+
+    void putDeviceToken(final String deviceToken) {
+        RudderClient.putDeviceToken(deviceToken);
+    }
+
+    void putAdvertisingId(final String advertisingId) {
+        RudderClient.putAdvertisingId(advertisingId);
+    }
+
+    void putAnonymousId(final String anonymousId) {
+        RudderClient.putAnonymousId(anonymousId);
+    }
+
+    void optOut(final boolean optOut) {
+        requireClient().optOut(optOut);
+    }
+
+    private RudderClient requireClient() {
+        if (client == null) {
+            throw new IllegalStateException("RudderStack SDK is not initialized");
+        }
+
+        return client;
+    }
+
+    private RudderConfig getRudderConfig(@Nullable final JSONObject configJson) {
+        if (configJson == null) {
+            return new RudderConfig.Builder().build();
+        }
+
+        final Map<String, Object> configMap = getMapFromJSON(configJson);
+        final RudderConfig.Builder configBuilder = new RudderConfig.Builder();
+
+        if (configMap.containsKey("dataPlaneUrl") && getString(configMap.get("dataPlaneUrl")) != null) {
+            configBuilder.withDataPlaneUrl(getString(configMap.get("dataPlaneUrl")));
+        }
+        if (configMap.containsKey("flushQueueSize") && getInteger(configMap.get("flushQueueSize")) != null) {
+            configBuilder.withFlushQueueSize(getInteger(configMap.get("flushQueueSize")));
+        }
+        if (configMap.containsKey("dbCountThreshold") && getInteger(configMap.get("dbCountThreshold")) != null) {
+            configBuilder.withDbThresholdCount(getInteger(configMap.get("dbCountThreshold")));
+        }
+        if (configMap.containsKey("configRefreshInterval") && getInteger(configMap.get("configRefreshInterval")) != null) {
+            configBuilder.withConfigRefreshInterval(getInteger(configMap.get("configRefreshInterval")));
+        }
+        if (configMap.containsKey("logLevel") && getInteger(configMap.get("logLevel")) != null) {
+            configBuilder.withLogLevel(getInteger(configMap.get("logLevel")));
+        }
+        if (configMap.containsKey("sleepTimeOut") && getInteger(configMap.get("sleepTimeOut")) != null) {
+            configBuilder.withSleepCount(getInteger(configMap.get("sleepTimeOut")));
+        }
+        if (configMap.containsKey("autoCollectAdvertId")) {
+            configBuilder.withAutoCollectAdvertId(getBoolean(configMap.get("autoCollectAdvertId")));
+        }
+        if (configMap.containsKey("trackLifecycleEvents")) {
+            configBuilder.withTrackLifecycleEvents(getBoolean(configMap.get("trackLifecycleEvents")));
+        }
+        if (configMap.containsKey("recordScreenViews")) {
+            configBuilder.withRecordScreenViews(getBoolean(configMap.get("recordScreenViews")));
+        }
+        if (configMap.containsKey("controlPlaneUrl") && getString(configMap.get("controlPlaneUrl")) != null) {
+            configBuilder.withControlPlaneUrl(getString(configMap.get("controlPlaneUrl")));
+        }
+
+        return configBuilder.build();
+    }
+
+    private @Nullable RudderOption getRudderOption(@Nullable final JSONObject optionsJson) {
+        if (optionsJson == null) {
+            return null;
+        }
+
+        final Map<String, Object> optionsMap = getMapFromJSON(optionsJson);
+        final RudderOption option = new RudderOption();
+
+        if (optionsMap.containsKey("externalIds")) {
+            final Map<String, Object> externalIdsMap = castMap(optionsMap.get("externalIds"));
+            for (Map.Entry<String, Object> entry : externalIdsMap.entrySet()) {
+                final String externalId = getString(entry.getValue());
+                if (externalId != null) {
+                    option.putExternalId(entry.getKey(), externalId);
+                }
+            }
+        }
+
+        if (optionsMap.containsKey("integrations")) {
+            final Map<String, Object> integrationsMap = castMap(optionsMap.get("integrations"));
+            for (Map.Entry<String, Object> entry : integrationsMap.entrySet()) {
+                option.putIntegration(entry.getKey(), getBoolean(entry.getValue()));
+            }
+        }
+
+        return option;
+    }
+
+    private @Nullable RudderTraits getRudderTraits(@Nullable final JSONObject traitsJson) {
+        if (traitsJson == null) {
+            return null;
+        }
+
+        final Map<String, Object> traitsMap = getMapFromJSON(traitsJson);
+        final RudderTraits traits = new RudderTraitsBuilder().build();
+        for (Map.Entry<String, Object> entry : traitsMap.entrySet()) {
+            traits.put(entry.getKey(), entry.getValue());
+        }
+        return traits;
+    }
+
+    private @Nullable RudderProperty getRudderProperty(@Nullable final JSONObject propertiesJson) {
+        if (propertiesJson == null) {
+            return null;
+        }
+
+        return new RudderProperty().putValue(getMapFromJSON(propertiesJson));
+    }
+
+    private Map<String, Object> getMapFromJSON(final JSONObject jsonObject) {
+        final Map<String, Object> map = new HashMap<>();
+        final Iterator<String> keysIter = jsonObject.keys();
+        while (keysIter.hasNext()) {
+            final String key = keysIter.next();
+            final Object value = jsonObject.isNull(key) ? null : getObject(jsonObject.opt(key));
+            if (value != null) {
+                map.put(key, value);
+            }
+        }
+        return map;
+    }
+
+    private Object getObject(final Object value) {
+        if (value instanceof JSONObject) {
+            return getMapFromJSON((JSONObject) value);
+        }
+        if (value instanceof JSONArray) {
+            return getListFromJSON((JSONArray) value);
+        }
+        return value;
+    }
+
+    private @Nullable String getString(final Object value) {
+        if (value instanceof String) {
+            return (String) value;
+        }
+        if (value instanceof Number) {
+            return String.valueOf(value);
+        }
+        return null;
+    }
+
+    private @Nullable Integer getInteger(final Object value) {
+        if (value instanceof Number) {
+            return ((Number) value).intValue();
+        }
+        if (value instanceof String) {
+            return Integer.valueOf((String) value);
+        }
+        return null;
+    }
+
+    private boolean getBoolean(final Object value) {
+        if (value instanceof Boolean) {
+            return (Boolean) value;
+        }
+        if (value instanceof Number) {
+            return ((Number) value).intValue() > 0;
+        }
+        if (value instanceof String) {
+            return Boolean.parseBoolean((String) value);
+        }
+        return false;
+    }
+
+    private List<Object> getListFromJSON(final JSONArray jsonArray) {
+        final List<Object> list = new ArrayList<>();
+        for (int i = 0, count = jsonArray.length(); i < count; i++) {
+            final Object value = getObject(jsonArray.opt(i));
+            if (value != null) {
+                list.add(value);
+            }
+        }
+        return list;
+    }
+
+    @SuppressWarnings("unchecked")
+    private Map<String, Object> castMap(final Object value) {
+        if (value instanceof Map) {
+            return (Map<String, Object>) value;
+        }
+        return new HashMap<>();
+    }
+}

package/android/src/main/java/app/capgo/rudderstack/RudderStackPlugin.java

@@ -0,0 +1,205 @@
+package app.capgo.rudderstack;
+
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+
+@CapacitorPlugin(name = "RudderStack")
+public class RudderStackPlugin extends Plugin {
+
+    private static final String VERSION = BuildConfig.VERSION_NAME;
+
+    private RudderStackBridge implementation;
+
+    @Override
+    public void load() {
+        implementation = new RudderStackBridge(getContext());
+    }
+
+    @PluginMethod
+    public void initialize(final PluginCall call) {
+        final String writeKey = call.getString("writeKey");
+        if (writeKey == null || writeKey.trim().isEmpty()) {
+            call.reject("writeKey is required");
+            return;
+        }
+
+        try {
+            implementation.initialize(writeKey, call.getObject("config"), call.getObject("options"));
+            call.resolve();
+        } catch (Exception exception) {
+            call.reject(exception.getMessage(), exception);
+        }
+    }
+
+    @PluginMethod
+    public void identify(final PluginCall call) {
+        final String userId = call.getString("userId");
+        if (userId == null || userId.trim().isEmpty()) {
+            call.reject("userId is required");
+            return;
+        }
+
+        try {
+            implementation.identify(userId, call.getObject("traits"), call.getObject("options"));
+            call.resolve();
+        } catch (Exception exception) {
+            call.reject(exception.getMessage(), exception);
+        }
+    }
+
+    @PluginMethod
+    public void group(final PluginCall call) {
+        final String groupId = call.getString("groupId");
+        if (groupId == null || groupId.trim().isEmpty()) {
+            call.reject("groupId is required");
+            return;
+        }
+
+        try {
+            implementation.group(groupId, call.getObject("groupTraits"), call.getObject("options"));
+            call.resolve();
+        } catch (Exception exception) {
+            call.reject(exception.getMessage(), exception);
+        }
+    }
+
+    @PluginMethod
+    public void track(final PluginCall call) {
+        final String eventName = call.getString("eventName");
+        if (eventName == null || eventName.trim().isEmpty()) {
+            call.reject("eventName is required");
+            return;
+        }
+
+        try {
+            implementation.track(eventName, call.getObject("properties"), call.getObject("options"));
+            call.resolve();
+        } catch (Exception exception) {
+            call.reject(exception.getMessage(), exception);
+        }
+    }
+
+    @PluginMethod
+    public void screen(final PluginCall call) {
+        final String screenName = call.getString("screenName");
+        if (screenName == null || screenName.trim().isEmpty()) {
+            call.reject("screenName is required");
+            return;
+        }
+
+        try {
+            implementation.screen(screenName, call.getObject("properties"), call.getObject("options"));
+            call.resolve();
+        } catch (Exception exception) {
+            call.reject(exception.getMessage(), exception);
+        }
+    }
+
+    @PluginMethod
+    public void alias(final PluginCall call) {
+        final String newId = call.getString("newId");
+        if (newId == null || newId.trim().isEmpty()) {
+            call.reject("newId is required");
+            return;
+        }
+
+        try {
+            implementation.alias(newId, call.getObject("options"));
+            call.resolve();
+        } catch (Exception exception) {
+            call.reject(exception.getMessage(), exception);
+        }
+    }
+
+    @PluginMethod
+    public void reset(final PluginCall call) {
+        try {
+            implementation.reset();
+            call.resolve();
+        } catch (Exception exception) {
+            call.reject(exception.getMessage(), exception);
+        }
+    }
+
+    @PluginMethod
+    public void flush(final PluginCall call) {
+        try {
+            implementation.flush();
+            call.resolve();
+        } catch (Exception exception) {
+            call.reject(exception.getMessage(), exception);
+        }
+    }
+
+    @PluginMethod
+    public void putDeviceToken(final PluginCall call) {
+        final String deviceToken = call.getString("deviceToken");
+        if (deviceToken == null || deviceToken.trim().isEmpty()) {
+            call.reject("deviceToken is required");
+            return;
+        }
+
+        implementation.putDeviceToken(deviceToken);
+        call.resolve();
+    }
+
+    @PluginMethod
+    public void setAdvertisingId(final PluginCall call) {
+        putAdvertisingId(call);
+    }
+
+    @PluginMethod
+    public void putAdvertisingId(final PluginCall call) {
+        final String advertisingId = call.getString("advertisingId");
+        if (advertisingId == null || advertisingId.trim().isEmpty()) {
+            call.reject("advertisingId is required");
+            return;
+        }
+
+        implementation.putAdvertisingId(advertisingId);
+        call.resolve();
+    }
+
+    @PluginMethod
+    public void setAnonymousId(final PluginCall call) {
+        putAnonymousId(call);
+    }
+
+    @PluginMethod
+    public void putAnonymousId(final PluginCall call) {
+        final String anonymousId = call.getString("anonymousId");
+        if (anonymousId == null || anonymousId.trim().isEmpty()) {
+            call.reject("anonymousId is required");
+            return;
+        }
+
+        implementation.putAnonymousId(anonymousId);
+        call.resolve();
+    }
+
+    @PluginMethod
+    public void optOut(final PluginCall call) {
+        final Boolean optOut = call.getBoolean("optOut");
+        if (optOut == null) {
+            call.reject("optOut is required");
+            return;
+        }
+
+        try {
+            implementation.optOut(optOut);
+            call.resolve();
+        } catch (Exception exception) {
+            call.reject(exception.getMessage(), exception);
+        }
+    }
+
+    @PluginMethod
+    public void getPluginVersion(final PluginCall call) {
+        final JSObject ret = new JSObject();
+        ret.put("version", VERSION);
+        call.resolve(ret);
+    }
+}