@hot-updater/react-native 1.0.0-rc.2 → 1.0.0-rc.21

package/ios/HotUpdater/Internal/URLSessionDownloadService.swift

@@ -23,27 +23,118 @@ protocol DownloadService {
 }
 
 
-enum DownloadError: Error {
+enum DownloadError: Error, Equatable {
     case incompleteDownload(expected: Int64, actual: Int64)
     case invalidContentLength
+    /// The server answered with a status outside 200-299. `originCode` is the
+    /// `<Code>` of a storage origin's XML error body, when it has one.
+    case httpStatus(Int, originCode: String? = nil)
+
+    /// How much of an error body is searched for a storage origin's code.
+    static let maximumErrorBodyPrefixByteCount = 4 * 1024
+    private static let maximumOriginCodeLength = 64
+
+    /// The failure for an HTTP response outside 200-299, or nil for a
+    /// successful or non-HTTP response. `body` is the saved response body.
+    static func httpStatusError(for response: URLResponse?, body: URL?) -> DownloadError? {
+        guard let httpResponse = response as? HTTPURLResponse,
+              !(200..<300).contains(httpResponse.statusCode) else {
+            return nil
+        }
+        let originCode = body.flatMap { body -> String? in
+            guard let handle = try? FileHandle(forReadingFrom: body) else {
+                return nil
+            }
+            defer { try? handle.close() }
+            let prefix = try? FileUtilities.readUpToCount(
+                from: handle,
+                count: maximumErrorBodyPrefixByteCount
+            )
+            return prefix.flatMap { storageOriginErrorCode(in: $0) }
+        }
+        return .httpStatus(httpResponse.statusCode, originCode: originCode)
+    }
+
+    /// The `<Code>` of an S3, R2, or GCS style `<Error>` document in the
+    /// first 4 KB of `body`, such as "AccessDenied". Nothing else from the
+    /// body is kept, and a code must be 1-64 characters of [A-Za-z0-9._-].
+    static func storageOriginErrorCode(in body: Data) -> String? {
+        let text = String(decoding: body.prefix(maximumErrorBodyPrefixByteCount), as: UTF8.self)
+        guard let errorElement = text.range(of: "<Error"),
+              let codeStart = text.range(of: "<Code>", range: errorElement.upperBound..<text.endIndex),
+              let codeEnd = text.range(of: "</Code>", range: codeStart.upperBound..<text.endIndex) else {
+            return nil
+        }
+        let code = text[codeStart.upperBound..<codeEnd.lowerBound]
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+        guard (1...maximumOriginCodeLength).contains(code.unicodeScalars.count),
+              code.unicodeScalars.allSatisfy(isOriginCodeCharacter) else {
+            return nil
+        }
+        return code
+    }
+
+    private static func isOriginCodeCharacter(_ scalar: Unicode.Scalar) -> Bool {
+        switch scalar {
+        case "A"..."Z", "a"..."z", "0"..."9", ".", "_", "-":
+            return true
+        default:
+            return false
+        }
+    }
 }
 
-// Task state for persistence and recovery
-struct TaskState: Codable {
-    let taskIdentifier: Int
-    let destination: String
-    let bundleId: String
-    let startedAt: TimeInterval
+extension DownloadError {
+    /// Attempts per download that retries, the first one included.
+    static let maximumAttempts = 3
+
+    /// Whether a failed download may succeed if tried again: a network
+    /// failure or timeout, a body that ended early, or a 408, 429, or 5xx
+    /// answer. Another 4xx, a TLS failure, a cancelled task, and a local file
+    /// failure would fail the same way again.
+    static func isRetryable(_ error: Error) -> Bool {
+        if let downloadError = error as? DownloadError {
+            switch downloadError {
+            case .httpStatus(let status, _):
+                return status == 408 || status == 429 || status >= 500
+            case .incompleteDownload:
+                return true
+            case .invalidContentLength:
+                return false
+            }
+        }
+        let nsError = error as NSError
+        guard nsError.domain == NSURLErrorDomain else {
+            return false
+        }
+        switch URLError.Code(rawValue: nsError.code) {
+        case .timedOut,
+             .cannotFindHost,
+             .cannotConnectToHost,
+             .networkConnectionLost,
+             .dnsLookupFailed,
+             .notConnectedToInternet,
+             .cannotLoadFromNetwork,
+             .callIsActive,
+             .dataNotAllowed,
+             .internationalRoamingOff,
+             .backgroundSessionWasDisconnected,
+             .badServerResponse:
+            return true
+        default:
+            return false
+        }
+    }
 }
 
 class URLSessionDownloadService: NSObject, DownloadService {
+    private let stateLock = NSRecursiveLock()
     private var session: URLSession!
     private var backgroundSession: URLSession!
     private var progressHandlers: [URLSessionTask: (DownloadProgress) -> Void] = [:]
     private var completionHandlers: [URLSessionTask: (Result<URL, Error>) -> Void] = [:]
     private var destinations: [URLSessionTask: String] = [:]
     private var fileSizeHandlers: [URLSessionTask: (Int64) -> Void] = [:]
-    private var taskStates: [Int: TaskState] = [:]
 
     override init() {
         super.init()
@@ -61,51 +152,22 @@ class URLSessionDownloadService: NSObject, DownloadService {
             backgroundConfig.sessionSendsLaunchEvents = true
         }
         backgroundSession = URLSession(configuration: backgroundConfig, delegate: self, delegateQueue: nil)
-
-        // Load persisted task states
-        taskStates = loadTaskStates()
-    }
-
-    // MARK: - State Persistence
-
-    private var stateFileURL: URL {
-        let documentsPath = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)[0]
-        return documentsPath.appendingPathComponent("download-state.json")
-    }
-
-    private func saveTaskState(_ state: TaskState) {
-        taskStates[state.taskIdentifier] = state
-
-        if let data = try? JSONEncoder().encode(taskStates) {
-            try? data.write(to: stateFileURL)
-        }
-    }
-
-    private func loadTaskStates() -> [Int: TaskState] {
-        guard let data = try? Data(contentsOf: stateFileURL),
-              let states = try? JSONDecoder().decode([Int: TaskState].self, from: data) else {
-            return [:]
-        }
-        return states
-    }
-
-    private func removeTaskState(_ taskIdentifier: Int) {
-        taskStates.removeValue(forKey: taskIdentifier)
-
-        if let data = try? JSONEncoder().encode(taskStates) {
-            try? data.write(to: stateFileURL)
-        }
     }
 
     func downloadFile(from url: URL, to destination: String, fileSizeHandler: ((Int64) -> Void)?, progressHandler: @escaping (DownloadProgress) -> Void, completion: @escaping (Result<URL, Error>) -> Void) -> URLSessionDownloadTask? {
+        // UIKit state is read on the main thread before taking the task-state lock.
         // Determine if we should use background session
         #if !os(macOS)
-        let appState = UIApplication.shared.applicationState
+        let appState = Thread.isMainThread
+            ? UIApplication.shared.applicationState
+            : DispatchQueue.main.sync { UIApplication.shared.applicationState }
         let useBackgroundSession = (appState == .background || appState == .inactive)
         #else
         let useBackgroundSession = false
         #endif
 
+        stateLock.lock()
+        defer { stateLock.unlock() }
         let selectedSession = useBackgroundSession ? backgroundSession : session
         let task = selectedSession?.downloadTask(with: url)
 
@@ -120,20 +182,6 @@ class URLSessionDownloadService: NSObject, DownloadService {
             fileSizeHandlers[task] = handler
         }
 
-        // Extract bundleId from destination path (e.g., "bundle-store/{bundleId}/bundle.zip")
-        let bundleId = (destination as NSString).pathComponents
-            .dropFirst()
-            .first(where: { $0 != "bundle-store" }) ?? "unknown"
-
-        // Save task metadata for background recovery
-        let taskState = TaskState(
-            taskIdentifier: task.taskIdentifier,
-            destination: destination,
-            bundleId: bundleId,
-            startedAt: Date().timeIntervalSince1970
-        )
-        saveTaskState(taskState)
-
         task.resume()
         return task
     }
@@ -141,6 +189,8 @@ class URLSessionDownloadService: NSObject, DownloadService {
 
 extension URLSessionDownloadService: URLSessionDownloadDelegate {
     func urlSession(_ session: URLSession, downloadTask: URLSessionDownloadTask, didFinishDownloadingTo location: URL) {
+        stateLock.lock()
+        defer { stateLock.unlock() }
         let completion = completionHandlers[downloadTask]
         let destination = destinations[downloadTask]
 
@@ -149,10 +199,6 @@ extension URLSessionDownloadService: URLSessionDownloadDelegate {
             completionHandlers.removeValue(forKey: downloadTask)
             destinations.removeValue(forKey: downloadTask)
             fileSizeHandlers.removeValue(forKey: downloadTask)
-            removeTaskState(downloadTask.taskIdentifier)
-
-            // 다운로드 완료 알림
-            NotificationCenter.default.post(name: .downloadDidFinish, object: downloadTask)
         }
 
         guard let destination = destination else {
@@ -160,6 +206,14 @@ extension URLSessionDownloadService: URLSessionDownloadDelegate {
             return
         }
 
+        // URLSession saves error bodies too, so reject them before they reach verification.
+        if let httpError = DownloadError.httpStatusError(for: downloadTask.response, body: location) {
+            NSLog("[DownloadService] Download failed: \(httpError)")
+            try? FileManager.default.removeItem(at: location)
+            completion?(.failure(httpError))
+            return
+        }
+
         // Verify file size
         let expectedSize = downloadTask.response?.expectedContentLength ?? -1
         let actualSize: Int64?
@@ -197,15 +251,14 @@ extension URLSessionDownloadService: URLSessionDownloadDelegate {
     }
     
     func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
+        stateLock.lock()
+        defer { stateLock.unlock() }
         let completion = completionHandlers[task]
         defer {
             progressHandlers.removeValue(forKey: task)
             completionHandlers.removeValue(forKey: task)
             destinations.removeValue(forKey: task)
             fileSizeHandlers.removeValue(forKey: task)
-            removeTaskState(task.taskIdentifier)
-
-            NotificationCenter.default.post(name: .downloadDidFinish, object: task)
         }
 
         if let error = error {
@@ -214,6 +267,8 @@ extension URLSessionDownloadService: URLSessionDownloadDelegate {
     }
     
     func urlSession(_ session: URLSession, downloadTask: URLSessionDownloadTask, didWriteData bytesWritten: Int64, totalBytesWritten: Int64, totalBytesExpectedToWrite: Int64) {
+        stateLock.lock()
+        defer { stateLock.unlock() }
         let progressHandler = progressHandlers[downloadTask]
 
         // Call file size handler on first callback when size is known
@@ -232,16 +287,9 @@ extension URLSessionDownloadService: URLSessionDownloadDelegate {
             let progress = Double(totalBytesWritten) / Double(totalBytesExpectedToWrite)
             progressHandler?(DownloadProgress(progress: progress, downloadedBytes: totalBytesWritten, totalBytes: totalBytesExpectedToWrite))
 
-            let progressInfo: [String: Any] = [
-                "progress": progress,
-                "totalBytesReceived": totalBytesWritten,
-                "totalBytesExpected": totalBytesExpectedToWrite
-            ]
-            NotificationCenter.default.post(name: .downloadProgressUpdate, object: downloadTask, userInfo: progressInfo)
         } else {
             progressHandler?(DownloadProgress(progress: 0, downloadedBytes: totalBytesWritten, totalBytes: nil))
 
-            NotificationCenter.default.post(name: .downloadProgressUpdate, object: downloadTask, userInfo: ["progress": 0.0, "totalBytesReceived": 0, "totalBytesExpected": 0])
         }
     }
 }

package/ios/HotUpdater/Internal/UpdateFailure.swift

@@ -0,0 +1,390 @@
+import Foundation
+
+/// Where an update failed: `download` covers transferring the update's files
+/// and verifying the downloaded bytes, and `install` covers producing the
+/// bundle on disk (patching, extracting, and moving files into place).
+enum UpdateFailureStage: String {
+    case download
+    case install
+}
+
+/// Why an update failed.
+enum UpdateFailureReason: String {
+    case network
+    case http
+    case invalidResponse = "invalid_response"
+    case hashMismatch = "hash_mismatch"
+    case signature
+    case patch
+    case extract
+    case storage
+    case unknown
+}
+
+/// What was being fetched or applied when an update failed.
+enum UpdateFailureResource: String {
+    case manifest
+    case file
+    case patch
+    case archive
+}
+
+/// How a transfer failed when no HTTP response arrived.
+enum UpdateFailureTransport: String {
+    case timeout
+    case dns
+    case tls
+    case connection
+    case offline
+    case cancelled
+
+    /// Returns nil for codes that do not name a transport failure.
+    init?(_ code: URLError.Code) {
+        switch code {
+        case .timedOut:
+            self = .timeout
+        case .cannotFindHost, .dnsLookupFailed:
+            self = .dns
+        case .secureConnectionFailed,
+             .serverCertificateHasBadDate,
+             .serverCertificateUntrusted,
+             .serverCertificateHasUnknownRoot,
+             .serverCertificateNotYetValid,
+             .clientCertificateRejected,
+             .clientCertificateRequired:
+            self = .tls
+        case .cannotConnectToHost, .networkConnectionLost:
+            self = .connection
+        case .notConnectedToInternet, .dataNotAllowed, .internationalRoamingOff:
+            self = .offline
+        case .cancelled:
+            self = .cancelled
+        default:
+            return nil
+        }
+    }
+}
+
+/// The classification an `updateBundle` rejection carries in its userInfo.
+struct UpdateFailure: Equatable {
+    static let stageKey = "stage"
+    static let reasonKey = "reason"
+    static let resourceKey = "resource"
+    static let httpStatusKey = "httpStatus"
+    static let transportKey = "transport"
+    static let originCodeKey = "originCode"
+
+    static let network = UpdateFailure(stage: .download, reason: .network)
+    static let invalidResponse = UpdateFailure(stage: .download, reason: .invalidResponse)
+    static let hashMismatch = UpdateFailure(stage: .download, reason: .hashMismatch)
+    static let signature = UpdateFailure(stage: .download, reason: .signature)
+    static let patch = UpdateFailure(stage: .install, reason: .patch)
+    static let extract = UpdateFailure(stage: .install, reason: .extract)
+    static let storage = UpdateFailure(stage: .install, reason: .storage)
+
+    static func network(transport: UpdateFailureTransport?) -> UpdateFailure {
+        UpdateFailure(stage: .download, reason: .network, transport: transport)
+    }
+
+    static func http(status: Int, originCode: String? = nil) -> UpdateFailure {
+        UpdateFailure(
+            stage: .download,
+            reason: .http,
+            httpStatus: status,
+            originCode: originCode
+        )
+    }
+
+    static func unknown(_ stage: UpdateFailureStage) -> UpdateFailure {
+        UpdateFailure(stage: stage, reason: .unknown)
+    }
+
+    let stage: UpdateFailureStage
+    let reason: UpdateFailureReason
+    /// What was being fetched or applied, when the failure concerns one.
+    private(set) var resource: UpdateFailureResource?
+    /// The response status; only set when `reason` is `.http`.
+    let httpStatus: Int?
+    /// Only set when `reason` is `.network` and no response arrived.
+    let transport: UpdateFailureTransport?
+    /// The storage origin's XML error code; only set when `reason` is `.http`.
+    let originCode: String?
+
+    private init(
+        stage: UpdateFailureStage,
+        reason: UpdateFailureReason,
+        httpStatus: Int? = nil,
+        transport: UpdateFailureTransport? = nil,
+        originCode: String? = nil
+    ) {
+        self.stage = stage
+        self.reason = reason
+        self.httpStatus = httpStatus
+        self.transport = transport
+        self.originCode = originCode
+    }
+
+    /// This failure, attributed to `resource` unless it already names one.
+    func with(resource: UpdateFailureResource?) -> UpdateFailure {
+        guard self.resource == nil, let resource else {
+            return self
+        }
+        var failure = self
+        failure.resource = resource
+        return failure
+    }
+
+    /// JSON-safe entries React Native copies into the JS error's `userInfo`.
+    var userInfo: [String: Any] {
+        var userInfo: [String: Any] = [
+            Self.stageKey: stage.rawValue,
+            Self.reasonKey: reason.rawValue,
+        ]
+        if let resource {
+            userInfo[Self.resourceKey] = resource.rawValue
+        }
+        if let httpStatus {
+            userInfo[Self.httpStatusKey] = NSNumber(value: httpStatus)
+        }
+        if let transport {
+            userInfo[Self.transportKey] = transport.rawValue
+        }
+        if let originCode {
+            userInfo[Self.originCodeKey] = originCode
+        }
+        return userInfo
+    }
+
+    /// An error carrying this classification, for rejections raised before
+    /// the update pipeline starts, such as invalid `updateBundle` parameters.
+    func error(description: String) -> NSError {
+        var userInfo = self.userInfo
+        userInfo[NSLocalizedDescriptionKey] = description
+        return NSError(domain: "HotUpdater", code: 0, userInfo: userInfo)
+    }
+}
+
+/// The update step an error came from. It classifies the errors whose type
+/// does not: a hash mismatch is a download failure after a transfer but a
+/// patch failure after patching, and an unexpected error keeps the stage.
+enum UpdatePhase {
+    /// Transferring manifest, archive, asset, or patch bytes.
+    case transfer
+    /// Checking downloaded bytes against the manifest.
+    case verification
+    /// Parsing and validating the manifest against the update parameters.
+    case manifest
+    /// Applying a bsdiff patch and checking its output.
+    case patch
+    /// Decoding brotli or tar data and checking the extracted files.
+    case extraction
+    /// Creating directories and copying, moving, or writing files.
+    case storage
+}
+
+/// An update pipeline error and its classification. `underlying` still
+/// decides the rejection code, so classifying an error never changes it.
+struct UpdateFailureError: Error {
+    let underlying: Error
+    let failure: UpdateFailure
+
+    /// Classifies `error` as raised during `phase` while fetching or applying
+    /// `resource`. An error that is already classified keeps its
+    /// classification and only gains a missing resource. Returns `error`
+    /// unchanged when it is not an update failure.
+    static func classifying(
+        _ error: Error,
+        during phase: UpdatePhase,
+        resource: UpdateFailureResource? = nil
+    ) -> Error {
+        if let classified = error as? UpdateFailureError {
+            return UpdateFailureError(
+                underlying: classified.underlying,
+                failure: classified.failure.with(resource: resource)
+            )
+        }
+        guard let failure = UpdateFailureClassifier.classify(error, during: phase) else {
+            return error
+        }
+        return UpdateFailureError(underlying: error, failure: failure.with(resource: resource))
+    }
+
+    /// Runs `body`, classifying what it throws as raised during `phase`.
+    static func during<T>(
+        _ phase: UpdatePhase,
+        resource: UpdateFailureResource? = nil,
+        _ body: () throws -> T
+    ) throws -> T {
+        do {
+            return try body()
+        } catch {
+            throw classifying(error, during: phase, resource: resource)
+        }
+    }
+
+    /// The error that decides the rejection code.
+    static func unwrap(_ error: Error) -> Error {
+        (error as? UpdateFailureError)?.underlying ?? error
+    }
+
+    /// The error `updateBundle` rejects with: the underlying error's domain,
+    /// code, and userInfo, plus the classification entries.
+    static func rejectionError(for error: Error) -> NSError {
+        guard let classified = error as? UpdateFailureError else {
+            return error as NSError
+        }
+        let underlying = classified.underlying as NSError
+        var userInfo = underlying.userInfo
+        userInfo[NSLocalizedDescriptionKey] = underlying.localizedDescription
+        userInfo.merge(classified.failure.userInfo) { _, classification in classification }
+        return NSError(domain: underlying.domain, code: underlying.code, userInfo: userInfo)
+    }
+}
+
+extension UpdateFailureError: LocalizedError {
+    var errorDescription: String? {
+        underlying.localizedDescription
+    }
+}
+
+/// The Release selection an install was staged for changed before the bundle
+/// was activated. The rejection is not an update failure.
+struct StaleReleaseSelectionError: Error, CustomNSError {
+    static var errorDomain: String {
+        "HotUpdater"
+    }
+
+    var errorCode: Int {
+        0
+    }
+
+    var errorUserInfo: [String: Any] {
+        [NSLocalizedDescriptionKey: "Release catalog selection is stale"]
+    }
+}
+
+enum UpdateFailureClassifier {
+    /// Classifies an error raised during `phase`, or returns nil when the
+    /// error is not an update failure.
+    static func classify(_ error: Error, during phase: UpdatePhase) -> UpdateFailure? {
+        switch error {
+        case let error as UpdateFailureError:
+            return error.failure
+        case is StaleReleaseSelectionError:
+            return nil
+        case let error as BundleStorageError:
+            return classifyStorageError(error, during: phase)
+        case let error as SignatureVerificationError:
+            return classifySignatureError(error, during: phase)
+        case let error as DownloadError:
+            return classifyDownloadError(error)
+        case let error as URLError:
+            return classifyURLError(error)
+        default:
+            return isFileSystemError(error) ? .storage : fallback(during: phase)
+        }
+    }
+
+    private static func classifyStorageError(
+        _ error: BundleStorageError,
+        during phase: UpdatePhase
+    ) -> UpdateFailure? {
+        switch error {
+        case .directoryCreationFailed, .moveOperationFailed:
+            return .storage
+        case .downloadFailed(let underlying):
+            return classify(underlying, during: .transfer)
+        case .incompleteDownload:
+            return .network
+        case .invalidBundle:
+            return .invalidResponse
+        case .signatureVerificationFailed(let underlying):
+            return classifySignatureError(underlying, during: phase)
+        case .bundleInCrashedHistory:
+            return nil
+        case .unknown(.some(let underlying)):
+            return classify(underlying, during: phase)
+        case .unknown(.none):
+            return fallback(during: phase)
+        }
+    }
+
+    private static func classifySignatureError(
+        _ error: SignatureVerificationError,
+        during phase: UpdatePhase
+    ) -> UpdateFailure {
+        switch error {
+        case .fileHashMismatch:
+            switch phase {
+            case .patch:
+                return .patch
+            case .extraction:
+                return .extract
+            case .transfer, .verification, .manifest, .storage:
+                return .hashMismatch
+            }
+        case .fileReadFailed:
+            return .storage
+        case .missingFileHash:
+            return .invalidResponse
+        case .publicKeyNotConfigured,
+             .invalidPublicKeyFormat,
+             .invalidSignatureFormat,
+             .signatureVerificationFailed,
+             .unsignedNotAllowed,
+             .securityFrameworkError:
+            return .signature
+        }
+    }
+
+    private static func classifyDownloadError(_ error: DownloadError) -> UpdateFailure {
+        switch error {
+        case .httpStatus(let status, let originCode):
+            return .http(status: status, originCode: originCode)
+        case .incompleteDownload, .invalidContentLength:
+            // A response arrived, so the failure names no transport.
+            return .network
+        }
+    }
+
+    private static func classifyURLError(_ error: URLError) -> UpdateFailure {
+        switch error.code {
+        case .badURL, .unsupportedURL:
+            return .invalidResponse
+        case .cannotCreateFile,
+             .cannotOpenFile,
+             .cannotCloseFile,
+             .cannotWriteToFile,
+             .cannotRemoveFile,
+             .cannotMoveFile:
+            return .storage
+        default:
+            return .network(transport: UpdateFailureTransport(error.code))
+        }
+    }
+
+    private static func isFileSystemError(_ error: Error) -> Bool {
+        if error is FileSystemError {
+            return true
+        }
+        if let cocoaError = error as? CocoaError {
+            return cocoaError.isFileError
+        }
+        return (error as NSError).domain == NSPOSIXErrorDomain
+    }
+
+    private static func fallback(during phase: UpdatePhase) -> UpdateFailure {
+        switch phase {
+        case .transfer, .verification:
+            return .unknown(.download)
+        case .manifest:
+            return .invalidResponse
+        case .patch:
+            return .patch
+        case .extraction:
+            return .extract
+        case .storage:
+            return .unknown(.install)
+        }
+    }
+}

package/ios/HotUpdater/Recovery/HotUpdaterRecovery.h

@@ -0,0 +1,16 @@
+#import <Foundation/Foundation.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void HotUpdaterMarkFailedRuntime(void);
+BOOL HotUpdaterIsFailedRuntime(void);
+void HotUpdaterInstallRecoveryHooks(void);
+BOOL HotUpdaterBeginSurfaceStart(const void *surfaceHandler);
+void HotUpdaterFinishSurfaceStart(const void *surfaceHandler);
+void HotUpdaterAfterSurfaceStarts(dispatch_block_t action);
+
+#ifdef __cplusplus
+}
+#endif