Aquest article pretén ser un recull de tots els recursos sobre desenvolupament d'aplicacions mòbils amb Android que podeu trobar en aquesta wiki. La documentació oficial de Google la podeu trobar a http://developer.android.com/index.html però també farem referència a multitud de recursos com online com androidhive, jarroba, sgoliver, etc.
Per als més impacients que puguin estar interessats en algun aspecte concret aquí teniu la llista de temes:
Vegeu Java
Consulteu Eclipse#Instal.C2.B7laci.C3.B3_per_a_Android
Vegeu Android Studio
IMPORTANT: Podeu utilitzar el suport KVM per executar els emuladors amb suport hardware i no us caldrà crear màquines virtuals. Consulteu l'article Android Studio Instal·lació
Pot ser interessant com emulador per què sol córrer més ràpid que els emuladors de ARM. Seguiu les passes de:
Instal·lació d'Android a Virtual Box
Vegeu també Android per tenir més informació sobre el sistema operatiu i les plataformes suportades.
Consulteu:
Desenvolupament_Android#Provar_les_aplicacions_al_m.C3.B2bil
NOTA: A Windows cal instal·lar un driver USB
Comandes importants:
Vegeu l'apartat emuladors. Podeu executar emuladors al mateix PC o en màquina remota i/o Màquina Virtual.
Cal que el dispositiu estigui rootejat. TODO. S'utilitza l'ordre adb connecŧ per connectar al dispositiu remot.
Aka emulators AVD o Android Virtual Device. Es gestionen amb l'eina Android Virtual Device Manager (comanda android avd).
Permeten emular un dispositiu Android en un PC.
NOTA: Els dispositiu Android sole corre en plataformes CPU ARM. Els PC en CPUs de la familia Intel. Pr aquesta raó es necessita un emulador
Podeu escollir dos tipus de emuladors:
Un cop executat la màquina virtual amb Android cal esbrinar la seva IP. La podeu consultar a:
I ara connectem:
$ ./adb connect 192.168.56.101
I comproveu que ja apareix a devices:
$ ./adb devices List of devices attached 192.168.56.101:5555 device
Recursos:
IMPORTANT: En alguns mòbils cal anar a "Acerca de"/"About device" i fer touch múltiples cops sobre la opció "Número de compilación"
Connecteu el vostre dispositiu mòbil. Abans cal configurar el mòbil de la següent manera. Aneu a:
Settings > Applications
NOTA: A version més modernes Android o trobareu a Settings > Security
Activeu:
Unknown sources
I també aneu a
Settings > Applications > Development
I activeu:
USB debugging
IMPORTANT: En algunes versions cal fer touch varios cops a número de compilació a About Device per activar l'apartat desenvolupador
També pot estar a l'apartat
Developer options
NOTA: A Android 4.0 aquesta opció es troba a: Settings > Developer options).
Indiqueu que l'aplicació es depurable al manifest de l'aplicació. A Eclipse ho podeu fer a la pestanya
Application
Del fitxer manifest.
Ara mirem si l'eina adb detecta el dispositiu:
$ cd $ cd android-sdks/platform-tools
Per a sistemes de 64 bits cal instal·lar:
$sudo apt-get install ia32-libs
I ara:
$ ./adb devices List of devices attached emulator-5554 device ???????????? no permissions
Com podeu veure el detectat però no tenim permisos. Observeu el ID del fabricant (a l'exemple HTC):
$ lsusb ... Bus 002 Device 006: ID 0bb4:0c86 High Tech Computer Corp.
és el que utilitzarem per indicar els permisos a udev. Creeu el fitxer:
$ sudo joe /etc/udev/rules.d/51-android.rules
I afegiu:dispositu
Acacha Wiki
SUBSYSTEM=="usb", ATTR{idVendor}=="0bb4", MODE="0666", GROUP="plugdev"
Ara executeu:
$ sudo chmod a+r /etc/udev/rules.d/51-android.rules
Desendolleu el USB del mòbil i torneu a connectar. Ara:
$ ./adb devices List of devices attached emulator-5554 device HT15NV811787 device
En cas que al fer lsusb ens mostri correctament el nostre dispositiu però al fer el adb devices no ens mostri res;és possible que sigui per que tenim un fabricant poc conegut. Llavors el que s'ha de fer es obtindre el ID del fabricant; això ho durem a terme fent el lsusb i mirant el numero que hi ha després de id fins als :
En aquest cas:
~$ lsusb Bus 004 Device 002: ID 2a47:0024 Intel Corp. Integrated Rate Matching Hub
el id serà 8087
editarem el següent fitxer:
nano ~/.android/adb_usb.ini
i afegim el id a baix dels comentaris:
# ANDROID 3RD PARTY USB VENDOR ID LIST -- DO NOT EDIT. # USE 'android update adb' TO GENERATE. # 1 USB VENDOR ID PER LINE. # ie0x2207 0x2a47
més info | aquí
Un cop tingueu un dispositiu associat/connectat ja sigui virtual (AVD) o real per USB o altres sistemes podeu connectar-vos a la shell del dispositiu amb:
$ adb shell
i executar:
$ logcat
.NOTA: Comproveu teniu el dispositiu amb l'ordre adbdevices. Si teniu més d'un dipositiu heu d'indicar amb el paràmetre -s quin dispositiu voleu utilitzar
des del vostre codi podeu escriure al log amb l'objecte Log. Exemple:
Log.d(TAG,"Missatge per a sortir pel LOG")
on TAG sol ser una constant que indica el prefix per identificar els missatges. Se sol combinar amb grep:
$ logcat | grep "TAG"
Altres exemples:
Log.e(): Errors Log.w(): Warnings Log.i(): Info Log.d(): Debug Log.v(): verbose
Dalvik Debug Monitor Server (DDMS)
El número final de la llibreria indica el API level a la que es va crear la llibreria.
~/adt-bundle/sdk/extras/android/support$ ls -la ... drwxrwxr-x 3 sergi sergi 4096 nov 26 17:42 v13 drwxrwxr-x 3 sergi sergi 4096 nov 26 17:42 v17 drwxrwxr-x 3 sergi sergi 4096 nov 26 17:42 v4 drwxrwxr-x 8 sergi sergi 4096 nov 26 17:42 v7
NOTA: Es poden tenir carregades al mateix temps múltiples llibreries, per exemple v4 i v7. En aquest cas s'ha de configurar el minSDK amb el valor de la llibreria més alta, a l'exemple 7
Es pot obtenir i descarregar des del gestor de descarregues del Android SDK Manager. A eclipse:
Window > Android SDK Manager
O executeu;
Manager.exe
de la carpeta:
<sdk>/tools/
escolliu:
Android Support package
de dins de:
Android Repository
Els fitxers es guarden a:
<sdk>/extras/android/support/
Recursos:
Consulteu Android_UI_Development#La_llibreria_de_compatibilitat_i_els_Fragments
Els Android form factors són (--acacha (discussió) 15:26, 30 oct 2015 (CET)):
Resources
Existeixen els següent components en Android:
Tots els components es defineixen a Android Manifest i normalment s'agrupen dins d'un objecte Application [2]. Vegeu:
https://gist.github.com/yanguango/971920#file-myapplication-java
Aquest objecte és l'objecte ideal per emmagatzemar l'estat global de l'aplicació o dades compartides per tots els components (per exemple les API de notificació d'una llibreria Push, etc)
Resources
Consulteu Android SDK
Per system
Vegeu Android Studio com exemple.
Per user
Afegiu les línies:
export PATH=${PATH}:~/Android/Sdk/tools
export PATH=${PATH}:~/Android/Sdk/platform-tools
o on sigui que tingueu el SDK. Si per exemple el SDK està a ~/android-studio:
export PATH=${PATH}:~/android-studio/sdk/tools
export PATH=${PATH}:~/android-studio/sdk/platform-tools
Al fitxer:
$ joe ~/.bashrc
IMPORTANT: Canvieu el path per tal que apunti a on es trobi el vostre sdk!
S'executa per línia de comandes amb:
$ android
A Eclipse ADT
Window > Android SDK Manager
TODO: Captura de pantalla.
A Android Studio:
Tools > Android > SDK Manager
TODO: Captura de pantalla.
L'ajuda la podeu consultar amb:
$ android -h
Usage:
android [global options] action [action options]
Global options:
-h --help : Help on a specific command.
-v --verbose : Verbose mode, shows errors, warnings and all messages.
--clear-cache: Clear the SDK Manager repository manifest cache.
-s --silent : Silent mode, shows errors only.
Valid
actions
are
composed
of a verb
and an
optional
direct
object:
- sdk : Displays the SDK Manager window.
- avd : Displays the AVD Manager window.
- list : Lists existing targets or virtual devices.
- list avd : Lists existing Android Virtual Devices.
- list target : Lists existing targets.
- list sdk : Lists remote SDK repository.
- create avd : Creates a new Android Virtual Device.
- move avd : Moves or renames an Android Virtual Device.
- delete avd : Deletes an Android Virtual Device.
- update avd : Updates an Android Virtual Device to match the folders
of a new SDK.
- create project : Creates a new Android project.
- update project : Updates an Android project (must already have an
AndroidManifest.xml).
- create test-project : Creates a new Android project for a test package.
- update test-project : Updates the Android project for a test package (must
already have an AndroidManifest.xml).
- create lib-project : Creates a new Android library project.
- update lib-project : Updates an Android library project (must already have
an AndroidManifest.xml).
- create uitest-project: Creates a new UI test project.
- update adb : Updates adb to support the USB devices declared in the
SDK add-ons.
- update sdk : Updates the SDK by suggesting new platforms to install
if available.
Es pot actualitzar el SDK per línia de comandes amb:
$ android update sdk
Per mostrar els targets possibles:
$ android list Available Android targets: ---------- id: 1 or "android-4" Name: Android 1.6 Type: Platform API level: 4 Revision: 3 Skins: WVGA800 (default), QVGA, WVGA854, HVGA ABIs : armeabi ---------- id: 2 or "android-10" Name: Android 2.3.3 Type: Platform API level: 10 Revision: 2 Skins: WVGA800 (default), QVGA, WVGA854, WQVGA400, HVGA, WQVGA432 ABIs : armeabi ---------- ...
es poden mostrar també altres coses amb l'ordre list, per exemples els AVD
$ android list avd Available Android Virtual Devices: Name: Prova Path: /home/sergi/.android/avd/Prova.avd Target: Android 4.2.2 (API level 17) ABI: armeabi-v7a Skin: 720x1280
NOTA: Per executar els AVD utilitzeu l'ordre emulator
Per gestionar els emuladors virtuals d'Android:
$ android avd
Per mostrar els avd:
$ android list avd
Available Android Virtual Devices:
Name: Prova
Path: /home/sergi/.android/avd/Prova.avd
Target: Android 4.2.2 (API level 17)
ABI: armeabi-v7a
Skin: 720x1280
Són les inicials de Android Debug Bridge. Podeu veure l'ajuda de la comanda amb:
$ adb
Android Debug Bridge version 1.0.31
-a - directs adb to listen on all interfaces for a connection
-d - directs command to the only connected USB device
returns an error if more than one USB device is present.
-e - directs command to the only running emulator.
returns an error if more than one emulator is running.
-s <specific device> - directs command to the device or emulator with the given
serial number or qualifier. Overrides ANDROID_SERIAL
environment variable.
-p <product name or path> - simple product name like 'sooner', or
a relative/absolute path to a product
out directory like 'out/target/product/sooner'.
If -p is not specified, the ANDROID_PRODUCT_OUT
environment variable is used, which must
be an absolute path.
-H - Name of adb server host (default: localhost)
-P - Port of adb server (default: 5037)
devices [-l] - list all connected devices
('-l' will also list device qualifiers)
connect <host>[:<port>] - connect to a device via TCP/IP
Port 5555 is used by default if no port number is specified.
disconnect [<host>[:<port>]] - disconnect from a TCP/IP device.
Port 5555 is used by default if no port number is specified.
Using this command with no additional arguments
will disconnect from all connected TCP/IP devices.
device commands:
adb push <local> <remote> - copy file/dir to device
adb pull <remote> [<local>] - copy file/dir from device
adb sync [ <directory> ] - copy host->device only if changed
(-l means list but don't copy)
(see 'adb help all')
adb shell - run remote shell interactively
adb shell <command> - run remote shell command
adb emu <command> - run emulator console command
adb logcat [ <filter-spec> ] - View device log
adb forward --list - list all forward socket connections.
the format is a list of lines with the following format:
<serial> " " <local> " " <remote> "\n"
adb forward <local> <remote> - forward socket connections
forward specs are one of:
tcp:<port>
localabstract:<unix domain socket name>
localreserved:<unix domain socket name>
localfilesystem:<unix domain socket name>
dev:<character device name>
jdwp:<process pid> (remote only)
adb forward --no-rebind <local> <remote>
- same as 'adb forward <local> <remote>' but fails
if <local> is already forwarded
adb forward --remove <local> - remove a specific forward socket connection
adb forward --remove-all - remove all forward socket connections
adb jdwp - list PIDs of processes hosting a JDWP transport
adb install [-l] [-r] [-s] [--algo <algorithm name> --key <hex-encoded key> --iv <hex-encoded iv>] <file>
- push this package file to the device and install it
('-l' means forward-lock the app)
('-r' means reinstall the app, keeping its data)
('-s' means install on SD card instead of internal storage)
('--algo', '--key', and '--iv' mean the file is encrypted already)
adb uninstall [-k] <package> - remove this app package from the device
('-k' means keep the data and cache directories)
adb bugreport - return all information from the device
that should be included in a bug report.
adb backup [-f <file>] [-apk|-noapk] [-obb|-noobb] [-shared|-noshared] [-all] [-system|-nosystem] [<packages...>]
- write an archive of the device's data to <file>.
If no -f option is supplied then the data is written
to "backup.ab" in the current directory.
(-apk|-noapk enable/disable backup of the .apks themselves
in the archive; the default is noapk.)
(-obb|-noobb enable/disable backup of any installed apk expansion
(aka .obb) files associated with each application; the default
is noobb.)
(-shared|-noshared enable/disable backup of the device's
shared storage / SD card contents; the default is noshared.)
(-all means to back up all installed applications)
(-system|-nosystem toggles whether -all automatically includes
system applications; the default is to include system apps)
(<packages...> is the list of applications to be backed up. If
the -all or -shared flags are passed, then the package
list is optional. Applications explicitly given on the
command line will be included even if -nosystem would
ordinarily cause them to be omitted.)
adb restore <file> - restore device contents from the <file> backup archive
adb help - show this help message adb version - show version num
scripting:
adb wait-for-device - block until device is online adb start-server - ensure that there is a server running adb kill-server - kill the server if it is running adb get-state - prints: offline | bootloader | device adb get-serialno - prints: <serial-number> adb get-devpath - prints: <device-path> adb status-window - continuously print device status for a specified device adb remount - remounts the /system partition on the device read-write adb reboot [bootloader|recovery] - reboots the device, optionally into the bootloader or recovery program adb reboot-bootloader - reboots the device into the bootloader adb root - restarts the adbd daemon with root permissions adb usb - restarts the adbd daemon listening on USB adb tcpip <port> - restarts the adbd daemon listening on TCP on the specified port
networking:
adb ppp <tty> [parameters] - Run PPP over USB. Note: you should not automatically start a PPP connection. <tty> refers to the tty for PPP stream. Eg. dev:/dev/omap_csmi_tty1 [parameters] - Eg. defaultroute debug dump local notty usepeerdns
adb sync notes: adb sync [ <directory> ]
<localdir> can be interpreted in several ways:
- If <directory> is not specified, both /system and /data partitions will be updated.
- If it is "system" or "data", only the corresponding partition is updated.
environmental variables:
ADB_TRACE - Print debug information. A comma separated list of the following values
1 or all, adb, sockets, packets, rwx, usb, sync, sysdeps, transport, jdwp
ANDROID_SERIAL - The serial number to connect to. -s takes priority over this if given.
ANDROID_LOG_TAGS - When used with the logcat option, only these debug tags are printed.
TODO:
Android Debug Bridge (adb) is a versatile command line tool that lets you communicate with an emulator instance or connected Android-powered device. It is a client-server program that includes three components:
A client, which runs on your development machine. You can invoke a client from a shell by issuing an adb command. Other Android tools such as the ADT plugin and DDMS also create adb clients. A server, which runs as a background process on your development machine. The server manages communication between the client and the adb daemon running on an emulator or device. A daemon, which runs as a background process on each emulator or device instance.
You can find the adb tool in <sdk>/platform-tools/.
When you start an adb client, the client first checks whether there is an adb server process already running. If there isn't, it starts the server process. When the server starts, it binds to local TCP port 5037 and listens for commands sent from adb clients—all adb clients use port 5037 to communicate with the adb server.
The server then sets up connections to all running emulator/device instances. It locates emulator/device instances by scanning odd-numbered ports in the range 5555 to 5585, the range used by emulators/devices. Where the server finds an adb daemon, it sets up a connection to that port. Note that each emulator/device instance acquires a pair of sequential ports — an even-numbered port for console connections and an odd-numbered port for adb connections. For example:
Emulator 1, console: 5554 Emulator 1, adb: 5555 Emulator 2, console: 5556 Emulator 2, adb: 5557 and so on...
As shown, the emulator instance connected to adb on port 5555 is the same as the instance whose console listens on port 5554.
Once the server has set up connections to all emulator instances, you can use adb commands to access those instances. Because the server manages connections to emulator/device instances and handles commands from multiple adb clients, you can control any emulator/device instance from any client (or from a script).
Note: When you connect a device running Android 4.2.2 or higher to your computer, the system shows a dialog asking whether to accept an RSA key that allows debugging through this computer. This security mechanism protects user devices because it ensures that USB debugging and other adb commands cannot be executed unless you're able to unlock the device and acknowledge the dialog. This requires that you have adb version 1.0.31 (available with SDK Platform-tools r16.0.1 and higher) in order to debug on a device running Android 4.2.2 or higher.
Recursos:
Consulteu els AVDs disponibles:
$ android list avds
Available Android Virtual Devices:
Name: AndroidAVD_API_4_3
Path: /home/sergi/.android/avd/AndroidAVD_API_4_3.avd
Target: Android 4.3 (API level 18)
ABI: x86
Skin: 1280x800
---------
Name: das
Path: /home/sergi/.android/avd/das.avd
Target: Android 1.6 (API level 4)
ABI: armeabi
Skin: 1280x800
---------
Name: Prova
Path: /home/sergi/.android/avd/Prova.avd
Target: Android 4.2.2 (API level 17)
ABI: armeabi-v7a
Skin: 720x1280
Executeu el emulador:
$ emulator -avd das
podeu executar múltiples de cop:
$ emulator -avd AndroidAVD_API_4_3
Ara mostreu els devices:
$ adb devices List of devices attached emulator-5554 device emulator-5556 offline
Permet instal·lar paquets Android. Vegem algun exemple:
$ adb install -r bin/MyFirstApp-debug.apk
No, prèviament per a tenir el fitxer creat cal:
$ ant debug
Per forçar la desinstal·lació de l'aplicació existent abans de instal·lar:
$ adb install -r bin/MyFirstApp-debug.apk
Consulteu els dispositius:
$ adb devices List of devices attached emulator-5554 device emulator-5556 device
Consulteu el nom dels paquets:
$ adb -s emulator-5556 shell [email protected]:/ # pm list packages
o
# pm list packages | grep iesebre package:com.iesebre.helloworldapp # exit
$ adb -s emulator-5556 uninstall com.iesebre.dam2.pa201415
La comanda emulator es troba a:
sdk/tools
i executa un emulador Android (aka AVD). Sense opcions:
$ emulator emulator: ERROR: You did not provide the name of an Android Virtual Device with the '-avd <name>' option. Read -help-avd for more information. If you *really* want to *NOT* run an AVD, consider using '-data <file>' to specify a data partition image file (I hope you know what you're doing).
Per mostrar els AVDs disponibles:
$ android list avd Available Android Virtual Devices: Name: Prova Path: /home/sergi/.android/avd/Prova.avd Target: Android 4.2.2 (API level 17) ABI: armeabi-v7a Skin: 720x1280
Ara podeu executar un emulador amb:
$ emulator -avd Prova
Per línia de comandes utilitzant Android SDK i la comanda android:
$ android create project --target <target-id> --name MyFirstApp \ --path <path-to-workspace>/MyFirstApp --activity MainActivity \ --package com.example.myfirstapp
Per saber els targets disponibles executeu:
$ android list targets
Un exemple concret:
$ android create project --target android-17 --name MyFirstApp --path /home/alumne/MyFirstApp --activity MainActivity --package com.iesebre.dam2.myfirstapp Created project directory: /home/alumne/MyFirstApp Created directory /home/alumne/MyFirstApp/src/com/iesebre/dam2/myfirstapp Added file /home/alumne/MyFirstApp/src/com/iesebre/dam2/myfirstapp/MainActivity.java Created directory /home/alumne/MyFirstApp/res Created directory /home/alumne/MyFirstApp/bin Created directory /home/alumne/MyFirstApp/libs Created directory /home/alumne/MyFirstApp/res/values Added file /home/alumne/MyFirstApp/res/values/strings.xml Created directory /home/alumne/MyFirstApp/res/layout Added file /home/alumne/MyFirstApp/res/layout/main.xml Created directory /home/alumne/MyFirstApp/res/drawable-xhdpi Created directory /home/alumne/MyFirstApp/res/drawable-hdpi Created directory /home/alumne/MyFirstApp/res/drawable-mdpi Created directory /home/alumne/MyFirstApp/res/drawable-ldpi Added file /home/alumne/MyFirstApp/AndroidManifest.xml Added file /home/alumne/MyFirstApp/build.xml Added file /home/alumne/MyFirstApp/proguard-project.txt
NOTA: Amb Gradle cal afegir l'opció g i la versió del Plugin de Gradle [3]
$ android create project -g -v 1.3.1 --target android-23 --name MyFirstAppGradle --path ~/Code/Android/MyFirstAppGradle --activity MainActivity --package com.example.myfirstappgradle
Ara cal fer les modificacions oportunes per crear el Hola Mon!
TODO
Per configurar els emuladors podeu utilitzar:
$ tools/android avd
Un cop creat un emulador (suposeu que li heu dit prova) el podeu executar amb:
$ emulator -avd prova
Comproveu que apareix com a dispositiu:
$ ./adb devices List of devices attached emulator-5554 device
Per executar per línia de comandes, primer cal crear el fitxer apk
$ ant debug
Ara per instal·lar l'app al mòbil:
$ adb install bin/MyFirstApp-debug.apk
NOTA: Tip: Add the platform-tools/ as well as the tools/ directory to your PATH environment variable.
Recursos
Vegeu ADT. Android Development Tools per a Eclipse
Vegeu Android Studio
Consulteu:
Vegeu Android_Studio#Estructura_d.27un_projecte
Estructura d'un projecte Android aka Android Project Structure.
Cada projecte Android creat amb l'assistent del ADT conté les següents carpetes:
Els fitxers més importants d'un projecte Android són:
Recursos:
aka The Android manifest file. Un exemple típic:
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.firstproject"
android:versionCode="1"
android:versionName="1.0" >
<uses-sdk android:minSdkVersion="7" />
<application
android:icon="@drawable/ic_launcher"
android:label="@string/app_name" >
<activity
android:name=".MynewprojectActivity"
android:label="@string/app_name" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
</manifest>
Algunes definicions importants:
Al fitxer de manifest s'utilitza el element XML uses-sdk
<uses-sdk>
La sintaxi és:
<uses-sdk android:minSdkVersion="integer"
android:targetSdkVersion="integer"
android:maxSdkVersion="integer" />
On:
Important: Please read the <uses-sdk> documentation before using this attribute.
vegeu també Android API Levels
Consulteu també:
http://developer.android.com/guide/topics/manifest/uses-sdk-element.html
Vegeu també Versions Android
http://jarroba.com/arquitectura-android-art-vs-dalvik/
NOTA: El procés de creació (building) d'un projecte Android és força complex i per aquesta raó s'utilitzen eines que ens assisteixen en el procés com poden ser Ant o Gradle. Estes eines executen múltiples subeïnes (compiladors, eines del SDK d'Android, etc..) de forma coordinada per tal de dur a terme el procés complet de construcció
La següent gràfica mostra el procediment resumit de construcció i execució de les aplicacions Android i els components que intervenen:
El següent gràfic mostra el procés detallat:
Durant el procés de construcció de l'aplicació, els projectes Android són compilats en fitxers .apk, que són els contenidors o paquets on s'emmagatzema el codi binari de l'aplicació Android. El paquet conté tota la informació necessària per tal d'executar l'aplicació en un dispositiu o un emulador.
Dins d'un paquet Android cal trobar:
En aquesta imatge podem veure els fitxer compilats .dex (que son .class convertits amb dx a .dex), també trobem una versió binaria dels fitxers AndroidManifest.xml i els recursos compilats (.arsc) i el recursos no compilats.
També hi trobem una carpeta anomenada res, que es d'on treiem els recursos, que conté el següent:
Hi trobem dues carpetes, drawable i layout. Dintre de la drawable es per als recursos de tipus imatge o "pintable" i dintre de la layout que conté la interficie grafica.
Si s'utilitza Eclipse, el Plugin ADT construeix l'aplicació de forma incremental a mesura que es fan canvis al codi font. Eclipse crea automàticament un fitxer apk i el guarda a la carpeta bin del projecte.
Si no s'utilitza Eclipse, es pot construir el projecte amb Ant i un fitxer build.xml.
Al crear un apk s'ha de marcar com debug mode o release mode. El debug mode és el més utilitzat quan es desenvolupa però al publicar l'aplicació (per exemple Google Play) s'han de signar utilitzant una clau privada.
El procés general és:
Recursos:
Recursos:
Dalvik Debug Monitor Server (DDMS)
Recursos:
Consulteu Android UI Development
Complet:
Resumit (estats):
Vegeu també el cicle de vida dels Fragments.
Recursos:
Resources:
Android Intent aka Intent
Un intent és una descripció abstracte d'una operació a realitzar. Es pot utilitzar amb:
Un dels usos més comuns és iniciar noves activitats des de altres activitats, hi en aquest sentit és un component que descriu la relació, el lligam, entre les dos activitats.
Un Intent té la següent estructura, resumida en dos parts:
Aquestes són les parts principals però també hi ha 4 parts secundaries:
Recursos:
Hi ha dos tipus d'intents:
S'anomena Intent Resolution al procediment que realitzar el sistema per trobar el component que ha d'executar un Intent implícit.
Recursos:
Exemple bàsic:
Intent intent = new Intent(MainActivity.this, Main2Activity.class); startActivity(intent);
Recursos:
Un Intent implícit, no determina explícitament el component target sinó que és el sistema operatiu qui determina quin component és el més adequat per a realitzar l'intent.
Sembla que fan com de màscara que indica quins intents implícits podrà realitzar o no l'aplicació. Els Intent filters són la forma en que qualsevol component pot fer saber al sistema operatiu Android quines són les seves capacitats. Aquestes capacitats es declaren al fitxer AndroidManifest.xml
Cal tenir en compte el següent:
Recursos:
TODO
A description of an Intent and target action to perform with it. Instances of this class are created with getActivity(Context, int, Intent, int), getActivities(Context, int, Intent[], int), getBroadcast(Context, int, Intent, int), and getService(Context, int, Intent, int); the returned object can be handed to other applications so that they can perform the action you described on your behalf at a later time.
By giving a PendingIntent to another application, you are granting it the right to perform the operation you have specified as if the other application was yourself (with the same permissions and identity). As such, you should be careful about how you build the PendingIntent: often, for example, the base Intent you supply will have the component name explicitly set to one of your own components, to ensure it is ultimately sent there and nowhere else.
A PendingIntent itself is simply a reference to a token maintained by the system describing the original data used to retrieve it. This means that, even if its owning application's process is killed, the PendingIntent itself will remain usable from other processes that have been given it. If the creating application later re-retrieves the same kind of PendingIntent (same operation, same Intent action, data, categories, and components, and same flags), it will receive a PendingIntent representing the same token if that is still valid, and can thus call cancel() to remove it.
Because of this behavior, it is important to know when two Intents are considered to be the same for purposes of retrieving a PendingIntent. A common mistake people make is to create multiple PendingIntent objects with Intents that only vary in their "extra" contents, expecting to get a different PendingIntent each time. This does not happen. The parts of the Intent that are used for matching are the same ones defined by Intent.filterEquals. If you use two Intent objects that are equivalent as per Intent.filterEquals, then you will get the same PendingIntent for both of them.
There are two typical ways to deal with this.
If you truly need multiple distinct PendingIntent objects active at the same time (such as to use as two notifications that are both shown at the same time), then you will need to ensure there is something that is different about them to associate them with different PendingIntents. This may be any of the Intent attributes considered by Intent.filterEquals, or different request code integers supplied to getActivity(Context, int, Intent, int), getActivities(Context, int, Intent[], int), getBroadcast(Context, int, Intent, int), or getService(Context, int, Intent, int).
If you only need one PendingIntent active at a time for any of the Intents you will use, then you can alternatively use the flags FLAG_CANCEL_CURRENT or FLAG_UPDATE_CURRENT to either cancel or modify whatever current PendingIntent is associated with the Intent you are supplying.
Una bona aplicació Android és més que només codi. Els recursos d'una aplicació Android (Android App Resources) són els fitxers addicionals que representen el contingut estàtic que el codi utilitzar (bitmaps, definicions de layouts, strings de la interfície, etc.)
Seguint els típics i aconsellables paradigmes de disseny, és altament recomanable externalitzar els recursos com les imatges o els textos del codi font. Això té múltiples avantatges, per exemple:
Qualsevol tipus de recurs pot classificar en un dels següents grups:
Com s'explica a l'apartat Estructura d'una aplicació Android, els recursos es guarden a la carpeta res. Vegem un exemple de configuration qualifier:
El layous de la interfície gràfica (layout UI) per defecte es guarda a la carpeta:
res/layout
Però es poden especificar altres layouts per a altres tipus de pantalles, o per exemple per a una orientació horitzontal (landscape):
res/layout-land/
Android automàticament aplica els recursos adequats.
La següents és una taula de les carpetes (segons el tipus de recurs) que us podeu trobar a dins de la carpeta res:
TODO: Taula
animator/ fitxers XML que defineixen propietats de lees animacions anim/ fitxers XML que defineixen tween animations color/ XML files that define a state list of colors. See Color State List Resource drawable/ Bitmap files (.png, .9.png, .jpg, .gif) or XML files that are compiled into the following drawable resource subtypes: Bitmap files Nine-Patches (re-sizable bitmaps) State lists Shapes Animation drawables Other drawables Drawable Resources layout/ Fitxers XML que defineixen layouts de la interfície gràfica. Vegeu Layout Resources. menu/ Fitxers XML que defineixen menús d'aplicaciones, com els menús Options Menu, Context Menu, o Sub Menu. Vegeu Menu Resource. raw/ Aquest és un directori tipus calix de sastre, que permet guardar qualsevol tipus de recurs en cru (raw). Es poden obrir aquests recursos amb com a InputStream, utilitzant Resources.openRawResource() i passant com a paràmetre el resource ID, que és R.raw.filename values/ Conté fitxers XML que contenen valors simples, com strings, enters o colors. A diferencia de les altres carpetes on cada fitxers descriu un recurs, aquí s'utilitza un sol fitxers per a tots els recursos del mateix tipus. Es poden posar els noms que es vulguin però es recomana: - arrays.xml: per definir vectors de recursos (aka typed arrays). - colors.xml: per valors de colors - dimens.xml: pre valors de dimensions - strings.xml: per a valors de text. - styles.xml: per a definir Android styles. Vegeu String Resources, Style Resource, i altres Resource Types. xml/ Permet guardar fixers XML de qualsevol tipus. En temps d'execución aquests fitxers estan disponibles amb Resources.getXML(). Serveix per exemple per guardar fitxers de configuració XML
De totes maneres, si es necessita accedir als recursos pel seu nom original de fitxers, es pot considerar la posibilitat d'utilitzar la carpeta:
assets
en comptes de res/raw
Els fitxers que es troben a la carpeta assets/ no tenen un resource ID, i per tant només es poden utilitzar utilitzant la classe AssetManager
Recursos:
Podeu obtenir una llista completa de recursos a:
http://developer.android.com/guide/topics/resources/available-resources.html
Els recursos es poden clasificar en recursos compilats i recursos no compilats:
L'eina que compila és Android Asset Packaging Tool (AAPT). Els recursos compilats es poden als fitxers .apk
La forma de proveir de recursos alternatius a una aplicació Android és la següent:
<resources_name>-<config_qualifier>
On:
Un exemple clar són les carpetes drawable que us genera Eclipse:
res/
drawable/
icon.png
background.png
drawable-hdpi/
icon.png
background.png
NOTA: Es pot indicar més d'un <qualifier>, cal separar cada qualificador amb un guió (dash).És important però posarlos en ordre segons les les taules de http://developer.android.com/guide/topics/resources/available-resources.html
on hdpi és un qualifier que indica dispositius amb pantalles high-density.
podeu consultar la taula completa de qualificadors a:
taules: http://developer.android.com/guide/topics/resources/providing-resources.html#AlternativeResources
Cal tenir en compte algunes normes alhora d'utilitzar els qualificadors.
Exemple correcte:
drawable-port-hdpi/
Exemple incorrecte:
drawable-hdpi-port/
El sistema operatiu té un algorisme per determinar quina és la configuració que més s'adapta al vostre dispositiu i per tant la que s'ha d'aplicar.
Recursos:
Aquests recursos estan predefinits per defecte per l'SDK i els podeu trobar a la carpeta
/data/res
Que estarà a on tingueu instal·lat el SDK, en el meu cas, p.ex.:
/home/sergi/android-sdks/platforms/android-17/data/res
Hi ha infinitat, la pàgina:
http://androiddrawables.com/
Us pot ajudar a trobar-los ja que els classifica per tipus.
Vegem alguns exemples:
Localized strings per a Yes/No/Cancel/Ok:
android.R.strings.yes android.R.strings.no android.R.strings.cancel android.R.strings.ok
android.R.color.transparent
android.R.anim
Recursos:
Tal i com es veu a la imatge:
podeu veure que a la part superior de l'editor gràfic del layout podeu canviar les configuracions per provar la configuració.
El primer desplegable mostra les configuracions possibles. Des d'aquí podeu utilitzar l'opció Create per crear una nova configuració.
TODO: Captura de pantalla
La clase clau per a la gestió de recursos és:
Resources -> http://developer.android.com/reference/android/content/res/Resources.html
Normalment s'obté una implementació d'aquesta clase amb el mètode:
getresources -> http://developer.android.com/reference/android/content/Context.html#getResources%28%29
Que és de la clase Context, de la que són pare totes les activitats.
El paràmetre més important d'un recurs és el seu Resource ID (identificador del recurs). L'aplicació:
aapt
és l'eina encarregada de crear la classe R (consulteu l'apartat Building & Running). Quan l'aplicació es construida per Eclipse (o manualment o p.ex utilitzant Ant), aapt genera la clase R que conté els identificadors de recursos de tots els recursos de la carpeta res. Per cada recurs hi ha una subclase R (per exemple R.drawable és una subclase amb tots els recursos de tipus R). Per a cada recurs hi ha un static integer que l'identifica, per exemple:
R.drawable.icon
Aquest integer (icon al exemple) és el resource ID.
Tot i que la classe R és on estan tots els IDs especificats, no cal mirar al seu interior per conèixer els IDs, ja que sempre es composen de la següent forma:
Hi ha dos formes d'accedir als recursos:
Accedint a recursos des del codi:
Un exemple de com obtenir una recurs de tipus imatge:
ImageView imageView = (ImageView) findViewById(R.id.myimageview); imageView.setImageResource(R.drawable.myimage);
El pàrametre és de tipus resource ID, tal i com podeu veure a la documentació API:
developer.android.com/reference/android/widget/ImageView.html
void setImageResource(int resId) Sets a drawable as the content of this ImageView.
Un altre exemple molt comú és el següent codi:
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
TODO
While uncommon, you might need access your original files and directories. If you do, then saving your files in res/ won't work for you, because the only way to read a resource from res/ is with the resource ID. Instead, you can save your resources in the assets/ directory.
Files saved in the assets/ directory are not given a resource ID, so you can't reference them through the R class or from XML resources. Instead, you can query files in the assets/ directory like a normal file system and read raw data using AssetManager.
However, if all you require is the ability to read raw data (such as a video or audio file), then save the file in the res/raw/ directory and read a stream of bytes using openRawResource(). Syntax
Here's the syntax to reference a resource in code:
[<package_name>.]R.<resource_type>.<resource_name>
<package_name> is the name of the package in which the resource is located (not required when referencing resources from your own package). <resource_type> is the R subclass for the resource type. <resource_name> is either the resource filename without the extension or the android:name attribute value in the XML element (for simple values).
See Resource Types for more information about each resource type and how to reference them. Use cases
There are many methods that accept a resource ID parameter and you can retrieve resources using methods in Resources. You can get an instance of Resources with Context.getResources().
Here are some examples of accessing resources in code:
// Load a background for the current screen from a drawable resource getWindow().setBackgroundDrawableResource(R.drawable.my_background_image) ;
// Set the Activity title by getting a string from the Resources object, because // this method requires a CharSequence rather than a resource ID getWindow().setTitle(getResources().getText(R.string.main_title));
// Load a custom layout for the current screen setContentView(R.layout.main_screen);
// Set a slide in animation by getting an Animation from the Resources object mFlipper.setInAnimation(AnimationUtils.loadAnimation(this,
R.anim.hyperspace_in));
// Set the text on a TextView object using a resource ID TextView msgTextView = (TextView) findViewById(R.id.msg); msgTextView.setText(R.string.hello_message);
Caution: You should never modify the R.java file by hand—it is generated by the aapt tool when your project is compiled. Any changes are overridden next time you compile.
Dins d'un fitxer XML es poden definir valors XML a els atributs i elements XML fent referencia a recursos Android existents. Per exemple als fitxers de layout XML (que per ells mateixos són també un recurs Android) es típic fer referencia a recursos Android de tipus valor de text (Strings). Un exemple:
<Button
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="@string/submit" />
aquest extracte d'un fitxer XMl de Layout representa un Botó el text del qual pren el valor del recurs de text @string/submit.
La sintaxi és la següent
@[<package_name>:]<resource_type>/<resource_name>
On:
Exemples
Declaració del recurs:
<?xml version="1.0" encoding="utf-8"?> <resources> <color name="opaque_red">#f00</color> <string name="hello">Hello!</string> </resources>
Ús del recurs.
<?xml version="1.0" encoding="utf-8"?> <EditText xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="fill_parent" android:layout_height="fill_parent" android:textColor="@color/opaque_red" android:text="@string/hello" />
En aquest fixeu-vos que no no cal indicar el paquet per que correspon a un recurs propi.
En altres casos utilitzarem recursos de sistema. Un exemple:
<?xml version="1.0" encoding="utf-8"?> <EditText xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="fill_parent" android:layout_height="fill_parent" android:textColor="@android:color/secondary_text_dark" android:text="@string/hello" />
Fixeu-vos en l'ús de:
@android:
Inclús es poden crear recursos en fitxers XML per tal de crear aliases. Per exemple es pot crear un recurs de tipus drwable que sigui un alias d'un altre recurs de tipus drawable:
<?xml version="1.0" encoding="utf-8"?> <bitmap xmlns:android="http://schemas.android.com/apk/res/android" android:src="@drawable/other_drawable" />
Això pot semblar redundant, però pot ser molt útil al utilitzar [[recursos alternatius]
Un recurs de tipus atribut d'estil permet fer referenciar al valor d'un atribut del tema aplicat actualment. Això permet personalitzar el "look & feel" dels elements de la vostra UI sense utilitzat valors hardcoded.
La sintaxi és similar a la resta de recursos però amb el prèfix ?:
?[<package_name>:][<resource_type>/]<resource_name>
Un exemple:, "primary" text color del tema del sistema:
<EditText id="text" android:layout_width="fill_parent" android:layout_height="wrap_content" android:textColor="?android:textColorSecondary" android:text="@string/hello_world" />
Android proporciona un nombre estandard de de recursos per defecte com els estils, els temes o els layouts aka Platform Resources. En aquests casos cal posar en prefix android, vegem un exemple amb ListAdapter:
setListAdapter(new ArrayAdapter<String>(this, android.R.layout.simple_list_item_1, myarray));
Al exemple, simple_list_item_1 és un layou predefinit pel sistema pensat per a les ListView. Vegeu també List View.
Recursos:
Android Localization
IMPORTANT: Recordeu que la localització és molt més que la traducció a diferents llengues d'una aplicació. Consulteu l10n i i18n per a més informació
En un mon internacionalitzat com el nostre hem de tenir en compte que les aplicacions Android es poden executar en múltiples tipus de dispositius en múltiples regions del món. Per tal de que l'aplicació pugui arribar a la majoria d'usuaris és important que l'aplicació tingui en compte les especificitats de cada regió.
La localització en Android se suporta en el conegut com a Android resource framework, ja que permet en gran manera separar la localització del codi Java.
Vegeu també:
Recursos:
Sempre és una bona idea separar els textos (Strings) de la interfície gràfica de l'aplicació del codi, mantenint estos textos en fitxers específics de forma que es faciliti la traducció.
Els Recursos Android i concretament els recursos de tipus string facilitant la tasca de la localització.
A la carpeta res/ hi ha un directori per als recursos de tipus valor res/values on trobareu el fitxer:
res/values/strings.xml
Per traduir l'aplicació només cal proveir de recursos alternatius de tipus string a la vostra aplicació:
TODO:
Captura de les facilitats que posa Eclipse. Captures de pantalla
Per accedir als strings des del codi Java podeu utilitzar getResources():
// Get a string resource from your app's Resources String hello = getResources().getString(R.string.hello_world);
o un altre exemple:
// Or supply a string resource to a method that requires a string TextView textView = new TextView(this); textView.setText(R.string.hello_world);
http://developer.android.com/intl/es/training/multiscreen/screendensities.html
Segurament la millor forma d'entendre el concepte de densitat de pantalla és comparar-ho amb la resol·lució s'indica com el nombre de pixels totals que hi ha a una pantalla (per exemple 1024x800). En canvi la densitat és quan pixels apareixen per a una unitat constant d'espai.
Si s'incrementa la resol·lució i la densitat al mateix temps la mida es manté. Aquesta és la raó per la que un G1 amb una pantalla de 320x480 i una pantalla de 480x800 d'un Droid tenen la mateixa mida.
Conceptes
px = dp * (dpi / 160).
Per exemple en una pantalla de 240 dpi, 1dp equival a 1.5 pixels físics.
IMPORTANT: Sempre s'han d'utilitzar unitats dp al definir la interfície gràfica, per tal d'assegurar-se que l'aplicació es veure correctament en pantalles de diferents densitat
Els grups generals s'obtenen a partir de la següent gràfica:
El que si que hi ha és unes característiques mínimes per pertanyer a un grup o a un altre:
la següent imatge mostra les relacions entre bitmaps depenen de la densitat:
La següent és una llista de les millors pràctiques a seguir:
Recursos:
Hi ha un assistent al SDK anomenat Android Icon Set.
Vegeu també: Android Asset Studio
El consell bàsic és tenir una imatge de base per a la mdpi i que sigui una imatge escalable sense perdre qualitat. A partir d'esta imatge de poden crear les imatges per a la resta de Screen densities:
Pàgina on s'explica molt bé:
Vegeu també Android Storage.
Hi ha uns quants casos en els que una activitat serà destruida pel sistema operatiu. Alguns d'aquests casos són normals o "obvis", com per exemple quan l'usuari prem el botó back i surt de l'aplicació o de l'activitat (en aquest cas s'invoca el mètode finish()).
També és possible però que el sistema operatiu elimini una activitat si està està aturada i es necessita alliberar recursos de sistema com memòria.
Quan l'activitat finalitza de forma normal la instància de l'activitat desapareix i si es torna a cridar l'activitat es torna a crear una nova activitat sense cap relació amb l'anterior.
En canvi si és el sistema operatiu qui elimina la activitat la instància actual de l'activitat desapareix però el sistema recorda que existia i permet recrear l'activitat (re-instanciar) a partir d'unes dades salvades pel programador. Les dades que el sistema utilitza pre retaurar l'estat anterior s'anomenen "instance state" i són una col·lecció de parells-valors que s'enmagatzemant en un objecte Bundle:
android.os.bundle [developer.android.com/reference/android/os/Bundle.html]
NOTA: bundle vol dir "farcell" o "bulto" en castellà
IMPORTANT: Les activitats també són detruides i tornades a crear cada cop que es rota la pantalla! Això és així per que la configuració de la pantalla ha canviat i cal tornar per exemple a executar onCreate per aplicar si s'escau layouts alternatius
al objecte Bundle cal salvar informació com per exemple el text posat a un camp de text d'un formulari abans que aquest sigui pujat.
Si cal guardar més dades o fer alguna acció més elaborada aleshores s'implementa:
onSaveInstanceState()
el sistema crida aquest mètode quan l'usuari deixa l'activitat i passa l'objecte Bundle per tal de guardar.lo. Aquest bundle es torna a passar al mètodes:
onRestoreInstanceState()
i
onCreate()
Vegeu Android_Storage#Fitxers
Consulteu:
Consulteu Procesos Android
Vegeu Android connectivity
Vegeu Android sensors
Vegeu:
Cal instal·lar el paquet:
$ sudo apt-get install ia32-libs
