Introduction à cette section :

Nous avons parlé d'un tas de choses qui semblent sans rapport avec notre développement Android, n'est-ce pas ? Bien sûr, cela ne semble ainsi que maintenant ; vous comprendrez en y repensant plus tard ! Bon, dans cette section, nous utiliserons le projet Hello World créé précédemment comme point d'entrée pour comprendre la structure du projet et les deux façons d'accéder aux ressources dans Android ! L'IDE utilisé dans les tutoriels suivants est Android Studio, car il y a quelques jours, Google a officiellement annoncé qu'il mettra fin au support des autres environnements de développement IDE avant la fin de l'année !


1. Analyse de la structure du projet :

Nous passons la majeure partie de notre temps de développement sur la partie suivante :

Ensuite, nous allons expliquer les parties clés :

  • java:C'est ici que nous écrivons le code Java, et les fonctions métier y sont implémentées.
  • res:C'est ici que nous stockons divers fichiers de ressources, notamment des images, des chaînes de caractères, des animations, de l'audio, etc., ainsi que diverses formes de fichiers XML.

1. Introduction au dossier de ressources res :

PS : En parlant de cerépertoire res, nous devrions aussi mentionner cerépertoire assetsBien qu'il ne soit pas ici, nous pouvons le créer nous-mêmes. La différence entre les deux est de savoir si tous les fichiers de ressources du premier généreront des ID de ressources correspondants dans le fichier R.java, alors que le second ne le fera pas. Pour le premier, nous pouvons accéder directement aux ressources correspondantes via l'ID de ressource ; pour le second, nous devons les lire sous la forme d'un flux binaire via AssetManager. Au fait, ce fichier R peut être compris comme un dictionnaire ; chaque ressource sous res générera un ID unique ici !

Ensuite, parlons des répertoires associés sous le répertoire de ressources res :

PS :Le répertoire mipmap mentionné ci-dessous n'existe pas dans Eclipse ; dans Eclipse, les répertoires commencent par drawable. En fait, la différence n'est pas grande. L'utilisation de mipmap offre une certaine optimisation des performances lors de la mise à l'échelle des images. Avec différentes résolutions, le système sélectionnera les images correspondantes sous hdpi, mdpi, xhdpi, xxhdpi en fonction de la densité de l'écran. Ainsi, lorsque vous décompressez l'APK de quelqu'un d'autre, vous pouvez voir des images portant le même nom dans les répertoires ci-dessus, présentes dans les quatre dossiers, ne différant que par la taille et les pixels ! Bien sûr, ce n'est pas absolu. Par exemple, si nous plaçons toutes les images dans drawable-hdpi, même si le téléphone devrait charger les ressources d'images depuis le dossier ldpi, comme il n'y en a aucune sous ldpi, il chargera quand même les images depuis hdpi ! De plus, il existe une autre situation : par exemple, si les répertoires hdpi et mdpi ont la ressource, mais pas ldpi, alors il chargera la ressource depuis mdpi ! Le principe est d'utiliser le niveau de densité le plus proche ! Aussi, si vous voulez empêcher Android de charger des ressources depuis différents dossiers en fonction de la densité de l'écran, ajoutez simplement le champ android:anyDensity="false" dans le fichier AndroidManifest.xml !

1. Tout d'abord, parlons desressources d'images :

  • drawable :Stocke divers fichiers bitmap (.png, .jpg, .9.png, .gif, etc.). En outre, il peut y avoir d'autres fichiers XML de type drawable.
  • mipmap-hdpi :Haute résolution ; nous plaçons généralement les images ici.
  • mipmap-mdpi :Résolution moyenne ; rarement utilisée, sauf si les téléphones compatibles sont très anciens.
  • mipmap-xhdpi :Très haute résolution ; la qualité des écrans de téléphone s'améliore de plus en plus, et l'on estime qu'elle évoluera progressivement vers ceci à l'avenir.
  • mipmap-xxhdpi :Résolution super super élevée ; cela se reflète dans les téléphones haut de gamme.

2. Passons maintenant auxressources demise en page :

  • layout : Ce répertoire stocke nos fichiers de mise en page. De plus, pour certains modèles spécifiques, lors de l'adaptation d'écran, comme les téléphones en 480*320, nous créerons un autre ensemble de mises en page, par exemple un dossier comme layout-480x320 !

3. Passons maintenant aux ressources de menu :

  • menu:C'était davantage utilisé sur les téléphones qui avaient auparavant un bouton de menu physique, c'est-à-dire la touche menu. Aujourd'hui, ce n'est plus beaucoup utilisé. Les ressources XML liées aux éléments de menu peuvent être écrites ici. Je me demande si Google introduira quelque chose de nouveau pour remplacer le menu~

4. Passons maintenant au répertoire values :

  • demens.xml : définit les ressources de dimension.
  • string.xml : définit les ressources de chaîne.
  • styles.xml : définit les ressources de style.
  • colors.xml : définit les ressources de couleur.
  • arrays.xml : définit les ressources de tableau.
  • attrs.xml : utilisé davantage lors de la personnalisation de contrôles ; définit les attributs des contrôles personnalisés !
  • theme est un fichier de thème, très similaire à styles, mais il affecte les Activities dans toute l'application ou une Activity spécifiée, modifiant généralement l'apparence de la fenêtre ! Il peut être utilisé via setTheme dans le code Java, ou en ajoutant l'attribut theme à <application...> dans AndroidManifest.xml ! PS : Vous avez peut-être vu des répertoires values comme values-w820dp, values-v11, etc. Le premier 'w' représente les appareils tablettes, et '820dp' représente la largeur d'écran ; tandis que 'v11' signifie qu'il ne sera utilisé qu'après API (11), c'est-à-dire Android 3.0 !

5. Passons maintenant au répertoire raw : Il est utilisé pour stocker diverses ressources natives (audio, vidéo, certains fichiers XML, etc.). Nous pouvons obtenir le flux binaire de la ressource via openRawResource(int id). En fait, c'est similaire à Assets, sauf que les ressources ici généreront un ID de ressource dans le fichier R.

6. Enfin, il y a les animations. Il existe deux types d'animations : l'animation de propriété et l'animation tween :

  • animator : stocke les fichiers XML pour l'animation de propriété.
  • anim : stocke les fichiers XML pour l'animation tween.

2. Comment utiliser ces ressources

Eh bien, maintenant que nous savons quelles ressources existent, comprenons comment les utiliser : Comme mentionné précédemment, tous nos fichiers de ressources généreront un ID de ressource dans le fichier R.java. Nous pouvons utiliser cet ID de ressource pour accéder aux ressources. Il y a deux cas d'utilisation : utilisation dans le code Java et utilisation dans le code XML.

Utilisation dans le code Java :

Texte Java :

txtName.setText(getResources().getText(R.string.name)); 

Image :

imgIcon.setBackgroundDrawableResource(R.drawable.icon); 

Couleur :

txtName.setTextColor(getResouces().getColor(R.color.red)); 

Mise en page :

setContentView(R.layout.main);

Contrôle :

txtName = (TextView)findViewById(R.id.txt_name);

Utilisation dans le code XML :

Vous pouvez l'obtenir via @xxx. Par exemple, ici nous obtenons du texte et des images :

<TextView android:text="@string/hello_world" android:layout_width="wrap_content" android:layout_height="wrap_content" android:background = "@drawable/img_back"/>

2. Compréhension approfondie de trois fichiers :

Très bien, nous allons ensuite analyser trois fichiers importants du projet : MainActivity.java, le fichier de mise en page : activity_main, et le fichier de configuration Android : AndroidManifest.xmlPS :Le contenu de l'image peut être un peu différent ; je n'ai pas eu le temps de faire le schéma, j'espère que vous comprenez~

MainActivity.java :

Le code est le suivant :

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

Analyse du code :

Fichier de mise en page : activity_main.xml :

Le code est le suivant :

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

Analyse du code :

Nous avons défini un LinearLayout. Dans l'espace de noms XML, nous définissons l'architecture que nous devons utiliser, qui provient de ①.

Fichier de configuration AndroidManifest.xml :

Le code est le suivant :

<?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>

Analyse du code :

En plus du contenu ci-dessus :

① Si l'application contient d'autres composants, ils doivent être déclarés dans ce fichier en utilisant la syntaxe de déclaration de type Service :élément BroadcastReceiverélément ContentProviderélément IntentFilter<intent-filter> élément

② Déclaration des autorisations : Dans ce fichier, déclarez explicitement les autorisations requises par le programme afin d'éviter que l'application n'utilise incorrectement des services ou n'accède de manière inappropriée aux ressources, ce qui améliore en fin de compte la robustesse de l'application Android. android.permission.SEND_SMS : si cette déclaration est présente, cela signifie que l'application a besoin de l'autorisation d'envoyer des SMS. L'utilisateur en sera informé lors de l'installation. Les autorisations pertinentes peuvent être trouvées dans le manuel de référence du SDK !


Résumé de cette section :

Dans cette section, nous avons acquis une compréhension détaillée de notre projet Hello World, de ce que font les répertoires associés, des fichiers de ressources présents sous res, de leur rôle et de la manière d'utiliser ces ressources ! Nous avons également expliqué en détail, à l'aide de schémas, les trois fichiers les plus importants du projet ! À ce stade, je pense que vous avez déjà une compréhension générale des projets Android ! Merci~