Curso de Introducción a Android Sesión 6: App Resources y App Manifest Introducción Como se ha visto en anteriores sesiones, Android hace por regla general un uso intensivo de los llamados recursos o resources, archivos importantes para el funcionamiento de la app que no están conformados por código Java. En esta sesión se estudiará en profundidad la gestión de los resources y cómo cambiar de unos a otros según la configuración del dispositivo (tamaño y orientación de pantalla, idioma, versión de la API...). Recursos y su organización Todos los recursos de la app se encuentran en la carpeta res. Esta carpeta está en app/src/main/res en Android Studio y a su vez cuenta con subcarpetas para organizar los recursos: animator: animaciones de propiedades (Android 3.0+) en XML. anim: animaciones y animaciones de propiedades declaradas en XML. color: listas de colores en XML aplicables a Views según su estado (pulsado, activada, desactivada, etc.). drawable: imágenes y drawables declarados en XML: Archivos.png,.jpg,.9.png y.gif. State-lists: archivos XML que asignan un drawable a cada estado de un View (activo, pulsado, etc.). Shapes: archivos XML que crean drawables a partir de formas (rectángulo, óvalo, línea, etc.). Animation Drawables: archivos XML que definen una animación creada a partir de una serie de imágenes. layout: layouts con las configuraciones de la interfaz en XML. menu: menús declarados en XML. raw: aquí van los archivos que se van a usar como recursos pero no cuadran en ninguna otra carpeta, como sonidos, vídeos, etc. values: valores simples como strings, colores, dimensiones o enteros. Por regla general se tienen los siguientes archivos: arrays.xml : almacena arrays de datos (string, ints, referencias a otros recursos). colors.xml : almacena colores asignándoles un nombre. dimens.xml : almacena dimensiones, tamaños de Views, márgenes, paddings, etc.
strings.xml : almacena cadenas de texto. styles.xml : almacena estilos y temas aplicables a Views o a Activities. xml: almacena archivos XML en general (por ejemplo, Preferences). Aparte de estos nombres de carpeta, Android permite añadir sufijos para que los recursos que maneje la aplicación concuerden con la configuración del dispositivo. Aunque se van a dar ejemplos concretos, estos sufijos pueden añadirse a cualquier carpeta, depende del desarrollador saber si tiene sentido o no hacerlo así. Además, estos sufijos pueden combinarse, pudiendo tener por ejemplo values-es y values-es-land. Otro punto importante es que estos valores sólo sobreescriben otros valores de la carpeta por defecto. Es decir, si tenemos un values/strings.xml con <string name="computer">pc</string> y sabemos que PC es igual en español, no necesitaremos un values-es/string.xml con el mismo valor (aunque Android por seguridad nos pedirá que lo pongamos). Aparte, podemos distinguir entre los recursos del propio proyecto y los de Android mediante @android:xxxxx/ y @xxxxxx/. En @color/ tendríamos los colores que hayamos definido en el proyecto y en @android:color/ los colores que el SDK de Android usa internamente. Algunos ejemplos de modificadores son: Densidad de píxeles Aunque Android por defecto hace escala de los drawables, puede ser interesante especificar drawables distintos si por ejemplo al tener muy poca densidad de píxeles se pierden detalles. Los distintos valores se miden a partir del valor de mdpi y se multiplican por un factor para saber el tamaño que debería tener. ldpi: 0.75 (en desuso) mdpi: 1.0 hdpi: 1.5 xhdpi: 2.0 xxhdpi: 3.0 xxxhdpi: 4.0 Para Android TV tenemos también tvdpi con un factor de escala de 1.33. Esto quiere decir que si tenemos una imagen que en mdpi son 40x40px, en ldpi debería ser de 30x30px y en xhdpi 80x80px.
Los nombres de las carpetas serían drawable-xxxx : drawable-ldpi, drawable-hdpi, etc. Si quisiéramos meter imágenes que no se reescalen nunca usaríamos drawable-nodpi. Tamaño de pantalla Hay varias formas de tratar las configuraciones. Tamaño general: Se miden por su tamaño máximo en dp. Las siguientes medidas significan "hasta ese valor sin incluírlo", es decir, si se alcanza estaríamos en la siguiente configuración. small: hasta 320x470dp (QVGA). normal: hasta 480x640dp (HVGA y WVGA). large: hasta 720x960dp (VGA y WVGA). xlarge: todas las que sean más grandes.
De esta forma tendríamos por ejemplo layout-large, layout-small, etc. Tamaño mínimo: Para esto tenemos el modificador sw dp, que nos permite especificar unos dp mínimos de ancho para el dispositivo. Tenemos por ejemplo que sw600dp suele ser para tablets de 7" y sw720dp para tablets de 10". Este "ancho" se mantiene entre cambios de orientación horizontal y vertical, es decir, aunque se gire, se toma como ancho "el valor más grande de ancho y alto". Por el contrario, con los modificadores w dp y h dp aunque sirven para lo mismo, este valor no se mantiene. Es decir, si tenemos un tablet de 600x360dp en vertical cogería los recursos que hubiese en layout_w600dp, pero si lo giramos pasaría a ser de 360x600dp y ya no entraría, aunque sí lo haría a una carpeta layout_h600dp. Orientación Podemos cambiar el valor de los distintos recursos según la orientación de pantalla con los modificadores port (vertical) y land (horizontal), aunque se suele usar sólo este último, ya que sin modificador se interpreta como port igualmente.
Así, podríamos tener distintos layouts para vertical y horizontal con layout y layout-land o incluso si sabemos que en hoizontal un texto puede contener más información, podríamos tener distintos strings.xml en values y values-land. Tipo de dispositivo: Aquí podemos configurar recursos para los distintos tipos de dispositivos: car: para coche, en un dock. desk: en un dock de escritorio. television: el dispositivo está conectado a una TV (Android TV, ChromeCast, Stick USB con Android)... appliance: el dispositivo no tiene pantalla. watch: el dispositivo es un reloj (Android Wear). Idioma Podemos configurar los recursos para cada idioma, con los formatos idioma_region o simplemente idioma. Por ejemplo, para inglés tendríamos values-en, para inglés americano values-en_us y para inglés británico values-en_gb. En español tendríamos values-es_es y por ejemplo `values-es_ar" para español de Argentina. Versión de la API Hay algunos Views, valores, temas, etc. que sólo están disponibles a partir de cierta versión de la API de Android y hay que tener cuidado de no intentar usarlos si el dispositivo en el que se usa la app no tiene dicha versión. Así por ejemplo, si sabemos que el tema Theme.Holo.Dark necesita Android 4.0 o superior (API 14) y queremos mantener la compatibilidad con Android 2.3.3 (API 10), por ejemplo, necesitaremos
crear: values : aquí irían los recursos de APIs 8 a 13 y comunes a todas las APIs. values-v14 : aquí irían los recursos propios de las APIs 14 y mayores. Si por ejemplo quisiéramos usar el tema Theme.Material.Light, de Android 5.0 (API 21) tendríamos que crear otra carpeta values-v21 con sus respectivos values. Como se ha dicho, esto es para mantener compatibilidad. Si quisiéramos hacer una app que funcionase sólo en Android 5.0 y superiores no sería necesario usar el modificador de API, con la carpeta por defecto nos valdría. Tipos de recursos: Animaciones: Tienen la siguiente forma: <set xmlns:android="http://schemas.android.com/apk/res/android" android:interpolator="@[package:]anim/interpolator_resource" android:shareinterpolator=["true" "false"] > <alpha android:fromalpha="float" android:toalpha="float" /> <scale android:fromxscale="float" android:toxscale="float" android:fromyscale="float" android:toyscale="float" android:pivotx="float" android:pivoty="float" /> <translate android:fromxdelta="float" android:toxdelta="float" android:fromydelta="float" android:toydelta="float" /> <rotate android:fromdegrees="float" android:todegrees="float" android:pivotx="float" android:pivoty="float" /> <set> Un set es un conjunto de de animaciones, que puede tener un interpolator (una forma de regular la
velocidad a la que se ejecutan las partes de la animación) y una serie de animaciones de los tipos: alpha: cambio de opacidad, 0 es invisible (pero aún se puede tocar) y 1 totalmente visible. scale: cambiar el ancho y el alto (X e Y), el pivot es desde qué punto de la View se inicia la animación, si pusiésemos 0.5 en pivotx y pivoty se iniciaría desde el centro. translate: cambiar la posición en pantalla de la View. rotate: rotar cierta cantidad de grados la View. Todas las animaciones además tienen los valores: duration: duración en ms de la animación (1000ms -> 1s). fillbefore fillafter: indica si se debe animar y además cambiar los valores de la View, pues es posible animar y que el cambio sólo sea estético pero no llegue al código, de forma que por ejemplo después de desplazar un View pinchas en la antigua posición, aún salte el evento de click. fillbefore : aplicar el cambio de valores antes de empezar la animación. Debe acompañarse de fillenabled="true" para que tenga efecto. fillafter : aplicar el cambio de valores al finalizar la animación (no es necesario fillenabled ). Las animaciones se pueden cargar en código con: Animation translateanim = AnimationUtils.loadAnimation(this, R.anim.hyperspace_ju miview.startanimation(translatanim); Drawables Como se ha dicho antes, un Drawable puede ser: Un fichero de imagen. Un color. Un XML que combine imágenes, colores, formas, etc. Una serie de drawables combinados. Un selector con distintos valores para los distintos estados de una View. Vamos a ver cómo se define por ejemplo un botón con relieve: <!-- layer-list es una lista de drawables uno encima de otro --> <layer-list xmlns:android="http://schemas.android.com/apk/res/android"> <!-- Sombra de 2dp, es un rectángulo con bordes redondeados --> <item> <shape android:shape="rectangle"> <solid android:color="#d8d8d8" /> <corners android:radius="7dp" />
</shape> </item> <!-- Parte superior del botón, de color blanco y con un margen inferior de 3dp este margen sirve para dar el efecto del botón con relieve --> <item android:bottom="3dp"> <shape android:shape="rectangle"> <solid android:color="#ffffff" /> <corners android:radius="7dp" /> </shape> </item> </layer-list> Este botón podría verse así al aplicarlo como android:background a una View: El esquema es el siguiente: * Lista de capas: -> Item: ->Shape, Bitmap, etc. ->Propiedades Si quisiésemos hacer un selector para que el botón se animara al pulsarlo: <selector xmlns:android="http://schemas.android.com/apk/res/android"> <item android:drawable="@drawable/numpad_button_bg_disabled" android:state_disa <item android:drawable="@drawable/numpad_button_bg_pressed" android:state_press <item android:drawable="@drawable/numpad_button_bg_normal"></item>
</selector> Este selector toma los posibles valores de los estados de View (pressed, selected, disabled, etc.) y asigna un drawable a cada uno de ellos, de forma que cuando se pulse o se desactive, el drawable que se dibuje cambiará. Este selector podría llamarse por ejemplo numpad_button y se podría seleccionar mediante @drawable/numpad_button. Menús Los menús se crean mediante archivos XML también. <menu xmlns:android="http://schemas.android.com/apk/res/android"> <item android:id="@+id/new_game" android:icon="@drawable/ic_new_game" android:title="@string/new_game" android:showasaction="ifroom"/> <item android:id="@+id/help" android:icon="@drawable/ic_help" android:title="@string/help" /> </menu> Este menú tendría 2 acciones, una con ID new_game y otra con ID help. Aunque ambos tendrían iconos, normalmente sólo se mostraría el primero. Esto se controla con android:showasaction. Como vemos, el primero usa "ifroom", es decir, "si queda espacio". Este menú podría verse similar al siguiente:
Donde los items con showasaction activado serían los iconos y el resto estaría en el menú desplegable. Raw
Aquí van el resto de recursos que no tienen cabida en ninguno de los apartados. Si por ejemplo quisiéramos cargar un MP3 podríamos hacerlo así: InputStream streamdatos = getresources().openrawresource(r.raw.mi_cancion); Lo cual nos abriría una puerta a los datos del archivo "mi_cancion.mp3" guardado en res/raw. Values Dentro de values podemos encontrar: Arrays: Son arrays o listas de recursos: <resources> <string-array name="ciudades"> <item>madrid</item> <item>barcelona</item> </string-array> <integer-array name="distancia_a_almeria"> <item>544</item> <item>797</item> </integer-array> </resources> Pueden cargarse con: String[] ciudades = getresources.getstringarray(r.array.ciudades); int[] distancias = getresources.getintarray(r.array.distancia_a_almeria); O asignarse a un ListView o Spinner con: android:entries="@arrays/ciudades" Colores: Nombres asignados a colores para su reutilización: <resources> <item name="blue" type="color">#ff33b5e5</item> <item name="purple" type="color">#ffaa66cc</item> <item name="green" type="color">#ff99cc00</item> <item name="orange" type="color">#ffffbb33</item>
<item name="red" type="color">#ffff4444</item> <item name="darkblue" type="color">#ff0099cc</item> <item name="darkpurple" type="color">#ff9933cc</item> <item name="darkgreen" type="color">#ff669900</item> <item name="darkorange" type="color">#ffff8800</item> <item name="darkred" type="color">#ffcc0000</item> </resources> Pueden cargarse como: int azul = getresources.getcolor(r.color.blue); O asignarse como un drawable: android:background="@color/blue" Dimensiones: Tamaños, ya sea de márgenes, anchos, altos, tamaños de fuentes... <resources> <dimen name="action_button_min_width">56dp</dimen> <dimen name="indeterminate_progress_size">32dp</dimen> </resources> Se cargan con: int progresssize = (int) getresources().getdimension(r.dimen.indterminate_progres O usarse como una dimensión más: android:layout_width="@dimen/width_view_principal" android:margintop="@dimen/margen_global" Strings: Cadenas de texto: <resources> <string name="hello">hello!</string> </resources> Pueden cargarse mediante: String hello = getstring(r.string.hello);
// O también hello = getresources.getstring(r.string.hello); Y pueden usarse con la propiedad android:text="@string/mi_string". Temas y estilos: Los estilos o styles en Android son similares a los estilos de CSS, se aplican a un elemento para no tener que definirlo todo cada vez en el xml o para elementos que tienen configuraciones comunes. Así por ejemplo, si nuestra app tiene un tema rojo y queremos que todos los botones sean rojos con el texto en blanco podemos definir: <resources> <style name="redbutton" parent="android:widget.button"> <item name="android:textsize">20sp</item> <item name="android:textcolor">#fff</item> <item name="android:background">#cc0000</item> </style> </resources> Como veis le hemos puesto como estilo padre el del botón por defecto de Android para que herede todos sus estilos por defecto y hemos sobreescrito el tamaño del texto, su color y el fondo del botón. Para aplicar este estilo usaríamos: <Button... style="@style/redbutton" /> Si ahora quisiéramos un botón rojo con el texto enorme podríamos crear: <resources> <style name="redbutton.big" parent="@style/redbutton"> <item name="android:textsize">40sp</item> </style> </resources> De esta forma tendríamos los mismos estilos que en RedButton, pero con el texto mucho más grande. Temas: Los temas son estilos que se aplican a una Activity o incluso a la aplicación entera. Para ello deben de tener como parent un tema por defecto de los de Android y pueden cambiar sus valores mediante items. Por ejemplo, podemos tener el siguiente tema:
<style name="customtheme" parent="android:theme.light"> <item name="android:windowbackground">@color/green_color</item> <item name="android:colorbackground">@color/green_color</item> </style> Que nos permitiría cambiar el color de fondo de la ventana por un color verde. Este tema lo aplicaríamos en el AndroidManifest.xml : <application android:theme="@style/customtheme"> <activity android:theme="@android:style/theme.translucent"> </application> Assets Los Assets funcionan de forma similar a los raw pero permiten tener acceso al archivo como tal, pudiendo copiarlo, borrarlo, listarlo, etc. Suelen usarse para guardar archivos relacionados con web para mostar en WebView y similares. AndroidManifest.xml El Android Manifest es un archivo XML que define puntos importantes de la app como por ejemplo: Permisos que usa la aplicación. Elementos que la componen. Dispositivos soportados. Características necesarias para su ejecución (cámara, bluetooth, gps...). <manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.example" > <uses-permission android:name="android.permission.internet" /> <uses-feature android:name="android.hardware.camera" android:required="true" /> <supports-screens android:largescreens="false"/> <application android:allowbackup="true" android:icon="@drawable/ic_launcher" android:label="@string/app_name" android:theme="@style/apptheme"> <activity android:name="com.example.mainactivity"
android:label="@string/app_name"> <intent-filter> <action android:name="android.intent.action.main" /> <category android:name="android.intent.category.launcher" /> </intent-filter> </activity> <service android:name="com.example.backgroundservice"> <intent-filter>... </intent-filter> </service> <receiver android:name="com.example.broadcastreceiver"> <intent-filter>... </intent-filter> </receiver> </application> </manifest> Este Manifest, por ejemplo: Tiene como paquete principal del proyecto com.example. Usa el permiso de Internet, sin el cual la aplicación se cerraría al intentar conectar a la red. Necesita que el dispositivo tenga cámara obligatoriamente. No soporta pantallas grandes (large). Tiene un icono, un label (o nombre) y un tema para la app y permite que se haga copia de seguridad de la misma. Tiene una activity que aparece en el Launcher (inicio del teléfono) debido a su intent-filter con category android.intent.category.launcher. Tiene un Service que hace trabajo de fondo. Tiene un BroadcastReceiver que responde a eventos del sistema según su intent-filter.