Android Core Aula 7 - Aplicações (Services, Broadcast Receivers, NDK/JNI)

Android Core

Felipe Silveirafelipesilveira.com.br Aula 7

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 cliente-servidor, 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 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 {

@Overridepublic int onStartCommand(Intent intent, int flags, int startId) {

new SyncDataTask().execute();return START_NOT_STICKY;

}

@Overridepublic 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;

}}}

Exemplo de implementação:

QuickNotesSyncService.java

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>

Services

Intent i = new Intent(context,

QuickNotesSyncService.class);

startService(i);

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 receiverspackage android.helloworld.sync;

import android.content.BroadcastReceiver;

import android.content.Context;

import android.content.Intent;

import android.net.ConnectivityManager;

import android.net.NetworkInfo;

public class ConnWatcher

extends BroadcastReceiver{

@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);

}

}

}

Exemplo de implementação:

ConnWatcher.java

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/helloworld/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_example_Activity_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 NDKOnur Cinar

Advanced Android: Getting Started with the NDKhttp://mobile.tutsplus.com/tutorials/android/ndk-tutorial/

Github

O projeto inteiro está disponível para download no github:

https://github.com/felipesilveira/QuickNotes

Obrigado.