Devoxx 2011 – Utilisation du GPU pour les applis Android

Par | Classé dans Conférence, Intermédiaire | Le 25/11/2011

Tags « »

0

Chet Haase et Romain Guy nous ont présenté pendant Devoxx lors de la conférence Graphics goodies in Android, les nouveautés d’Android pour développer des applications qui tuent. Nous allons voir dans cet article l’utilisation de l’accélération graphique pour les rendus 2D des applications Android 3.0 et supérieures.

L’openGL existe depuis les premières versions d’Android pour les jeux et certains autres composants mais l’interface graphique des applications a toujours été “SOFTWARE”.
Depuis Android 3.0 il est possible d’activer l’accélération graphique pour chaque application ce qui nous permet d’avoir une meilleur expérience utilisateur, avoir des animations plus fluides et de libérer un peu le CPU.

Software rendering vs Hardware rendering

Software vs Hardware

Lorsqu’une application utilise l’accélération matérielle, l’OpenGL est utilisé lors de l’appel de la fonction Canvas.draw().

Activation de l’accélération matérielle

Pour activer l’utilisation du GPU sur Android 3.0+, il suffit d’ajouter android:hardwareAccelerated=“true” dans le tag application du fichier AndroidManifest.xml. Ce simple ajout devrait activer l’accélération matérielle pour toute votre application, cependant certains composant ne peuvent pas (encore) bénéficier de cette fonctionnalité c’est pourquoi nous allons voir par la suite comment la contrôler.

Contrôle de l’accélération matérielle

Si votre application a des problèmes sur certains éléments avec l’accélération matérielle, il est tout à fait possible de définir quels éléments doivent ou non utiliser le GPU.

On peut donc l’activer ou la désactiver sur ces différents éléments :

  • Application
  • Activity
  • Window
  • View

Pour utiliser l’accélération matérielle au niveau Application ou Activity il faut utiliser le fichier AndroidManifest.xml

<application android:hardwareAccelerated="true">
    <activity ... />
    <activity android:hardwareAccelerated="false" />
</application>

Voici ci-dessous un exemple de code à utiliser pour l’utiliser au niveau “Window” :

getWindow().setFlags(
        WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED,
        WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED);

Pour finir, on peut désactiver l’utilisation du GPU seulement pour un partie de l’écran (View) :

view.setLayerType(View.LAYER_TYPE_SOFTWARE, null);

Vérifier si un élément utilise le GPU

Il peut être important de savoir si un élément utilise l’accélération matérielle à un moment donné.
Il existe 2 façons de le vérifier :

Fonctions supportant l’accélération matérielle

La plupart des fonctions habituelles de la classe Canvas sont supportées, cependant certaines ne le sont pas mais le seront peut-être dans les futures versions d’Android.

Voici la liste des fonctions non supportées :

Certaines autres fonctions fonctionnent différemment lorsque l’accélératrion matérielle est activée :

Paint

  • ComposeShader can only contain shaders of different types (a BitmapShader and a LinearGradientShader for instance, but not two instances of BitmapShader)
  • ComposeShader cannot contain a ComposeShader

Les View Layers

Les layers sont présents depuis la première version d’Android. Ils permettent d’avoir plusieurs couches (différentes vues) en cache et d’avoir de meilleures performances pour des animations ou des effets.

Android 3.0 introduit une nouvelle API appelée View.setLayerType(int type, Paint p). Cette fonction prend 2 paramètres, le premier définit le type de layer que l’on souhaite utiliser et le second (facultatif) définit grâce à un Paint comment la couche doit être composée (Translucency (alpha), Blending mode, Color filter).

Il existe 3 différents types de layer :

  • LAYER_TYPE_NONE : Rendu normal sans mémoire tampon.
  • LAYER_TYPE_HARDWARE : Rendu utilisant les textures matérielles seulement si l’application utilise l’accélération matérielle, sinon le layer sera de type LAYER_TYPE_SOFTWARE.
  • LAYER_TYPE_SOFTWARE : Rendu transformé par le software en bitmap.

Vous pouvez choisir le type de Layer en fonction des objectifs de ceux-ci :

  • Performance : Utilisation du type hardware. Une fois que le rendu est calculé, le code générant le rendu de la View ne sera plus éxecuté tant que la fonction invalidate() de la View ne sera pas appelé. Quelques animations comme celles utilisant la transparence peuvent utiliser directement le layer généré ce qui est très efficace à faire par le GPU.
  • Effets Visuel : Utilisation du hardware ou software layer en appliquant un “Paint”, le second paramètre de la fonction View.setLayerType(int type, Paint p). Par exemple, c’est assez simple d’avoir un rendu noir et blanc sur une image en utilisant “ColorMatrixColorFilter”.
  • Compatibilité : Utilisation du software layer pour forcer le calcul du rendu de la View par le software. Ça permet contourner toutes les restrictions hardware vues précédemment.

Conclusion

Lors de l’Android keynote Devoxx 2011, Tim Bray a annoncé que l’Android market avait plus de 300 000 applications et que maintenant l’objectif est d’avoir un maximum d’applications “géniales” (make it great…). Le but de cette conférence était donc non seulement de présenter les nouveautés d’Android mais aussi de motiver les développeurs à créer de super applications (belle, rapide, fluide, …).
Cet article reprend les explications, présentées lors de la conférence Graphics goodies in Android, pour activer et jouer avec l’accélération matérielle dans nos applications. Vous pouvez retrouver une documentation plus précise sur le site Android developers.
J’espère que cet article est assez clair et que les développeurs francophones pourront s’en inspirer pour améliorer l’expérience utilisateur de leurs applis.

Partagez !    |