lemnisk-react-native 0.1.17 → 0.1.19

package/android/.gradle/buildOutputCleanup/cache.properties

@@ -0,0 +1,2 @@
+#Thu Mar 27 15:06:49 IST 2025
+gradle.version=7.5

package/android/build.gradle

@@ -7,7 +7,7 @@ buildscript {
         }
 
         dependencies {
-            classpath 'com.android.tools.build:gradle:4.1.0'
+            classpath 'com.android.tools.build:gradle:7.4.2'
         }
     }
 }
@@ -19,11 +19,11 @@ def safeExtGet(prop, fallback) {
 }
 
 android {
-    compileSdkVersion safeExtGet('LemniskSdk_compileSdkVersion', 33)
-    buildToolsVersion safeExtGet('LemniskSdk_buildToolsVersion', '30.0.2')
+    compileSdkVersion safeExtGet('LemniskSdk_compileSdkVersion', 34)
+    buildToolsVersion safeExtGet('LemniskSdk_buildToolsVersion', '34.0.0')
     defaultConfig {
         minSdkVersion safeExtGet('LemniskSdk_minSdkVersion', 21)
-        targetSdkVersion safeExtGet('LemniskSdk_targetSdkVersion', 33)
+        targetSdkVersion safeExtGet('LemniskSdk_targetSdkVersion', 34)
         versionCode 1
         versionName "1.0"
 
@@ -38,8 +38,8 @@ android {
         disable 'GradleCompatible'
     }
     compileOptions {
-        sourceCompatibility JavaVersion.VERSION_1_8
-        targetCompatibility JavaVersion.VERSION_1_8
+        sourceCompatibility JavaVersion.VERSION_11
+        targetCompatibility JavaVersion.VERSION_11
     }
 }
 
@@ -56,7 +56,7 @@ repositories {
 dependencies {
     //noinspection GradleDynamicVersion
     implementation "com.facebook.react:react-native:+"  // From node_modules
-    implementation 'co.lemnisk.app.android:AndroidSDK:1.1.50'
+    implementation 'co.lemnisk.app.android:AndroidSDK:1.1.52'
     implementation 'org.apache.commons:commons-text:1.9'
     //implementation(name:'AndroidSDK-release', ext:'aar')
     implementation group: 'joda-time', name: 'joda-time', version: '2.10.10'

package/android/gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.7-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.5-all.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

package/android/src/main/java/com/reactnativelemnisksdk/LemniskSdkModule.java

@@ -9,6 +9,7 @@ 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.bridge.ReadableArray;
 import com.facebook.react.module.annotations.ReactModule;
 import com.google.android.gms.tasks.OnSuccessListener;
 import com.google.android.gms.tasks.Task;
@@ -23,30 +24,50 @@ import co.lemnisk.app.android.LemniskHelper;
 import co.lemnisk.app.android.Utils;
 import co.lemnisk.app.android.LemConstants;
 import android.text.TextUtils;
+import android.os.Handler;
+import android.os.Looper;
+import com.facebook.react.bridge.Callback;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.Arguments;
+import java.util.List;
+import java.util.ArrayList;
+
+import co.lemnisk.app.android.NotificationCenter;
 
 @ReactModule(name = LemniskSdkModule.NAME)
 public class LemniskSdkModule extends ReactContextBaseJavaModule {
     public static final String NAME = "LemniskSdk";
+    public static final String NOTIFICATION_CENTER_URL = "Lemnisk.Notification_Center_URL";
     private ReactApplicationContext reactContext;
 
     public LemniskSdkModule(ReactApplicationContext reactContext) {
-        super(reactContext);
-        this.reactContext = reactContext;
-        LemniskHelper helper = LemniskHelper.getInstance(reactContext);
-
-        Task<String> task = FirebaseMessaging.getInstance().getToken();
-        task.addOnSuccessListener(new OnSuccessListener<String>() {
-          @Override
-          public void onSuccess(@NonNull  String s) {
-            Log.d("Firebase Token","onSuccess ========> : "+s);
-            String previousToken = Utils.getInstance(reactContext).getStringFromSharedPrefs(LemConstants.PREFS_GCM_TOKEN);
-            helper.init();
-            if(!TextUtils.isEmpty(previousToken) && !s.equalsIgnoreCase(previousToken)){
-              Utils.getInstance(reactContext).setStringInSharedPrefs(LemConstants.PREFS_GCM_TOKEN, "");
-              helper.setGCMToken(s);
-            }
+      super(reactContext);
+      this.reactContext = reactContext;
+
+      LemniskHelper helper = LemniskHelper.getInstance(reactContext);
+
+      new Handler(Looper.getMainLooper()).post(new Runnable() {
+        @Override
+        public void run() {
+          try {
+              android.content.pm.ApplicationInfo ai = reactContext.getPackageManager().getApplicationInfo(
+                  reactContext.getPackageName(), 
+                  android.content.pm.PackageManager.GET_META_DATA
+              );
+              String notificationCenterUrl = ai.metaData.getString(NOTIFICATION_CENTER_URL);
+              
+              if (notificationCenterUrl != null && !notificationCenterUrl.isEmpty()) {
+                  helper.init(null, null, null, notificationCenterUrl, null, null);
+              } else {
+                  helper.init();
+              }
+          } catch (Exception e) {
+              Log.e("LemniskSdk", "Failed to load meta-data: " + e.getMessage());
+              helper.init();
           }
-        });
+        }
+      });
+      
     }
 
     @Override
@@ -169,5 +190,245 @@ public class LemniskSdkModule extends ReactContextBaseJavaModule {
         }
     }
 
+    @ReactMethod
+    public void setUniqueUserId(String tokenizedCid) {
+        Log.d("Lemnisk: ", "setUniqueUserId: " + tokenizedCid);
+        try {
+            LemniskHelper.getInstance(getReactApplicationContext()).setUniqueUserId(tokenizedCid);
+        } catch (Exception e) {
+            Log.e("Lemnisk", "Exception in setUniqueUserId", e);
+        }
+    }
+
+    @ReactMethod
+    public void resetUser(){
+        Log.d("Lemnisk: ", "resetUser");
+        try {
+            LemniskHelper.getInstance(getReactApplicationContext()).resetUser();
+        } catch (Exception e) {
+            Log.e("Lemnisk", "Exception in resetUser", e);
+        }
+    }
+
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    public String getUniqueUserId() {
+        Log.d("Lemnisk: ", "getUniqueUserId");
+        try {
+            String uniqueUserId = LemniskHelper.getInstance(getReactApplicationContext()).getUniqueUserId();
+            return uniqueUserId != null ? uniqueUserId : "";
+        } catch (Exception e) {
+            Log.e("Lemnisk", "Exception in getUniqueUserId", e);
+            return "";
+        }
+    }
+
+    @ReactMethod
+    public void setCustomConsent(boolean transConsent, boolean promoConsent) {
+        Log.d("Lemnisk: ", "setCustomConsent: transConsent=" + transConsent + ", promoConsent=" + promoConsent);
+        try {
+            JSONObject consent = new JSONObject();
+            consent.put("trans_consent", transConsent);
+            consent.put("promo_consent", promoConsent);
+            LemniskHelper.getInstance(getReactApplicationContext()).setCustomConsent(consent);
+        } catch (Exception e) {
+            Log.e("Lemnisk", "Exception in setCustomConsent", e);
+        }
+    }
+
+    @ReactMethod
+    public void getCustomConsent(final Callback callback) {
+        Log.d("Lemnisk: ", "getCustomConsent");
+        try {
+            LemniskHelper.getInstance(getReactApplicationContext()).getCustomConsent(new LemniskHelper.ConsentCallback() {
+                @Override
+                public void getConsent(JSONObject consent) {
+                    WritableArray result = Arguments.createArray();
+                    if (consent != null) {
+                        boolean transConsent = consent.optBoolean("trans_consent");
+                        boolean promoConsent = consent.optBoolean("promo_consent");
+                        result.pushBoolean(transConsent);
+                        result.pushBoolean(promoConsent);
+                    } else {
+                        result.pushNull();
+                        result.pushNull();
+                    }
+                    callback.invoke(result);
+                }
+            });
+        } catch (Exception e) {
+            Log.e("Lemnisk", "Exception in getCustomConsent", e);
+            WritableArray result = Arguments.createArray();
+            result.pushNull();
+            result.pushNull();
+            callback.invoke(result);
+        }
+    }
+
+    @ReactMethod
+    public void getOSConsent(final Callback callback) {
+        Log.d("Lemnisk: ", "getOSConsent");
+        try {
+            int consent = LemniskHelper.getInstance(getReactApplicationContext()).getOSConsent();
+            callback.invoke(consent);
+        } catch (Exception e) {
+            Log.e("Lemnisk", "Exception in getOSConsent", e);
+            callback.invoke(3); // Unknown consent
+        }
+    }
+
+    @ReactMethod
+    public void setCustomerDeviceId(String deviceId) {
+        Log.d("Lemnisk: ", "setCustomerDeviceId: " + deviceId);
+        try {
+            LemniskHelper.getInstance(getReactApplicationContext()).setCustomerDeviceId(deviceId);
+        } catch (Exception e) {
+            Log.e("Lemnisk", "Exception in setCustomerDeviceId", e);
+        }
+    }
+
+    @ReactMethod
+    public void overrideDeviceId(String deviceId) {
+        Log.d("Lemnisk: ", "overrideDeviceId: " + deviceId);
+        try {
+            LemniskHelper.getInstance(getReactApplicationContext()).overrideDeviceId(deviceId);
+        } catch (Exception e) {
+            Log.e("Lemnisk", "Exception in overrideDeviceId", e);
+        }
+    }
+
+    @ReactMethod
+    public void getUnreadCount(String tokenizedCid, final Promise promise) {
+        Log.d("Lemnisk: ", "getUnreadCount: " + tokenizedCid);
+        try {
+            LemniskHelper.getInstance(getReactApplicationContext()).getUnreadCount(tokenizedCid, 
+                new NotificationCenter.NotificationCenterListener<Integer>() {
+                    @Override
+                    public void onResponse(Integer unreadCount) {
+                        promise.resolve(unreadCount);
+                    }
+                }
+            );
+        } catch (Exception e) {
+            Log.e("Lemnisk", "Exception in getUnreadCount", e);
+            promise.reject("ERROR", "Failed to get unread count", e);
+        }
+    }
+
+    @ReactMethod
+    public void markRead(String tokenizedCid, String pid, final Promise promise) {
+        Log.d("Lemnisk: ", "markRead: tokenizedCid=" + tokenizedCid + ", pid=" + pid);
+        try {
+            LemniskHelper.getInstance(getReactApplicationContext()).markRead(tokenizedCid, pid, 
+                new NotificationCenter.NotificationCenterListener<Boolean>() {
+                    @Override
+                    public void onResponse(Boolean success) {
+                        promise.resolve(success);
+                    }
+                }
+            );
+        } catch (Exception e) {
+            Log.e("Lemnisk", "Exception in markRead", e);
+            promise.reject("ERROR", "Failed to mark as read", e);
+        }
+    }
+
+    @ReactMethod
+    public void markBulkRead(String tokenizedCid, ReadableArray pidsArray, final Promise promise) {
+        Log.d("Lemnisk: ", "markBulkRead: tokenizedCid=" + tokenizedCid);
+        try {
+            List<String> pids = new ArrayList<>();
+            for (int i = 0; i < pidsArray.size(); i++) {
+                pids.add(pidsArray.getString(i));
+            }
+            LemniskHelper.getInstance(getReactApplicationContext()).markBulkRead(tokenizedCid, pids, 
+                new NotificationCenter.NotificationCenterListener<Boolean>() {
+                    @Override
+                    public void onResponse(Boolean success) {
+                        promise.resolve(success);
+                    }
+                }
+            );
+        } catch (Exception e) {
+            Log.e("Lemnisk", "Exception in markBulkRead", e);
+            promise.reject("ERROR", "Failed to mark bulk as read", e);
+        }
+    }
+
+    @ReactMethod
+    public void markDelete(String tokenizedCid, String pid, final Promise promise) {
+        Log.d("Lemnisk: ", "markDelete: tokenizedCid=" + tokenizedCid + ", pid=" + pid);
+        try {
+            LemniskHelper.getInstance(getReactApplicationContext()).markDelete(tokenizedCid, pid, 
+                new NotificationCenter.NotificationCenterListener<Boolean>() {
+                    @Override
+                    public void onResponse(Boolean success) {
+                        promise.resolve(success);
+                    }
+                }
+            );
+        } catch (Exception e) {
+            Log.e("Lemnisk", "Exception in markDelete", e);
+            promise.reject("ERROR", "Failed to mark as deleted", e);
+        }
+    }
+
+    @ReactMethod
+    public void markBulkDelete(String tokenizedCid, ReadableArray pidsArray, final Promise promise) {
+        Log.d("Lemnisk: ", "markBulkDelete: tokenizedCid=" + tokenizedCid);
+        try {
+            List<String> pids = new ArrayList<>();
+            for (int i = 0; i < pidsArray.size(); i++) {
+                pids.add(pidsArray.getString(i));
+            }
+            LemniskHelper.getInstance(getReactApplicationContext()).markBulkDelete(tokenizedCid, pids, 
+                new NotificationCenter.NotificationCenterListener<Boolean>() {
+                    @Override
+                    public void onResponse(Boolean success) {
+                        promise.resolve(success);
+                    }
+                }
+            );
+        } catch (Exception e) {
+            Log.e("Lemnisk", "Exception in markBulkDelete", e);
+            promise.reject("ERROR", "Failed to mark bulk as deleted", e);
+        }
+    }
+
+    @ReactMethod
+    public void readAll(String tokenizedCid, String type, final Promise promise) {
+        Log.d("Lemnisk: ", "readAll: tokenizedCid=" + tokenizedCid + ", type=" + type);
+        try {
+            LemniskHelper.getInstance(getReactApplicationContext()).readAll(tokenizedCid, type, 
+                new NotificationCenter.NotificationCenterListener<Boolean>() {
+                    @Override
+                    public void onResponse(Boolean success) {
+                        promise.resolve(success);
+                    }
+                }
+            );
+        } catch (Exception e) {
+            Log.e("Lemnisk", "Exception in readAll", e);
+            promise.reject("ERROR", "Failed to mark all as read", e);
+        }
+    }
+
+    @ReactMethod
+    public void deleteAll(String tokenizedCid, String type, final Promise promise) {
+        Log.d("Lemnisk: ", "deleteAll: tokenizedCid=" + tokenizedCid + ", type=" + type);
+        try {
+            LemniskHelper.getInstance(getReactApplicationContext()).deleteAll(tokenizedCid, type, 
+                new NotificationCenter.NotificationCenterListener<Boolean>() {
+                    @Override
+                    public void onResponse(Boolean success) {
+                        promise.resolve(success);
+                    }
+                }
+            );
+        } catch (Exception e) {
+            Log.e("Lemnisk", "Exception in deleteAll", e);
+            promise.reject("ERROR", "Failed to mark all as deleted", e);
+        }
+    }
+
     public static native int nativeMultiply(int a, int b);
 }

package/ios/LemniskSdk.m

@@ -35,4 +35,165 @@ RCT_EXPORT_METHOD(registerForPush) {
     RCTLogInfo(@"calling registerForPushNotifications");
     [[Lemnisk shared] registerForPushNotifications];
 }
+
+RCT_EXPORT_METHOD(setUniqueUserId:(NSString *) tokenized_cid) {
+    RCTLogInfo(@"calling setUniqueUserId");
+    [[Lemnisk shared] setUniqueUserId:tokenized_cid];
+}
+
+RCT_EXPORT_METHOD(resetUser) {
+    RCTLogInfo(@"calling resetuser");
+    [[Lemnisk shared] resetUser];
+}
+
+RCT_EXPORT_SYNCHRONOUS_TYPED_METHOD(NSString *, getUniqueUserId) {
+    RCTLogInfo(@"Getting unique user ID");
+    NSString *uniqueUserId = [[Lemnisk shared] getUniqueUserId];
+    return uniqueUserId ?: @"";
+}
+
+// Set Custom Consent method
+RCT_EXPORT_METHOD(setCustomConsent:(BOOL)transConsent promoConsent:(BOOL)promoConsent) {
+    RCTLogInfo(@"Setting custom consent: transConsent=%d, promoConsent=%d", transConsent, promoConsent);
+    [[Lemnisk shared] setCustomConsentWithTransConsent:transConsent promoConsent:promoConsent];
+}
+
+// Get Custom Consent method (asynchronous with callback)
+RCT_EXPORT_METHOD(getCustomConsent:(RCTResponseSenderBlock)callback) {
+    RCTLogInfo(@"Getting custom consent");
+    [[Lemnisk shared] getCustomConsentObjcWithCompletion:^(NSNumber * _Nullable transConsent, NSNumber * _Nullable promoConsent) {
+        NSArray *response;
+        if (transConsent != nil && promoConsent != nil) {
+            response = @[transConsent, promoConsent];
+        } else {
+            response = @[NSNull.null, NSNull.null];
+        }
+        callback(@[response]);
+    }];
+}
+
+// Get OS Consent method (asynchronous with callback)
+RCT_EXPORT_METHOD(getOSConsent:(RCTResponseSenderBlock)callback) {
+    RCTLogInfo(@"Getting OS consent");
+    [[Lemnisk shared] getOSConsentWithCompletion:^(NSInteger consent) {
+        callback(@[@(consent)]);
+    }];
+}
+
+// Set Custom Device ID method
+RCT_EXPORT_METHOD(setCustomerDeviceId:(NSString *)deviceId) {
+    RCTLogInfo(@"Setting custom device ID: %@", deviceId);
+    [[Lemnisk shared] setCustomerDeviceIdWithDeviceId:deviceId];
+}
+
+// Override Device ID method
+RCT_EXPORT_METHOD(overrideDeviceId:(NSString *)deviceId) {
+    RCTLogInfo(@"Overriding device ID: %@", deviceId);
+    [[Lemnisk shared] overrideDeviceIdWithDeviceId:deviceId];
+}
+
+// Get Unread Count
+RCT_EXPORT_METHOD(getUnreadCount:(NSString *)tokenizedCid
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    RCTLogInfo(@"Getting unread count for tokenizedCid: %@", tokenizedCid);
+    [[Lemnisk shared] getUnreadCountObjcWithTokenizedCid:tokenizedCid completion:^(NSNumber * _Nullable count) {
+        if (count != nil) {
+            resolve(count);
+        } else {
+            reject(@"error", @"Failed to get unread count", nil);
+        }
+    }];
+}
+
+// Mark as Read
+RCT_EXPORT_METHOD(markRead:(NSString *)tokenizedCid
+                  pid:(NSString *)pid
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    RCTLogInfo(@"Marking notification as read for tokenizedCid: %@, pid: %@", tokenizedCid, pid);
+    [[Lemnisk shared] markReadObjcWithTokenizedCid:tokenizedCid pid:pid completion:^(NSNumber * _Nullable success) {
+        if (success != nil) {
+            resolve(success);
+        } else {
+            reject(@"error", @"Failed to mark as read", nil);
+        }
+    }];
+}
+
+// Mark as Deleted
+RCT_EXPORT_METHOD(markDelete:(NSString *)tokenizedCid
+                  pid:(NSString *)pid
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    RCTLogInfo(@"Marking notification as deleted for tokenizedCid: %@, pid: %@", tokenizedCid, pid);
+    [[Lemnisk shared] markDeleteObjcWithTokenizedCid:tokenizedCid pid:pid completion:^(NSNumber * _Nullable success) {
+        if (success != nil) {
+            resolve(success);
+        } else {
+            reject(@"error", @"Failed to mark as deleted", nil);
+        }
+    }];
+}
+
+// Mark as Read (Bulk)
+RCT_EXPORT_METHOD(markBulkRead:(NSString *)tokenizedCid
+                  pids:(NSArray *)pids
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    RCTLogInfo(@"Marking bulk notifications as read for tokenizedCid: %@, pids: %@", tokenizedCid, pids);
+    [[Lemnisk shared] markBulkReadObjcWithTokenizedCid:tokenizedCid pids:pids completion:^(NSNumber * _Nullable success) {
+        if (success != nil) {
+            resolve(success);
+        } else {
+            reject(@"error", @"Failed to mark bulk as read", nil);
+        }
+    }];
+}
+
+// Mark as Deleted (Bulk)
+RCT_EXPORT_METHOD(markBulkDelete:(NSString *)tokenizedCid
+                  pids:(NSArray *)pids
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    RCTLogInfo(@"Marking bulk notifications as deleted for tokenizedCid: %@, pids: %@", tokenizedCid, pids);
+    [[Lemnisk shared] markBulkDeleteObjcWithTokenizedCid:tokenizedCid pids:pids completion:^(NSNumber * _Nullable success) {
+        if (success != nil) {
+            resolve(success);
+        } else {
+            reject(@"error", @"Failed to mark bulk as deleted", nil);
+        }
+    }];
+}
+
+// Read All
+RCT_EXPORT_METHOD(readAll:(NSString *)tokenizedCid
+                  type:(NSString *)type
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    RCTLogInfo(@"Reading all notifications for tokenizedCid: %@, type: %@", tokenizedCid, type);
+    [[Lemnisk shared] readAllObjcWithTokenizedCid:tokenizedCid type:type completion:^(NSNumber * _Nullable success) {
+        if (success != nil) {
+            resolve(success);
+        } else {
+            reject(@"error", @"Failed to read all", nil);
+        }
+    }];
+}
+
+// Delete All
+RCT_EXPORT_METHOD(deleteAll:(NSString *)tokenizedCid
+                  type:(NSString *)type
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    RCTLogInfo(@"Deleting all notifications for tokenizedCid: %@, type: %@", tokenizedCid, type);
+    [[Lemnisk shared] deleteAllObjcWithTokenizedCid:tokenizedCid type:type completion:^(NSNumber * _Nullable success) {
+        if (success != nil) {
+            resolve(success);
+        } else {
+            reject(@"error", @"Failed to delete all", nil);
+        }
+    }];
+}
+
 @end

package/ios/LemniskSdk.xcodeproj/project.pbxproj

@@ -20,6 +20,7 @@
 
 /* Begin PBXFileReference section */
 		134814201AA4EA6300B7C361 /* libLemniskSdk.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libLemniskSdk.a; sourceTree = BUILT_PRODUCTS_DIR; };
+		6E0930EA2D92C3F500D3A5E4 /* Lemnisk.xcframework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.xcframework; name = Lemnisk.xcframework; path = "../../ios-swift-sdk/LemniskFrameworkCode/build/Lemnisk/Lemnisk.xcframework"; sourceTree = "<group>"; };
 		B3E7B5881CC2AC0600A0062D /* LemniskSdk.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LemniskSdk.h; sourceTree = "<group>"; };
 		B3E7B5891CC2AC0600A0062D /* LemniskSdk.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = LemniskSdk.m; sourceTree = "<group>"; };
 /* End PBXFileReference section */
@@ -56,6 +57,7 @@
 		6D63E5B47AF0FDB6B5CFD387 /* Frameworks */ = {
 			isa = PBXGroup;
 			children = (
+				6E0930EA2D92C3F500D3A5E4 /* Lemnisk.xcframework */,
 			);
 			name = Frameworks;
 			sourceTree = "<group>";

package/ios/LemniskSdk.xcodeproj/project.xcworkspace/contents.xcworkspacedata

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Workspace
+   version = "1.0">
+   <FileRef
+      location = "self:">
+   </FileRef>
+</Workspace>

package/ios/LemniskSdk.xcodeproj/xcuserdata/koteswaruduakula.xcuserdatad/xcschemes/xcschememanagement.plist

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>SchemeUserState</key>
+	<dict>
+		<key>LemniskSdk.xcscheme_^#shared#^_</key>
+		<dict>
+			<key>orderHint</key>
+			<integer>0</integer>
+		</dict>
+	</dict>
+</dict>
+</plist>

package/lemnisk-react-native.podspec

@@ -15,7 +15,7 @@ Pod::Spec.new do |s|
   s.source       = { :git => 'https://github.com/Immensitas/lemnisk-react', :tag => s.version }
 
   s.source_files = 'ios/**/*.{h,m,mm}'
-
+  
   s.dependency 'React-Core'
-  s.dependency 'Lemnisk-iOS-SDK', '3.9.4'
+  s.dependency 'Lemnisk-iOS-SDK', '3.9.7'
 end

package/lib/commonjs/index.js

@@ -15,5 +15,18 @@ LemniskSdk.registerForPushNotifications = (title, message) => {
     LemniskSdk.registerForPush();
   }
 };
+const originalSetCustomConsent = LemniskSdk.setCustomConsent;
+LemniskSdk.setCustomConsent = options => {
+  return originalSetCustomConsent(options.transactional, options.promotional);
+};
+const originalGetCustomConsent = LemniskSdk.getCustomConsent;
+LemniskSdk.getCustomConsent = callback => {
+  originalGetCustomConsent(consent => {
+    callback({
+      transactional: consent[0],
+      promotional: consent[1]
+    });
+  });
+};
 var _default = exports.default = LemniskSdk;
 //# sourceMappingURL=index.js.map

package/lib/commonjs/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["_reactNative","require","LemniskSdk","NativeModules","registerForPushNotifications","title","message","Platform","OS","registerForPush","_default","exports","default"],"sources":["index.tsx"],"sourcesContent":["import { NativeModules, Platform } from 'react-native';\n\nconst { LemniskSdk } = NativeModules;\n\n\nLemniskSdk.registerForPushNotifications = (title: string, message: string)=>{\n  if(Platform.OS == \"android\"){\n    LemniskSdk.registerForPush(title, message);\n  }\n  else if(Platform.OS == \"ios\"){\n    LemniskSdk.registerForPush();\n  }\n}\n\ntype LemniskSdkType = {\n  createLemniskEvent(name: string, object: object): any;\n  track(eventName: string, properties: object, otherIds: object): any;\n  screen(name: string, properties: object, otherIds: object): any;\n  identify(userId: string, properties: object, otherIds: object): any;\n  registerForPushNotifications( title?: string, message?: string): any ;\n  \n};\n\n\nexport default LemniskSdk as LemniskSdkType;\n"],"mappings":";;;;;;AAAA,IAAAA,YAAA,GAAAC,OAAA;AAEA,MAAM;EAAEC;AAAW,CAAC,GAAGC,0BAAa;AAGpCD,UAAU,CAACE,4BAA4B,GAAG,CAACC,KAAa,EAAEC,OAAe,KAAG;EAC1E,IAAGC,qBAAQ,CAACC,EAAE,IAAI,SAAS,EAAC;IAC1BN,UAAU,CAACO,eAAe,CAACJ,KAAK,EAAEC,OAAO,CAAC;EAC5C,CAAC,MACI,IAAGC,qBAAQ,CAACC,EAAE,IAAI,KAAK,EAAC;IAC3BN,UAAU,CAACO,eAAe,CAAC,CAAC;EAC9B;AACF,CAAC;AAAA,IAAAC,QAAA,GAAAC,OAAA,CAAAC,OAAA,GAYcV,UAAU","ignoreList":[]}
+{"version":3,"names":["_reactNative","require","LemniskSdk","NativeModules","registerForPushNotifications","title","message","Platform","OS","registerForPush","originalSetCustomConsent","setCustomConsent","options","transactional","promotional","originalGetCustomConsent","getCustomConsent","callback","consent","_default","exports","default"],"sources":["index.tsx"],"sourcesContent":["import { NativeModules, Platform } from 'react-native';\n\nconst { LemniskSdk } = NativeModules;\n\ntype ConsentOptions = {\n  transactional: boolean;\n  promotional: boolean;\n};\n\nLemniskSdk.registerForPushNotifications = (title: string, message: string)=>{\n  if(Platform.OS == \"android\"){\n    LemniskSdk.registerForPush(title, message);\n  }\n  else if(Platform.OS == \"ios\"){\n    LemniskSdk.registerForPush();\n  }\n}\n\ntype LemniskSdkType = {\n  createLemniskEvent(name: string, object: object): any;\n  track(eventName: string, properties: object, otherIds: object): any;\n  screen(name: string, properties: object, otherIds: object): any;\n  identify(userId: string, properties: object, otherIds: object): any;\n  registerForPushNotifications(title?: string, message?: string): any;\n  setUniqueUserId(tokenizedCid: string): void;\n  getUniqueUserId(): string;\n  setCustomConsent(options: ConsentOptions): void;\n  getCustomConsent(callback: (consent: { transactional: boolean | null; promotional: boolean | null }) => void): void;\n  getOSConsent(callback: (consent: number) => void): void;\n  setCustomerDeviceId(deviceId: string): void;\n  overrideDeviceId(deviceId: string): void;\n  getUnreadCount(tokenizedCid: string): Promise<number>;\n  markRead(tokenizedCid: string, pid: string): Promise<boolean>;\n  markBulkRead(tokenizedCid: string, pids: string[]): Promise<boolean>;\n  markDelete(tokenizedCid: string, pid: string): Promise<boolean>;\n  markBulkDelete(tokenizedCid: string, pids: string[]): Promise<boolean>;\n  readAll(tokenizedCid: string, type: string): Promise<boolean>;\n  deleteAll(tokenizedCid: string, type: string): Promise<boolean>;\n  resetUser(): void;\n};\n\nconst originalSetCustomConsent = LemniskSdk.setCustomConsent;\nLemniskSdk.setCustomConsent = (options: ConsentOptions) => {\n  return originalSetCustomConsent(options.transactional, options.promotional);\n};\n\n\nconst originalGetCustomConsent = LemniskSdk.getCustomConsent;\nLemniskSdk.getCustomConsent = (callback: (consent: { transactional: boolean | null; promotional: boolean | null }) => void) => {\n  originalGetCustomConsent((consent: [boolean | null, boolean | null]) => {\n    callback({\n      transactional: consent[0],\n      promotional: consent[1]\n    });\n  });\n};\n\nexport default LemniskSdk as LemniskSdkType;\n"],"mappings":";;;;;;AAAA,IAAAA,YAAA,GAAAC,OAAA;AAEA,MAAM;EAAEC;AAAW,CAAC,GAAGC,0BAAa;AAOpCD,UAAU,CAACE,4BAA4B,GAAG,CAACC,KAAa,EAAEC,OAAe,KAAG;EAC1E,IAAGC,qBAAQ,CAACC,EAAE,IAAI,SAAS,EAAC;IAC1BN,UAAU,CAACO,eAAe,CAACJ,KAAK,EAAEC,OAAO,CAAC;EAC5C,CAAC,MACI,IAAGC,qBAAQ,CAACC,EAAE,IAAI,KAAK,EAAC;IAC3BN,UAAU,CAACO,eAAe,CAAC,CAAC;EAC9B;AACF,CAAC;AAyBD,MAAMC,wBAAwB,GAAGR,UAAU,CAACS,gBAAgB;AAC5DT,UAAU,CAACS,gBAAgB,GAAIC,OAAuB,IAAK;EACzD,OAAOF,wBAAwB,CAACE,OAAO,CAACC,aAAa,EAAED,OAAO,CAACE,WAAW,CAAC;AAC7E,CAAC;AAGD,MAAMC,wBAAwB,GAAGb,UAAU,CAACc,gBAAgB;AAC5Dd,UAAU,CAACc,gBAAgB,GAAIC,QAA2F,IAAK;EAC7HF,wBAAwB,CAAEG,OAAyC,IAAK;IACtED,QAAQ,CAAC;MACPJ,aAAa,EAAEK,OAAO,CAAC,CAAC,CAAC;MACzBJ,WAAW,EAAEI,OAAO,CAAC,CAAC;IACxB,CAAC,CAAC;EACJ,CAAC,CAAC;AACJ,CAAC;AAAC,IAAAC,QAAA,GAAAC,OAAA,CAAAC,OAAA,GAEanB,UAAU","ignoreList":[]}

package/lib/module/index.js

@@ -9,5 +9,18 @@ LemniskSdk.registerForPushNotifications = (title, message) => {
     LemniskSdk.registerForPush();
   }
 };
+const originalSetCustomConsent = LemniskSdk.setCustomConsent;
+LemniskSdk.setCustomConsent = options => {
+  return originalSetCustomConsent(options.transactional, options.promotional);
+};
+const originalGetCustomConsent = LemniskSdk.getCustomConsent;
+LemniskSdk.getCustomConsent = callback => {
+  originalGetCustomConsent(consent => {
+    callback({
+      transactional: consent[0],
+      promotional: consent[1]
+    });
+  });
+};
 export default LemniskSdk;
 //# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["NativeModules","Platform","LemniskSdk","registerForPushNotifications","title","message","OS","registerForPush"],"sources":["index.tsx"],"sourcesContent":["import { NativeModules, Platform } from 'react-native';\n\nconst { LemniskSdk } = NativeModules;\n\n\nLemniskSdk.registerForPushNotifications = (title: string, message: string)=>{\n  if(Platform.OS == \"android\"){\n    LemniskSdk.registerForPush(title, message);\n  }\n  else if(Platform.OS == \"ios\"){\n    LemniskSdk.registerForPush();\n  }\n}\n\ntype LemniskSdkType = {\n  createLemniskEvent(name: string, object: object): any;\n  track(eventName: string, properties: object, otherIds: object): any;\n  screen(name: string, properties: object, otherIds: object): any;\n  identify(userId: string, properties: object, otherIds: object): any;\n  registerForPushNotifications( title?: string, message?: string): any ;\n  \n};\n\n\nexport default LemniskSdk as LemniskSdkType;\n"],"mappings":"AAAA,SAASA,aAAa,EAAEC,QAAQ,QAAQ,cAAc;AAEtD,MAAM;EAAEC;AAAW,CAAC,GAAGF,aAAa;AAGpCE,UAAU,CAACC,4BAA4B,GAAG,CAACC,KAAa,EAAEC,OAAe,KAAG;EAC1E,IAAGJ,QAAQ,CAACK,EAAE,IAAI,SAAS,EAAC;IAC1BJ,UAAU,CAACK,eAAe,CAACH,KAAK,EAAEC,OAAO,CAAC;EAC5C,CAAC,MACI,IAAGJ,QAAQ,CAACK,EAAE,IAAI,KAAK,EAAC;IAC3BJ,UAAU,CAACK,eAAe,CAAC,CAAC;EAC9B;AACF,CAAC;AAYD,eAAeL,UAAU","ignoreList":[]}
+{"version":3,"names":["NativeModules","Platform","LemniskSdk","registerForPushNotifications","title","message","OS","registerForPush","originalSetCustomConsent","setCustomConsent","options","transactional","promotional","originalGetCustomConsent","getCustomConsent","callback","consent"],"sources":["index.tsx"],"sourcesContent":["import { NativeModules, Platform } from 'react-native';\n\nconst { LemniskSdk } = NativeModules;\n\ntype ConsentOptions = {\n  transactional: boolean;\n  promotional: boolean;\n};\n\nLemniskSdk.registerForPushNotifications = (title: string, message: string)=>{\n  if(Platform.OS == \"android\"){\n    LemniskSdk.registerForPush(title, message);\n  }\n  else if(Platform.OS == \"ios\"){\n    LemniskSdk.registerForPush();\n  }\n}\n\ntype LemniskSdkType = {\n  createLemniskEvent(name: string, object: object): any;\n  track(eventName: string, properties: object, otherIds: object): any;\n  screen(name: string, properties: object, otherIds: object): any;\n  identify(userId: string, properties: object, otherIds: object): any;\n  registerForPushNotifications(title?: string, message?: string): any;\n  setUniqueUserId(tokenizedCid: string): void;\n  getUniqueUserId(): string;\n  setCustomConsent(options: ConsentOptions): void;\n  getCustomConsent(callback: (consent: { transactional: boolean | null; promotional: boolean | null }) => void): void;\n  getOSConsent(callback: (consent: number) => void): void;\n  setCustomerDeviceId(deviceId: string): void;\n  overrideDeviceId(deviceId: string): void;\n  getUnreadCount(tokenizedCid: string): Promise<number>;\n  markRead(tokenizedCid: string, pid: string): Promise<boolean>;\n  markBulkRead(tokenizedCid: string, pids: string[]): Promise<boolean>;\n  markDelete(tokenizedCid: string, pid: string): Promise<boolean>;\n  markBulkDelete(tokenizedCid: string, pids: string[]): Promise<boolean>;\n  readAll(tokenizedCid: string, type: string): Promise<boolean>;\n  deleteAll(tokenizedCid: string, type: string): Promise<boolean>;\n  resetUser(): void;\n};\n\nconst originalSetCustomConsent = LemniskSdk.setCustomConsent;\nLemniskSdk.setCustomConsent = (options: ConsentOptions) => {\n  return originalSetCustomConsent(options.transactional, options.promotional);\n};\n\n\nconst originalGetCustomConsent = LemniskSdk.getCustomConsent;\nLemniskSdk.getCustomConsent = (callback: (consent: { transactional: boolean | null; promotional: boolean | null }) => void) => {\n  originalGetCustomConsent((consent: [boolean | null, boolean | null]) => {\n    callback({\n      transactional: consent[0],\n      promotional: consent[1]\n    });\n  });\n};\n\nexport default LemniskSdk as LemniskSdkType;\n"],"mappings":"AAAA,SAASA,aAAa,EAAEC,QAAQ,QAAQ,cAAc;AAEtD,MAAM;EAAEC;AAAW,CAAC,GAAGF,aAAa;AAOpCE,UAAU,CAACC,4BAA4B,GAAG,CAACC,KAAa,EAAEC,OAAe,KAAG;EAC1E,IAAGJ,QAAQ,CAACK,EAAE,IAAI,SAAS,EAAC;IAC1BJ,UAAU,CAACK,eAAe,CAACH,KAAK,EAAEC,OAAO,CAAC;EAC5C,CAAC,MACI,IAAGJ,QAAQ,CAACK,EAAE,IAAI,KAAK,EAAC;IAC3BJ,UAAU,CAACK,eAAe,CAAC,CAAC;EAC9B;AACF,CAAC;AAyBD,MAAMC,wBAAwB,GAAGN,UAAU,CAACO,gBAAgB;AAC5DP,UAAU,CAACO,gBAAgB,GAAIC,OAAuB,IAAK;EACzD,OAAOF,wBAAwB,CAACE,OAAO,CAACC,aAAa,EAAED,OAAO,CAACE,WAAW,CAAC;AAC7E,CAAC;AAGD,MAAMC,wBAAwB,GAAGX,UAAU,CAACY,gBAAgB;AAC5DZ,UAAU,CAACY,gBAAgB,GAAIC,QAA2F,IAAK;EAC7HF,wBAAwB,CAAEG,OAAyC,IAAK;IACtED,QAAQ,CAAC;MACPJ,aAAa,EAAEK,OAAO,CAAC,CAAC,CAAC;MACzBJ,WAAW,EAAEI,OAAO,CAAC,CAAC;IACxB,CAAC,CAAC;EACJ,CAAC,CAAC;AACJ,CAAC;AAED,eAAed,UAAU","ignoreList":[]}

package/lib/typescript/src/index.d.ts

@@ -1,9 +1,31 @@
+type ConsentOptions = {
+    transactional: boolean;
+    promotional: boolean;
+};
 type LemniskSdkType = {
     createLemniskEvent(name: string, object: object): any;
     track(eventName: string, properties: object, otherIds: object): any;
     screen(name: string, properties: object, otherIds: object): any;
     identify(userId: string, properties: object, otherIds: object): any;
     registerForPushNotifications(title?: string, message?: string): any;
+    setUniqueUserId(tokenizedCid: string): void;
+    getUniqueUserId(): string;
+    setCustomConsent(options: ConsentOptions): void;
+    getCustomConsent(callback: (consent: {
+        transactional: boolean | null;
+        promotional: boolean | null;
+    }) => void): void;
+    getOSConsent(callback: (consent: number) => void): void;
+    setCustomerDeviceId(deviceId: string): void;
+    overrideDeviceId(deviceId: string): void;
+    getUnreadCount(tokenizedCid: string): Promise<number>;
+    markRead(tokenizedCid: string, pid: string): Promise<boolean>;
+    markBulkRead(tokenizedCid: string, pids: string[]): Promise<boolean>;
+    markDelete(tokenizedCid: string, pid: string): Promise<boolean>;
+    markBulkDelete(tokenizedCid: string, pids: string[]): Promise<boolean>;
+    readAll(tokenizedCid: string, type: string): Promise<boolean>;
+    deleteAll(tokenizedCid: string, type: string): Promise<boolean>;
+    resetUser(): void;
 };
 declare const _default: LemniskSdkType;
 export default _default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lemnisk-react-native",
-  "version": "0.1.17",
+  "version": "0.1.19",
   "description": "plugin to setup the lemnisk sdk on both android and ios platform",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",

package/src/index.tsx

@@ -2,6 +2,10 @@ import { NativeModules, Platform } from 'react-native';
 
 const { LemniskSdk } = NativeModules;
 
+type ConsentOptions = {
+  transactional: boolean;
+  promotional: boolean;
+};
 
 LemniskSdk.registerForPushNotifications = (title: string, message: string)=>{
   if(Platform.OS == "android"){
@@ -17,9 +21,38 @@ type LemniskSdkType = {
   track(eventName: string, properties: object, otherIds: object): any;
   screen(name: string, properties: object, otherIds: object): any;
   identify(userId: string, properties: object, otherIds: object): any;
-  registerForPushNotifications( title?: string, message?: string): any ;
-  
+  registerForPushNotifications(title?: string, message?: string): any;
+  setUniqueUserId(tokenizedCid: string): void;
+  getUniqueUserId(): string;
+  setCustomConsent(options: ConsentOptions): void;
+  getCustomConsent(callback: (consent: { transactional: boolean | null; promotional: boolean | null }) => void): void;
+  getOSConsent(callback: (consent: number) => void): void;
+  setCustomerDeviceId(deviceId: string): void;
+  overrideDeviceId(deviceId: string): void;
+  getUnreadCount(tokenizedCid: string): Promise<number>;
+  markRead(tokenizedCid: string, pid: string): Promise<boolean>;
+  markBulkRead(tokenizedCid: string, pids: string[]): Promise<boolean>;
+  markDelete(tokenizedCid: string, pid: string): Promise<boolean>;
+  markBulkDelete(tokenizedCid: string, pids: string[]): Promise<boolean>;
+  readAll(tokenizedCid: string, type: string): Promise<boolean>;
+  deleteAll(tokenizedCid: string, type: string): Promise<boolean>;
+  resetUser(): void;
+};
+
+const originalSetCustomConsent = LemniskSdk.setCustomConsent;
+LemniskSdk.setCustomConsent = (options: ConsentOptions) => {
+  return originalSetCustomConsent(options.transactional, options.promotional);
 };
 
 
+const originalGetCustomConsent = LemniskSdk.getCustomConsent;
+LemniskSdk.getCustomConsent = (callback: (consent: { transactional: boolean | null; promotional: boolean | null }) => void) => {
+  originalGetCustomConsent((consent: [boolean | null, boolean | null]) => {
+    callback({
+      transactional: consent[0],
+      promotional: consent[1]
+    });
+  });
+};
+
 export default LemniskSdk as LemniskSdkType;