CodLab

Maintenant que vous savez que vous devez rester dans les clous avec les widgets, on va commencer à pouvoir y aller à la pelle et voir qu’on peut quand même faire du bon gros quick’n'dirty ; bon ok… on va pas aller jusque là mais vous saurez que vous pouvez faire plus que ce qui vous pensiez pouvoir faire depuis le précédent article. héhé

Rien de miraculeux, il faut garder à l’esprit toutes les différentes remarques pour cet article qui se propose de mettre les mains dans le code au travers d’un exemple simple et de faire découvrir un aspect des widgets et du développement sous android.

Commençons

Pour cet exemple, créons un simple projet. Chargez votre IDE favori et créez le projet. Peu importe le package de base que vous utiliserez, souvenez-vous simplement que des éléments du Manifest et des déclarations de xml auront besoin du package exact de vos classes pour instanciations/permissions.

Classes de base

Faisons simple. Si vous avez lu l’article précédent, vous aurez besoin d’un AppWidgetProvider pour le widget, et d’un Service.

Nous les appellerons simplement MyAppWidgetProvider et MyService (pourquoi faire compliqué). Dans la classe MyAppWidgetProvider, nous allons surcharger la méthode onUpdate puis dans Service, la méthode onStartCommand (pour l’exemple)

public class MyAppWidgetProvider extends AppWidgetProvider {
@Override
public void onUpdate(Context context, AppWidgetManager appWidgetManager, int []appWidgetId) {
}
}

public class InspectService extends Service {
@Override
public int onStartCommand(Intent intent, int flags, int e){
return START_STICKY;
}
}

La base est donnée, nous pouvons continuer. Nous allons créer un simple layout affichant du texte. Créez donc un nouveau layout dans le dossier res/layout en lui donnant un nom que vous souhaitez puis ajoutez dedans :

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:gravity="center_horizontal|center_vertical"
android:orientation="vertical" >

<TextView

android:id="@+widget/text"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:gravity="center_horizontal"
android:text="@string/start" />
</LinearLayout>

Ajoutons maintenant deux valeurs strings dans les ressources

<string android:name="start">Start the service</string>
<string android:name="stop">Stop the service</string>

Qui servirons à lancer/stopper le service exemple

Manifestons !

Maintenant que la vue pour le widget existe, que les classes sont déclarées, modifions le manifest.

Ouvrez le manifest et au sein de la balise application, indiquez que l’application utilisera un service et un receiver avec un intent-filter

<service android:name="your.package.is.here.MyService" />

<receiver
android:name="your.package.here.MyAppWidgetProvider">
<intent-filter>
<action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
</intent-filter>

<meta-data
android:name="android.appwidget.provider"
android:resource="@xml/widget_service" />
</receiver>

Vous avez vu le meta-data? Au niveau de android:resource? Nous allons voir dans l’étape suivante quoi faire

Au bout du tunnel… du widget

Bon ok, on va voir quoi faire mais attention, il faudra un autre article pour vous montrer dans le détail toutes les possibilités qui vous sont offertes !

Donc créez un simple fichier xml dans res/xml. D’après l’étape précédente, j’appelle donc le mien widget_service.xml. Ouvrez le et mettez :

<?xml version="1.0" encoding="utf-8"?>
<appwidget-provider xmlns:android="http://schemas.android.com/apk/res/android"
android:minWidth="40dip"
android:minHeight="40dip"
android:minResizeWidth="40dip"
android:minResizeHeight="40dip"
android:updatePeriodMillis="0"
android:previewImage="@drawable/uneresourcegraphiqueexemple"
android:initialLayout="@layout/lelayoutcreeavant"
/>

Ce qu’il faut remarquer ici (outre les informations de taille, que vous pouvez changer…) : vous pouvez gérer une image de présentation qui apparaitra dans la liste des Widgets. et un layout par défaut, celui qui est chargé par le widget, dont le nom est à changer en fonction du layout que avez créé précédemment. Dernière petite info, en mettant 0 dans updatePeriodMillis, on indique que le widget sera mis à jour “manuellement” par l’application et non par le système qui aurait pu le faire à intervalle régulier.

Récapitulons rapidement, nous avons :

1. une classe de widget et un service,
2. déclaré un layout pour le widget
3. déclaré un xml de déclaration d’informations sur le widget
4. modifié le manifest pour décrire l’utilisation du service et du widget

Agrémentons tous cela maintenant.

Du Widget au Service

Rajoutons de l’activité dans le Widget. Ouvrez votre classe du widget, et mettez ce code dans la méthode onUpdate:

// Preparation des vues
RemoteViews views = new RemoteViews(context.getPackageName(), R.layout.widget_service);

//petite disjonction sur l'état d'activité du service, que nous implémenterons après

//change le texte en fonction de l'état
if(MyService.getState() == MyService.RUNNING){
views.setTextViewText(R.widget.text, context.getString(R.string.stop));
}else{
views.setTextViewText(R.widget.text, context.getString(R.string.start));
}

// préparation d'un intent à déclencher au clic sur le widget
Intent serviceIntent = new Intent(context, MyService.class);
serviceIntent.putExtra("state", 2);

PendingIntent pendingIntent = PendingIntent.getService(context, 1, serviceIntent, PendingIntent.FLAG_UPDATE_CURRENT);
views.setOnClickPendingIntent(R.widget.text, pendingIntent);

//on envoie sur toutes les instances du widget présentes sur le launcher
for(int i=0;appWidgetId != null && i<appWidgetId.length;i++)
appWidgetManager.updateAppWidget(appWidgetId[i], views);

Cela aura pour effet d’instancier le widget et de le préparer pour l’espace utilisateur. N’oubliez pas qu’il faille en faire un minimum pour permettre de ne pas dépasser le temps critique autorisé et éviter des ANR potentielles (d’après certains tests, 5sec entrainent des messages de warning dans les logs selon les versions du système)

… et du Service, chargeons le Widget

Dernière étape ! Mais pas la plus dure, vous allez voir.

Tout à l’heure, j’ai utilisé une méthode static getState() dans onUpdate. Nous créons donc cela dans le service :

public final static int RUNNING = 1;
public final static int STOPPED = 2;
private static int _state;

public static int getState(){
return _state;
}

Nous avançons ; mettons en place la mise à jour simple des widgets dans une méthode updateWidgets()

private void updateWidgets(){

//récupération du manager général
AppWidgetManager appWidgetManager = AppWidgetManager.getInstance(this.getApplicationContext());

//récupération d'un ComponentName de notre provider
ComponentName widgetComponentName = new ComponentName(getApplicationContext(), MyAppWidgetProvider.class);

//récupération des widgets possible de l'application
int[] widgetIds = appWidgetManager.getAppWidgetIds(widgetComponentName);

for (int widgetId : widgetIds) {

//pour chaque type, récupération des vues "distantes" (nous sortons de l'application, d'où notamment les restrictions sur les variables vues dans le précédent article)
RemoteViews remoteViews = new RemoteViews(this
.getApplicationContext().getPackageName(),
R.layout.widget_service);

//changeons le texte en fonction de l'état
if(getState() == RUNNING){
remoteViews.setTextViewText(R.widget.text,getString(R.string.stop));

}else{
remoteViews.setTextViewText(R.widget.text,getString(R.string.start));
}

//et on envoie la mise à jour - ici on peut dépasser les 5sec etc... mais attention, en parallèle d'interfactions utilisateurs !
appWidgetManager.updateAppWidget(widgetId, remoteViews);

}
}

Et la gestion du cycle du service dans tout cela? Elle vient juste après ; nous avons donc besoin de pouvoir savoir quand le service démarre, “gère” et quitte :

@Override public void onCreate() {
super.onCreate();

updateWidgets();

}

@Override
public int onStartCommand(Intent intent, int flags, int e){
if(intent != null && intent.hasExtra("state")){
int state = intent.getIntExtra("state", 0);
if(state == 2){
_state = (this.getState() == RUNNING) ? STOPPED : RUNNING;
}

if(_state == STOPPED){
stopSelf();
}else if(_state == RUNNING){
}
updateWidgets();
}
return START_STICKY;
}

@Override
public void onDestroy() {
super.onDestroy();

_state = STOPPED;

updateWidgets();
}

Vous voyez ce que cela fait? Au démarrage du service, les widgets sont mis à jour pour indiquer qu’il est possible de quitter le service. Puis à l’extinction du service, ils le sont en leur indiquant que le service peut être lancé

Conclusion

Voilà, vous avez pu voir la création d’un très très simple widget qu’on aurait pu appeller le tout-pas-beau ainsi qu’un moyen de les mettre à jour par l’utilisation d’un service. Vous pouvez bien évidemment aussi utiliser les receiver pour récupérer des états bien spécifiques, des url, des tags NFC (quoique je n’ai pas essayé celui-là). A vous donc de gravir le reste de la montagne mais n’oubliez pas : le launcher, ce n’est pas un emplacement sur lequel utiliser tout l’espace, il faut penser à l’expérience utilisateur avant tout