Ava2 - Programação para Dispositivos Móveis (IL10315)

Prévia do material em texto

UNIVERSIDADE VEIGA DE ALMEIDA – UVA 
GRADUAÇÃO EM ANÁLISE E DESENVOLVIMENTO DE SISTEMAS 
 
 
 
 
 
ENTREGA DA AVALIAÇÃO - AVA 2 
 
 
MARCELO RICHTER CASSAR 
PROGRAMAÇÃO PARA DISPOSITIVOS MÓVEIS (IL10315) 
 
 
 
 
 
 
Sumário 
1. QUESTÃO ......................................................................................................... 3 
2. DESENVOLVIMENTO ....................................................................................... 4 
Introdução .............................................................................................................. 4 
Do MVC .................................................................................................................. 6 
activity_main.xml ................................................................................................... 8 
MainActivity.java .................................................................................................... 9 
CadastroActivity.java ........................................................................................... 14 
activity_cadastro .................................................................................................. 16 
AlterarActivity.java ............................................................................................... 18 
activity.alterar.xml ............................................................................................... 20 
AndroidManifest.xml ........................................................................................... 22 
Tela ....................................................................................................................... 23 
3. CONCLUSÃO .................................................................................................. 25 
4. REFERÊNCIAS ............................................................................................... 26 
 
 
1. QUESTÃO 
Desenvolvimento de um aplicativo com a persistência de dados com o uso do SQLite no Android 
A persistência é um recurso muito importante no desenvolvimento de aplicativos. Saber trabalhar 
com os diversos tipos de armazenamento permite que você desenvolva projetos mais robustos. O 
desenvolvimento de projetos com uso de banco de dados, seja local ou remoto, é um pré-requisito 
para o desenvolvimento de aplicativos modernos. 
Para a concretização dos conhecimentos obtidos nesta unidade, você deve definir um objeto para 
a criação de sua classe e desenvolver um projeto com uso de persistência de dados com uso do 
SQLite no Android para realizar a manutenção dos diferentes registros de armazenamento, com a 
listagem, inclusão, alteração e exclusão desses registros. 
Crie um aplicativo Android para trabalhar com uma base de dados com uma tabela para 
persistência de dados de um objeto escolhido por você. 
O objeto deve ser definido por meio de uma classe própria, com: 
O mínimo de cinco atributos (com uso de três diferentes tipos de dados) mais o atributo id (long). 
Pelo menos um método construtor. 
Métodos de acesso (setters & getters) para todos os atributos. 
Outros métodos que sejam necessários. 
A aplicação deverá tratar a inclusão, alteração e exclusão dos registros, além de tratar o acesso, 
abertura e fechamento do recurso do banco de dados do SQLite, com o uso da arquitetura em três 
camadas. 
O aplicativo deverá apresentar os dados dos objetos armazenados por meio de uma lista 
(ListView) e apresentar as funcionalidades de inclusão, exclusão e alteração, que podem ser 
realizadas de acordo com a sua escolha. 
Você pode montar as telas a seu critério, desde que atenda aos requisitos de listagem, inclusão, 
exclusão e alteração dos registros. 
 
Procedimentos para elaboração do TD 
Crie um projeto no Android Studio e desenvolva a aplicação. Prepare um documento do Word com 
uma capa (apresentado a instituição, o curso, a disciplina, o aluno e o professor); a introdução do 
trabalho; o conteúdo com a documentação do sistema, contendo a captura das telas e os códigos 
de desenvolvimento das telas (código XML da view); os códigos de programação de todas as 
classes com comentários e apresentação dos testes realizados com o aplicativo com as capturas 
das telas dos testes; a conclusão e a bibliografia do trabalho. 
Realize o envio da tarefa incluindo o arquivo do Word. 
 
2. DESENVOLVIMENTO 
Introdução 
O código implementa as operações CRUD (Create, Read, Update, Delete) para interagir 
com o banco de dados SQLite, que é uma parte importante do padrão arquitetural MVC. Aqui está 
como as operações CRUD são realizadas no código: 
1. **Create (Criar)**: 
 - A operação de criação é realizada quando o usuário insere novos dados através da 
tela de cadastro (`CadastroActivity.java`). 
 - Quando o usuário preenche todos os campos e clica no botão "Gravar", os dados são 
capturados dos campos de texto e inseridos no banco de dados SQLite. 
 - Isso é feito por meio da execução de uma instrução SQL de inserção (`INSERT INTO`) 
no método `cadastrar()` da classe `CadastroActivity.java`. 
 - Os dados inseridos são persistidos no banco de dados para uso futuro. 
2. **Read (Ler)**: 
 - A operação de leitura é executada para exibir os dados existentes na tela principal 
(`MainActivity.java`) em forma de lista. 
 - Isso é realizado recuperando os registros armazenados no banco de dados SQLite e 
exibindo-os na lista. 
 - A leitura dos dados é feita através da execução de uma consulta SQL (`SELECT`) no 
banco de dados na classe `MainActivity.java`, no método `listarDados()`. 
3. **Update (Atualizar)**: 
 - A operação de atualização é realizada quando o usuário deseja modificar os dados 
existentes. 
 - Isso é feito através da tela de alteração (`AlterarActivity.java`), onde os dados 
existentes são carregados nos campos de texto. 
 - Após fazer as alterações desejadas, o usuário clica no botão "Alterar", e os dados 
modificados são atualizados no banco de dados. 
 - A atualização é realizada através da execução de uma instrução SQL de atualização 
(`UPDATE`) no método `alterar()` da classe `AlterarActivity.java`. 
 
4. **Delete (Excluir)**: 
 - A operação de exclusão é executada quando o usuário deseja remover um registro 
existente. 
 - Isso é feito através de um clique longo em um item da lista na tela principal 
(`MainActivity.java`). 
 - Quando o usuário confirma a exclusão na caixa de diálogo, o registro correspondente 
é excluído do banco de dados SQLite. 
 - A exclusão é realizada através da execução de uma instrução SQL de exclusão 
(`DELETE FROM`) no método `excluir()` da classe `MainActivity.java`. 
Em resumo, as operações CRUD permitem ao usuário criar, ler, atualizar e excluir 
registros no banco de dados SQLite, proporcionando uma experiência completa de manipulação 
de dados dentro do aplicativo. Essas operações são essenciais para qualquer aplicativo que lida 
com armazenamento e gerenciamento de dados. 
 
 
Do MVC 
Vamos analisar como o padrão arquitetural MVC (Model-View-Controller) é aplicado em 
cada arquivo do projeto: 
No contexto do Android, a camada de modelo (Model) geralmente é representada pelos 
arquivos de banco de dados SQLite e pelas classes de modelo que representam os dados. 
No projeto, o modelo é representado pelo banco de dados SQLite, que é criado e 
manipulado nos arquivos CadastroActivity.java, AlterarActivity.java e MainActivity.java. Esses 
arquivos interagem diretamente com o banco de dados SQLite para realizar operações CRUD. 
Além disso, não há classes de modelo específicas neste projeto, mas os dados são 
representados pelos campos de entrada (EditText) nos arquivos de layout XML e manipulados 
pelos componentes de interface do usuário. 
A camada de visualização (View) éresponsável pela apresentação dos dados ao usuário 
e pela interação com ele. 
Nos arquivos XML de layout (activity_cadastro.xml, activity_main.xml, activity_alterar.xml), 
a estrutura visual da interface do usuário é definida. Esses arquivos determinam como os 
elementos da interface do usuário são organizados na tela, como botões, campos de texto e listas. 
Além disso, as classes Java (CadastroActivity.java, MainActivity.java, AlterarActivity.java) 
atuam como controladores indiretos, pois lidam com eventos de interface do usuário e atualizam 
a visualização conforme necessário. 
A camada de controlador (Controler) lida com a lógica de negócios, processando as 
entradas do usuário, tomando decisões e atualizando o modelo e a visualização conforme 
necessário. 
Nos arquivos Java (CadastroActivity.java, MainActivity.java, AlterarActivity.java), as 
classes atuam como controladores. Elas respondem aos eventos de interface do usuário, como 
cliques em botões, inserção de dados e seleção de itens, e coordenam as interações entre o 
modelo e a visualização. 
Por exemplo, nos métodos cadastrar(), listarDados(), alterar(), excluir() dessas classes, a 
lógica de negócios é implementada para lidar com as operações CRUD, interagindo com o modelo 
(banco de dados SQLite) e atualizando a visualização conforme necessário. 
Portanto, o padrão MVC é aplicado neste projeto de maneira simplificada, onde os 
arquivos de layout XML atuam como a camada de visualização, os arquivos Java atuam como 
controladores e o banco de dados SQLite atua como a camada de modelo, fornecendo uma 
separação clara das responsabilidades entre as diferentes partes do aplicativo. 
 
Das 5 propriedades 
Em CadastroActivity.java defini as 5 propriedades exigidas no trabalho: data, nome, sobrenome, 
idade e nacionalidade. 
 
 
activity_main.xml 
<?xml version="1.0" encoding="utf-8"?> 
<androidx.constraintlayout.widget.ConstraintLayout 
xmlns:android="http://schemas.android.com/apk/res/android" 
 xmlns:app="http://schemas.android.com/apk/res-auto" 
 xmlns:tools="http://schemas.android.com/tools" 
 android:id="@+id/main" 
 android:layout_width="match_parent" 
 android:layout_height="match_parent" 
 tools:context=".MainActivity"> 
 
 <ListView 
 android:id="@+id/listViewDados" 
 android:layout_width="0dp" 
 android:layout_height="0dp" 
 android:layout_marginStart="72dp" 
 android:layout_marginTop="64dp" 
 android:layout_marginEnd="72dp" 
 android:layout_marginBottom="179dp" 
 app:layout_constraintBottom_toTopOf="@+id/buttonCadastrar" 
 app:layout_constraintEnd_toEndOf="parent" 
 app:layout_constraintStart_toStartOf="parent" 
 app:layout_constraintTop_toTopOf="parent" /> 
 
 <Button 
 android:id="@+id/buttonCadastrar" 
 android:layout_width="175dp" 
 android:layout_height="96dp" 
 android:layout_marginBottom="71dp" 
 android:text="Cadastrar" 
 app:layout_constraintBottom_toBottomOf="parent" 
 app:layout_constraintEnd_toEndOf="parent" 
 app:layout_constraintStart_toStartOf="parent" 
 app:layout_constraintTop_toBottomOf="@+id/listViewDados" /> 
</androidx.constraintlayout.widget.ConstraintLayout> 
 
 
MainActivity.java 
package com.exemple.myapplication; 
 
import android.content.DialogInterface; 
import android.content.Intent; 
import android.database.Cursor; 
import android.database.sqlite.SQLiteDatabase; 
import android.database.sqlite.SQLiteStatement; 
import android.os.Bundle; 
import android.view.View; 
import android.widget.AdapterView; 
import android.widget.ArrayAdapter; 
import android.widget.Button; 
import android.widget.ListView; 
 
import androidx.activity.EdgeToEdge; 
import androidx.appcompat.app.AlertDialog; 
import androidx.appcompat.app.AppCompatActivity; 
import androidx.core.graphics.Insets; 
import androidx.core.view.ViewCompat; 
import androidx.core.view.WindowInsetsCompat; 
 
import java.util.ArrayList; 
 
public class MainActivity extends AppCompatActivity { 
 
 private SQLiteDatabase bancoDados; 
 private ListView listViewDados; 
 private Button botao; 
 private ArrayList<Integer> arrayIds; 
 private Integer idSelecionado; 
 
 // Construtor vazio 
 public MainActivity() { 
 } 
 
 // Getters e Setters 
 public SQLiteDatabase getBancoDados() { 
 return bancoDados; 
 } 
 
 public void setBancoDados(SQLiteDatabase bancoDados) { 
 this.bancoDados = bancoDados; 
 } 
 
 public ListView getListViewDados() { 
 return listViewDados; 
 } 
 
 public void setListViewDados(ListView listViewDados) { 
 this.listViewDados = listViewDados; 
 } 
 
 public Button getBotao() { 
 return botao; 
 } 
 
 public void setBotao(Button botao) { 
 this.botao = botao; 
 } 
 
 public ArrayList<Integer> getArrayIds() { 
 return arrayIds; 
 } 
 
 public void setArrayIds(ArrayList<Integer> arrayIds) { 
 this.arrayIds = arrayIds; 
 } 
 
 public Integer getIdSelecionado() { 
 return idSelecionado; 
 } 
 
 public void setIdSelecionado(Integer idSelecionado) { 
 this.idSelecionado = idSelecionado; 
 } 
 
 @Override 
 protected void onCreate(Bundle savedInstanceState) { 
 super.onCreate(savedInstanceState); 
 EdgeToEdge.enable(this); 
 setContentView(R.layout.activity_main); 
 
 listViewDados = findViewById(R.id.listViewDados); 
 botao = findViewById(R.id.buttonCadastrar); 
 botao.setOnClickListener(new View.OnClickListener() { 
 @Override 
 public void onClick(View v) { 
 abrirTelaCadastro(); 
 } 
 }); 
 
 listViewDados.setOnItemLongClickListener(new 
AdapterView.OnItemLongClickListener() { 
 @Override 
 public boolean onItemLongClick(AdapterView<?> parent, View 
view, int position, long id) { 
 idSelecionado = arrayIds.get(position); 
 confirmaExcluir(); 
 return true; 
 } 
 }); 
 
 listViewDados.setOnItemClickListener(new 
AdapterView.OnItemClickListener() { 
 @Override 
 public void onItemClick(AdapterView<?> parent, View view, 
int position, long id) { 
 idSelecionado = arrayIds.get(position); 
 abrirTelaAlterar(); 
 } 
 }); 
 
 criarBancoDados(); 
 listarDados(); 
 
 
ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.main), (v, 
insets) -> { 
 Insets systemBars = 
insets.getInsets(WindowInsetsCompat.Type.systemBars()); 
 v.setPadding(systemBars.left, systemBars.top, 
systemBars.right, systemBars.bottom); 
 return insets; 
 }); 
 } 
 
 @Override 
 protected void onResume() { 
 super.onResume(); 
 listarDados(); 
 } 
 
 public void criarBancoDados() { 
 try { 
 bancoDados = openOrCreateDatabase("crudapp2", 
MODE_PRIVATE, null); 
 bancoDados.execSQL("CREATE TABLE IF NOT EXISTS banco2(" 
 + "id INTEGER PRIMARY KEY AUTOINCREMENT, " + 
 "nome TEXT, sobrenome TEXT, " + 
 "idade INTEGER, " + 
 "data_nascimento DATE, " + 
 "pais TEXT)"); 
 bancoDados.close(); 
 } catch (Exception e) { 
 e.printStackTrace(); 
 } 
 } 
 
 public void apagarBancoDados() { 
 try { 
 bancoDados = openOrCreateDatabase("crudapp2", 
MODE_PRIVATE, null); 
 String sql = "DROP TABLE IF EXISTS banco2"; 
 bancoDados.execSQL(sql); 
 bancoDados.close(); 
 recreate();} catch (Exception e) { 
 e.printStackTrace(); 
 } 
 } 
 
 public void listarDados() { 
 try { 
 arrayIds = new ArrayList<>(); 
 bancoDados = openOrCreateDatabase("crudapp2", 
MODE_PRIVATE, null); 
 Cursor meuCursor = bancoDados.rawQuery("SELECT id, nome 
FROM banco2", null); 
 ArrayList<String> linhas = new ArrayList<String>(); 
 if (meuCursor != null && meuCursor.moveToFirst()) { 
 do { 
 linhas.add("ID: " + meuCursor.getInt(0) + ", Nome: 
" + meuCursor.getString(1)); 
 arrayIds.add(meuCursor.getInt(0)); 
 } while (meuCursor.moveToNext()); 
 } 
 ArrayAdapter meuAdapter = new ArrayAdapter<String>( 
 this, 
 android.R.layout.simple_list_item_1, 
 android.R.id.text1, 
 linhas 
 ); 
 listViewDados.setAdapter(meuAdapter); 
 meuCursor.close(); 
 } catch (Exception e) { 
 e.printStackTrace(); 
 } 
 } 
 
 public void abrirTelaCadastro() { 
 try { 
 Intent intent = new Intent(this, CadastroActivity.class); 
 startActivity(intent); 
 } catch (Exception e) { 
 e.printStackTrace(); 
 } 
 } 
 
 public void excluir() { 
 try { 
 bancoDados = openOrCreateDatabase("crudapp2", 
MODE_PRIVATE, null); 
 String sql = "DELETE FROM banco2 WHERE id=?"; 
 SQLiteStatement stmt = bancoDados.compileStatement(sql); 
 stmt.bindLong(1, idSelecionado); 
 stmt.executeUpdateDelete(); 
 listarDados(); 
 bancoDados.close(); 
 } catch (Exception e) { 
 e.printStackTrace(); 
 } 
 } 
 
 public void confirmaExcluir() { 
 AlertDialog.Builder msgBox = new 
AlertDialog.Builder(MainActivity.this); 
 msgBox.setTitle("Excluir"); 
 msgBox.setIcon(android.R.drawable.ic_menu_delete); 
 msgBox.setMessage("Realmente deseja excluir o registro?"); 
 msgBox.setPositiveButton("Sim", new 
DialogInterface.OnClickListener() { 
 @Override 
 public void onClick(DialogInterface dialogInterface, int 
i) { 
 excluir(); 
 } 
 }); 
 msgBox.setNegativeButton("Não", new 
DialogInterface.OnClickListener() { 
 @Override 
 public void onClick(DialogInterface dialogInterface, int 
i) { 
 } 
 }); 
 msgBox.show(); 
 } 
 
 public void abrirTelaAlterar() { 
 Intent intent = new Intent(this, AlterarActivity.class); 
 intent.putExtra("id", idSelecionado); 
 startActivity(intent); 
 } 
 
} 
 
CadastroActivity.java 
package com.exemple.myapplication; 
 
import androidx.appcompat.app.AppCompatActivity; 
 
import android.database.Cursor; 
import android.database.sqlite.SQLiteDatabase; 
import android.database.sqlite.SQLiteStatement; 
import android.os.Bundle; 
import android.text.TextUtils; 
import android.view.View; 
import android.widget.Button; 
import android.widget.EditText; 
 
public class CadastroActivity extends AppCompatActivity { 
 private EditText editTextNome, editTextSobreNome, editTextIdade, 
editTextDataNascimento, editTextPais; 
 private Button botao; 
 private SQLiteDatabase bancoDados; 
 
 // Construtor vazio 
 public CadastroActivity() { 
 } 
 
 // Getters e Setters 
 public EditText getEditTextNome() { 
 return editTextNome; 
 } 
 
 public void setEditTextNome(EditText editTextNome) { 
 this.editTextNome = editTextNome; 
 } 
 
 public EditText getEditTextSobreNome() { 
 return editTextSobreNome; 
 } 
 
 public void setEditTextSobreNome(EditText editTextSobreNome) { 
 this.editTextSobreNome = editTextSobreNome; 
 } 
 
 public EditText getEditTextIdade() { 
 return editTextIdade; 
 } 
 
 public void setEditTextIdade(EditText editTextIdade) { 
 this.editTextIdade = editTextIdade; 
 } 
 
 public EditText getEditTextDataNascimento() { 
 return editTextDataNascimento; 
 } 
 
 public void setEditTextDataNascimento(EditText 
editTextDataNascimento) { 
 this.editTextDataNascimento = editTextDataNascimento; 
 } 
 
 public EditText getEditTextPais() { 
 return editTextPais; 
 } 
 
 public void setEditTextPais(EditText editTextPais) { 
 this.editTextPais = editTextPais; 
 } 
 
 public Button getBotao() { 
 return botao; 
 } 
 
 public void setBotao(Button botao) { 
 this.botao = botao; 
 } 
 
 public SQLiteDatabase getBancoDados() { 
 return bancoDados; 
 } 
 
 public void setBancoDados(SQLiteDatabase bancoDados) { 
 this.bancoDados = bancoDados; 
 } 
 
 @Override 
 protected void onCreate(Bundle savedInstanceState) { 
 super.onCreate(savedInstanceState); 
 setContentView(R.layout.activity_cadastro); 
 
 // Inicialize os campos de entrada de dados e o botão 
 editTextNome = findViewById(R.id.editTextNome); 
 editTextSobreNome = findViewById(R.id.editTextSobreNome); 
 editTextIdade = findViewById(R.id.editTextIdade); 
 editTextDataNascimento = 
findViewById(R.id.editTextDataNascimento); 
 editTextPais = findViewById(R.id.editTextPais); 
 botao = findViewById(R.id.buttonCadastrar); 
 
 // Defina o OnClickListener para o botão de Cadastrar 
 botao.setOnClickListener(new View.OnClickListener() { 
 @Override 
 public void onClick(View view) { 
 cadastrar(); 
 //limparTabela(); 
 } 
 }); 
 } 
 
 // Método para cadastrar os dados 
 public void cadastrar(){ 
 //if(!TextUtils.isEmpty(editTextNome.getText().toString())){ 
 try{ 
 // Exibir os dados cadastrados 
 String nome = editTextNome.getText().toString(); 
 String sobrenome = editTextSobreNome.getText().toString(); 
 String idade = editTextIdade.getText().toString(); 
 String dataNascimento = 
editTextDataNascimento.getText().toString(); 
 String pais = editTextPais.getText().toString(); 
 System.out.println("Dados cadastrados:"); 
 System.out.println("Nome: " + nome); 
 System.out.println("Sobrenome: " + sobrenome); 
 System.out.println("Idade: " + idade); 
 System.out.println("Data de Nascimento: " + 
dataNascimento); 
 System.out.println("País: " + pais); 
 
 bancoDados = openOrCreateDatabase("crudapp2", 
MODE_PRIVATE, null); 
 String sql = "INSERT INTO banco2 (nome, sobrenome, idade, 
data_nascimento, pais) VALUES (?, ?, ?, ?, ?)"; 
 SQLiteStatement stmt = bancoDados.compileStatement(sql); 
 stmt.bindString(1, editTextNome.getText().toString()); 
 stmt.bindString(2, 
editTextSobreNome.getText().toString()); 
 stmt.bindString(3, editTextIdade.getText().toString()); 
 stmt.bindString(4, 
editTextDataNascimento.getText().toString()); 
 stmt.bindString(5, editTextPais.getText().toString()); 
 stmt.executeInsert(); 
 
 bancoDados.close(); 
 finish(); 
 } catch (Exception e){ 
 e.printStackTrace(); 
 } 
 //} 
 } 
 
 public void limparTabela() { 
 try { 
 bancoDados = openOrCreateDatabase("crudapp2", 
MODE_PRIVATE, null); 
 String sql = "DROP TABLE IF EXISTS banco2"; 
 bancoDados.execSQL(sql); 
 bancoDados.close();System.out.println("Todos os dados foram removidos da 
tabela."); 
 } catch (Exception e) { 
 e.printStackTrace(); 
 } 
 } 
} 
 
 
 
activity_cadastro 
<?xml version="1.0" encoding="utf-8"?> 
<androidx.constraintlayout.widget.ConstraintLayout 
xmlns:android="http://schemas.android.com/apk/res/android" 
 xmlns:app="http://schemas.android.com/apk/res-auto" 
 xmlns:tools="http://schemas.android.com/tools" 
 android:id="@+id/main" 
 android:layout_width="match_parent" 
 android:layout_height="match_parent" 
 tools:context=".CadastroActivity"> 
 
 <EditText 
 android:id="@+id/editTextNome" 
 android:layout_width="0dp" 
 android:layout_height="wrap_content" 
 android:layout_marginStart="24dp" 
 android:layout_marginTop="32dp" 
 android:layout_marginEnd="24dp" 
 android:ems="10" 
 android:hint="Nome" 
 android:inputType="text" 
 app:layout_constraintEnd_toEndOf="parent" 
 app:layout_constraintStart_toStartOf="parent" 
 app:layout_constraintTop_toTopOf="parent" /> 
 
 <EditText 
 android:id="@+id/editTextSobreNome" 
 android:layout_width="0dp" 
 android:layout_height="wrap_content" 
 android:layout_marginStart="24dp" 
 android:layout_marginTop="16dp" 
 android:layout_marginEnd="24dp" 
 android:ems="10" 
 android:hint="Sobrenome" 
 android:inputType="text" 
 app:layout_constraintEnd_toEndOf="parent" 
 app:layout_constraintStart_toStartOf="parent" 
 app:layout_constraintTop_toBottomOf="@+id/editTextNome" /> 
 
 <EditText 
 android:id="@+id/editTextIdade" 
 android:layout_width="0dp" 
 android:layout_height="wrap_content" 
 android:layout_marginStart="24dp" 
 android:layout_marginTop="16dp" 
 android:layout_marginEnd="24dp" 
 android:ems="10" 
 android:hint="Idade" 
 android:inputType="number" 
 app:layout_constraintEnd_toEndOf="parent" 
 app:layout_constraintStart_toStartOf="parent" 
 app:layout_constraintTop_toBottomOf="@+id/editTextSobreNome" 
/> 
 
 <EditText 
 android:id="@+id/editTextDataNascimento" 
 android:layout_width="0dp" 
 android:layout_height="wrap_content" 
 android:layout_marginStart="24dp" 
 android:layout_marginTop="16dp" 
 android:layout_marginEnd="24dp" 
 android:ems="10" 
 android:hint="Data de Nascimento (dd/mm/aaaa)" 
 android:inputType="text" 
 app:layout_constraintEnd_toEndOf="parent" 
 app:layout_constraintStart_toStartOf="parent" 
 app:layout_constraintTop_toBottomOf="@+id/editTextIdade" /> 
 
 <EditText 
 android:id="@+id/editTextPais" 
 android:layout_width="0dp" 
 android:layout_height="wrap_content" 
 android:layout_marginStart="24dp" 
 android:layout_marginTop="16dp" 
 android:layout_marginEnd="24dp" 
 android:ems="10" 
 android:hint="País" 
 android:inputType="text" 
 app:layout_constraintEnd_toEndOf="parent" 
 app:layout_constraintStart_toStartOf="parent" 
 
app:layout_constraintTop_toBottomOf="@+id/editTextDataNascimento" /> 
 
 <Button 
 android:id="@+id/buttonCadastrar" 
 android:layout_width="wrap_content" 
 android:layout_height="wrap_content" 
 android:text="Gravar" 
 app:layout_constraintEnd_toEndOf="parent" 
 app:layout_constraintStart_toStartOf="parent" 
 app:layout_constraintTop_toBottomOf="@+id/editTextPais" /> 
 
</androidx.constraintlayout.widget.ConstraintLayout> 
 
 
 
AlterarActivity.java 
package com.exemple.myapplication; 
 
import android.content.Intent; 
import android.database.Cursor; 
import android.database.sqlite.SQLiteDatabase; 
import android.database.sqlite.SQLiteStatement; 
import android.os.Bundle; 
import android.view.View; 
import android.widget.Button; 
import android.widget.EditText; 
 
import androidx.appcompat.app.AppCompatActivity; 
 
import com.exemple.myapplication.R; 
 
public class AlterarActivity extends AppCompatActivity { 
 
 private SQLiteDatabase bancoDados; 
 private Button buttonAlterar; 
 private EditText editTextNome, editTextSobreNome, 
editTextNumberIdade, editTextNacionalidade, editTextDateNascimento; 
 private Integer id; 
 
 @Override 
 protected void onCreate(Bundle savedInstanceState) { 
 super.onCreate(savedInstanceState); 
 setContentView(R.layout.activity_alterar); 
 
 buttonAlterar = findViewById(R.id.buttonCadastrar); 
 editTextNome = findViewById(R.id.editTextNome); 
 editTextSobreNome = findViewById(R.id.editTextSobreNome); 
 editTextNumberIdade = findViewById(R.id.editTextNumberIdade); 
 editTextNacionalidade = 
findViewById(R.id.editTextNacionalidade); 
 editTextDateNascimento = 
findViewById(R.id.editTextDateNascimento); 
 
 Intent intent = getIntent(); 
 id = intent.getIntExtra("id", 0); 
 
 carregarDados(); 
 
 buttonAlterar.setOnClickListener(new View.OnClickListener() { 
 @Override 
 public void onClick(View v) { 
 alterar(); 
 } 
 }); 
 } 
 
 public void carregarDados() { 
 try { 
 bancoDados = openOrCreateDatabase("crudapp2", 
MODE_PRIVATE, null); 
 Cursor cursor = bancoDados.rawQuery("SELECT * FROM banco2 
WHERE id = ?", new String[]{String.valueOf(id)}); 
 if (cursor.moveToFirst()) { 
 
editTextNome.setText(cursor.getString(cursor.getColumnIndex("nome"))); 
 
editTextSobreNome.setText(cursor.getString(cursor.getColumnIndex("sobr
enome"))); 
 
editTextNumberIdade.setText(cursor.getString(cursor.getColumnIndex("id
ade"))); 
 
editTextNacionalidade.setText(cursor.getString(cursor.getColumnIndex("
pais"))); 
 
editTextDateNascimento.setText(cursor.getString(cursor.getColumnIndex(
"data_nascimento"))); 
 } 
 cursor.close(); 
 bancoDados.close(); 
 } catch (Exception e) { 
 e.printStackTrace(); 
 } 
 } 
 
 public void alterar() { 
 try { 
 bancoDados = openOrCreateDatabase("crudapp2", 
MODE_PRIVATE, null); 
 String sql = "UPDATE banco2 SET nome=?, sobrenome=?, 
idade=?, pais=?, data_nascimento=? WHERE id=?"; 
 SQLiteStatement stmt = bancoDados.compileStatement(sql); 
 stmt.bindString(1, editTextNome.getText().toString()); 
 stmt.bindString(2, 
editTextSobreNome.getText().toString()); 
 stmt.bindString(3, 
editTextNumberIdade.getText().toString()); 
 stmt.bindString(4, 
editTextNacionalidade.getText().toString()); 
 stmt.bindString(5, 
editTextDateNascimento.getText().toString()); 
 stmt.bindLong(6, id); 
 stmt.executeUpdateDelete(); 
 bancoDados.close(); 
 finish(); 
 } catch (Exception e) { 
 e.printStackTrace(); 
 } 
 } 
} 
 
 
 
activity.alterar.xml 
<?xml version="1.0" encoding="utf-8"?> 
<androidx.constraintlayout.widget.ConstraintLayout 
xmlns:android="http://schemas.android.com/apk/res/android" 
 xmlns:app="http://schemas.android.com/apk/res-auto" 
 xmlns:tools="http://schemas.android.com/tools" 
 android:id="@+id/main" 
 android:layout_width="match_parent" 
 android:layout_height="match_parent" 
 tools:context=".AlterarActivity"> 
 
 <EditText 
 android:id="@+id/editTextNome" 
 android:layout_width="0dp" 
 android:layout_height="wrap_content" 
 android:layout_marginStart="24dp" 
 android:layout_marginTop="24dp"android:layout_marginEnd="24dp" 
 android:ems="10" 
 android:hint="Nome" 
 android:inputType="text" 
 app:layout_constraintEnd_toEndOf="parent" 
 app:layout_constraintStart_toStartOf="parent" 
 app:layout_constraintTop_toTopOf="parent" /> 
 
 <EditText 
 android:id="@+id/editTextNumberIdade" 
 android:layout_width="0dp" 
 android:layout_height="wrap_content" 
 android:layout_marginStart="24dp" 
 android:layout_marginTop="13dp" 
 android:layout_marginEnd="24dp" 
 android:ems="10" 
 android:hint="Idade" 
 android:inputType="number" 
 app:layout_constraintEnd_toEndOf="parent" 
 app:layout_constraintStart_toStartOf="parent" 
 app:layout_constraintTop_toBottomOf="@+id/editTextSobreNome" 
/> 
 
 <EditText 
 android:id="@+id/editTextNacionalidade" 
 android:layout_width="0dp" 
 android:layout_height="wrap_content" 
 android:layout_marginStart="24dp" 
 android:layout_marginTop="16dp" 
 android:layout_marginEnd="24dp" 
 android:ems="10" 
 android:hint="Nacionalidade" 
 android:inputType="text" 
 app:layout_constraintEnd_toEndOf="parent" 
 app:layout_constraintStart_toStartOf="parent" 
 app:layout_constraintTop_toBottomOf="@+id/editTextNumberIdade" 
/> 
 
 <Button 
 android:id="@+id/buttonCadastrar" 
 android:layout_width="wrap_content" 
 android:layout_height="wrap_content" 
 android:layout_marginBottom="131dp" 
 android:text="Alterar" 
 app:layout_constraintBottom_toBottomOf="parent" 
 app:layout_constraintEnd_toEndOf="parent" 
 app:layout_constraintStart_toStartOf="parent" /> 
 
 <EditText 
 android:id="@+id/editTextDateNascimento" 
 android:layout_width="wrap_content" 
 android:layout_height="wrap_content" 
 android:ems="10" 
 android:hint="Nascimento" 
 android:inputType="date" 
 app:layout_constraintBottom_toBottomOf="parent" 
 app:layout_constraintEnd_toEndOf="parent" 
 app:layout_constraintStart_toStartOf="parent" 
 app:layout_constraintTop_toTopOf="parent" /> 
 
 <EditText 
 android:id="@+id/editTextSobreNome" 
 android:layout_width="wrap_content" 
 android:layout_height="wrap_content" 
 android:layout_marginTop="19dp" 
 android:ems="10" 
 android:hint="Sobrenome" 
 android:inputType="text" 
 
app:layout_constraintStart_toStartOf="@+id/editTextNumberIdade" 
 app:layout_constraintTop_toBottomOf="@+id/editTextNome" /> 
 
</androidx.constraintlayout.widget.ConstraintLayout> 
 
AndroidManifest.xml 
<?xml version="1.0" encoding="utf-8"?> 
<manifest xmlns:android="http://schemas.android.com/apk/res/android" 
 xmlns:tools="http://schemas.android.com/tools"> 
 
 <application 
 android:allowBackup="true" 
 android:dataExtractionRules="@xml/data_extraction_rules" 
 android:fullBackupContent="@xml/backup_rules" 
 android:icon="@mipmap/ic_launcher" 
 android:label="@string/app_name" 
 android:roundIcon="@mipmap/ic_launcher_round" 
 android:supportsRtl="true" 
 android:theme="@style/Theme.MyApplication" 
 tools:targetApi="31"> 
 <activity 
 android:name=".AlterarActivity" 
 android:parentActivityName=".MainActivity" 
 android:exported="false" /> 
 <activity 
 android:name=".CadastroActivity" 
 android:exported="false" 
 android:parentActivityName=".MainActivity" 
 /> 
 <activity 
 android:name=".MainActivity" 
 android:exported="true"> 
 <intent-filter> 
 <action android:name="android.intent.action.MAIN" /> 
 
 <category 
android:name="android.intent.category.LAUNCHER" /> 
 </intent-filter> 
 </activity> 
 </application> 
 
</manifest> 
 
 
Telas 
Tela Principal 
 
Tela de Exclusão (alert): 
 
Tela de Alteração: 
 
Tela de Cadastro: 
 
 
 
3. CONCLUSÃO 
Este trabalho apresenta uma aplicação Android de CRUD (Create, Read, Update, Delete) 
que permite ao usuário gerenciar registros em um banco de dados SQLite. A aplicação segue a 
arquitetura MVC (Model-View-Controller), onde a `MainActivity` atua como o controlador, 
interagindo com a interface do usuário (`View`) e manipulando os dados no banco de dados 
(`Model`) por meio da classe `SQLiteOpenHelper`. 
Cada tela da aplicação é responsável por uma operação específica do CRUD: 
- `CadastroActivity`: Permite ao usuário inserir novos registros no banco de dados. 
- `MainActivity`: Lista todos os registros existentes, oferecendo opções para visualizar, 
editar e excluir cada um deles. 
- `AlterarActivity`: Permite ao usuário editar um registro existente no banco de dados. 
Além disso, a aplicação apresenta uma interface intuitiva para o usuário, com botões e 
listas que facilitam a interação. Utiliza-se também o padrão de projeto Observer, onde a lista de 
registros é atualizada automaticamente sempre que ocorre uma modificação no banco de dados. 
 
Em resumo, este projeto demonstra a implementação de uma aplicação Android utilizando 
conceitos importantes de arquitetura de software, como MVC e CRUD, proporcionando uma 
experiência de usuário eficiente e fácil de usar para gerenciar dados em um banco de dados local. 
 
4. REFERÊNCIAS 
DEITEL, Harvey M.; DEITEL, Paul J. Java: como programar. São Paulo: Pearson Prentice Hall, 
2005. 1110 p. ISBN 8576050196. (BV).