db fixes, new version

@@ -5,7 +5,7 @@ android.buildFeatures.buildConfig = true
 
 
 ext {
 ext {
     PUBLISH_GROUP_ID = 'ly.warp'
     PUBLISH_GROUP_ID = 'ly.warp'
-    PUBLISH_VERSION = '4.5.5.4p10'
+    PUBLISH_VERSION = '4.5.5.4p11'
     PUBLISH_ARTIFACT_ID = 'warply-android-sdk'
     PUBLISH_ARTIFACT_ID = 'warply-android-sdk'
 }
 }
 
 
@@ -107,9 +107,9 @@ dependencies {
     implementation 'com.huawei.hms:maps-basic:6.9.0.300'
     implementation 'com.huawei.hms:maps-basic:6.9.0.300'
 
 
     //------------------------------ SQLCipher -----------------------------//
     //------------------------------ SQLCipher -----------------------------//
-    api "net.zetetic:android-database-sqlcipher:4.5.2"
-    api "androidx.sqlite:sqlite:2.2.0"
-    api 'com.getkeepsafe.relinker:relinker:1.4.4'
+    api "net.zetetic:android-database-sqlcipher:4.5.4"
+    api "androidx.sqlite:sqlite:2.5.1"
+    api 'com.getkeepsafe.relinker:relinker:1.4.5'
 
 
     //------------------------------ Calligraphy -----------------------------//
     //------------------------------ Calligraphy -----------------------------//
 //    api 'io.github.inflationx:calligraphy3:3.1.1'
 //    api 'io.github.inflationx:calligraphy3:3.1.1'

@@ -258,8 +258,8 @@
         <!--            </intent-filter>-->
         <!--            </intent-filter>-->
         <!--        </receiver>-->
         <!--        </receiver>-->
 
 
-        <!--        <provider-->
-        <!--            android:name=".utils.WarplyProvider"-->
-        <!--            android:authorities="ly.warp.sdk.utils.WarplyProvider" />-->
+        <provider
+            android:name=".utils.WarplyProvider"
+            android:authorities="ly.warp.sdk.utils.WarplyProvider" />
     </application>
     </application>
 </manifest>
 </manifest>
\ No newline at end of file

@@ -26,6 +26,11 @@ import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.List;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
 
 
 import ly.warp.sdk.utils.constants.WarpConstants;
 import ly.warp.sdk.utils.constants.WarpConstants;
 
 
@@ -40,8 +45,12 @@ public class WarplyDBHelper extends SQLiteOpenHelper {
     }
     }
 
 
     private static final String DB_NAME = "warply.db";
     private static final String DB_NAME = "warply.db";
-    private static final int DB_VERSION = 12;
+    private static final int DB_VERSION = 13;
     private static final String KEY_CIPHER = "tn#mpOl3v3Dy1pr@W";
     private static final String KEY_CIPHER = "tn#mpOl3v3Dy1pr@W";
+    
+    // Timeout constants
+    private static final int CONNECTION_TIMEOUT_MS = 5000; // 5 seconds for database connection
+    private static final int OPERATION_TIMEOUT_MS = 5000; // 5 seconds for database operations
 
 
     //------------------------------ Fields -----------------------------//
     //------------------------------ Fields -----------------------------//
     private static String TABLE_REQUESTS = "requests";
     private static String TABLE_REQUESTS = "requests";
@@ -118,6 +127,9 @@ public class WarplyDBHelper extends SQLiteOpenHelper {
 
 
     private SQLiteDatabase mDb;
     private SQLiteDatabase mDb;
     private static WarplyDBHelper mDBHelperInstance;
     private static WarplyDBHelper mDBHelperInstance;
+    
+    // Single-threaded executor for database operations
+    private final ExecutorService dbExecutor = Executors.newSingleThreadExecutor();
 
 
     // ===========================================================
     // ===========================================================
     // Constructors
     // Constructors
@@ -145,30 +157,119 @@ public class WarplyDBHelper extends SQLiteOpenHelper {
     }
     }
 
 
     /**
     /**
-     * If database connection already initialized, return the db. Else create a
-     * new one
+     * Gets a writable database connection on a background thread with timeout.
+     * This prevents ANR issues by ensuring database operations don't block the main thread.
      */
      */
     private SQLiteDatabase getDb() {
     private SQLiteDatabase getDb() {
-        if (mDb == null)
-            mDb = getWritableDatabase(KEY_CIPHER);
+        if (mDb == null || !mDb.isOpen()) {
+            try {
+                // Submit task to executor and get future
+                Future<SQLiteDatabase> future = dbExecutor.submit(() -> getWritableDatabase(KEY_CIPHER));
+                
+                // Wait for result with timeout
+                mDb = future.get(CONNECTION_TIMEOUT_MS, TimeUnit.MILLISECONDS);
+                
+                // Set busy timeout on the database connection
+                if (mDb != null && mDb.isOpen()) {
+                    mDb.rawExecSQL("PRAGMA busy_timeout = " + CONNECTION_TIMEOUT_MS);
+                }
+            } catch (TimeoutException e) {
+                Log.e("WarplyDBHelper", "Timeout getting writable database connection", e);
+                // Return null or handle timeout as appropriate
+            } catch (Exception e) {
+                Log.e("WarplyDBHelper", "Error getting writable database connection", e);
+                // Handle other exceptions
+            }
+        }
         return mDb;
         return mDb;
     }
     }
 
 
+    /**
+     * Gets a readable database connection on a background thread with timeout.
+     * This prevents ANR issues by ensuring database operations don't block the main thread.
+     */
     private SQLiteDatabase getReadableDb() {
     private SQLiteDatabase getReadableDb() {
-        if (mDb == null)
-            mDb = getReadableDatabase(KEY_CIPHER);
+        if (mDb == null || !mDb.isOpen()) {
+            try {
+                // Submit task to executor and get future
+                Future<SQLiteDatabase> future = dbExecutor.submit(() -> getReadableDatabase(KEY_CIPHER));
+                
+                // Wait for result with timeout
+                mDb = future.get(CONNECTION_TIMEOUT_MS, TimeUnit.MILLISECONDS);
+                
+                // Set busy timeout on the database connection
+                if (mDb != null && mDb.isOpen()) {
+                    mDb.rawExecSQL("PRAGMA busy_timeout = " + CONNECTION_TIMEOUT_MS);
+                }
+            } catch (TimeoutException e) {
+                Log.e("WarplyDBHelper", "Timeout getting readable database connection", e);
+                // Return null or handle timeout as appropriate
+            } catch (Exception e) {
+                Log.e("WarplyDBHelper", "Error getting readable database connection", e);
+                // Handle other exceptions
+            }
+        }
         return mDb;
         return mDb;
     }
     }
 
 
+    /**
+     * Close database connection - should only be called when app is being destroyed
+     * or when database won't be used for a long time
+     */
     private void closeDb() {
     private void closeDb() {
         if (mDb != null && mDb.isOpen()) {
         if (mDb != null && mDb.isOpen()) {
             mDb.close();
             mDb.close();
             mDb = null;
             mDb = null;
         }
         }
     }
     }
+    
+    /**
+     * Initialize database connection on a background thread. 
+     * Call this during app startup to prevent ANR issues.
+     */
+    public void initialize() {
+        if (mDb == null || !mDb.isOpen()) {
+            try {
+                // Submit task to executor and get future
+                Future<SQLiteDatabase> future = dbExecutor.submit(() -> getWritableDatabase(KEY_CIPHER));
+                
+                // Wait for result with timeout
+                mDb = future.get(CONNECTION_TIMEOUT_MS, TimeUnit.MILLISECONDS);
+                
+                // Set busy timeout on the database connection
+                if (mDb != null && mDb.isOpen()) {
+                    mDb.rawExecSQL("PRAGMA busy_timeout = " + CONNECTION_TIMEOUT_MS);
+                }
+            } catch (TimeoutException e) {
+                Log.e("WarplyDBHelper", "Timeout initializing database connection", e);
+            } catch (Exception e) {
+                Log.e("WarplyDBHelper", "Error initializing database connection", e);
+            }
+        }
+    }
+    
+    /**
+     * Shutdown database connection and executor service.
+     * Call this when app is being destroyed.
+     */
+    public void shutdown() {
+        closeDb();
+        
+        // Shutdown executor service
+        dbExecutor.shutdown();
+        try {
+            if (!dbExecutor.awaitTermination(5, TimeUnit.SECONDS)) {
+                dbExecutor.shutdownNow();
+            }
+        } catch (InterruptedException e) {
+            dbExecutor.shutdownNow();
+            Thread.currentThread().interrupt();
+        }
+    }
 
 
     @Override
     @Override
     public void onCreate(SQLiteDatabase db) {
     public void onCreate(SQLiteDatabase db) {
+        // Create tables
         db.execSQL(CREATE_TABLE_REQUESTS);
         db.execSQL(CREATE_TABLE_REQUESTS);
         db.execSQL(CREATE_TABLE_TAGS);
         db.execSQL(CREATE_TABLE_TAGS);
         db.execSQL(CREATE_TABLE_PUSH_REQUESTS);
         db.execSQL(CREATE_TABLE_PUSH_REQUESTS);
@@ -176,6 +277,14 @@ public class WarplyDBHelper extends SQLiteOpenHelper {
         db.execSQL(CREATE_TABLE_CLIENT);
         db.execSQL(CREATE_TABLE_CLIENT);
         db.execSQL(CREATE_TABLE_AUTH);
         db.execSQL(CREATE_TABLE_AUTH);
         db.execSQL(CREATE_TABLE_TELEMATICS);
         db.execSQL(CREATE_TABLE_TELEMATICS);
+        
+        // Create indexes for frequently queried columns to improve performance
+        db.execSQL("CREATE INDEX IF NOT EXISTS idx_requests_force ON " + TABLE_REQUESTS + "(" + KEY_REQUESTS_FORCE + ")");
+        db.execSQL("CREATE INDEX IF NOT EXISTS idx_requests_date ON " + TABLE_REQUESTS + "(" + KEY_REQUESTS_DATE_ADDED + ")");
+        db.execSQL("CREATE INDEX IF NOT EXISTS idx_push_requests_force ON " + TABLE_PUSH_REQUESTS + "(" + KEY_REQUESTS_FORCE + ")");
+        db.execSQL("CREATE INDEX IF NOT EXISTS idx_push_requests_date ON " + TABLE_PUSH_REQUESTS + "(" + KEY_REQUESTS_DATE_ADDED + ")");
+        db.execSQL("CREATE INDEX IF NOT EXISTS idx_push_ack_requests_force ON " + TABLE_PUSH_ACK_REQUESTS + "(" + KEY_REQUESTS_FORCE + ")");
+        db.execSQL("CREATE INDEX IF NOT EXISTS idx_push_ack_requests_date ON " + TABLE_PUSH_ACK_REQUESTS + "(" + KEY_REQUESTS_DATE_ADDED + ")");
     }
     }
 
 
     @Override
     @Override
@@ -228,36 +337,36 @@ public class WarplyDBHelper extends SQLiteOpenHelper {
     public synchronized void clearTable(String tableName) {
     public synchronized void clearTable(String tableName) {
         SQLiteDatabase db = getDb();
         SQLiteDatabase db = getDb();
         db.delete(tableName, null, null);
         db.delete(tableName, null, null);
-
-        closeDb();
+        // Don't close the database here to improve performance
     }
     }
 
 
     public synchronized void insert(String tableName, ContentValues values) {
     public synchronized void insert(String tableName, ContentValues values) {
         SQLiteDatabase db = getDb();
         SQLiteDatabase db = getDb();
         db.insert(tableName, null, values);
         db.insert(tableName, null, values);
-
-        closeDb();
+        // Don't close the database here to improve performance
     }
     }
 
 
     public synchronized void update(String tableName, ContentValues values) {
     public synchronized void update(String tableName, ContentValues values) {
         SQLiteDatabase db = getDb();
         SQLiteDatabase db = getDb();
         db.update(tableName, values, null, null);
         db.update(tableName, values, null, null);
-
-        closeDb();
+        // Don't close the database here to improve performance
     }
     }
 
 
     public synchronized boolean isTableNotEmpty(String tableName) {
     public synchronized boolean isTableNotEmpty(String tableName) {
-        Cursor cursor = getReadableDb().rawQuery("SELECT COUNT(*) FROM " + tableName,
-                null);
-        if (cursor != null && cursor.moveToFirst()) {
-            boolean isNotEmpty = cursor.getInt(0) > 0;
-            cursor.close();
-            closeDb();
-            return isNotEmpty;
-        } else {
-            closeDb();
-            return false;
+        boolean isNotEmpty = false;
+        Cursor cursor = null;
+        try {
+            cursor = getReadableDb().rawQuery("SELECT COUNT(*) FROM " + tableName, null);
+            if (cursor != null && cursor.moveToFirst()) {
+                isNotEmpty = cursor.getInt(0) > 0;
+            }
+        } finally {
+            if (cursor != null) {
+                cursor.close();
+            }
+            // Don't close the database here to improve performance
         }
         }
+        return isNotEmpty;
     }
     }
 
 
     //------------------------------ Auth -----------------------------//
     //------------------------------ Auth -----------------------------//
@@ -288,30 +397,36 @@ public class WarplyDBHelper extends SQLiteOpenHelper {
     @Nullable
     @Nullable
     public synchronized String getAuthValue(String columnName) {
     public synchronized String getAuthValue(String columnName) {
         String columnValue = "";
         String columnValue = "";
-        Cursor cursor = getReadableDb().query(TABLE_AUTH, new String[]{columnName}, null, null, null, null, null);
-        if (cursor != null && cursor.moveToFirst()) {
-            cursor.moveToFirst();
-            columnValue = cursor.getString(cursor.getColumnIndex(columnName));
-            cursor.close();
+        Cursor cursor = null;
+        try {
+            cursor = getReadableDb().query(TABLE_AUTH, new String[]{columnName}, null, null, null, null, null);
+            if (cursor != null && cursor.moveToFirst()) {
+                columnValue = cursor.getString(cursor.getColumnIndex(columnName));
+            }
+        } finally {
+            if (cursor != null) {
+                cursor.close();
+            }
+            // Don't close the database here to improve performance
         }
         }
-
-        closeDb();
-
         return columnValue;
         return columnValue;
     }
     }
 
 
     @Nullable
     @Nullable
     public synchronized String getClientValue(String columnName) {
     public synchronized String getClientValue(String columnName) {
         String columnValue = "";
         String columnValue = "";
-        Cursor cursor = getReadableDb().query(TABLE_CLIENT, new String[]{columnName}, null, null, null, null, null);
-        if (cursor != null && cursor.moveToFirst()) {
-            cursor.moveToFirst();
-            columnValue = cursor.getString(cursor.getColumnIndex(columnName));
-            cursor.close();
+        Cursor cursor = null;
+        try {
+            cursor = getReadableDb().query(TABLE_CLIENT, new String[]{columnName}, null, null, null, null, null);
+            if (cursor != null && cursor.moveToFirst()) {
+                columnValue = cursor.getString(cursor.getColumnIndex(columnName));
+            }
+        } finally {
+            if (cursor != null) {
+                cursor.close();
+            }
+            // Don't close the database here to improve performance
         }
         }
-
-        closeDb();
-
         return columnValue;
         return columnValue;
     }
     }
 
 
@@ -324,21 +439,36 @@ public class WarplyDBHelper extends SQLiteOpenHelper {
     }
     }
 
 
     //------------------------------ Api requests -----------------------------//
     //------------------------------ Api requests -----------------------------//
+    /**
+     * Gets all requests from the database.
+     * NOTE: The caller is responsible for closing the returned Cursor when done with it.
+     */
     public synchronized Cursor getAllRequests() {
     public synchronized Cursor getAllRequests() {
+        // We don't close the database here because the cursor needs it to remain open
         return getReadableDb().query(TABLE_REQUESTS,
         return getReadableDb().query(TABLE_REQUESTS,
                 new String[]{KEY_REQUESTS_ID,
                 new String[]{KEY_REQUESTS_ID,
                         KEY_REQUESTS_MICROAPP, KEY_REQUESTS_ENTITY}, null, null, null, null,
                         KEY_REQUESTS_MICROAPP, KEY_REQUESTS_ENTITY}, null, null, null, null,
                 KEY_REQUESTS_DATE_ADDED + " asc", "20");
                 KEY_REQUESTS_DATE_ADDED + " asc", "20");
     }
     }
 
 
+    /**
+     * Gets all push requests from the database.
+     * NOTE: The caller is responsible for closing the returned Cursor when done with it.
+     */
     public synchronized Cursor getAllPushRequests() {
     public synchronized Cursor getAllPushRequests() {
+        // We don't close the database here because the cursor needs it to remain open
         return getReadableDb().query(TABLE_PUSH_REQUESTS,
         return getReadableDb().query(TABLE_PUSH_REQUESTS,
                 new String[]{KEY_REQUESTS_ID,
                 new String[]{KEY_REQUESTS_ID,
                         KEY_REQUESTS_MICROAPP, KEY_REQUESTS_ENTITY}, null, null, null, null,
                         KEY_REQUESTS_MICROAPP, KEY_REQUESTS_ENTITY}, null, null, null, null,
                 KEY_REQUESTS_DATE_ADDED + " asc", "20");
                 KEY_REQUESTS_DATE_ADDED + " asc", "20");
     }
     }
 
 
+    /**
+     * Gets all push acknowledgment requests from the database.
+     * NOTE: The caller is responsible for closing the returned Cursor when done with it.
+     */
     public synchronized Cursor getAllPushAckRequests() {
     public synchronized Cursor getAllPushAckRequests() {
+        // We don't close the database here because the cursor needs it to remain open
         return getReadableDb().query(TABLE_PUSH_ACK_REQUESTS,
         return getReadableDb().query(TABLE_PUSH_ACK_REQUESTS,
                 new String[]{KEY_REQUESTS_ID,
                 new String[]{KEY_REQUESTS_ID,
                         KEY_REQUESTS_MICROAPP, KEY_REQUESTS_ENTITY}, null, null, null, null,
                         KEY_REQUESTS_MICROAPP, KEY_REQUESTS_ENTITY}, null, null, null, null,
@@ -388,163 +518,225 @@ public class WarplyDBHelper extends SQLiteOpenHelper {
     }
     }
 
 
     public synchronized long getRequestsInQueueCount() {
     public synchronized long getRequestsInQueueCount() {
-        return DatabaseUtils.queryNumEntries(getReadableDb(), TABLE_REQUESTS);
+        SQLiteDatabase db = getReadableDb();
+        long count = DatabaseUtils.queryNumEntries(db, TABLE_REQUESTS);
+        // Don't close the database here to improve performance
+        return count;
     }
     }
 
 
     public synchronized long getPushRequestsInQueueCount() {
     public synchronized long getPushRequestsInQueueCount() {
-        return DatabaseUtils.queryNumEntries(getReadableDb(), TABLE_PUSH_REQUESTS);
+        SQLiteDatabase db = getReadableDb();
+        long count = DatabaseUtils.queryNumEntries(db, TABLE_PUSH_REQUESTS);
+        // Don't close the database here to improve performance
+        return count;
     }
     }
 
 
     public synchronized long getPushAckRequestsInQueueCount() {
     public synchronized long getPushAckRequestsInQueueCount() {
-        return DatabaseUtils.queryNumEntries(getReadableDb(), TABLE_PUSH_ACK_REQUESTS);
+        SQLiteDatabase db = getReadableDb();
+        long count = DatabaseUtils.queryNumEntries(db, TABLE_PUSH_ACK_REQUESTS);
+        // Don't close the database here to improve performance
+        return count;
     }
     }
 
 
     public synchronized void deleteRequests(Long... ids) {
     public synchronized void deleteRequests(Long... ids) {
-        StringBuilder strFilter = new StringBuilder();
-        for (int i = 0; i < ids.length; i++) {
-            if (i > 0) {
-                strFilter.append(" OR ");
+        if (ids.length == 0) return;
+        
+        SQLiteDatabase db = getDb();
+        try {
+            db.beginTransaction();
+            StringBuilder strFilter = new StringBuilder();
+            for (int i = 0; i < ids.length; i++) {
+                if (i > 0) {
+                    strFilter.append(" OR ");
+                }
+                strFilter.append(KEY_REQUESTS_ID);
+                strFilter.append("=");
+                strFilter.append(ids[i]);
             }
             }
-            strFilter.append(KEY_REQUESTS_ID);
-            strFilter.append("=");
-            strFilter.append(ids[i]);
+            db.delete(TABLE_REQUESTS, strFilter.toString(), null);
+            db.setTransactionSuccessful();
+        } finally {
+            db.endTransaction();
+            // Don't close the database here to improve performance
         }
         }
-        getDb().delete(TABLE_REQUESTS, strFilter.toString(), null);
-
-        closeDb();
     }
     }
 
 
     public synchronized void deletePushRequests(Long... ids) {
     public synchronized void deletePushRequests(Long... ids) {
-        StringBuilder strFilter = new StringBuilder();
-        for (int i = 0; i < ids.length; i++) {
-            if (i > 0) {
-                strFilter.append(" OR ");
+        if (ids.length == 0) return;
+        
+        SQLiteDatabase db = getDb();
+        try {
+            db.beginTransaction();
+            StringBuilder strFilter = new StringBuilder();
+            for (int i = 0; i < ids.length; i++) {
+                if (i > 0) {
+                    strFilter.append(" OR ");
+                }
+                strFilter.append(KEY_REQUESTS_ID);
+                strFilter.append("=");
+                strFilter.append(ids[i]);
             }
             }
-            strFilter.append(KEY_REQUESTS_ID);
-            strFilter.append("=");
-            strFilter.append(ids[i]);
+            db.delete(TABLE_PUSH_REQUESTS, strFilter.toString(), null);
+            db.setTransactionSuccessful();
+        } finally {
+            db.endTransaction();
+            // Don't close the database here to improve performance
         }
         }
-        getDb().delete(TABLE_PUSH_REQUESTS, strFilter.toString(), null);
-
-        closeDb();
     }
     }
 
 
     public synchronized void deletePushAckRequests(Long... ids) {
     public synchronized void deletePushAckRequests(Long... ids) {
-        StringBuilder strFilter = new StringBuilder();
-        for (int i = 0; i < ids.length; i++) {
-            if (i > 0) {
-                strFilter.append(" OR ");
+        if (ids.length == 0) return;
+        
+        SQLiteDatabase db = getDb();
+        try {
+            db.beginTransaction();
+            StringBuilder strFilter = new StringBuilder();
+            for (int i = 0; i < ids.length; i++) {
+                if (i > 0) {
+                    strFilter.append(" OR ");
+                }
+                strFilter.append(KEY_REQUESTS_ID);
+                strFilter.append("=");
+                strFilter.append(ids[i]);
             }
             }
-            strFilter.append(KEY_REQUESTS_ID);
-            strFilter.append("=");
-            strFilter.append(ids[i]);
+            db.delete(TABLE_PUSH_ACK_REQUESTS, strFilter.toString(), null);
+            db.setTransactionSuccessful();
+        } finally {
+            db.endTransaction();
+            // Don't close the database here to improve performance
         }
         }
-        getDb().delete(TABLE_PUSH_ACK_REQUESTS, strFilter.toString(), null);
-
-        closeDb();
     }
     }
 
 
     public synchronized boolean isForceRequestsExist() {
     public synchronized boolean isForceRequestsExist() {
-        Cursor cursor = getReadableDb().query(TABLE_REQUESTS, null, KEY_REQUESTS_FORCE + "=1",
-                null, null, null, null);
         boolean result = false;
         boolean result = false;
-        if (cursor != null) {
-            result = cursor.getCount() > 0;
-            cursor.close();
+        Cursor cursor = null;
+        try {
+            cursor = getReadableDb().query(TABLE_REQUESTS, null, KEY_REQUESTS_FORCE + "=1",
+                    null, null, null, null);
+            if (cursor != null) {
+                result = cursor.getCount() > 0;
+            }
+        } finally {
+            if (cursor != null) {
+                cursor.close();
+            }
+            // Don't close the database here to improve performance
         }
         }
-
-        closeDb();
-
         return result;
         return result;
     }
     }
 
 
     public synchronized boolean isForcePushRequestsExist() {
     public synchronized boolean isForcePushRequestsExist() {
-        Cursor cursor = getReadableDb().query(TABLE_PUSH_REQUESTS, null, KEY_REQUESTS_FORCE + "=1",
-                null, null, null, null);
         boolean result = false;
         boolean result = false;
-        if (cursor != null) {
-            result = cursor.getCount() > 0;
-            cursor.close();
+        Cursor cursor = null;
+        try {
+            cursor = getReadableDb().query(TABLE_PUSH_REQUESTS, null, KEY_REQUESTS_FORCE + "=1",
+                    null, null, null, null);
+            if (cursor != null) {
+                result = cursor.getCount() > 0;
+            }
+        } finally {
+            if (cursor != null) {
+                cursor.close();
+            }
+            // Don't close the database here to improve performance
         }
         }
-
-        closeDb();
-
         return result;
         return result;
     }
     }
 
 
     public synchronized boolean isForcePushAckRequestsExist() {
     public synchronized boolean isForcePushAckRequestsExist() {
-        Cursor cursor = getReadableDb().query(TABLE_PUSH_ACK_REQUESTS, null, KEY_REQUESTS_FORCE + "=1",
-                null, null, null, null);
         boolean result = false;
         boolean result = false;
-        if (cursor != null) {
-            result = cursor.getCount() > 0;
-            cursor.close();
+        Cursor cursor = null;
+        try {
+            cursor = getReadableDb().query(TABLE_PUSH_ACK_REQUESTS, null, KEY_REQUESTS_FORCE + "=1",
+                    null, null, null, null);
+            if (cursor != null) {
+                result = cursor.getCount() > 0;
+            }
+        } finally {
+            if (cursor != null) {
+                cursor.close();
+            }
+            // Don't close the database here to improve performance
         }
         }
-
-        closeDb();
-
         return result;
         return result;
     }
     }
 
 
     //------------------------------ Tags -----------------------------//
     //------------------------------ Tags -----------------------------//
     public synchronized void saveTags(String[] tags) {
     public synchronized void saveTags(String[] tags) {
         if (tags != null && tags.length > 0) {
         if (tags != null && tags.length > 0) {
+            SQLiteDatabase db = getDb();
             try {
             try {
-                getDb().beginTransaction();
+                db.beginTransaction();
                 ContentValues values = new ContentValues();
                 ContentValues values = new ContentValues();
                 for (String tag : tags) {
                 for (String tag : tags) {
+                    values.clear();
                     values.put(KEY_TAG, tag);
                     values.put(KEY_TAG, tag);
                     values.put(KEY_TAG_LAST_ADD_DATE, System.currentTimeMillis());
                     values.put(KEY_TAG_LAST_ADD_DATE, System.currentTimeMillis());
-                    insert(TABLE_TAGS, values);
+                    db.insert(TABLE_TAGS, null, values);
                 }
                 }
-                getDb().setTransactionSuccessful();
-
+                db.setTransactionSuccessful();
             } catch (SQLException e) {
             } catch (SQLException e) {
-                closeDb();
                 if (WarpConstants.DEBUG) {
                 if (WarpConstants.DEBUG) {
                     e.printStackTrace();
                     e.printStackTrace();
                 }
                 }
             } finally {
             } finally {
-                getDb().endTransaction();
-
-                closeDb();
+                db.endTransaction();
+                // Don't close the database here to improve performance
             }
             }
         }
         }
     }
     }
 
 
     public synchronized void saveTelematics(JSONArray jsonArray) {
     public synchronized void saveTelematics(JSONArray jsonArray) {
         if (jsonArray != null && jsonArray.length() > 0) {
         if (jsonArray != null && jsonArray.length() > 0) {
-            ContentValues values = new ContentValues();
-            for (int i = 0; i < jsonArray.length(); i++) {
-                JSONObject jsonobject = jsonArray.optJSONObject(i);
-                if (jsonobject != null) {
-                    String timestamp = jsonobject.keys().next();
-                    values.put(KEY_TIMESTAMP, timestamp);
-                    JSONObject jobjData = jsonobject.optJSONObject(timestamp);
-                    if (jobjData != null) {
-                        values.put(KEY_ACCELERATION, jobjData.optDouble(KEY_ACCELERATION));
-                        values.put(KEY_SPEED, jobjData.optDouble(KEY_SPEED));
+            SQLiteDatabase db = getDb();
+            try {
+                db.beginTransaction();
+                ContentValues values = new ContentValues();
+                for (int i = 0; i < jsonArray.length(); i++) {
+                    JSONObject jsonobject = jsonArray.optJSONObject(i);
+                    if (jsonobject != null) {
+                        values.clear();
+                        String timestamp = jsonobject.keys().next();
+                        values.put(KEY_TIMESTAMP, timestamp);
+                        JSONObject jobjData = jsonobject.optJSONObject(timestamp);
+                        if (jobjData != null) {
+                            values.put(KEY_ACCELERATION, jobjData.optDouble(KEY_ACCELERATION));
+                            values.put(KEY_SPEED, jobjData.optDouble(KEY_SPEED));
+                        }
+                        db.insert(TABLE_TELEMATICS, null, values);
                     }
                     }
-                    insert(TABLE_TELEMATICS, values);
                 }
                 }
+                db.setTransactionSuccessful();
+            } finally {
+                db.endTransaction();
+                // Don't close the database here to improve performance
             }
             }
         }
         }
     }
     }
 
 
     public synchronized void removeTags(String[] tags) {
     public synchronized void removeTags(String[] tags) {
-        StringBuilder strFilter = new StringBuilder();
-        for (int i = 0; i < tags.length; i++) {
-            if (i > 0) {
-                strFilter.append(" OR ");
+        if (tags.length == 0) return;
+        
+        SQLiteDatabase db = getDb();
+        try {
+            db.beginTransaction();
+            StringBuilder strFilter = new StringBuilder();
+            for (int i = 0; i < tags.length; i++) {
+                if (i > 0) {
+                    strFilter.append(" OR ");
+                }
+                strFilter.append(KEY_TAG);
+                strFilter.append("=");
+                strFilter.append("'");
+                strFilter.append(tags[i]);
+                strFilter.append("'");
             }
             }
-            strFilter.append(KEY_TAG);
-            strFilter.append("=");
-            strFilter.append("'");
-            strFilter.append(tags[i]);
-            strFilter.append("'");
+            db.delete(TABLE_TAGS, strFilter.toString(), null);
+            db.setTransactionSuccessful();
+        } finally {
+            db.endTransaction();
+            // Don't close the database here to improve performance
         }
         }
-        getDb().delete(TABLE_TAGS, strFilter.toString(), null);
-        closeDb();
     }
     }
 
 
     public synchronized void removeAllTags() {
     public synchronized void removeAllTags() {
@@ -553,21 +745,22 @@ public class WarplyDBHelper extends SQLiteOpenHelper {
 
 
     @Nullable
     @Nullable
     public synchronized String[] getTags() {
     public synchronized String[] getTags() {
-
         List<String> tags = null;
         List<String> tags = null;
-        Cursor cursor = getReadableDb().query(TABLE_TAGS, null, null, null, null, null, null);
-        if (cursor != null) {
-
-            tags = new ArrayList<>(cursor.getCount());
-            while (cursor.moveToNext()) {
-                tags.add(cursor.getString(cursor
-                        .getColumnIndex(KEY_TAG)));
+        Cursor cursor = null;
+        try {
+            cursor = getReadableDb().query(TABLE_TAGS, null, null, null, null, null, null);
+            if (cursor != null) {
+                tags = new ArrayList<>(cursor.getCount());
+                while (cursor.moveToNext()) {
+                    tags.add(cursor.getString(cursor.getColumnIndex(KEY_TAG)));
+                }
+            }
+        } finally {
+            if (cursor != null) {
+                cursor.close();
             }
             }
-            cursor.close();
+            // Don't close the database here to improve performance
         }
         }
-
-        closeDb();
-
         return tags != null ? tags.toArray(new String[tags.size()]) : null;
         return tags != null ? tags.toArray(new String[tags.size()]) : null;
     }
     }
 
 

@@ -2,6 +2,7 @@ package ly.warp.sdk.utils;
 
 
 import android.content.ContentProvider;
 import android.content.ContentProvider;
 import android.content.ContentValues;
 import android.content.ContentValues;
+import android.content.Context;
 import android.database.Cursor;
 import android.database.Cursor;
 import android.net.Uri;
 import android.net.Uri;
 
 
@@ -9,6 +10,8 @@ import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.annotation.Nullable;
 import androidx.appcompat.app.AppCompatDelegate;
 import androidx.appcompat.app.AppCompatDelegate;
 
 
+import ly.warp.sdk.db.WarplyDBHelper;
+
 /**
 /**
  * Created by Panagiotis Triantafyllou on 05/Αυγ/2022.
  * Created by Panagiotis Triantafyllou on 05/Αυγ/2022.
  */
  */
@@ -16,7 +19,14 @@ public class WarplyProvider extends ContentProvider {
 
 
     @Override
     @Override
     public boolean onCreate() {
     public boolean onCreate() {
-        AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_NO);
+//        AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_NO);
+        
+        // Initialize the database helper
+        Context context = getContext();
+        if (context != null) {
+            WarplyDBHelper dbHelper = WarplyDBHelper.getInstance(context);
+            dbHelper.initialize(); // This will initialize the database connection on a background thread
+        }
 //        ViewPump.init(ViewPump.builder()
 //        ViewPump.init(ViewPump.builder()
 //                .addInterceptor(new CalligraphyInterceptor(
 //                .addInterceptor(new CalligraphyInterceptor(
 //                        new CalligraphyConfig.Builder()
 //                        new CalligraphyConfig.Builder()
@@ -34,6 +44,18 @@ public class WarplyProvider extends ContentProvider {
         return true;
         return true;
     }
     }
 
 
+    @Override
+    public void shutdown() {
+        // Get the database helper instance and shut it down
+        Context context = getContext();
+        if (context != null) {
+            WarplyDBHelper dbHelper = WarplyDBHelper.getInstance(context);
+            dbHelper.shutdown();
+        }
+        
+        super.shutdown();
+    }
+
     @Nullable
     @Nullable
     @Override
     @Override
     public Cursor query(@NonNull Uri uri, @Nullable String[] strings, @Nullable String s, @Nullable String[] strings1, @Nullable String s1) {
     public Cursor query(@NonNull Uri uri, @Nullable String[] strings, @Nullable String s, @Nullable String[] strings1, @Nullable String s1) {