Aula 7 - Felipe Silveira

Android Core
Felipe Silveira
felipesilveira.com.br
Aula 6
Aplicações II
Services
Services
Service é um dos componentes principais da plataforma
Android.
● Executado em background
● Sem interface com o usuário
● Sua execução continua mesmo quando o usuário inicia
outra aplicação.
Services
Dois principais tipos:
● Started: são services iniciados através de outros
componentes (activities, por exemplo) através do
método startService(). Após o seu início, o serviço
pode continuar sendo executado indefinidamente.
Services
● Bound: são services iniciados através do método
bindService(). Os Bound Services interagem com os
outros componentes através de uma interface clienteservidor, que inclusive podem ocorrer entre diferentes
processos (IPC).
Um Bound Service é executado enquanto possui
requisições a serem tratadas.
Services
O que um Service NÃO é:
● Um service NÃO é um processo separado. Ele pode
ser executado em um processo separado, mas por
padrão não é.
● Um service NÃO é um thread separada. Por padrão,
seu código é executado na Main Thread.
Services
Ciclo de vida
Services
Exemplo de
implementação:
QuickNotesSyncService.java
package android.helloworld.sync;
import android.app.Service;
import android.content.Intent;
import android.os.AsyncTask;
import android.os.IBinder;
public class QuickNotesSyncService extends Service {
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
new SyncDataTask().execute();
return START_NOT_STICKY;
}
@Override
public IBinder onBind(Intent arg0) {
// Neste exemplo, iremos supor que o service sera invocado apenas
// atraves de startService()
return null;
}
private class SyncDataTask extends AsyncTask<Void, Integer, Void> {
protected Void doInBackground(Void... p) {
DataSync d = new DataSync(QuickNotesSyncService.this);
d.syncPendingNotes();
return null;
}
}
}
Services
Após implementar a classe filha de Service, é necessário
registrar o serviço no AndroidManifest:
<application
android:icon="@drawable/icon"
android:label="QuickNotes" >
…
<service
android:name="android.helloworld.sync.QuickNotesSyncService" >
</service>
</application>
Broadcast Receiver
Broadcast receivers
O último - e não menos importante - dos principais
componentes de uma aplicação Android é o Broadcast
Receiver.
Broadcast Receivers são componentes responsáveis por
receber e tratar mensagens do sistema ou de outras
aplicações (Broadcasts)
Broadcast receivers
Broadcasts podem ser lançados pelo sistema ou por
aplicações. Exemplos de broadcasts do sistema:
●
●
●
●
●
Intent.ACTION_BOOT_COMPLETED
Intent.ACTION_POWER_CONNECTED
Intent.ACTION_POWER_DISCONNECTED
Intent.ACTION_BATTERY_LOW
Intent.ACTION_BATTERY_OKAY
Broadcast receivers
Broadcast receivers não possuem Interface com usuário,
mas eles podem lançar um Notificação para alertar o
usuário que algum evento ocorreu.
Normalmente, o broadcast receiver age como um
gateway, recebendo os broadcasts e invocando outros
componentes, como activities, services, etc.
Broadcast receivers
Ciclo de vida
O ciclo de vida de um Broadcast é bastante simples:
Quando o broadcast a ser capturado ocorre, o método
onReceive() é chamado.
Após isso, o broadcast receiver é retirado da memória.
É importante ressaltar que o método onReceive() é
executado na main thread, então é importante lançar uma
nova thread para operações demoradas.
Broadcast receivers
É importante ressaltar que o método onReceive() é
executado na main thread, então é importante lançar uma
nova thread para operações demoradas.
Broadcast receivers
package android.helloworld.sync;
Exemplo de
implementação:
import
import
import
import
import
ConnWatcher.java
public class ConnWatcher
extends BroadcastReceiver{
android.content.BroadcastReceiver;
android.content.Context;
android.content.Intent;
android.net.ConnectivityManager;
android.net.NetworkInfo;
@Override
public void onReceive(Context context, Intent intent) {
ConnectivityManager cm =
(ConnectivityManager)context.getSystemService(
Context.CONNECTIVITY_SERVICE);
NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
boolean isConnected = (activeNetwork != null) &&
activeNetwork.isConnected();
if (isConnected) {
Intent i = new Intent(context, QuickNotesSyncService.class);
context.startService(i);
}
}
}
Broadcast receivers
Após implementar a classe filha de BroadcastReceiver, é
necessário registrar o serviço no AndroidManifest:
<application
android:icon="@drawable/icon"
android:label="QuickNotes" >
…
<receiver android:name="android.helloworld.sync.ConnWatcher">
<intent-filter>
<action android:name="android.net.conn.CONNECTIVITY_CHANGE" />
</intent-filter>
</receiver>
</application>
Broadcast receivers
Além de registrar o broadcast receiver, é também
necessário declarar a permissão que será usada. No nosso
caso, a permissão para acessar o estado das conexões de
rede.
…
<uses-sdk android:minSdkVersion="4" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<application
android:icon="@drawable/icon"
android:label="QuickNotes" >
HTTP
Clientes HTTP
Em Android temos dois clientes HTTP:
● Apache HTTP Client
● HttpURLConnection
O Google aconselha o uso de HttpURLConnection desde
a versão 2.3 (Gingerbread)
Sincronização
Usaremos o HTTPUrlConnection para enviar as notas,
que no nosso exemplo são armazenadas no banco de
dados local, para um servidor remoto.
Vamos fazer isso em dois passos:
1) Criar uma flag no banco de dados, para termos
controle do que já foi enviado.
2) Usar HTTPUrlConnection para enviar os dados via
POST para o servidor remoto.
Sincronização
Para criar uma coluna extra na tabela do nosso banco
de dados, basta alterar o método onCreate da classe
QuickNotesProvider$DBHelper
@Override
public void onCreate(SQLiteDatabase db) {
db.execSQL("CREATE TABLE " + NOTES_TABLE + " (" +
Notes.NOTE_ID + " INTEGER PRIMARY KEY AUTOINCREMENT," +
Notes.SYNCED + " INTEGER," +
Notes.TEXT + " LONGTEXT" + ");");
}
Sincronização
Após a alteração no DBHelper, é necessário criar a
constante SYNCED na classe QuickNotesProvider$Notes,
que fica assim:
public static final class Notes implements BaseColumns {
public static final Uri CONTENT_URI = Uri.parse("content://" +
QuickNotesProvider.AUTHORITY + "/notes");
public static final String CONTENT_TYPE =
"vnd.android.cursor.dir/vnd.jwei512.notes";
public static final String NOTE_ID = "_id";
public static final String TEXT = "text";
public static final String SYNCED = "synced";
}
Sincronização
Além das alterações no Content Provider, precisamos
alterar o método addNote da MainActivity para passar a
gravar as notas com a flag SYNCED = 0, significando que
ela ainda não foi enviada ao server.
protected void addNote(String text) {
…
values.put(QuickNotesProvider.Notes.SYNCED, 0);
…
}
Sincronização
Com a flag criada, seguimos ao segundo passo, que é a
criação dos métodos para acesso ao servidor remoto.
Criaremos para isso a class DataSync, já referenciada no
QuickNotesSyncService, e que possui dois métodos:
● syncPendingNotes(), responsável por procurar no
banco de dados as notas ainda não enviadas, e
● sendPendingNote(), responsável por enviar uma nota
ao servidor.
Sincronização
Com a implementação dos métodos citados, a classe
DataSync fica como mostrado no endereço abaixo:
https://github.
com/felipesilveira/QuickNotes/blob/master/src/android/he
lloworld/sync/DataSync.java
Sincronização
Por fim, basta invocar o serviço de sincronização no
método addNote(), se houver internet:
ConnectivityManager cm =
(ConnectivityManager)getSystemService(
Context.CONNECTIVITY_SERVICE);
NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
bool
ean isConnected = (activeNetwork != null) && activeNetwork.isConnected();
if
(isConnected) {
Intent i = new Intent(this, QuickNotesSyncService.class);
startService(i);
}
Backend
Para os testes, foi criado um backend no seguinte
endereço:
http://tests.felipesilveira.com.br/android-core/
Onde são listadas todas as notas enviadas através de POST
para a URL:
http://tests.felipesilveira.com.br/android-core/insert.php
NDK
NDK
O NDK permite que códigos escritos em linguagem
nativa (C/C++) sejam executados em uma aplicação
android.
O objetivo do NDK não é substituir o desenvolvimento Java
por desenvolvimento nativo, e sim complementá-lo em
situações específicas.
NDK
Principais usos:
● Reaproveitamento de bibliotecas nativas
● Execução de algoritmos complexos
● Jogos
JNI
Toda comunicação entre código Java e código nativo é
feita através de JNI - Java Native Interface.
Activities
As chamadas nativas podem ser integradas à aplicação de
basicamente duas formas:
● Em Activities convencionais
● Em NativeActivities, que são Activities especiais cujo
propósito é ser inteiramente implementadas de forma
nativa - muito comuns em jogos.
Criando uma chamada nativa
Iremos agora criar uma chamada nativa dentro de nossa
MainActivity. Será uma chamada bastante simples, que
apenas será responsável por criar uma entrada no log da
aplicação.
Criando uma chamada nativa
Passo 1 - Criando o código em C
Crie o diretório jni dentro do diretório do projeto
QuickNotes, e dentro dele crie o arquivo native.c, com o
seguinte conteúdo:
#include <jni.h>
#include <string.h>
#include <android/log.h>
#define DEBUG_TAG "NDK_AndroidNDK1SampleActivity"
void Java_com_mamlambo_sample_ndk1_AndroidNDK1SampleActivity_helloLog(JNIEnv * env, jobject
this, jstring logThis)
{
jboolean isCopy;
const char * szLogThis = (*env)->GetStringUTFChars(env, logThis, &isCopy);
__android_log_print(ANDROID_LOG_DEBUG, DEBUG_TAG, "NDK:LC: [%s]", szLogThis);
(*env)->ReleaseStringUTFChars(env, logThis, szLogThis);
}
Criando uma chamada nativa
Passo 2 - Criando as chamadas no código java
Dentro do método addNote() da MainActivity, adicione a
seguinte chamada:
helloLog("Nota corretamente adicionada!");
E declare o método nativo da seguinte forma:
private native void helloLog(String logThis);
Criando uma chamada nativa
Passo 2 - Criando as chamadas no código java
Além disso, é também necessário fazer a inicialização
estática da lib a ser criada:
st
atic {
System.loadLibrary("ndk1");
}
Criando uma chamada nativa
Passo 3 - Criando o Makefile para o código nativo
É necessária a criação de um Makefile para o código nativo
que criamos, para que seja possível o compilarmos
usando o NDK. Para isso, crie o arquivo Android.mk com o
seguinte conteúdo:
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_LDLIBS := -llog
LOCAL_MODULE
:= ndk1
LOCAL_SRC_FILES := native.c
include $(BUILD_SHARED_LIBRARY)
Criando uma chamada nativa
Passo 4 - Compilando o código nativo
Para compilar o código nativo, basta entrar no diretório jni
e executar o comando ndk-build (presente na raiz do
ndk).
Criando uma chamada nativa
Passo 5 - Compilando a aplicação
Por fim, basta compilar a aplicação QuickNotes da forma
tradicional, para a chamada nativa estar integrada ao
código Java.
Bibliografia
Pro Android C++ with the NDK
Onur Cinar
Advanced Android: Getting Started with the NDK
http://mobile.tutsplus.com/tutorials/android/ndk-tutorial/
Github
O projeto inteiro está disponível para download no github:
https://github.com/felipesilveira/QuickNotes
Obrigado.