@hot-updater/react-native 0.16.7-0 → 0.18.0

package/ios/HotUpdater/Internal/HotUpdater-Bridging-Header.h

@@ -0,0 +1,8 @@
+#ifndef HotUpdater_Bridging_Header_h
+#define HotUpdater_Bridging_Header_h
+
+#import "React/RCTBridgeModule.h"
+#import "React/RCTEventEmitter.h"
+#import "React/RCTUtils.h" // Needed for RCTPromiseResolveBlock/RejectBlock in Swift
+#import <SSZipArchive/SSZipArchive.h>
+#endif /* HotUpdater_Bridging_Header_h */

package/ios/HotUpdater/Internal/HotUpdater.mm

@@ -0,0 +1,241 @@
+#import "HotUpdater.h"
+#import <React/RCTReloadCommand.h>
+#import <React/RCTLog.h>
+
+
+#if __has_include("HotUpdater/HotUpdater-Swift.h")
+#import "HotUpdater/HotUpdater-Swift.h"
+#else
+#import "HotUpdater-Swift.h"
+#endif
+
+
+// Define Notification names used for observing Swift Core
+NSNotificationName const HotUpdaterDownloadProgressUpdateNotification = @"HotUpdaterDownloadProgressUpdate";
+NSNotificationName const HotUpdaterDownloadDidFinishNotification = @"HotUpdaterDownloadDidFinish";
+
+// Create static HotUpdaterImpl instance
+static HotUpdaterImpl *_hotUpdaterImpl = [HotUpdaterFactory.shared create];
+
+@implementation HotUpdater {
+    bool hasListeners;
+    // Keep track of tasks ONLY for removing observers when this ObjC instance is invalidated
+    NSMutableSet<NSURLSessionTask *> *observedTasks; // Changed to NSURLSessionTask for broader compatibility if needed
+}
+
++ (BOOL)requiresMainQueueSetup {
+    return YES;
+}
+
+- (instancetype)init {
+    self = [super init];
+    if (self) {
+        observedTasks = [NSMutableSet set];
+        
+        // Start observing notifications needed for cleanup/events
+        // Using self as observer
+        [[NSNotificationCenter defaultCenter] addObserver:self
+                                                 selector:@selector(handleDownloadProgress:)
+                                                     name:HotUpdaterDownloadProgressUpdateNotification
+                                                   object:nil]; // Observe all tasks from Impl
+        [[NSNotificationCenter defaultCenter] addObserver:self
+                                                 selector:@selector(handleDownloadCompletion:)
+                                                     name:HotUpdaterDownloadDidFinishNotification
+                                                   object:nil]; // Observe all tasks from Impl
+
+        _lastUpdateTime = 0;
+    }
+    return self;
+}
+
+// Clean up observers when module is invalidated or deallocated
+- (void)invalidate {
+    RCTLogInfo(@"[HotUpdater.mm] invalidate called, removing observers.");
+    [[NSNotificationCenter defaultCenter] removeObserver:self];
+    // Swift side should handle KVO observer removal for its tasks
+    [super invalidate];
+}
+
+- (void)dealloc {
+    RCTLogInfo(@"[HotUpdater.mm] dealloc called, removing observers.");
+    [[NSNotificationCenter defaultCenter] removeObserver:self];
+}
+
+
+RCT_EXPORT_MODULE();
+
+#pragma mark - React Native Constants (Keep getMinBundleId, delegate others)
+
+// Keep local implementation if complex or uses macros
+- (NSString *)getMinBundleId {
+     static NSString *uuid = nil;
+     static dispatch_once_t onceToken;
+     dispatch_once(&onceToken, ^{
+     #if DEBUG
+         uuid = @"00000000-0000-0000-0000-000000000000";
+     #else
+         NSString *compileDateStr = [NSString stringWithFormat:@"%s %s", __DATE__, __TIME__];
+         NSDateFormatter *formatter = [[NSDateFormatter alloc] init];
+         [formatter setLocale:[[NSLocale alloc] initWithLocaleIdentifier:@"en_US_POSIX"]];
+         [formatter setDateFormat:@"MMM d yyyy HH:mm:ss"]; // Correct format for __DATE__ __TIME__
+         NSDate *buildDate = [formatter dateFromString:compileDateStr];
+         if (!buildDate) {
+             RCTLogWarn(@"[HotUpdater.mm] Could not parse build date: %@", compileDateStr);
+             uuid = @"00000000-0000-0000-0000-000000000000";
+             return;
+         }
+         uint64_t buildTimestampMs = (uint64_t)([buildDate timeIntervalSince1970] * 1000.0);
+         unsigned char bytes[16];
+         bytes[0] = (buildTimestampMs >> 40) & 0xFF; // ... rest of UUID logic ...
+         bytes[1] = (buildTimestampMs >> 32) & 0xFF;
+         bytes[2] = (buildTimestampMs >> 24) & 0xFF;
+         bytes[3] = (buildTimestampMs >> 16) & 0xFF;
+         bytes[4] = (buildTimestampMs >> 8) & 0xFF;
+         bytes[5] = buildTimestampMs & 0xFF;
+         bytes[6] = 0x70; bytes[7] = 0x00; bytes[8] = 0x80; bytes[9] = 0x00;
+         bytes[10] = 0x00; bytes[11] = 0x00; bytes[12] = 0x00; bytes[13] = 0x00; bytes[14] = 0x00; bytes[15] = 0x00;
+         uuid = [NSString stringWithFormat:
+                 @"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
+                 bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7],
+                 bytes[8], bytes[9], bytes[10], bytes[11], bytes[12], bytes[13], bytes[14], bytes[15]];
+     #endif
+     });
+     return uuid;
+}
+
+
+- (NSDictionary *)constantsToExport {
+    return @{
+        @"MIN_BUNDLE_ID": [self getMinBundleId] ?: [NSNull null], // Local
+        @"APP_VERSION": [HotUpdaterImpl appVersion] ?: [NSNull null], // Swift
+        @"CHANNEL": [_hotUpdaterImpl getChannel] ?: [NSNull null]        // Swift
+    };
+}
+
+- (NSDictionary *)getConstants {
+ return [self constantsToExport];
+}
+
+
+// Get bundleURL using static instance
++ (NSURL *)bundleURL {
+    return [_hotUpdaterImpl bundleURL];
+}
+
+
+#pragma mark - Progress Updates & Event Emitting (Keep in ObjC Wrapper)
+
+- (void)handleDownloadProgress:(NSNotification *)notification {
+     if (!hasListeners) return;
+
+     NSDictionary *userInfo = notification.userInfo;
+     NSNumber *progressNum = userInfo[@"progress"];
+
+     if (progressNum) {
+         double progress = [progressNum doubleValue];
+         NSTimeInterval currentTime = [[NSDate date] timeIntervalSince1970] * 1000;
+         // Throttle events
+         if ((currentTime - self.lastUpdateTime) >= 100 || progress >= 1.0) {
+             self.lastUpdateTime = currentTime;
+             // RCTLogInfo(@"[HotUpdater.mm] Sending progress event: %.2f", progress); // Reduce log noise
+             [self sendEventWithName:@"onProgress" body:@{@"progress": @(progress)}];
+         }
+     }
+ }
+
+- (void)handleDownloadCompletion:(NSNotification *)notification {
+      NSURLSessionTask *task = notification.object; // Task that finished
+      RCTLogInfo(@"[HotUpdater.mm] Received download completion notification for task: %@", task.originalRequest.URL);
+      // Swift side handles KVO observer removal internally now when task finishes.
+      // No specific cleanup needed here based on this notification anymore.
+}
+
+
+#pragma mark - React Native Events (Keep as is)
+
+- (NSArray<NSString *> *)supportedEvents {
+    return @[@"onProgress"];
+}
+
+- (void)startObserving {
+    hasListeners = YES;
+    RCTLogInfo(@"[HotUpdater.mm] Start observing JS events.");
+    // Observers are added in init now
+}
+
+- (void)stopObserving {
+    hasListeners = NO;
+    RCTLogInfo(@"[HotUpdater.mm] Stop observing JS events.");
+    // Observers are removed in invalidate/dealloc
+}
+
+- (void)sendEventWithName:(NSString * _Nonnull)name body:(id)body { // Changed body type to id
+    if (hasListeners) {
+        [super sendEventWithName:name body:body];
+    }
+}
+
+
+#pragma mark - React Native Exports (Slimmed Down)
+
+// Keep reload logic here as it interacts with RN Bridge
+RCT_EXPORT_METHOD(reload) {
+    RCTLogInfo(@"[HotUpdater.mm] HotUpdater requested a reload");
+    dispatch_async(dispatch_get_main_queue(), ^{
+        // Get bundleURL using static instance
+        NSURL *bundleURL = [_hotUpdaterImpl bundleURL];
+        RCTLogInfo(@"[HotUpdater.mm] Reloading with bundle URL: %@", bundleURL);
+        if (bundleURL && super.bridge) {
+            @try {
+                 // This method of setting bundleURL might be outdated depending on RN version.
+                 // Consider alternatives if this doesn't work reliably.
+                 [super.bridge setValue:bundleURL forKey:@"bundleURL"];
+            } @catch (NSException *exception) {
+                 RCTLogError(@"[HotUpdater.mm] Failed to set bundleURL on bridge: %@", exception);
+            }
+        } else if (!super.bridge) {
+             RCTLogWarn(@"[HotUpdater.mm] Bridge is nil, cannot set bundleURL for reload.");
+        }
+        RCTTriggerReloadCommandListeners(@"HotUpdater requested a reload");
+    });
+}
+
+#ifdef RCT_NEW_ARCH_ENABLED
+
+RCT_EXPORT_METHOD(updateBundle:(JS::NativeHotUpdater::UpdateBundleParams &)params
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+    NSLog(@"[HotUpdater.mm] updateBundle called.");
+    NSMutableDictionary *paramDict = [NSMutableDictionary dictionary];
+    if (params.bundleId()) {
+        paramDict[@"bundleId"] = params.bundleId();
+    }
+    if (params.fileUrl()) {
+        paramDict[@"fileUrl"] = params.fileUrl();
+    }
+    
+    [_hotUpdaterImpl updateBundle:paramDict resolver:resolve rejecter:reject];
+}
+#else
+RCT_EXPORT_METHOD(updateBundle:(NSDictionary *)params
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+    NSLog(@"[HotUpdater.mm] updateBundle called. params: %@", params);
+    [_hotUpdaterImpl updateBundle:params resolver:resolve rejecter:reject];
+}
+#endif
+
+
+
+
+#pragma mark - Turbo Module Support (Keep as is)
+
+
+#ifdef RCT_NEW_ARCH_ENABLED
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const facebook::react::ObjCTurboModule::InitParams &)params {
+    return std::make_shared<facebook::react::NativeHotUpdaterSpecJSI>(params);
+}
+#endif
+
+
+@end

package/ios/HotUpdater/Internal/HotUpdaterFactory.swift

@@ -0,0 +1,24 @@
+import Foundation
+
+@objcMembers
+public class HotUpdaterFactory: NSObject {
+    public static let shared = HotUpdaterFactory()
+    
+    private override init() {}
+    
+    public func create() -> HotUpdaterImpl {
+        let fileSystem = FileManagerService()
+        let preferences = VersionedPreferencesService()
+        let downloadService = URLSessionDownloadService()
+        let unzipService = SSZipArchiveUnzipService()
+        
+        let bundleStorage = BundleFileStorageService(
+            fileSystem: fileSystem,
+            downloadService: downloadService,
+            unzipService: unzipService,
+            preferences: preferences
+        )
+        
+        return HotUpdaterImpl(bundleStorage: bundleStorage, preferences: preferences)
+    }
+}

package/ios/HotUpdater/Internal/HotUpdaterImpl.swift

@@ -0,0 +1,143 @@
+import Foundation
+import React
+
+@objcMembers public class HotUpdaterImpl: NSObject {
+    private let bundleStorage: BundleStorageService
+    private let preferences: PreferencesService
+    
+    // MARK: - Initialization
+    
+    /**
+     * Convenience initializer that creates and configures all dependencies.
+     */
+    public convenience override init() {
+        let fileSystem = FileManagerService()
+        let preferences = VersionedPreferencesService()
+        let downloadService = URLSessionDownloadService()
+        let unzipService = SSZipArchiveUnzipService()
+        
+        let bundleStorage = BundleFileStorageService(
+            fileSystem: fileSystem,
+            downloadService: downloadService,
+            unzipService: unzipService,
+            preferences: preferences
+        )
+        
+        self.init(bundleStorage: bundleStorage, preferences: preferences)
+    }
+    
+    /**
+     * Primary initializer with dependency injection.
+     * @param bundleStorage Service for bundle storage operations
+     * @param preferences Service for preference storage
+     */
+    internal init(bundleStorage: BundleStorageService, preferences: PreferencesService) {
+        self.bundleStorage = bundleStorage
+        self.preferences = preferences
+        super.init()
+        
+        // Configure preferences with app version
+        if let appVersion = HotUpdaterImpl.appVersion {
+            (preferences as? VersionedPreferencesService)?.configure(appVersion: appVersion)
+        }
+    }
+    
+    // MARK: - Static Properties
+    
+    /**
+     * Returns the app version from main bundle info.
+     */
+    public static var appVersion: String? {
+        return Bundle.main.object(forInfoDictionaryKey: "CFBundleShortVersionString") as? String
+    }
+    
+    // MARK: - Channel Management
+    
+    /**
+     * Gets the current update channel.
+     * @return The channel name or nil if not set
+     */
+    private static let DEFAULT_CHANNEL = "production"
+    
+    public func getChannel() -> String {
+        return Bundle.main.object(forInfoDictionaryKey: "HOT_UPDATER_CHANNEL") as? String ?? Self.DEFAULT_CHANNEL
+    }
+
+    
+    // MARK: - Bundle URL Management
+    
+    /**
+     * Gets the URL to the bundle file.
+     * @return URL to the bundle or nil
+     */
+    public func bundleURL() -> URL? {
+        return bundleStorage.getBundleURL()
+    }
+    
+    // MARK: - Bundle Update
+    
+    /**
+     * Updates the bundle from JavaScript bridge.
+     * This method acts as the primary error boundary for all bundle operations.
+     * @param params Dictionary with bundleId and fileUrl parameters
+     * @param resolve Promise resolve callback
+     * @param reject Promise reject callback
+     */
+    public func updateBundle(_ params: NSDictionary?,
+                                         resolver resolve: @escaping RCTPromiseResolveBlock,
+                                         rejecter reject: @escaping RCTPromiseRejectBlock) {
+        
+        do {
+            // Validate parameters (this runs on calling thread - typically JS thread)
+            guard let data = params else {
+                throw NSError(domain: "HotUpdaterError", code: 101, 
+                             userInfo: [NSLocalizedDescriptionKey: "Missing params dictionary"])
+            }
+            
+            guard let bundleId = data["bundleId"] as? String, !bundleId.isEmpty else {
+                throw NSError(domain: "HotUpdaterError", code: 102, 
+                             userInfo: [NSLocalizedDescriptionKey: "Missing or empty 'bundleId'"])
+            }
+            
+            let fileUrlString = data["fileUrl"] as? String ?? ""
+            
+            var fileUrl: URL? = nil
+            if !fileUrlString.isEmpty {
+                guard let url = URL(string: fileUrlString) else {
+                    throw NSError(domain: "HotUpdaterError", code: 103, 
+                                 userInfo: [NSLocalizedDescriptionKey: "Invalid 'fileUrl' provided: \(fileUrlString)"])
+                }
+                fileUrl = url
+            }
+            
+            NSLog("[HotUpdaterImpl] updateBundle called with bundleId: \(bundleId), fileUrl: \(fileUrl?.absoluteString ?? "nil")")
+            
+            // Heavy work is delegated to bundle storage service with safe error handling
+            bundleStorage.updateBundle(bundleId: bundleId, fileUrl: fileUrl) { [weak self] result in
+                guard self != nil else {
+                    let error = NSError(domain: "HotUpdaterError", code: 998, 
+                                       userInfo: [NSLocalizedDescriptionKey: "Self deallocated during update"])
+                    DispatchQueue.main.async {
+                        reject("UPDATE_ERROR", error.localizedDescription, error)
+                    }
+                    return
+                }
+                // Return results on main thread for React Native bridge
+                DispatchQueue.main.async {
+                    switch result {
+                    case .success:
+                        NSLog("[HotUpdaterImpl] Update successful for \(bundleId). Resolving promise.")
+                        resolve(true)
+                    case .failure(let error):
+                        NSLog("[HotUpdaterImpl] Update failed for \(bundleId): \(error.localizedDescription). Rejecting promise.")
+                        reject("UPDATE_ERROR", error.localizedDescription, error)
+                    }
+                }
+            }
+        } catch let error {
+            // Main error boundary - catch and convert all errors to JS rejection
+            NSLog("[HotUpdaterImpl] Error in updateBundleFromJS: \(error.localizedDescription)")
+            reject("UPDATE_ERROR", error.localizedDescription, error)
+        }
+    }
+}

package/ios/HotUpdater/Internal/NotificationExtension.swift

@@ -0,0 +1,6 @@
+import Foundation
+
+extension Notification.Name {
+    static let downloadProgressUpdate = Notification.Name("HotUpdaterDownloadProgressUpdate")
+    static let downloadDidFinish = Notification.Name("HotUpdaterDownloadDidFinish")
+}

package/ios/HotUpdater/Internal/SSZipArchiveUnzipService.swift

@@ -0,0 +1,25 @@
+import Foundation
+import SSZipArchive
+
+protocol UnzipService {
+    /**
+     * Unzips a file to a destination directory.
+     * @param file Path to the zip file
+     * @param destination Directory to extract to
+     * @throws Error if unzipping fails
+     */
+    func unzip(file: String, to destination: String) throws
+}
+
+class SSZipArchiveUnzipService: UnzipService {
+    func unzip(file: String, to destination: String) throws {
+        var error: Error?
+        
+        do {
+            try SSZipArchive.unzipFile(atPath: file, toDestination: destination, overwrite: true, password: nil)
+        } catch let caughtError {
+            error = caughtError
+            throw error!
+        }
+    }
+}

package/ios/HotUpdater/Internal/URLSessionDownloadService.swift

@@ -0,0 +1,101 @@
+import Foundation
+
+protocol DownloadService {
+    /**
+     * Downloads a file from a URL.
+     * @param url The URL to download from
+     * @param destination The local path to save to
+     * @param progressHandler Callback for download progress updates
+     * @param completion Callback with result of the download
+     * @return The download task (optional)
+     */
+    func downloadFile(from url: URL, to destination: String, progressHandler: @escaping (Double) -> Void, completion: @escaping (Result<URL, Error>) -> Void) -> URLSessionDownloadTask?
+}
+
+
+class URLSessionDownloadService: NSObject, DownloadService {
+    private var session: URLSession!
+    private var progressHandlers: [URLSessionTask: (Double) -> Void] = [:]
+    private var completionHandlers: [URLSessionTask: (Result<URL, Error>) -> Void] = [:]
+    private var destinations: [URLSessionTask: String] = [:]
+    
+    override init() {
+        super.init()
+        let configuration = URLSessionConfiguration.default
+        session = URLSession(configuration: configuration, delegate: self, delegateQueue: nil)
+    }
+    
+    func downloadFile(from url: URL, to destination: String, progressHandler: @escaping (Double) -> Void, completion: @escaping (Result<URL, Error>) -> Void) -> URLSessionDownloadTask? {
+        let task = session.downloadTask(with: url)
+        progressHandlers[task] = progressHandler
+        completionHandlers[task] = completion
+        destinations[task] = destination
+        task.resume()
+        return task
+    }
+}
+
+extension URLSessionDownloadService: URLSessionDownloadDelegate {
+    func urlSession(_ session: URLSession, downloadTask: URLSessionDownloadTask, didFinishDownloadingTo location: URL) {
+        let completion = completionHandlers[downloadTask]
+        let destination = destinations[downloadTask]
+        
+        defer {
+            progressHandlers.removeValue(forKey: downloadTask)
+            completionHandlers.removeValue(forKey: downloadTask)
+            destinations.removeValue(forKey: downloadTask)
+            
+            // 다운로드 완료 알림
+            NotificationCenter.default.post(name: .downloadDidFinish, object: downloadTask)
+        }
+        
+        guard let destination = destination else {
+            completion?(.failure(NSError(domain: "HotUpdaterError", code: 1, userInfo: [NSLocalizedDescriptionKey: "Destination path not found"])))
+            return
+        }
+        
+        do {
+            let destinationURL = URL(fileURLWithPath: destination)
+            try FileManager.default.copyItem(at: location, to: destinationURL)
+            completion?(.success(destinationURL))
+        } catch {
+            NSLog("[DownloadService] Failed to copy downloaded file: \(error.localizedDescription)")
+            completion?(.failure(error))
+        }
+    }
+    
+    func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
+        let completion = completionHandlers[task]
+        defer {
+            progressHandlers.removeValue(forKey: task)
+            completionHandlers.removeValue(forKey: task)
+            destinations.removeValue(forKey: task)
+            
+            NotificationCenter.default.post(name: .downloadDidFinish, object: task)
+        }
+        
+        if let error = error {
+            completion?(.failure(error))
+        }
+    }
+    
+    func urlSession(_ session: URLSession, downloadTask: URLSessionDownloadTask, didWriteData bytesWritten: Int64, totalBytesWritten: Int64, totalBytesExpectedToWrite: Int64) {
+        let progressHandler = progressHandlers[downloadTask]
+        
+        if totalBytesExpectedToWrite > 0 {
+            let progress = Double(totalBytesWritten) / Double(totalBytesExpectedToWrite)
+            progressHandler?(progress)
+            
+            let progressInfo: [String: Any] = [
+                "progress": progress,
+                "totalBytesReceived": totalBytesWritten,
+                "totalBytesExpected": totalBytesExpectedToWrite
+            ]
+            NotificationCenter.default.post(name: .downloadProgressUpdate, object: downloadTask, userInfo: progressInfo)
+        } else {
+            progressHandler?(0)
+            
+            NotificationCenter.default.post(name: .downloadProgressUpdate, object: downloadTask, userInfo: ["progress": 0.0, "totalBytesReceived": 0, "totalBytesExpected": 0])
+        }
+    }
+}

package/ios/HotUpdater/Internal/VersionedPreferencesService.swift

@@ -0,0 +1,82 @@
+import Foundation
+
+enum PreferencesError: Error {
+    case configurationError
+    case setItemError(String)
+    case getItemError(String)
+}
+
+protocol PreferencesService {
+    func setItem(_ value: String?, forKey key: String) throws
+    func getItem(forKey key: String) throws -> String?
+}
+
+class VersionedPreferencesService: PreferencesService {
+    private let userDefaults: UserDefaults
+    private var keyPrefix: String = ""
+    
+    init(userDefaults: UserDefaults = .standard) {
+        self.userDefaults = userDefaults
+    }
+    
+    /**
+     * Configures the service with app version for key prefixing.
+     * @param appVersion The app version to use for key prefixing
+     */
+    func configure(appVersion: String?) {
+        self.keyPrefix = "hotupdater_\(appVersion ?? "unknown")_"
+        NSLog("[PreferencesService] Configured with appVersion: \(appVersion ?? "nil"). Key prefix: \(self.keyPrefix)")
+    }
+    
+    /**
+     * Creates a prefixed key for UserDefaults storage.
+     * @param key The base key to prefix
+     * @return The prefixed key
+     * @throws PreferencesError if configuration is missing
+     */
+    private func prefixedKey(forKey key: String) throws -> String {
+        guard !keyPrefix.isEmpty else {
+            NSLog("[PreferencesService] Warning: PreferencesService used before configure(appVersion:) was called. Key prefix is empty.")
+            throw PreferencesError.configurationError
+        }
+        return "\(keyPrefix)\(key)"
+    }
+    
+    /**
+     * Sets a value in preferences.
+     * @param value The value to store (or nil to remove)
+     * @param key The key to store under
+     * @throws PreferencesError if key prefixing fails
+     */
+    func setItem(_ value: String?, forKey key: String) throws {
+        do {
+            let fullKey = try prefixedKey(forKey: key)
+            if let valueToSet = value {
+                userDefaults.set(valueToSet, forKey: fullKey)
+                NSLog("[PreferencesService] Set '\(fullKey)' = '\(valueToSet)'")
+            } else {
+                userDefaults.removeObject(forKey: fullKey)
+                NSLog("[PreferencesService] Removed '\(fullKey)'")
+            }
+        } catch {
+            NSLog("[PreferencesService] Error setting key '\(key)': \(error)")
+            throw PreferencesError.setItemError(key)
+        }
+    }
+    
+    /**
+     * Gets a value from preferences.
+     * @param key The key to retrieve
+     * @return The stored value or nil if not found
+     * @throws PreferencesError if key prefixing fails
+     */
+    func getItem(forKey key: String) throws -> String? {
+        do {
+            let fullKey = try prefixedKey(forKey: key)
+            return userDefaults.string(forKey: fullKey)
+        } catch {
+            NSLog("[PreferencesService] Error getting key '\(key)': \(error)")
+            throw PreferencesError.getItemError(key)
+        }
+    }
+}

package/ios/HotUpdater/Package.resolved

@@ -0,0 +1,15 @@
+{
+  "originHash" : "11a19903c341bf413adfdb15a6fb5dff9a819b0557a6cfe9e5fe00f32a0ff74e",
+  "pins" : [
+    {
+      "identity" : "ziparchive",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/ZipArchive/ZipArchive.git",
+      "state" : {
+        "revision" : "df35718ea19a94e015b91dc4881dee028ce4cdba",
+        "version" : "2.6.0"
+      }
+    }
+  ],
+  "version" : 3
+}

package/ios/HotUpdater/Public/HotUpdater.h

@@ -0,0 +1,29 @@
+#import <React/RCTEventEmitter.h>
+#import <React/RCTBundleURLProvider.h>
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <HotUpdaterSpec/HotUpdaterSpec.h>
+@interface HotUpdater : RCTEventEmitter <NativeHotUpdaterSpec>
+#else
+#import <React/RCTBridgeModule.h>
+@interface HotUpdater : RCTEventEmitter <RCTBridgeModule>
+#endif // RCT_NEW_ARCH_ENABLED
+
+/**
+ * Returns the currently active bundle URL.
+* Callable from Objective-C (e.g., AppDelegate).
+ * This is implemented in HotUpdater.mm and calls the Swift static method.
+ */
++ (NSURL *)bundleURL;
+
+/**
+ * 다운로드 진행 상황 업데이트 시간을 추적하는 속성
+ */
+@property (nonatomic, assign) NSTimeInterval lastUpdateTime;
+
+// No need to declare the exported methods (reload, etc.) here
+// as RCT_EXPORT_METHOD handles their exposure to JavaScript.
+// We also don't need to declare supportedEvents or requiresMainQueueSetup here
+// as they are implemented in the .mm file (calling Swift).
+
+@end