Android – Une bonne douzaine de snippet de code

Partager cet article

Temps estimé pour la lecture de cet article : 96 min

On a tous des snippets de codes récupérés à droite à gauche sur internet (stackoverflow 😀 ?) afin de réaliser une action bien définie. Mon but ici, c’est avant tout d’avoir des aide-mémoire sur des bouts de code réutilisable directement dans une application Android. Mais, on va faire mieux que juste lister le code sans réfléchir. Nous allons également prendre le temps de l’analyser.

Le snippet le plus connu: l’obtention du modèle d’un smartphone Android

On commence par un grand classique mais un incontournable, récupérer le modèle du téléphone à quoi ça peut bien servir me direz-vous ? Souvent, c’est utilisé afin d’être ajouté dans le mail de contact de la plupart des applications, afin de pouvoir débugguer si le besoin s’en fait sentir, le problème d’un utilisateur.

Pour ce faire, on utilise la classe Build d’Android. Elle contient tout simplement un ensemble d’informations sur le système sur lequel l’application a été buildée. On y retrouve par exemples des données comme le modèle du smartphone, la marque, la version d’Android et j’en passe. La plupart des
variables de la classe sont statiques, il suffit donc de les lire directement.

public static String getDevice() {
    final String manufacturer = Build.MANUFACTURER;
    final String model = Build.MODEL;
    if (model.startsWith(manufacturer)) {
        return capitalize(model);
    } else {
        return capitalize(manufacturer) + "_" + model;
    }
}

private static String capitalize(String string) {
    if (string == null || string.length() < 2) {
        return string;
    }
    return string.substring(0, 1).toUpperCase() + string.substring(1);
}

À noter, qu’on capitalise, la première lettre uniquement pour un effet de style !

Obtenir le niveau de batterie actuel d’un device Android

Un autre grand classique, c’est l’obtention du niveau de batterie d’un smartphone.

android snippets battery level

Si vous avez besoin d’exécuter des traitements lourds comme par exemple faire des synchronisations avec un serveur. Cela peut être une excellente idée, de faire en sorte que votre application effectue ce type d’actions, uniquement si le niveau de batterie de téléphone de l’utilisateur le permet (à vous de définir un seuil acceptable).

Pour ce faire, on va devoir utiliser un Intent du type ACTION_BATTERY_CHANGED. Une fois l’intent reçu, vous allez pouvoir consulter les extras afin d’obtenir le niveau de batterie.

public static int getCurrentBatteryLevel(Context context) {
    final IntentFilter intentFilter = new IntentFilter(Intent.ACTION_BATTERY_CHANGED);
    final Intent batteryStatus = context.registerReceiver(null, intentFilter);
    if (batteryStatus != null) {
        final int level = batteryStatus.getIntExtra(BatteryManager.EXTRA_LEVEL, -1);
        final int scale = batteryStatus.getIntExtra(BatteryManager.EXTRA_SCALE, -1);
        if (scale > 0) {
            return (level * 100) / scale;
        }
    }
    return -1;
}

Ici, la fonction retourne donc -1, si elle n’arrive pas à récupérer l’information et sinon une valeur comprise entre 0 et 100.

Envoyer un email avec une pièce jointe sous Android

Ce snippet-là, personne n’y a coupé, lorsque l’on a, au moins une fois travaillait sur une application Android. Mais avez-vous déjà vu comment rajouter une pièce jointe dans l’email. Regardons ça en détail.

La solution passe par un… Intent et oui, on va en voir pas mal dans le lot ! Ici, on va utiliser l’action ACTION_SENDTO, dont le nom est plutôt transparent. Afin d’envoyer un message à quelqu’un il faut spécifier le field data de l’intent grâce à la méthode setData().

Cette méthode prend un URI en paramètre, il faut créer un URI de type mailto. On précise alors le destinataire bien souvent une adresse email de contact mais ça peut très bien être un email personnel. Je précise également le sujet du mail et j’y ajoute la date.

Enfin, pour rajouter une pièce jointe, on va utiliser l’extra EXTRA_STREAM, encore une fois, la valeur à fournir est une URI du type file, ce coup-ci. Pour récupérer un fichier de logs que votre app aurait généré par exemple. Il suffit d’utiliser la méthode getExternalFilesDir() avec l’environnement DIRECTORY_DOCUMENTS et rajouter le nom du fichier. Il nous reste plus qu’à lancer l’intent.

public void sendEmail() {
    try {
        Intent intent = new Intent(Intent.ACTION_SENDTO);
        String recipient = "contact@myapp.com";
        Date today = new Date();
        SimpleDateFormat simpledDateFormat = new SimpleDateFormat("yyyy-MM-dd", Locale.getDefault());
        String stringDate = simpledDateFormat.format(today);
        Uri uriData = Uri.parse("mailto:" + recipient + "?subject=MyApp - " + stringDate);
        intent.setData(uriData);
        Uri fileURI = Uri.parse("file://" + getExternalFilesDir(Environment.DIRECTORY_DOCUMENTS) + "/logs.txt");
        intent.putExtra(Intent.EXTRA_STREAM, fileURI);
        startActivity(intent);
    } catch(ActivityNotFoundException activityNotFoundException) {
        Log.e("MainActivity", "No activity has been found to send email...");
    }
}

Vous pourriez également avoir envie d’ajouter des informations en plus comme par exemple le modèle du téléphone ou encore le niveau de batterie du téléphone au moment du problème. On peut facilement le faire avec l’extra EXTRA_TEXT ou encore en précisant un argument body dans le mailto. À noter que ce dernier supporte mal les caractères spéciaux, il faut donc les « formatter ».

String debugInfo = getDevice() + "<br>" + getCurrentBatteryLevel(getApplicationContext()) + "%25";
Uri uriData = Uri.parse("mailto:" + recipient + "?subject=MyApp - " + stringDate + "&body=" + debugInfo);

Un snippet toujours pratique à avoir sous le coude.

Ouvrir une page internet dans un navigateur sous Android

Les intents sont légion dans ce genre d’action courte à réaliser notre prochain Intent permet d’ouvrir une page web dans un navigateur internet. Très utile par exemple, si vous voulez éviter de créer une page dans votre application pour afficher des conditions d’utilisation ou encore l’ensemble des licences des librairies qu’utilise votre application.

L’action cette fois-ci s’appelle ACTION_VIEW. Il suffit de préciser en paramètre l’URL à ouvrir et c’est tout. On va quand même améliorer notre fonction en checkant si l’URL fourni est effectivement correct. Pour ce faire, on va utiliser la classe Patterns et la regex WEB_URL. Il suffira ensuite d’utiliser la méthode matches() pour vérifier si l’URL est bonne. Dans le cas contraire, on affichera un log d’erreur.

Enfin, dernière petite aparté, dans ma méthode, il y a un try & catch afin d’éviter d’avoir une exception de levée, cette dernière peut se produire, si le téléphone en question ne possède pas d’application de type browser, c’est-à-dire pas de navigateurs internet. Une bonne pratique conseillée par la documentation d’Android, c’est d’utiliser la méthode resolveActivity(). Je n’en parle pas ici car je veux volontaire avoir des exemples simples, si vous voulez gérer plus proprement ce cas-là, je vous laisse suivre la documentation.

public void openInBrowser(String url) {
    if (Patterns.WEB_URL.matcher(url).matches()) {
        try {
            Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(url));
            startActivity(intent);
        } catch(ActivityNotFoundException activityNotFoundException) {
            Log.e("MainActivity", "No activity has been found to open this url: " + url);
        }
    }
}

Enfin, il existe également une action appelée ACTION_WEB_SEARCH. Cette action est utile, si vous voudriez préciser des critères de recherches sur un site donné. Par exemple pour effectuer une recherche sur google. Il faudrait rajouter dans l’intent un extra avec comme clé SearchManager.QUERY et la valeur recherchée.

Intent intent = new Intent(Intent.ACTION_WEB_SEARCH);
String search = "The answer to life, the universe and everything";
intent.putExtra(SearchManager.QUERY, search);
startActivity(intent);

Ça peut toujours être pratique.

Forcer un mode d’affichage portrait

Il se peut que votre application n’ait aucun intérêt à écouter les changements d’orientation du téléphone. Par défaut, sous Android, si l’utilisateur accepte la rotation de l’écran dans les paramètres, lorsque l’événement arrive, l’activity en cours est détruite et reconstruite. On peut alors redéfinir la méthode onConfigurationChanged afin de redéfinir le nouvel affichage de notre activité par exemple.

Mais il est possible que cela ne représente aucun intérêt pour vous de gérer l’un des deux modes vous pouvez très bien alors décider de verrouiller un mode d’affichage de style portrait par exemple. Pour ce faire, il suffit de préciser dans le manifest de votre application les deux éléments aux activités qui ne doivent pas changer de direction :

  • android:screenOrientation, le nom est plutôt transparent le mode que l’on veut forcer
  • android:configChanges, les changements de configuration sont gérés par l’activité elle-même.

Ce qui nous donne par exemple :

<activity
   android:name=".MainActivity"
   android:screenOrientation="portrait"
   android:configChanges="orientation|keyboardHidden" />

N’hésitez pas à vous rafraichir la même sur la gestion de l’orientation sous Android, ça ne fait jamais de mal ;).

Copier le texte d’un TextView dans le clipboard du téléphone

L’API d’Android permet facilement de copier-coller dans le clipboard du système une string grâce à la classe ClipboardManager. Pratique, si vous voulez pouvoir donner facilement accès à un ID créée par votre application. L’utilisation est assez simple, il vous suffit d’utiliser les accesseurs et mutateurs de la classe TextView afin de récupérer le texte qui vous intéresse.

final ClipboardManager clipboardManager = (ClipboardManager) getApplicationContext().getSystemService(Context.CLIPBOARD_SERVICE);
final String text = textView.getText().toString();
final ClipData clipData = ClipData.newPlainText(null, text);
clipboardManager.setPrimaryClip(clipData);
Toast.makeText(getApplicationContext(), "Copied text: " + text, Toast.LENGTH_SHORT).show();

Notre snippet ici est assez bref. On récupére une instance du service ClipboardManager. On récupère et set dans le clipboard la valeur du texte de notre textView et on affiche le tout grâce à un Toast.

Comment masquer une actionbar sous Android ?

Bien souvent plutôt que masquer l’actionBar, une bonne pratique c’est de l’utiliser afin de mettre à disposition des raccouris pour accéder aux settings de son application par exemple. Mais dans certains cas, la masquer peut s’avérer être intéressant, comme pour les jeux vidéo, par exemple.

android snippets actionbar

Pour ce faire sous Android, c’est assez simple. On peut le faire en xml, on peut rajouter dans le fichier styles.xml, ces quelques lignes :

<style name="AppTheme.NoActionBar" parent="Theme.AppCompat.Light.DarkActionBar">
    <item name="windowActionBar">false</item>
    <item name="windowNoTitle">true</item>
</style>

Ensuite, il ne reste plus qu’à préciser dans le Manifest que l’activité que vous désirez lancer sans ActionBar doit utiliser le thème défini au-dessus, comme ceci :

<activity android:name=".MainActivity" android:theme="@style/AppTheme.NoActionBar">
    <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.LAUNCHER" />
    </intent-filter>
</activity>

On peut également le faire de manière logicielle, il suffit d’utiliser l’instruction setFlags de la classe Window.

final Window window = getWindow();
final int flagFullScreen = WindowManager.LayoutParams.FLAG_FULLSCREEN; 
window.setFlags(flagFullScreen, flagFullScreen);

Comment gérer les couleurs transparentes sur Android

Admettons, on voudrait un background bleu (#2471a3) avec 50% de transparence. Afin par exemple de permettre d’afficher une image derrière notre layout. On peut faire en sorte d’avoir que 50% de couleur dans le canal alpha. Il suffit de préciser la valeur en hexadécimal :

<TextView
   ...
   android:background="#7F2471A3" />

Dans l’exemple 7F est la valeur hexadécimale du nombre 127, on l’obtient en faisant: 255*0.5 = 127.5. Les deux premières valeurs décimales indiquées dans le background correspondent au canal alpha de la couleur. Le format est le suivant #AARRGGBB, avec AA les valeurs du canal alpha, RR ceux de la couleur rouge, GG la couleur verte et enfin BB la couleur bleue. Ce qui nous donne 50% de transparence et 50% opaque.

Pour calculer, la valeur dont vous avez besoin, regardons la procédure à suivre :

  1. Vous voulez un certain pourcentage de transparence, disons 20, on sait que du coup le pourcentage opaque de la couleur sera 80. C’est simplement, 100-20 = 80.
  2. Comme on l’a vu le cannel alpha est défini sur 8 bits (2^8 = 256), donc il est compris entre 0 et 255.
  3. Ici, on veut donc 20% de transparence, il faut conserver 80% de la couleur, donc 255*0.8 = 204. Dans certains cas, il vous faudra arrondir à l’entier le plus proche.
  4. Convertissez votre valeur obtenue à l’étape 3 en hexadécimal.
  5. Enfin, il vous suffit d’ajouter l’hexadécimal obtenu à l’étape 4 à la couleur désirée. Donc, pour du rouge avec 20% de transparence, on obtient: #CCFF0000.

Pour finir, voici un petit tableau récapitulatif des différentes opacités par tranche de 5 :

Pourcentage d’opacité de la couleurValeur hexadécimal
0%00
5%0D
10%1A
15%26
20%33
25%40
30%4D
35%59
40%66
45%73
50%80
55%8C
60%99
65%A6
70%B3
75%BF
80%CC
85%D9
90%E6
95%F2
100%FF

Restaurer l’état de scroll dans un RecyclerView

On vous a demandé de réaliser une liste d’items qui peut être très longue, de l’ordre de plus d’une centaine d’éléments. On aimerait que lorsque l’application se fasse killer, on puisse facilement restaurer l’endroit où l’utilisateur s’est arrêté. Android va nous permettre de faire cela en surchargeant la méthode onSaveInstanceState(). Cette dernière est appelée avant que l’application ne se fasse stopper justement afin de pouvoir restaurer un état précédent.

Si on reprend notre exemple, on peut sauvegarder l’état de notre RecyclerView à un endroit donné. L’instance d’un RecyclerView permet d’accéder à son LayoutManager, grâce à ceci on va pouvoir récupérer grâce à la méthode onSaveInstanceState() l’état de scrolling de notre liste.

On va alors récupérer un Parcelable que l’on va pouvoir enregistrer dans un Bundle de sortie.

private final String RECYCLER_VIEW_STATE_KEY = "recycler.view.state";

...

@Override
public void onSaveInstanceState(@NonNull Bundle outState, @NonNull PersistableBundle outPersistentState) {
    final RecyclerView.LayoutManager layoutManager = recyclerView.getLayoutManager();
    if (layoutManager != null) {
        final Parcelable recyclerViewState = layoutManager.onSaveInstanceState();
        outState.putParcelable(RECYCLER_VIEW_STATE_KEY, recyclerViewState)
    }
    super.onSaveInstanceState(outState, outPersistentState);
}

Maintenant, qu’on a enregistré l’état, il ne reste plus qu’à le charger à partir de la méthode onCreate() de notre activité. Mais on pourrait très bien le faire aussi grâce à la méthode onRestoreInstanceState(). On vérifie, si notre bundle contient la clé dans laquelle on a conservé l’état de notre RecyclerView, si c’est le cas, on essaye de charger le dernier état connu.

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    ...
    if (savedInstanceState.containsKey(RECYCLER_VIEW_STATE_KEY)) {
        final Parcelable recyclerViewLastState = savedInstanceState.getParcelable(RECYCLER_VIEW_STATE_KEY);
        if (recyclerViewLastState != null) {
            final RecyclerView.LayoutManager layoutManager = recyclerView.getLayoutManager();
            if (layoutManager != null) {
                layoutManager.onRestoreInstanceState(recyclerViewLastState);
            }
        }
    }
}

Pratique, n’est-il pas ?

Obtenir la hauteur et la largeur d’une View

Bien souvent, quand on veut s’amuser à faire des animations custom ou modifier l’UI dynamiquement, on a besoin de connaître les dimensions d’une View donnée. Si vous voulez lancer l’animation dans le onCreate(). Ce n’est pas possible directement, en effet il vous faudra attendre que le layout soit calculé or cela arrive après l’appel de la méthode onCreate. Il existe alors différentes méthodes pour faire cela.

Écouter les événements d’affichage de layout grâce à la classe ViewTreeObserver

La classe ViewTreeObserver est appelée à chaque changement dans l’affichage. On peut ainsi utiliser le listener OnGlobalLayoutListener afin d’être informé lorsque la phase d’affichage du layout est terminé et ainsi récupéré les informations de mesure de la View. Voici un exemple d’utilisation des deux classes précédentes :

view.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
    @Override
    public void onGlobalLayout() {
        view.getViewTreeObserver().removeOnGlobalLayoutListener(this);
        view.getHeight(); //height is ready
    }
});

À savoir que le listener va être automatiquement supprimé car sinon, il serait appelé à chaque changement dans le layout. S’il vous faut supporter une version de SDK < 16, vous devez faire le unregister vous-même grâce à la méthode removeGlobalOnLayoutListener.

Ajouter un runnable à l’UI queue grâce à la méthode View.post()

La phase de layout se déroule sur une queue UI dans laquelle, l’on va pouvoir poster ses propres runnable. Chaque View possède ainsi sa propre méthode post(). Comme la queue va tout simplement traiter les événements dans l’ordre ainsi le setContentView sera invoqué avant le runnable que vous allez ajouter. Votre View sera donc déjà inflaté et prête à l’utilisation.

Ce qui nous donne par exemple :

view.post(new Runnable() {
    @Override
    public void run() {
        int height = view.getHeight();
        int width = view.getWidth();
        ...
    }
});

Surcharger la méthode onLayout de votre View

Pratique uniquement dans certaines situations par exemple lorsque l’on veut créer sa propre view custom et appliquer certaines actions directement dans la View en elle-même. Mais cela reste très verbueux…

view = new View(this) {
    @Override
    protected void onLayout(boolean changed, int l, int t, int r, int b) {
        super.onLayout(changed, l, t, r, b);
        int height = view.getHeight();       
        int width  = view.getWidth();
        ...
    }
};

Il faut également garder à l’esprit que la méthode onLayout peut-être appelée plusieurs fois, donc soyez prudent lorsque vous utiliser un morceau de code dans cette fonction.

Kotlin à la rescousse grâce à la librairie core.view

Enfin, AndroidX possède plusieurs extensions de fonctions qui permettent ce genre de chose, notamment dans la librairie: androidx.core.view. Vous aurez besoin de la dépendance suivante: androidx.core:core-ktx:1.0.0.

Je vous conseille notamment la méthode doOnLayout, qui permet d’effectuer une action lorsque la View aura été « laid out », c’est-à-dire lorsqu’elle sera prête. Par exemple :

button.doOnLayout { view ->
    val width = view.width
    val height = view.height
    // ...
}

Un TextView avec des liens cliquables

Il arrive qu’on ait besoin d’afficher dans une TextView un texte contenant des URLs, dans ce cas bien précis, si le texte affiché est du HTML, il est bien interprété mais les liens ne sont pas cliquables. Il existe alors l’option autoLink qui est à rajouter au niveau du TextView.

<TextView
    android:id="@+id/text_view"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:autoLink="web"
    android:text="@string/text_with_urls"/>

Ainsi si les URLs sont complètes, elles seront affichées en bleu et cliquables. Voici un exemple de liens supportés :

Some text <a href="http://www.google.com">http://www.google.com</a>
Some text http://www.google.com

Une seconde solution et la meilleure des deux, c’est d’utiliser la méthode setMovementMethod de la classe View, elle permettra également de supporter les liens HTML avec n’importe quelle description à l’intérieur de la balise link.

TextView textView = (TextView) findViewById(R.id.text_view);
textView.setMovementMethod(LinkMovementMethod.getInstance());

Et les liens supportés :

Some text <a href="http://www.google.com">http://www.google.com</a>
Some text http://www.google.com
Some text <a href="http://www.google.com">Go to Google</a>

Attention, si vous utilisez cette méthode il faut supprimer l’attribut autoLink= »web » de votre layout.

Enfin, google met également à notre dispotion la classe Linkify, qui permettra de faire matcher d’autres types d’URLs comme par exemple des intents. Elle est très simple à utiliser :

Linkify.addLinks(TextView, Linkify.ALL);

Si vous avez juste besoin de supporter des liens je vous conseille la méthode setMovementMethod autrement, cela vaut peut-être le coup de se pencher sur cette classe !

Obtenir la taille de l’écran du smartphone

Il peut être parfois utile d’obtenir la résolution du smartphone sur lequel notre application va tourner. Cela peut permettre d’adapter une animation en dépendant de la hauteur de l’écran ou encore dans le cas de la réalisation d’un Layout custom par exemple.

Pour ce faire, il faut utiliser la classe WindowManager, qui permet d’obtenir des informations sur un Display donné, dans notre cas l’écran du smartphone. Il y a deux possibilités pour accéder à une instance de la classe WindowManager.

  • Si vous êtes dans une activité et que vous avez accès directement au context, vous pouvez directement appeler la méthode: getWindowManager()
  • Autrement, si vous accédez à cette classe depuis un framework par exemple, il vous faudra passer une instance de l’application context et utiliser la méthode getSystemService(): context.getSystemService(Context.WINDOW_SERVICE)

Ensuite, on utilisera la méthode getDefaultDisplay() (dépréciée à partir d’Android 11 pour la méthode getDisplay(), qu’on pourra directement accéder depuis le Context). On reçoit alors une instance de la classe Display. On crée une instance de la classe Point et on donne cette instance à manger à la méthode getSize de display. Il suffira alors de lire les valeurs obtenues !

Ce qui nous donne pour résumer :

final WindowManager windowManager = (WindowManager) applicationContext.getSystemService(Context.WINDOW_SERVICE);
Display display = windowManager.getDefaultDisplay();
Point size = new Point();
display.getSize(size);
int width = size.x;
int height = size.y;

Et voilà, vous avez accès à la hauteur du smartphone ainsi qu’à sa largeur.

Créer une ImageView avec des bords arrondis

Je finis par un grand classique ! Les bords arrondis sur les Views, un grand classique des designers. Il y a plein de solutions pour se use case mais je vais vous montrer la plus pratique à mon goût, le seul bémol, étant que ma solution n’est valide qu’à partir de l’API 21. Autrement, je vous propose une autre solution cette petite librairie basée sur une réponse de Romain guy. L’idée étant d’utiliser un shader pour faire les bords arrondis, l’avantage étant de ne pas créer de copie du Bitmap, ce que beaucoup font, c’est fonctionnel mais… bourrin !

android snippets chuck norris

Voici, un exemple de la solution, si vous voulez éviter toute une librairie juste pour ça !

BitmapShader shader;
shader = new BitmapShader(bitmap, Shader.TileMode.CLAMP, Shader.TileMode.CLAMP);

Paint paint = new Paint();
paint.setAntiAlias(true);
paint.setShader(shader);

RectF rect = new RectF(0.0f, 0.0f, width, height);

// rect contains the bounds of the shape
// radius is the radius in pixels of the rounded corners
// paint contains the shader that will texture the shape
canvas.drawRoundRect(rect, radius, radius, paint);

Parmi les avantages, en plus d’éviter une copie du Bitamp :

  • Cela supporte l’antialisasing
  • Également l’accélération matérielle
  • Et ce n’est dessiné qu’une fois sur le Canvas

Plutôt une bonne solution ! Mais je vous présente ma solution qui est plus simple, surtout si vous ne supportez plus Android KitKat pourquoi s’en priver ;).

Il suffit de créer un background avec des bords arrondis en XML :

<shape xmlns:android="http://schemas.android.com/apk/res/android" android:shape="rectangle">
    <corners android:radius="20dp" />
    <solid android:color="@android:color/transparent" />
</shape>

Ensuite de l’appliquer à notre View, par exemple avec une image :

 <ImageView
    android:id="@+id/circle_image_view_kitten"
    android:layout_width="200dp"
    android:layout_height="200dp"
    android:scaleType="fitXY"
    android:src="@drawable/kitten"
    android:background="@drawable/background_image_with_radius"
    android:contentDescription="@string/little_kitten" />

Mais, si on laisse comme ça tel quel rien ne se passe, il faut rajouter l’option clipToOutline, qui va permettre au background de faire effet. Attention, toutefois ça ne fonctionne qu’avec des shapes rectangle et circle. Et autre point négatif, vous allez devoir appliquer l’option en java car il y a une issue qui traine depuis 5 ans sur l’option en XML…

Pas trop dur tout de même, on référence la View et on applique la méthode setClipToOutline.

ImageView circleImageViewKitten = findViewById(R.id.circle_image_view_kitten);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
    circleImageViewKitten.setClipToOutline(true);
}

Et c’est tout bon !

android snippets rounded image view

Les snippets en veux-tu, en voilà

Bon, ça fait déjà une bonne dose de code à digérer pour les nouveaux et pour les anciens de bons rappels j’espère. Si vous avez d’autres idées de snippets, n’hésitez pas je peux refaire une série d’articles du genre !

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.