Introducción a esta sección:
Hemos hablado antes de un montón de cosas que parecen no tener relación con el desarrollo de Android, ¿verdad? Por supuesto, solo parecen así ahora; ¡más adelante, cuando mires atrás, lo entenderás! Bien, en esta sección tomaremos como punto de entrada el proyecto Hello World creado anteriormente para comprender la estructura del proyecto y las dos formas de acceso a recursos en Android. El IDE utilizado en los tutoriales posteriores es Android Studio, porque hace unos días Google anunció oficialmente que antes de fin de año terminará el soporte para otros entornos de desarrollo IDE.

1. Análisis de la estructura del proyecto:
Pasamos la mayor parte del tiempo de desarrollo en la siguiente parte:

A continuación, explicamos las partes clave:
- java:El lugar donde escribimos código Java; las funciones de negocio se implementan aquí.
- res:El lugar donde se almacenan nuestros diversos archivos de recursos, como imágenes, cadenas, animaciones, audio, etc., así como archivos XML de diversas formas.
1. Introducción a la carpeta de recursos res:
PD: Hablando de estodirectorio res, también mencionemos esto:directorio assetsAunque no está aquí, podemos crearlo nosotros mismos. La diferencia entre ambos es que en el primero (res) todos los archivos de recursos generan un ID de recurso correspondiente en el archivo R.java, mientras que en el segundo (assets) no. En el primero podemos acceder directamente al recurso correspondiente mediante el ID de recurso; en el segundo, necesitamos leerlo a través de AssetManager en forma de flujo binario. Por cierto, este archivo R puede entenderse como un diccionario: cada recurso en res genera un ID único aquí.
A continuación, hablemos de los directorios relacionados bajo el directorio de recursos res:
PS:El directorio mipmap mencionado a continuación no existe en Eclipse; en Eclipse todos son carpetas que comienzan con drawable. En realidad, la diferencia no es grande, solo que usar mipmap proporciona cierta optimización del rendimiento en la escala de imágenes. Con diferentes resoluciones, el sistema seleccionará las imágenes correspondientes en hdpi, mdpi, xhdpi, xxhdpi según la resolución de pantalla. Por eso, al descomprimir el APK de otra persona, puedes ver imágenes con el mismo nombre en los directorios mencionados, presentes en las cuatro carpetas, solo que con diferentes tamaños y píxeles. ¡Por supuesto, esto no es absoluto! Por ejemplo, si ponemos todas las imágenes en drawable-hdpi, aunque el teléfono debería cargar los recursos de imagen de la carpeta ldpi, como no hay nada en ldpi, cargará las imágenes de hdpi. Además, hay otro caso: por ejemplo, si existen en las carpetas hdpi y mdpi, pero no en ldpi, entonces se cargarán los recursos de mdpi. El principio es usar el nivel de densidad más cercano. Además, si quieres evitar que Android cargue recursos de diferentes carpetas según la densidad de pantalla, solo necesitas agregar el campo android:anyDensity="false" en el archivo AndroidManifest.xml.
1. Primero hablemos deimágenesrecursos:
- drawable:Almacena varios archivos de mapa de bits (.png, .jpg, .9png, .gif, etc.), además pueden ser algunos otros archivos XML de tipo drawable.
- mipmap-hdpi:Alta resolución; generalmente ponemos las imágenes aquí.
- mipmap-mdpi:Resolución media; muy pocas veces, a menos que el teléfono compatible sea muy antiguo.
- mipmap-xhdpi:Resolución ultra alta; los materiales de las pantallas de los teléfonos mejoran cada vez más, y se estima que gradualmente se migrará hacia aquí en el futuro.
- mipmap-xxhdpi:Resolución ultra ultra alta; esto se refleja en los teléfonos de gama alta.
2. Continuemos hablando dediseñorecursos:
- layout: en este directorio se almacenan nuestros archivos de diseño. Además, en algunos modelos específicos, hacemos adaptación de pantalla, como teléfonos de 480*320; creamos otro conjunto de diseños, por ejemplo, una carpeta como layout-480x320.
3. A continuación hablemos de los recursos de menú:
- menu:En teléfonos que solían tener un botón de menú físico, es decir, la tecla de menú, se usaba bastante; ahora no se usa mucho. Los recursos XML relacionados con los elementos de menú se pueden escribir aquí. No sé si Google lanzará algo nuevo para reemplazar el menú.
4. A continuación hablemos del directorio values:
- demens.xml: define recursos de dimensiones.
- string.xml: define recursos de cadenas.
- styles.xml: define recursos de estilos.
- colors.xml: define recursos de colores.
- arrays.xml: define recursos de arrays.
- attrs.xml: se usa más al personalizar controles; ¡define los atributos de los controles personalizados!
- theme es un archivo de tema, muy similar a styles, pero afecta a toda la Actividad o a una Actividad específica en la aplicación; generalmente se usa para cambiar la apariencia de la ventana. Se puede usar mediante setTheme en código Java, o agregando el atributo theme para <application...> en AndroidManifest.xml. PD: Es posible que hayas visto directorios values como values-w820dp, values-v11, etc. La 'w' del primero representa dispositivos tableta, y 820dp representa el ancho de pantalla; mientras que 'v11' significa que solo se usará después de API(11), es decir, Android 3.0.
5. Continuemos hablando del directorio raw: se utiliza para almacenar varios recursos nativos (audio, video, algunos archivos XML, etc.). Podemos obtener el flujo binario del recurso mediante openRawResource(int id). En realidad, es similar a Assets, solo que los recursos aquí generan un ID de recurso en el archivo R.
6. Por último, también están las animaciones; hay dos tipos: animación de propiedades y animación interpolada (tween).
- animator: almacena archivos XML de animación de propiedades.
- anim: almacena archivos XML de animación interpolada (tween).
2. Cómo utilizar estos recursos
Bien, ya sabemos qué recursos hay; a continuación, veamos cómo usarlos. Como se dijo antes, todos nuestros archivos de recursos generan un ID de recurso en el archivo R.java; podemos usar este ID de recurso para acceder al recurso. Hay dos formas de uso: uso en código Java y uso en código XML.
Uso en código Java:
Texto en Java:
txtName.setText(getResources().getText(R.string.name));
Imagen:
imgIcon.setBackgroundDrawableResource(R.drawable.icon);
Color:
txtName.setTextColor(getResouces().getColor(R.color.red));
Diseño:
setContentView(R.layout.main);
Control:
txtName = (TextView)findViewById(R.id.txt_name);
Uso en código XML:
Se obtiene mediante @xxx; por ejemplo, aquí para obtener texto e imagen:
<TextView android:text="@string/hello_world" android:layout_width="wrap_content" android:layout_height="wrap_content" android:background = "@drawable/img_back"/>
2. Conocimiento profundo de tres archivos:
Bien, a continuación analizaremos tres archivos importantes del proyecto: MainActivity.java, el archivo de diseño activity_main y el archivo de configuración de Android: AndroidManifest.xml.PS:El contenido de las imágenes puede diferir un poco; no tuve tiempo de hacer las figuras, espero que comprendas.

MainActivity.java:
El código es el siguiente
package jay.com.example.firstapp;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
}
Análisis del código:
Archivo de diseño: activity_main.xml:
El código es el siguiente:
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity">
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/hello_world" />
</RelativeLayout>
Análisis del código:
Definimos un diseño lineal LinearLayout; en el espacio de nombres xml definimos el esquema que necesitamos usar, que proviene de ①.

Archivo de configuración AndroidManifest.xml:
El código es el siguiente:
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="jay.com.example.firstapp" >
<application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:theme="@style/AppTheme" >
<activity
android:name=".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>
</application>
</manifest>
Análisis del código:

Además del contenido anterior:
① Si la aplicación contiene otros componentes, todos deben declararse en este archivo mediante la sintaxis de especificación de tipo. Server:
Elemento BroadcastReceiver Elemento ContentProvider Elemento Elemento IntentFilter<intent-filter>
Resumen de esta sección:
Resumen de esta sección: