cordova-plugin-appice 2.0.10 → 2.1.2

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 {

package/src/ios/AppICEPlugin.h

@@ -89,5 +89,8 @@ static NSString* const AIHandleActionNotification = @"AIHandleActionNotification
 -(void)pushNotificationClicked:(CDVInvokedUrlCommand *)command;
 -(void)getDeepLinkURL:(CDVInvokedUrlCommand *)command;
 
+//new empty function
+-(void)isDeviceReady:(CDVInvokedUrlCommand *)command;
+
 @end
 

package/src/ios/AppICEPlugin.m

@@ -158,7 +158,23 @@ static NSInteger const kNotificationStackSize = 10;
 -(void)onHandleNotificationUResponse:(NSDictionary *)userInfo {
     @try {
         NSLog(@"appice - uresponse : %@",userInfo);
-     [self sendCallback:userInfo];
+       
+       
+        
+        if (userInfo != nil && userInfo.count >0){
+          
+            [[appICE sharedInstance]handleClickOnPush:userInfo OpenDeepLink:YES];
+            
+            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);
@@ -1068,93 +1084,12 @@ static NSInteger const kNotificationStackSize = 10;
     [self.commandDelegate sendPluginResult:pluginResult callbackId:command.callbackId];
 }
 
-- (void)pushNotificationClicked:(CDVInvokedUrlCommand *)command {
-    @try {
-        // Attempt to handle the push notification click
-        NSObject *payloadObj = [command argumentAtIndex:0];
-        NSDictionary *pushPayloadDict = [payloadObj valueForKey:@"pushPayload"];
-        
-
-        
-        // Check if a non-empty payload is received
-        if (pushPayloadDict != nil && pushPayloadDict.count >0) {
-            NSLog(@"appice - pushNotificationClicked : %@", pushPayloadDict);
-           
-            // Call a method from the appICE SDK with the push payload dictionary
-            [[appICE sharedInstance] handleClickOnPush:pushPayloadDict OpenDeepLink:YES];
-            
-            // Send a success callback to the Cordova JavaScript side
-            CDVPluginResult *pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK];
-            [self.commandDelegate sendPluginResult:pluginResult callbackId:command.callbackId];
-        }
-    } @catch (NSException *error) {
-        // Handle any exceptions that occur during the execution
-        NSLog(@"appice - pushNotificationClicked exception: %@", error.description);
-        
-        // Send an error callback to the Cordova JavaScript side
-        CDVPluginResult *pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR];
-        [self.commandDelegate sendPluginResult:pluginResult callbackId:command.callbackId];
-    }
-}
-
-- (void)getDeepLinkURL:(CDVInvokedUrlCommand *)command {
-    @try {
-        // Initialize user as an empty string
-        NSString *user = @"";
-
-        // Attempt to extract the 'pushPayload' key from the command's arguments
-        NSObject *payloadObj = [command argumentAtIndex:0];
-        NSDictionary *pushPayloadDict = [payloadObj valueForKey:@"pushPayload"];
-        
-      
-        
-        // Check if a non-empty payload is received
-        if (pushPayloadDict != nil && pushPayloadDict.count >0){
-            NSLog(@"appice - getDeepLinkURL : %@", pushPayloadDict);
-   
-            
-            if ([pushPayloadDict valueForKeyPath:@"data.message.cdata.eurl"]) {
-                // Extract the 'eurl' key from 'cdataDictionary'
-                user = [pushPayloadDict valueForKeyPath:@"data.message.cdata.eurl"];
-            }
-            else
-            {
-                // If 'user' is still empty, attempt to extract 'eurl' directly from the payload
-                if([pushPayloadDict valueForKeyPath:@"data.message.eurl"])
-                {
-                    user = [pushPayloadDict valueForKeyPath:@"data.message.eurl"];
-                }
-            }
-          
-            NSLog(@"Value of 'user': %@", user);
-            
-            // Send the 'user' value as a success callback to the Cordova JavaScript side
-            CDVPluginResult *pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsString:user];
-            [self.commandDelegate sendPluginResult:pluginResult callbackId:command.callbackId];
-        }
-    } @catch (NSException *error) {
-        // Handle any exceptions that occur during the execution
-        NSLog(@"appice - getDeepLinkURL exception : %@", error.description);
-        
-        // Send an error callback to the Cordova JavaScript side
-        CDVPluginResult *pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR];
-        [self.commandDelegate sendPluginResult:pluginResult callbackId:command.callbackId];
-    }
+// new empty function
+-(void)isDeviceReady:(CDVInvokedUrlCommand *)command {
+    CDVPluginResult *pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK];
+    [self.commandDelegate sendPluginResult:pluginResult callbackId:command.callbackId];
 }
 
--(BOOL)isNullOrEmptyString:(NSString*)validateString{
-    if(![validateString isKindOfClass:[NSString class]])
-    {
-        return true;
-    }
-    if(validateString && ![validateString isEqualToString:@""])
-    {
-        return false;
-    }
-    else{
-        return true;
-    }
-}
 @end