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).