reactnative-plugin-appice 1.7.30 → 1.7.32

package/android/.idea/workspace.xml

@@ -0,0 +1,103 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="AutoImportSettings">
+    <option name="autoReloadType" value="NONE" />
+  </component>
+  <component name="ChangeListManager">
+    <list default="true" id="aee4312c-1901-4a6b-8b92-4d5a8d6d561e" name="Changes" comment="">
+      <change beforePath="$PROJECT_DIR$/src/main/AndroidManifest.xml" beforeDir="false" afterPath="$PROJECT_DIR$/src/main/AndroidManifest.xml" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/../example/android/.gradle/7.3.3/checksums/checksums.lock" beforeDir="false" />
+      <change beforePath="$PROJECT_DIR$/../example/android/.gradle/7.3.3/fileChanges/last-build.bin" beforeDir="false" />
+      <change beforePath="$PROJECT_DIR$/../example/android/.gradle/7.3.3/fileHashes/fileHashes.lock" beforeDir="false" />
+      <change beforePath="$PROJECT_DIR$/../example/android/.gradle/7.3.3/gc.properties" beforeDir="false" />
+      <change beforePath="$PROJECT_DIR$/../example/android/.gradle/vcs-1/gc.properties" beforeDir="false" />
+      <change beforePath="$PROJECT_DIR$/../example/package.json" beforeDir="false" afterPath="$PROJECT_DIR$/../example/package.json" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/../package.json" beforeDir="false" afterPath="$PROJECT_DIR$/../package.json" afterDir="false" />
+    </list>
+    <option name="SHOW_DIALOG" value="false" />
+    <option name="HIGHLIGHT_CONFLICTS" value="true" />
+    <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
+    <option name="LAST_RESOLUTION" value="IGNORE" />
+  </component>
+  <component name="ClangdSettings">
+    <option name="formatViaClangd" value="false" />
+  </component>
+  <component name="ExternalProjectsData">
+    <projectState path="$PROJECT_DIR$">
+      <ProjectState />
+    </projectState>
+  </component>
+  <component name="Git.Settings">
+    <option name="RECENT_BRANCH_BY_REPOSITORY">
+      <map>
+        <entry key="$PROJECT_DIR$/.." value="dev" />
+      </map>
+    </option>
+    <option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$/.." />
+  </component>
+  <component name="GitLabMergeRequestFiltersHistory">{
+  &quot;lastFilter&quot;: {
+    &quot;state&quot;: &quot;OPENED&quot;,
+    &quot;assignee&quot;: {
+      &quot;type&quot;: &quot;org.jetbrains.plugins.gitlab.mergerequest.ui.filters.GitLabMergeRequestsFiltersValue.MergeRequestsMemberFilterValue.MergeRequestsAssigneeFilterValue&quot;,
+      &quot;username&quot;: &quot;amit.pandey.work&quot;,
+      &quot;fullname&quot;: &quot;Amit Pandey&quot;
+    }
+  }
+}</component>
+  <component name="GitLabMergeRequestsSettings">{
+  &quot;selectedUrlAndAccountId&quot;: {
+    &quot;first&quot;: &quot;https://gitlab.com/grp_appice/src_reactnative_appice-sdk.git&quot;,
+    &quot;second&quot;: &quot;3049d1c2-c9c2-4ad3-90d8-501e6fe141e1&quot;
+  }
+}</component>
+  <component name="ProjectColorInfo">{
+  &quot;associatedIndex&quot;: 6
+}</component>
+  <component name="ProjectId" id="2xcttwNrwHU9Ne1lHjEiEC2bldp" />
+  <component name="ProjectViewState">
+    <option name="hideEmptyMiddlePackages" value="true" />
+    <option name="showLibraryContents" value="true" />
+  </component>
+  <component name="PropertiesComponent"><![CDATA[{
+  "keyToString": {
+    "RunOnceActivity.ShowReadmeOnStart": "true",
+    "RunOnceActivity.cidr.known.project.marker": "true",
+    "RunOnceActivity.git.unshallow": "true",
+    "RunOnceActivity.readMode.enableVisualFormatting": "true",
+    "cf.first.check.clang-format": "false",
+    "cidr.known.project.marker": "true",
+    "git-widget-placeholder": "release-hotfix-2.6.12",
+    "last_opened_file_path": "/Users/amitpandey/Desktop/AppICE/src_reactnative_appice-sdk/android",
+    "project.structure.last.edited": "Project",
+    "project.structure.proportion": "0.17",
+    "project.structure.side.proportion": "0.2",
+    "settings.editor.selected.configurable": "reference.settingsdialog.project.gradle"
+  }
+}]]></component>
+  <component name="PsdUISettings">
+    <option name="LAST_EDITED_BUILD_TYPE" value="release" />
+  </component>
+  <component name="SpellCheckerSettings" RuntimeDictionaries="0" Folders="0" CustomDictionaries="0" DefaultDictionary="application-level" UseSingleDictionary="true" transferred="true" />
+  <component name="TaskManager">
+    <task active="true" id="Default" summary="Default task">
+      <changelist id="aee4312c-1901-4a6b-8b92-4d5a8d6d561e" name="Changes" comment="" />
+      <created>1748249407888</created>
+      <option name="number" value="Default" />
+      <option name="presentableId" value="Default" />
+      <updated>1748249407888</updated>
+    </task>
+    <servers />
+  </component>
+  <component name="play_dynamic_filters_status">
+    <option name="appIdToCheckInfo">
+      <map>
+        <entry key="com.reactlibrary.test">
+          <value>
+            <CheckInfo lastCheckTimestamp="1748426745571" />
+          </value>
+        </entry>
+      </map>
+    </option>
+  </component>
+</project>

package/android/build.gradle

@@ -94,7 +94,7 @@ dependencies {
     annotationProcessor "androidx.lifecycle:lifecycle-compiler:2.3.1"
 
     //appice
-    implementation "appice.io.android:sdk:2.6.23"
+    implementation "appice.io.android:sdk:2.6.26-release"
 
     //glide
     implementation "com.github.bumptech.glide:glide:4.11.0"

package/android/src/main/java/com/appice/react/AppICEUtils.java

@@ -1,27 +1,212 @@
 package com.appice.react;
 
+import android.content.Context;
+import android.content.Intent;
+import android.os.Bundle;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
 import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.ReadableMapKeySetIterator;
 import com.facebook.react.bridge.ReadableType;
 import com.facebook.react.bridge.WritableArray;
 import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
 
+import java.util.ArrayDeque;
 import java.util.ArrayList;
+import java.util.Deque;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.Map;
+import java.util.concurrent.atomic.AtomicBoolean;
 
 import org.json.JSONObject;
 
 import semusi.context.ui.appInbox.AppICEInboxMessage;
+import semusi.context.utility.PushClickData;
 import semusi.model.campaign.Campaign;
 import semusi.model.user.User;
 
 
 public class AppICEUtils {
     private static final String TAG = "AppICEUtils";
+    static final Deque<Event> EVENT_QUEUE = new ArrayDeque<>();
+    static final AtomicBoolean IS_FLUSHING = new AtomicBoolean(false);
+
+    static class Event {
+        final String name;
+        final WritableMap params;
+
+        Event(String name, @Nullable WritableMap params) {
+            this.name = name;
+            this.params = params;
+        }
+    }
+
+    static void sendEventHelper(String eventName, @Nullable WritableMap params, ReactContext context) {
+        if (context == null || !context.hasActiveCatalystInstance()) {
+            synchronized (EVENT_QUEUE) {
+                WritableMap queued = null;
+                if (params != null) {
+                    try {
+                        queued = cloneReadableMap(params);
+                    } catch (Exception ex) {
+                        printLog(TAG, "sendEvent: failed to clone params for queue " + eventName + " - " + ex.getMessage());
+                        queued = null;
+                    }
+                }
+                EVENT_QUEUE.add(new Event(eventName, queued));
+            }
+            return;
+        }
+
+        WritableMap emitCopy = null;
+        if (params != null) {
+            try {
+                emitCopy = cloneReadableMap(params);
+            } catch (Exception ex) {
+                emitCopy = null;
+            }
+        }
+
+        try {
+            context.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                    .emit(eventName, emitCopy);
+            printLog(TAG, "Successfully emitted event: " + eventName);
+        } catch (Exception e) {
+            printLog(TAG, "emit failed for " + eventName + " - " + e.getMessage());
+            synchronized (EVENT_QUEUE) {
+                WritableMap queued = null;
+                if (params != null) {
+                    try {
+                        queued = cloneReadableMap(params);
+                    } catch (Exception ex) {
+                        queued = null;
+                    }
+                }
+                EVENT_QUEUE.add(new Event(eventName, queued));
+            }
+        }
+    }
+
+    static void flushEventQueue(ReactContext reactContext) {
+        if (reactContext == null || !reactContext.hasActiveCatalystInstance()) {
+            return;
+        }
+
+        if (!IS_FLUSHING.compareAndSet(false, true)) {
+            return;
+        }
+
+        try {
+            synchronized (EVENT_QUEUE) {
+                int initialSize = EVENT_QUEUE.size();
+                while (!EVENT_QUEUE.isEmpty()) {
+                    Event event = EVENT_QUEUE.poll();
+                    try {
+                        WritableMap toEmit = null;
+                        if (event.params != null) {
+                            try {
+                                toEmit = cloneReadableMap(event.params);
+                            } catch (Exception ex) {
+                                toEmit = event.params;
+                            }
+                        }
+                        reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                                .emit(event.name, toEmit);
+                        printLog(TAG, "Successfully flushed event: " + event.name + ". Remaining in queue: " + EVENT_QUEUE.size());
+                    } catch (Exception e) {
+                        EVENT_QUEUE.addFirst(event);
+                        break;
+                    }
+                }
+            }
+        } finally {
+            IS_FLUSHING.set(false);
+        }
+    }
+
+    public static WritableMap cloneReadableMap(@NonNull ReadableMap source) {
+        WritableMap result = Arguments.createMap();
+        ReadableMapKeySetIterator iterator = source.keySetIterator();
+        while (iterator.hasNextKey()) {
+            String key = iterator.nextKey();
+            ReadableType type = source.getType(key);
+            try {
+                switch (type) {
+                    case String:
+                        result.putString(key, source.getString(key));
+                        break;
+                    case Number:
+                        result.putDouble(key, source.getDouble(key));
+                        break;
+                    case Boolean:
+                        result.putBoolean(key, source.getBoolean(key));
+                        break;
+                    case Map:
+                        ReadableMap nested = source.getMap(key);
+                        if (nested != null) result.putMap(key, cloneReadableMap(nested));
+                        else result.putNull(key);
+                        break;
+                    case Array:
+                        ReadableArray arr = source.getArray(key);
+                        if (arr != null) result.putArray(key, cloneReadableArray(arr));
+                        else result.putNull(key);
+                        break;
+                    case Null:
+                    default:
+                        result.putNull(key);
+                        break;
+                }
+            } catch (Exception ex) {
+                AppICEUtils.printLog(TAG, "cloneReadableMap: failed to copy key '" + key + "' - " + ex.getMessage());
+            }
+        }
+        return result;
+    }
+
+    public static WritableArray cloneReadableArray(@NonNull ReadableArray source) {
+        WritableArray result = Arguments.createArray();
+        for (int i = 0; i < source.size(); i++) {
+            try {
+                ReadableType t = source.getType(i);
+                switch (t) {
+                    case String:
+                        result.pushString(source.getString(i));
+                        break;
+                    case Number:
+                        result.pushDouble(source.getDouble(i));
+                        break;
+                    case Boolean:
+                        result.pushBoolean(source.getBoolean(i));
+                        break;
+                    case Map:
+                        ReadableMap m = source.getMap(i);
+                        if (m != null) result.pushMap(cloneReadableMap(m));
+                        else result.pushNull();
+                        break;
+                    case Array:
+                        ReadableArray a = source.getArray(i);
+                        if (a != null) result.pushArray(cloneReadableArray(a));
+                        else result.pushNull();
+                        break;
+                    case Null:
+                    default:
+                        result.pushNull();
+                        break;
+                }
+            } catch (Exception ex) {
+                AppICEUtils.printLog(TAG, "cloneReadableArray: failed at index '" + i + "' - " + ex.getMessage());
+                result.pushNull();
+            }
+        }
+        return result;
+    }
 
     public static WritableMap convertClassToWritableMap(AppICEInboxMessage inboxMessage) {
         WritableMap inboxObject = Arguments.createMap();
@@ -272,4 +457,20 @@ public class AppICEUtils {
         System.out.println(TAG + ", " + message);
     }
 
+    public static boolean handleAppICEPayload(@NonNull Intent intent, Context context){
+        try {
+            if (intent.getExtras() != null){
+                Bundle bundle = intent.getExtras();
+                boolean isAppICEPush = bundle.getBoolean("ai_push", false);
+                if (isAppICEPush) {
+                    CampaignCampsReceiver campsReceiver = new CampaignCampsReceiver();
+                    campsReceiver.sendCallback(bundle, context);
+                    intent.removeExtra("ai_push");
+                }
+            }
+        }catch (Throwable t){
+            printLog("PUSH", " exception in click "+t);
+        }
+        return false;
+    }
 }