Créer une classe de vue

Essayer Compose
Jetpack Compose est le kit d'outils d'interface utilisateur recommandé pour Android. Découvrez comment utiliser les mises en page dans Compose.
<ph type="x-smartling-placeholder"></ph> Mises en page personnalisées dans Compose →

Une vue personnalisée bien conçue est semblable à n'importe quelle autre classe bien conçue. Il encapsule ensemble spécifique de avec une interface simple, une utilisation efficace du processeur et de la mémoire, etc. Dans en plus d'être un bien conçue, une vue personnalisée doit remplir les conditions suivantes:

  • respecter les normes Android ;
  • Fournissez des attributs personnalisables personnalisés compatibles avec les mises en page XML Android.
  • Envoyer des événements d'accessibilité
  • Être compatible avec de nombreuses plates-formes Android

Le framework Android fournit un ensemble de classes de base et de balises XML pour vous aider à créer une vue qui répond à tous ces critères exigences. Cette leçon explique comment utiliser le framework Android pour créer fonctionnalité d'une vue .

Vous trouverez d'autres les informations de la section Composants de la vue personnalisée.

Sous-classer une vue

Toutes les classes de vue définies dans le framework Android s'étendent View Votre la vue personnalisée étendez View directement, ou vous pouvez gagnez du temps en prolongeant vue existante telles que Button.

Pour permettre à Android Studio d'interagir avec votre vue, vous devez au minimum fournir un constructeur qui accepte un Context et un objet AttributeSet comme paramètres. Ce constructeur permet à l'éditeur de mise en page de créer et de modifier une instance de votre vue.

Kotlin

class PieChart(context: Context, attrs: AttributeSet) : View(context, attrs)

Java

class PieChart extends View {
    public PieChart(Context context, AttributeSet attrs) {
        super(context, attrs);
    }
}

Définir des attributs personnalisés

Pour ajouter un View intégré à votre interface utilisateur, spécifiez-le dans un élément XML et contrôler ses l'apparence et le comportement avec les attributs d'éléments. Vous pouvez aussi ajouter un style personnalisé des vues à l'aide de XML. À activer ce comportement dans votre vue personnalisée, procédez comme suit:

  • Définissez des attributs personnalisés pour votre vue dans un élément de ressource <declare-styleable> .
  • Spécifiez les valeurs des attributs dans votre mise en page XML.
  • Récupérez les valeurs d'attribut au moment de l'exécution.
  • Appliquez les valeurs d'attribut récupérées à votre vue.

Cette section explique comment définir des attributs personnalisés et spécifier leurs valeurs. La section suivante aborde récupérer et appliquer les valeurs lors de l'exécution.

Pour définir des attributs personnalisés, ajoutez des ressources <declare-styleable> à votre projet. Il est d'usage de placer ces ressources dans un res/values/attrs.xml. Voici Voici un exemple de fichier attrs.xml: 

<resources>
   <declare-styleable name="PieChart">
       <attr name="showText" format="boolean" />
       <attr name="labelPosition" format="enum">
           <enum name="left" value="0"/>
           <enum name="right" value="1"/>
       </attr>
   </declare-styleable>
</resources>

Ce code déclare deux attributs personnalisés, showText et labelPosition, appartenant à une classe stylisée Entité nommée PieChart. Par convention, le nom de l'entité personnalisables est le même en tant que nom de la classe qui définit la vue personnalisée. Bien qu'il ne soit pas nécessaire de respecter cette convention, de nombreux types de code les éditeurs dépendent de cette convention d'attribution de noms pour fournir la complétion d'instruction.

Une fois que vous avez défini des attributs personnalisés, vous pouvez les utiliser dans les fichiers XML de mise en page, comme pour les . La seule différence réside dans le fait que vos attributs personnalisés appartiennent à un espace de noms différent. Au lieu d'appartenir à l'espace de noms http://schemas.android.com/apk/res/android, ils appartiennent à http://schemas.android.com/apk/res/[your package name]. Par exemple, voici comment utiliser le les attributs définis pour PieChart: 

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
   xmlns:custom="http://schemas.android.com/apk/res-auto">
 <com.example.customviews.charting.PieChart
     custom:showText="true"
     custom:labelPosition="left" />
</LinearLayout>

Pour éviter de devoir répéter l'URI d'espace de noms long, l'exemple utilise un la directive xmlns. Cette directive attribue l'alias custom à l'espace de noms http://schemas.android.com/apk/res/com.example.customviews. Vous pouvez choisir n'importe quel alias pour votre espace de noms.

Notez le nom de la balise XML qui ajoute la vue personnalisée à la mise en page. Il s'agit de l'environnement nom complet du personnalisée. Si votre classe de vue est une classe interne, qualifiez-la davantage avec le nom de la classe externe de la vue. Par exemple, le paramètre La classe PieChart comporte une classe interne appelée PieView. Pour utiliser la les attributs personnalisés de cette classe, utilisez la balise com.example.customviews.charting.PieChart$PieView.

Appliquer des attributs personnalisés

Lorsqu'une vue est créée à partir d'une mise en page XML, tous les attributs de la balise XML sont lus de la ressource et transmis au constructeur de la vue en tant que AttributeSet Même s'il s'agit il est possible de lire directement les valeurs à partir de AttributeSet. présente quelques inconvénients:

  • Les références de ressources dans les valeurs d'attribut ne sont pas résolues.
  • Les styles ne sont pas appliqués.

Transmettez plutôt AttributeSet à obtainStyledAttributes() Cette méthode renvoie une TypedArray tableau de des valeurs qui sont déjà déréférencés et stylisés.

Le compilateur de ressources Android effectue beaucoup de travail pour que les appels obtainStyledAttributes() plus facile. Pour chaque <declare-styleable> ressource dans le répertoire res/, l'élément R.java généré définit à la fois un tableau d'attributs d'identifiants et un ensemble de constantes qui définissent l'index de chaque attribut du tableau. Pour ce faire, vous devez utiliser constantes à lire les attributs de TypedArray. Voici comment procéder : la classe PieChart lit ses attributs:

Kotlin

init {
    context.theme.obtainStyledAttributes(
            attrs,
            R.styleable.PieChart,
            0, 0).apply {

        try {
            mShowText = getBoolean(R.styleable.PieChart_showText, false)
            textPos = getInteger(R.styleable.PieChart_labelPosition, 0)
        } finally {
            recycle()
        }
    }
}

Java

public PieChart(Context context, AttributeSet attrs) {
   super(context, attrs);
   TypedArray a = context.getTheme().obtainStyledAttributes(
        attrs,
        R.styleable.PieChart,
        0, 0);

   try {
       mShowText = a.getBoolean(R.styleable.PieChart_showText, false);
       textPos = a.getInteger(R.styleable.PieChart_labelPosition, 0);
   } finally {
       a.recycle();
   }
}

Notez que les objets TypedArray sont une ressource partagée et doivent être recyclés après utilisation.

Ajouter des propriétés et des événements

Les attributs permettent de contrôler efficacement le comportement et l'apparence des vues, ils ne peuvent être lus que lorsque la vue est initialisée. Pour fournir un comportement dynamique, exposez un getter de propriété et un objet une paire setter pour chaque attribut personnalisé. L'extrait suivant montre comment PieChart expose une propriété appelé showText:

Kotlin

fun isShowText(): Boolean {
    return mShowText
}

fun setShowText(showText: Boolean) {
    mShowText = showText
    invalidate()
    requestLayout()
}

Java

public boolean isShowText() {
   return mShowText;
}

public void setShowText(boolean showText) {
   mShowText = showText;
   invalidate();
   requestLayout();
}

Notez que setShowText appelle invalidate(). et requestLayout(). Ces appels sont essentiels pour garantir un comportement fiable de la vue. Vous devez pour invalider la vue après toute modification de ses propriétés susceptible l'apparence afin que la le système sait qu'il doit être redessiné. De même, vous devez demander une nouvelle mise en page une propriété change d'une façon pouvant affecter la taille ou la forme de la vue. Oublier ces appels de méthode difficile à trouver insectes.

Les vues personnalisées doivent également être compatibles avec les écouteurs d'événements pour communiquer les événements importants. Pour instance, PieChart expose un événement personnalisé appelé OnCurrentItemChanged pour avertir les écouteurs que l'utilisateur a fait pivoter la graphique à secteurs pour vous concentrer sur un nouveau secteur.

Il est facile d'oublier d'exposer les propriétés et les événements, en particulier lorsque vous êtes le seul utilisateur de la vue personnalisée. Prendre le temps de définir soigneusement l'interface de votre vue réduit la maintenance future les coûts. Une bonne règle consiste à toujours exposer toute propriété qui affecte l'audience l'apparence ou le comportement votre vue personnalisée.

Conception pour l'accessibilité

Votre vue personnalisée doit prendre en charge un large éventail d'utilisateurs. Cela inclut les utilisateurs ayant handicapées qui les empêcher de voir ou d’utiliser un écran tactile. Pour aider les utilisateurs handicapés, effectuer les opérations suivantes:

  • Attribuez un libellé à vos champs de saisie à l'aide de l'android:contentDescription .
  • Envoyer des événements d'accessibilité en appelant sendAccessibilityEvent() le cas échéant.
  • Prenez en charge d'autres manettes, comme un pavé directionnel ou un trackball.

Pour en savoir plus sur la création de vues accessibles, consultez <ph type="x-smartling-placeholder"></ph> Rendre les applications plus accessibles