Android Room，最大数据库容量上限

Question

I am working on a production app, so I am not able to share the code. But I will try my best to explain the current scenario.

We need to set a maximum size of the database, this size is provided via API call (so this might change at runtime if API provides a new size). For example, let's consider the max size as 10 MB. Once the database reaches this maximum size, we need to remove some database entries so that new entries can be inserted.

Here I am confused a bit. How to set the maximum size of the database when using Android Room and how to figure out that how many entries I need to delete in order to insert a new record and keep the database at its max size allowed.

Hope I am clear, but I can provide additional examples if required.

Answer 1

Like in mentioned in the android-united slack, you can accomplish this by using an abstract dao class as base for all your daos. just check the file size before performing insert operations. Using only a DAO:

package com.github.fcopardo.room.base

import android.arch.persistence.room.Delete
import android.arch.persistence.room.Insert
import android.arch.persistence.room.OnConflictStrategy
import android.arch.persistence.room.Update
import android.content.Context
import java.io.File

abstract class LimitedDao<T> {

    private var byteLimit : Long = 0
    private var context : Context? = null
    private var databaseName : String = ""

    public fun setByteLimit(byteLimit : Long){
        this.byteLimit = byteLimit
    }

    public fun setContext(context: Context?){
        this.context = context
    }

    public fun setDatabaseName(databaseName: String){
        this.databaseName = databaseName
    }

    protected fun writingCondition() : Boolean {
        var result = true

        if(byteLimit>0){
            var dbFile : File? = context?.getDatabasePath(databaseName)

            if(dbFile!=null){
                result = dbFile.length() >byteLimit
            }
        }

        return result
    }

    @Insert
    protected abstract fun insert(data: T)

    public fun insertData(data:T){
        if(writingCondition()) insert(data)
    }

    @Insert(onConflict = OnConflictStrategy.REPLACE)
    protected abstract fun persist(data: T)

    public fun persistData(data:T){
        if(writingCondition()) persist(data)
    }

    @Delete
    protected abstract fun delete(data: T)

    @Delete
    protected abstract fun delete(data: List<T>)

    @Update
    protected abstract fun update(data: T)

    @Update
    protected abstract fun update(data: List<T>)
}

A better solution can be achieved by using a base database class too, or you can wrap this logic at viewmodel level; that would give you safe access to a context, but writing operations done outside the viewmodel would write to the database. Be mindful of clearing the context reference with setContext(null) when you are done with the dao.