@capgo/cordova-updater 8.1.1

package/src/android/test/app/capgo/cordova/updater/DelayUpdateUtilsTest.java

@@ -0,0 +1,177 @@
+package app.capgo.cordova.updater;
+
+import static org.junit.Assert.*;
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.*;
+
+import android.content.SharedPreferences;
+import io.github.g00fy2.versioncompare.Version;
+import java.util.ArrayList;
+import org.json.JSONArray;
+import org.json.JSONObject;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+public class DelayUpdateUtilsTest {
+
+    @Mock
+    private SharedPreferences prefs;
+
+    @Mock
+    private SharedPreferences.Editor editor;
+
+    @Mock
+    private Logger logger;
+
+    private DelayUpdateUtils utils;
+
+    @Before
+    public void setUp() {
+        MockitoAnnotations.openMocks(this);
+
+        when(prefs.getString(eq(DelayUpdateUtils.DELAY_CONDITION_PREFERENCES), anyString())).thenReturn("[]");
+        when(prefs.getLong(eq(DelayUpdateUtils.BACKGROUND_TIMESTAMP_KEY), anyLong())).thenReturn(0L);
+        when(editor.putString(anyString(), anyString())).thenReturn(editor);
+        when(editor.remove(anyString())).thenReturn(editor);
+        when(editor.commit()).thenReturn(true);
+
+        utils = new DelayUpdateUtils(prefs, editor, new Version("1.0.0"), logger);
+    }
+
+    @Test
+    public void parseDelayConditions_returnsPopulatedListForValidJson() throws Exception {
+        JSONArray jsonArray = new JSONArray();
+        jsonArray.put(new JSONObject().put("kind", "background").put("value", "5000"));
+        jsonArray.put(new JSONObject().put("kind", "kill").put("value", ""));
+        jsonArray.put(new JSONObject().put("kind", "nativeVersion").put("value", "2.0.0"));
+        jsonArray.put(new JSONObject().put("kind", "date").put("value", "2023-01-01T00:00:00.000"));
+
+        ArrayList<DelayCondition> result = utils.parseDelayConditions(jsonArray.toString());
+
+        assertEquals(4, result.size());
+        assertEquals(DelayUntilNext.background, result.get(0).getKind());
+        assertEquals("5000", result.get(0).getValue());
+        assertEquals(DelayUntilNext.kill, result.get(1).getKind());
+        assertEquals(DelayUntilNext.nativeVersion, result.get(2).getKind());
+        assertEquals(DelayUntilNext.date, result.get(3).getKind());
+    }
+
+    @Test
+    public void parseDelayConditions_skipsInvalidEntries() throws Exception {
+        JSONArray jsonArray = new JSONArray();
+        jsonArray.put(new JSONObject().put("kind", "unknown").put("value", "123"));
+        jsonArray.put(new JSONObject().put("value", "missingKind"));
+        jsonArray.put(new JSONObject().put("kind", "kill").put("value", ""));
+
+        ArrayList<DelayCondition> result = utils.parseDelayConditions(jsonArray.toString());
+
+        assertEquals(1, result.size());
+        assertEquals(DelayUntilNext.kill, result.get(0).getKind());
+    }
+
+    @Test
+    public void parseDelayConditions_handlesInvalidJsonSafely() {
+        ArrayList<DelayCondition> result = utils.parseDelayConditions("not-json");
+
+        assertTrue(result.isEmpty());
+        verify(logger).error(contains("Failed to parse delay conditions"));
+    }
+
+    @Test
+    public void checkCancelDelay_foregroundRemovesExpiredBackgroundCondition() throws Exception {
+        JSONArray stored = new JSONArray();
+        stored.put(new JSONObject().put("kind", "background").put("value", "1"));
+        stored.put(new JSONObject().put("kind", "kill").put("value", ""));
+        when(prefs.getString(eq(DelayUpdateUtils.DELAY_CONDITION_PREFERENCES), anyString())).thenReturn(stored.toString());
+
+        utils.checkCancelDelay(DelayUpdateUtils.CancelDelaySource.FOREGROUND);
+
+        ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
+        verify(editor).putString(eq(DelayUpdateUtils.DELAY_CONDITION_PREFERENCES), captor.capture());
+        verify(editor).commit();
+
+        JSONArray updated = new JSONArray(captor.getValue());
+        assertEquals(1, updated.length());
+        JSONObject remaining = updated.getJSONObject(0);
+        assertEquals("kill", remaining.getString("kind"));
+    }
+
+    @Test
+    public void checkCancelDelay_killedClearsDelaysWithoutInstalling() throws Exception {
+        JSONArray stored = new JSONArray();
+        stored.put(new JSONObject().put("kind", "kill").put("value", ""));
+        when(prefs.getString(eq(DelayUpdateUtils.DELAY_CONDITION_PREFERENCES), anyString())).thenReturn(stored.toString());
+
+        utils.checkCancelDelay(DelayUpdateUtils.CancelDelaySource.KILLED);
+
+        verify(editor).remove(eq(DelayUpdateUtils.DELAY_CONDITION_PREFERENCES));
+        verify(editor).commit();
+        verify(editor, never()).putString(eq(DelayUpdateUtils.DELAY_CONDITION_PREFERENCES), anyString());
+    }
+
+    @Test
+    public void checkCancelDelay_killedKeepsOtherConditions() throws Exception {
+        JSONArray stored = new JSONArray();
+        stored.put(new JSONObject().put("kind", "kill").put("value", ""));
+        stored.put(new JSONObject().put("kind", "background").put("value", "5000"));
+        when(prefs.getString(eq(DelayUpdateUtils.DELAY_CONDITION_PREFERENCES), anyString())).thenReturn(stored.toString());
+
+        utils.checkCancelDelay(DelayUpdateUtils.CancelDelaySource.KILLED);
+
+        ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
+        verify(editor).putString(eq(DelayUpdateUtils.DELAY_CONDITION_PREFERENCES), captor.capture());
+        verify(editor).commit();
+        verify(editor, never()).remove(eq(DelayUpdateUtils.DELAY_CONDITION_PREFERENCES));
+
+        JSONArray updated = new JSONArray(captor.getValue());
+        assertEquals(1, updated.length());
+        JSONObject remaining = updated.getJSONObject(0);
+        assertEquals("background", remaining.getString("kind"));
+        assertEquals("5000", remaining.getString("value"));
+    }
+
+    @Test
+    public void checkCancelDelay_foregroundKeepsIsoDateWithoutMilliseconds() throws Exception {
+        JSONArray stored = new JSONArray();
+        stored.put(new JSONObject().put("kind", "date").put("value", "2099-12-31T23:59:59Z"));
+        when(prefs.getString(eq(DelayUpdateUtils.DELAY_CONDITION_PREFERENCES), anyString())).thenReturn(stored.toString());
+
+        utils.checkCancelDelay(DelayUpdateUtils.CancelDelaySource.FOREGROUND);
+
+        ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
+        verify(editor).putString(eq(DelayUpdateUtils.DELAY_CONDITION_PREFERENCES), captor.capture());
+        verify(editor).commit();
+        verify(editor, never()).remove(eq(DelayUpdateUtils.DELAY_CONDITION_PREFERENCES));
+
+        JSONArray updated = new JSONArray(captor.getValue());
+        assertEquals(1, updated.length());
+        JSONObject remaining = updated.getJSONObject(0);
+        assertEquals("date", remaining.getString("kind"));
+        assertEquals("2099-12-31T23:59:59Z", remaining.getString("value"));
+    }
+
+    @Test
+    public void checkCancelDelay_foregroundKeepsIsoDateWithCompactOffset() throws Exception {
+        JSONArray stored = new JSONArray();
+        stored.put(new JSONObject().put("kind", "date").put("value", "2099-12-31T23:59:59+0000"));
+        when(prefs.getString(eq(DelayUpdateUtils.DELAY_CONDITION_PREFERENCES), anyString())).thenReturn(stored.toString());
+
+        utils.checkCancelDelay(DelayUpdateUtils.CancelDelaySource.FOREGROUND);
+
+        ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
+        verify(editor).putString(eq(DelayUpdateUtils.DELAY_CONDITION_PREFERENCES), captor.capture());
+        verify(editor).commit();
+        verify(editor, never()).remove(eq(DelayUpdateUtils.DELAY_CONDITION_PREFERENCES));
+
+        JSONArray updated = new JSONArray(captor.getValue());
+        assertEquals(1, updated.length());
+        JSONObject remaining = updated.getJSONObject(0);
+        assertEquals("date", remaining.getString("kind"));
+        assertEquals("2099-12-31T23:59:59+0000", remaining.getString("value"));
+    }
+}

package/src/android/test/app/capgo/cordova/updater/NativeContractTest.java

@@ -0,0 +1,105 @@
+package app.capgo.cordova.updater;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import org.json.JSONArray;
+import org.json.JSONObject;
+import org.junit.Test;
+
+public class NativeContractTest {
+
+    private static JSONObject contract() {
+        try {
+            return new JSONObject(new String(Files.readAllBytes(contractFile()), StandardCharsets.UTF_8));
+        } catch (Exception error) {
+            throw new AssertionError("Unable to load native contract fixture", error);
+        }
+    }
+
+    private static Path contractFile() throws IOException {
+        Path current = Path.of(System.getProperty("user.dir")).toAbsolutePath();
+        while (current != null) {
+            Path candidate = current.resolve("native-contract-tests/core.json");
+            if (Files.exists(candidate)) {
+                return candidate;
+            }
+            current = current.getParent();
+        }
+        throw new IOException("native-contract-tests/core.json not found");
+    }
+
+    private static String nullableString(final JSONObject object, final String key) throws Exception {
+        if (!object.has(key) || object.isNull(key)) {
+            return null;
+        }
+        return object.getString(key);
+    }
+
+    @Test
+    public void periodCheckDelayMatchesNativeContract() throws Exception {
+        JSONArray cases = contract().getJSONArray("periodCheckDelay");
+        for (int index = 0; index < cases.length(); index++) {
+            JSONObject testCase = cases.getJSONObject(index);
+            String id = testCase.getString("id");
+            int seconds = testCase.getJSONObject("input").getInt("seconds");
+            int expected = testCase.getJSONObject("expect").getInt("normalizedSeconds");
+
+            assertEquals(id, expected, CordovaUpdaterPlugin.normalizedPeriodCheckDelaySeconds(seconds));
+        }
+    }
+
+    @Test
+    public void autoUpdateModeMatchesNativeContract() throws Exception {
+        JSONArray cases = contract().getJSONArray("autoUpdateMode");
+        for (int index = 0; index < cases.length(); index++) {
+            JSONObject testCase = cases.getJSONObject(index);
+            String id = testCase.getString("id");
+            String mode = testCase.getJSONObject("input").getString("mode");
+            JSONObject expect = testCase.getJSONObject("expect");
+            String normalizedMode = CordovaUpdaterPlugin.normalizedAutoUpdateMode(mode);
+
+            assertEquals(id, expect.getString("mode"), normalizedMode);
+            assertEquals(id, expect.getBoolean("enabled"), CordovaUpdaterPlugin.isAutoUpdateModeEnabled(normalizedMode));
+            assertEquals(
+                id,
+                expect.getString("directUpdateMode"),
+                CordovaUpdaterPlugin.directUpdateModeForAutoUpdateMode(normalizedMode)
+            );
+            assertEquals(id, expect.getBoolean("setNextBundle"), CordovaUpdaterPlugin.shouldAutoUpdateModeSetNextBundle(normalizedMode));
+        }
+    }
+
+    @Test
+    public void onLaunchDirectUpdateConsumptionMatchesNativeContract() throws Exception {
+        JSONArray cases = contract().getJSONArray("onLaunchDirectUpdateConsumption");
+        for (int index = 0; index < cases.length(); index++) {
+            JSONObject testCase = cases.getJSONObject(index);
+            String id = testCase.getString("id");
+            JSONObject input = testCase.getJSONObject("input");
+            boolean expected = testCase.getJSONObject("expect").getBoolean("consume");
+
+            assertEquals(
+                id,
+                expected,
+                CordovaUpdaterPlugin.shouldConsumeOnLaunchDirectUpdate(input.getString("mode"), input.getBoolean("plannedDirectUpdate"))
+            );
+        }
+    }
+
+    @Test
+    public void updateResponseKindMatchesNativeContract() throws Exception {
+        JSONArray cases = contract().getJSONArray("updateResponseKind");
+        for (int index = 0; index < cases.length(); index++) {
+            JSONObject testCase = cases.getJSONObject(index);
+            String id = testCase.getString("id");
+            String kind = nullableString(testCase.getJSONObject("input"), "kind");
+            String expected = testCase.getJSONObject("expect").getString("kind");
+
+            assertEquals(id, expected, CordovaUpdaterPlugin.normalizedUpdateResponseKind(kind));
+        }
+    }
+}

package/src/ios/AES.swift

@@ -0,0 +1,216 @@
+import Foundation
+import CommonCrypto
+import CryptoKit
+import Darwin
+
+///
+/// Constants
+///
+private enum AESConstants {
+    static let aesAlgorithm: CCAlgorithm = CCAlgorithm(kCCAlgorithmAES)
+    static let aesOptions: CCOptions = CCOptions(kCCOptionPKCS7Padding)
+}
+
+// We do all this stuff because ios is shit and open source libraries allow to do decryption with public key
+// So we have to do it manually, while in nodejs or Java it's ok and done at language level.
+
+///
+/// The AES key. Contains both the initialization vector and secret key.
+///
+public struct AES128Key {
+    /// Initialization vector
+    private let initVector: Data
+    private let logger: Logger
+    private let aes128Key: Data
+    #if DEBUG
+    // swiftlint:disable:next identifier_name
+    public var __debug_iv: Data { initVector }
+    // swiftlint:disable:next identifier_name
+    public var __debug_aes128Key: Data { aes128Key }
+    #endif
+    // swiftlint:disable:next identifier_name
+    init(iv: Data, aes128Key: Data, logger: Logger) {
+        self.initVector = iv
+        self.aes128Key = aes128Key
+        self.logger = logger
+    }
+    ///
+    /// Takes the data and uses the private key to decrypt it. Will call `CCCrypt` in CommonCrypto
+    /// and provide it `ivData` for the initialization vector. Will use cipher block chaining (CBC) as
+    /// the mode of operation.
+    ///
+    /// Returns the decrypted data.
+    ///
+    public func decrypt(data: Data) -> Data? {
+        let encryptedData: UnsafePointer<UInt8> = (data as NSData).bytes.bindMemory(
+            to: UInt8.self, capacity: data.count)
+        let encryptedDataLength: Int = data.count
+
+        if let result: NSMutableData = NSMutableData(length: encryptedDataLength) {
+            let keyData: UnsafePointer<UInt8> = (self.aes128Key as NSData).bytes.bindMemory(
+                to: UInt8.self, capacity: self.aes128Key.count)
+            let keyLength: size_t = size_t(self.aes128Key.count)
+            let ivData: UnsafePointer<UInt8> = (initVector as NSData).bytes.bindMemory(
+                to: UInt8.self, capacity: self.initVector.count)
+
+            let decryptedData: UnsafeMutablePointer<UInt8> = UnsafeMutablePointer<UInt8>(
+                result.mutableBytes.assumingMemoryBound(to: UInt8.self))
+            let decryptedDataLength: size_t = size_t(result.length)
+
+            var decryptedLength: size_t = 0
+
+            let status: CCCryptorStatus = CCCrypt(
+                CCOperation(kCCDecrypt),
+                AESConstants.aesAlgorithm,
+                AESConstants.aesOptions,
+                keyData,
+                keyLength,
+                ivData,
+                encryptedData,
+                encryptedDataLength,
+                decryptedData,
+                decryptedDataLength,
+                &decryptedLength)
+
+            if Int32(status) == Int32(kCCSuccess) {
+                result.length = Int(decryptedLength)
+                return result as Data
+            } else {
+                logger.error("AES decryption failed with status: \(status)")
+                return nil
+            }
+        } else {
+            logger.error("Failed to allocate memory for AES decryption")
+            return nil
+        }
+    }
+
+    /// AES-CBC file-to-file. Never holds the whole ciphertext in RAM.
+    func decrypt(from source: URL, to destination: URL) throws {
+        var cryptor: CCCryptorRef?
+        let createStatus: CCCryptorStatus = aes128Key.withUnsafeBytes { keyBytes in
+            initVector.withUnsafeBytes { ivBytes in
+                guard let keyPtr = keyBytes.baseAddress, let ivPtr = ivBytes.baseAddress else {
+                    return CCCryptorStatus(kCCParamError)
+                }
+                return CCCryptorCreate(
+                    CCOperation(kCCDecrypt),
+                    AESConstants.aesAlgorithm,
+                    AESConstants.aesOptions,
+                    keyPtr,
+                    keyBytes.count,
+                    ivPtr,
+                    &cryptor
+                )
+            }
+        }
+        guard createStatus == kCCSuccess, let cryptor else {
+            logger.error("Failed to create AES cryptor")
+            throw NSError(domain: "AESDecryptError", code: Int(createStatus), userInfo: nil)
+        }
+        defer {
+            CCCryptorRelease(cryptor)
+        }
+
+        guard let input = InputStream(url: source) else {
+            throw NSError(domain: "AESDecryptError", code: 1, userInfo: [NSLocalizedDescriptionKey: "Failed to open AES source"])
+        }
+        input.open()
+        defer {
+            input.close()
+        }
+
+        let tempURL = destination.deletingLastPathComponent().appendingPathComponent("capgo-aes-\(UUID().uuidString).tmp")
+        let fileManager = FileManager.default
+        fileManager.createFile(atPath: tempURL.path, contents: nil)
+        let output = try FileHandle(forWritingTo: tempURL)
+        defer {
+            try? output.close()
+            try? fileManager.removeItem(at: tempURL)
+        }
+
+        let bufferSize = CryptoCipher.ioBufferBytes()
+        let outBufSize = bufferSize + kCCBlockSizeAES128
+        var inBuf = [UInt8](repeating: 0, count: bufferSize)
+        var outBuf = [UInt8](repeating: 0, count: outBufSize)
+        let outFd = output.fileDescriptor
+
+        while true {
+            let n = inBuf.withUnsafeMutableBufferPointer { ptr in
+                input.read(ptr.baseAddress!, maxLength: ptr.count)
+            }
+            if n == 0 {
+                break
+            }
+            if n < 0 {
+                throw input.streamError ?? NSError(domain: "AESDecryptError", code: 2, userInfo: [NSLocalizedDescriptionKey: "AES stream read failed"])
+            }
+            var moved: size_t = 0
+            let status: CCCryptorStatus = inBuf.withUnsafeBufferPointer { inRaw in
+                outBuf.withUnsafeMutableBytes { outRaw in
+                    CCCryptorUpdate(
+                        cryptor,
+                        inRaw.baseAddress,
+                        n,
+                        outRaw.baseAddress,
+                        outBufSize,
+                        &moved
+                    )
+                }
+            }
+            guard status == kCCSuccess else {
+                logger.error("AES stream update failed")
+                throw NSError(domain: "AESDecryptError", code: Int(status), userInfo: nil)
+            }
+            if moved > 0 {
+                try Self.writeAll(fd: outFd, buffer: &outBuf, count: moved)
+            }
+        }
+
+        var moved: size_t = 0
+        let finalStatus: CCCryptorStatus = outBuf.withUnsafeMutableBytes { outRaw in
+            CCCryptorFinal(cryptor, outRaw.baseAddress, outBufSize, &moved)
+        }
+        guard finalStatus == kCCSuccess else {
+            logger.error("AES stream finalize failed")
+            throw NSError(domain: "AESDecryptError", code: Int(finalStatus), userInfo: nil)
+        }
+        if moved > 0 {
+            try Self.writeAll(fd: outFd, buffer: &outBuf, count: moved)
+        }
+        try output.close()
+
+        let decryptedSize = (try fileManager.attributesOfItem(atPath: tempURL.path)[.size] as? NSNumber)?.uint64Value ?? 0
+        if decryptedSize == 0 {
+            throw NSError(domain: "Empty decrypted data", code: 7, userInfo: nil)
+        }
+
+        do {
+            _ = try fileManager.replaceItemAt(destination, withItemAt: tempURL)
+        } catch {
+            if fileManager.fileExists(atPath: destination.path) {
+                throw error
+            }
+            try fileManager.moveItem(at: tempURL, to: destination)
+        }
+    }
+
+    private static func writeAll(fd: Int32, buffer: inout [UInt8], count: Int) throws {
+        var offset = 0
+        while offset < count {
+            let written = buffer.withUnsafeBufferPointer { ptr -> Int in
+                Darwin.write(fd, ptr.baseAddress!.advanced(by: offset), count - offset)
+            }
+            if written < 0 {
+                if errno == EINTR {
+                    continue
+                }
+                throw NSError(domain: NSPOSIXErrorDomain, code: Int(errno), userInfo: [NSLocalizedDescriptionKey: "AES stream write failed"])
+            }
+            if written == 0 {
+                throw NSError(domain: NSPOSIXErrorDomain, code: Int(EIO), userInfo: [NSLocalizedDescriptionKey: "AES stream write failed"])
+            }
+            offset += written
+        }
+    }
+}

package/src/ios/AppHealthTracker.swift

@@ -0,0 +1,82 @@
+import Foundation
+
+final class AppHealthTracker {
+    private let appSessionIdDefaultsKey = "CapacitorUpdater.appSessionId"
+    private let appSessionForegroundDefaultsKey = "CapacitorUpdater.appSessionForeground"
+    private let appSessionStartedAtDefaultsKey = "CapacitorUpdater.appSessionStartedAt"
+    private let lastReportedUncleanSessionDefaultsKey = "CapacitorUpdater.lastReportedUncleanSessionId"
+
+    private let implementation: CapgoUpdater
+
+    init(implementation: CapgoUpdater) {
+        self.implementation = implementation
+    }
+
+    static func shouldReportUncleanForegroundExit(
+        previousSessionId: String?,
+        lastReportedSessionId: String?,
+        wasForeground: Bool
+    ) -> Bool {
+        guard wasForeground, let previousSessionId, !previousSessionId.isEmpty else {
+            return false
+        }
+        return previousSessionId != lastReportedSessionId
+    }
+
+    func reportPreviousUncleanForegroundExit() {
+        let defaults = UserDefaults.standard
+        let previousSessionId = defaults.string(forKey: appSessionIdDefaultsKey)
+        let lastReportedSessionId = defaults.string(forKey: lastReportedUncleanSessionDefaultsKey)
+        let wasForeground = defaults.bool(forKey: appSessionForegroundDefaultsKey)
+
+        guard Self.shouldReportUncleanForegroundExit(
+            previousSessionId: previousSessionId,
+            lastReportedSessionId: lastReportedSessionId,
+            wasForeground: wasForeground
+        ), let previousSessionId else {
+            return
+        }
+
+        var metadata = [
+            "exit_reason": "unclean_foreground_exit",
+            "exit_source": "ios_session_marker",
+            "previous_session_id": previousSessionId
+        ]
+        if let sessionStartedAt = defaults.string(forKey: appSessionStartedAtDefaultsKey), !sessionStartedAt.isEmpty {
+            metadata["session_started_at"] = sessionStartedAt
+        }
+
+        let current = implementation.getCurrentBundle()
+        implementation.sendStats(
+            action: "app_crash",
+            versionName: current.getVersionName(),
+            oldVersionName: "",
+            metadata: metadata
+        )
+        defaults.set(previousSessionId, forKey: lastReportedUncleanSessionDefaultsKey)
+        defaults.synchronize()
+    }
+
+    func startSession() {
+        let defaults = UserDefaults.standard
+        defaults.set(UUID().uuidString, forKey: appSessionIdDefaultsKey)
+        defaults.set(true, forKey: appSessionForegroundDefaultsKey)
+        defaults.set(String(Int64(Date().timeIntervalSince1970 * 1000)), forKey: appSessionStartedAtDefaultsKey)
+        defaults.synchronize()
+    }
+
+    func markForeground(_ isForeground: Bool) {
+        UserDefaults.standard.set(isForeground, forKey: appSessionForegroundDefaultsKey)
+        UserDefaults.standard.synchronize()
+    }
+
+    func reportMemoryWarning() {
+        let current = implementation.getCurrentBundle()
+        implementation.sendStats(
+            action: "app_memory_warning",
+            versionName: current.getVersionName(),
+            oldVersionName: "",
+            metadata: ["source": "ios_memory_warning"]
+        )
+    }
+}