WhatsApp: +244 946269760 Facebook: Ja Ta Ki

Mentira Da Programação Androide.

A Programação Androide refere-se ao desenvolvimento de aplicativos para dispositivos móveis que utilizam o
sistema operacional Androide. Isso envolve a utilização de linguagens de programação como Java ou Kotlin,
juntamente com o uso de ferramentas e recursos específicos do Androide SDK (Software Development Kit). Os
desenvolvedores Androide trabalham na criação de aplicativos que atendem a uma variedade de finalidades,
como jogos, redes sociais, utilitários, produtividade e muito mais. Eles precisam compreender os conceitos
fundamentais da plataforma Androide, incluindo a estrutura de aplicativos, layouts de interface do
usuário, componentes de interface, gerenciamento de dados, segurança, integração de serviços e outras
funcionalidades específicas do sistema operacional. Além disso, é importante estar atualizado sobre as
diretrizes de design da Material Design, fornecidas pelo Google, para garantir que os aplicativos tenham
uma aparência e comportamento consistentes em vários dispositivos Androide. Em resumo, a programação
Androide envolve a criação de aplicativos funcionais e atrativos que atendam às necessidades dos usuários,
utilizando as ferramentas e tecnologias disponíveis para a plataforma Androide.

A história do Androide começa em 2003, quando a empresa Androide Inc. foi fundada por Andy Rubin, Rich
Miner, Nick Sears e Chris White. Inicialmente, a empresa tinha como objetivo desenvolver um sistema
operacional para câmeras digitais, mas depois decidiu focar em um sistema operacional para dispositivos
móveis. Em 2005, a Androide Inc. foi adquirida pelo Google, que viu o potencial da empresa e decidiu
investir em seu desenvolvimento. Em 2007, o Google lançou a plataforma Androide, baseada em um sistema
operacional móvel de código aberto, que se tornou um concorrente direto do iOS da Apple. Em setembro de
2008, foi lançada a primeira versão do sistema operacional Androide, chamada de Androide 1.0. Nos anos
seguintes, o Google lançou várias atualizações do sistema operacional, adicionando novos recursos e
aprimorando a experiência do usuário. O Androide rapidamente ganhou popularidade e se tornou o sistema
operacional móvel mais utilizado em todo o mundo. Uma das principais vantagens do Androide é o fato de ser
um sistema de código aberto, o que permite que os desenvolvedores criem aplicativos e personalizem o
sistema de acordo com suas necessidades. Ao longo dos anos, o Androide passou por diversas atualizações
importantes, adicionando recursos como suporte a múltiplas telas, reconhecimento de voz, assistente
pessoal (Google Assistant), sistemas de pagamentos móveis (Androide Pay) e melhorias na segurança do
sistema. O Androide se tornou um ecossistema vasto, com uma enorme quantidade de dispositivos que rodam o
sistema operacional, desde smartphones e tablets, até smart TVs, relógios inteligentes e carros
conectados. Hoje em dia, o Androide continua evoluindo e se mantém como uma das principais plataformas
para desenvolvimento de aplicativos móveis.

1. IDE E PRIMEIRO PROGRAMA: para criar o seu primeiro programa 3.

com o CodeStudio, siga os passos abaixo: 1. Pasta app: contém o código-fonte do aplicativo,
1. Instale e Abre o aplicativo CodeStudio no seu fone. incluindo as classes, layouts, arquivos de recursos e os
2. Abra o aplicativo e clique em "New App" para. assets.
3. Cria um novo projeto: 2. Pasta res: contém todos os recursos, como as imagens,
a. Nome do projeto "Jtk1" ícones, strings, cores e layouts. É subdividida nas
b. Pacote naturalmente comece com "com.___._." pastas drawable, layout, mipmap, values, entre outras.
c. Escolha onde deseja salvá-lo. 3. Pasta manifest: contém arquivo Androidemanifest.xml,
4. Selecione o SDK target (a versão do Androide em que responsável por definir as permissões, as configurações
pretende desenvolver) e clique em "Create" para criar o do aplicativo, as atividades, serviços, broadcast
projeto. receivers, entre outros elementos.
5. O CodeStudio irá gerar automaticamente uma estrutura 4. Pasta gen: contém arquivos gerados automaticamente pelo
básica de projeto para você, incluindo as pastas "src" sistema durante a compilação do aplicativo. Geralmente,
para o código-fonte e "res" para os recursos. não é necessário editar os arquivos dessa pasta.
6. Abra o arquivo "MainActivity.java" localizado em "src" e 5. Pasta libs: contém bibliotecas externas (geralmente em
comece a escrever o código do seu programa Java. formato .jar) que são usadas pelo aplicativo.
7. Por exemplo, você pode escrever um programa simples para 6. Pasta assets: contém recursos que não são compilados
exibir uma mensagem na tela, abaixo do "package". Aqui pelo sistema, como arquivos de vídeos, músicas, imagens,
está um exemplo: html, css, javascript, etc.
```java 7. Pasta build: contém arquivos temporários criados durante
import Androide.app.Activity; o processo de construção do aplicativo.
import Androide.os.Bundle; 8. Pasta gradle: contém o arquivo build.gradle, responsável
import Androide.widget.TextView; pela configuração e compilação do aplicativo.
public class MainActivity extends Activity { Cada pasta e arquivo possui sua devida função no projeto
@Override Androide, sendo extremamente importante seguir as boas práticas
protected void onCreate(Bundle savedInstanceState) { de desenvolvimento e organização para manter a estrutura de
super.onCreate(savedInstanceState); forma adequada.
TextView textView = new TextView(this);
textView.setText("Olá, mundo!"); 4. ARQUITETURA DO ANDROIDE: é baseada em camadas, seguindo o
setContentView(textView); padrão de arquitetura de software em camadas. A seguir,
} estão as principais camadas da arquitetura do Androide:
} 1. Aplicações: essa camada é onde estão os aplicativos
``` desenvolvidos pelos desenvolvedores e que os usuários
8. Clica em "Run" para compilar e executar o aplicativo no interagem. Exemplos de aplicativos são WhatsApp,
emulador ou em um dispositivo físico conectado. Facebook, Instagram, etc.
9. O CodeStudio irá construir o aplicativo e instalá-lo no 2. Framework de aplicativos: esta camada fornece as classes
dispositivo selecionado. Você poderá ver a saída do e estruturas de desenvolvimento para a criação de
programa e interagir com ele. aplicativos. É composta por componentes como Activities,
Até aqui você criou o seu primeiro programa com o Content Providers, Services e Broadcast Receivers.
CodeStudio. A partir daí, você pode explorar mais recursos 3. Bibliotecas Androide: essa camada contém um conjunto de
e funcionalidades do CodeStudio para desenvolver bibliotecas C/C++ que são usadas pelos aplicativos para
aplicativos Androide mais complexos. acesso às funcionalidades do sistema, como a
renderização de gráficos 2D/3D, acesso a banco de dados,
2. ESTRUTURA DE UM APLICATIVO ANDROIDE: Um aplicativo Androide manipulação de imagens, etc.
é composto por várias pastas que contêm diferentes tipos de
arquivos e recursos. A seguir, estão as principais pastas
de um aplicativo Androide:

{
1. Esquece o que ouve
Regra : Aprendizado acelerado , Você 2. Entende o que vê
3. Aprende o que faz
 WhatsApp: +244 946269760 Facebook: Ja Ta Ki
4. Androide Runtime: essa camada é responsável pela
execução dos aplicativos Androide. Ela inclui a máquina  Serviço (Service): é um componente que executa uma
virtual Dalvik ou ART (Androide Runtime), responsável tarefa sem interação com o usuário. Em outras palavras,
por executar o bytecode do aplicativo, que é convertido é um tipo de classe que executa uma tarefa de segundo
a partir do código fonte Java durante a compilação. plano em um aplicativo Androide. No exemplo a seguir,
5. Bibliotecas Nativas: essa camada contém várias vamos criar um serviço simples que exibe uma mensagem na
bibliotecas nativas escritas em linguagens como C e C++. tela a cada 5 segundos.
Elas são usadas pela Androide Runtime e pelo sistema ```
operacional para fornecer funcionalidades de baixo public class MyService extends Service {
nível, como manipulação de gráficos, reprodução de private Timer timer;
áudio, suporte a Bluetooth, etc. @Override
6. Kernel do Linux: essa é a camada mais baixa da public void onCreate() {
arquitetura do Androide. Ela inclui o kernel do Linux, super.onCreate();
que é responsável por gerenciar os recursos do sistema, timer = new Timer();
como memória, processos, drivers de dispositivo, rede, timer.schedule(new TimerTask() {
etc. @Override
Essa arquitetura em camadas permite que o Androide seja public void run() {
altamente personalizável e adaptável a uma ampla variedade de Toast.makeText(MyService.this, "Olá mundo!",
dispositivos, desde smartphones e tablets até TVs inteligentes, Toast.LENGTH_SHORT).show();
smartwatches, carros conectados e muito mais. }
}, 0, 5000);
}
5. VISÃO GERAL: um resumo básico de conceitos e recursos @Override
comuns usados na programação Androide, vamos apresentar public void onDestroy() {
exemplos completos que utiliza os componentes básicos do super.onDestroy();
Androide com Java: timer.cancel();
timer = null;
1. Androide Studio: ambiente de desenvolvimento integrado }
(IDE) usado para desenvolver aplicativos Androide. Já @Nullable
instalamos e criamos um programa simples. @Override
2. Linguagem de programação: a principal linguagem de public IBinder onBind(Intent intent) {
programação usada para desenvolver aplicativos Androide return null;
é a linguagem Java. Kotlin é outra linguagem popular }
usada atualmente, mas usaremos Java pelo poder que ela }
tem. Conforme criamos um projeto em Androide também ```
podemos criar em Java, para entender a logica de
programação. Mas para entender bem Java adquira o nosso  Receptor de Transmissão (Broadcast Receiver): é um tipo
material de Java, e depois resolva os exercícios. de classe que responde a eventos do sistema ou de outros
aplicativos. Em outras palavras, é um componente que
Exercício permite que um aplicativo Androide registe ações do
1.º. Calculadora básica
sistema e faça algo específico quando essas ações
2.º. Conversão de temperatura (Celsius para Fahrenheit)
ocorrem. No exemplo a seguir, vamos criar um receptor de
3.º. Soma dos números pares de 1 até um número informado pelo
transmissão que exibe uma mensagem na tela quando o
usuário
dispositivo for reiniciado.
4.º. Verificar se um número é par ou ímpar
```
5.º. Verificar se um número é primo ou não
public class MyReceiver extends BroadcastReceiver {
6.º. Converter um número decimal para binário
@Override
7.º. Gerador de tabuada
public void onReceive(Context context, Intent intent) {
8.º. Cálculo do IMC (Índice de Massa Corporal)
if (intent.getAction().equals(Intent.ACTION_BOOT_COMPLETED))
9.º. Verificador de idade (maioridade ou não)
{
10.º. Calcular o fatorial de um número
Toast.makeText(context, "Dispositivo reiniciado!",
Toast.LENGTH_SHORT).show();
}
6. Componentes básicos do Androide: atividade, serviço, }
recetor de transmissão e provedor de conteúdo. }
 Atividade (Activity): é uma tela que apresenta uma ```
interface gráfica de usuário (UI). Em outras palavras, é
um tipo de classe que define o que o usuário vê e faz em  Provedor de Conteúdo (Content Provider): permite que um
um aplicativo Androide. No exemplo a seguir, vamos criar aplicativo Androide publique ou consuma dados em um
uma atividade simples que exibe uma mensagem na tela sistema de arquivos compartilhado. Em outras palavras, é
quando o usuário clica em um botão. um tipo de classe que permite que um aplicativo Androide
``` compartilhe ou obtenha dados com outros aplicativos ou
public class MainActivity extends AppCompatActivity { com o próprio sistema. No exemplo a seguir, vamos criar
private Button button; um provedor de conteúdo simples que permite que um
@Override aplicativo Androide obtenha uma lista de contatos do
protected void onCreate(Bundle savedInstanceState) { dispositivo.
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main); ```
button = findViewById(R.id.button); public class MyProvider extends ContentProvider {
button.setOnClickListener(new View.OnClickListener() { private static final UriMatcher uriMatcher = new
@Override UriMatcher(UriMatcher.NO_MATCH);
public void onClick(View v) { private static final int CONTACTS = 1;
Toast.makeText(MainActivity.this, "Olá mundo!", static {
Toast.LENGTH_SHORT).show(); uriMatcher.addURI("com.example.myapp.provider", "contacts",
} CONTACTS);
}); }
} private MyDatabaseHelper dbHelper;
} @Override
``` public boolean onCreate() {
dbHelper = new MyDatabaseHelper(getContext());
return true;

{
1. Esquece o que ouve
Regra : Aprendizado acelerado , Você 2. Entende o que vê
3. Aprende o que faz
 WhatsApp: +244 946269760 Facebook: Ja Ta Ki
}
@Nullable
@Override 7. CICLO DE VIDA DA ATIVIDADE: onCreate (), onStart (),
public Cursor query(@NonNull Uri uri, @Nullable String[] onResume (), onPause (), onStop () e onDestroy (). Pode ser
projection, @Nullable String selection, @Nullable String[] influenciado por eventos externos, como a rotação do
selectionArgs, @Nullable String sortOrder) { dispositivo, a chegada de uma chamada telefônica, ou a
SQLiteDatabase db = dbHelper.getReadableDatabase(); finalização do aplicativo pelo usuário. Além disso, é
switch (uriMatcher.match(uri)) { importante lembrar que uma atividade pode ser parcialmente
case CONTACTS: ou totalmente destruída pelo sistema Androide a qualquer
return db.query("contacts", projection, selection, momento, para liberar recursos de memória. Por isso, é
selectionArgs, null, null, sortOrder); importante implementar corretamente o ciclo de vida da
default: atividade e salvar o estado da atividade em instâncias
throw new IllegalArgumentException("URI inválida: " + "onSaveInstanceState" para que o aplicativo possa ser
uri); restaurado corretamente após a destruição da atividade ou
} recriação pelo sistema.
} 1. Crie um novo projeto no Androide Studio e adicione uma
@Nullable atividade chamada "LifeCycleActivity".
@Override 2. Abra o arquivo "LifeCycleActivity.java" e adicione o
public String getType(@NonNull Uri uri) { seguinte código:
switch (uriMatcher.match(uri)) { ```
case CONTACTS: import Androide.support.v7.app.AppCompatActivity;
return "vnd.Androide.cursor.dir/contacts"; import Androide.os.Bundle;
default: import Androide.util.Log;
throw new IllegalArgumentException("URI inválida: " + public class LifeCycleActivity extends AppCompatActivity {
uri); private static final String TAG = "LifeCycleActivity";
} //- onCreate: a atividade é criada - O método onCreate é
} chamado quando a atividade é criada pela primeira vez e é
@Nullable responsável pela inicialização da mesma, como carregar o layout
@Override da interface do usuário e configurar os componentes
public Uri insert(@NonNull Uri uri, @Nullable ContentValues necessários. Ele chama o método setContentView para definir o
values) { layout, e o método Log.d para registrar uma mensagem no Logcat,
SQLiteDatabase db = dbHelper.getWritableDatabase(); indicando que o método onCreate foi chamado.
long id = db.insert("contacts", null, values); @Override
getContext().getContentResolver().notifyChange(uri, protected void onCreate(Bundle savedInstanceState) {
null); super.onCreate(savedInstanceState);
return Uri.withAppendedPath(uri, String.valueOf(id)); setContentView(R.layout.activity_life_cycle);
} Log.d(TAG, "onCreate: ");
@Override }
public int delete(@NonNull Uri uri, @Nullable String //- onStart: a atividade fica visível - O método onStart é
selection, @Nullable String[] selectionArgs) { chamado logo depois do onCreate e é responsável por tornar a
SQLiteDatabase db = dbHelper.getWritableDatabase(); atividade visível para o usuário. Ele chama o método Log.d para
int count; registrar uma mensagem indicando que o método onStart foi
switch (uriMatcher.match(uri)) { chamado.
case CONTACTS: @Override
count = db.delete("contacts", selection, selectionArgs); protected void onStart() {
break; super.onStart();
default: Log.d(TAG, "onStart: ");
throw new IllegalArgumentException("URI inválida: " + }
uri); //- onResume: a atividade ganha o foco e pode interagir com o
} usuário - O método onResume é chamado logo depois do onStart e
getContext().getContentResolver().notifyChange(uri, null); é responsável por colocar a atividade em primeiro plano e
return count; permitir que o usuário interaja com ela. Ele chama o método
} Log.d para registrar uma mensagem indicando que o método
@Override onResume foi chamado.
public int update(@NonNull Uri uri, @Nullable ContentValues @Override
values, @Nullable String selection, @Nullable String[] protected void onResume() {
selectionArgs) { super.onResume();
SQLiteDatabase db = dbHelper.getWritableDatabase(); Log.d(TAG, "onResume: ");
int count; }
switch (uriMatcher.match(uri)) { //- onPause: a atividade é pausada enquanto outra atividade
case CONTACTS: toma o foco - O método onPause é chamado quando a atividade
count = db.update("contacts", values, selection, perde o foco, seja por causa de outra atividade que está sendo
selectionArgs); executada ou por causa de um evento externo (como uma chamada
break; telefônica). Ele chama o método Log.d para registrar uma
default: mensagem indicando que o método onPause foi chamado.
throw new IllegalArgumentException("URI inválida: " + @Override
uri); protected void onPause() {
} super.onPause();
getContext().getContentResolver().notifyChange(uri, null); Log.d(TAG, "onPause: ");
return count; }
} //- onStop: a atividade não é mais visível - O método onStop é
} chamado quando a atividade não é mais visível para o usuário.
``` Ele chama o método Log.d para registrar uma mensagem indicando
que o método onStop foi chamado.
Esperamos que este exemplo tenha ajudado a compreender melhor @Override
como os componentes básicos do Androide (Atividade, Serviço, protected void onStop() {
Recetor de Transmissão e Provedor de Conteúdo) funcionam em super.onStop();
programação Androide com Java. Lembre-se de que este é apenas Log.d(TAG, "onStop: ");
um exemplo; existem muitas maneiras diferentes de utilizar }
esses componentes no desenvolvimento de aplicativos Androide. //- onDestroy: a atividade é destruída - O método onDestroy é
chamado quando a atividade é destruída pelo sistema operacional

{
1. Esquece o que ouve
Regra : Aprendizado acelerado , Você 2. Entende o que vê
3. Aprende o que faz
 WhatsApp: +244 946269760 Facebook: Ja Ta Ki
Androide, seja por causa de uma solicitação explícita do
usuário (como tocar no botão "Voltar" do
dispositivo) ou por causa de um evento externo (como a falta de Além disso, pode-se utilizar outras views além do LinearLayout
recursos do sistema). Ele chama o método Log.d para registrar para criar layouts personalizados.
uma mensagem indicando que o método onDestroy foi chamado.
@Override 3. Gerenciadores de Layout: são responsáveis por posicionar
protected void onDestroy() { as views dentro do layout.xml. Existem diversos tipos de
super.onDestroy(); gerenciadores de layout e cada um possui suas próprias
Log.d(TAG, "onDestroy: "); características. Alguns dos mais comuns são:
} 3.1. LinearLayout: organiza as views de forma linear,
} permitindo a definição da orientação (horizontal
``` ou vertical);
3. Abra o arquivo "activity_life_cycle.xml" e adicione o 3.2. RelativeLayout: organiza as views de forma
seguinte layout: relativa, permitindo a definição da posição de
``` uma view em relação a outra;
<RelativeLayout 3.3. ConstraintLayout: organiza as views utilizando
xmlns:Androide="http://schemas.Androide.com/apk/res/Androide" restrições, permitindo uma maior flexibilidade no
xmlns:tools="http://schemas.Androide.com/tools" posicionamento das views;
Androide:id="@+id/activity_life_cycle" 3.4. GridLayout: organiza as views em uma grade,
Androide:layout_width="match_parent" permitindo a definição do número de linhas e
Androide:layout_height="match_parent" colunas.
4 Hierarquia de Views: define a estrutura do layout e a
tools:context="com.example.lifecycletest.LifeCycleActivity"> posição de cada view dentro dela. Cada view é
posicionada em relação a um pai, que pode ser o layout
<TextView principal ou outra view. É importante definir a
Androide:id="@+id/text_view" hierarquia de views corretamente para evitar problemas
Androide:layout_width="wrap_content" de posicionamento e de desempenho na aplicação.
Androide:layout_height="wrap_content" 5 Recursos: são arquivos que podem ser acessados pela
Androide:text="Hello World!" aplicação, como imagens, sons, cores e strings. Eles são
Androide:textSize="24sp" salvos em pastas específicas dentro de res e são
Androide:layout_centerInParent="true"/> referenciados nos layouts XML. Os recursos permitem uma
maior organização e reutilização de elementos na
</RelativeLayout> aplicação. Por exemplo, uma imagem de background pode
``` ser salva como um recurso e utilizada em diversos
4. Execute o aplicativo no dispositivo ou emulador Androide e layouts diferentes.
observe o Logcat na janela Androide Studio.
Conclusão: layouts são uma parte fundamental no desenvolvimento
de aplicativos Android. Eles permitem uma organização visual do
8. LAYOUTS: estrutura visual usada para definir a interface do conteúdo e a definição da hierarquia de views dentro da
usuário de um aplicativo. Exemplo completo de Layouts: aplicação. Com a compreensão dos conceitos apresentados neste
1. Pasta res: é onde os recursos de layout, cores, strings, artigo, será possível criar layouts personalizados e eficientes
imagens e valores são armazenados. Para este exemplo, para suas aplicações.
vamos focar nos layouts, então criaremos uma nova pasta
dentro de res chamada layout. Dentro desta pasta,
podemos criar nossos arquivos de layout.xml. 9. WIDGET: é um componente de interface do usuário que permite
2. Views: são as entidades visuais em uma aplicação ao usuário interagir com o aplicativo sem acessá-lo
Android. Podem ser botões, campos de texto, imagens, diretamente. Alguns exemplos de Widgets são a previsão do
layouts, etc. As views precisam ser definidas no arquivo tempo ou a visualização de eventos do calendário na tela
de layout.xml utilizando as tags XML conforme a inicial. Em Androide, existem dois tipos de Widgets: o "app
necessidade. Exemplo de layout.xml: widget" e o "home screen widget". O app widget é feito para
```xml ser integrado no layout do aplicativo, enquanto o home
<?xml version="1.0" encoding="utf-8"?> screen widget é feito para aparecer na tela inicial do
<LinearLayout dispositivo. Leva sempre em consideração a experiência do
xmlns:android="http://schemas.android.com/apk/res/android" usuário e como ela pode ser aprimorada por meio do uso de
android:layout_width="match_parent" widgets bem projetados.
android:layout_height="match_parent" 1. Crie um novo projeto no Android Studio e adicione as
android:orientation="vertical" seguintes dependências no arquivo `build.gradle`:
android:padding="16dp"> ```groovy
<TextView implementation 'com.android.support:appcompat-v7:<versão>'
android:layout_width="wrap_content" implementation 'com.android.support:design:<versão>'
android:layout_height="wrap_content" ```
android:text="@string/hello_world"/>
<Button 2. No arquivo de layout XML `activity_main.xml`, adicione
android:id="@+id/button" os seguintes widgets:
android:layout_width="wrap_content" ```xml
android:layout_height="wrap_content" <LinearLayout
android:text="@string/button_text"/> xmlns:android="http://schemas.android.com/apk/res/android"
</LinearLayout> xmlns:tools="http://schemas.android.com/tools"
``` android:layout_width="match_parent"
Este layout acima é um LinearLayout simples. Ele contém duas android:layout_height="match_parent"
views, um TextView e um Button. A view LinearLayout é utilizada android:orientation="vertical"
para organização e definição de espaçamentos (padding) e android:padding="16dp"
orientação. O atributo orientation determina se a ordem de tools:context=".MainActivity">
posicionamento será na vertical ou horizontal.O TextView tem o
atributo text definido como “@string/hello_world”, este valor é <TextView
salvo como um recurso de string que pode ser acessado também em android:id="@+id/textView"
outros arquivos XML. O Button tem um ID definido como android:layout_width="wrap_content"
“@+id/button” que pode ser utilizado para acessá-lo android:layout_height="wrap_content"
programaticamente na classe Java. O atributo text é definido android:text="Exemplo de Widget"
como “@string/button_text”, que novamente é um recurso de android:textSize="20sp" />
string salvo em outro arquivo XML. Este é um exemplo básico de

{
1. Esquece o que ouve
Regra : Aprendizado acelerado , Você 2. Entende o que vê
3. Aprende o que faz
 WhatsApp: +244 946269760 Facebook: Ja Ta Ki
como criar um layout.xml. Logicamente, layouts mais complexos
com várias views podem ser criados. É importante lembrar de
ajustar as alturas e larguras de acordo com suas necessidades.
<ToggleButton 1. No arquivo da classe Java `MainActivity.java`,
android:id="@+id/toggleButton" inicialize os widgets e defina os ouvintes e
android:layout_width="wrap_content" comportamentos desejados:
android:layout_height="wrap_content" ```java
android:textOff="Desligado" import android.os.Bundle;
android:textOn="Ligado" /> import android.support.v7.app.AppCompatActivity;
<Button import android.view.View;
android:id="@+id/button" import android.widget.Button;
android:layout_width="wrap_content" import android.widget.CheckBox;
android:layout_height="wrap_content" import android.widget.EditText;
android:text="Clique Aqui" /> import android.widget.ImageButton;
<CheckBox import android.widget.ImageSwitcher;
android:id="@+id/checkBox" import android.widget.ProgressBar;
android:layout_width="wrap_content" import android.widget.RadioButton;
android:layout_height="wrap_content" import android.widget.RadioGroup;
android:text="Selecionar" /> import android.widget.RatingBar;
<SeekBar import android.widget.SeekBar;
android:id="@+id/seekBar" import android.widget.Spinner;
android:layout_width="match_parent" import android.widget.Switch;
android:layout_height="wrap_content" /> import android.widget.TextView;
<TextSwitcher import android.widget.TextSwitcher;
android:id="@+id/textSwitcher" import android.widget.ToggleButton;
android:layout_width="wrap_content" import android.widget.ViewSwitcher;
android:layout_height="wrap_content" /> public class MainActivity extends AppCompatActivity {
<EditText private TextView textView;
android:id="@+id/editText" private ToggleButton toggleButton;
android:layout_width="match_parent" private Button button;
android:layout_height="wrap_content" private CheckBox checkBox;
android:hint="Digite algo" /> private SeekBar seekBar;
<Switch private TextSwitcher textSwitcher;
android:id="@+id/switch" private EditText editText;
android:layout_width="wrap_content" private Switch aSwitch;
android:layout_height="wrap_content" private Spinner spinner;
android:text="Ligar/Desligar" /> private RatingBar ratingBar;
<Spinner private ImageButton imageButton;
android:id="@+id/spinner" private RadioGroup radioGroup;
android:layout_width="match_parent" private ProgressBar progressBar;
android:layout_height="wrap_content" /> private ImageSwitcher imageSwitcher;
<RatingBar @Override
android:id="@+id/ratingBar" protected void onCreate(Bundle savedInstanceState) {
android:layout_width="wrap_content" super.onCreate(savedInstanceState);
android:layout_height="wrap_content" setContentView(R.layout.activity_main);
android:numStars="5" // Inicializa os widgets
android:stepSize="0.5" /> textView = findViewById(R.id.textView);
<ImageButton toggleButton = findViewById(R.id.toggleButton);
android:id="@+id/imageButton" button = findViewById(R.id.button);
android:layout_width="wrap_content" checkBox = findViewById(R.id.checkBox);
android:layout_height="wrap_content" seekBar = findViewById(R.id.seekBar);
android:src="@drawable/ic_launcher_background" /> textSwitcher = findViewById(R.id.textSwitcher);
<RadioGroup editText = findViewById(R.id.editText);
android:id="@+id/radioGroup" aSwitch = findViewById(R.id.switch);
android:layout_width="wrap_content" spinner = findViewById(R.id.spinner);
android:layout_height="wrap_content" ratingBar = findViewById(R.id.ratingBar);
android:orientation="horizontal"> imageButton = findViewById(R.id.imageButton);
<RadioButton radioGroup = findViewById(R.id.radioGroup);
android:id="@+id/radioButton1" progressBar = findViewById(R.id.progressBar);
android:layout_width="wrap_content" imageSwitcher = findViewById(R.id.imageSwitcher);
android:layout_height="wrap_content" // Configura o comportamento dos widgets
android:text="Opção 1" /> // TextView
<RadioButton textView.setText("Exemplo de Widget");
android:id="@+id/radioButton2" // ToggleButton
android:layout_width="wrap_content" toggleButton.setOnCheckedChangeListener(new
android:layout_height="wrap_content" CompoundButton.OnCheckedChangeListener() {
android:text="Opção 2" /> @Override
<RadioButton public void onCheckedChanged(CompoundButton
android:id="@+id/radioButton3" buttonView, boolean isChecked) {
android:layout_width="wrap_content" if (isChecked) {
android:layout_height="wrap_content" textView.setText("Ligado");
android:text="Opção 3" /> } else {
</RadioGroup> textView.setText("Desligado");
<ProgressBar }
android:id="@+id/progressBar" }
android:layout_width="wrap_content" });
android:layout_height="wrap_content" /> // Button
<ImageSwitcher button.setOnClickListener(new View.OnClickListener() {
android:id="@+id/imageSwitcher" @Override
android:layout_width="wrap_content" public void onClick(View v) {
android:layout_height="wrap_content" /> // Lógica de clique do botão
</LinearLayout> }

{
1. Esquece o que ouve
Regra : Aprendizado acelerado , Você 2. Entende o que vê
3. Aprende o que faz
 WhatsApp: +244 946269760 Facebook: Ja Ta Ki
``` });

// CheckBox @Override
checkBox.setOnCheckedChangeListener(new public void onItemSelected(AdapterView<?> parent, View
CompoundButton.OnCheckedChangeListener() { view, int position, long id) {
@Override String selectedItem =
public void onCheckedChanged(CompoundButton parent.getItemAtPosition(position).toString();
buttonView, boolean isChecked) { textView.setText("Selecionado: " + selectedItem);
if (isChecked) { }
textView.setText("Selecionado"); @Override
} else { public void onNothingSelected(AdapterView<?> parent) {
textView.setText("Não selecionado"); // Executa quando nenhum item é selecionado
} }
} });
}); // RatingBar
// SeekBar ratingBar.setOnRatingBarChangeListener(new
seekBar.setOnSeekBarChangeListener(new RatingBar.OnRatingBarChangeListener() {
SeekBar.OnSeekBarChangeListener() { @Override
@Override public void onRatingChanged(RatingBar ratingBar, float
public void onProgressChanged(SeekBar seekBar, int rating, boolean fromUser) {
progress, boolean fromUser) { textView.setText("Avaliação: " + rating);
// Atualiza o valor do TextView com o valor da }
SeekBar });
textView.setText("Valor: " + progress); // ImageButton
} imageButton.setOnClickListener(new
@Override View.OnClickListener() {
public void onStartTrackingTouch(SeekBar seekBar) { @Override
} public void onClick(View v) {
@Override // Lógica de clique do ImageButton
public void onStopTrackingTouch(SeekBar seekBar) { }
} });
}); // RadioGroup
// TextSwitcher radioGroup.setOnCheckedChangeListener(new
textSwitcher.setFactory(new ViewSwitcher.ViewFactory() RadioGroup.OnCheckedChangeListener() {
{ @Override
@Override public void onCheckedChanged(RadioGroup group, int
public View makeView() { checkedId) {
TextView textView = new RadioButton radioButton = findViewById(checkedId);
TextView(MainActivity.this); textView.setText("Selecionado: " +
textView.setTextSize(16); radioButton.getText());
return textView; }
} });
}); // ProgressBar (neste exemplo, assumimos o uso de
textSwitcher.setText("Texto 1"); determinado estilo de progresso)
textSwitcher.setOnClickListener(new progressBar.setMax(100); // Definindo o valor máximo
View.OnClickListener() { da barra de progresso
@Override progressBar.setProgress(50); // Definindo um valor
public void onClick(View v) { inicial para a barra de progresso
// Lógica de clique do TextSwitcher // ImageSwitcher
} imageSwitcher.setFactory(new ViewSwitcher.ViewFactory()
}); {
editText.setOnEditorActionListener(new @Override
TextView.OnEditorActionListener() { public View makeView() {
@Override ImageView imageView = new ImageView(MainActivity.this);
public boolean onEditorAction(TextView v, int
actionId, KeyEvent event) { imageView.setScaleType(ImageView.ScaleType.CENTER_CROP);
if (actionId == EditorInfo.IME_ACTION_SEARCH) { return imageView;
// Executar ação de busca }
return true; });
} imageSwitcher.setImageResource(R.drawable.image1);
return false; imageSwitcher.setOnClickListener(new
} View.OnClickListener() {
}); @Override
```java public void onClick(View v) {
// Switch // Lógica de clique do ImageSwitcher
aSwitch.setOnCheckedChangeListener(new }
CompoundButton.OnCheckedChangeListener() { });
@Override }
public void onCheckedChanged(CompoundButton buttonView, }
boolean isChecked) { ```
if (isChecked) {
textView.setText("Switch ativado");
} else {
textView.setText("Switch desativado");
}
}
});
// Spinner
spinner.setOnItemSelectedListener(new
AdapterView.OnItemSelectedListener() {

{
1. Esquece o que ouve
Regra : Aprendizado acelerado , Você 2. Entende o que vê
3. Aprende o que faz
 WhatsApp: +244 946269760 Facebook: Ja Ta Ki

10. MATERIAL DESIGN: é um conjunto de diretrizes de design e 5. Agora você pode executar o aplicativo e verá o Material
componentes visuais para criar aplicativos Androide com uma Design em ação, com a barra superior contendo a barra de
aparência moderna e consistente. Leva em consideração as ferramentas e o botão flutuante no canto inferior
diretrizes de Material Design para garantir que a interface direito da tela.
do usuário seja consistente, amigável e atenda às Este é apenas um exemplo básico de como usar o Material Design
expectativas dos usuários. em programação Android com Java e XML. Existem muitos outros
1. Primeiro, certifique-se de ter as dependências corretas componentes e recursos disponíveis no Material Design, então
adicionadas ao seu arquivo build.gradle (module: app). sinta-se à vontade para explorar mais e personalizar o design
Adicione as seguintes linhas ao bloco dependencies: do seu aplicativo de acordo com suas necessidades.
```java
implementation 'com.google.android.material:material:1.3.0'
``` 11. INTENÇÕES: os objetos Intenção são usados para iniciar
2. Em seguida, abra o arquivo XML da sua activity e defina uma nova atividade ou serviço, bem como para enviar
o tema do aplicativo para usar o Material Design. Por informações entre componentes do aplicativo.
exemplo, você pode adicionar a seguinte linha ao 1. Primeiro, crie um novo projeto no Android Studio e abra
atributo "android:theme" da tag <application>: a atividade principal.
```xml 2. No arquivo de layout XML da atividade principal
android:theme="@style/Theme.MaterialComponents.Light" (activity_main.xml), adicione um botão:
``` ```xml
3. Agora, vamos adicionar um componente Material Design à <Button
nossa activity. Por exemplo, vamos adicionar um botão android:id="@+id/button"
flutuante (FloatingActionButton) e uma barra superior android:layout_width="wrap_content"
(AppBarLayout) com uma barra de ferramentas (Toolbar). android:layout_height="wrap_content"
Abra o arquivo XML da sua activity e adicione o seguinte android:text="Abrir Segunda Atividade" />
código: ```
```xml 3. No arquivo Java da atividade principal
<androidx.coordinatorlayout.widget.CoordinatorLayout (MainActivity.java), defina o comportamento do botão
xmlns:android="http://schemas.android.com/apk/res/android" para abrir a segunda atividade quando clicado:
xmlns:app="http://schemas.android.com/apk/res-auto" ```java
xmlns:tools="http://schemas.android.com/tools" public class MainActivity extends AppCompatActivity {
android:layout_width="match_parent" @Override
android:layout_height="match_parent"> protected void onCreate(Bundle savedInstanceState) {
<com.google.android.material.appbar.AppBarLayout super.onCreate(savedInstanceState);
android:id="@+id/app_bar" setContentView(R.layout.activity_main);
android:layout_width="match_parent" Button button = findViewById(R.id.button);
android:layout_height="wrap_content" button.setOnClickListener(new View.OnClickListener() {
android:theme="@style/ThemeOverlay.AppCompat.Dark.ActionBar"> @Override
<androidx.appcompat.widget.Toolbar public void onClick(View v) {
android:id="@+id/toolbar" Intent intent = new Intent(MainActivity.this,
android:layout_width="match_parent" SecondActivity.class);
android:layout_height="?attr/actionBarSize" startActivity(intent);
android:background="?attr/colorPrimary" }
app:popupTheme="@style/ThemeOverlay.AppCompat.Light" /> });
</com.google.android.material.appbar.AppBarLayout> }
<RelativeLayout }
android:layout_width="match_parent" ```
android:layout_height="match_parent"> 4. Em seguida, crie a segunda atividade
<!-- Seu conteúdo aqui --> (SecondActivity.java) e seu arquivo de layout
</RelativeLayout> correspondente (activity_second.xml).
<com.google.android.material.floatingactionbutton. 5. Na segunda atividade, você pode receber dados da
android:id="@+id/fab_button" atividade anterior por meio de intenções. Por exemplo,
android:layout_width="wrap_content" se deseja passar um texto da primeira atividade para a
android:layout_height="wrap_content" segunda, você pode fazer o seguinte:
android:layout_margin="@dimen/fab_margin"
android:src="@drawable/ic_add" Na primeira atividade (MainActivity.java):
app:layout_anchor="@id/app_bar" ```java
app:layout_anchorGravity="bottom|end" /> Intent intent = new Intent(MainActivity.this,
</androidx.coordinatorlayout.widget.CoordinatorLayout> SecondActivity.class);
``` intent.putExtra("EXTRA_MESSAGE", "Olá, Segunda Atividade!");
4. Agora, vá para o arquivo Java da sua activity e adicione startActivity(intent);
o seguinte código: ```
```java Na segunda atividade (SecondActivity.java):
import com.google.android.material.floatingactionbutton. ```java
FloatingActionButton; Intent intent = getIntent();
public class MainActivity extends AppCompatActivity { String message = intent.getStringExtra("EXTRA_MESSAGE");
private FloatingActionButton fabButton; // Agora você pode usar a variável 'message' conforme
@Override necessário
protected void onCreate(Bundle savedInstanceState) { ```
super.onCreate(savedInstanceState); Essas são apenas algumas dicas básicas para lidar com intenções
setContentView(R.layout.activity_main); em programação Android. Espero que este exemplo completo e as
Toolbar toolbar = findViewById(R.id.toolbar); dicas sejam úteis para você! Se precisar de mais informações ou
setSupportActionBar(toolbar); esclarecimentos, sinta-se à vontade para perguntar.
fabButton = findViewById(R.id.fab_button);
fabButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
// Ação do botão flutuante aqui
}

{
1. Esquece o que ouve
Regra : Aprendizado acelerado , Você 2. Entende o que vê
3. Aprende o que faz
 WhatsApp: +244 946269760 Facebook: Ja Ta Ki
});
}
}
```
Com esses passos, você criou um exemplo completo de como usar
12. FRAGMENTOS: são subseções de interfaces de usuário que Fragmentos em programação Android com Java e XML. Este exemplo
podem ser reaproveitados entre diferentes atividades. inclui a criação do layout XML para o fragmento, a classe Java
1. Primeiro, vamos criar o arquivo XML para o layout do para o fragmento, a modificação da atividade principal para
fragmento (fragment_example.xml): incluir o fragmento e a adição do contêiner do fragmento ao
```xml layout da atividade principal.
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent" 13. SQLITE: é um banco de dados relacional incorporado que
android:layout_height="match_parent" permite aos desenvolvedores Androide armazenar e recuperar
android:orientation="vertical"> dados em um aplicativo.
<TextView 1. Primeiro, você precisará criar um arquivo de layout XML para
android:id="@+id/text_view_fragment" a interface do usuário. Vamos chamá-lo de activity_main.xml:
android:layout_width="wrap_content" ```xml
android:layout_height="wrap_content" <RelativeLayout
android:text="Este é um exemplo de fragmento" /> xmlns:android="http://schemas.android.com/apk/res/android"
</LinearLayout> android:layout_width="match_parent"
``` android:layout_height="match_parent">
2. Agora, vamos criar a classe Java para o fragmento <?xml version="1.0" encoding="utf-8"?>
(ExampleFragment.java): <ScrollView
```java xmlns:android="http://schemas.android.com/apk/res/android"
import android.os.Bundle; xmlns:app="http://schemas.android.com/apk/res-auto"
import android.view.LayoutInflater; xmlns:tools="http://schemas.android.com/tools"
import android.view.View; android:layout_width="match_parent"
import android.view.ViewGroup; android:layout_height="match_parent"
import androidx.fragment.app.Fragment; tools:context=".MainActivity">
public class ExampleFragment extends Fragment { <androidx.constraintlayout.widget.ConstraintLayout
@Override android:layout_width="match_parent"
public View onCreateView(LayoutInflater inflater, ViewGroup android:layout_height="match_parent">
container, Bundle savedInstanceState) { <EditText
// Inflar o layout do fragmento android:id="@+id/editText2"
View view = inflater.inflate(R.layout.fragment_example, android:layout_width="0dp"
container, false); android:layout_height="wrap_content"
// Acessar e modificar os componentes do layout android:layout_marginStart="32dp"
TextView textView = android:layout_marginEnd="32dp"
view.findViewById(R.id.text_view_fragment); android:layout_marginBottom="24dp"
textView.setText("Este é um exemplo de fragmento"); android:gravity="start|top"
return view; android:hint="Enter example Name"
} android:inputType="textMultiLine"/>
} <EditText
``` android:id="@+id/editText3"
1. Em seguida, vamos modificar nossa atividade principal android:layout_width="0dp"
para incluir o fragmento (MainActivity.java): android:layout_height="wrap_content"
```java android:maxLength="10"
import androidx.appcompat.app.AppCompatActivity; android:hint="Enter example number"
import androidx.fragment.app.FragmentManager; android:inputType="number"/>
import androidx.fragment.app.FragmentTransaction; <EditText
import android.os.Bundle; android:id="@+id/editText1"
public class MainActivity extends AppCompatActivity { android:layout_width="0dp"
@Override android:layout_height="wrap_content"
protected void onCreate(Bundle savedInstanceState) { android:layout_marginBottom="24dp"
super.onCreate(savedInstanceState); android:hint="Enter id For update delete and
setContentView(R.layout.activity_main); search"
// Obter o FragmentManager android:inputType="numberSigned"/>
FragmentManager fragmentManager = <Button
getSupportFragmentManager(); android:id="@+id/button"
// Iniciar a transação do FragmentTransaction android:layout_width="0dp"
FragmentTransaction fragmentTransaction = android:layout_height="wrap_content"
fragmentManager.beginTransaction(); android:layout_marginTop="32dp"
// Adicionar o fragmento ao layout da atividade android:layout_marginEnd="8dp"
principal android:background="@drawable/custom_button"
ExampleFragment fragment = new ExampleFragment(); android:text="Save"/>
fragmentTransaction.add(R.id.fragment_container, <Button
fragment); android:id="@+id/button3"
// Confirmar a transação android:layout_width="0dp"
fragmentTransaction.commit(); android:layout_height="48dp"
} android:layout_marginTop="16dp"
} android:layout_marginEnd="8dp"
``` android:background="@drawable/custom_button"
2. Por último, vamos adicionar o contêiner do fragmento ao android:text="Update"/>
layout da atividade principal (activity_main.xml): <Button
```xml android:id="@+id/button2"
<RelativeLayout android:layout_width="0dp"
xmlns:android="http://schemas.android.com/apk/res/android" android:layout_height="wrap_content"
android:layout_width="match_parent" android:layout_marginStart="8dp"
android:layout_height="match_parent"> android:layout_marginTop="32dp"
<FrameLayout android:background="@drawable/custom_button"

{
1. Esquece o que ouve
Regra : Aprendizado acelerado , Você 2. Entende o que vê
3. Aprende o que faz
 WhatsApp: +244 946269760 Facebook: Ja Ta Ki
android:id="@+id/fragment_container" android:text="Read"/>
android:layout_width="match_parent"
android:layout_height="match_parent" />
</RelativeLayout>
```
<Button public void updateData(String id, String name, int num) {
android:id="@+id/button4" SQLiteDatabase db = this.getWritableDatabase();
android:layout_width="0dp" ContentValues values = new ContentValues();
android:layout_height="wrap_content" values.put(COLUMN_NAME, name);
android:layout_marginStart="8dp" values.put(COLUMN_NUMBER, num);
android:layout_marginTop="16dp" // Which row to update , based on the ID
android:background="@drawable/custom_button" // Update SQL Statement
android:text="Delete"/> long result = db.update(TABLE_NAME, values, "ID = ?",
<Button new String[]{id});
android:id="@+id/button5" // To check data updated or not
android:layout_width="0dp" if (result == -1) {
android:layout_height="wrap_content" Toast.makeText(context, "Data not Updated",
android:layout_marginTop="16dp" Toast.LENGTH_SHORT).show();
android:background="@drawable/custom_button" } else {
android:text="Search"/> Toast.makeText(context, "Data Updated
<Button Successfully!", Toast.LENGTH_SHORT).show();
android:id="@+id/button6" }
android:layout_width="0dp" }
android:layout_height="wrap_content" void deleteData(String id) {
android:layout_marginTop="16dp" SQLiteDatabase db = this.getWritableDatabase();
android:background="@drawable/custom_button" // SQL Statement for Delete
android:text="Delete All Data"/> long result = db.delete(TABLE_NAME, "ID = ?", new
</androidx.constraintlayout.widget.ConstraintLayout> String[]{id});
</ScrollView> if (result == -1) {
</RelativeLayout> Toast.makeText(context, "Data not Deleted",
``` Toast.LENGTH_SHORT).show();
} else {
2. Agora, vamos criar a classe Java para manipular o banco de Toast.makeText(context, "Data Successfully
dados. Vamos chamá-lo de DatabaseHelper.java: Deleted", Toast.LENGTH_SHORT).show();
```java }
import android.content.ContentValues; }
import android.content.Context; public Cursor readData() {
import android.database.Cursor; SQLiteDatabase db = this.getWritableDatabase();
import android.database.sqlite.SQLiteDatabase; // SQL Statement
import android.database.sqlite.SQLiteOpenHelper; String query = "SELECT * FROM " + TABLE_NAME;
import android.widget.Toast; Cursor cursor = db.rawQuery(query, null);
public class dbHelper extends SQLiteOpenHelper { return cursor;
public static final int DATABASE_VERSION = 1; }
public static final String DATABASE_NAME = "example.db"; public Cursor searchData(String id) {
public static final String TABLE_NAME = "Example_table"; SQLiteDatabase db = this.getWritableDatabase();
public static final String COLUMN_ID = "ID"; // Which row to search , based on the ID
public static final String COLUMN_NAME = "NAME"; String[] columns = new String[]{COLUMN_ID, COLUMN_NAME,
public static final String COLUMN_NUMBER = "NUMBER"; COLUMN_NUMBER};
Context context; Cursor cursor = db.query(TABLE_NAME, columns, "ID = ?",
public dbHelper(Context context) { new String[]{id},
super(context, DATABASE_NAME, null, DATABASE_VERSION); null, null, null, null);
this.context = context; return cursor;
} }
@Override public void deleteAllData() {
public void onCreate(SQLiteDatabase db) { SQLiteDatabase db = this.getWritableDatabase();
String SQL_CREATE = "CREATE TABLE " + TABLE_NAME + db.execSQL("DELETE FROM " + TABLE_NAME);
" (" + COLUMN_ID + " INTEGER PRIMARY KEY }
AUTOINCREMENT, " + }
COLUMN_NAME + " TEXT, " + ```
COLUMN_NUMBER + " INTERGER );";
db.execSQL(SQL_CREATE); 3. Agora, na sua atividade principal (MainActivity.java), você
} pode usar o DatabaseHelper para adicionar dados à tabela e ler
@Override dados dela.
public void onUpgrade(SQLiteDatabase db, int oldVersion, ```java
int newVersion) { import android.content.DialogInterface;
String SQL_DELETE = "DROP TABLE IF EXISTS " + import android.database.Cursor;
TABLE_NAME; import android.os.Bundle;
db.execSQL(SQL_DELETE); import android.view.View;
onCreate(db); import android.widget.ArrayAdapter;
} import android.widget.Button;
public void insertData(String name, int num) { import android.widget.EditText;
SQLiteDatabase db = this.getWritableDatabase(); import android.widget.Toast;
ContentValues values = new ContentValues(); import androidx.appcompat.app.AlertDialog;
values.put(COLUMN_NAME, name); import androidx.appcompat.app.AppCompatActivity;
values.put(COLUMN_NUMBER, num); public class MainActivity extends AppCompatActivity {
// Insert new row private EditText editTextID;
// Insert SQL Statement private EditText editTextName;
long result = db.insert(TABLE_NAME, null, values); private EditText editTextNum;
// To check data is inserted or not private String name;
if (result == -1) { private int number;
Toast.makeText(context, "Data not saved ", private String ID;
Toast.LENGTH_SHORT).show(); private dbHelper db;

{
1. Esquece o que ouve
Regra : Aprendizado acelerado , Você 2. Entende o que vê
3. Aprende o que faz
 WhatsApp: +244 946269760 Facebook: Ja Ta Ki
} else { @Override
Toast.makeText(context, "Data saved Successfully", protected void onCreate(Bundle savedInstanceState) {
Toast.LENGTH_SHORT).show(); super.onCreate(savedInstanceState);
} setContentView(R.layout.activity_main);
} db = new dbHelper(this);
editTextID = findViewById(R.id.editText1); @Override
editTextName = findViewById(R.id.editText2); public void onClick(DialogInterface dialog,
editTextNum = findViewById(R.id.editText3); int which) {
Button buttonSave = findViewById(R.id.button); dialog.cancel();
Button buttonRead = findViewById(R.id.button2); }
Button buttonUpdate = findViewById(R.id.button3); });
Button buttonDelete = findViewById(R.id.button4); AlertDialog dialog = builder.create();
Button buttonSearch = findViewById(R.id.button5); dialog.show();
Button buttonDeleteAll = findViewById(R.id.button6); }
buttonSave.setOnClickListener(new });
View.OnClickListener() { buttonUpdate.setOnClickListener(new
@Override View.OnClickListener() {
public void onClick(View v) { @Override
name = editTextName.getText().toString(); public void onClick(View v) {
String num = editTextNum.getText().toString(); name = editTextName.getText().toString();
if (name.isEmpty() || num.isEmpty()) { String num = editTextNum.getText().toString();
Toast.makeText(MainActivity.this, "Cannot ID = editTextID.getText().toString();
Submit Empty Fields", Toast.LENGTH_SHORT).show(); if (name.isEmpty() || num.isEmpty() ||
} else { ID.isEmpty()) {
number = Integer.parseInt(num); Toast.makeText(MainActivity.this, "Cannot
try { Submit Empty Fields", Toast.LENGTH_SHORT).show();
// Insert Data } else {
db.insertData(name, number); number = Integer.parseInt(num);
// Clear the fields try {
editTextID.getText().clear(); // Update Data
editTextName.getText().clear(); db.updateData(ID, name, number);
editTextNum.getText().clear(); // Clear the fields
} catch (Exception e) { editTextID.getText().clear();
e.printStackTrace(); editTextName.getText().clear();
} editTextNum.getText().clear();
} } catch (Exception e) {
} e.printStackTrace();
}); }
buttonRead.setOnClickListener(new }
View.OnClickListener() { }
@Override });
public void onClick(View v) { buttonDelete.setOnClickListener(new
final ArrayAdapter<String> adapter = new View.OnClickListener() {
ArrayAdapter<>(MainActivity.this, @Override
android.R.layout.simple_list_item_1); public void onClick(View v) {
String name; ID = editTextID.getText().toString();
String num; if (ID.isEmpty()) {
String id; Toast.makeText(MainActivity.this, "Please
try { enter the ID", Toast.LENGTH_SHORT).show();
Cursor cursor = db.readData(); } else {
if (cursor != null && cursor.getCount() > try {
0) { // Delete Data
while (cursor.moveToNext()) { db.deleteData(ID);
id = cursor.getString(0); // get // Clear the fields
data in column index 0 editTextID.getText().clear();
name = cursor.getString(1); // get editTextName.getText().clear();
data in column index 1 editTextNum.getText().clear();
num = cursor.getString(2); // get } catch (Exception e) {
data in column index 2 e.printStackTrace();
// Add SQLite data to listView }
adapter.add("ID :- " + id + "\n" + }
"Name :- " + name + "\n" + }
"Number :- " + num + "\n\ });
n"); buttonDeleteAll.setOnClickListener(new
} View.OnClickListener() {
} else { @Override
adapter.add("No Data"); public void onClick(View v) {
} // Delete all data
cursor.close(); // You can simply delete all the data by
} catch (Exception e) { calling this method --> db.deleteAllData();
e.printStackTrace(); // You can try this also
} AlertDialog.Builder builder = new
// show the saved data in alertDialog AlertDialog.Builder(MainActivity.this);
AlertDialog.Builder builder = new builder.setIcon(R.mipmap.app_icon_foreground);
AlertDialog.Builder(MainActivity.this); builder.setTitle("Delete All Data");
builder.setTitle("SQLite saved data"); builder.setCancelable(false);
builder.setIcon(R.mipmap.app_icon_foreground); builder.setMessage("Do you really need to
builder.setAdapter(adapter, new delete your all data ?");
DialogInterface.OnClickListener() { builder.setPositiveButton("Yes", new
@Override DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, @Override
int which) { public void onClick(DialogInterface dialog, int which) {

{
1. Esquece o que ouve
Regra : Aprendizado acelerado , Você 2. Entende o que vê
3. Aprende o que faz
 WhatsApp: +244 946269760 Facebook: Ja Ta Ki
} // User confirmed , now you can delete the data
});
builder.setPositiveButton("OK", new
DialogInterface.OnClickListener() {

db.deleteAllData(); O processo de solicitação de permissões é iniciado quando o

// Clear the fields aplicativo tenta acessar um recurso protegido. Se o aplicativo
editTextID.getText().clear(); não tiver a permissão necessária, o sistema exibe uma caixa de
editTextName.getText().clear(); diálogo no dispositivo, solicitando que o usuário conceda ou
editTextNum.getText().clear(); negue a permissão. Se o usuário conceder a permissão, o
} aplicativo é autorizado a acessar o recurso solicitado. Se o
}); usuário negar a permissão, o aplicativo não terá acesso ao
builder.setNegativeButton("No", new recurso.
DialogInterface.OnClickListener() { Um exemplo de permissões em um aplicativo Android escrito em
@Override Java e XML pode ser visto a seguir:
public void onClick(DialogInterface dialog, 1. Definindo as permissões necessárias no manifesto do
int which) { aplicativo (Arquivo: AndroidManifest.xml)
// user not confirmed ```xml
dialog.cancel(); <manifest
} xmlns:android="http://schemas.android.com/apk/res/android"
}); package="com.example.myapp">
AlertDialog dialog = builder.create(); <uses-permission
dialog.show(); android:name="android.permission.CAMERA" />
} <uses-permission
}); android:name="android.permission.READ_EXTERNAL_STORAGE" />
buttonSearch.setOnClickListener(new <uses-permission
View.OnClickListener() { android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
@Override
public void onClick(View v) { <application
ID = editTextID.getText().toString(); ...
if (ID.isEmpty()) { >
Toast.makeText(MainActivity.this, "Please ...
enter the ID", Toast.LENGTH_SHORT).show(); </application>
} else { </manifest>
try { ```
// Search data Neste exemplo, estamos solicitando permissões para acessar a
Cursor cursor = db.searchData(ID); câmera, ler e escrever no armazenamento externo.
if (cursor.moveToFirst()) { 2. Solicitando permissões em tempo de execução (Classe:
editTextName.setText(cursor.getString(1)); MainActivity.java)
editTextNum.setText(cursor.getString(2)); ```java
Toast.makeText(MainActivity.this, public class MainActivity extends AppCompatActivity {
"Data successfully searched", Toast.LENGTH_SHORT).show(); private Button mButton;
} else { private static final int REQUEST_CAMERA_PERMISSION = 1;
Toast.makeText(MainActivity.this, private static final int REQUEST_STORAGE_PERMISSION = 2;
"ID not found", Toast.LENGTH_SHORT).show(); private boolean mCameraPermission = false;
editTextNum.setText("ID Not private boolean mStoragePermission = false;
found"); @Override
editTextName.setText("ID not protected void onCreate(Bundle savedInstanceState) {
found"); super.onCreate(savedInstanceState);
} setContentView(R.layout.activity_main);
cursor.close();
} catch (Exception e) { mButton = findViewById(R.id.button);
e.printStackTrace();
} mButton.setOnClickListener(new View.OnClickListener() {
} @Override
} public void onClick(View view) {
}); if (!mCameraPermission && !mStoragePermission)
} {
} requestPermissions(new String[]
``` {Manifest.permission.CAMERA}, REQUEST_CAMERA_PERMISSION);
Com esses códigos, você tem um exemplo completo de como usar o requestPermissions(new String[]
SQLite em programação Android com Java e XML. Isso inclui a {Manifest.permission.READ_EXTERNAL_STORAGE,
criação do layout XML, a classe Java para manipular o banco de Manifest.permission.WRITE_EXTERNAL_STORAGE},
dados e a integração em sua atividade principal. Espero que REQUEST_STORAGE_PERMISSION);
isso te ajude! } else {
// Permissões concedidas, acessar a câmera
e o armazenamento externo.
14. PERMISSÕES: são usadas para definir quais recursos do }
dispositivo um aplicativo pode acessar, como microfone, }
câmera, sensores, internet, etc. O sistema de permissões no });
Android é uma das características mais importantes do }
sistema operacional, pois permite aos usuários controlar o @Override
acesso de cada aplicativo a recursos do dispositivo, como a public void onRequestPermissionsResult(int requestCode,
câmera, a galeria de imagens, os contatos, a localização @NonNull String[] permissions, @NonNull int[] grantResults) {
etc. Sem essas permissões, muitos aplicativos simplesmente super.onRequestPermissionsResult(requestCode,
não funcionariam corretamente, ou poderiam representar um permissions, grantResults);
risco de segurança para o usuário..
Por padrão, os aplicativos no Android têm acesso limitado a if (requestCode == REQUEST_CAMERA_PERMISSION &&
recursos do sistema, e precisam solicitar permissões grantResults.length > 0 && grantResults[0] ==
específicas para acessar determinados recursos. Cada permissão PackageManager.PERMISSION_GRANTED){
é agrupada em categorias, como "LOCALIZAÇÃO", "CÂMERA", mCameraPermission = true;
// A permissão da câmera foi concedida.

{
1. Esquece o que ouve
Regra : Aprendizado acelerado , Você 2. Entende o que vê
3. Aprende o que faz
 WhatsApp: +244 946269760 Facebook: Ja Ta Ki
"ARMAZENAMENTO", "CONTATOS", "MENSAGENS", "TELEFONE" etc. Essas }
categorias são definidas pelo sistema operacional e podem if (requestCode == REQUEST_STORAGE_PERMISSION &&
variar de acordo com a versão do Android. grantResults.length > 0 && grantResults[0] ==
PackageManager.PERMISSION_GRANTED){

mStoragePermission = true; 1. Adicione a dependência do Retrofit em seu arquivo

// A permissão do armazenamento externo foi build.gradle (Módulo: app):
concedida. ```
} dependencies {
} implementation 'com.squareup.retrofit2:retrofit:2.9.0'
} }
``` ```
Neste exemplo, estamos solicitando permissões em tempo de 2. Crie as classes Java para seu modelo de dados e para a API.
execução para acessar a câmera e o armazenamento externo, Ex: Modelo de dados (User.java):
usando o método `requestPermissions`. Em seguida, verificamos ```
se as permissões foram concedidas, no método public class User {
`onRequestPermissionsResult`. private int id;
private String name;
3. Concedendo permissões manualmente no dispositivo Android private String email;
Se o usuário negar uma permissão em uma caixa de diálogo, é public User(int id, String name, String email) {
possível conceder a permissão manualmente no dispositivo this.id = id;
Android, acessando as configurações do aplicativo. this.name = name;
Para conceder permissões manualmente, siga estes passos: this.email = email;
- Abra o aplicativo Configurações no dispositivo }
- Role até a seção “Aplicativos” e selecione o aplicativo // getters and setters
desejado }
- Abra a seção “Permissões” e conceda as permissões ```
necessárias. API (UserService.java)
```
Conclusão: As permissões em aplicativos Android são uma parte public interface UserService {
importante do sistema operacional, e ajudam a proteger a @GET("users")
privacidade e a segurança dos usuários. É importante que os Call<List<User>> getUsers();
desenvolvedores solicitem apenas as permissões necessárias para }
o funcionamento correto do aplicativo, e que expliquem ```
claramente ao usuário por que essas permissões são necessárias. 3. Crie uma instância do Retrofit
Além disso, é importante verificar se as permissões foram ```
concedidas pelo usuário em tempo de execução e lidar com a Retrofit retrofit = new Retrofit.Builder()
possibilidade de permissões negadas. .baseUrl("https://myserver.com/")
.addConverterFactory(GsonConverterFactory.creat
e())
15. DEPURAÇÃO: é o processo de encontrar e corrigir erros em .build();
um aplicativo Androide. As ferramentas de depuração incluem ```
o Androide Debug Bridge (ADB) e o depurador do Androide 4. Crie uma instância do serviço API
Studio. ```
1. Configure seu dispositivo Android para desenvolvimento, UserService userService = retrofit.create(UserService.class);
ativando as Opções do Desenvolvedor e habilitando a ```
Depuração por USB. 5. Faça chamadas para o servidor da web
2. Conecte seu dispositivo ao computador via USB. ```
3. Abra o Android Studio e clique no ícone "Terminal" na Call<List<User>> call = userService.getUsers();
parte inferior da janela. call.enqueue(new Callback<List<User>>() {
4. No terminal, navegue até a pasta onde o ADB está @Override
localizado. Normalmente, está dentro da pasta Platform- public void onResponse(Call<List<User>> call,
Tools no diretório de instalação do Android SDK. Response<List<User>> response) {
5. Execute o comando "adb devices" para garantir que o List<User> users = response.body();
dispositivo esteja conectado e reconhecido pelo ADB. // fazer algo com os usuários
6. Execute o comando "adb logcat" para mostrar os logs do }
dispositivo Android. Isso irá exibir informações @Override
detalhadas sobre o comportamento do aplicativo em public void onFailure(Call<List<User>> call, Throwable t) {
execução no dispositivo, incluindo mensagens de erro e // handle error
exceções. }
7. Se você estiver depurando um aplicativo específico, pode });
usar o comando "adb shell am start -D -n ```
com.seuapp.nomepacote/.MainActivity" para iniciar o
aplicativo com depuração. Com estas etapas, você pode se comunicar com o servidor da web
8. Quando uma exceção ocorrer, preste atenção aos logs usando Retrofit em seu aplicativo Android. Além disso, é
exibidos pelo comando "adb logcat" para identificar a possível utilizar outras funcionalidades do Retrofit, como
origem do problema e corrigi-lo. autenticação, interceptores e conversores de dados.
Além disso, ao desenvolver seu aplicativo Android, você pode
inserir pontos de interrupção em seu código Java no Android PROJETOS
Studio e, em seguida, depurar o aplicativo em execução no 1. Desenvolvimento de um sistema de gerenciamento de biblioteca
dispositivo conectado. em Programação Androide
2. Criação de um jogo de cartas em Programação Androide
16. RETROFIT: é uma biblioteca de rede que simplifica o 3. Implementação de um sistema de controle de estoque em
Programação Androide
processo de fazer solicitações HTTP em um aplicativo
4. Desenvolvimento de um aplicativo de agenda em Programação
Androide. O Retrofit é uma biblioteca de cliente HTTP para
Androide
Android e Java que permite enviar solicitações de rede para
5. Construção de um sistema de gerenciamento de vendas em
um servidor da web e tratar as respostas. Ele simplifica a
Programação Androide
comunicação com a API da web ao definir uma interface para
6. Criação de um aplicativo de chat em Programação Androide
cada serviço da web.
7. Implementação de um sistema de controle de despesas em
Para usar Retrofit em seu projeto Android com Java e Xml, siga

{
1. Esquece o que ouve
Regra : Aprendizado acelerado , Você 2. Entende o que vê
3. Aprende o que faz
 WhatsApp: +244 946269760 Facebook: Ja Ta Ki
os seguintes passos: Programação Androide
8. Desenvolvimento de um sistema de gerenciamento de tarefas em
Programação Androide
9. Construção de um aplicativo de previsão do tempo em
Programação Androide
10. Criação de um sistema de gerenciamento de clientes em
Programação Androide
11. Implementação de um sistema de controle de acesso em * MAIS CURSO, CONSULTE: *
Programação Androide 1. Android Developers website (developer.android.com)
12. Desenvolvimento de um aplicativo de lista de compras em 2. Android Tutorial Point (www.androidtutorialpoint.com)
Programação Androide 3. Java Tutorials Point (www.javatpoint.com/android-tutorial)
13. Construção de um sistema de gerenciamento de projetos em 4. Udemy (www.udemy.com/topic/android-development)
Programação Androide 5. Coursera (www.coursera.org/courses?query=android
14. Criação de um jogo de palavras cruzadas em Programação %20development)
Androide 6. Codecademy (www.codecademy.com/learn/learn-android)
15. Implementação de um sistema de controle de alunos em 7. AndroidHive (www.androidhive.info)
Programação Androide 8. Vogella (www.vogella.com/tutorials/android)
16. Desenvolvimento de um aplicativo de gerenciamento de 9. MindOrks (mindorks.com/android-development-tutorials)
finanças pessoais em Programação Androide 10. Android Weekly (androidweekly.net)
17. Construção de um sistema de gerenciamento de funcionários 11. Medium (medium.com/topic/android-development)
em Programação Androide 12. Stack Overflow (stackoverflow.com/questions/tagged/android)
18. Criação de um aplicativo de tradução em Programação 13. GitHub (github.com/topics/android)
Androide 14. Android Arsenal (android-arsenal.com)
19. Implementação de um sistema de controle de estoque de uma 15. AndroidX (developer.android.com/jetpack/androidx)
loja em Programação Androide 16. Android Design Guidelines (developer.android.com/design)
20. Desenvolvimento de um sistema de gerenciamento de eventos 17. Google Developer YouTube channel
em Programação Androide (www.youtube.com/user/AndroidDevelopers)
21. Construção de um aplicativo de lista de tarefas em 18. Android Weekly Newsletter (androidweekly.net/newsletter)
Programação Androide 19. The Big Nerd Ranch Guide to Android Programming
22. Criação de um jogo de adivinhação em Programação Androide (www.bignerdranch.com/books/android-programming)
23. Implementação de um sistema de controle de empréstimos em 20. Android Cookbook: Problems and Solutions for Android
Programação Androide Developers
24. Desenvolvimento de um aplicativo de gerenciamento de (www.oreilly.com/library/view/android-cookbook/9781449328387)
contatos em Programação Androide
25. Construção de um sistema de gerenciamento de reservas em
Programação Androide
26. Criação de um sistema de gerenciamento de academias em
Programação Androide
27. Implementação de um aplicativo de receitas culinárias em
Programação Androide
28. Desenvolvimento de um sistema de controle de biblioteca
virtual em Programação Androide
29. Construção de um jogo de quebra-cabeça em Programação
Androide
30. Criação de um sistema de gerenciamento de imóveis em
Programação Androide
31. Implementação de um aplicativo de monitoramento de
atividades físicas em Programação Androide
32. Desenvolvimento de um sistema de controle de pedidos de
delivery em Programação Androide
33. Construção de um aplicativo de gerenciamento de viagens em
Programação Androide
34. Criação de um jogo de memória em Programação Androide
35. Implementação de um sistema de controle de estoque de uma
farmácia em Programação Androide
36. Desenvolvimento de um sistema de gerenciamento de consultas
médicas em Programação Androide
37. Construção de um aplicativo de organização de eventos em
Programação Androide
38. Criação de um sistema de gerenciamento de vendas online em
Programação Androide
39. Implementação de um aplicativo de controle de gastos de
viagem em Programação Androide
40. Desenvolvimento de um sistema de gerenciamento de cursos
online em Programação Androide
41. Construção de um jogo de forca em Programação Androide
42. Criação de um sistema de gerenciamento de projetos de
software em Programação Androide
43. Implementação de um aplicativo de controle de séries e
filmes em Programação Androide
44. Desenvolvimento de um sistema de gerenciamento de clínica
veterinária em Programação Androide
45. Construção de um aplicativo de organização de receitas
médicas em Programação Androide

{
1. Esquece o que ouve
Regra : Aprendizado acelerado , Você 2. Entende o que vê
3. Aprende o que faz