Repositório de dado

Prévia do material em texto

<p>UNIVERSIDADE PITÁGORAS UNOPAR ANHANGUERA</p><p>CURSO</p><p>NOME</p><p>ATIVIDADE PRÁTICA</p><p>REPOSITÓRIO DE DADOS</p><p>CIDADE</p><p>ANO</p><p>NOME</p><p>ATIVIDADE PRÁTICA</p><p>REPOSITÓRIO DE DADOS</p><p>Trabalho apresentado à Universidade, como requisito parcial para a obtenção de média semestral nas disciplinas norteadoras do semestre letivo.</p><p>Tutor (a): INSERIR NOME</p><p>CIDADE</p><p>ANO</p><p>SUMÁRIO</p><p>INTRODUÇÃO	3</p><p>MÉTODOS E RESULTADOS	4</p><p>CONCLUSÃO	21</p><p>REFERÊNCIAS BIBLIOGRÁFICAS	22</p><p>INTRODUÇÃO</p><p>O desenvolvimento de aplicações móveis para Android envolve a compreensão e implementação de diversos conceitos que abrangem desde a criação da estrutura básica de um aplicativo até o armazenamento e recuperação de dados. Este portfólio reúne as atividades práticas desenvolvidas ao longo do curso de Repositório de Dados, com foco em aplicações Android e no uso de frameworks como Ionic para criar funcionalidades robustas e eficientes.</p><p>As atividades realizadas têm como objetivo central a criação e configuração de aplicações Android, abordando aspectos como compatibilidade de dispositivos, manipulação de dados utilizando arquivos no formato JSON e o uso de ferramentas como o Logcat para a detecção e correção de erros. Além disso, o portfólio inclui a criação de uma aplicação simples utilizando o framework Ionic, com a finalidade de armazenar dados localmente no dispositivo.</p><p>Ao longo deste portfólio, será apresentada a criação de uma aplicação Android básica, destacando os elementos fundamentais de um projeto, como o arquivo de manifesto e a configuração das propriedades essenciais no Google Colab. Outro ponto de destaque é o desenvolvimento de uma aplicação que armazena e recupera dados no formato JSON, explorando o armazenamento interno do dispositivo. Além disso, foi utilizado o Logcat para identificar e corrigir problemas no desenvolvimento, por meio de um processo prático de detecção de erros e solução de desafios específicos.</p><p>A última atividade explora a criação de uma aplicação com Ionic, que permite ao usuário inserir e armazenar dados localmente, utilizando o Node.js e o Android Studio para emulação e testes. Essa abordagem visa ampliar a compreensão dos alunos sobre o desenvolvimento multiplataforma, integrando tecnologias que facilitam a criação de aplicações móveis com funcionalidades de armazenamento.</p><p>Esse conjunto de atividades reflete uma visão prática e aplicada dos principais conceitos envolvidos no desenvolvimento de aplicações Android e no uso de frameworks modernos, proporcionando uma sólida base para futuros projetos na área de repositório de dados móveis.</p><p>MÉTODOS E RESULTADOS</p><p>Atividade 1 – Fundamentos De Um App</p><p>A primeira atividade prática deste portfólio teve como objetivo a criação de uma aplicação Android simples, abordando os conceitos fundamentais relacionados à estrutura básica de um aplicativo. A seguir, apresento o relatório detalhado das etapas realizadas.</p><p>1. Configuração Inicial</p><p>A atividade iniciou com a criação de um novo projeto no Android Studio. Para isso, selecionei a opção de criar um projeto com uma Activity vazia, fornecendo um nome adequado ao projeto e configurando o diretório de salvamento. Após a criação do projeto, foi realizada a configuração do arquivo `AndroidManifest.xml`, que é o responsável por definir as propriedades fundamentais do aplicativo, como permissões e informações sobre as atividades. Esse arquivo também serve como um ponto central para a definição de informações essenciais sobre o aplicativo, como seu ícone, nome e atividades principais.</p><p>No arquivo `AndroidManifest.xml`, foi incluída a Activity principal, garantindo que o aplicativo inicie corretamente quando executado. Esse arquivo também foi configurado para fornecer as permissões necessárias para a execução da aplicação em diferentes dispositivos.</p><p>2. Compatibilidade de Dispositivos</p><p>Uma parte importante desta atividade foi garantir a compatibilidade do aplicativo com diferentes versões do Android. Para isso, acessei o arquivo `build.gradle` e configurei tanto a versão mínima (minSdkVersion) quanto a versão alvo (targetSdkVersion) do SDK, que define a gama de dispositivos que poderão executar o aplicativo. A versão mínima foi ajustada para garantir que o aplicativo seja compatível com uma ampla variedade de dispositivos, sem comprometer a funcionalidade moderna esperada para as versões mais recentes.</p><p>Essa etapa é fundamental para garantir que o aplicativo possa ser executado em dispositivos mais antigos, ao mesmo tempo em que oferece suporte a recursos mais avançados disponíveis em versões recentes do Android.</p><p>3. Recursos de um Aplicativo</p><p>Na sequência, foram adicionados os recursos ao aplicativo, como strings, cores e layouts. O arquivo `strings.xml` foi utilizado para armazenar o texto exibido na interface do usuário, facilitando a manutenção e a tradução futura do aplicativo. Além disso, defini cores personalizadas no arquivo `colors.xml`, garantindo uma aparência visual agradável e consistente.</p><p>A estrutura do layout foi definida no arquivo `activity_main.xml`, utilizando o componente `TextView` para exibir o texto "Hello, World!" no centro da tela. Para centralizar o texto, utilizei o layout `ConstraintLayout`, ajustando as margens e restrições necessárias para garantir que o texto fosse exibido corretamente, independentemente do tamanho da tela do dispositivo.</p><p>4. Execução do Aplicativo</p><p>Após a configuração dos recursos, compilei e executei o aplicativo tanto em um emulador quanto em um dispositivo físico. A execução foi bem-sucedida em ambos os casos, e o texto "Hello, World!" foi exibido corretamente no centro da tela, conforme o esperado.</p><p>Essa etapa de execução é crucial para validar o comportamento do aplicativo em diferentes ambientes, garantindo que ele funcione conforme o planejado tanto em emuladores quanto em dispositivos físicos.</p><p>A realização dessa atividade prática proporcionou uma compreensão aprofundada sobre a estrutura básica de um projeto Android, desde a configuração inicial até a adição de recursos e a execução do aplicativo. Além disso, foi possível explorar aspectos importantes relacionados à compatibilidade de dispositivos e à organização de recursos.</p><p>Atividade 2 - Armazenamento de Dados em Dispositivos Móveis II</p><p>A segunda atividade prática deste portfólio teve como foco a implementação de uma aplicação Android capaz de armazenar e recuperar dados em formato JSON, utilizando o armazenamento interno do dispositivo. O objetivo principal foi criar uma interface de usuário para inserir e exibir dados e implementar a lógica necessária para manipulação dos dados em JSON. A seguir, apresento o relatório detalhado das etapas realizadas.</p><p>1. Configuração Inicial</p><p>A atividade iniciou com a criação de um novo projeto no Android Studio, utilizando a configuração padrão para uma Activity vazia. Após a criação do projeto, foi realizada a configuração do arquivo `AndroidManifest.xml`, que define as propriedades principais da aplicação, como permissões e informações sobre as Activities.</p><p>Dentro do `AndroidManifest.xml`, a Activity principal foi configurada adequadamente, e as permissões necessárias para o armazenamento de dados no dispositivo foram incluídas, garantindo que o aplicativo possa acessar o armazenamento interno com segurança.</p><p>2. Criação da Interface do Usuário</p><p>A interface do usuário foi desenvolvida no arquivo `activity_main.xml`, utilizando componentes básicos do Android, como `EditText` para a inserção de dados e `TextView` para a exibição dos dados armazenados. Foi criado um botão que, ao ser pressionado, salva os dados inseridos no formato JSON. Outro botão foi adicionado para carregar os dados salvos e exibi-los na interface.</p><p>A disposição dos componentes foi organizada utilizando o layout `LinearLayout`, facilitando a visualização e a interação com o aplicativo. A interface foi planejada para ser simples e funcional, permitindo uma interação direta com as funcionalidades de salvar e carregar dados.</p><p>3. Armazenamento e Recuperação de Dados</p><p>A lógica para armazenar</p><p>e recuperar dados em formato JSON foi implementada na classe `MainActivity`. Para o armazenamento, foram utilizados os métodos `saveData` e `loadData`, que lidam diretamente com a escrita e leitura de arquivos JSON no armazenamento interno do dispositivo.</p><p>3.1. Armazenamento de Dados (saveData): Neste método, os dados inseridos pelo usuário no campo `EditText` foram convertidos para o formato JSON e salvos em um arquivo no armazenamento interno. Foi utilizado o método `openFileOutput` para criar e escrever no arquivo JSON. A conversão dos dados para o formato JSON foi feita utilizando a classe `JSONObject`, garantindo a estrutura correta dos dados.</p><p>3.2. Recuperação de Dados (loadData): Para recuperar os dados salvos, o método `openFileInput` foi utilizado para abrir o arquivo JSON armazenado, e os dados foram lidos e convertidos de volta para texto, utilizando novamente a classe `JSONObject`. Os dados recuperados foram exibidos no componente `TextView`, permitindo ao usuário visualizar as informações previamente salvas.</p><p>Esses métodos garantem que os dados sejam salvos de forma persistente no dispositivo e possam ser carregados mesmo após o fechamento do aplicativo, garantindo a integridade das informações.</p><p>4. Execução do Aplicativo</p><p>Após a implementação da lógica de armazenamento e recuperação de dados, o aplicativo foi compilado e executado tanto em um emulador quanto em um dispositivo físico. Durante os testes, verifiquei se os dados inseridos pelo usuário eram salvos corretamente no arquivo JSON e, em seguida, carregados e exibidos de forma adequada na interface.</p><p>Os testes mostraram que o aplicativo funcionou conforme o esperado, com os dados sendo salvos e recuperados sem falhas. Tanto a inserção quanto a exibição dos dados ocorreram de maneira fluida, confirmando o sucesso da implementação.</p><p>Esta atividade proporcionou uma compreensão prática de como manipular dados em formato JSON no Android, abordando desde a criação de uma interface de usuário funcional até a implementação da lógica de armazenamento e recuperação de dados. A atividade reforçou a importância de utilizar o armazenamento interno para manter a integridade dos dados em um dispositivo Android e demonstrou como os dados podem ser gerenciados de forma eficiente em uma aplicação real. A correta implementação dos métodos `saveData` e `loadData` garantiu a persistência dos dados, sendo um passo crucial para o desenvolvimento de aplicações mais complexas.</p><p>Atividade 3 - Armazenamento de Dados em Dispositivos Móveis II</p><p>A terceira atividade prática deste portfólio teve como objetivo a criação de uma aplicação Android que permite o armazenamento e a recuperação de dados em formato JSON, utilizando o armazenamento interno do dispositivo. Esta atividade reforça os conceitos de persistência de dados e manipulação de arquivos no Android. A seguir, apresento o relatório detalhado das etapas realizadas.</p><p>1. Configuração Inicial</p><p>A atividade iniciou com a criação de um novo projeto no Android Studio, utilizando a configuração padrão para uma Activity vazia. Após a criação do projeto, o arquivo `AndroidManifest.xml` foi configurado adequadamente para definir as permissões necessárias para acessar o armazenamento interno. A Activity principal foi devidamente registrada no `AndroidManifest.xml`, garantindo o correto funcionamento da aplicação.</p><p>O `AndroidManifest.xml` desempenha um papel essencial na configuração inicial do aplicativo, especialmente no que diz respeito às permissões que garantem o acesso ao armazenamento do dispositivo. Essas configurações foram realizadas para que o aplicativo possa ler e gravar arquivos de maneira adequada no armazenamento interno.</p><p>2. Criação da Interface do Usuário</p><p>Para permitir a interação do usuário com a aplicação, a interface foi desenvolvida no arquivo `activity_main.xml`. Elementos de interface foram adicionados para possibilitar a inserção e exibição de dados. Especificamente, utilizei um campo `EditText` para que o usuário possa inserir os dados e um componente `TextView` para exibir os dados recuperados.</p><p>Além disso, foram adicionados dois botões, um para salvar os dados inseridos e outro para carregar os dados previamente salvos. A interface foi projetada para ser simples e funcional, permitindo ao usuário interagir de forma intuitiva com as funcionalidades de salvar e recuperar dados.</p><p>O layout foi estruturado usando o `LinearLayout` para facilitar o posicionamento dos elementos de interface e garantir a responsividade em diferentes dispositivos.</p><p>3. Armazenamento e Recuperação de Dados</p><p>A implementação da lógica de armazenamento e recuperação de dados foi realizada dentro da classe `MainActivity`. Foram criados dois métodos principais: `saveData` e `loadData`, responsáveis pela manipulação dos dados em formato JSON no armazenamento interno do dispositivo.</p><p>3.1. Armazenamento de Dados (saveData): O método `saveData` foi implementado para capturar o texto inserido pelo usuário no campo `EditText`, convertê-lo para o formato JSON utilizando a classe `JSONObject`, e salvá-lo em um arquivo no armazenamento interno. Para gravar o arquivo, utilizei o método `openFileOutput`, que permite a escrita de dados no formato adequado.</p><p>3.2. Recuperação de Dados (loadData): O método `loadData` foi implementado para ler o arquivo JSON armazenado e exibir o conteúdo no campo `TextView`. A leitura do arquivo foi realizada através do método `openFileInput`, e o conteúdo foi processado utilizando o `JSONObject` para garantir a correta conversão do JSON para o formato exibível.</p><p>Esses métodos garantem que os dados inseridos pelo usuário sejam armazenados de forma persistente e recuperados de maneira correta, mesmo após o fechamento do aplicativo.</p><p>4. Execução do Aplicativo</p><p>Após a implementação completa da lógica de armazenamento e recuperação de dados, o aplicativo foi compilado e executado tanto em um emulador quanto em um dispositivo físico. Durante os testes, foi possível verificar que o aplicativo funcionava corretamente: os dados inseridos pelo usuário eram salvos em formato JSON no armazenamento interno e recuperados com sucesso quando solicitados.</p><p>Os testes confirmaram que os dados eram gravados de forma persistente e exibidos adequadamente na interface do aplicativo, validando o funcionamento correto dos métodos implementados e da interface de usuário.</p><p>Esta terceira atividade prática consolidou o conhecimento sobre o uso de JSON como formato de armazenamento de dados em uma aplicação Android, além de reforçar os conceitos relacionados à persistência de dados e à manipulação de arquivos no armazenamento interno do dispositivo. A implementação dos métodos `saveData` e `loadData` proporcionou uma visão clara sobre a importância de garantir que os dados do usuário sejam manipulados de maneira eficiente e segura. A execução bem-sucedida do aplicativo demonstrou a funcionalidade adequada do armazenamento e recuperação de dados, cumprindo os objetivos propostos pela atividade.</p><p>Atividade 4 – Testando o App</p><p>A quarta atividade prática deste portfólio teve como objetivo o uso do Logcat para detectar e corrigir problemas comuns no desenvolvimento de aplicativos Android. O Logcat é uma ferramenta essencial para a depuração, pois fornece informações detalhadas sobre o comportamento do aplicativo em tempo de execução, facilitando a identificação e solução de erros. A seguir, apresento o relatório das etapas realizadas nesta atividade.</p><p>1. Configuração do Ambiente</p><p>1.1. Abrir o Android Studio:</p><p>A primeira etapa da atividade foi garantir que o Android Studio estivesse instalado e configurado corretamente. Após a verificação, abri o Android Studio para dar início à criação do projeto.</p><p>1.2. Criar ou abrir um projeto Android:</p><p>Criei um novo projeto Android com uma Activity vazia. O projeto foi nomeado como "LogcatDemo", seguindo as boas práticas de nomenclatura de projetos. Este ambiente foi utilizado para testar a funcionalidade de depuração com o Logcat.</p><p>1.3. Adicionar código problemático:</p><p>Na classe `MainActivity.java`, adicionei</p><p>um trecho de código problemático para simular um erro que deveria ser identificado e corrigido. O erro inserido foi uma tentativa de chamar o método `toString()` em um objeto `String` nulo, o que causaria uma exceção do tipo `NullPointerException`:</p><p>```java</p><p>String text = null;</p><p>Log.d("MainActivity", text.toString()); // Isto causará uma NullPointerException</p><p>```</p><p>Esse erro foi propositalmente introduzido para ser detectado posteriormente com a ajuda do Logcat.</p><p>2. Uso do Logcat</p><p>2.1. Executar a aplicação:</p><p>Após a inserção do código problemático, compilei e executei o aplicativo tanto em um emulador quanto em um dispositivo físico. A execução falhou, como esperado, devido à exceção `NullPointerException`.</p><p>2.2. Abrir o Logcat:</p><p>No Android Studio, abri a aba "Logcat" localizada na parte inferior da interface para observar as mensagens de log geradas pela execução da aplicação. O Logcat fornece um histórico detalhado de logs que permite acompanhar o comportamento do aplicativo em tempo real.</p><p>2.3. Filtrar mensagens de log:</p><p>Usei o filtro de mensagens do Logcat para exibir apenas as informações relacionadas à Activity `MainActivity`. Para isso, filtrei os logs pela tag "MainActivity", que foi utilizada no código para gerar mensagens de log.</p><p>3. Detecção e Correção de Problemas</p><p>3.1. Analisar mensagens de erro:</p><p>Ao observar o Logcat, identifiquei a exceção `NullPointerException`, juntamente com o stack trace completo. A mensagem de erro incluía a linha exata do código onde o erro ocorreu:</p><p>```java</p><p>E/AndroidRuntime: FATAL EXCEPTION: main</p><p>Process: com.example.logcatdemo, PID: 1234</p><p>java.lang.NullPointerException: Attempt to invoke virtual method 'java.lang.String</p><p>java.lang.Object.toString()' on a null object reference</p><p>at com.example.logcatdemo.MainActivity.onCreate(MainActivity.java:16)</p><p>```</p><p>A análise do stack trace revelou que a linha problemática estava no método `onCreate`, onde o método `toString()` estava sendo chamado em um objeto nulo.</p><p>3.2. Corrigir o problema:</p><p>Com base nas informações do Logcat, corrigi o código na classe `MainActivity`. Adicionei uma verificação condicional para garantir que o objeto `text` não fosse nulo antes de tentar acessar o método `toString()`. O código corrigido ficou da seguinte forma:</p><p>```java</p><p>String text = null;</p><p>if (text != null) {</p><p>Log.d("MainActivity", text.toString());</p><p>} else {</p><p>Log.d("MainActivity", "Text is null");</p><p>}</p><p>```</p><p>Essa modificação garantiu que a exceção `NullPointerException` não ocorresse mais.</p><p>3.3. Executar novamente a aplicação:</p><p>Após corrigir o problema, executei novamente o aplicativo no emulador e em um dispositivo físico. O Logcat confirmou que a exceção `NullPointerException` não aparecia mais, e a mensagem "Text is null" foi corretamente exibida no log, indicando que o código agora lidava adequadamente com a condição de nulo.</p><p>4. Boas Práticas</p><p>4.1. Adicionar logs para depuração:</p><p>Adicionei logs em diferentes níveis (`Log.v`, `Log.d`, `Log.i`, `Log.w`, `Log.e`) para explorar como cada nível pode ser utilizado em diferentes cenários de depuração. Esses logs foram inseridos em pontos críticos do código para facilitar a detecção de possíveis problemas futuros. Por exemplo:</p><p>```java</p><p>Log.v("MainActivity", "Verbose log");</p><p>Log.d("MainActivity", "Debug log");</p><p>Log.i("MainActivity", "Info log");</p><p>Log.w("MainActivity", "Warning log");</p><p>Log.e("MainActivity", "Error log");</p><p>```</p><p>4.1. Revisar e limpar logs:</p><p>Por fim, revisei os logs adicionados ao código e removi aqueles que não eram mais necessários, mantendo apenas os logs essenciais para manutenção e suporte. Isso é importante para garantir que o aplicativo final não contenha informações desnecessárias que possam impactar a performance ou expor detalhes internos da aplicação em ambientes de produção.</p><p>Esta atividade prática foi fundamental para consolidar o uso do Logcat como uma ferramenta de depuração no desenvolvimento de aplicativos Android. A introdução de erros deliberados e sua correção por meio da análise de logs demonstrou a eficiência do Logcat na detecção de problemas. A implementação de boas práticas, como a adição de logs em diferentes níveis e a limpeza dos logs antes da liberação do aplicativo, reforçou a importância da organização e monitoramento do código durante o desenvolvimento. A atividade contribuiu para a compreensão da importância de identificar, diagnosticar e corrigir erros de maneira eficaz no ambiente de desenvolvimento Android.</p><p>Atividade 5 - Componentes Ionic Entrada de Dados</p><p>A quinta atividade prática deste portfólio consistiu no desenvolvimento de um aplicativo Android simples usando o framework Ionic, com foco na entrada, armazenamento e exibição de dados localmente. O objetivo principal foi implementar uma funcionalidade que permitisse ao usuário inserir informações por meio de um formulário, armazená-las no dispositivo e, posteriormente, exibi-las na tela inicial. A seguir, apresento o relatório das etapas realizadas nesta atividade.</p><p>1. Criação do Projeto Ionic</p><p>1.1. Abertura do terminal e navegação ao diretório de trabalho:</p><p>Iniciei o processo abrindo o terminal e navegando até o diretório onde desejei criar o projeto.</p><p>1.2. Criação do projeto Ionic:</p><p>Utilizei o comando `ionic start DadosApp blank` para criar um novo projeto Ionic chamado "DadosApp" com um template em branco. Esse template é o ponto de partida ideal para criar um aplicativo personalizado desde o início.</p><p>1.3. Acesso ao diretório do projeto:</p><p>Após a criação do projeto, entrei no diretório do mesmo com o comando `cd DadosApp`, onde todas as configurações e modificações subsequentes foram realizadas.</p><p>2. Configuração da Página de Entrada de Dados</p><p>2.1. Abertura do projeto no editor de código:</p><p>Utilizei o Visual Studio Code (VSCode) para abrir o projeto. Naveguei até o arquivo `src/app/home/home.page.html`, que é responsável por definir a interface da página inicial do aplicativo.</p><p>2.2. Modificação da interface de entrada de dados:</p><p>Substituí o conteúdo do arquivo `home.page.html` com um formulário que permite a entrada de nome e idade. O código HTML implementado foi o seguinte:</p><p>```html</p><p>Entrada de Dados</p><p>Nome</p><p>Idade</p><p>Salvar</p><p>```</p><p>Este código cria um formulário simples com campos de entrada para o nome e a idade do usuário.</p><p>2.3. Configuração da lógica para salvar dados:</p><p>Em seguida, editei o arquivo `home.page.ts`, que define a lógica da página principal. O código foi modificado para implementar a funcionalidade de armazenamento de dados localmente usando o Ionic Storage:</p><p>```typescript</p><p>import { Component } from '@angular/core';</p><p>import { Storage } from '@ionic/storage-angular';</p><p>@Component({</p><p>selector: 'app-home',</p><p>templateUrl: 'home.page.html',</p><p>styleUrls: ['home.page.scss'],</p><p>})</p><p>export class HomePage {</p><p>data = {</p><p>name: '',</p><p>age: null</p><p>};</p><p>constructor(private storage: Storage) {}</p><p>async ngOnInit() {</p><p>await this.storage.create();</p><p>}</p><p>async saveData() {</p><p>await this.storage.set('userData', this.data);</p><p>console.log('Dados salvos:', this.data);</p><p>}</p><p>}</p><p>```</p><p>Esse código permite que os dados inseridos no formulário sejam armazenados localmente usando o método `saveData()`.</p><p>3. Configuração do Ionic Storage</p><p>3.1. Instalação do pacote Ionic Storage:</p><p>Para habilitar o armazenamento de dados, instalei o pacote necessário com o comando:</p><p>```bash</p><p>npm install @ionic/storage-angular</p><p>```</p><p>3.2. Configuração do Ionic Storage no projeto:</p><p>No arquivo `app.module.ts`, importei e configurei o módulo de armazenamento:</p><p>```typescript</p><p>import { IonicStorageModule } from '@ionic/storage-angular';</p><p>@NgModule({</p><p>declarations: [AppComponent],</p><p>entryComponents: [],</p><p>imports: [BrowserModule, IonicModule.forRoot(), AppRoutingModule, IonicStorageModule.forRoot()],</p><p>providers: [{ provide: RouteReuseStrategy, useClass: IonicRouteStrategy }],</p><p>bootstrap: [AppComponent],</p><p>})</p><p>export class AppModule {}</p><p>```</p><p>Essa configuração garante que o Ionic Storage esteja disponível para uso em todo o aplicativo.</p><p>4. Testando a Aplicação</p><p>4.1. Execução da aplicação:</p><p>Após configurar todas as funcionalidades, executei o comando `ionic capacitor run android` para testar o aplicativo em um dispositivo Android e no emulador.</p><p>4.2. Inserção e armazenamento de dados:</p><p>Testei a funcionalidade de entrada de dados inserindo valores nos campos "Nome" e "Idade", pressionando o botão "Salvar". O aplicativo armazenou os dados localmente no dispositivo e exibiu uma mensagem no console, confirmando o sucesso da operação.</p><p>5. Modificação do Aplicativo - Exibição de Dados Salvos</p><p>Após a implementação inicial, adicionei a funcionalidade de listar os dados salvos na tela inicial do aplicativo. Para isso, modifiquei o arquivo `home.page.ts` para incluir um método que recuperasse e exibisse os dados armazenados. O código final incluía a funcionalidade de carregamento dos dados na inicialização da página:</p><p>```typescript</p><p>async loadData() {</p><p>const storedData = await this.storage.get('userData');</p><p>if (storedData) {</p><p>this.data = storedData;</p><p>}</p><p>}</p><p>```</p><p>Esse método foi chamado dentro do `ngOnInit()` para garantir que os dados fossem carregados assim que o aplicativo fosse iniciado.</p><p>A quinta atividade prática proporcionou uma compreensão detalhada sobre o desenvolvimento de aplicações móveis utilizando o Ionic, com ênfase na manipulação e armazenamento de dados localmente. A integração do Ionic Storage foi crucial para garantir que os dados inseridos pelos usuários fossem mantidos no dispositivo. O uso de componentes do Ionic como `ion-input` e `ion-button` facilitou a criação de uma interface amigável e funcional. Ao final, o aplicativo foi testado com sucesso, permitindo a entrada, armazenamento e exibição de dados, completando os requisitos da atividade.</p><p>CONCLUSÃO</p><p>O portfólio apresentado permitiu a realização de atividades práticas fundamentais no contexto do desenvolvimento de aplicações móveis para Android, com ênfase na manipulação de dados e na implementação de funcionalidades robustas utilizando frameworks como o Ionic. Através das etapas descritas, foi possível compreender e aplicar conceitos essenciais, desde a criação da estrutura básica de um aplicativo Android até o uso de ferramentas avançadas como o Logcat para depuração e correção de erros.</p><p>Cada atividade contribuiu para a formação de uma base sólida, abordando a configuração inicial de projetos Android, a compatibilidade com diferentes dispositivos, e a utilização de arquivos JSON para o armazenamento e recuperação de dados. Além disso, o uso do Google Colab para estruturar o projeto e a implementação de soluções de detecção de erros por meio do Logcat proporcionaram uma visão prática dos desafios enfrentados no desenvolvimento de software móvel.</p><p>O destaque final foi a criação de uma aplicação utilizando o Ionic, integrando tecnologias como Node.js e Android Studio para oferecer uma solução multiplataforma que permite o armazenamento de dados localmente. Essa abordagem reforçou a importância da integração entre diferentes ferramentas e frameworks no desenvolvimento de aplicativos móveis modernos.</p><p>Em suma, este portfólio não apenas reforçou o entendimento dos principais conceitos de desenvolvimento para Android, mas também ampliou as capacidades técnicas necessárias para futuros projetos, particularmente no que se refere ao repositório de dados em dispositivos móveis. O conhecimento adquirido ao longo dessas atividades práticas constitui uma base valiosa para o desenvolvimento contínuo e mais avançado na área.</p><p>REFERÊNCIAS BIBLIOGRÁFICAS</p><p>Christopher John Date. An introduction to database systems. Pearson Education India, 1981.</p><p>Ramez Elmasri e Sham Navathe. Fundamentals of Database Systems. 7ª edição. Pearson, 2016.</p><p>Nenad Jukic, Susan Vrbsky e Svetlozar Nestorov. Database systems: Introduction to databases and data warehouses. Pearson, 2014.</p><p>Michael McLaughlin. MySQL Workbench: Data Modeling Development. McGraw Hill Professional, 2013.</p><p>22</p>