cordova-plugin-mserviceinterface-2.0 1.0.73 → 1.0.75

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cordova-plugin-mserviceinterface-2.0",
-  "version": "1.0.73",
+  "version": "1.0.75",
   "description": "This plugin establishes the connection to the native interface and performs the requested task.",
   "main": "index.js",
   "scripts": {
@@ -19,9 +19,10 @@
     "url": "https://github.com/selfservit/cordova-plugin-mserviceinterface-2.0/issues"
   },
   "homepage": "https://github.com/selfservit/cordova-plugin-mserviceinterface-2.0#readme",
-  "engines": [{
+  "engines": [
+    {
       "name": "cordova",
       "version": ">=5.0.0"
     }
   ]
-}
+}

package/plugin.xml

@@ -2,7 +2,7 @@
 <plugin xmlns="http://apache.org/cordova/ns/plugins/1.0"
     xmlns:android="http://schemas.android.com/apk/res/android"
     id="cordova-plugin-mserviceinterface-2.0"
-    version="1.0.73">
+    version="1.0.75">
     <name>mserviceinterface-2.0</name>
     <description>This plugin establishes the connection to the native interface and performs the requested task.</description>
     <author>selfservit@gmail.com</author>
@@ -48,6 +48,7 @@
             <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
             <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
             <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
+            <uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION" />
             <uses-permission android:name="android.permission.READ_PHONE_STATE" />
             <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
         </config-file>
@@ -61,6 +62,11 @@
                     <action android:name="com.example.checkservice" />
                 </intent-filter>
             </receiver>
+            <receiver android:enabled="true" android:exported="true" android:name="com.selfservit.util.GeofenceBroadcastReceiver">
+                <intent-filter>
+                    <action android:name="com.google.android.gms.location.GeofenceEvent" />
+                </intent-filter>
+            </receiver>
             <provider android:name="com.selfservit.util.FileProvider" android:authorities="${applicationId}.provider" android:exported="false" android:grantUriPermissions="true">
                 <meta-data android:name="android.support.FILE_PROVIDER_PATHS" android:resource="@xml/opener_paths" />
             </provider>

package/src/android/GeofenceBroadcastReceiver.java

@@ -0,0 +1,117 @@
+package com.selfservit.util;
+
+import android.app.NotificationChannel;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Build;
+import android.util.Log;
+import android.widget.Toast;
+
+import androidx.core.app.NotificationCompat;
+import androidx.core.app.NotificationManagerCompat;
+
+import com.google.android.gms.location.Geofence;
+import com.google.android.gms.location.GeofencingEvent;
+import com.selfservit.pegdev.MainActivity;
+import com.selfservit.pegdev.R;
+
+import org.json.JSONObject;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.util.UUID;
+
+public class GeofenceBroadcastReceiver extends BroadcastReceiver {
+
+    private static final String TAG = "GeofenceReceiver";
+    private static final String CHANNEL_ID = "geofence_channel";
+
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        GeofencingEvent geofencingEvent = GeofencingEvent.fromIntent(intent);
+
+        if (geofencingEvent.hasError()) {
+            Log.e(TAG, "GeofencingEvent error: " + geofencingEvent.getErrorCode());
+            return;
+        }
+        String enterMessage = intent.getStringExtra("enterMessage");
+        String exitMessage = intent.getStringExtra("exitMessage");
+        int geofenceTransition = geofencingEvent.getGeofenceTransition();
+        if (geofenceTransition == Geofence.GEOFENCE_TRANSITION_ENTER ||
+                geofenceTransition == Geofence.GEOFENCE_TRANSITION_EXIT) {
+            String transitionType = geofenceTransition == Geofence.GEOFENCE_TRANSITION_ENTER ? "enter" : "exit";
+
+            for (Geofence geofence : geofencingEvent.getTriggeringGeofences()) {
+                String geofenceId = geofence.getRequestId();
+                writeEventToJsonFile(context, geofenceId, transitionType);
+                createNotificationChannel(context);
+                String message = (transitionType.equals("enter") ? enterMessage : exitMessage);
+                sendNotification(context, "GeoFence", message);
+//                showToast(context, "Geofence " + transitionType + ": " + geofenceId);
+            }
+        }
+    }
+    private void showToast(Context context, String message) {
+        //Toast.makeText(context.getApplicationContext(), message, Toast.LENGTH_LONG).show();
+    }
+    private void writeEventToJsonFile(Context context, String geofenceId, String eventType) {
+        File notificationsFile, fileDirectory;
+        try {
+            JSONObject jsonObject = new JSONObject();
+            jsonObject.put("eventName", eventType);
+            jsonObject.put("geofenceID", geofenceId);
+            String[] parameters = geofenceId.split("--");
+            fileDirectory = new File(new File(context.getExternalFilesDir(""), "") + "/" + parameters[0] + "/" + parameters[1] + "/" + parameters[2] + "/" + parameters[3] + "/" + "geofence");
+            if (!fileDirectory.exists()) {
+                boolean success = fileDirectory.mkdirs();
+                if (!success) {
+                    System.out.println("Directory not created");
+                }
+            };
+            notificationsFile = new File(fileDirectory, geofenceId + "--" + eventType + ".json");
+            FileWriter fw = new FileWriter(notificationsFile);
+            fw.write(mInterfaceUtil.encrypt(jsonObject.toString()));
+            fw.close();
+            Log.i(TAG, "Event written to file: " + geofenceId + ".json");
+        } catch (Exception e) {
+            Log.e(TAG, "Error writing event to JSON file", e);
+        }
+    }
+
+    private void sendNotification(Context context, String title, String message) {
+        Intent intent = new Intent(context, MainActivity.class);
+        intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_SINGLE_TOP);
+        PendingIntent pendingIntent = PendingIntent.getActivity(context, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_IMMUTABLE);
+        NotificationCompat.Builder notificationBuilder = new NotificationCompat.Builder(context, CHANNEL_ID)
+                .setSmallIcon(R.drawable.ic_notification)
+                .setContentTitle(title)
+                .setContentText(message)
+                .setAutoCancel(true)
+                .setContentIntent(pendingIntent);
+        NotificationManager notificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            NotificationChannel channel = new NotificationChannel(CHANNEL_ID, "Channel human readable title", NotificationManager.IMPORTANCE_DEFAULT);
+            notificationManager.createNotificationChannel(channel);
+        };
+        int notificationId = UUID.randomUUID().hashCode();
+        notificationManager.notify(notificationId, notificationBuilder.build());
+    }
+
+    private void createNotificationChannel(Context context) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            CharSequence name = "Geofence Channel";
+            String description = "Channel for geofence events";
+            int importance = NotificationManager.IMPORTANCE_HIGH;
+            NotificationChannel channel = new NotificationChannel(CHANNEL_ID, name, importance);
+            channel.setDescription(description);
+            NotificationManager notificationManager = context.getSystemService(NotificationManager.class);
+            notificationManager.createNotificationChannel(channel);
+        }
+    }
+}

package/src/android/mInterface.java

@@ -6,6 +6,7 @@ import android.Manifest;
 import android.app.Activity;
 import android.app.ActivityManager;
 import android.app.AlertDialog;
+import android.app.PendingIntent;
 import android.app.ProgressDialog;
 import android.content.ContentResolver;
 import android.content.ContentUris;
@@ -57,6 +58,9 @@ import com.google.android.gms.common.api.GoogleApiClient;
 import com.google.android.gms.common.api.PendingResult;
 import com.google.android.gms.common.api.ResultCallback;
 import com.google.android.gms.common.api.Status;
+import com.google.android.gms.location.Geofence;
+import com.google.android.gms.location.GeofencingClient;
+import com.google.android.gms.location.GeofencingRequest;
 import com.google.android.gms.location.LocationRequest;
 import com.google.android.gms.location.LocationServices;
 import com.google.android.gms.location.LocationSettingsRequest;
@@ -94,6 +98,7 @@ import java.net.URL;
 import java.text.SimpleDateFormat;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.Date;
 import java.util.List;
 import java.util.Stack;
@@ -102,6 +107,8 @@ import java.util.zip.ZipEntry;
 import java.util.zip.ZipInputStream;
 
 import id.zelory.compressor.Compressor;
+import com.selfservit.util.GeofenceBroadcastReceiver;
+
 
 public class mInterface extends CordovaPlugin implements com.google.android.gms.location.LocationListener, GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener, ResultCallback<LocationSettingsResult> {
     private static final String TAG = "mInterface";
@@ -134,6 +141,8 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
     private static final long FASTEST_INTERVAL = 5 * 60 * 1000;
     public static String attachmentDestPath = "";
 
+    private GeofencingClient geofencingClient;
+    private PendingIntent geofencePendingIntent;
     /* START SERVICE WHEN USER COMES FROM INACTIVE TO ACTIVE STATE IF SERVICE NOT RUNNING */
     @Override
     public void onResume(boolean multitasking) {
@@ -158,7 +167,28 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
             if (mInterfaceUtil.packageName.equals("")) {
                 mInterfaceUtil.packageName = cordova.getActivity().getApplicationContext().getPackageName().split("\\.")[2];
             }
-            if (action.equals("AppCleanUp")) {
+            if (action.equals("viewRoute")) {
+                double endLat = Double.parseDouble(args.getJSONObject(0).optString("destinationLat"));
+                double endLng = Double.parseDouble(args.getJSONObject(0).optString("destinationLng"));
+                openMaps(endLat, endLng, callbackContext);
+                return true;
+            } else if (action.equals("addGeoFence")) {
+                geofencingClient = LocationServices.getGeofencingClient(cordova.getActivity().getApplicationContext());
+                double latitude = Double.parseDouble(args.getJSONObject(0).optString("latitude"));
+                double longitude = Double.parseDouble(args.getJSONObject(0).optString("longitude"));
+                float radius = Float.parseFloat(args.getJSONObject(0).optString("radius"));
+                String geofenceId = args.getJSONObject(0).optString("geofenceId");
+                String enterMessage = args.getJSONObject(0).optString("enterNotificationMsg");
+                String exitMessage = args.getJSONObject(0).optString("exitNotificationMsg");
+
+                addGeofence(latitude, longitude, radius, geofenceId, enterMessage, exitMessage, callbackContext, cordova.getActivity().getApplicationContext());
+                callbackContext.success("Success");
+                return true;
+            } else if (action.equals("removeGeofence")) {
+                String geofenceId  = args.getJSONObject(0).optString("geofenceId");
+                removeGeofence(geofenceId, callbackContext);
+                return true;
+            } else if (action.equals("AppCleanUp")) {
                 mInterfaceUtil.appCleanUp(callbackContext, cordova.getActivity().getApplicationContext());
             } else if (action.equals("StartService")) {
                 try {
@@ -966,7 +996,6 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
                     result = new PluginResult(PluginResult.Status.ERROR, "copyAttachmentFile failed, exception is : " + e.getMessage());
                     callback.sendPluginResult(result);
                 }
-
             } else if (action.equals("getMyAccountsData")) {
                 try {
                     String folderPath = mInterfaceUtil.rootDirectory + "/" + args.getJSONObject(0).optString("folderPath");
@@ -987,7 +1016,56 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
         }
         return true;
     }
+    private void addGeofence(double latitude, double longitude, float radius, String geofenceId, String enterMessage, String exitMessage, CallbackContext callbackContext, Context context) {
+        Geofence geofence = new Geofence.Builder()
+                .setRequestId(geofenceId)
+                .setCircularRegion(latitude, longitude, radius)
+                .setExpirationDuration(Geofence.NEVER_EXPIRE)
+                .setTransitionTypes(Geofence.GEOFENCE_TRANSITION_ENTER | Geofence.GEOFENCE_TRANSITION_EXIT)
+                .build();
 
+        GeofencingRequest geofencingRequest = new GeofencingRequest.Builder()
+                .setInitialTrigger(GeofencingRequest.INITIAL_TRIGGER_ENTER)
+                .addGeofence(geofence)
+                .build();
+
+        geofencePendingIntent = getGeofencePendingIntent(enterMessage, exitMessage);
+
+        if (ActivityCompat.checkSelfPermission(context, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
+
+            return;
+        }
+        geofencingClient.addGeofences(geofencingRequest, geofencePendingIntent)
+                .addOnSuccessListener(aVoid -> {
+                    callbackContext.success("Geofence added successfully");
+                    Log.i(TAG, "Geofence added successfully");
+                })
+                .addOnFailureListener(e -> {
+                    callbackContext.error("Failed to add geofence");
+                    Log.e(TAG, "Failed to add geofence", e);
+                });
+    }
+    private void removeGeofence(String geofenceId, CallbackContext callbackContext) {
+        geofencingClient.removeGeofences(Collections.singletonList(geofenceId))
+                .addOnSuccessListener(aVoid -> {
+                    callbackContext.success("Geofence removed successfully");
+                    Log.i(TAG, "Geofence removed successfully");
+                })
+                .addOnFailureListener(e -> {
+                    callbackContext.error("Failed to remove geofence");
+                    Log.e(TAG, "Failed to remove geofence", e);
+                });
+    }
+    private PendingIntent getGeofencePendingIntent( String enterMessage, String exitMessage) {
+        if (geofencePendingIntent != null) {
+            return geofencePendingIntent;
+        }
+        Intent intent = new Intent(cordova.getActivity(), GeofenceBroadcastReceiver.class);
+        intent.putExtra("enterMessage", enterMessage);
+        intent.putExtra("exitMessage", exitMessage);
+        geofencePendingIntent = PendingIntent.getBroadcast(cordova.getActivity(), 0, intent, PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_MUTABLE);
+        return geofencePendingIntent;
+    }
     public static ArrayList<JSONObject> getJsonDataFromFiles(String folderPath) {
         ArrayList<JSONObject> dataArray = new ArrayList<>();
         try {
@@ -2472,4 +2550,11 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
         }
         return "";
     }
+
+    private void openMaps( double endLat, double endLng, CallbackContext callbackContext) {
+        Uri mapUri = Uri.parse("https://www.google.com/maps?daddr=" + endLat + "," + endLng);
+        Intent mapIntent = new Intent(Intent.ACTION_VIEW, mapUri);
+        this.cordova.getActivity().startActivity(mapIntent);
+        callbackContext.success("Google Maps intent launched successfully");
+    }
 }

package/src/ios/mInterface.h

@@ -42,6 +42,7 @@
     UIInterfaceOrientation _lastOrientation;
 }
 @property(strong) NSString* callbackID;
+- (void)viewRoute:(CDVInvokedUrlCommand*)command;
 - (void)GetFCMUtils:(CDVInvokedUrlCommand *)command;
 -(void)GetBase64String:(CDVInvokedUrlCommand *)command;
 - (void)ValidateAppStateInfo;
@@ -109,6 +110,7 @@
 - (void)GetSyncIndicator:(CDVInvokedUrlCommand*)command;
 - (void)CopyAttachmentFile:(CDVInvokedUrlCommand*)command;
 - (void)getMyAccountsData:(CDVInvokedUrlCommand*)command;
+- (void)addGeoFence:(CDVInvokedUrlCommand*)command;
 @property (strong, nonatomic) CLLocationManager * locationManager;
 @property (strong, nonatomic) NSMutableArray * coordinatesArray;
 @property (weak, nonatomic) IBOutlet UIButton *btnGallery;

package/src/ios/mInterface.m

@@ -29,6 +29,166 @@
 @synthesize controller = docController;
 @synthesize callbackID;
 
+- (void)viewRoute:(CDVInvokedUrlCommand*)command {
+    CDVPluginResult* pluginResult = nil;
+    
+    NSDictionary *dict = [[command arguments] objectAtIndex:0];
+    NSString* destinationLat = dict[@"destinationLat"];
+    NSString* destinationLng = dict[@"destinationLng"];
+ 
+    if (destinationLat != nil && destinationLng != nil && [destinationLat length] != 0 && [destinationLng length] != 0) {
+            NSString* urlString = [NSString stringWithFormat:@"https://www.google.com/maps?daddr=%@,%@", destinationLat, destinationLng];
+            NSURL* url = [NSURL URLWithString:urlString];
+     
+            if ([[UIApplication sharedApplication] canOpenURL:url]) {
+                [[UIApplication sharedApplication] openURL:url options:@{} completionHandler:^(BOOL success) {
+                    if (success) {
+                        CDVPluginResult *result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsString:@"Google Maps launched successfully"];
+                        [self.commandDelegate sendPluginResult:result callbackId:command.callbackId];
+                    } else {
+                        CDVPluginResult *result = [CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR messageAsString:@"Failed to launch Google Maps app"];
+                        [self.commandDelegate sendPluginResult:result callbackId:command.callbackId];
+                    }
+                }];
+            } else {
+                pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR messageAsString:@"Google Maps app is not installed"];
+                [self.commandDelegate sendPluginResult:pluginResult callbackId:command.callbackId];
+            }
+        } else {
+            pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR messageAsString:@"Invalid coordinates"];
+            [self.commandDelegate sendPluginResult:pluginResult callbackId:command.callbackId];
+        }
+}
+- (void)addGeoFence:(CDVInvokedUrlCommand *)command {
+    NSDictionary *dict = [[command arguments] objectAtIndex:0];
+    @try {
+        
+        if (!self.locationManager) {
+            self.locationManager = [[CLLocationManager alloc] init];
+            self.locationManager.delegate = self;
+            [self.locationManager requestAlwaysAuthorization];
+        }
+        
+        UNUserNotificationCenter *center = [UNUserNotificationCenter currentNotificationCenter];
+        [center requestAuthorizationWithOptions:(UNAuthorizationOptionAlert + UNAuthorizationOptionSound)
+                              completionHandler:^(BOOL granted, NSError * _Nullable error) {
+            if (!granted) {
+                NSLog(@"Notification permission not granted");
+            }
+        }];
+        
+        double latitude = [dict[@"latitude"] doubleValue];
+        double longitude = [dict[@"longitude"] doubleValue];
+        double radius  = [dict[@"radius"] doubleValue];
+        NSString *identifier = dict[@"geofenceId"];
+        NSString *enterMessage = dict[@"enterNotificationMsg"];
+        NSString *exitMessage = dict[@"exitNotificationMsg"]; 
+        NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
+        [defaults setObject:enterMessage forKey:[NSString stringWithFormat:@"%@_enterMessage", identifier]];
+        [defaults setObject:exitMessage forKey:[NSString stringWithFormat:@"%@_exitMessage", identifier]];
+        [defaults synchronize];
+        
+        CLLocationCoordinate2D centerCoordinate = CLLocationCoordinate2DMake(latitude, longitude);
+        CLCircularRegion *region = [[CLCircularRegion alloc] initWithCenter:centerCoordinate radius:radius identifier:identifier];
+        region.notifyOnEntry = YES;
+        region.notifyOnExit = YES;
+        
+        [self.locationManager startMonitoringForRegion:region];
+        
+        CDVPluginResult *pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsString:@"Geofence added"];
+        [self.commandDelegate sendPluginResult:pluginResult callbackId:command.callbackId];
+    } @catch (NSException *exception) {
+        CDVPluginResult *pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR messageAsString:@"Failed to add geofence"];
+        [self.commandDelegate sendPluginResult:pluginResult callbackId:command.callbackId];
+    }
+}
+
+- (void)locationManager:(CLLocationManager *)manager didEnterRegion:(CLRegion *)region {
+    if ([region isKindOfClass:[CLCircularRegion class]]) {
+        [self handleEventForRegion:(CLCircularRegion *)region eventType:@"enter"];
+    }
+}
+
+- (void)locationManager:(CLLocationManager *)manager didExitRegion:(CLRegion *)region {
+    if ([region isKindOfClass:[CLCircularRegion class]]) {
+        [self handleEventForRegion:(CLCircularRegion *)region eventType:@"exit"];
+    }
+}
+
+- (void)handleEventForRegion:(CLCircularRegion *)region eventType:(NSString *)eventType {
+    NSLog(@"Handling event for region: %@ with event type: %@", region.identifier, eventType);
+    NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
+    NSString *messageKey = [NSString stringWithFormat:@"%@_%@Message", region.identifier, eventType];
+    NSString *customMessage = [defaults stringForKey:messageKey];
+    UNMutableNotificationContent *content = [[UNMutableNotificationContent alloc] init];
+    content.title = @"Geofence Event";
+    content.body = customMessage ? customMessage : [NSString stringWithFormat:@"Geofence %@: %@", eventType, region.identifier];
+    content.sound = [UNNotificationSound defaultSound];
+
+    UNNotificationRequest *request = [UNNotificationRequest requestWithIdentifier:[[NSUUID UUID] UUIDString] content:content trigger:nil];
+    UNUserNotificationCenter *center = [UNUserNotificationCenter currentNotificationCenter];
+    [center addNotificationRequest:request withCompletionHandler:^(NSError * _Nullable error) {
+        if (error != nil) {
+            NSLog(@"Error adding notification request: %@", error);
+        } else {
+            NSLog(@"Notification request added successfully");
+        }
+    }];
+    
+    NSArray *components = [region.identifier componentsSeparatedByString:@"--"];
+    NSString *clientID = components[1];
+    NSString *countryCode = components[2];
+    NSString *userID = components[3];
+    
+    NSString *directory = [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) objectAtIndex:0];
+    NSString *baseFolder = [NSString stringWithFormat:@"%@/%@/%@/%@/%@/geofence", directory, [self GetAppName], clientID, countryCode,userID];
+    
+    NSString *fileName = [NSString stringWithFormat:@"%@--%@.json", region.identifier, eventType];
+
+	[self writeEventToJsonFileWithGeofenceId:region.identifier eventType:eventType folderPath:baseFolder fileName:fileName];
+}
+
+- (void)writeEventToJsonFileWithGeofenceId:(NSString *)geofenceId eventType:(NSString *)eventType folderPath:(NSString *)folderPath fileName:(NSString *)fileName {
+    NSDictionary *event = @{
+        @"eventName": eventType,
+        @"geofenceID": geofenceId
+    };
+
+    NSError *error;
+    NSData *jsonData = [NSJSONSerialization dataWithJSONObject:event options:NSJSONWritingPrettyPrinted error:&error];
+    
+    if (!jsonData) {
+        NSLog(@"Error creating JSON: %@", error.localizedDescription);
+        return;
+    }
+    NSString *filePath = [folderPath stringByAppendingPathComponent:fileName];
+    NSFileManager *fileManager = [NSFileManager defaultManager];
+    if (![fileManager fileExistsAtPath:folderPath]) {
+        [fileManager createDirectoryAtPath:folderPath withIntermediateDirectories:YES attributes:nil error:&error];
+        if (error) {
+            NSLog(@"Error creating directory: %@", error.localizedDescription);
+            return;
+        }
+    }
+    BOOL success = [jsonData writeToFile:filePath atomically:YES];
+    
+    if (success) {
+        NSLog(@"Successfully wrote event to file: %@", filePath);
+    } else {
+        NSLog(@"Failed to write event to file: %@", filePath);
+    }
+       NSData *jsonData1 = [NSData dataWithContentsOfFile:filePath options:NSDataReadingMappedIfSafe error:&error];
+       
+       if (!jsonData1) {
+           NSLog(@"Error reading JSON file: %@", error.localizedDescription);
+           
+       }
+
+       // Convert JSON data to a string
+       NSString *jsonString = [[NSString alloc] initWithData:jsonData1 encoding:NSUTF8StringEncoding];
+        NSLog(@"content: %@", jsonString);
+    
+}
 - (void)GetFCMUtils:(CDVInvokedUrlCommand *)command {
     OSDeviceState *deviceState = [OneSignal getDeviceState];
     NSMutableDictionary * deviceDict = [[NSMutableDictionary alloc] init];