Introduction à cette section :

À partir de cette section, nous allons apprendre quelques connaissances de base sur le dessin et l'animation dans Android, en posant les fondations pour nos vues personnalisées dans la partie avancée ! Dans la première section, nous allons nous plonger dans les Drawable d'Android ! Android nous fournit jusqu'à 13 types de Drawable, et dans cette section nous allons les passer en revue un par un !


Remarques sur l'utilisation des ressources Drawable

  • Les Drawable se divisent en deux types : l'un correspond à nosressources d'images ordinaires, dans Android Studio nous les plaçons généralement dans le répertoire res/mipmap, contrairement à Eclipse auparavant ! De plus, si nous basculons le projet en mode projet Android, nous pouvons simplement déposer les images dans le répertoire mipmap, et AS les répartira automatiquement en hdpi, xhdpi... !Ressources Drawable au format XML, nous les plaçons généralement dans le répertoire res/drawable, comme le Selector le plus courant pour changer l'arrière-plan au clic d'un bouton !
  • En XML, nous pouvons définir directement un Drawable via @mipmap ou @drawable, par exemple : android:background = "@mipmap/iv_icon_zhu" / "@drawable/btn_back_selctor". Dans le code Java, nous pouvons obtenir des ressources drawable via getDrawable(R.mipmap.xxx) de Resource. Si l'on définit un arrière-plan pour un contrôle, comme ImageView, nous pouvons directement appeler getDrawable() du contrôle pour obtenir aussi l'objet drawable !
  • Les noms de ressources dans drawable sous Android ont des contraintes ; ils doivent être :[a-z0-9_.](c'est-à-dire ne peuvent être que des lettres, des chiffres,et .), et ne peuvent pas commencer par un chiffre, sinon la compilation signalera une erreur : Invalid file name: must contain only [a-z0-9.]! Minuscules!!!! Minuscules!!! Minuscules! — Les choses importantes se disent trois fois~

Très bien, voilà pour les points à noter. Ensuite, découvrons les 13 Drawables fournis dans Android !


1.ColorDrawable

Le type de Drawable le plus simple. Lorsque nous dessinons ColorDrawable sur Canvas (le canevas), il utilise une couleur fixe pour remplir Paint, puis dessine une zone de couleur unie sur le canevas !

1). Définition de ColorDrawable en Java :

ColorDrawable drawable = new ColorDrawable(0xffff2200);  
txtShow.setBackground(drawable);  

2). Définition de ColorDrawable en XML :

<?xml version="1.0" encoding="utf-8"?>  
<color  
    xmlns:android="http://schemas.android.com/apk/res/android"  
    android:color="#FF0000"/>  

Bien sûr, ces utilisations ci-dessus ne sont en fait pas très courantes. Le plus souvent, on crée un fichier color.xml dans le répertoire res/values, on y écrit les valeurs de couleur dont on a besoin, puis, au besoin, on récupère la valeur correspondante via @color, par exemple :

3). Créer un fichier color.xml

Par exemple :

<?xml version="1.0" encoding="utf-8"?>  
<resources>  
    <color name="material_grey_100">#fff5f5f5</color>
    <color name="material_grey_300">#ffe0e0e0</color>
    <color name="material_grey_50">#fffafafa</color>
    <color name="material_grey_600">#ff757575</color>
    <color name="material_grey_800">#ff424242</color>
    <color name="material_grey_850">#ff303030</color>
    <color name="material_grey_900">#ff212121</color>
</resources>

Ensuite, si l'on est dans un fichier XML, on peut obtenir la valeur de couleur correspondante via @color/xxx. Si l'on est en Java :

int mycolor = getResources().getColor(R.color.mycolor);    
btn.setBackgroundColor(mycolor);  

ps : Une autre chose à noter : si l'on définit directement des valeurs de couleur en Java, il faut ajouter 0x, et on ne peut pas omettre la transparence :

int mycolor = 0xff123456;    
btn.setBackgroundColor(mycolor); 

4). Utilisation de couleurs définies par le système :

Par exemple : BLACK (noir), BLUE (bleu), CYAN (cyan), GRAY (gris), GREEN (vert), RED (rouge), WRITE (blanc), YELLOW (jaune) ! Utilisation :btn.setBackgroundColor(Color.BLUE);Vous pouvez également récupérer les couleurs du système, puis les définir :

int getcolor = Resources.getSystem().getColor(android.R.color.holo_green_light);  
btn.setBackgroundColor(getcolor);  

Utilisation en XML :android:background="@android:color/black"

5). Utilisation de la méthode statique argb pour définir des couleurs :

Android utilise une donnée de type int pour représenter les valeurs de couleur, généralement en hexadécimal, c'est-à-dire commençant par 0x. Une valeur de couleur est définie par la transparence alpha et les trois couleurs primaires RGB (rouge, vert, bleu), commençant par '#', suivies dans l'ordre par :
Alpha - Rouge - Vert - Bleu;ex:#RGB #ARGB #RRGGBB #AARRGGBB
Chaque élément est représenté par un octet (8 bits), donc la plage de valeurs est de 0~255. En XML, vous pouvez omettre la transparence lors de la définition des couleurs, mais si vous êtes dans du code Java, vous devez spécifier explicitement la valeur de transparence. Si elle est omise, cela signifie qu'elle est totalement transparente, et elle n'aura alors aucun effet~ Par exemple : 0xFF0000 représente le rouge, mais si vous l'écrivez directement, rien ne se passe ; vous devez l'écrire comme ceci : 0xFFFF0000. Rappelez-vous que, lorsque vous définissez des valeurs de couleur dans du code Java, vous devez ajouter la transparence devant~ Exemple : (paramètres dans l'ordre : alpha, valeur de rouge, valeur de vert, valeur de bleu)txtShow.setBackgroundColor(Color.argb(0xff, 0x00, 0x00, 0x00));


2.NiewPatchDrawable

C'est l'image .9. Précédemment, nous1.6 Comment utiliser les images .9 (Nine Patch)avons déjà expliqué en détail comment créer des images .9 ! Le framework Android utilise un algorithme efficace d'optimisation graphique lors de l'affichage des images Nine-Patch, nous n'avons donc pas besoin de traitement spécial pour obtenir un étirement d'image adaptatif~ De plus, lors de l'utilisation d'AS, notez les points suivants :

  • 1. Les images nine-patch ne peuvent pas être placées dans le répertoire mipmap ; elles doivent être placées dans le répertoire drawable !
  • 2. L'image .9 dans AS doit avoir des lignes noires, sinon la compilation ne passera pas. Ce matin, mon cousin Ajun a dit dans le groupe que le designer de son entreprise lui a donné une image .9 sans lignes noires, a dit qu'elle avait été réalisée avec un logiciel quelconque, et qu'elle fonctionnait sur Eclipse. Oui, c'était une .9 sans lignes noires, bon sang, mais quand je suis passé à AS, elle ne compilait pas directement ! Il semble que l'un des critères pour qu'AS reconnaisse les images .9 soit la présence de points noirs ou de lignes noires ! De plus, mon cousin a donné une méthode pour supprimer les lignes noires :9patch(.9) Comment supprimer les points noirs/lignes noires que vous avez dessinés dessusJe ne l'ai pas essayé spécifiquement. Si cela vous intéresse, vous pouvez l'essayer vous-même, mais les lignes noires sont-elles vraiment si embêtantes... Je n'ai pas de TOC, donc je ne pense pas ! Un autre point : lorsque vous décompressez l'APK de quelqu'un d'autre et prenez des ressources .9, vous constatez qu'il n'y a pas de lignes noires, et cela signale aussi des erreurs ! Si vous voulez extraire des ressources .9 avec des lignes noires, vous devez décompiler l'APK plutôt que de le dézipper directement !!! La décompilation a aussi été présentée plus tôt, donc je n'entrerai pas dans les détails ici !

Ensuite, présentons deux choses qui ne sont pas très utiles :

Définir NinePatchDrawable en XML:

<!--pic9.xml-->  
<!--参数依次为:引用的.9图片,是否对位图进行抖动处理-->  
<?xml version="1.0" encoding="utf-8"?>  
<nine-patch  
    xmlns:android="http://schemas.android.com/apk/res/android"  
    android:src="@drawable/dule_pic.html"  
    android:dither="true"/>  

Utiliser Bitmap pour encapsuler des images .9:

<!--pic9.xml-->  
<!--参数依次为:引用的.9图片,是否对位图进行抖动处理-->  
<?xml version="1.0" encoding="utf-8"?>  
<bitmap  
    xmlns:android="http://schemas.android.com/apk/res/android"  
    android:src="@drawable/dule_pic.html"  
    android:dither="true"/>

3.ShapeDrawable

C'est le Drawable de forme, définissant des formes géométriques de base telles que (rectangle, cercle, ligne, etc.). L'élément racine est <shape../>. Il y a pas mal de nœuds ; les nœuds associés sont les suivants :

  • ① <shape>:
  • ~ visible: Définir si visible
  • ~ shape: Forme, facultatif: rectangle (rectangle, y compris le carré), oval (ellipse, y compris le cercle), line (segment de ligne), ring (anneau)
  • ~ innerRadiusRatio: Uniquement valide lorsque shape vaut ring; indique le rapport entre le rayon intérieur de l'anneau et le rayon total. Si innerRadius est défini, il sera ignoré.
  • ~ innerRadius: Uniquement valide lorsque shape vaut ring; indique la taille du rayon intérieur de l'anneau.
  • ~ thicknessRatio: Uniquement valide lorsque shape vaut ring; indique le rapport entre l'épaisseur de l'anneau et le rayon.
  • ~ thickness: Uniquement valide lorsque shape vaut ring; indique l'épaisseur de l'anneau, c'est-à-dire la différence entre le rayon extérieur et le rayon intérieur.
  • ~ useLevel: Uniquement valide lorsque shape vaut ring; indique s'il est permis d'afficher une partie de l'anneau en fonction du niveau.
  • ②<size>:
  • ~ width: Largeur de la forme
  • ~ height: Hauteur de la forme
  • ③<gradient>: Sera abordé plus tard dans GradientDrawable~
  • ④<solid>
  • ~ color: Couleur de remplissage d'arrière-plan. Après avoir défini solid, cela remplacera tous les effets définis par gradient!!!!!!
  • ⑤<stroke>
  • ~ width: Largeur de la bordure
  • ~ color: Couleur de la bordure
  • ~ dashWidth: Longueur des tirets de la bordure
  • ~ dashGap: Espace entre les tirets de la bordure
  • ⑥<conner>
  • ~ radius: Rayon des coins, applicable aux quatre coins : haut, bas, gauche, droite
  • ~ topLeftRadius,topRightRadius,BottomLeftRadius,tBottomRightRadius: Dans l'ordre : valeurs des coins supérieur gauche, supérieur droit, inférieur gauche, inférieur droit. Définissez-les selon vos besoins !
  • ⑦<padding>
  • left, top, right, bottom : Dans l'ordre, les marges dans les directions gauche, haut, droite, bas !

Exemple d'utilisation: 2.3.1 TextView (zone de texte) Explication détaillée


4.GradientDrawable

Un Drawable avec des zones de dégradé, permettant d'obtenir des effets de dégradé linéaire, radial et en balayage. Nœud central : <gradient/>, avec les attributs facultatifs suivants :

  • startColor: Couleur de début du dégradé
  • centerColor: Couleur intermédiaire du dégradé
  • endColor: Couleur de fin du dégradé
  • type: Type de dégradé, facultatif (linear,radial,sweep), dégradé linéaire(permet de définir l'angle du dégradé), dégradé radial (rayonnant du centre vers l'extérieur), dégradé sweep
  • centerX: coordonnée X de la couleur intermédiaire du dégradé, plage de valeurs : 0~1
  • centerY: coordonnée Y de la couleur intermédiaire du dégradé, plage de valeurs : 0~1
  • angle: Uniquement les dégradés de type linear sont valides ; indique l'angle du dégradé, qui doit être un multiple de 45.
  • gradientRadius: Uniquement les dégradés de type radial et sweep sont valides ; pour radial, il doit être défini, indiquant le rayon de l'effet de dégradé.
  • useLevel: Détermine s'il faut dessiner l'effet de dégradé en fonction du niveau.

Exemple de code: (Démonstration des trois effets de dégradé) :

Capture d'écran de l'effet d'exécution:

Créez d'abord trois fichiers XML de dégradé dans drawable :

(Dégradé linéaire) gradient_linear.xml:

<?xml version="1.0" encoding="utf-8"?>
<shape
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:shape="oval" >
    <gradient
        android:angle="90"
        android:centerColor="#FFEB82"
        android:endColor="#35B2DE"
        android:startColor="#DEACAB" />

    <stroke
        android:dashGap="5dip"
        android:dashWidth="4dip"
        android:width="3dip"
        android:color="#fff" />
</shape>

(Dégradé radial) gradient_radial.xml:

<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android"
    android:innerRadius="0dip"
    android:shape="ring"
    android:thickness="70dip"
    android:useLevel="false" >

    <gradient
        android:centerColor="#FFEB82"
        android:endColor="#35B2DE"
        android:gradientRadius="70"
        android:startColor="#DEACAB"
        android:type="radial"
        android:useLevel="false" />

</shape> 

(Dégradé sweep) gradient_sweep.xml:

<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android"
    android:innerRadiusRatio="8"
    android:shape="ring"
    android:thicknessRatio="3"
    android:useLevel="false" >

    <gradient
        android:centerColor="#FFEB82"
        android:endColor="#35B2DE"
        android:startColor="#DEACAB"
        android:type="sweep"
        android:useLevel="false" />

</shape> 

Appelez les trois drawablesactivity_main.xml:

<LinearLayout 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"
    android:orientation="vertical">

    <TextView
        android:id="@+id/txtShow1"
        android:layout_width="200dp"
        android:layout_height="100dp"
        android:background="@drawable/gradient_linear" />

    <TextView
        android:id="@+id/txtShow2"
        android:layout_width="200dp"
        android:layout_height="200dp"
        android:background="@drawable/gradient_radial" />

    <TextView
        android:id="@+id/txtShow3"
        android:layout_width="100dp"
        android:layout_height="100dp"
        android:background="@drawable/gradient_sweep" />

</LinearLayout>  

Bon, c'est aussi simple que ça~ Bien sûr, si vous voulez dessiner des graphiques plus complexes, utiliser uniquement des fichiers XML est loin d'être suffisant. Les effets plus complexes doivent être réalisés avec du code Java. La démonstration suivante est un extrait de code source pris sur Internet :

Capture d'écran de l'effet d'exécution :

Code d'implémentation:

MainActivity.java:

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(new SampleView(this));
    }

    private static class SampleView extends View {
        private ShapeDrawable[] mDrawables;

        private static Shader makeSweep() {
            return new SweepGradient(150, 25,
                    new int[] { 0xFFFF0000, 0xFF00FF00, 0xFF0000FF, 0xFFFF0000 },
                    null);
        }

        private static Shader makeLinear() {
            return new LinearGradient(0, 0, 50, 50,
                    new int[] { 0xFFFF0000, 0xFF00FF00, 0xFF0000FF },
                    null, Shader.TileMode.MIRROR);
        }

        private static Shader makeTiling() {
            int[] pixels = new int[] { 0xFFFF0000, 0xFF00FF00, 0xFF0000FF, 0};
            Bitmap bm = Bitmap.createBitmap(pixels, 2, 2,
                    Bitmap.Config.ARGB_8888);

            return new BitmapShader(bm, Shader.TileMode.REPEAT,
                    Shader.TileMode.REPEAT);
        }

        private static class MyShapeDrawable extends ShapeDrawable {
            private Paint mStrokePaint = new Paint(Paint.ANTI_ALIAS_FLAG);

            public MyShapeDrawable(Shape s) {
                super(s);
                mStrokePaint.setStyle(Paint.Style.STROKE);
            }

            public Paint getStrokePaint() {
                return mStrokePaint;
            }

            @Override protected void onDraw(Shape s, Canvas c, Paint p) {
                s.draw(c, p);
                s.draw(c, mStrokePaint);
            }
        }

        public SampleView(Context context) {
            super(context);
            setFocusable(true);

            float[] outerR = new float[] { 12, 12, 12, 12, 0, 0, 0, 0 };
            RectF inset = new RectF(6, 6, 6, 6);
            float[] innerR = new float[] { 12, 12, 0, 0, 12, 12, 0, 0 };

            Path path = new Path();
            path.moveTo(50, 0);
            path.lineTo(0, 50);
            path.lineTo(50, 100);
            path.lineTo(100, 50);
            path.close();

            mDrawables = new ShapeDrawable[7];
            mDrawables[0] = new ShapeDrawable(new RectShape());
            mDrawables[1] = new ShapeDrawable(new OvalShape());
            mDrawables[2] = new ShapeDrawable(new RoundRectShape(outerR, null,
                    null));
            mDrawables[3] = new ShapeDrawable(new RoundRectShape(outerR, inset,
                    null));
            mDrawables[4] = new ShapeDrawable(new RoundRectShape(outerR, inset,
                    innerR));
            mDrawables[5] = new ShapeDrawable(new PathShape(path, 100, 100));
            mDrawables[6] = new MyShapeDrawable(new ArcShape(45, -270));

            mDrawables[0].getPaint().setColor(0xFFFF0000);
            mDrawables[1].getPaint().setColor(0xFF00FF00);
            mDrawables[2].getPaint().setColor(0xFF0000FF);
            mDrawables[3].getPaint().setShader(makeSweep());
            mDrawables[4].getPaint().setShader(makeLinear());
            mDrawables[5].getPaint().setShader(makeTiling());
            mDrawables[6].getPaint().setColor(0x88FF8844);

            PathEffect pe = new DiscretePathEffect(10, 4);
            PathEffect pe2 = new CornerPathEffect(4);
            mDrawables[3].getPaint().setPathEffect(
                    new ComposePathEffect(pe2, pe));

            MyShapeDrawable msd = (MyShapeDrawable)mDrawables[6];
            msd.getStrokePaint().setStrokeWidth(4);
        }

        @Override protected void onDraw(Canvas canvas) {

            int x = 10;
            int y = 10;
            int width = 400;
            int height = 100;

            for (Drawable dr : mDrawables) {
                dr.setBounds(x, y, x + width, y + height);
                dr.draw(canvas);
                y += height + 5;
            }
        }
    }
}

Le code utilise ShapeDrawable et PathEffect. Le premier est une enveloppe pour les formes ordinaires, incluant : ArcShape, OvalShape, PathShape, RectShape, RoundRectShape !
PathEffect, quant à lui, est un effet de tracé, incluant : CornerPathEffect, DashPathEffect et DiscretePathEffect, qui peuvent être utilisés pour créer des bordures de formes complexes...
C'est tout pour GradientDrawable. Si ces derniers vous intéressent, vous pouvez vous rendre sur :appium/android-apidemos


Résumé de cette section :

Bon, dans cette section, nous allons d'abord découvrir ColorDrawable, NinePatchDrawable, ShapeDrawable et GradientDrawable.
Commençons par les quatre Drawables. Bien sûr, ce sont d'anciens sujets qui ont déjà été traités, mais pour l'exhaustivité du tutoriel, j'ai décidé de les écrire à nouveau. De plus, après avoir terminé les tutoriels de base, certains blogs écrits auparavant seront supprimés !