Comment: Définir le thème (style) de l'élément de widget personnalisé

J'ai écrit un widget personnalisé pour un contrôle que nous utilisons largement tout au long de notre application. Le widget de la classe dérive de ImageButton et l'étend dans un couple de façons simples. J'ai défini un style qui je peux demander à le widget comme il est utilisé, mais je préfère cette série à travers un thème. Dans R.styleable je vois widget attributs de style comme imageButtonStyle et textViewStyle. Est-il possible de créer quelque chose comme ça pour le widget personnalisé que j'ai écrit?

InformationsquelleAutor jsmith | 2010-12-20

android android-theme

207

Oui, il y a un moyen:

Supposons que vous avez une déclaration d'attributs pour votre widget (dans attrs.xml):
```
<declare-styleable name="CustomImageButton">
    <attr name="customAttr" format="string"/>
</declare-styleable>
```
Déclarer un attribut à utiliser pour un style de référence (en attrs.xml):
```
<declare-styleable name="CustomTheme">
    <attr name="customImageButtonStyle" format="reference"/>
</declare-styleable>
```
Déclarer un ensemble de valeurs d'attribut par défaut pour le widget (dans styles.xml):
```
<style name="Widget.ImageButton.Custom" parent="android:style/Widget.ImageButton">
    <item name="customAttr">some value</item>
</style>
```
Déclarer un thème personnalisé (dans themes.xml):
```
<style name="Theme.Custom" parent="@android:style/Theme">
    <item name="customImageButtonStyle">@style/Widget.ImageButton.Custom</item>
</style>
```
Utiliser cet attribut en tant que troisième argument dans votre widget du constructeur (en CustomImageButton.java):
```
public class CustomImageButton extends ImageButton {
    private String customAttr;

    public CustomImageButton( Context context ) {
        this( context, null );
    }

    public CustomImageButton( Context context, AttributeSet attrs ) {
        this( context, attrs, R.attr.customImageButtonStyle );
    }

    public CustomImageButton( Context context, AttributeSet attrs,
            int defStyle ) {
        super( context, attrs, defStyle );

        final TypedArray array = context.obtainStyledAttributes( attrs,
            R.styleable.CustomImageButton, defStyle,
            R.style.Widget_ImageButton_Custom ); //see below
        this.customAttr =
            array.getString( R.styleable.CustomImageButton_customAttr, "" );
        array.recycle();
    }
}
```
Maintenant, vous devez appliquer Theme.Custom à toutes les activités qui utilisent CustomImageButton (en AndroidManifest.xml):
```
<activity android:name=".MyActivity" android:theme="@style/Theme.Custom"/>
```
C'est tout. Maintenant CustomImageButton essaie de charger les valeurs d'attribut par défaut de customImageButtonStyle attribut du thème actuel. Si aucun attribut n'est trouvé dans le thème ou la valeur de l'attribut est @null puis le dernier argument pour obtainStyledAttributes seront utilisés: Widget.ImageButton.Custom dans ce cas.

Vous pouvez modifier les noms de toutes les instances et tous les fichiers (sauf AndroidManifest.xml), mais il serait préférable d'utiliser Android convention de nommage.
- Est-il un moyen de faire exactement la même chose sans l'aide d'un thème? J'ai quelques widgets personnalisés, mais je veux que les utilisateurs soient en mesure d'utiliser ces widgets avec n'importe quel thème qu'ils veulent. Faire de la même manière que vous avez posté, serait d'obliger les utilisateurs à utiliser mon thème.
- Si vous voulez dire une bibliothèque que les développeurs peuvent utiliser, alors ils seront en mesure de créer leurs propres thèmes et de spécifier le style du widget à l'aide d'un attribut style dans le thème (customImageButtonStyle dans cette réponse). C'est ainsi que la barre d'action personnalisé sur Android. Et si vous voulez dire que la modification d'un thème à l'exécution, alors il n'est pas possible avec cette approche.
- Oui je voulais dire une bibliothèque que les développeurs peuvent utiliser. Votre commentaire a résolu mon problème. Merci!
- Je ne comprends pas le troisième bloc. Plus précisément, je ne suis pas à comprendre comment vous attachez le widget personnalisé/classe et c'est du package ici, autre que de simplement en utilisant son attribut personnalisé noms dans les première et troisième blocs de code indiqué. Est l'attribut parent dans le troisième bloc censé être la classe parent vous sur rode lorsque vous avez créé votre widget personnalisé? Dans ce cas, je suis en supposant CustomImageButton s'étend ImageButton?
- Le but principal de la troisième et de la quatrième blocs est de fournir des valeurs par défaut pour la coutume et attributs prédéfinis pour un widget personnalisé. Le style et le thème sont appliquées lorsque vous passez à Context.obtainStyledAttributes() pour récupérer les valeurs d'attribut. Mais pour que cela fonctionne, vous devez avoir votre thème personnalisé défini comme l'activité du thème par défaut (dernier bloc). Dans ce cas defStyle dans le troisième constructeur sera résolu à @style/Widget.ImageButton.Custom.
- La chose la plus incroyable à propos de tout cela est que quelqu'un à Google que ce n'est pas grave.
- C'est pourquoi j'ai hate de développement Android
- Ne name="CustomTheme" dans le declare-styleable attribut wrapper servir n'importe quel but? Est-ce seulement pour l'organisation, parce que je ne vois pas utilisé n'importe où. Puis-je mettre tous mes attributs de style pour les différents widgets dans un conteneur?
- Je dirais que c'est une sorte de convention, de sorte que vous pouvez l'appeler ce que vous voulez.
- Pourquoi il y a deux declare-stylable des blocs? ne serait-il pas de travail pour mettre l'attribut style dans le premier bloc?
- Le premier bloc est pour le widget. Ce bloc est utilisé lors de la lecture des attributs de la fenêtre, il est donc préférable de ne pas mettre indépendants des trucs dedans. Le second est pour les thèmes, et vous pouvez les combiner avec d'autres thème des blocs.
- cela est vrai à tous les niveaux! ils l'ont fait tordu et désespérée. définition des styles dans android est PITA
InformationsquelleAutor Michael
4

Un autre aspect en plus de michael excellente réponse est primordial d'attributs personnalisés dans les thèmes.
Supposons que vous avez un certain nombre de vues personnalisées qui font tous référence à l'attribut personnalisé "custom_background".
```
<declare-styleable name="MyCustomStylables">
    <attr name="custom_background" format="color"/>
</declare-styleable>
```
Dans un thème vous définir ce que la valeur est
```
<style name="MyColorfulTheme" parent="AppTheme">
    <item name="custom_background">#ff0000</item>
</style>
```
ou
```
<style name="MyBoringTheme" parent="AppTheme">
    <item name="custom_background">#ffffff</item>
</style>
```
Vous pouvez vous référer à l'attribut dans un style
```
<style name="MyDefaultLabelStyle" parent="AppTheme">
    <item name="android:background">?background_label</item>
</style>
```
Avis le point d'interrogation, comme il est également utilisé pour la référence android attribut comme dans
```
?android:attr/colorBackground
```
Comme la plupart d'entre vous l'ont remarqué, vous pouvez et devriez probablement utiliser @références couleurs au lieu de les couleurs sont codées en dur.

Alors pourquoi ne pas simplement faire
```
<item name="android:background">@color/my_background_color</item>
```
Vous ne pouvez pas modifier la définition de "my_background_color" au moment de l'exécution, tandis que vous pouvez facilement changer de thème.

InformationsquelleAutor mir

Vous devez vous connecter pour publier un commentaire.