PDF - VERSÃO DE IMPRESSÃO

Lição 10 - Armazenamento de dados em dispositivos móveis

objetivo

Depois de entendermos como criar aplicativos híbridos usando o Kotlin Multiplatform, chegou a hora de aprender sobre as principais opções de armazenamento de dados em dispositivos móveis usando o Kotlin. No desenvolvimento de aplicativos Android, é essencial escolher a abordagem correta para armazenar informações de forma eficiente e segura; sendo assim, nesta lição, exploraremos o uso do Room, uma biblioteca que facilita a persistência de dados usando bancos de dados SQLite, e o Shared Preferences, que permite armazenar pequenas quantidades de dados de forma simples e rápida.

Além disso, discutiremos boas práticas para gerenciamento de dados, garantindo a integridade e segurança das informações do usuário. Ao final desta lição, você será capaz de aplicar essas técnicas em seus projetos para criar aplicativos mais robustos e eficientes. Vamos começar?

problematização

Ao desenvolver um aplicativo de anotações para dispositivos móveis, garantir que os dados do usuário sejam armazenados de forma segura e acessível, mesmo sem conexão com a internet, é um desafio. Se as informações forem mantidas apenas na memória, elas serão perdidas assim que o aplicativo for fechado. Por outro lado, se utilizarmos um banco de dados para todas as informações, até mesmo para salvar configurações simples, como a preferência pelo tema escuro ou claro, pode tornar o sistema mais complexo do que o necessário.

Nessa problematização, é essencial escolher o tipo de armazenamento mais adequado para cada necessidade. Mas como garantir a persistência das notas de forma eficiente? Quando optar por um banco de dados estruturado, como o Room, e quando utilizar o Shared Preferences para armazenar configurações leves? Compreender essas opções permite desenvolver aplicativos mais eficientes, organizados e adaptados às necessidades reais dos usuários.

Vamos entender melhor sobre isso?

case

Agora, vamos entender como o armazenamento de dados em dispositivos móveis funciona na prática? Para facilitar sua compreensão, conheça a empresa fictícia NoteFast que está desenvolvendo um aplicativo de anotações rápidas para smartphones Android. O objetivo é permitir que os usuários criem, editem e excluam notas de maneira intuitiva. Para isso, inicialmente, a equipe pensou em armazenar as anotações apenas na memória, mas percebeu que os dados eram perdidos ao fechar o aplicativo. Para resolver isso, a equipe decidiu utilizar o Room, garantindo que as notas fossem armazenadas de forma persistente.

Essa não foi, porém, a única decisão da equipe! Para melhorar a experiência do usuário, o Shared Preferences foi implementado para salvar configurações do aplicativo, como o modo escuro ativado ou não. Dessa forma, o usuário conseguiria personalizar a interface e manter suas preferências salvas mesmo após reiniciar o dispositivo. Com essas soluções, o aplicativo se tornou mais funcional e confiável, garantindo uma ótima experiência para os usuários.

Portanto, por meio do exemplo desse case, é possível compreender a importância de escolher o método de armazenamento adequado para cada tipo de dado. Além disso, é uma situação que ilustra a aplicação de conceitos, como bancos de dados locais (Room) para armazenar informações essenciais e Shared Preferences para salvar configurações leves, criando aplicativos mais eficientes e adaptáveis às necessidades dos usuários. Agora, tendo um pouco mais de conhecimento sobre o assunto, vamos nos aprofundar!

Conceitualização

O armazenamento de dados é um aspecto fundamental no desenvolvimento de aplicações Android, garantindo que informações importantes sejam preservadas mesmo após o fechamento do aplicativo. Dependendo da necessidade da aplicação, diferentes estratégias podem ser adotadas para armazenar e recuperar dados de maneira eficiente, garantindo uma boa experiência ao usuário. No Android, há uma variedade de soluções disponíveis, cada uma adequada para um tipo específico de dado e contexto de uso. Resende (2018) destaca que podemos utilizar quatro formas principais de armazenar os dados da sua aplicação. Conheça cada uma delas:

Shared Preferences: armazena pequenos dados como configurações e preferências do usuário em arquivos XML. Resende (2018) complementa dizendo que é um tipo de persistência muito simples, em que os dados são armazenados por chave-valor.
Room Database: uma camada de abstração sobre o SQLite que facilita a criação e manipulação de bancos de dados locais. Resende (2018) diz que é a solução mais completa que podemos ter para dados estruturados.
Arquivos locais: permite salvar documentos, imagens e outros arquivos diretamente no armazenamento do dispositivo. Resende (2018) diz que usamos esse tipo quando precisamos armazenar arquivos somente no contexto do nosso App.
Banco de dados na nuvem: soluções, como Firebase, que, segundo Machado (2021), é uma estrutura recheada de recursos oferecida pelo Google, permitem armazenar dados on-line e sincronizá-los entre dispositivos.

Shared Preferences: armazenamento de preferências do usuário

O Shared Preference é uma forma de armazenamento ideal para pequenas configurações, como o estado de login ou o tema do aplicativo. De acordo com Resende (2018), geralmente ele é utilizado para guardar preferências dos usuários, por exemplo, “manter-se conectado”. Veja a seguir, na Figura 1, um exemplo de Shared Preference para salvar a preferência do usuário pelo tema escuro:

Figura 1 - Shared Preference em Kotlin
Fonte: o autor.

#PraCegoVer: a figura apresenta quatro linhas. Na linha 1, está escrito “val sharedPreferences = getSharedPreferences("AppPrefs", MODE_PRIVATE)”; na linha 2, “val editor = sharedPreferences.edit()”; na linha 3, “editor.putBoolean("modoEscuro", true)”; e, na linha 4, “editor.apply()”. Fim da descrição.

Explicação do código:

Linha 1: crio um Shared Preference com o nome de AppPrefs.
Linha 2: atribuo para uma variável editor o editor de Shared Preferences.
Linha 3: salvo no SP um valor verdadeiro para o modo escuro do tema do aplicativo.
linha 4: aplico as alterações feitas pelo editor.

Uma vez que foram salvas essas preferências, conseguimos, também, recuperar o valor para validação em nossa regra de negócio, como:

val modoEscuro = sharedPreferences.getBoolean(“modoEscuro”, false)

Room Database: persistência de dados com SQLite

O Room Database simplifica o uso do SQLite, tornando o código mais organizado e seguro. Segundo Resende (2018), por ser a solução mais completa, uma das principais vantagens do Room é a capacidade de implementar um banco de dados SQLite inteiro utilizando uma abordagem ORM (Object-Relational Mapping), que facilita significativamente a manipulação dos dados. Com o Room, é possível criar entidades (tabelas) e realizar operações, como inserção, leitura, atualização e exclusão de dados, de forma mais eficiente e com menor chance de erros.

Na Figura 2, apresento a você um exemplo básico de implementação do Room em Kotlin. Nesse exemplo, a criação de uma entidade é feita por meio de classes anotadas com @Entity, conforme explicita Resende (2018). Essas anotações indicam ao banco de dados que a estrutura de dados definida pela classe será mapeada como uma tabela dentro do banco.

Figura 2 - Entity com Room em Kotlin
Fonte: o autor.

#PraCegoVer: figura apresenta seis linhas. Na linha 1, está escrito “@Entity”; na linha 2, “data class Nota(”; na linha 3, “@PrimaryKey(autoGenerate = true) val id: Int = 0”; na linha 4, “val titulo: String”; na linha 5, “val conteudo: String”; e, na linha 6, “)”. Fim da descrição.

Pontos a serem entendidos no código:

A anotação @Entity na linha 1, que define a classe como uma entidade (tabela), e a anotação @PrimaryKey(autoGenerate = true), que define o atributo id como a chave primária da entidade, sendo gerada automaticamente.

O Room também exige a criação de uma classe DAO para cada entidade. Resende (2018) explica que DAO é a abreviação de Data Access Object (objeto de acesso a dados) e que esse é um padrão comum em projetos de software que acessam bancos de dados. Assim, veja, na Figura 3, uma implementação da NotaDao:

Figura 3 - DAO com Room em Kotlin
Fonte: o autor.

#PraCegoVer: a figura apresenta oito linhas. Na linha 1, está escrito “@Dao”; na linha 2, “interface NotaDao {”; na linha 3, “@Insert”; na linha 4, “fun inserirNota(nota: Nota)”; na linha 6, “@Query(“SELECT * FROM Nota”)”; na linha 7, “fun listarNotas(): List<Nota>”; e, na linha 8, “}”. Na linha 5, não há conteúdo escrito. Fim da descrição.

Pontos a serem entendidos no código:

A anotação @Dao na linha 1, que informa a utilidade da interface, @Insert na linha 3, que informa que a função inserirNota insere dados no banco de dados, e @Query(“SELECT * FROM Nota”), que seleciona todos os registros da entidade Nota, o que, por consequência, seleciona todos os registros da tabela notas do banco de dados, por meio da função listarNotas().

Para que tudo funcione corretamente, é necessário também criar o banco de dados; caso contrário, nada terá efeito. Resende (2018) explica que essa é a última parte da implementação do Room, que envolve a criação do objeto de banco de dados. Por isso, na Figura 4, irei mostrar como criar um banco de dados utilizando o Room:

Figura 4 - Criação do banco de dados com Room em Kotlin
Fonte: o autor.

#PraCegoVer: a figura apresenta quatro linhas. Na linha 1, está escrito “@Database(entities = [Nota::class], version = 1)”; na linha 2, “abstract class AppDatabase : RoomDatabase() {”; na linha 3, “abstract fun notaDao(): NotaDao”; e, na linha 4, “}”. Fim da descrição.

Pontos a serem entendidos no código:

A anotação @Database(entities = [Nota::class], version = 1), que cria o banco de dados e as respectivas tabelas ou entities que precisam ser registradas como a entidade Nota foi. Além disso, define a versão do banco de dados, que sempre começa com o valor 1.

Agora que temos a entidade, o DAO e o banco de dados criados, a próxima dúvida é: como utilizá-los? Na Figura 5, mostro a você como salvar uma nota utilizando a estrutura que criamos:

Figura 5 - Utilizando o Room para criar uma nova nota em Kotlin
Fonte: o autor.

#PraCegoVer: a figura apresenta oito linhas. Na linha 1, está escrito “val db = Room.databaseBuilder(”; na linha 2, “applicationContext”; na linha 3, “AppDatabase::class.java, ‘notas-database’”; na linha 4, “).build()”; na linha 6, “val notaDao = db.notaDao()”; na linha 7, “val novaNota = Nota(titulo = "Minha Nota", conteudo = "Conteúdo da nota")”; e, na linha 8, “notaDao.inserirNota(novaNota)”. Na linha 5, não há conteúdo escrito. Fim da descrição.

Pontos a serem entendidos no código:

Entre as linhas 1 e 4, estamos criando o banco de dados com o título notas-database usando o databaseBuilder do Room e nossa classe AppDatabase.
Na linha 6, instanciamos o objeto notaDao para fazer as operações com a entidade.
Na linha 7, instanciamos um objeto Nota com titulo e conteudo.
Na linha 8, usamos notaDao por meio de seu método inserirNota() para inserir a nota criada.

Com essa abordagem, os dados são armazenados de forma persistente e podem ser acessados sempre que necessário. O uso de Shared Preferences e Room com Kotlin oferece soluções eficazes para o armazenamento de dados em aplicativos Android, cada uma adequada a necessidades específicas.

O Shared Preferences é ideal para armazenar pequenas quantidades de dados simples, como configurações de usuário e preferências de interface, de forma rápida e eficiente. Por outro lado, o Room oferece uma poderosa abstração sobre o SQLite, permitindo a persistência de dados estruturados com segurança e escalabilidade. É a melhor opção para armazenar informações mais complexas, como listas de notas ou registros de usuários. Ao combinar essas tecnologias de maneira adequada, os desenvolvedores podem criar aplicativos robustos, garantindo eficiência, persistência e uma experiência aprimorada para o usuário.

saiba aplicar

Compreender o uso do Room e do Shared Preferences é essencial para você, futuro técnico em Desenvolvimento de Sistemas, pois permite implementar soluções eficientes para armazenamento e persistência de dados em aplicativos Android. Enquanto o Room facilita a manipulação de bancos de dados SQLite de forma segura e organizada, o Shared Preferences possibilita salvar pequenas configurações do usuário sem a complexidade de um banco de dados completo. Agora, entendendo melhor a teoria, vamos colocar isso em prática!

Como já compreendemos os conceitos de armazenamento de dados utilizando Room e Shared Preferences, é hora de aplicar esse conhecimento em um desafio prático. Vamos desenvolver um aplicativo de anotações, onde o usuário poderá cadastrar suas notas utilizando o Kotlin e o Jetpack Compose.

Para esse desenvolvimento, siga o passo a passo:

1) Crie um projeto no Android Studio usando Kotlin e Jetpack Compose como nas lições anteriores.

2) Configuração do projeto:

a) Certifique-se de que as dependências do Room estão corretamente configuradas no build.gradle.kts.

i) Em plugins, inclua a linha alias(libs.plugins.ksp),

ii) Em dependencies, inclua as três linhas a seguir:

(1) implementation(libs.androidx.room.runtime)

(2) implementation(libs.androidx.room.ktx)

(3) ksp(libs.androidx.room.compiler)

b) No arquivo libs.versions.toml, inclua:

i) Em versions, inclua kspVersion = "1.9.0-1.0.13"

ii) Em libraries, inclua a linha: androidx-room-ksp = { module = "androidx.room:room-compiler", version.ref = "roomRuntime" }

iii) Em plugins, inclua a linha: ksp = { id = "com.google.devtools.ksp", version.ref = "kspVersion" }

c) Adicione as permissões necessárias para acessar o armazenamento local, se necessário.

3) Criação das classes:

a) Classe Nota (Figura 2): definição da entidade do banco de dados para armazenar as anotações.

b) Interface NotaDao (Figura 3): criação do DAO para inserir e recuperar notas no banco de dados.

c) Classe AppDatabase (Figura 4): implementação do banco de dados utilizando Room.

4) Implementar o código da Figura 6 que implementa a MainActivity:

Figura 6 - Implementando a tela de cadastro de notas em Jetpack Compose
Fonte: o autor.

#PraCegoVer: a figura apresenta 31 linhas. Na linha 1, está escrito “class MainActivity : ComponentActivity() {”; na linha 2, “private lateinit var db: AppDatabase”; na linha 4, “override fun onCreate(savedInstanceState: Bundle?) {”; na linha 5, “super.onCreate(savedInstanceState)”; na linha 6, “enableEdgeToEdge()”; na linha 8, “db = Room.databaseBuilder(applicationContext, AppDatabase::class.java, "notas-database")”; na linha 9, “.build()”; na linha 11, “setContent {”; na linha 23, “RoomTheme {”; na linha 13, “Scaffold(modifier = Modifier.fillMaxSize()) { innerPadding ->”; na linha 14, “NotaCadastroScreen(”; na linha 15, “modifier = Modifier.padding(innerPadding)”; na linha 16, “onSave = { titulo, conteudo -> salvarNota(titulo, conteudo) }”; na linha 17, “)”; na linha 18, “}”; na linha 19, “}”; na linha 20 “}”; na linha 21, “}”; na linha 23, “private fun salvarNota(titulo: String, conteudo: String) {”; na linha 24, “lifecycleScope.launch(Dispatchers.IO) {”; na linha 25, “val notaDao = db.notaDao()”; na linha 26, “val novaNota = Nota(titulo = titulo, conteudo = conteudo)”; na linha 27, “notaDao.inserirNota(novaNota)”; na linha 28, “Log.d("DatabaseLog", "Nota salva: Titulo: $titulo, Conteúdo: $conteudo")”; na linha 29, “}”; na linha 30, “}”; e, na linha 31, “}”. Nas linhas 7, 10 e 22, não há conteúdo escrito. Fim da descrição.

5) Na sequência, implemente o componente NotaCadastroScreen() na Figura 7:

Figura 7 - Criação do Composable de cadastro de notas em Jetpack Compose
Fonte: o autor.

#PraCegoVer: a figura apresenta 49 linhas. Na linha 1, está escrito “@Composable”; na linha 2, “fun NotaCadastroScreen(modifier: Modifier = Modifier, onSave: (String, String) -> Unit) {”; na linha 3, “var titulo by remember { mutableStateOf("") }”; na linha 4, “var conteudo by remember { mutableStateOf("") }”; na linha 6, “Column(”; na linha 7, “modifier = modifier.fillMaxSize().padding(16.dp)”; na linha 8, “verticalArrangement = Arrangement.Center”; na linha 9, “horizontalAlignment = Alignment.CenterHorizontally”; na linha 10, “) {”; na linha 11, “Text(”; na linha 12, “text = ‘Nova Nota’”; na linha 13, “style = MaterialTheme.typography.titleLarge”; na linha 14, “modifier = Modifier.padding(bottom = 16.dp)”; na linha 15, “)”; na linha 17, “OutlinedTextField(”; na linha 18, “value = titulo”; na linha 19, “onValueChange = { titulo = it }”; na linha 20, “label = { Text("Título") }”; na linha 21, “singleLine = true”; na linha 22, “modifier = Modifier.fillMaxWidth()”; na linha 23, “)”; na linha 25, “Spacer(modifier = Modifier.height(12.dp))”; na linha 27, “OutlinedTextField(”; na linha 28, “value = conteúdo”; na linha 29, “onValueChange = { conteudo = it }”; na linha 30, “label = { Text("Conteúdo") }”; na linha 31, “modifier = Modifier.fillMaxWidth().height(150.dp)”; na linha 32, “)”; na linha 34, “Spacer(modifier = Modifier.height(24.dp))”; na linha 36, “Button(”; na linha 37, “onClick = {”; na linha 38, “if (titulo.isNotBlank() && conteudo.isNotBlank()) {”; na linha 39, “onSave(titulo, conteudo)”; na linha 40, titulo = ’’”; na linha 41, “conteudo = ’’”; na linha 42, “}”; na linha 43, “}”; na linha 44, “modifier = Modifier.fillMaxWidth()”; na linha 45, “) {”; na linha 46, “Text(text = “Salvar Nota”)”; na linha 47, “}”; na linha 48, “}”; e, na linha 49, “}”. Nas linhas 5, 16, 24, 26, 33 e 35, não há conteúdo escrito. Fim da descrição.

Com esse desafio, você implementou a persistência de dados utilizando o ORM Room. Agora, desafie seus colegas e/ou professores a criar a tela que visualização das notas salvas. E aí, pronto para esse novo desafio?

REFERÊNCIAS

MACHADO, K. Angular 11 e Firebase: construindo uma aplicação integrada com a plataforma do Google. São Paulo: Casa do Código, 2021.

RESENDE, K. Kotlin com Android: crie aplicativos de maneira fácil e divertida. São Paulo: Casa do Código, 2018.

Page updated

Google Sites

Report abuse