@capgo/cordova-updater 8.1.1

package/src/ios/CryptoCipher.swift

@@ -0,0 +1,326 @@
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+import Foundation
+import CryptoKit
+
+public struct CryptoCipher {
+    private static var logger: Logger!
+
+    public static func setLogger(_ logger: Logger) {
+        self.logger = logger
+    }
+
+    private static func hexStringToData(_ hex: String) -> Data? {
+        var data = Data()
+        var hexIterator = hex.makeIterator()
+        while let char1 = hexIterator.next(), let char2 = hexIterator.next() {
+            guard let byte = UInt8(String([char1, char2]), radix: 16) else {
+                return nil
+            }
+            data.append(byte)
+        }
+        return data
+    }
+
+    private static func isHexString(_ str: String) -> Bool {
+        let hexCharacterSet = CharacterSet(charactersIn: "0123456789abcdefABCDEF")
+        return str.unicodeScalars.allSatisfy { hexCharacterSet.contains($0) }
+    }
+
+    public static func decryptChecksum(checksum: String, publicKey: String) throws -> String {
+        if publicKey.isEmpty {
+            logger.info("No encryption set (public key) ignored")
+            return checksum
+        }
+        do {
+            // Determine if input is hex or base64 encoded
+            // Hex strings only contain 0-9 and a-f, while base64 contains other characters
+            let checksumBytes: Data
+            let detectedFormat: String
+            if isHexString(checksum) {
+                // Hex encoded (new format from CLI for plugin versions >= 5.30.0, 6.30.0, 7.30.0)
+                guard let hexData = hexStringToData(checksum) else {
+                    logger.error("Cannot decode checksum as hex")
+                    logger.debug("Checksum value: \(checksum)")
+                    throw CustomError.cannotDecode
+                }
+                checksumBytes = hexData
+                detectedFormat = "hex"
+            } else {
+                // TODO: remove backwards compatibility
+                // Base64 encoded (old format for backwards compatibility)
+                guard let base64Data = Data(base64Encoded: checksum) else {
+                    logger.error("Cannot decode checksum as base64")
+                    logger.debug("Checksum value: \(checksum)")
+                    throw CustomError.cannotDecode
+                }
+                checksumBytes = base64Data
+                detectedFormat = "base64"
+            }
+            // swiftlint:disable:next line_length
+            logger.debug("Received checksum format: \(detectedFormat) (length: \(checksum.count) chars, \(checksumBytes.count) bytes)")
+
+            if checksumBytes.isEmpty {
+                logger.error("Decoded checksum is empty")
+                throw CustomError.cannotDecode
+            }
+
+            // RSA-2048 encrypted data must be exactly 256 bytes
+            // If the checksum is not 256 bytes, the bundle was not encrypted properly
+            if checksumBytes.count != 256 {
+                // swiftlint:disable:next line_length
+                logger.error("Checksum is not RSA encrypted (size: \(checksumBytes.count) bytes, expected 256 for RSA-2048). Bundle must be uploaded with encryption when public key is configured.")
+                throw CustomError.cannotDecode
+            }
+
+            guard let rsaPublicKey = RSAPublicKey.load(rsaPublicKey: publicKey) else {
+                logger.error("The public key is not a valid RSA Public key")
+                throw CustomError.cannotDecode
+            }
+
+            guard let decryptedChecksum = rsaPublicKey.decrypt(data: checksumBytes) else {
+                logger.error("decryptChecksum fail")
+                throw NSError(domain: "Failed to decrypt session key data", code: 2, userInfo: nil)
+            }
+
+            // Return as hex string to match calcChecksum output format
+            let result = decryptedChecksum.map { String(format: "%02x", $0) }.joined()
+
+            // Detect checksum algorithm based on length
+            let detectedAlgorithm: String
+            if decryptedChecksum.count == 32 {
+                detectedAlgorithm = "SHA-256"
+            } else if decryptedChecksum.count == 4 {
+                detectedAlgorithm = "CRC32 (deprecated)"
+                logger.error("CRC32 checksum detected - deprecated algorithm")
+            } else {
+                detectedAlgorithm = "unknown (\(decryptedChecksum.count) bytes)"
+                logger.error("Unknown checksum algorithm detected")
+                logger.debug("Byte count: \(decryptedChecksum.count), Expected: 32 (SHA-256)")
+            }
+            // swiftlint:disable:next line_length
+            logger.debug("Decrypted checksum: \(detectedAlgorithm) hex format (length: \(result.count) chars, \(decryptedChecksum.count) bytes)")
+            return result
+        } catch {
+            logger.error("Checksum decryption failed")
+            logger.debug("Error: \(error.localizedDescription)")
+            throw CustomError.cannotDecode
+        }
+    }
+
+    /// Detect checksum algorithm based on hex string length.
+    /// SHA-256 = 64 hex chars (32 bytes)
+    /// CRC32 = 8 hex chars (4 bytes)
+    public static func detectChecksumAlgorithm(_ hexChecksum: String) -> String {
+        if hexChecksum.isEmpty {
+            return "empty"
+        }
+        let len = hexChecksum.count
+        if len == 64 {
+            return "SHA-256"
+        } else if len == 8 {
+            return "CRC32 (deprecated)"
+        } else {
+            return "unknown (\(len) hex chars)"
+        }
+    }
+
+    /// Log checksum info and warn if deprecated algorithm detected.
+    public static func logChecksumInfo(label: String, hexChecksum: String) {
+        let algorithm = detectChecksumAlgorithm(hexChecksum)
+        logger.debug("\(label): \(algorithm) hex format (length: \(hexChecksum.count) chars)")
+        if algorithm.contains("CRC32") {
+            logger.error("CRC32 checksum detected - deprecated algorithm")
+        } else if algorithm.contains("unknown") {
+            logger.error("Unknown checksum algorithm detected")
+            logger.debug("Char count: \(hexChecksum.count), Expected: 64 (SHA-256)")
+        }
+    }
+
+    /// 256 KiB: one size for checksum, copy, and decode.
+    /// 64 workers * 256 KiB = 16 MiB for one buffer; AES/Brotli hold two (~32 MiB).
+    static let ioBufferBytesValue = 256 * 1024
+
+    static func ioBufferBytes() -> Int {
+        return ioBufferBytesValue
+    }
+
+    static func checksumBufferBytes() -> Int {
+        return ioBufferBytesValue
+    }
+
+    static func copyBufferBytes() -> Int {
+        return ioBufferBytesValue
+    }
+
+    public static func calcChecksum(filePath: URL) -> String {
+        let bufferSize = checksumBufferBytes()
+        var sha256 = SHA256()
+
+        do {
+            let fileHandle: FileHandle
+            do {
+                fileHandle = try FileHandle(forReadingFrom: filePath)
+            } catch {
+                logger.error("Cannot open file for checksum calculation")
+                logger.debug("Path: \(filePath.path), Error: \(error)")
+                return ""
+            }
+
+            defer {
+                do {
+                    try fileHandle.close()
+                } catch {
+                    logger.error("Error closing file during checksum")
+                    logger.debug("Error: \(error)")
+                }
+            }
+
+            while autoreleasepool(invoking: {
+                let fileData: Data
+                do {
+                    fileData = try fileHandle.read(upToCount: bufferSize) ?? Data()
+                } catch {
+                    logger.error("Error reading file during checksum")
+                    logger.debug("Error: \(error)")
+                    return false
+                }
+
+                if fileData.count > 0 {
+                    sha256.update(data: fileData)
+                    return true // Continue
+                } else {
+                    return false // End of file
+                }
+            }) {}
+
+            return hexString(from: sha256)
+        } catch {
+            logger.error("Cannot calculate checksum")
+            logger.debug("Path: \(filePath.path), Error: \(error)")
+            return ""
+        }
+    }
+
+    final class RunningChecksum {
+        private var sha256 = SHA256()
+
+        func update(_ data: Data) {
+            guard !data.isEmpty else {
+                return
+            }
+            sha256.update(data: data)
+        }
+
+        func hex() -> String {
+            CryptoCipher.hexString(from: sha256)
+        }
+    }
+
+    static func hexString(from sha256: SHA256) -> String {
+        var copy = sha256
+        return copy.finalize().compactMap { String(format: "%02x", $0) }.joined()
+    }
+
+    static func shortPathKey(_ fileName: String) -> String {
+        var sha256 = SHA256()
+        sha256.update(data: Data(fileName.utf8))
+        return String(hexString(from: sha256).prefix(16))
+    }
+
+    public static func decryptFile(filePath: URL, publicKey: String, sessionKey: String, version: String) throws {
+        if publicKey.isEmpty || sessionKey.isEmpty || sessionKey.components(separatedBy: ":").count != 2 {
+            logger.info("Encryption not set, no public key or session, ignored")
+            return
+        }
+
+        if !publicKey.hasPrefix("-----BEGIN RSA PUBLIC KEY-----") {
+            logger.error("The public key is not a valid RSA Public key")
+            return
+        }
+
+        do {
+            guard let rsaPublicKey = RSAPublicKey.load(rsaPublicKey: publicKey) else {
+                logger.error("The public key is not a valid RSA Public key")
+                throw CustomError.cannotDecode
+            }
+
+            let sessionKeyComponents = sessionKey.components(separatedBy: ":")
+            let ivBase64 = sessionKeyComponents[0]
+            let encryptedKeyBase64 = sessionKeyComponents[1]
+
+            guard let ivData = Data(base64Encoded: ivBase64) else {
+                logger.error("Cannot decode sessionKey IV")
+                logger.debug("IV value: \(ivBase64)")
+                throw CustomError.cannotDecode
+            }
+
+            if ivData.count != 16 {
+                logger.error("IV data has invalid length")
+                logger.debug("Length: \(ivData.count), Expected: 16")
+                throw CustomError.cannotDecode
+            }
+
+            guard let sessionKeyDataEncrypted = Data(base64Encoded: encryptedKeyBase64) else {
+                logger.error("Cannot decode sessionKey data")
+                logger.debug("Key value: \(encryptedKeyBase64)")
+                throw NSError(domain: "Invalid session key data", code: 1, userInfo: nil)
+            }
+
+            guard let sessionKeyDataDecrypted = rsaPublicKey.decrypt(data: sessionKeyDataEncrypted) else {
+                logger.error("Failed to decrypt session key data")
+                throw NSError(domain: "Failed to decrypt session key data", code: 2, userInfo: nil)
+            }
+
+            if sessionKeyDataDecrypted.count != 16 {
+                logger.error("Decrypted session key has invalid length")
+                logger.debug("Length: \(sessionKeyDataDecrypted.count), Expected: 16")
+                throw NSError(domain: "Invalid decrypted session key", code: 5, userInfo: nil)
+            }
+
+            let aesPrivateKey = AES128Key(iv: ivData, aes128Key: sessionKeyDataDecrypted, logger: logger)
+
+            let encryptedSize = (try FileManager.default.attributesOfItem(atPath: filePath.path)[.size] as? NSNumber)?.uint64Value ?? 0
+            if encryptedSize == 0 {
+                logger.error("Encrypted file data is empty")
+                throw NSError(domain: "Empty encrypted data", code: 6, userInfo: nil)
+            }
+
+            try aesPrivateKey.decrypt(from: filePath, to: filePath)
+            let decryptedSize = (try FileManager.default.attributesOfItem(atPath: filePath.path)[.size] as? NSNumber)?.uint64Value ?? 0
+            if decryptedSize == 0 {
+                logger.error("Decrypted data is empty")
+                throw NSError(domain: "Empty decrypted data", code: 7, userInfo: nil)
+            }
+
+        } catch {
+            logger.error("File decryption failed")
+            throw CustomError.cannotDecode
+        }
+    }
+
+    /// Get first 20 characters of the public key for identification
+    /// Returns 20-character string or empty string if key is invalid/empty
+    /// The first 12 chars are always "MIIBCgKCAQEA" for RSA 2048-bit keys,
+    /// so the unique part starts at character 13
+    public static func calcKeyId(publicKey: String) -> String {
+        if publicKey.isEmpty {
+            return ""
+        }
+
+        // Remove PEM headers and whitespace to get the raw key data
+        let cleanedKey = publicKey
+            .replacingOccurrences(of: "-----BEGIN RSA PUBLIC KEY-----", with: "")
+            .replacingOccurrences(of: "-----END RSA PUBLIC KEY-----", with: "")
+            .replacingOccurrences(of: "\n", with: "")
+            .replacingOccurrences(of: "\r", with: "")
+            .replacingOccurrences(of: " ", with: "")
+
+        // Return first 20 characters of the base64-encoded key
+        return String(cleanedKey.prefix(20))
+    }
+}

package/src/ios/DelayCondition.swift

@@ -0,0 +1,74 @@
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+//
+//  DelayCondition.swift
+//  Plugin
+//
+//  Created by Luca Peruzzo on 12/09/22.
+//  Copyright © 2022 Capgo. All rights reserved.
+//
+
+import Foundation
+
+private func delayUntilNextValue(value: String) -> DelayUntilNext {
+    switch value {
+    case "background": return .background
+    case "kill": return .kill
+    case "nativeVersion": return .nativeVersion
+    case "date": return .date
+    default:
+        return .background
+    }
+}
+
+@objc public class DelayCondition: NSObject, Decodable, Encodable {
+    private let kind: DelayUntilNext
+    private let value: String?
+
+    convenience init(kind: String, value: String?) {
+        self.init(kind: delayUntilNextValue(value: kind), value: value)
+    }
+
+    init(kind: DelayUntilNext, value: String?) {
+        self.kind = kind
+        self.value = value
+    }
+
+    public required init(from decoder: Decoder) throws {
+        let values: KeyedDecodingContainer<DelayCondition.CodingKeys> = try decoder.container(keyedBy: CodingKeys.self)
+        kind = try values.decode(DelayUntilNext.self, forKey: .kind)
+        value = try values.decode(String.self, forKey: .value)
+    }
+
+    enum CodingKeys: String, CodingKey {
+        case kind, value
+    }
+
+    public func getKind() -> String {
+        return self.kind.description
+    }
+
+    public func getValue() -> String? {
+        return self.value
+    }
+
+    public func toJSON() -> [String: String] {
+        return [
+            "kind": self.getKind(),
+            "value": self.getValue() ?? ""
+        ]
+    }
+
+    public static func == (lhs: DelayCondition, rhs: DelayCondition) -> Bool {
+        return lhs.getKind() == rhs.getKind() && lhs.getValue() == rhs.getValue()
+    }
+
+    public func toString() -> String {
+        return "{ \"kind\": \"\(self.getKind())\", \"value\": \"\(self.getValue() ?? "")\"}"
+    }
+
+}

package/src/ios/DelayUntilNext.swift

@@ -0,0 +1,30 @@
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+//
+//  DelayUntilNext.swift
+//  Plugin
+//
+//  Created by Luca Peruzzo on 12/09/22.
+//  Copyright © 2022 Capgo. All rights reserved.
+//
+
+import Foundation
+enum DelayUntilNext: Decodable, Encodable, CustomStringConvertible {
+    case background
+    case kill
+    case nativeVersion
+    case date
+
+    var description: String {
+        switch self {
+        case .background: return "background"
+        case .kill: return "kill"
+        case .nativeVersion: return "nativeVersion"
+        case .date: return "date"
+        }
+    }
+}

package/src/ios/DelayUpdateUtils.swift

@@ -0,0 +1,257 @@
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+//
+//  DelayUpdateUtils.swift
+//  Plugin
+//
+//  Created by Auto-generated based on Android implementation
+//  Copyright © 2024 Capgo. All rights reserved.
+//
+
+import Foundation
+import Version
+
+public class DelayUpdateUtils {
+
+    // swiftlint:disable identifier_name
+    static let DELAY_CONDITION_PREFERENCES = "DELAY_CONDITION_PREFERENCES_CAPGO"
+    static let BACKGROUND_TIMESTAMP_KEY = "BACKGROUND_TIMESTAMP_KEY_CAPGO"
+    // swiftlint:enable identifier_name
+    private let logger: Logger
+
+    private let currentVersionNative: Version
+
+    public enum CancelDelaySource {
+        case killed
+        case background
+        case foreground
+
+        var description: String {
+            switch self {
+            case .killed: return "KILLED"
+            case .background: return "BACKGROUND"
+            case .foreground: return "FOREGROUND"
+            }
+        }
+    }
+
+    public init(currentVersionNative: Version, logger: Logger) {
+        self.currentVersionNative = currentVersionNative
+        self.logger = logger
+    }
+
+    public func checkCancelDelay(source: CancelDelaySource) {
+        let delayUpdatePreferences = UserDefaults.standard.string(
+            forKey: DelayUpdateUtils.DELAY_CONDITION_PREFERENCES) ?? "[]"
+        let delayConditionList: [DelayCondition] = fromJsonArr(json: delayUpdatePreferences).compactMap { obj in
+            guard let kind = obj.value(forKey: "kind") as? String else { return nil }
+            let value: String? = obj.value(forKey: "value") as? String
+            return DelayCondition(kind: kind, value: value)
+        }
+
+        var delayConditionListToKeep: [DelayCondition] = []
+        var index = 0
+
+        for condition in delayConditionList {
+            let kind = condition.getKind()
+            let value = condition.getValue()
+
+            switch kind {
+            case "background":
+                if source == .foreground {
+                    let backgroundedAt = getBackgroundTimestamp()
+                    let now = Int64(Date().timeIntervalSince1970 * 1000) // Convert to milliseconds
+                    let delta = max(0, now - backgroundedAt)
+
+                    var longValue: Int64 = 0
+                    if let value = value, !value.isEmpty {
+                        longValue = Int64(value) ?? 0
+                    }
+
+                    if delta > longValue {
+                        // swiftlint:disable:next line_length
+                        logger.info("Background condition (value: \(value ?? "")) deleted at index \(index). Delta: \(delta), longValue: \(longValue)")
+                    } else {
+                        delayConditionListToKeep.append(condition)
+                        // swiftlint:disable:next line_length
+                        logger.info("Background delay (value: \(value ?? "")) condition kept at index \(index) (source: \(source.description))")
+                    }
+                } else {
+                    delayConditionListToKeep.append(condition)
+                    // swiftlint:disable:next line_length
+                    logger.info("Background delay (value: \(value ?? "")) condition kept at index \(index) (source: \(source.description))")
+                }
+
+            case "kill":
+                if source == .killed {
+                    logger.info("Kill delay (value: \(value ?? "")) removed at index \(index) after app kill")
+                } else {
+                    delayConditionListToKeep.append(condition)
+                    // swiftlint:disable:next line_length
+                    logger.info("Kill delay (value: \(value ?? "")) condition kept at index \(index) (source: \(source.description))")
+                }
+
+            case "date":
+                if let value = value, !value.isEmpty {
+                    if let date = parseDateCondition(value) {
+                        if Date() > date {
+                            // swiftlint:disable:next line_length
+                            logger.info("Date delay (value: \(value)) condition removed due to expired date at index \(index)")
+                        } else {
+                            delayConditionListToKeep.append(condition)
+                            logger.info("Date delay (value: \(value)) kept at index \(index)")
+                        }
+                    } else {
+                        // swiftlint:disable:next line_length
+                        logger.error("Date delay (value: \(value)) condition removed due to parsing issue at index \(index)")
+                    }
+                } else {
+                    // swiftlint:disable:next line_length
+                    logger.error("Date delay (value: \(value ?? "")) condition removed due to empty value at index \(index)")
+                }
+
+            case "nativeVersion":
+                if let value = value, !value.isEmpty {
+                    do {
+                        let versionLimit = try Version(value)
+                        if currentVersionNative >= versionLimit {
+                            // swiftlint:disable:next line_length
+                            logger.info("Native version delay (value: \(value)) condition removed due to above limit at index \(index)")
+                        } else {
+                            delayConditionListToKeep.append(condition)
+                            logger.info("Native version delay (value: \(value)) kept at index \(index)")
+                        }
+                    } catch {
+                        // swiftlint:disable:next line_length
+                        logger.error("Native version delay (value: \(value)) condition removed due to parsing issue at index \(index): \(error)")
+                    }
+                } else {
+                    // swiftlint:disable:next line_length
+                    logger.error("Native version delay (value: \(value ?? "")) condition removed due to empty value at index \(index)")
+                }
+
+            default:
+                logger.error("Unknown delay condition kind: \(kind) at index \(index)")
+            }
+
+            index += 1
+        }
+
+        if !delayConditionListToKeep.isEmpty {
+            let json = toJson(object: delayConditionListToKeep.map { $0.toJSON() })
+            _ = setMultiDelay(delayConditions: json)
+        } else {
+            // Clear all delay conditions if none are left to keep
+            _ = cancelDelay(source: "checkCancelDelay")
+        }
+    }
+
+    public func setMultiDelay(delayConditions: String) -> Bool {
+        do {
+            UserDefaults.standard.set(delayConditions, forKey: DelayUpdateUtils.DELAY_CONDITION_PREFERENCES)
+            UserDefaults.standard.synchronize()
+            logger.info("Delay update saved")
+            return true
+        } catch {
+            logger.error("Failed to delay update, [Error calling 'setMultiDelay()']: \(error)")
+            return false
+        }
+    }
+
+    public func setBackgroundTimestamp(_ backgroundTimestamp: Int64) {
+        do {
+            UserDefaults.standard.set(backgroundTimestamp, forKey: DelayUpdateUtils.BACKGROUND_TIMESTAMP_KEY)
+            UserDefaults.standard.synchronize()
+            logger.info("Background timestamp saved")
+        } catch {
+            logger.error("Failed to save background timestamp, [Error calling 'setBackgroundTimestamp()']: \(error)")
+        }
+    }
+
+    public func unsetBackgroundTimestamp() {
+        do {
+            UserDefaults.standard.removeObject(forKey: DelayUpdateUtils.BACKGROUND_TIMESTAMP_KEY)
+            UserDefaults.standard.synchronize()
+            logger.info("Background timestamp removed")
+        } catch {
+            // swiftlint:disable:next line_length
+            logger.error("Failed to remove background timestamp, [Error calling 'unsetBackgroundTimestamp()']: \(error)")
+        }
+    }
+
+    private func getBackgroundTimestamp() -> Int64 {
+        do {
+            let key = DelayUpdateUtils.BACKGROUND_TIMESTAMP_KEY
+            let timestamp = UserDefaults.standard.object(forKey: key) as? Int64 ?? 0
+            return timestamp
+        } catch {
+            logger.error("Failed to get background timestamp, [Error calling 'getBackgroundTimestamp()']: \(error)")
+            return 0
+        }
+    }
+
+    public func cancelDelay(source: String) -> Bool {
+        do {
+            UserDefaults.standard.removeObject(forKey: DelayUpdateUtils.DELAY_CONDITION_PREFERENCES)
+            UserDefaults.standard.synchronize()
+            logger.info("All delays canceled from \(source)")
+            return true
+        } catch {
+            logger.error("Failed to cancel update delay: \(error)")
+            return false
+        }
+    }
+
+    // MARK: - Helper methods
+
+    private func parseDateCondition(_ value: String) -> Date? {
+        let withFractionalSeconds = ISO8601DateFormatter()
+        withFractionalSeconds.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        if let date = withFractionalSeconds.date(from: value) {
+            return date
+        }
+
+        let withoutFractionalSeconds = ISO8601DateFormatter()
+        withoutFractionalSeconds.formatOptions = [.withInternetDateTime]
+        if let date = withoutFractionalSeconds.date(from: value) {
+            return date
+        }
+
+        // Legacy fallback for strings without timezone.
+        for format in ["yyyy-MM-dd'T'HH:mm:ss.SSS", "yyyy-MM-dd'T'HH:mm:ss"] {
+            let formatter = DateFormatter()
+            formatter.locale = Locale(identifier: "en_US_POSIX")
+            formatter.calendar = Calendar(identifier: .gregorian)
+            formatter.timeZone = .current
+            formatter.isLenient = false
+            formatter.dateFormat = format
+            if let date = formatter.date(from: value) {
+                return date
+            }
+        }
+
+        return nil
+    }
+
+    private func toJson(object: Any) -> String {
+        guard let data = try? JSONSerialization.data(withJSONObject: object, options: []) else {
+            return ""
+        }
+        return String(data: data, encoding: String.Encoding.utf8) ?? ""
+    }
+
+    private func fromJsonArr(json: String) -> [NSObject] {
+        guard let jsonData = json.data(using: .utf8) else {
+            return []
+        }
+        let object = try? JSONSerialization.jsonObject(
+            with: jsonData,
+            options: .mutableContainers
+        ) as? [NSObject]
+        return object ?? []
+    }
+}