@amplitude/analytics-react-native 1.3.3 → 1.3.4

package/android/src/main/java/com/amplitude/reactnative/AmplitudeReactNativeModule.kt

@@ -6,12 +6,20 @@ import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactContextBaseJavaModule
 import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableNativeArray
 import com.facebook.react.bridge.WritableNativeMap
 
 const val MODULE_NAME = "AmplitudeReactNative"
 
 @ReactModule(name = MODULE_NAME)
 class AmplitudeReactNativeModule(private val reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
+    companion object {
+        const val DEVICE_ID_KEY = "device_id"
+        const val USER_ID_KEY = "user_id"
+        const val LAST_EVENT_TIME_KEY = "last_event_time"
+        const val LAST_EVENT_ID_KEY = "last_event_id"
+        const val PREVIOUS_SESSION_ID_KEY = "previous_session_id"
+    }
 
     private var androidContextProvider: AndroidContextProvider? = null
 
@@ -42,4 +50,97 @@ class AmplitudeReactNativeModule(private val reactContext: ReactApplicationConte
             putString("appSetId", androidContextProvider!!.appSetId)
         })
     }
+
+    @ReactMethod
+    private fun getLegacySessionData(instanceName: String?, promise: Promise) {
+        try {
+            val storage = LegacyDatabaseStorageProvider.getStorage(reactContext.applicationContext, instanceName)
+            val deviceId = getLegacyValue(storage, DEVICE_ID_KEY)
+            val userId = getLegacyValue(storage, USER_ID_KEY)
+            val previousSessionId = getLegacyLongValue(storage, PREVIOUS_SESSION_ID_KEY)
+            val lastEventTime = getLegacyLongValue(storage, LAST_EVENT_TIME_KEY)
+            val lastEventId = getLegacyLongValue(storage, LAST_EVENT_ID_KEY)
+            promise.resolve(WritableNativeMap().apply {
+                if (deviceId != null) {
+                    putString("deviceId", deviceId)
+                }
+                if (userId != null) {
+                    putString("userId", userId)
+                }
+                if (previousSessionId != null) {
+                    putDouble("sessionId", previousSessionId.toDouble())
+                }
+                if (lastEventTime != null) {
+                    putDouble("lastEventTime", lastEventTime.toDouble())
+                }
+                if (lastEventId != null) {
+                    putDouble("lastEventId", lastEventId.toDouble())
+                }
+            })
+        } catch (e: Exception) {
+            LogcatLogger.logger.error(
+                "can't get legacy session data: $e"
+            )
+        }
+    }
+
+    private fun getLegacyValue(storage: LegacyDatabaseStorage, key: String): String? {
+        try {
+            return storage.getValue(key)
+        } catch (e: Exception) {
+            LogcatLogger.logger.error(
+                "can't get legacy $key: $e"
+            )
+            return null
+        }
+    }
+
+    private fun getLegacyLongValue(storage: LegacyDatabaseStorage, key: String): Long? {
+        try {
+            return storage.getLongValue(key)
+        } catch (e: Exception) {
+            LogcatLogger.logger.error(
+                "can't get legacy $key: $e"
+            )
+            return null
+        }
+    }
+
+    @ReactMethod
+    private fun getLegacyEvents(instanceName: String?, eventKind: String, promise: Promise) {
+        try {
+            val storage = LegacyDatabaseStorageProvider.getStorage(reactContext.applicationContext, instanceName)
+            val jsonEvents = when (eventKind) {
+                "event" -> storage.readEvents()
+                "identify" -> storage.readIdentifies()
+                "interceptedIdentify" -> storage.readInterceptedIdentifies()
+                else -> listOf()
+            }
+
+            val events = WritableNativeArray()
+            jsonEvents.forEach { event -> events.pushString(event.toString()) }
+            promise.resolve(events)
+        } catch (e: Exception) {
+            LogcatLogger.logger.error(
+                "can't get legacy ${eventKind}s: $e"
+            )
+            promise.resolve(WritableNativeArray())
+        }
+    }
+
+    @ReactMethod
+    private fun removeLegacyEvent(instanceName: String?, eventKind: String, eventId: Int) {
+        try {
+            val storage = LegacyDatabaseStorageProvider.getStorage(reactContext.applicationContext, instanceName)
+            when (eventKind) {
+                "event" -> storage.removeEvent(eventId)
+                "identify" -> storage.removeIdentify(eventId)
+                "interceptedIdentify" -> storage.removeInterceptedIdentify(eventId)
+            }
+        } catch (e: Exception) {
+            LogcatLogger.logger.error(
+                "can't remove legacy $eventKind with id=$eventId: $e"
+            )
+        }
+    }
 }

package/android/src/main/java/com/amplitude/reactnative/LegacyDatabaseStorage.kt

@@ -0,0 +1,313 @@
+package com.amplitude.reactnative
+
+import android.content.Context
+import android.database.Cursor
+import android.database.sqlite.SQLiteDatabase
+import android.database.sqlite.SQLiteException
+import android.database.sqlite.SQLiteOpenHelper
+import org.json.JSONObject
+import java.io.File
+import java.util.LinkedList
+import java.util.Locale
+
+/**
+ * Store the database related constants.
+ * Align with com/amplitude/api/DatabaseHelper.java in previous SDK.
+ */
+object DatabaseConstants {
+    const val DEFAULT_INSTANCE = "\$default_instance"
+    const val DATABASE_NAME = "com.amplitude.api"
+    const val DATABASE_VERSION = 4
+
+    const val EVENT_TABLE_NAME = "events"
+    const val IDENTIFY_TABLE_NAME = "identifys"
+    const val IDENTIFY_INTERCEPTOR_TABLE_NAME = "identify_interceptor"
+    const val ID_FIELD = "id"
+    const val EVENT_FIELD = "event"
+
+    const val LONG_STORE_TABLE_NAME = "long_store"
+    const val STORE_TABLE_NAME = "store"
+    const val KEY_FIELD = "key"
+    const val VALUE_FIELD = "value"
+}
+
+/**
+ * The SDK doesn't need to write/read from local sqlite database.
+ * This storage class is used for migrating events only.
+ */
+class LegacyDatabaseStorage(context: Context, databaseName: String) : SQLiteOpenHelper(
+    context,
+    databaseName,
+    null,
+    DatabaseConstants.DATABASE_VERSION
+) {
+    private var file: File = context.getDatabasePath(databaseName)
+    var currentDbVersion: Int = DatabaseConstants.DATABASE_VERSION
+        private set
+
+    override fun onCreate(db: SQLiteDatabase) {
+        throw NotImplementedError()
+    }
+
+    override fun onUpgrade(db: SQLiteDatabase?, oldVersion: Int, newVersion: Int) {
+        currentDbVersion = oldVersion
+    }
+
+    private fun queryDb(
+        db: SQLiteDatabase,
+        table: String?,
+        columns: Array<String?>?,
+        selection: String?,
+        selectionArgs: Array<String?>?,
+        orderBy: String?,
+    ): Cursor? {
+        return db.query(table, columns, selection, selectionArgs, null, null, orderBy, null)
+    }
+
+    private fun handleIfCursorRowTooLargeException(e: java.lang.IllegalStateException) {
+        val message = e.message
+        if (!message.isNullOrEmpty() && message.contains("Couldn't read") && message.contains("CursorWindow")) {
+            closeDb()
+        } else {
+            throw e
+        }
+    }
+
+    private fun convertIfCursorWindowException(e: java.lang.RuntimeException) {
+        val message = e.message
+        if (!message.isNullOrEmpty() && (message.startsWith("Cursor window allocation of") || message.startsWith("Could not allocate CursorWindow"))) {
+            throw CursorWindowAllocationException(message)
+        } else {
+            throw e
+        }
+    }
+
+    private fun closeDb() {
+        try {
+            close()
+        } catch (e: Exception) {
+            LogcatLogger.logger.error("close failed: ${e.message}")
+        }
+    }
+
+    @Synchronized
+    fun readEvents(): List<JSONObject> {
+        return readEventsFromTable(DatabaseConstants.EVENT_TABLE_NAME)
+    }
+
+    @Synchronized
+    fun readIdentifies(): List<JSONObject> {
+        return readEventsFromTable(DatabaseConstants.IDENTIFY_TABLE_NAME)
+    }
+
+    @Synchronized
+    fun readInterceptedIdentifies(): List<JSONObject> {
+        if (currentDbVersion < 4) {
+            return listOf()
+        }
+        return readEventsFromTable(DatabaseConstants.IDENTIFY_INTERCEPTOR_TABLE_NAME)
+    }
+
+    private fun readEventsFromTable(table: String): List<JSONObject> {
+        if (!file.exists()) {
+            return arrayListOf()
+        }
+
+        val events: MutableList<JSONObject> = LinkedList()
+        var cursor: Cursor? = null
+        try {
+            val db = readableDatabase
+            cursor = queryDb(
+                db,
+                table,
+                arrayOf(DatabaseConstants.ID_FIELD, DatabaseConstants.EVENT_FIELD),
+                null,
+                null,
+                DatabaseConstants.ID_FIELD + " ASC",
+            )
+            while (cursor!!.moveToNext()) {
+                val eventId = cursor.getLong(0)
+                val event = cursor.getString(1)
+                if (event.isNullOrEmpty()) {
+                    continue
+                }
+                val obj = JSONObject(event)
+                obj.put("event_id", eventId)
+                events.add(obj)
+            }
+        } catch (e: SQLiteException) {
+            LogcatLogger.logger.error(
+                "read events from $table failed: ${e.message}"
+            )
+            closeDb()
+        } catch (e: StackOverflowError) {
+            LogcatLogger.logger.error(
+                "read events from $table failed: ${e.message}"
+            )
+            closeDb()
+        } catch (e: IllegalStateException) { // put before Runtime since IllegalState extends
+            handleIfCursorRowTooLargeException(e)
+        } catch (e: RuntimeException) {
+            convertIfCursorWindowException(e)
+        } finally {
+            cursor?.close()
+            close()
+        }
+        return events
+    }
+
+    @Synchronized
+    fun removeEvent(eventId: Int) {
+        removeEventFromTable(DatabaseConstants.EVENT_TABLE_NAME, eventId)
+    }
+
+    @Synchronized
+    fun removeIdentify(eventId: Int) {
+        removeEventFromTable(DatabaseConstants.IDENTIFY_TABLE_NAME, eventId)
+    }
+
+    @Synchronized
+    fun removeInterceptedIdentify(eventId: Int) {
+        if (currentDbVersion < 4) {
+            return
+        }
+        removeEventFromTable(DatabaseConstants.IDENTIFY_INTERCEPTOR_TABLE_NAME, eventId)
+    }
+
+    private fun removeEventFromTable(table: String, eventId: Int) {
+        try {
+            val db = writableDatabase
+            db.delete(
+                table,
+                "${DatabaseConstants.ID_FIELD} = ?",
+                arrayOf(eventId.toString())
+            )
+        } catch (e: SQLiteException) {
+            LogcatLogger.logger.error(
+                "remove events from $table failed: ${e.message}"
+            )
+            closeDb()
+        } catch (e: StackOverflowError) {
+            LogcatLogger.logger.error(
+                "remove events from $table failed: ${e.message}"
+            )
+            closeDb()
+        } finally {
+            close()
+        }
+    }
+
+    @Synchronized
+    fun getValue(key: String): String? {
+        return getValueFromTable(DatabaseConstants.STORE_TABLE_NAME, key) as String?
+    }
+
+    @Synchronized
+    fun getLongValue(key: String): Long? {
+        return getValueFromTable(DatabaseConstants.LONG_STORE_TABLE_NAME, key) as Long?
+    }
+
+    private fun getValueFromTable(table: String, key: String): Any? {
+        if (!file.exists()) {
+            return null
+        }
+
+        var value: Any? = null
+        var cursor: Cursor? = null
+        try {
+            val db = readableDatabase
+            cursor = queryDb(
+                db,
+                table,
+                arrayOf<String?>(
+                    DatabaseConstants.KEY_FIELD,
+                    DatabaseConstants.VALUE_FIELD
+                ),
+                DatabaseConstants.KEY_FIELD + " = ?",
+                arrayOf(key),
+                null,
+            )
+            if (cursor!!.moveToFirst()) {
+                value = if (table == DatabaseConstants.STORE_TABLE_NAME) cursor.getString(1) else cursor.getLong(1)
+            }
+        } catch (e: SQLiteException) {
+            LogcatLogger.logger.error(
+                "getValue from $table failed: ${e.message}"
+            )
+            // Hard to recover from SQLiteExceptions, just start fresh
+            closeDb()
+        } catch (e: StackOverflowError) {
+            LogcatLogger.logger.error(
+                "getValue from $table failed: ${e.message}"
+            )
+            // potential stack overflow error when getting database on custom Android versions
+            closeDb()
+        } catch (e: IllegalStateException) { // put before Runtime since IllegalState extends
+            // cursor window row too big exception
+            handleIfCursorRowTooLargeException(e)
+        } catch (e: RuntimeException) {
+            // cursor window allocation exception
+            convertIfCursorWindowException(e)
+        } finally {
+            cursor?.close()
+            close()
+        }
+        return value
+    }
+
+    @Synchronized
+    fun removeValue(key: String) {
+        removeValueFromTable(DatabaseConstants.STORE_TABLE_NAME, key)
+    }
+
+    @Synchronized
+    fun removeLongValue(key: String) {
+        removeValueFromTable(DatabaseConstants.LONG_STORE_TABLE_NAME, key)
+    }
+
+    private fun removeValueFromTable(table: String, key: String) {
+        try {
+            val db = writableDatabase
+            db.delete(
+                table,
+                "${DatabaseConstants.KEY_FIELD} = ?",
+                arrayOf(key)
+            )
+        } catch (e: SQLiteException) {
+            LogcatLogger.logger.error(
+                "remove value from $table failed: ${e.message}"
+            )
+            closeDb()
+        } catch (e: StackOverflowError) {
+            LogcatLogger.logger.error(
+                "remove value from $table failed: ${e.message}"
+            )
+            closeDb()
+        } finally {
+            close()
+        }
+    }
+}
+
+class CursorWindowAllocationException(description: String?) :
+    java.lang.RuntimeException(description)
+
+object LegacyDatabaseStorageProvider {
+    private val instances: MutableMap<String, LegacyDatabaseStorage> = mutableMapOf()
+
+    fun getStorage(context: Context, instanceName: String?): LegacyDatabaseStorage {
+        val databaseName = getDatabaseName(instanceName)
+        var storage = instances[databaseName]
+        if (storage == null) {
+            storage = LegacyDatabaseStorage(context, databaseName)
+            instances[databaseName] = storage
+        }
+
+        return storage
+    }
+
+    private fun getDatabaseName(instanceName: String?): String {
+        val normalizedInstanceName = instanceName?.lowercase(Locale.getDefault())
+        return if (normalizedInstanceName.isNullOrEmpty() || normalizedInstanceName == DatabaseConstants.DEFAULT_INSTANCE) DatabaseConstants.DATABASE_NAME else "${DatabaseConstants.DATABASE_NAME}_$normalizedInstanceName"
+    }
+}

package/ios/AmplitudeReactNative.m

@@ -3,5 +3,8 @@
 @interface RCT_EXTERN_MODULE(AmplitudeReactNative, NSObject)
 
 RCT_EXTERN_METHOD(getApplicationContext: (NSDictionary*)options resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(getLegacySessionData: (NSString*)instanceName resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(getLegacyEvents: (NSString*)instanceName eventKind:(NSString*)eventKind resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(removeLegacyEvent: (NSString*)instanceName eventKind:(NSString*)eventKind eventId:(double)eventId)
 
 @end

package/ios/AmplitudeReactNative.swift

@@ -33,4 +33,78 @@ class ReactNative: NSObject {
         }
         resolve(applicationContext)
     }
+
+    @objc
+    func getLegacySessionData(
+        _ instanceName: String?,
+        resolver resolve: RCTPromiseResolveBlock,
+        rejecter reject: RCTPromiseRejectBlock
+    ) -> Void {
+        let storage = LegacyDatabaseStorage.getStorage(instanceName)
+        var sessionData: [String: Any?] = [:]
+
+        if let deviceId = storage.getValue("device_id") {
+            sessionData["deviceId"] = deviceId
+        }
+        if let userId = storage.getValue("user_id") {
+            sessionData["userId"] = userId
+        }
+        if let previousSessionId = storage.getLongValue("previous_session_id") {
+            sessionData["sessionId"] = previousSessionId
+        }
+        if let lastEventTime = storage.getLongValue("previous_session_time") {
+            sessionData["lastEventTime"] = lastEventTime
+        }
+        if let lastEventId = storage.getLastEventId() {
+            sessionData["lastEventId"] = lastEventId
+        }
+        resolve(sessionData)
+    }
+
+    @objc
+    func getLegacyEvents(
+        _ instanceName: String?,
+        eventKind: String,
+        resolver resolve: RCTPromiseResolveBlock,
+        rejecter reject: RCTPromiseRejectBlock
+    ) -> Void {
+        let storage = LegacyDatabaseStorage.getStorage(instanceName)
+        var events: [[String: Any]] = []
+        switch eventKind {
+        case "event":
+            events = storage.readEvents()
+        case "identify":
+            events = storage.readIdentifies()
+        case "interceptedIdentify":
+            events = storage.readInterceptedIdentifies()
+        default:
+            break
+        }
+        var jsonEvents: [String] = []
+        events.forEach { event in
+            if let jsonEvent = try? JSONSerialization.data(withJSONObject: event) {
+                jsonEvents.append(String(decoding: jsonEvent, as: UTF8.self))
+            }
+        }
+        resolve(jsonEvents)
+    }
+
+    @objc
+    func removeLegacyEvent(
+        _ instanceName: String?,
+        eventKind: String,
+        eventId: Double
+    ) -> Void {
+        let storage = LegacyDatabaseStorage.getStorage(instanceName)
+        switch eventKind {
+        case "event":
+            storage.removeEvent(Int64(eventId))
+        case "identify":
+            storage.removeIdentify(Int64(eventId))
+        case "interceptedIdentify":
+            storage.removeInterceptedIdentify(Int64(eventId))
+        default:
+            break
+        }
+    }
 }

package/ios/AmplitudeReactNative.xcodeproj/project.pbxproj

@@ -7,10 +7,9 @@
 	objects = {
 
 /* Begin PBXBuildFile section */
-
-		5E555C0D2413F4C50049A1A2 /* AmplitudeReactNative.m in Sources */ = {isa = PBXBuildFile; fileRef = B3E7B5891CC2AC0600A0062D /* AmplitudeReactNative.m */; };
-		F4FF95D7245B92E800C19C63 /*  AmplitudeReactNative.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4FF95D6245B92E800C19C63 /*  AmplitudeReactNative.swift */; };
-
+		5E555C0D2413F4C50049A1A2 /* PBXBuildFile */ = {isa = PBXBuildFile; fileRef = B3E7B5891CC2AC0600A0062D /* AmplitudeReactNative.m */; };
+		8EDEC1ED2DCD14B370FA86F1 /* LegacyDatabaseStorage.swift in Sources */ = {isa = PBXBuildFile; fileRef = 8EDECE6C52794FD9D46192E2 /* LegacyDatabaseStorage.swift */; };
+		F4FF95D7245B92E800C19C63 /* AmplitudeReactNative.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4FF95D6245B92E800C19C63 /* AmplitudeReactNative.swift */; };
 /* End PBXBuildFile section */
 
 /* Begin PBXCopyFilesBuildPhase section */
@@ -27,11 +26,10 @@
 
 /* Begin PBXFileReference section */
 		134814201AA4EA6300B7C361 /* libAmplitudeReactNative.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libAmplitudeReactNative.a; sourceTree = BUILT_PRODUCTS_DIR; };
-
+		8EDECE6C52794FD9D46192E2 /* LegacyDatabaseStorage.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = LegacyDatabaseStorage.swift; sourceTree = "<group>"; };
 		B3E7B5891CC2AC0600A0062D /* AmplitudeReactNative.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = AmplitudeReactNative.m; sourceTree = "<group>"; };
 		F4FF95D5245B92E700C19C63 /* AmplitudeReactNative-Bridging-Header.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "AmplitudeReactNative-Bridging-Header.h"; sourceTree = "<group>"; };
 		F4FF95D6245B92E800C19C63 /* AmplitudeReactNative.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AmplitudeReactNative.swift; sourceTree = "<group>"; };
-
 /* End PBXFileReference section */
 
 /* Begin PBXFrameworksBuildPhase section */
@@ -56,12 +54,11 @@
 		58B511D21A9E6C8500147676 = {
 			isa = PBXGroup;
 			children = (
-
 				F4FF95D6245B92E800C19C63 /* AmplitudeReactNative.swift */,
 				B3E7B5891CC2AC0600A0062D /* AmplitudeReactNative.m */,
 				F4FF95D5245B92E700C19C63 /* AmplitudeReactNative-Bridging-Header.h */,
-
 				134814211AA4EA7D00B7C361 /* Products */,
+				8EDECE6C52794FD9D46192E2 /* LegacyDatabaseStorage.swift */,
 			);
 			sourceTree = "<group>";
 		};
@@ -99,7 +96,7 @@
 					};
 				};
 			};
-			buildConfigurationList = 58B511D61A9E6C8500147676 /* Build configuration list for PBXProject "ReactNative" */;
+			buildConfigurationList = 58B511D61A9E6C8500147676 /* Build configuration list for PBXProject "AmplitudeReactNative" */;
 			compatibilityVersion = "Xcode 3.2";
 			developmentRegion = English;
 			hasScannedForEncodings = 0;
@@ -122,10 +119,9 @@
 			isa = PBXSourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
-
 				F4FF95D7245B92E800C19C63 /* AmplitudeReactNative.swift in Sources */,
-				B3E7B58A1CC2AC0600A0062D /* AmplitudeReactNative.m in Sources */,
-
+				B3E7B58A1CC2AC0600A0062D,
+				8EDEC1ED2DCD14B370FA86F1 /* LegacyDatabaseStorage.swift in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -238,11 +234,9 @@
 				OTHER_LDFLAGS = "-ObjC";
 				PRODUCT_NAME = ReactNative;
 				SKIP_INSTALL = YES;
-
 				SWIFT_OBJC_BRIDGING_HEADER = "AmplitudeReactNative-Bridging-Header.h";
 				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
 				SWIFT_VERSION = 5.0;
-
 			};
 			name = Debug;
 		};
@@ -259,17 +253,15 @@
 				OTHER_LDFLAGS = "-ObjC";
 				PRODUCT_NAME = ReactNative;
 				SKIP_INSTALL = YES;
-
 				SWIFT_OBJC_BRIDGING_HEADER = "AmplitudeReactNative-Bridging-Header.h";
 				SWIFT_VERSION = 5.0;
-
 			};
 			name = Release;
 		};
 /* End XCBuildConfiguration section */
 
 /* Begin XCConfigurationList section */
-		58B511D61A9E6C8500147676 /* Build configuration list for PBXProject "ReactNative" */ = {
+		58B511D61A9E6C8500147676 /* Build configuration list for PBXProject "AmplitudeReactNative" */ = {
 			isa = XCConfigurationList;
 			buildConfigurations = (
 				58B511ED1A9E6C8500147676 /* Debug */,