cordova-plugin-appice 2.0.9 → 2.1.1

package/src/ios/AppDelegate+AppICEPlugin.m

@@ -17,6 +17,23 @@
 #define kApplicationInBackgroundKey @"applicationInBackground"
 #define SYSTEM_VERSION_GRATERTHAN_OR_EQUALTO(v)  ([[[UIDevice currentDevice] systemVersion] compare:v options:NSNumericSearch] != NSOrderedAscending)
 
+Method originalMethodReceiveRemoteNotification;
+Method swizzledMethodReceiveRemoteNotification;
+
+Method originalMethoddidReceiveNotificationResponse;
+Method swizzledMethoddidReceiveNotificationResponse;
+
+
+Method originalMethodRemoteNotificationsWithDeviceToken;
+Method swizzledMethodRemoteNotificationsWithDeviceToken;
+
+
+Method originalMethodWillPresentNotification;
+Method swizzledMethodWillPresentNotification;
+
+Method originalMethoddidFailToRegisterRemoteNotification;
+Method swizzledMethoddidFailToRegisterRemoteNotification;
+
 @implementation AppDelegate (AppICEPlugin)
 
 static id appdelegate;
@@ -24,33 +41,103 @@ typedef void (*OriginalImpType)(id self, SEL selector);
 static OriginalImpType originalImp;
 + (void)load {
     
-    NSLog(@"In Appice Load method");
-    
-    // Swizzling method for handling received remote notifications
-    Method originalDidReceiveRemoteNotification = class_getInstanceMethod(self, @selector(application:didReceiveRemoteNotification:fetchCompletionHandler:));
-    Method swizzleDidReceiveRemoteNotification = class_getInstanceMethod(self, @selector(application:swizzleddidReceiveRemoteNotification:fetchCompletionHandler:));
-    method_exchangeImplementations(originalDidReceiveRemoteNotification, swizzleDidReceiveRemoteNotification);
-    
-    // Swizzling method for handling notification responses
-    Method originalDidResponseRemoteNotification = class_getInstanceMethod(self, @selector(userNotificationCenter:didReceiveNotificationResponse:withCompletionHandler:));
-    Method swizzleDidResponseRemoteNotification = class_getInstanceMethod(self, @selector(userNotificationCenter:swizzleddidReceiveNotificationResponse:withCompletionHandler:));
-    method_exchangeImplementations(originalDidResponseRemoteNotification, swizzleDidResponseRemoteNotification);
-    
-    // Swizzling method for handling notification will present
-    Method originalwillPresentNotification = class_getInstanceMethod(self, @selector(userNotificationCenter:willPresentNotification:withCompletionHandler:));
-    Method swizzlewillPresentNotification = class_getInstanceMethod(self, @selector(userNotificationCenter:swizzledwillPresentNotification:withCompletionHandler:));
-    method_exchangeImplementations(originalwillPresentNotification, swizzlewillPresentNotification);
-    
-    // Swizzling method for handling device token registration for remote notifications
-    Method originaldidRegisterForRemoteNotificationsWithDeviceToken = class_getInstanceMethod(self, @selector(application:didRegisterForRemoteNotificationsWithDeviceToken:));
-    Method swizzleddidRegisterForRemoteNotificationsWithDeviceToken = class_getInstanceMethod(self, @selector(application:swizzleddidRegisterForRemoteNotificationsWithDeviceToken:));
-    method_exchangeImplementations(originaldidRegisterForRemoteNotificationsWithDeviceToken, swizzleddidRegisterForRemoteNotificationsWithDeviceToken);
-    
-    // Swizzling method for handling failures during remote notification registration
-    Method originaldidFailToRegisterForRemoteNotificationsWithError = class_getInstanceMethod(self, @selector(application:didFailToRegisterForRemoteNotificationsWithError:));
-    Method swizzleddidFailToRegisterForRemoteNotificationsWithError = class_getInstanceMethod(self, @selector(application:swizzleddidFailToRegisterForRemoteNotificationsWithError:));
-    method_exchangeImplementations(originaldidFailToRegisterForRemoteNotificationsWithError, swizzleddidFailToRegisterForRemoteNotificationsWithError);
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+        //for receving Notification
+        Class class = [self class];
+        
+        SEL originalSelectorReceiveRemoteNotification = @selector(application:didReceiveRemoteNotification:fetchCompletionHandler:);
+        SEL swizzledSelectorReceiveRemoteNotification = @selector(swizzled_application:swizzleddidReceiveRemoteNotification:fetchCompletionHandler:);
+        
+        originalMethodReceiveRemoteNotification = class_getInstanceMethod(class, originalSelectorReceiveRemoteNotification);
+        swizzledMethodReceiveRemoteNotification = class_getInstanceMethod(class, swizzledSelectorReceiveRemoteNotification);
+        
+        BOOL didAddMethodReceiveRemoteNotification =
+        class_addMethod(class, originalSelectorReceiveRemoteNotification, method_getImplementation(swizzledMethodReceiveRemoteNotification), method_getTypeEncoding(swizzledMethodReceiveRemoteNotification));
+        
+        if (didAddMethodReceiveRemoteNotification) {
+            class_replaceMethod(class, swizzledSelectorReceiveRemoteNotification, method_getImplementation(originalMethodReceiveRemoteNotification), method_getTypeEncoding(originalMethodReceiveRemoteNotification));
+        } else {
+            method_exchangeImplementations(originalMethodReceiveRemoteNotification, swizzledMethodReceiveRemoteNotification);
+        }
+        
+        
+        
+        //for notfication response
+        
+        SEL originalSelectorReceiveNotificationResponse = @selector(userNotificationCenter:didReceiveNotificationResponse:withCompletionHandler:);
+        SEL swizzledSelectorReceiveNotificationResponse = @selector(swizzled_userNotificationCenter:swizzleddidReceiveNotificationResponse:withCompletionHandler:);
+        
+        originalMethoddidReceiveNotificationResponse = class_getInstanceMethod(class, originalSelectorReceiveNotificationResponse);
+        swizzledMethoddidReceiveNotificationResponse = class_getInstanceMethod(class, swizzledSelectorReceiveNotificationResponse);
+        
+        BOOL didAddMethodReceiveNotificationResponse =
+        class_addMethod(class, originalSelectorReceiveNotificationResponse, method_getImplementation(swizzledMethoddidReceiveNotificationResponse), method_getTypeEncoding(swizzledMethoddidReceiveNotificationResponse));
+        
+        if (didAddMethodReceiveNotificationResponse) {
+            class_replaceMethod(class, swizzledSelectorReceiveNotificationResponse, method_getImplementation(originalMethoddidReceiveNotificationResponse), method_getTypeEncoding(originalMethoddidReceiveNotificationResponse));
+        } else {
+            method_exchangeImplementations(originalMethoddidReceiveNotificationResponse, swizzledMethoddidReceiveNotificationResponse);
+        }
+        
+        
+        //for token
+
+        SEL originalSelectorRemoteNotificationsWithDeviceToken = @selector(application:didRegisterForRemoteNotificationsWithDeviceToken:);
+        SEL swizzledSelectorRemoteNotificationsWithDeviceToken = @selector(swizzled_application:swizzleddidRegisterForRemoteNotificationsWithDeviceToken:);
+        
+        originalMethodRemoteNotificationsWithDeviceToken = class_getInstanceMethod(class, originalSelectorRemoteNotificationsWithDeviceToken);
+        swizzledMethodRemoteNotificationsWithDeviceToken = class_getInstanceMethod(class, swizzledSelectorRemoteNotificationsWithDeviceToken);
+        
+        BOOL didAddMethodRemoteNotificationsWithDeviceToken =
+        class_addMethod(class, originalSelectorRemoteNotificationsWithDeviceToken, method_getImplementation(swizzledMethodRemoteNotificationsWithDeviceToken), method_getTypeEncoding(swizzledMethodRemoteNotificationsWithDeviceToken));
+        
+        if (didAddMethodRemoteNotificationsWithDeviceToken) {
+            class_replaceMethod(class, swizzledSelectorRemoteNotificationsWithDeviceToken, method_getImplementation(originalMethodRemoteNotificationsWithDeviceToken), method_getTypeEncoding(originalMethodRemoteNotificationsWithDeviceToken));
+        } else {
+            method_exchangeImplementations(originalMethodRemoteNotificationsWithDeviceToken, swizzledMethodRemoteNotificationsWithDeviceToken);
+        }
+        
+        
+        //will present
+
+        SEL originalSelectorWillPresentNotification = @selector(userNotificationCenter:willPresentNotification:withCompletionHandler:);
+        SEL swizzledSelectorWillPresentNotification = @selector(swizzled_userNotificationCenter:swizzledwillPresentNotification:withCompletionHandler:);
+        
+        originalMethodWillPresentNotification = class_getInstanceMethod(class, originalSelectorWillPresentNotification);
+        swizzledMethodWillPresentNotification = class_getInstanceMethod(class, swizzledSelectorWillPresentNotification);
+        
+        BOOL didAddMethodWillPresentNotification =
+        class_addMethod(class, originalSelectorWillPresentNotification, method_getImplementation(swizzledMethodWillPresentNotification), method_getTypeEncoding(swizzledMethodWillPresentNotification));
+        
+        if (didAddMethodWillPresentNotification) {
+            class_replaceMethod(class, swizzledSelectorWillPresentNotification, method_getImplementation(originalMethodWillPresentNotification), method_getTypeEncoding(originalMethodWillPresentNotification));
+        } else {
+            method_exchangeImplementations(originalMethodWillPresentNotification, swizzledMethodWillPresentNotification);
+        }
+        
+        
+        //push failure
+
+        SEL originalSelectordidFailToRegisterRemoteNotification = @selector(application:didFailToRegisterForRemoteNotificationsWithError:);
+        SEL swizzledSelectordidFailToRegisterRemoteNotification = @selector(swizzled_application:swizzleddidFailToRegisterForRemoteNotificationsWithError:);
+        
+        originalMethoddidFailToRegisterRemoteNotification = class_getInstanceMethod(class, originalSelectordidFailToRegisterRemoteNotification);
+        swizzledMethoddidFailToRegisterRemoteNotification = class_getInstanceMethod(class, swizzledSelectordidFailToRegisterRemoteNotification);
+        
+        BOOL didAddMethoddidFailToRegisterRemoteNotification =
+        class_addMethod(class, originalSelectordidFailToRegisterRemoteNotification, method_getImplementation(swizzledMethoddidFailToRegisterRemoteNotification), method_getTypeEncoding(swizzledMethoddidFailToRegisterRemoteNotification));
+        
+        if (didAddMethoddidFailToRegisterRemoteNotification) {
+            class_replaceMethod(class, swizzledSelectordidFailToRegisterRemoteNotification, method_getImplementation(originalMethoddidFailToRegisterRemoteNotification), method_getTypeEncoding(originalMethoddidFailToRegisterRemoteNotification));
+        } else {
+            method_exchangeImplementations(originalMethoddidFailToRegisterRemoteNotification, swizzledMethoddidFailToRegisterRemoteNotification);
+        }
+        
+
+    });
     
+    NSLog(@"In Appice Load method");
     
 }
 
@@ -77,7 +164,7 @@ static OriginalImpType originalImp;
 #pragma mark - Handling received remote notifications
 
 // Swizzled method for handling received remote notifications
-- (void)application:(UIApplication *)application swizzleddidReceiveRemoteNotification:(NSDictionary *)userInfo fetchCompletionHandler:(void (^)(UIBackgroundFetchResult))completionHandler {
+- (void)swizzled_application:(UIApplication *)application swizzleddidReceiveRemoteNotification:(NSDictionary *)userInfo fetchCompletionHandler:(void (^)(UIBackgroundFetchResult))completionHandler {
     NSLog(@"inside swizzledidreceive %@", userInfo);
     @try {
         // Check if the push is from Appice server.
@@ -87,8 +174,16 @@ static OriginalImpType originalImp;
             [[AppICEPlugin appice] onHandleRemoteUNotification:userInfo];
             completionHandler(UIBackgroundFetchResultNewData);
         } else {
-            // Else, the notification is not related to Appice, so it will be handled by other third-party plugin.
-            [self application:application swizzleddidReceiveRemoteNotification:userInfo fetchCompletionHandler:completionHandler];
+            //NOTE : originalMethodReceiveRemoteNotification will be nil by default as our plugin also dont have original method. It will not be nil if any other push plugin is there
+            if(originalMethodReceiveRemoteNotification)
+            {
+                //caling original method over swizzling ie other plugin push method
+                method_exchangeImplementations(swizzledMethodReceiveRemoteNotification,originalMethodReceiveRemoteNotification);
+                //CALLING ORIGINAL METHOD
+                [self application:application didReceiveRemoteNotification:userInfo fetchCompletionHandler:completionHandler];
+                //reverting back our swizzling over original method of other plugin push
+                method_exchangeImplementations(originalMethodReceiveRemoteNotification,swizzledMethodReceiveRemoteNotification);
+            }
         }
     }
     @catch (NSException *exception) {
@@ -96,81 +191,87 @@ static OriginalImpType originalImp;
     }
 }
 
--(void)application:(UIApplication *)application didReceiveRemoteNotification:(NSDictionary *)userInfo fetchCompletionHandler:(void (^)(UIBackgroundFetchResult))completionHandler {
-    NSLog(@"inside original didReceiveRemoteNotification %@",userInfo);
-    completionHandler(UIBackgroundFetchResultNewData);
-}
 
 #pragma mark - Handling of remote notification response
 // Swizzled method for handling remote notification response
-- (void)userNotificationCenter:(UNUserNotificationCenter *)center swizzleddidReceiveNotificationResponse:(UNNotificationResponse *)response withCompletionHandler:(void(^)(void))completionHandler{
+- (void)swizzled_userNotificationCenter:(UNUserNotificationCenter *)center swizzleddidReceiveNotificationResponse:(UNNotificationResponse *)response withCompletionHandler:(void(^)(void))completionHandler{
     
     @try {
-        NSDictionary *userInfo = response.notification.request.content.userInfo;
-        NSLog(@"inside swizzledidresponse %@",userInfo);
-        BOOL appIceServer = [[appICE sharedInstance] isAppICENotification:userInfo];
-        if(appIceServer)
-        {
-            // If yes, Appice plugin will be notified.
-            [[AppICEPlugin appice] onHandleNotificationUResponse:userInfo];
-            completionHandler();
-        }
-        else
-        {
-            // Else, the notification is not related to Appice, so it will be handled by other third-party plugin.
-            [self userNotificationCenter:center swizzleddidReceiveNotificationResponse:response withCompletionHandler:completionHandler];
-        }
+        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+            [NSThread sleepForTimeInterval:2.0f];
+            dispatch_async(dispatch_get_main_queue(), ^{
+                NSDictionary *userInfo = response.notification.request.content.userInfo;
+                NSLog(@"inside swizzledidresponse %@",userInfo);
+                BOOL appIceServer = [[appICE sharedInstance] isAppICENotification:userInfo];
+                if(appIceServer)
+                {
+                    // If yes, Appice plugin will be notified.
+                    [[AppICEPlugin appice] onHandleNotificationUResponse:userInfo];
+                    completionHandler();
+                }
+                else
+                {
+                    //NOTE : originalMethodReceiveRemoteNotification will be nil by default as our plugin also dont have original method. It will not be nil if any other push plugin is there
+                    
+                    if(originalMethoddidReceiveNotificationResponse)
+                    {
+                        //caling original method over swizzling ie other plugin push method
+                        method_exchangeImplementations(swizzledMethoddidReceiveNotificationResponse,originalMethoddidReceiveNotificationResponse);
+                        //CALLING ORIGINAL METHOD
+                        [self userNotificationCenter:center didReceiveNotificationResponse:response withCompletionHandler:completionHandler];
+                        //reverting back our swizzling over original method of other plugin push
+                        method_exchangeImplementations(originalMethoddidReceiveNotificationResponse,swizzledMethoddidReceiveNotificationResponse);
+                    }
+                }
+            });
+        });
    
     }
     @catch (NSException *exception) {
         NSLog(@"exception from did response notfication cordova = %@",exception.reason);
     }
 }
-- (void)userNotificationCenter:(UNUserNotificationCenter *)center didReceiveNotificationResponse:(UNNotificationResponse *)response withCompletionHandler:(void(^)(void))completionHandler{
-    
-    @try {
-        NSLog(@"In original userNotificationCenter");
-    }
-    @catch (NSException *exception) {
-        
-    }
-}
 #pragma mark - Handling of remote notification registration failures
 // Swizzled method for handling remote notification registration failures
-- (void)application:(UIApplication*)application swizzleddidFailToRegisterForRemoteNotificationsWithError:(NSError*)error {
+- (void)swizzled_application:(UIApplication*)application swizzleddidFailToRegisterForRemoteNotificationsWithError:(NSError*)error {
     @try {
         [[AppICEPlugin appice] handleTokenError:error];
-        [self application:application swizzleddidFailToRegisterForRemoteNotificationsWithError:error];
+        
+        if(originalMethoddidFailToRegisterRemoteNotification)
+        {
+            //caling original method over swizzling ie other plugin push method
+            method_exchangeImplementations(swizzledMethodReceiveRemoteNotification,originalMethodReceiveRemoteNotification);
+            //CALLING ORIGINAL METHOD
+            [self application:application didFailToRegisterForRemoteNotificationsWithError:error];
+            //reverting back our swizzling over original method of other plugin push
+            method_exchangeImplementations(originalMethoddidFailToRegisterRemoteNotification,swizzledMethoddidFailToRegisterRemoteNotification);
+        }
+
     } @catch (NSException *exception) {
         NSLog(@"exception from swizzleddidFailToRegisterForRemoteNotificationsWithError cordova = %@",exception.reason);
     }
 }
-- (void)application:(UIApplication*)application didFailToRegisterForRemoteNotificationsWithError:(NSError*)error {
-    @try {
-        NSLog(@"in original didFailToRegisterForRemoteNotificationsWithError");
-    } @catch (NSException *exception) {
-    }
-}
+
 #pragma mark - Handle Device Token
 // Swizzled method for handling Device Token
-- (void)application:(UIApplication*)application swizzleddidRegisterForRemoteNotificationsWithDeviceToken:(NSData*)deviceToken {
+- (void)swizzled_application:(UIApplication*)application swizzleddidRegisterForRemoteNotificationsWithDeviceToken:(NSData*)deviceToken {
     @try {
         NSLog(@"apns token appIce  %@",deviceToken);
         [[AppICEPlugin appice] handleToken:deviceToken];
-        [self application:application swizzleddidRegisterForRemoteNotificationsWithDeviceToken:deviceToken];
+        if(originalMethodRemoteNotificationsWithDeviceToken){
+            //caling original method over swizzling ie other plugin push method
+            method_exchangeImplementations(swizzledMethodRemoteNotificationsWithDeviceToken,originalMethodRemoteNotificationsWithDeviceToken);
+            //CALLING ORIGINAL METHOD
+            [self application:application didRegisterForRemoteNotificationsWithDeviceToken:deviceToken];
+            //reverting back our swizzling over original method of other plugin push
+            method_exchangeImplementations(originalMethodRemoteNotificationsWithDeviceToken,swizzledMethodRemoteNotificationsWithDeviceToken);
+        }
+        
         
     } @catch(NSException *e){
         NSLog(@"exception from swizzleddidRegisterForRemoteNotificationsWithDeviceToken cordova = %@",e.reason);
     }
 }
-- (void)application:(UIApplication*)application didRegisterForRemoteNotificationsWithDeviceToken:(NSData*)deviceToken
-{
-    @try {
-        NSLog(@"inside didRegisterForRemoteNotificationsWithDeviceToken %@",deviceToken);
-        
-    } @catch (NSException *exception) {
-    }
-}
 #pragma mark - Handle Local Notification
 
 - (void) application:(UIApplication*)application didReceiveLocalNotification:(UILocalNotification*)notification {
@@ -184,19 +285,8 @@ static OriginalImpType originalImp;
 #pragma mark - Handling of remote notification willPresentNotification
 
 #if defined(__IPHONE_10_0) && __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_10_0
-- (void)userNotificationCenter:(UNUserNotificationCenter *)center
-       willPresentNotification:(UNNotification *)notification
-         withCompletionHandler:(void (^)(UNNotificationPresentationOptions))completionHandler {
-    @try {
-        NSLog(@"inside original willPresentNotification");
-    } @catch (NSException *exception) {
-
-    } @finally {
-        
-    }
-}
 
-- (void)userNotificationCenter:(UNUserNotificationCenter *)center
+- (void)swizzled_userNotificationCenter:(UNUserNotificationCenter *)center
 swizzledwillPresentNotification:(UNNotification *)notification
          withCompletionHandler:(void (^)(UNNotificationPresentationOptions))completionHandler {
     @try {
@@ -270,10 +360,9 @@ swizzledwillPresentNotification:(UNNotification *)notification
 
 - (void)openURL:(NSURL*)url options:(NSDictionary<NSString *, id> *)options completionHandler:(void (^ __nullable)(BOOL success))completion {
     @try {
-        [[AppICEPlugin appice] onHandleOpenURLNotification:url];
+    
     } @catch (NSException *exception) {
     }
 }
 
 @end
-

package/src/ios/AppICEPlugin.h

@@ -85,6 +85,9 @@ static NSString* const AIHandleActionNotification = @"AIHandleActionNotification
 
 -(void)onHandleRemoteUNotification:(NSDictionary *)userInfo;
 -(void)onHandleNotificationUResponse:(NSDictionary *)userInfo;
+-(void)registerLifeCycle:(CDVInvokedUrlCommand *)command;
+-(void)pushNotificationClicked:(CDVInvokedUrlCommand *)command;
+-(void)getDeepLinkURL:(CDVInvokedUrlCommand *)command;
 
 @end
 

package/src/ios/AppICEPlugin.m

@@ -1,4 +1,3 @@
-
 #if defined(__IPHONE_10_0) && __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_10_0
 @import UserNotifications;
 #endif
@@ -31,8 +30,10 @@ NSTimeInterval requestTime;
 static AppICEPlugin *appice;
 
 static NSInteger const kNotificationStackSize = 10;
-@synthesize notificationCallbackId;
-@synthesize notificationStack;
+@synthesize notificationCallbackId; // Manages the callback ID for notifications.
+@synthesize notificationStack;     // Stack to hold pending notifications.
+
+
 
 +(void)load {
     
@@ -157,14 +158,41 @@ static NSInteger const kNotificationStackSize = 10;
 -(void)onHandleNotificationUResponse:(NSDictionary *)userInfo {
     @try {
         NSLog(@"appice - uresponse : %@",userInfo);
-       
-        BOOL appIceServer = [[appICE sharedInstance] isAppICENotification:userInfo];
-        if(appIceServer)
-        {
-             [[appICE sharedInstance] handleClickOnPush:userInfo OpenDeepLink:YES];
-             [self sendCallback:userInfo];
+        NSString *deepLinkurl = @"";
+        [[appICE sharedInstance]handleClickOnPush:userInfo OpenDeepLink:YES];
+        
+        if (userInfo != nil && userInfo.count >0){
+            NSLog(@"appice - getDeepLinkURL : %@", userInfo);
+   
             
+            if ([userInfo valueForKeyPath:@"data.message.cdata.eurl"]) {
+                // Extract the 'eurl' key from 'cdataDictionary'
+                deepLinkurl = [userInfo valueForKeyPath:@"data.message.cdata.eurl"];
+            }
+            else
+            {
+                // If 'user' is still empty, attempt to extract 'eurl' directly from the payload
+                if([userInfo valueForKeyPath:@"data.message.eurl"])
+                {
+                    deepLinkurl = [userInfo valueForKeyPath:@"data.message.eurl"];
+                }
+            }
+          
+            NSLog(@"Value of 'user': %@", deepLinkurl);
+       
+            NSString *js = [NSString stringWithFormat:@"onDeepLink({'deeplink':'%@'});",deepLinkurl];
+            [self.commandDelegate evalJs:js];
         }
+        NSDictionary *pushPayload = [userInfo valueForKeyPath:@"data.message"];
+        NSData *payloadData = [NSJSONSerialization dataWithJSONObject:pushPayload
+                                                                   options:kNilOptions
+                                                                     error:nil];
+        NSString *payloadString = [[NSString alloc] initWithData:payloadData encoding:NSUTF8StringEncoding];
+        NSLog(@"payloadString string: %@", payloadString);
+        
+        NSString *js = [NSString stringWithFormat:@"pushNotificationClicked({'payload':'%@'});",payloadString];
+        [self.commandDelegate evalJs:js];
+
     } @catch (NSException *exception) {
         NSLog(@"appice - uresponse : %@",exception.description);
     } @finally {
@@ -212,7 +240,9 @@ static NSInteger const kNotificationStackSize = 10;
         if (userInfo != NULL&& [userInfo objectForKey:@"data"] != NULL) {
             NSDictionary *data = [userInfo objectForKey:@"data"];
             NSDictionary *message = [data objectForKey:@"message"];
+            NSDictionary *cdata = [message objectForKey:@"cdata"];
             [self sendNotification:userInfo];
+            
             if (message != NULL && [message objectForKey:@"et"] != NULL) {
                 NSString *et = [message objectForKey:@"et"];
                 if (et != NULL
@@ -233,7 +263,7 @@ static NSInteger const kNotificationStackSize = 10;
                     } @catch(NSException *e) {}
                     
                     @try {
-                        NSDictionary *cdata = [message objectForKey:@"cdata"];
+                      
                         NSString *template = [cdata objectForKey:@"template"];
                         if (template != NULL
                             && [template isKindOfClass:[NSString class]]
@@ -413,6 +443,7 @@ static NSInteger const kNotificationStackSize = 10;
     return params;
 }
 
+
 -(void)onHandleOpenURLNotification:(NSURL *)url {
     
 }
@@ -1025,7 +1056,16 @@ static NSInteger const kNotificationStackSize = 10;
         
     }
 }
+/**
+ Sends a notification to the registered callback if available; otherwise, stacks the notification for future processing.
 
+ @param userInfo The dictionary containing notification information.
+ 
+ This method attempts to send a notification to the registered callback if it exists.
+ If the callback is available, it creates a plugin result with the provided notification data, sets the callback to persist, and sends the result to the command delegate using the notification callback ID.
+ If no callback is registered, it stacks the notification in a queue (notificationStack) for later processing.
+ It limits the stack size to a predefined constant (kNotificationStackSize) to manage memory usage.
+*/
 - (void)sendNotification:(NSDictionary *)userInfo {
     @try {
        NSLog(@"Appice send-notifcallback a1 %@",notificationCallbackId);
@@ -1056,7 +1096,12 @@ static NSInteger const kNotificationStackSize = 10;
         
     }
 }
+-(void)registerLifeCycle:(CDVInvokedUrlCommand *)command {
+    CDVPluginResult *pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK];
+    [self.commandDelegate sendPluginResult:pluginResult callbackId:command.callbackId];
+}
 
 @end
 
 
+