Einführung in diesen Abschnitt:
Ab diesem Abschnitt lernen wir einige Grundlagen über Zeichnen und Animation in Android kennen und legen die Grundlage für unsere benutzerdefinierten Views im fortgeschrittenen Teil! Im ersten Abschnitt tauchen wir in Drawable in Android ein! Android bietet uns bis zu 13 Arten von Drawable, und in diesem Abschnitt gehen wir sie einzeln durch!
Hinweise zur Verwendung von Drawable-Ressourcen
- Drawable ist in zwei Typen unterteilt: Einer sind unseregewöhnlichen Bildressourcen, in Android Studio legen wir sie normalerweise im Verzeichnis res/mipmap ab, anders als früher bei Eclipse! Wenn wir das Projekt in den Android-Projektmodus umschalten, können wir Bilder einfach in das mipmap-Verzeichnis ziehen, und AS teilt sie automatisch in hdpi, xhdpi... auf!Drawable-Ressourcen in XML-Formlegen wir normalerweise im Verzeichnis res/drawable ab, wie z. B. den am häufigsten verwendeten Selector zum Umschalten des Hintergrunds beim Klicken auf Schaltflächen!
- In XML können wir Drawable direkt über @mipmap oder @drawable festlegen, zum Beispiel: android:background = "@mipmap/iv_icon_zhu" / "@drawable/btn_back_selctor". Im Java-Code können wir Drawable-Ressourcen über die getDrawable(R.mipmap.xxx) von Resource abrufen. Wenn wir einen Hintergrund für ein Steuerelement wie ImageView festlegen, können wir direkt getDrawable() des Steuerelements aufrufen, um ebenfalls das Drawable-Objekt zu erhalten!
- Ressourcennamen in drawable unter Android haben Einschränkungen; sie müssen sein:[a-z0-9_.](d. h. dürfen nur Buchstaben, Zahlen,und . enthalten), und dürfen nicht mit einer Ziffer beginnen, sonst meldet die Kompilierung einen Fehler: Invalid file name: must contain only [a-z0-9.]! Kleinbuchstaben!!!! Kleinbuchstaben!!! Kleinbuchstaben! — Wichtige Dinge dreimal gesagt~
Gut, das waren die Dinge, die zu beachten sind. Als Nächstes lernen wir die 13 Drawables kennen, die Android bereitstellt!
1.ColorDrawable
Die einfachste Art von Drawable. Wenn wir ColorDrawable auf Canvas (die Zeichenfläche) zeichnen, verwendet es eine feste Farbe zum Füllen von Paint und zeichnet dann einen einfarbigen Bereich auf die Zeichenfläche!
1). ColorDrawable in Java definieren:
ColorDrawable drawable = new ColorDrawable(0xffff2200); txtShow.setBackground(drawable);
2). ColorDrawable in XML definieren:
<?xml version="1.0" encoding="utf-8"?>
<color
xmlns:android="http://schemas.android.com/apk/res/android"
android:color="#FF0000"/>
Natürlich werden die oben genannten Verwendungen in der Praxis nicht oft genutzt. Häufiger erstellen wir eine color.xml-Datei im Verzeichnis res/values, schreiben die benötigten Farbwerte hinein und rufen bei Bedarf den entsprechenden Wert über @color ab, zum Beispiel:
3). Eine color.xml-Datei erstellen
Zum Beispiel:
<?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>
Wenn wir uns dann in einer XML-Datei befinden, können wir den entsprechenden Farbwert über @color/xxx abrufen. Wenn in Java:
int mycolor = getResources().getColor(R.color.mycolor); btn.setBackgroundColor(mycolor);
PS: Noch ein Hinweis: Wenn wir Farbwerte direkt in Java definieren, müssen wir 0x hinzufügen und dürfen die Transparenz nicht weglassen:
int mycolor = 0xff123456; btn.setBackgroundColor(mycolor);
4). Systemdefinierte Farben verwenden:
Zum Beispiel: BLACK (schwarz), BLUE (blau), CYAN (cyan), GRAY (grau), GREEN (grün), RED (rot), WRITE (weiß), YELLOW (gelb)! Verwendung:btn.setBackgroundColor(Color.BLUE);Man kann auch Systemfarben abrufen und sie dann setzen:
int getcolor = Resources.getSystem().getColor(android.R.color.holo_green_light); btn.setBackgroundColor(getcolor);
Verwendung in XML:android:background="@android:color/black"
5). Verwenden der statischen Methode argb zum Festlegen von Farben:
Android verwendet einen int-Datentyp, um Farbwerte darzustellen, normalerweise hexadezimal, d. h. beginnend mit 0x. Ein Farbwert wird durch die Alpha-Transparenz und die drei Primärfarben RGB (Rot, Grün, Blau) definiert, beginnt mit '#', gefolgt in dieser Reihenfolge von:
Alpha - Rot - Grün - Blau;z. B.:#RGB #ARGB #RRGGBB #AARRGGBB
Jedes Element wird durch ein Byte (8 Bits) dargestellt, daher liegt der Wertebereich bei 0~255. In XML kann man beim Festlegen von Farben die Transparenz weglassen, aber im Java-Code muss der Transparenzwert explizit angegeben werden. Wird sie weggelassen, bedeutet das vollständig transparent, und dann hat es keine Wirkung~ Zum Beispiel: 0xFF0000 repräsentiert Rot, aber wenn man es direkt schreibt, passiert nichts; man sollte es so schreiben: 0xFFFF0000. Denke daran, dass beim Festlegen von Farbwerten im Java-Code die Transparenz vorangestellt werden muss~ Beispiel: (Parameter in der Reihenfolge: Alpha, Rotwert, Grünwert, Blauwert)txtShow.setBackgroundColor(Color.argb(0xff, 0x00, 0x00, 0x00));
2. NiewPatchDrawable
Es ist das .9-Bild. Weiter oben haben wir1.6 Verwendung von .9- (Nine-Patch-)Bildernbereits ausführlich erklärt, wie man .9-Bilder erstellt! Das Android-Framework verwendet beim Anzeigen von Nine-Patch-Bildern einen effizienten Grafikoptimierungsalgorithmus, sodass wir keine spezielle Behandlung benötigen, um eine adaptive Bilddehnung zu erreichen~ Außerdem sind bei der Verwendung von AS folgende Punkte zu beachten:
- 1. Nine-Patch-Bilder können nicht im mipmap-Verzeichnis abgelegt werden; sie müssen im drawable-Verzeichnis abgelegt werden!
- 2. Das .9-Bild in AS muss schwarze Linien haben, sonst wird die Kompilierung nicht durchlaufen. Heute Morgen hat mein Cousin Ajun in der Gruppe gesagt, dass der Designer seiner Firma ihm ein .9-Bild ohne schwarze Linien gegeben hat, sagte, es sei mit irgendeiner Software erstellt worden, und es funktionierte unter Eclipse. Ja, es war ein .9 ohne schwarze Linien, verdammt, aber als ich zu AS wechselte, ließ es sich nicht direkt kompilieren! Es scheint, dass eines der Kriterien dafür, dass AS .9-Bilder erkennt, schwarze Punkte oder schwarze Linien sind! Außerdem hat mein Cousin eine Methode genannt, um schwarze Linien zu entfernen:9patch(.9) Wie entfernt man die schwarzen Punkte/schwarzen Linien, die man darauf gezeichnet hatIch habe es nicht speziell ausprobiert. Wenn du interessiert bist, kannst du es selbst ausprobieren, aber sind die schwarzen Linien wirklich so nervig ... Ich habe kein OCD, also finde ich das nicht! Ein weiterer Punkt ist, dass du, wenn du das APK von jemand anderem dekomprimierst und .9-Assets entnimmst, feststellst, dass keine schwarzen Linien vorhanden sind, und es außerdem Fehler meldet! Wenn du .9-Assets mit schwarzen Linien extrahieren möchtest, musst du das APK dekompilieren, statt es direkt zu entpacken!!! Die Dekompilierung wurde ebenfalls schon früher vorgestellt, daher gehe ich hier nicht näher darauf ein!
Als Nächstes stellen wir zwei Dinge vor, die nicht besonders nützlich sind:
NinePatchDrawable in XML definieren:
<!--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"/>
Bitmap zum Umschließen von .9-Bildern verwenden:
<!--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
Es ist das Shape-Drawable, das grundlegende geometrische Formen wie (Rechteck, Kreis, Linie usw.) definiert. Das Wurzelelement ist <shape../>. Es gibt ziemlich viele Knoten; die zugehörigen Knoten sind wie folgt:
- ① <shape>:
- ~ sichtbar: Legt fest, ob sichtbar
- ~ shape: Form, optional: rectangle (Rechteck, einschließlich Quadrat), oval (Ellipse, einschließlich Kreis), line (Liniensegment), ring (Ring)
- ~ innerRadiusRatio: Nur gültig, wenn shape ring ist; gibt das Verhältnis des Innenradius des Rings zum Gesamtradius an. Wenn innerRadius gesetzt ist, wird es ignoriert.
- ~ innerRadius: Nur gültig, wenn shape ring ist; gibt die Größe des Innenradius des Rings an.
- ~ thicknessRatio: Nur gültig, wenn shape ring ist; gibt das Verhältnis der Ringdicke zum Radius an.
- ~ thickness: Nur gültig, wenn shape ring ist; gibt die Dicke des Rings an, d. h. die Differenz zwischen Außenradius und Innenradius.
- ~ useLevel: Nur gültig, wenn shape ring ist; gibt an, ob erlaubt werden soll, einen Teil des Rings basierend auf level anzuzeigen.
- ②<size>:
- ~ width: Breite der Form
- ~ height: Höhe der Form
- ③<gradient>: Wird später in GradientDrawable~ behandelt
- ④<solid>
- ~ color: Hintergrundfüllfarbe. Nach dem Setzen von solid werden alle von gradient festgelegten Effekte überschrieben!!!!!!
- ⑤<stroke>
- ~ width: Rahmenbreite
- ~ color: Rahmenfarbe
- ~ dashWidth: Strichlänge des Rahmens
- ~ dashGap: Abstand zwischen den Strichen des Rahmens
- ⑥<conner>
- ~ radius: Eckenradius, anwendbar auf alle vier Ecken: oben, unten, links, rechts
- ~ topLeftRadius,topRightRadius,BottomLeftRadius,tBottomRightRadius: In dieser Reihenfolge: Werte für die Ecken oben links, oben rechts, unten links, unten rechts. Legen Sie sie nach Bedarf fest!
- ⑦<padding>
- left, top, right, bottom: In dieser Reihenfolge die Außenabstände in den Richtungen links, oben, rechts, unten!
Anwendungsbeispiel: 2.3.1 TextView (Textfeld) Detaillierte Erklärung

4.GradientDrawable
Ein Drawable mit Gradientenbereichen, das lineare, radiale und Sweep-Gradient-Effekte erzielen kann. Kernknoten: <gradient/>, mit den folgenden optionalen Attributen:
- startColor: Gradienten-Startfarbe
- centerColor: Gradienten-Mittelfarbe
- endColor: Gradienten-Endfarbe
- type: Farbverlaufstyp, optional (linear,radial,sweep), linearer Farbverlauf(kann den Farbverlaufswinkel festlegen), radialer Farbverlauf (vom Zentrum nach außen strahlend), Sweep-Farbverlauf
- centerX: X-Koordinate der mittleren Farbe des Farbverlaufs, Wertebereich: 0~1
- centerY: Y-Koordinate der mittleren Farbe des Farbverlaufs, Wertebereich: 0~1
- angleNur lineare Verlaufstypen sind gültig; gibt den Winkel des Farbverlaufs an, der ein Vielfaches von 45 sein muss.
- gradientRadiusNur radiale und Sweep-Verlaufstypen sind gültig; für radial muss er festgelegt werden und gibt den Radius des Farbverlaufseffekts an.
- useLevelBestimmt, ob der Farbverlaufseffekt abhängig von level gezeichnet wird.
Codebeispiel: (Demonstration der drei Farbverlaufseffekte):
Screenshot des Laufeffekts:

Erstellen Sie zuerst drei XML-Dateien für Farbverläufe unter drawable:
(Linearer Farbverlauf) 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>
(Radialer Farbverlauf) 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>
(Sweep-Farbverlauf) 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>
Rufe die drei Drawables aufactivity_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>
Okay, das ist schon alles~ Natürlich, wenn du komplexere Grafiken zeichnen möchtest, reichen XML-Dateien allein bei Weitem nicht aus. Komplexere Effekte müssen mit Java-Code umgesetzt werden. Die folgende Demonstration ist ein Stück Quellcode, das aus dem Internet entnommen wurde:
Screenshot des Ausführungseffekts:
Implementierungscode:
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;
}
}
}
}
Der Code verwendet ShapeDrawable und PathEffect. Ersteres ist ein Wrapper für gewöhnliche Formen, darunter: ArcShape, OvalShape, PathShape, RectShape, RoundRectShape!
PathEffect hingegen ist ein Pfadeffekt, darunter: CornerPathEffect, DashPathEffect und DiscretePathEffect, mit denen komplexe Formränder erstellt werden können...
Das war alles zu GradientDrawable. Wenn du an den letzteren Sachen interessiert bist, kannst du hierhin gehen:appium/android-apidemos
Zusammenfassung dieses Abschnitts:
Okay, in diesem Abschnitt lernen wir zuerst ColorDrawable, NinePatchDrawable, ShapeDrawable und GradientDrawable kennen.
Beginnen wir mit den vier Drawables. Natürlich sind das alte Themen, die schon einmal geschrieben wurden, aber für die Vollständigkeit des Tutorials habe ich mich entschieden, sie erneut zu schreiben. Außerdem werden nach Abschluss der grundlegenden Tutorials einige früher geschriebene Blogs gelöscht!

Okay, in diesem Abschnitt lernen wir zuerst ColorDrawable, NinePatchDrawable, ShapeDrawable und GradientDrawable kennen.