O documento apresenta um treinamento sobre desenvolvimento de aplicativos Android. Ele discute como configurar o ambiente de desenvolvimento, portar uma aplicação existente para rodar em processadores x86 e criar uma nova aplicação usando código nativo do início ao fim.
2. Agenda
• Introdução
• Ambiente de desenvolvimento
• Laboratório: mãos à obra
– Introdução ao laboratório & ferramentas Android*
– Portando uma aplicação para processador Intel® Atom™
– Criando uma aplicação baseada em NDK do início ao fim
• Resumo
3. Agenda
• Introdução
• Ambiente de desenvolvimento
• Laboratório: mãos à obra
– Introdução ao laboratório & ferramentas Android*
– Portando uma aplicação para processador Intel® Atom™
– Criando uma aplicação baseada em NDK do início ao fim
• Resumo
4. Aplicação (App) Android*
•
Software baseado em Java
roda dentro da máquina
virtual Dalvik
•
API padrão do Android
Application Framework
•
Independente de dispositivo
Android App
Figura: Arquitetura Android Fonte:
android.com
A maioria dos Apps Android são independentes de plataforma
5. Usando Código Nativo em Apps Android*
•
JNI: interface entre código nativo (C/C++) e código dentro da Dalvik*
•
Por que código nativo?
–
Alto desempenho
–
Reutilização de código
•
Código nativo depende da arquitetura de hardware
•
A maioria dos Apps no Android Market não contém código nativo
–
Tais Apps são compatíveis com dispositivos com processador Atom™
Android App sem Código
Nativo
Android App com Código
Nativo
Dalvik
optimized Java
Classes
Dalvik
optimized Java
Classes
JNI/Native code
libraries
Android
Manifest
Resources
Android
Manifest
Resources
6. Agenda
• Introdução
• Ambiente de desenvolvimento
• Laboratório: mãos à obra
– Introdução ao laboratório & ferramentas Android*
– Portando uma aplicação para processador Intel® Atom™
– Criando uma aplicação baseada em NDK do início ao fim
• Resumo
7. Ambiente de Desenvolvimento
− Java Development Kit (JDK)
− Android* SDK
− Android* NDK
− Opcional:
− Eclipse
− ADT - Android Development Tools
− CDT - C/C++ Development Tools
− Cygwin (Obrigatório para usar NDK no Windows*)
8. Agenda
• Introdução
• Ambiente de desenvolvimento
• Laboratório: mãos à obra
– Introdução ao laboratório & ferramentas Android*
– Portando uma aplicação para processador Intel® Atom™
– Criando uma aplicação baseada em NDK do início ao fim
• Resumo
9. Agenda
• Introdução
• Ambiente de desenvolvimento
• Laboratório: mãos à obra
– Introdução ao laboratório & ferramentas Android*
– Portando uma aplicação para processador Intel® Atom™
– Criando uma aplicação baseada em NDK do início ao fim
• Resumo
10. Introdução ao Lab & Ferramentas do
Android*
Objetivos
• Familiarização ao Lab e às ferramentas de desenvolvimento para
Android*
• Como executar o emulador x86 para Android e verificar a execução
de uma imagem do Android* ICS
• Como configurar e testar as ferramentas de desenvolvimento para
Android*
11. Configuração e teste inicial
• SDK do Android e as demais ferramentas já estão instaladas
• Abra o terminal e verifique quais são as APIs (targets)
Android instaladas.
1. Abra o terminal de comandos com duplo clique em LXTerminal
2. Digite na linha de comando:
$ android list
2.3.7
4.0.4
12. Criando um AVD ICS para emulador x86
1. Para iniciar o Android Virtual Device
(AVD) Manager,
digite na linha de comando:
$ android avd
2. Para criar um novo AVD clique em
New
3. Digite ics no campo Name
4. Selecione o Target:
Android 4.0.3 – API Level 15 e
CPU/ABI: Intel Atom (x86)
5. Clique em Create AVD.
6. Clique em OK.
13. Executando o Emulador
1. Para executar o emulador usando o AVD recém criado, digite na linha de
comando:
$ emulator-x86 –avd ics &
14. Introdução ao Laboratório & Android*
Resumo
• Apresentamos o laboratório, o emulador x86 para Android e o ambiente
de desenvolvimento
• Demonstramos o uso básico do emulador e outras ferramentas de
desenvolvimento para Android. Agora o sistema está pronto para fazer
os exercícios
15. Agenda
• Introdução
• Ambiente de desenvolvimento
• Laboratório: mãos à obra
– Introdução ao laboratório & ferramentas Android*
– Portando uma aplicação para processador Intel® Atom™
– Criando uma aplicação baseada em NDK do início ao fim
• Resumo
16. Lab 1: Portando a aplicação Terminal
Emulator para processador Atom™
Objetivos:
• Utilizar o emulador x86 Android na instalação, execução e depuração de Apps
• Aprender como identificar erros relacionados ao NDK
• Familiarizar-se com as ferramentas do NDK, adb e ant durante o porte de uma
App simples baseado no NDK x86
• Demonstrar quão fácil é portar Apps Android baseadas no NDK ARM para a
arquitetura x86
Conteúdo do diretório lab1:
• AndroidMarket-jackpal.androidterm-2.apk
• src – diretório com os arquivos fonte do Terminal Emulator
• solution – diretório com a versão final do lab 1
17. Conteúdo do APK do Terminal Emulator
•
APK: Android Application Package
•
Descompacte o arquivo apk para ver seu conteúdo
•
Apps usando NDK contém o diretório /lib com a interface JNI
– /lib/x86: biblioteca compilada para arquitetura x86
– /lib/armeabi: biblioteca compilada para Arm v5
– /lib/armeabi-v7: biblioteca compilada para Arm v7
Alguns APKs podem suportar múltiplas arquiteturas
18. Use o adb para instalar o Terminal
Emulator no emulador
1. Para mudar para o diretório lab1, digite:
$ cd ~/labs/lab1
2. Para instalar o App usando adb na linha, digite:
$ adb install AndroidMarket-jackpal-androidterm-2.apk
3. Clique na icone recém instalado para abrir o App
19. Use logcat para depurar problemas
Para usar o logcat para verificar erros, digite:
$ adb shell logcat –t 50
20. Use logcat para depurar problemas
Para desinstalar o App, digite:
$ adb uninstall jackpal.androidterm
21. Conteúdo do arquivo de configuração
antes de recompilar
1. Para mudar para o diretório com o código da App, digite:
$ cd ~/labs/lab1/src/Android-Terminal-Emulator
2. Para exibir o makefile e verificar as flags de compilação, digite:
$ cat jni/Android.mk
Figura: Android.mk
22. Recompilando o App
1. Para recompilar o código fonte para x86 usando ndk-build, digite:
$ ndk-build APP_ABI=x86
2. Para atualizar o projeto Android usando ICS (API nível 15), digite:
$ android update project –-target “android-16” –-path .
3. Para compilar o projeto para teste usando ant, digite:
$ ant debug
23. Instale e execute a App no emulador
Para instalar o App recém compilado usando adb, digite:
$ adb install bin/Term-debug.apk
24. Verificando a App no emulador
Para ver as últimas 20 mensagens através do logcat, digite:
$ adb shell logcat –t 20
Para desinstalar o App usando o adb, digite:
$ adb uninstall jackpal.androidterm
25. Lab 1: Portando a aplicação Terminal Emulator
para processador Atom™
Resumo:
• Aprendemos como instalar, executar e depurar Apps usando o emulador x86 para
Android
• Aprendemos o processo de portar um App simples dependente do NDK para
arquitetura x86
• Demonstramos que portar pode ser um processo simples e prático.
26. Agenda
• Introdução
• Ambiente de desenvolvimento
• Laboratório: mãos à obra
– Introdução ao laboratório & ferramentas Android*
– Portando uma aplicação para processador Intel® Atom™
– Criando uma aplicação baseada em NDK do início ao fim
• Resumo
27. Lab 2: criando uma App baseada em
NDK do início ao fim
Objetivos:
• Criar e compilar uma biblioteca nativa compartilhada simples na arquitetura x86
• Criar e compilar uma App Android simples que use a biblioteca nativa
28. 1. Criando um projeto “Hello World”
1. Crie um diretório para o projeto, digitando:
$ mkdir -p ~/labs/lab2 && cd ~/labs/lab2
2. Para criar o projeto Android, digite:
$ android create project --target android-15 --activity CPUIdApp
--package com.example.cpuid --path .
Esqueleto do arquivo CPUIdApp.java que iremos alterar futuramente:
29. 2. Compilando e instalando o novo projeto
1. Para poder testar o Hello World, primeiro execute o emulador, digitando:
$ emulator-x86 -avd ics &
2. Para compilar e instalatar o pacote (apk), digite:
$ ant debug && adb install –r bin/CPUIdApp-debug.apk
31. 3. Criando chamada à função nativa e
carregando a biblioteca nativa
Para copiar o arquivo modificado do diretório com a solução, digite:
$ cp ../lab2sol/src/com/example/cpuid/CPUIdApp.java
src/com/example/cpuid/CPUIdApp.java
32. 4. Usando javah para gerar os headers JNI
1. Para recompilar gerando os arquivos class de Java, digite:
$ ant debug
2. Para gerar os headers JNI através do javah , digite:
$ export JNI_CP=bin/classes:$ANDROID_SDK/platforms/android-16/android.jar
$ javah -d jni -classpath $JNI_CP com.example.cpuid.CPUIdApp
O comando javah gera esse arquivo
automáticamente
33. 5. Criando o arquivo stub nativo em C para
invocação JNI
O stub contém a implementação da interface definida no header JNI:
Para copiar esse arquivo do diretório de soluções, digite:
$ cp ../lab2sol/jni/com_example_cpuid_CPUIdApp.c
jni/com_example_cpuid_CPUIdApp.c
34. 6. Copiando código C nativo com CPUID e
makefile
1. Para copiar o código fonte nativo em C do CPUID, digite:
$ cp ../lab2sol/jni/cpuid.c jni/cpuid.c
2. Para copiar o arquivo de compilação da biblioteca compartilhada, digite:
$ cp ../lab2sol/jni/Android.mk jni/Android.mk
35. 7. Compilando e Instalando App
Completo para Arquitetura x86
1. Para compilar a biblioteca nativa usando o NDK x86, digite
$ ndk-build APP_ABI=x86
2.
Para recompilar o App e reinstalá-lo usando o ADB, digite:
$ ant debug && adb install –r bin/CPUIdApp-debug.apk
37. Lab 2: Criando uma App baseado em NDK do início
ao fim
Resumo:
• Criamos um App Android usando código nativo do início ao fim.
• Aprendemos como definir e gerar chamadas nativas usando JNI
• Aprendemos como criar, reusar e compilar uma biblioteca nativa compartilhada
para Apps Android
• Essa biblioteca compartilhada pode ser usada para criar algorítmos que exigem
alto desempenho, permitir que Apps Android acessem código legado ou outros
motvios.
38. Resumo & Próximos Passos
• Apps padrão funcionam em qualquer aparelho Android
contendo o processador Intel® Atom™
• Portar um App usando NDK é tão simple quanto
recompilar (maior parte dos casos)
• Use o NDK x86 para diferenciar seus Apps tirando
vantagem das capacidades do processador Intel®
Atom™
40. Risk Factors
The above statements and any others in this document that refer to plans and expectations for the second quarter, the year and the future are forward-looking
statements that involve a number of risks and uncertainties. Words such as “anticipates,” “expects,” “intends,” “plans,” “believes,” “seeks,” “estimates,” “may,” “will,”
“should” and their variations identify forward-looking statements. Statements that refer to or are based on projections, uncertain events or assumptions also identify
forward-looking statements. Many factors could affect Intel’s actual results, and variances from Intel’s current expectations regarding such factors could cause actual
results to differ materially from those expressed in these forward-looking statements. Intel presently considers the following to be the important factors that could
cause actual results to differ materially from the company’s expectations. Demand could be different from Intel's expectations due to factors including changes in
business and economic conditions, including supply constraints and other disruptions affecting customers; customer acceptance of Intel’s and competitors’ products;
changes in customer order patterns including order cancellations; and changes in the level of inventory at customers. Uncertainty in global economic and financial
conditions poses a risk that consumers and businesses may defer purchases in response to negative financial events, which could negatively affect product demand and
other related matters. Intel operates in intensely competitive industries that are characterized by a high percentage of costs that are fixed or difficult to reduce in the
short term and product demand that is highly variable and difficult to forecast. Revenue and the gross margin percentage are affected by the timing of Intel product
introductions and the demand for and market acceptance of Intel's products; actions taken by Intel's competitors, including product offerings and introductions,
marketing programs and pricing pressures and Intel’s response to such actions; and Intel’s ability to respond quickly to technological developments and to incorporate
new features into its products. Intel is in the process of transitioning to its next generation of products on 22nm process technology, and there could be execution and
timing issues associated with these changes, including products defects and errata and lower than anticipated manufacturing yields. The gross margin percentage could
vary significantly from expectations based on capacity utilization; variations in inventory valuation, including variations related to the timing of qualifying products for
sale; changes in revenue levels; segment product mix; the timing and execution of the manufacturing ramp and associated costs; start-up costs; excess or obsolete
inventory; changes in unit costs; defects or disruptions in the supply of materials or resources; product manufacturing quality/yields; and impairments of long-lived
assets, including manufacturing, assembly/test and intangible assets. The majority of Intel’s non-marketable equity investment portfolio balance is concentrated in
companies in the flash memory market segment, and declines in this market segment or changes in management’s plans with respect to Intel’s investments in this
market segment could result in significant impairment charges, impacting restructuring charges as well as gains/losses on equity investments and interest and other.
Intel's results could be affected by adverse economic, social, political and physical/infrastructure conditions in countries where Intel, its customers or its suppliers
operate, including military conflict and other security risks, natural disasters, infrastructure disruptions, health concerns and fluctuations in currency exchange rates.
Expenses, particularly certain marketing and compensation expenses, as well as restructuring and asset impairment charges, vary depending on the level of demand for
Intel's products and the level of revenue and profits. Intel’s results could be affected by the timing of closing of acquisitions and divestitures. Intel's results could be
affected by adverse effects associated with product defects and errata (deviations from published specifications), and by litigation or regulatory matters involving
intellectual property, stockholder, consumer, antitrust, disclosure and other issues, such as the litigation and regulatory matters described in Intel's SEC reports. An
unfavorable ruling could include monetary damages or an injunction prohibiting Intel from manufacturing or selling one or more products, precluding particular
business practices, impacting Intel’s ability to design its products, or requiring other remedies such as compulsory licensing of intellectual property. A detailed
discussion of these and other factors that could affect Intel’s results is included in Intel’s SEC filings, including the report on Form 10-K for the year ended Dec. 31, 2011.
Rev. 4/17/12
Kernel level: - deep interaction with hardware Libraries and Dalvik - in the top of the kernel, but can have hardware dependencesApplication Framework - Hardware Independent – provide common set ofservicesStandard Android Apps: - in the top of Android Application Framework
What does native code means?When we talk about Android Apps we are talking about JavaFor Java Apps, C/C++ means native codeCode Reuse sample: Firefox; Opera
Introduzir lab como um todo
Introduzirprimeira parte
Why to update project –target “android-15”?????-> Android API level 15 means ICS 4.0.3 …
Explain all the flags on step 3. “android-15” is ICS. “android-10” is Gingerbread.
Codigo Assembly extrai o ID do processador,algoque eh dependente de dependente de arquiteturaHyper ThreadingVirtualizationMultimedia features
Install the app onto a tablet some time around now to show how the results differ in the emulator vs. a tablet.