IMPORTANT: Per accedir als fitxer de subversion: http://acacha.org/svn (sense password). Poc a poc s'aniran migrant els enllaços. Encara però funciona el subversion de la farga però no se sap fins quan... (usuari: prova i la paraula de pas 123456)

Desenvolupament amb Android

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:

Contingut

Preparar l'entorn de desenvolupament

Instal·lar Java

Vegeu Java

Instal·lar Eclipse

Consulteu Eclipse#Instal.C2.B7laci.C3.B3_per_a_Android

Instal·lar Android Studio

Vegeu Android Studio

Instal·lar emulador Android amb x86 a Virtual Box

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.

Depuració

Connexió directe a dispositiu per USB

Consulteu:

Desenvolupament_Android#Provar_les_aplicacions_al_m.C3.B2bil

NOTA: A Windows cal instal·lar un driver USB

Comandes importants:

Depuració a emulador

Vegeu l'apartat emuladors. Podeu executar emuladors al mateix PC o en màquina remota i/o Màquina Virtual.

Connexió directe a dispositiu per wifi

Cal que el dispositiu estigui rootejat. TODO. S'utilitza l'ordre adb connecŧ per connectar al dispositiu remot.

Emuladors

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

Android Emulators

AVD (Android Virtual Device)

Podeu escollir dos tipus de emuladors:

Emuladors executat en màquina virtual

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:

Provar les aplicacions al mòbil

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

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í

Logcat

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)

Dalvik Debug Monitor Server (DDMS)

Versions i compatibilitat

Android Support Library

Versions

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

Descarregar la llibreria de suport

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:

Configurar una aplicació per treballar amb la llibreria

Com treballar amb Fragments

Consulteu Android_UI_Development#La_llibreria_de_compatibilitat_i_els_Fragments

Android form factors

Els Android form factors són (--acacha (discussió) 15:26, 30 oct 2015 (CET)):

Resources

Components

Existeixen els següent components en Android:

  • Activitats: Un Android Activity o activity representa una sola pantalla amb una interfície d'usuari. Per exemple una aplicació de emails tindrà una activitat on mostrarà la llista dels emails nous, un altre activitat per enviar emails i un altre per a llegir-los, etc. Tot i que les activitat treballen de forma conjunta a per tal de tenir una experiència d'usuari (UX) completa cada activitat és independent de la resta. Android utilitza el Intents per a comunicar activitats (i altres components android) entre si. Les activitats són el component principal d'Android.
  • Serveis: un servei Android o service és un component android que s'executa en segon terme (background) per tal d'executar operacions de llarga durada. Com a tal els serveis al contrari que les activitats no tenen interfície d'usuari. Per exemple un servei pot executar música en segon terme mentrestant s'està treballant en una activitat (itnterfície d'usuari concreta)
  • Content providers: Un Android content provider o Content Provider gestiona un conjunt compartit de dades d'aplicació. Les dades poden estar guardades a qualsevol dels sistemes de persistència en Android com un fitxer o una base de dades SQLite, però també a la web o a qualsevol storage location al que la la vostra aplicació tingui accés.
  • Broadcast receivers: un broadcast receiver és un component Android que respon a a esdeveniments de broadcast del sistema. Molts d'aquests esdeveniments són generats pel propi sistema (exemples: pantalla s'ha aturar, la bateria és baixa, s'ha connectat un dispositiu USB). Les aplicacions també poden generar esdeveniments de broadcast. Sovint els broadcast receivers no tenen cap interfície gràfica tot i que si poden crear una notificació o alerta a la barra d'estatus però el més comú és que simplement siguin un "gateway" que simplement executi un altre component com una activitat o un servei que processi l'esdeveniment. Un broadcast receiver s'implementa heretant la classe BroadcastReceiver i cada broadcast és entregat utilitzant un Intent object ([1]). Vegeu article Broadcast receivers


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

Android SDK

Consulteu Android SDK

Configuració del path

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!

Android SDK Manager

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.

Comanda android

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.
android update sdk

Es pot actualitzar el SDK per línia de comandes amb:

$ android update sdk

android list

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

Android avd

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

Tools

adb

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:

adb devices

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
adb install

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
adb uninstall

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
root@android:/ # pm list packages

o

# pm list packages | grep iesebre
package:com.iesebre.helloworldapp
# exit


$ adb -s emulator-5556 uninstall com.iesebre.dam2.pa201415
adb connect

emulator

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

Exemple de creació d'una primera aplicació

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

IDEs

Eclipse

ADT. Android Development Tools per a Eclipse

Vegeu ADT. Android Development Tools per a Eclipse

Android Studio

Vegeu Android Studio

Primer programa. Hola mon!

Consulteu:

Estructura d'un projecte Android (Android Project Structure)

Android Studio

Vegeu Android_Studio#Estructura_d.27un_projecte

General

Estructura d'un projecte Android aka Android Project Structure.

Cada projecte Android creat amb l'assistent del ADT conté les següents carpetes:

  • src: Aquesta carpeta conté el codi font Java
  • gen: Generated Java library. És d'ús intern només per a Android
  • Res: En aquesta carpeta es guarden els recursos com qualsevol tipus de fitxer (imatges, vídeos, etc.), fitxers XML definint els layouts de la UI, etc.:
  • Drawable: Aquí s'emmagatzemen els diferents fitxers gràfics. Hi ha diferents fitxers per a cada resol·lució com per exemple: Drawable-mdpi, drawable-hdpi... Vegeu Android screen resolutions.
  • Layout: Aquí és troben els fitxers XML que defineixen els layouts. Els layouts indiquen com diferents objectes com textboxes, buttons, etc. s'organitzen a la pantalla.
  • Values: Fitxers XML que emmagatzemen string values (títols, etiquetes, etc.).
  • Assets: també conté recursos externs com la carpeta res, però la diferència principal és que els recursos es troben guardats en cru i només es poden llegir a través del codi font.

Els fitxers més importants d'un projecte Android són:

  • AndroidManifest.xml: This is the Android definition file. It contains information about the Android application such as minimum Android version, permission to access Android device capabilities such as internet access permission, ability to use phone permission, etc.
  • MainLayout.xml: This file describes the layout of the page. This means the placement of every component (such as textboxes, labels, radio buttons, user defined components, etc.) on the app screen.
  • Activity class: Every application that occupies the entire device screen needs at least one class which inherits from the Activity class. One major method is called OnCreate. This method initiates the app and loads the layout page.


Recursos:

El fitxer manifest d'Android

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:

  • Android:versionCode: Indica la versió del codi, i és important per tal que el dispositiu Android sàpiga quan hi ha una nova versió.
  • Android:sdkMinVersion: Defineix la versió mínima. Consulteu versions d'Android.
  • Activity element: Quina de les activitats disponibles és la activitat principal i s'ha d'arrencar a l'inici de l'aplicació.

Indicar les versions suportades per l'aplicació Android (MinSdkVersion, TargetSdkVersion)

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:

  • minSdkVersion: especifica la versió mínima d'API Level que la aplicació necessita per a executar-se. El valor per defecte és 1, és a dir, totes les versions.
  • targetSdkVersion: Especifica el API level per a la que l'aplicació ha estat dissenyada per ser executada. En alguns casos, això permet a les aplicacions utilitzar elements o comportaments definits en aquest nivell en comptes de estar limitada al ús de l'indicat a minSdkVersion.
  • maxSdkVersion: Especifica el valor màxim d'API Level al qual l'aplicació es pot executar.
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

Building & Running

http://jarroba.com/arquitectura-android-art-vs-dalvik/

Building & Running Android

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:

Br1ferranpallares.png

El següent gràfic mostra el procés detallat:

Br2ferranpallares.png

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:

Apkjuliaadell.png
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:

Resalexpearson.png
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:

  • L'eina Android Asset Packaging Tool (aapt) agafa els App Android Resources com per exemple el fitxer AndroidManifest.xml i la resta de fitxers XML de les activitats i les compila. També es crea la clase R.java per tal de que es pugui utilitzar al codi Java.
  • L'eina aidl converteix qualsevol interfície .aidl en interfície Java
  • Tot el codi, incloent el propi, la classe R.java i els fitxers aidl són compilats pel compilador Java.
  • L'eina dex converteix els fitxers .class a fitxers .hex (Dalvik byte code). Totes les llibreries de tercers i fitxers .class inclosos també són convertits a .hex i empaquetats al fitxer final apk.
  • Tots els recursos no compilats (p.ex. les imatges), i també els fitxers .dex són enviats a l'eina apkbuilder per tal que crei el apk.
  • Un cop el apk s'ha creat es signa
  • Si l'aplicació es signa en release mode, aleshores s'utilitza l'eina zipalign. Això permet disminuir el ús de memòria quan l'aplicació spexecuta a un dispositiu real.

Recursos:

Testing

Recursos:

Depurar

Dalvik Debug Monitor Server (DDMS)

Recursos:

Publicar

Desenvolupament de l'entorn gràfic d'Android. Android UI Development

Consulteu Android UI Development

Les activitats Android

Cicle de vida

Complet:

  • activity_lifecycle.png

Resumit (estats):

  • android-basiclifecycle.png

Vegeu també el cicle de vida dels Fragments.

Recursos:

Activity Stack

Activity Stack:

Android_activity_lifecycle_diagram.png

Resources:

Intent

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:

  • action: Acostuma a ser una constant que indica el tipus d'acció a realitzar (veure, modificar, editar, etc.). Exemples: ACTION_VIEW, ACTION_EDIT, ACTION_MAIN, etc.
  • data: una URI que indica de forma unívoca el recurs o dades sobre les que s'aplicarà l'acció.

Aquestes són les parts principals però també hi ha 4 parts secundaries:

  • category: Gives additional information about the action to execute. For example, CATEGORY_LAUNCHER means it should appear in the Launcher as a top-level application, while CATEGORY_ALTERNATIVE means it should be included in a list of alternative actions the user can perform on a piece of data.
  • type: Specifies an explicit type (a MIME type) of the intent data. Normally the type is inferred from the data itself. By setting this attribute, you disable that evaluation and force an explicit type.
  • component: Specifies an explicit name of a component class to use for the intent. Normally this is determined by looking at the other information in the intent (the action, data/type, and categories) and matching that with a component that can handle it. If this attribute is set then none of the evaluation is performed, and this component is used exactly as is. By specifying this attribute, all of the other Intent attributes become optional.
  • extras: This is a Bundle of any additional information. This can be used to provide extended information to the component. For example, if we have a action to send an e-mail message, we could also include extra pieces of data here to supply a subject, body, etc.

Recursos:

Tipus d'Intents

Hi ha dos tipus d'intents:

  • Explicit Intents: són aquells intents en que s'especifica un components utilitzant els mètodes setComponent(ComponentName) o setClass(Context, Class). Així s'indica de forma explícita quina classe s'ha d'executar. Sovint s'utilitza aquest tipus d'intents sense cap mena d'informació més afegida a l'intent, sent aquesta una manera típica d'executar Activitats des de altres Activitats.
  • Implicit Intents: no s'especifica la part del components de l'acció. Aleshores se suposa que l'Intent té prou informació per tal que el sistema pugui determinar quin component ha d'executar l'intent.

S'anomena Intent Resolution al procediment que realitzar el sistema per trobar el component que ha d'executar un Intent implícit.

Recursos:

Executar un altre activitat

Exemple bàsic:

 Intent intent = new Intent(MainActivity.this, Main2Activity.class);
 startActivity(intent);

Recursos:

Implicit intents

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.

Intent filters

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:

  • Els intents implícits no especifiquen un component de tipus target.
  • Els Components que volen rebre intents implícits tenen que obligatòriament declarar aquesta habilitat declarant Intent Filters al fitxer de manifest.
  • Un component pot declarar múltiples Intent Filters o el que és el mateix, múltiples capacitats.
  • Pot haver-hi més d'un component que declari el mateix tipus de Intent Filter o capacitat. En aquest cas al executar-se un Intent implícit el sistema operatiu deixarà escollir a l'usuari.
  • Es poden posar prioritats

Recursos:


PendingIntents

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.

Exemples

Android App Resources

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:

  • Suportar diferents configuracions. Per exemple, diferents idiomes o mides de pantalla.
  • Tot això sense haver de fer modificacions del codi per tal d'adaptar l'aplicació a nous possibles dispositius o configuracions fet molt important per que contínuament surten nous dispositius amb noves característiques.

Qualsevol tipus de recurs pot classificar en un dels següents grups:

  • Recursos per defecte (default resources): Són els recursos que s'utilitzaran per defecte independentment de la configuració del dispositiu o quan no s'especifiquen recursos alternatius per a la configuració actual.
  • Recursos alternatius (Alternative resources): són els que es disseyen per a una configuració específica. Per especificar que un conjunt de recursos són per a una configuració especifica, s'afegeix un sufix al nom de la carptea on estan els recursos. Aquest sufix es coneix com a configuration qualifier.
Dos dispositius diferents, utilitzant els dos el layout per defecte (la aplicació no té layouts alternatius).
Dos dispositius diferents, utilitzant cadascun un layout diferent per a diferents mides de pantalla.

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:

Tipus de 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:

  • Recursos compilats: la majoria de recursos XML de la carpeta res/ es compilen. Per exemple els layouts, els recursos simples de tipus text o el fitxer Manifest són compilats. Al compilar-los en temps d'execució es té un major rendiment al utilitzar-los.
  • Recursos no compilats: En canvi per exemple els fitxers de la carpeta /res/raw/ no es compilen, i cal utilitzar l'API s'Streams per a llegir aquests fitxers.

L'eina que compila és Android Asset Packaging Tool (AAPT). Els recursos compilats es poden als fitxers .apk

Recursos alternatius

La forma de proveir de recursos alternatius a una aplicació Android és la següent:

  • Crear un nou directoru a la carpeta res/. La sintaxi és:
<resources_name>-<config_qualifier>

On:

  • <resources_name>: és el nom del directory on està definit el corresponent recurs per defecte (default resources)
  • <qualifier>: és un nom reservat que especifica una tipus de configuració individual.

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/
  • No es poden fer anidaments de tipus: res/drawable/drawable-en/
  • Els valors són case-insensitive.
  • Només un valor és possible per cada tipus de qualificador.

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:

Recursos builtin

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

Built-in colors:

android.R.color.transparent

Built-in animations

android.R.anim

Recursos:

Eclipse ADT i la gestió de recursos

Tal i com es veu a la imatge:

layout_editor.png

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

Accedint als recursos des del codi

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:

  • El tipus de recurs: tots els recursos estan dins d'un tipus com string, drawable o layout. Vegeu Resource Types
  • El nom de recurs: sempre coincideix amb el nom del fitxer sense tenir en compte la extensión o en el cas dels values el atribut XML android:name si el recurs és un valor simple.

Hi ha dos formes d'accedir als recursos:

  • Accedir des del codi font: S'utilitza l'especificat anteriorment. Els detalls els trobeu en aquest mateix apartat. Per exemple: R.string.hello és un exemple clar de com obtenir el Resource ID d'un recurs.
  • Accedir des de fitxers XML: s'utilitza una sintaxi especial que s'explica al següent apartat.

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

Accedir als fitxers originals

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.

Accedint als recursos des de fitxers XML

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:

  • <package_name>: és un valor opcional que indica el nom del paquet a on es troba el recurs. No cal posar-ho quan s'utilitzant recursos del mateix paquet.
  • <resource_type>: és la subclase de la classe R, o el que coneixem com a tipus de recurs.
  • <resource_name>: és o el nom del fitxer sense la extensió del fitxer que conté el recurs, o en le cas de recursos del tipus valor simple el valor de l'atribut android:name.

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]

Utilitzant els atributs d'estil (style attributes)

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" />

Platform Resources

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:

Localització

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:

Suport per a múltiples idiomes

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/training/basics/supporting-devices/languages.html

Dispositius

Screen Densities

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

  • Screen size: la mida real de la pantalla, normalment es mesura segons la diagonal de la pantalla. A Android s'agrupen les mides de pantalla en els següents conjunts: small, normal, large i extra large
  • Screen density: Mesura la qualitat dels píxels per una unitat concreta de mesura. Normalment s'utilitza el terme dpi (dots per inch). Per exemple, una pantalla de baixa densitat té menys píxels donada un àrea concreta. Per simplicitat hi ha els següents grups: low, medium, high i extra high.
  • Orientació: l'orientació de la pantalla, des del punt de vista de l'usuari, pot ser landscape o portrait.
  • Resolution: és el número total de píxels físics a una pantalla. Quan s'afegeix suport per múltiples pantalles, les aplicacions no treballen directament amb la resol·lució, és a dir només s'han de preocupar de la mida de la pantalla i de la densitat.
  • Density-independent pixel (dp o dpi): Una unitat de píxel virtual que s'ha d'utilitzar al definir el layout de la UI per tal d'utilitzar-la a les mides de dimensions o posicions d'una forma independent a la densitat utilitzada. El dp és equivalent a un píxel en la mida base: 160 dpi screen. Tota la resta són relatives a aquesta base. En temps d'execució automàticament i de forma transparent es fa la conversió de dp virtual a píxel físic:
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:

screens-ranges.png

El que si que hi ha és unes característiques mínimes per pertanyer a un grup o a un altre:

  • xlarge screens are at least 960dp x 720dp
  • large screens are at least 640dp x 480dp
  • normal screens are at least 470dp x 320dp
  • small screens are at least 426dp x 320dp

la següent imatge mostra les relacions entre bitmaps depenen de la densitat:

screens-densities.png

La següent és una llista de les millors pràctiques a seguir:

  • Utilitzeu wrap_content, fill_parent, o unitat ens dps quan s'especifiquen les dimensions en un layout XML.
  • No utilitzar mai valors hardcoded de pixels en el codi.
  • No utilitzar mai AbsoluteLayout (deprecated)
  • Per cada imatge cal proporcionar bitmap drawables per a cada densitat de pantalla.

Recursos:

Disseny Icones

Hi ha un assistent al SDK anomenat Android Icon Set.

Vegeu també: Android Asset Studio

Disseny imatges

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é:

Persistència de dades. Emmagatzemament (Storage)

Vegeu també Android Storage.

Android bundle. Recreant activitats

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()

Fitxers

Vegeu Android_Storage#Fitxers

SQL lite

Programació xarxes Android

Consulteu:

Android Multimedia

Procesos

Consulteu Procesos Android


Android connectivity

Vegeu Android connectivity

Android Sensors

Vegeu Android sensors

Troubleshooting. Resol·lució de problemes

Error creant un emulador a Android 4.0. Unable to find a 'userdata.img' file for ABI armeabi to copy into the AVD folder.

Vegeu:

64 bits

Cal instal·lar el paquet:

$ sudo apt-get install ia32-libs

Vegeu també

Enllaços externs