FUNDAÇÃO DO SDK DO ANDROID

1.0 O QUE É ANDROID MANIFEST

Agora vamos entender como se fundamenta os apps e o que significa as pastas. Para
isso, vamos abrir um novo projeto. Após ele criar ele vai criar pastas

Pasta manifests:
 Nessa pasta temos apenas um arquivo chamado de AndroidManifest.xml, que é esse
arquivo:
 Esse arquivo é onde colocamos todas ad definições de configuração de como
queremos como o app se cmporte. Então temos tags de configurações, tags que diz respeito
ao app e como vai funcionar.

Na linha:
<manifest
É a tag inicial, isso quer dizer que tudo que temos dentro dela será configurado.

Próxima linha:
xmlns:android="http://schemas.android.com/apk/res/android"
é uma url com todos os atributos responsáveis que podemos estar utilizando.

Terceira:
package="co.ritinha.myapplication">
identificador único, é o nome que demos ao tamplete inicial. Para alterar tem que
olhar ai.

Tag:
<application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
 android:roundIcon="@mipmap/ic_launcher_round"
android:supportsRtl="true"
android:theme="@style/AppTheme">
<activity android:name=".MainActivity">
<intent-filter>
<action android:name="android.intent.action.MAIN" />

<category android:name="android.intent.category.LAUNCHER" />

</intent-filter>
</activity>
</application>
Tudo que tem dentro da tag aplication tem os atributos de android e seus valores.

Os atributos que temos é o permitir backup:

android:allowBackup="true"

temos um ícone especifico de uma imagem para aparecer no explorador:

android:icon="@mipmap/ic_launcher"

label é o nome do nosso app:

android:label="@string/app_name"

ícones arredondados:
android:roundIcon="@mipmap/ic_launcher_round"

suporte rtl em alguns países escrevem da direita pra esquerda:

android:supportsRtl="true"

porém o mais importante que veremos aqui é o actvity:

<activity android:name=".MainActivity">
<intent-filter>
<action android:name="android.intent.action.MAIN" />

<category android:name="android.intent.category.LAUNCHER" />

</intent-filter>
</activity>

Toda tela nova devemos definir uma atividade, uma classe java é uma main activity, é a
nossa primeira tela, isso quer dizer que a activiy é respondavel por redenrizar a parte gráfica e
fazer a parte de lógica de programação do app.

Todo aplicativo andoid tem a parte estática ou seu layout, mas tudo isso
precisa ser dinâmico o que nos fazemos com a parte lógica, todo usuário deve ter suas
recomendações e suas peculiaridades. A parte estática precisa ser administrada e gerenciada
por uma parte logica que no caso é uma linguagem de programação java/kotlin.

Então precisamos mostrar no androidManifest que a gente precisará usar uma

atividade e um layout precisa usar uma atividade.
 Em um app com muitas telas precisamos dizer quem é a primeira tela, para
isso usamos a tag:
<intent-filter>
E ppassamos para ele uma action:
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
Então aqui está definido que essa vai ser nossa atividade principal:
<activity android:name=".MainActivity">
<intent-filter>
<action android:name="android.intent.action.MAIN" />

<category android:name="android.intent.category.LAUNCHER" />

</intent-filter>
</activity>
A nossa main activity, a primeira tela que vamosver ao abrir o app.

Temos muitas coisas para usar nesse local:

Uma delas é a tag para seu app funcionar no android 12, como já mostrado. Relembre:
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="co.ritinha.meuprimeiroaplicativo">
 <application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:roundIcon="@mipmap/ic_launcher_round"
android:supportsRtl="true"
android:theme="@style/AppTheme">
<activity android:name=".MainActivity"
android:exported="true">
<intent-filter>
<action android:name="android.intent.action.MAIN" />

<category android:name="android.intent.category.LAUNCHER" />

</intent-filter>
</activity>
</application>

</manifest>

Tag adicionada: android:exported="true">

Quando se necessário usar internet, usar localização, estado de wifi, gerenciamento de

bateria precisa por permissões e essas permissões são necessárias para abrir as coisas e o
usuário precisa dar ok, através dessas permissões o google vai pedir para o user.
<uses-permission android:name="android.permission.CAMERA"/>

Então definindo essa pasta com uma palavra é: CONFIGURAÇÃO. As configurações

maiores serão atribuídas aqui.

2.0 O QUE É A PASTA JAVA

Na aula vamos ver uma pasta muito importante, vamos ver a pasta Java. Todos os
códigos estão dentro dessa pasta. Dentro da pasta Java nós temos toda unidade lógica e
dinâmica para nosso app funcionar (eventos de touch, eventos de botão, campo de texto,
campos de formulários, tudo lógico e dinâmico, salvar dados em um bd):
 Quando criamos o app inicial a IDE cria uma estrutura de pastas principais que é o
mesmo padrão da unidade de tamplate que criamos, no caso, nosso ID único (co.ritinha).
dentro dessa pasta nos criamos subpastas e organizamos nosso projeto.

Nesse local é onde começamos a programar para o nosso app ficar da forma que
queremos e dinâmicos com um comportamento legal.

Pastas andoid test e test:

Essas duas pastas também são unidades logicas, mas são códigos escritos para testar
nossos códigos. É importante criar códigos para testar códigos já feitos, pois se no futuro eu
quiser alterar o código/ fazer mudanças eu preciso ver se essas mudanças não quebraram o
código passado.

Android teste: testar a telas

Test: testar a parte logica (contas, cálculos por exemplo)

Mas, nesse momento vamos focar na pasta main:

No AndroidManifest falamos que nossa tela principal é a mainactitity: <activity

android:name=".MainActivity">. Então é onde vamos definir o e atribuir o layout que
vai ser redenrizada a tela. Se quisermos adicionar uma segunda tela precisamos criar outra
pasta e atribuir essa pasta no AndroidManifest: <activity andoid:name=”registeractivt”/>.

3.0 O QUE É PASTA RES

 Agora vemos ver a pasta RES, e suas diferenças. A pasta RES são os recursos estáticos.
Recursos estáticos não mudam o seu estado, para que a unidade lógica dinâmica alterem
apenas as lacunas que deixamos nesse bloco estático.

Por exemplo uma caixa de filmes, é necessário desenhar onde eles ficaram, isso será
estático, já os filmes, as imagens serão os espaços dinâmicos. Então, dentro dessa pasta temos
4 subpastas:

Pasta layout:

A pasta layout é onde fica desenhada a nossa tela:

Quando ele inicia a pasta de inicialização pelo MainActivity nos conseguimos fazer um
layout para ela. Então, para criar outra tela é necessário criar uma atividade de cadastro e criar
um xml de cadastro e ai vamos ter uma unidade logica que acaba renderizando a partir do
arquivo xml a parte estática. Então, quando abre o arquivo dentro da pasta de layout a IDE cria
esse editor visual visto na imagem, um visualEditor que permite construir de forma visual
nossas telas.

Então nele temos uma interface de disegner, e tem a parte de text onde fica todo o
designe que arrastarmos, ele vai escrever o xml para nos. Logo a cima nos temos a opção code:
OBS: UMA OBSERVAÇÃO É QUE ESTÁ DANDO O SEGUINTE ERRO AO RODAR UM APP NOVO

PARA CONSERTAR ESSE ERRO É NESCESSÁRIO ABRIR A PASTA BUILD.GRADE

ABAIXO DE BILDETYPES ADICIONE O SEGUINTE CODIGO:
android {
compileOptions {
sourceCompatibility JavaVersion.VERSION_1_8
targetCompatibility JavaVersion.VERSION_1_8
}
}
E RODE O APP NOVAMENTE

RESULTADO:

O APP FUNCIONARÁ NORMALMENTE

Agora de volta ao modulo, como podemos observar na imagem o modulo de layout apresenta
um erro, para concertar esse erro é nescessário ir em: Android Studio: File ---> Invalidate
Caches/ Restart.

Também, utilize no androidM a seguinte configuração:

dependencies {
implementation fileTree(dir: 'libs', include: ['*.jar'])

implementation 'androidx.appcompat:appcompat:1.0.2'
implementation 'androidx.constraintlayout:constraintlayout:1.1.3'
testImplementation 'junit:junit:4.12'
androidTestImplementation 'androidx.test.ext:junit:1.1.1'
androidTestImplementation 'androidx.test.espresso:espresso-core:3.2.0'
}

quando aprendermos melhor poderemos alteralás

prorsseguindo

podemos observar que quando adicionamos um botão o seu xml é escrito

de forma automática:
 Esse xml button foi escrito de forma automática asism que o botão foi
arrastado para o layout da tela.

O xml escreveu toda a estrutura principal para ter um botão, define as

posições na tela e constrói os componentes prontos. Nos simplesmente precisamos
usar button e para alterar nomes, cores podemos alterar usando códigos xml.
Alterando o android:text:

Também podemos ver como está ficando o projeto. Então, é no layout que
ficam os itens estáticos e depois adicionamos a parte dinâmica.
Pasta drawble:

Dentro da pasta drawble fica tudo que é desenhável (png, logo do app, tudo
o que for de imagem). Também podemos definir nosso próprio desenhável. Nos
podemos usar o próprio xml para desenhar bordar de um botão por exemplo, em
vez de usar uma imagem feita no potoshop. Nele podemos mudar fonte, cor, e
tudo. Na pasta drawble será escrito em xml.

Se já tiver uma imagem pronta podemos usar a imagem.

Mipmap:

Essa pasta é específica para os lançadores (ícones de pasta principal do app)

Na pasta ic_laucher se encontra as imagens quadradas:

Na pasta ic_laucher_round as imagens arredondadas para apps que suportam as

mesmas:
 Para criar esse pode ser especificado no potoshop. Os tamanhos diferentes
são para dispositivos diferentes, quando o celular abre o app dependendo do
aparelho ele vai escolher uma definição de qual utilizar.

(mdpi) = media de piexel

(hdpi) = alto

(xhdpi) = extra alto

(xxhdpi) = extra extra altp

(xxxhdpi) = três vezes alto

Então quando criado o app colocamos a imagem e especificamos vários

tamanhos no celular, para se adaptar no celular, pois a imagem ficara feia
dependendo do celular.

Podemos definir isso nos lançadores e nos drawables. Encontramos isso em:
 Então podemos alterar e criar pastas com nossas imagens.

Values:

A pasta values são valores fixos/estáticos que podemos usar durante todo o
projeto.

Temos o arquivo strings para textos estáticos para usar durante todo o
projeto.
 Então se quiser alterar o nome do valor do projeto, podemos alterar ai que
será alterado em todos os locais que foi o atualizado o nome anterior
automaticamente. Para altear a língua também podemos criar strings especificas
em linguagens especificas.

Em colors, temos cores primarias onde ficaram salvas cores.

Para otimizar caso queira trocar a cor, então definimos um único lugar
separado para alterar tudo de uma vez caso necessário.

Em values também temos estilos e fins.

5.0 O QUE SÇAO GRADLE SCRIPTIS

Gradle scriptis são o pacote a parte fora do app.

Gradle tem vários arquivos e varias configurações tanto do SDK do android,

onde está definido e muitas coisas avançadas sobre o grandle.

Grandle é o nosso gerenciador, é que vai construir o app, e outras coisas

para o app existir.

Por enquanto vamos nos preocupar apenas com o arquivo build.grandle,

buildi.grandle é a contrução do aplicativo. Temos dois, mas vamos ver o do app:

Então quando criamos o tamplate inicial do AndoidStudio ele criou esse

código. Aqui nos temos o SDK mínimo que o palicativo vai rodar,
minSdkVersion 26
nosso id único:
applicationId "co.ritinha.myapplication"
versão que está hoje:
versionCode 1
 se quiser alterar é necessário alterar a versão.

Sempre que alterar as modificação é necessário sincronizar, senão não pega

as configurações feitas.

Uma parte muito importante do app é a tag chamada de dependências:

dependencies {
implementation fileTree(dir: 'libs', include: ['*.jar'])

implementation 'androidx.appcompat:appcompat:1.0.2'
implementation 'androidx.constraintlayout:constraintlayout:1.1.3'
testImplementation 'junit:junit:4.12'
androidTestImplementation 'androidx.test.ext:junit:1.1.1'
androidTestImplementation 'androidx.test.espresso:espresso-core:3.2.0'
}

essa é a parte onde vamos começar a atribuir códigos de terceiros, então se

não quisermos desenvolver a logica das coisas podemos usar dependências de
terceiros, podemos baixar códigos de terceiros que criam projetos legais e
disponibilizam gratuitamen

Para fazer o dawload de imagem vamo te. s definir a tag implementation e

dar o caminho, assim vai ser adicionado o anexo no nosso projeto.

Ex: Picasso android

https://square.github.io/picasso/

pra ter disponível no projeto é nescessário por a tag implementation

implementation 'com.squareup.picasso:picasso:(insert latest version)'

O restante são recursos mais avançados.

6.0 ATALHOS E PAINÉS DO ANDROID STUDIO

Aqui vamos ver os painéis que vamos utilizar, quando abrimos o android
studio no lado esquerdo temos algumaa abas:
 1. Nosso projeto, ele abre e fecha

7. a estrutura do nosso arquivo, os métodos, as funções e as variáveis criadas

naquele arquivo.

Também podemos usar as teclas de atalho do teclado, com CTRL e o

numero que exite no atalho.

Vamos usar o Project, o struct, o loggcat(já visto). Em cima ficam os botões

essenciais.

Selecionar dispositivo:
Botãoo de play, pausa, debugg, avd maneger, SDK maneger:

Em file:

Utilizamos para atualizar:

E em rum:

Usamos o rum app, debug e o select:

Em build:

Geralmente o projeto não sincroniza direito, sempre que ouver um erro de

construção podemos usar o clean Project:

Ele tenta limpar e depois você pode reconstruir.

CRLT + E abre arquivos recentes

SHIFT + SHIFT : pesquisa tudo dentro da AS

CRLT + F : busca textos no arquivo atual

CRLT + SHIFT + F : encontrar textos em qualquer arquivo

8.0 CONSTRUINDO EFETIVAMENTE O PRIMEIRO APP(APK)

Agora será explicado o processo de upload/construção do nosso arquivo

final do app. Onde será empacotado todo o contexto do aplicativo. Isso será feito
em um arquivo .APK.

A compilação é o ato de transformar uma linguagem de auto nível para uma

de baixo. Isso é feito inteiramente pelo grandle, o grandle é uma ferramente, um
conjunto de códigos (escritos em grandle) pra gerenciar o biuldi, a construção do
apk e as dependências e utilização de códigos de terceiros.

Além de tudo isso, não precisamos dominar todo o grandle, pois so vamos
construir coisas de versão. Quando rodamos o rebuild, começa a rodar o
grandle.build rum, o build é o projeto final que vai rolar no celular. Se abrir:

É onde definimos a versão onde vai baixar a grandle(raramente mexemos

nisso) já vem configurado.

Também definimos coisas pra configurar o grandle

 Mas o mais importante é o build.grandle

O outro grandle são apenas definições para a gente saber de onde vai baixar
arquivos de terceiros. Repositórios do google ou do java.

Então, vamos criar o primeiro apk de debug. Para criar vamos em build,
escolhemos build banos APK e clicamos em build apk:
 Então clicamos em buiild que vai gerar execuções:

Quando gera ele mostra uma caixinha dizendo que o arquivo foi gerado
com sucesso e clique em om para localizar. Também podemos procurar na pasta
do projeto. Para instalar no telefone virtual é preciso apenas arrastar que ele irá
instalar o projeto. Local: C:\Users\rita1\AndroidStudioProjects\MyApplication\app\
build\outputs\apk\debug

Link para a tabela de cores:

https://m2.material.io/resources/color/#!/?view.left=0&view.right=0