@greatdayhr/capacitor-datetime-setting 1.1.2 → 2.0.0

package/ios/Plugin/DateTimeSettingPlugin.swift

@@ -4,75 +4,213 @@ import Capacitor
 /**
  * DateTimeSettingPlugin
  * 
- * Capacitor plugin to check auto time/timezone settings and open device settings.
+ * Capacitor plugin for comprehensive date/time change detection and management.
+ * Cloned from date_change_checker Flutter plugin.
  * 
- * iOS implementation uses TimeZone.autoupdatingCurrent to determine
- * if the device is set to automatically update its time zone and date/time settings.
+ * iOS implementation uses network time comparison with AutoDateTimeDetector
+ * for reliable detection of automatic date/time settings and changes.
  */
 @objc(DateTimeSettingPlugin)
 public class DateTimeSettingPlugin: CAPPlugin {
     
+    override public func load() {
+        super.load()
+        // Initialize the AutoDateTimeDetector
+        AutoDateTimeDetector.initialize()
+    }
+    
+    deinit {
+        // Clean up network monitoring when plugin is deallocated
+        AutoDateTimeDetector.stopNetworkMonitoring()
+    }
+    
+    // MARK: - Date/Time Change Detection
+    
+    /**
+     * Detects if the device's date/time has been manually changed
+     */
+    @objc func detectDateTimeChange(_ call: CAPPluginCall) {
+        AutoDateTimeDetector.detectDateTimeChange { changeDetected in
+            DispatchQueue.main.async {
+                call.resolve([
+                    "changed": changeDetected
+                ])
+            }
+        }
+    }
+    
+    /**
+     * Comprehensive date and time change detection with detailed analysis
+     */
+    @objc func detectComprehensiveDateTimeChange(_ call: CAPPluginCall) {
+        AutoDateTimeDetector.detectComprehensiveDateTimeChange { result in
+            DispatchQueue.main.async {
+                let changeTypeString: String
+                switch result.changeType {
+                case .noChange:
+                    changeTypeString = "noChange"
+                case .timeOnly:
+                    changeTypeString = "timeOnly"
+                case .dateOnly:
+                    changeTypeString = "dateOnly"
+                case .dateAndTime:
+                    changeTypeString = "dateAndTime"
+                }
+                
+                var resultDict: [String: Any] = [
+                    "changeType": changeTypeString,
+                    "timeDifference": result.timeDifference,
+                    "dateChanged": result.dateChanged,
+                    "timeChanged": result.timeChanged,
+                    "isAutoDateTimeEnabled": result.isAutoDateTimeEnabled,
+                    "currentDate": result.currentDate.timeIntervalSince1970
+                ]
+                
+                if let previousDate = result.previousDate {
+                    resultDict["previousDate"] = previousDate.timeIntervalSince1970
+                }
+                
+                call.resolve(resultDict)
+            }
+        }
+    }
+    
+    /**
+     * Detects specifically if only the date has been changed
+     */
+    @objc func detectDateOnlyChange(_ call: CAPPluginCall) {
+        AutoDateTimeDetector.detectDateOnlyChange { changeDetected in
+            DispatchQueue.main.async {
+                call.resolve([
+                    "changed": changeDetected
+                ])
+            }
+        }
+    }
+    
     /**
-     * Check if automatic time is enabled on the device.
-     * 
-     * iOS implementation uses TimeZone.autoupdatingCurrent to determine
-     * if the device is set to automatically update its time zone and date/time settings.
+     * Comprehensive date and time change detection with automatic notifications
      */
-    @objc func timeIsAuto(_ call: CAPPluginCall) {
-        let isAuto = checkAutoDateTime()
+    @objc func detectAndNotifyDateTimeChanges(_ call: CAPPluginCall) {
+        AutoDateTimeDetector.detectAndNotifyDateTimeChanges { result in
+            DispatchQueue.main.async {
+                let changeTypeString: String
+                switch result.changeType {
+                case .noChange:
+                    changeTypeString = "noChange"
+                case .timeOnly:
+                    changeTypeString = "timeOnly"
+                case .dateOnly:
+                    changeTypeString = "dateOnly"
+                case .dateAndTime:
+                    changeTypeString = "dateAndTime"
+                }
+                
+                var resultDict: [String: Any] = [
+                    "changeType": changeTypeString,
+                    "timeDifference": result.timeDifference,
+                    "dateChanged": result.dateChanged,
+                    "timeChanged": result.timeChanged,
+                    "isAutoDateTimeEnabled": result.isAutoDateTimeEnabled,
+                    "currentDate": result.currentDate.timeIntervalSince1970
+                ]
+                
+                if let previousDate = result.previousDate {
+                    resultDict["previousDate"] = previousDate.timeIntervalSince1970
+                }
+                
+                call.resolve(resultDict)
+            }
+        }
+    }
+    
+    // MARK: - Time Utilities
+    
+    /**
+     * Get the device's current local time
+     */
+    @objc func getLocalTime(_ call: CAPPluginCall) {
+        let currentTime = AutoDateTimeDetector.getCurrentLocalTime()
+        let timestamp = currentTime.timeIntervalSince1970
         call.resolve([
-            "value": isAuto
+            "timestamp": timestamp
         ])
     }
     
     /**
-     * Check if automatic timezone is enabled on the device.
-     * 
-     * iOS implementation uses TimeZone.autoupdatingCurrent to determine
-     * if the device is set to automatically update its time zone.
+     * Fetch accurate UTC time from internet time server
      */
-    @objc func timeZoneIsAuto(_ call: CAPPluginCall) {
-        let isAuto = checkAutoDateTime()
+    @objc func getInternetUTCTime(_ call: CAPPluginCall) {
+        AutoDateTimeDetector.fetchInternetUTCTime { result in
+            DispatchQueue.main.async {
+                switch result {
+                case .success(let utcTime):
+                    let timestamp = utcTime.timeIntervalSince1970
+                    call.resolve([
+                        "timestamp": timestamp
+                    ])
+                case .failure(let error):
+                    call.reject("Failed to fetch internet time", nil, error)
+                }
+            }
+        }
+    }
+    
+    /**
+     * Convert local time to UTC
+     */
+    @objc func convertToLocalTime(_ call: CAPPluginCall) {
+        guard let timestamp = call.getDouble("timestamp") else {
+            call.reject("Missing timestamp parameter")
+            return
+        }
+        
+        let localTime = Date(timeIntervalSince1970: timestamp)
+        let utcTime = AutoDateTimeDetector.convertLocalTimeToUTC(localTime)
+        let utcTimestamp = utcTime.timeIntervalSince1970
+        
         call.resolve([
-            "value": isAuto
+            "timestamp": utcTimestamp
         ])
     }
     
+    // MARK: - Timestamp Management
+    
     /**
-     * Helper method to check if auto date/time is enabled.
-     * 
-     * Compares the autoupdating timezone with the system timezone.
-     * If they are equal, auto date/time is enabled.
+     * Set the stored timestamp for future change detection
      */
-    private func checkAutoDateTime() -> Bool {
-        let autoUpdatingTimeZone = TimeZone.autoupdatingCurrent
-        let systemTimeZone = TimeZone.current
-        return autoUpdatingTimeZone == systemTimeZone
+    @objc func setStoredTimestamp(_ call: CAPPluginCall) {
+        guard let timestamp = call.getDouble("timestamp") else {
+            call.reject("Missing timestamp parameter")
+            return
+        }
+        
+        let date = Date(timeIntervalSince1970: timestamp)
+        AutoDateTimeDetector.setStoredTimestamp(date)
+        call.resolve()
     }
     
     /**
-     * Open the device's Settings app.
-     * 
-     * On iOS, this opens the main Settings app as there's no direct way
-     * to open the Date & Time settings page.
+     * Get the currently stored timestamp
      */
-    @objc func openSetting(_ call: CAPPluginCall) {
-        DispatchQueue.main.async {
-            if let settingsUrl = URL(string: UIApplication.openSettingsURLString) {
-                if UIApplication.shared.canOpenURL(settingsUrl) {
-                    UIApplication.shared.open(settingsUrl, options: [:]) { success in
-                        if success {
-                            call.resolve()
-                        } else {
-                            call.reject("Failed to open settings")
-                        }
-                    }
-                } else {
-                    call.reject("Cannot open settings URL")
-                }
-            } else {
-                call.reject("Invalid settings URL")
-            }
+    @objc func getStoredTimestamp(_ call: CAPPluginCall) {
+        if let storedTime = AutoDateTimeDetector.getStoredTimestamp() {
+            let timestamp = storedTime.timeIntervalSince1970
+            call.resolve([
+                "timestamp": timestamp
+            ])
+        } else {
+            call.resolve([
+                "timestamp": NSNull()
+            ])
         }
     }
+    
+    /**
+     * Reset the detector (clears all stored data and cache)
+     */
+    @objc func resetDetector(_ call: CAPPluginCall) {
+        AutoDateTimeDetector.reset()
+        call.resolve()
+    }
 }

package/ios/Plugin/NotificationManager.swift

@@ -0,0 +1,259 @@
+import Foundation
+import UserNotifications
+import UIKit
+
+/**
+ * NotificationManager handles displaying notifications for date/time change detection
+ * Supports iOS 10+ with UserNotifications framework and fallback for older versions
+ */
+class NotificationManager: NSObject {
+    
+    static let shared = NotificationManager()
+    
+    private override init() {
+        super.init()
+    }
+    
+    /**
+     * Requests notification permission from the user
+     * Should be called during app initialization
+     */
+    func requestNotificationPermission(completion: @escaping (Bool) -> Void) {
+        if #available(iOS 10.0, *) {
+            let center = UNUserNotificationCenter.current()
+            center.requestAuthorization(options: [.alert, .sound, .badge]) { granted, error in
+                DispatchQueue.main.async {
+                    if let error = error {
+                        print("Notification permission error: \(error.localizedDescription)")
+                        completion(false)
+                    } else {
+                        completion(granted)
+                    }
+                }
+            }
+        } else {
+            // Fallback for iOS 9 and earlier
+            let settings = UIUserNotificationSettings(types: [.alert, .sound, .badge], categories: nil)
+            UIApplication.shared.registerUserNotificationSettings(settings)
+            completion(true)
+        }
+    }
+    
+    /**
+     * Displays a notification when automatic date/time is disabled
+     */
+    func showAutoDateTimeDisabledNotification() {
+        let title = "Automatic Date & Time Disabled"
+        let body = "Your device's automatic date and time setting appears to be disabled. Please enable it in Settings > General > Date & Time for accurate time synchronization."
+        
+        showNotification(title: title, body: body, identifier: "auto_datetime_disabled")
+    }
+    
+    /**
+     * Displays a notification when date-only change is detected
+     */
+    func showDateOnlyChangeNotification() {
+        let title = "Date Change Detected"
+        let body = "The date has been manually changed while the time remained unchanged. This may indicate that automatic date and time is disabled."
+        
+        showNotification(title: title, body: body, identifier: "date_only_change")
+    }
+    
+    /**
+     * Displays a notification when time-only change is detected
+     */
+    func showTimeOnlyChangeNotification() {
+        let title = "Time Change Detected"
+        let body = "The time has been manually changed. This may indicate that automatic date and time is disabled."
+        
+        showNotification(title: title, body: body, identifier: "time_only_change")
+    }
+    
+    /**
+     * Displays a notification when both date and time changes are detected
+     */
+    func showDateTimeChangeNotification() {
+        let title = "Date & Time Change Detected"
+        let body = "Both date and time have been manually changed. Please ensure automatic date and time is enabled for accurate synchronization."
+        
+        showNotification(title: title, body: body, identifier: "datetime_change")
+    }
+    
+    /**
+     * Displays a custom notification with specified parameters
+     */
+    func showCustomNotification(title: String, body: String, identifier: String? = nil) {
+        let notificationId = identifier ?? "custom_notification_\(Date().timeIntervalSince1970)"
+        showNotification(title: title, body: body, identifier: notificationId)
+    }
+    
+    /**
+     * Core notification display method that handles iOS version compatibility
+     */
+    private func showNotification(title: String, body: String, identifier: String) {
+        if #available(iOS 10.0, *) {
+            showModernNotification(title: title, body: body, identifier: identifier)
+        } else {
+            showLegacyNotification(title: title, body: body)
+        }
+    }
+    
+    /**
+     * Shows notification using UserNotifications framework (iOS 10+)
+     */
+    @available(iOS 10.0, *)
+    private func showModernNotification(title: String, body: String, identifier: String) {
+        let center = UNUserNotificationCenter.current()
+        
+        // Check if notifications are authorized
+        center.getNotificationSettings { settings in
+            guard settings.authorizationStatus == .authorized else {
+                print("Notifications not authorized")
+                return
+            }
+            
+            // Create notification content
+            let content = UNMutableNotificationContent()
+            content.title = title
+            content.body = body
+            content.sound = .default
+            content.badge = NSNumber(value: UIApplication.shared.applicationIconBadgeNumber + 1)
+            
+            // Create trigger (immediate delivery)
+            let trigger = UNTimeIntervalNotificationTrigger(timeInterval: 0.1, repeats: false)
+            
+            // Create request
+            let request = UNNotificationRequest(identifier: identifier, content: content, trigger: trigger)
+            
+            // Schedule notification
+            center.add(request) { error in
+                if let error = error {
+                    print("Failed to schedule notification: \(error.localizedDescription)")
+                } else {
+                    print("Notification scheduled successfully: \(title)")
+                }
+            }
+        }
+    }
+    
+    /**
+     * Shows notification using legacy UILocalNotification (iOS 9 and earlier)
+     */
+    private func showLegacyNotification(title: String, body: String) {
+        DispatchQueue.main.async {
+            if #available(iOS 8.0, *) {
+                let notification = UILocalNotification()
+                notification.alertTitle = title
+                notification.alertBody = body
+                notification.soundName = UILocalNotificationDefaultSoundName
+                notification.applicationIconBadgeNumber = UIApplication.shared.applicationIconBadgeNumber + 1
+                notification.fireDate = Date(timeIntervalSinceNow: 0.1)
+                
+                UIApplication.shared.scheduleLocalNotification(notification)
+                print("Legacy notification scheduled: \(title)")
+            } else {
+                // For iOS 7 and earlier, show an alert
+                let alert = UIAlertView(title: title, message: body, delegate: nil, cancelButtonTitle: "OK")
+                alert.show()
+                print("Alert shown for iOS 7: \(title)")
+            }
+        }
+    }
+    
+    /**
+     * Cancels all pending notifications
+     */
+    func cancelAllNotifications() {
+        if #available(iOS 10.0, *) {
+            UNUserNotificationCenter.current().removeAllPendingNotificationRequests()
+            UNUserNotificationCenter.current().removeAllDeliveredNotifications()
+        } else {
+            UIApplication.shared.cancelAllLocalNotifications()
+        }
+        
+        // Reset badge count
+        DispatchQueue.main.async {
+            UIApplication.shared.applicationIconBadgeNumber = 0
+        }
+    }
+    
+    /**
+     * Cancels notifications with specific identifier
+     */
+    func cancelNotification(withIdentifier identifier: String) {
+        if #available(iOS 10.0, *) {
+            UNUserNotificationCenter.current().removePendingNotificationRequests(withIdentifiers: [identifier])
+            UNUserNotificationCenter.current().removeDeliveredNotifications(withIdentifiers: [identifier])
+        } else {
+            // For legacy notifications, we need to cancel all and reschedule others
+            // This is a limitation of the older notification system
+            let scheduledNotifications = UIApplication.shared.scheduledLocalNotifications ?? []
+            for notification in scheduledNotifications {
+                if notification.userInfo?["identifier"] as? String == identifier {
+                    UIApplication.shared.cancelLocalNotification(notification)
+                }
+            }
+        }
+    }
+    
+    /**
+     * Checks current notification authorization status
+     */
+    func checkNotificationPermission(completion: @escaping (Bool) -> Void) {
+        if #available(iOS 10.0, *) {
+            UNUserNotificationCenter.current().getNotificationSettings { settings in
+                DispatchQueue.main.async {
+                    completion(settings.authorizationStatus == .authorized)
+                }
+            }
+        } else {
+            // For older iOS versions, check if notification types are enabled
+            let settings = UIApplication.shared.currentUserNotificationSettings
+            completion(settings?.types != [])
+        }
+    }
+}
+
+// MARK: - UNUserNotificationCenterDelegate
+
+@available(iOS 10.0, *)
+extension NotificationManager: UNUserNotificationCenterDelegate {
+    
+    /**
+     * Handle notification when app is in foreground
+     */
+    func userNotificationCenter(_ center: UNUserNotificationCenter,
+                              willPresent notification: UNNotification,
+                              withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
+        // Show notification even when app is in foreground
+        if #available(iOS 14.0, *) {
+            completionHandler([.banner, .sound, .badge])
+        } else {
+            completionHandler([.alert, .sound, .badge])
+        }
+    }
+    
+    /**
+     * Handle notification tap
+     */
+    func userNotificationCenter(_ center: UNUserNotificationCenter,
+                              didReceive response: UNNotificationResponse,
+                              withCompletionHandler completionHandler: @escaping () -> Void) {
+        let identifier = response.notification.request.identifier
+        print("Notification tapped: \(identifier)")
+        
+        // Handle specific notification actions here if needed
+        switch identifier {
+        case "auto_datetime_disabled":
+            // Could open settings or show more information
+            break
+        case "date_only_change", "time_only_change", "datetime_change":
+            // Could show detailed change information
+            break
+        default:
+            break
+        }
+        
+        completionHandler()
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@greatdayhr/capacitor-datetime-setting",
-  "version": "1.1.2",
-  "description": "Capacitor plugin to get information about auto time and auto timezone, open setting if not set to auto",
+  "version": "2.0.0",
+  "description": "Capacitor plugin for comprehensive iOS date/time change detection. Cloned from date_change_checker Flutter plugin.",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",
   "types": "dist/esm/index.d.ts",
@@ -27,9 +27,12 @@
     "plugin",
     "native",
     "datetime",
-    "timezone",
-    "auto-time",
-    "settings"
+    "time-detection",
+    "date-change",
+    "ios",
+    "date-change-checker",
+    "automatic-time",
+    "network-time"
   ],
   "scripts": {
     "verify": "npm run verify:ios && npm run verify:android && npm run verify:web",