Como criaria uma base de dados para uma aplicação…

Para criar uma base de dados local no Android, eu usaria a Room Persistence Library.

É uma abstração sobre SQLite que simplifica o trabalho com bases de dados, fornecendo uma API anotada para criar esquemas, consultas e gerir migrações.

Passos principais:

Adicionar dependências:

// No build.gradle (nível de app)
dependencies {
    implementation("androidx.room:room-runtime:2.6.1")
    annotationProcessor("androidx.room:room-compiler:2.6.1") // Para Java
    kapt("androidx.room:room-compiler:2.6.1") // Para Kotlin
    implementation("androidx.room:room-ktx:2.6.1") // Para coroutines
}

Criar entidades (Entities): POJO (Plain Old Java Object) ou classes de dados que representam tabelas na base de dados. As anotações @Entity, @PrimaryKey, @ColumnInfo são usadas para definir a estrutura.

@Entity(tableName = "users")
data class User(
    @PrimaryKey(autoGenerate = true) val id: Int = 0,
    @ColumnInfo(name = "first_name") val firstName: String?,
    @ColumnInfo(name = "last_name") val lastName: String?
)

Criar DAO (Data Access Objects): Interfaces que definem métodos de acesso aos dados (inserir, eliminar, atualizar, consultas). As anotações @Dao, @Insert, @Delete, @Update, @Query são usadas.

@Dao
interface UserDao {
    @Query("SELECT * FROM users")
    fun getAll(): List<User>

    @Insert
    fun insertAll(vararg users: User)

    @Delete
    fun delete(user: User)
}

Criar a classe Database: Classe abstrata que herda de RoomDatabase, que fornece acesso ao DAO e define o esquema. A anotação @Database indica as entidades e a versão.

@Database(entities = [User::class], version = 1)
abstract class AppDatabase : RoomDatabase() {
    abstract fun userDao(): UserDao

    companion object {
        @Volatile
        private var INSTANCE: AppDatabase? = null

        fun getDatabase(context: Context): AppDatabase {
            return INSTANCE ?: synchronized(this) {
                val instance = Room.databaseBuilder(
                    context.applicationContext,
                    AppDatabase::class.java,
                    "app_database"
                ).build()
                INSTANCE = instance
                instance
            }
        }
    }
}

Trabalhar com a base de dados: Obter a instância e realizar operações através do DAO.

val db = AppDatabase.getDatabase(applicationContext)
val userDao = db.userDao()

// Inserir dados (normalmente em uma thread de fundo)
GlobalScope.launch {
    userDao.insertAll(User(firstName = "John", lastName = "Doe"))
}

// Obter dados
GlobalScope.launch {
    val users = userDao.getAll()
}

Vantagens do Room:

Verificação de consultas na compilação: As consultas SQL são verificadas durante a compilação, o que reduz erros em tempo de execução.
Trabalho fácil com threads: A integração com corrotinas ou LiveData facilita o trabalho com dados em threads de fundo.
Migração mais fácil: Fornece ferramentas para gerenciar mudanças no esquema.
Menos código boilerplate comparado ao SQLite nativo.

Se os requisitos forem muito específicos ou pequenos, pode-se considerar usar Shared Preferences para pares chave-valor simples, mas para dados estruturados e consultas, o Room é preferido. Para cenários mais complexos que requerem sincronização ou acesso de diferentes fontes (por exemplo, web), pode-se considerar usar bancos de dados na nuvem como Firebase Realtime Database ou Firestore, mas para armazenamento local, o Room é a solução padrão e recomendada.

Como criaria uma base de dados para uma aplicação móvel?