Android Wear : premiers pas pour concevoir et designer une application

Le marché des montres connectées est en plein essor actuellement. Le salon de l’IFA qui vient de se dérouler à Berlin en est un exemple flagrant. Ce ne sont pas moins de 5 constructeurs de smartphones différents qui ont présenté leurs montres connectées. Bien que toutes ces montres n’utilisent pas Android Wear la tendance montre clairement que ce genre d’accessoire va se développer dans les prochaines années.

Canalys prévoit que le nombre de bracelets connectés devrait atteindre les 45 millions d’unités en 2017. Les constructeurs misent donc sur les smartwatches pour être un relais de croissance en s’appuyant sur la base des smartphones installés et, étant donné la pénétration du marché d’Android, il y a fort à parier qu’une majorité de ces montres se baseront sur l’OS de Google. Cet article présentera les principes à garder en tête lors de la conception d’une application pour Android Wear ainsi que des exemples de code pour la réaliser.

Android Wear le compagnon idéal du smartphone

Le lien avec le smartphone est très fort dans la conception d’applications pour Android Wear. En effet, développer une application Android Wear revient principalement à développer une application Android classique en ajoutant un module Android Wear qui contiendra les actions réalisables à partir du wearable device. La philosophie derrière cette architecture est de permettre aux applications de délivrer la meilleure information au moment le plus juste. Google encourage donc les développeurs d’applications Android Wear à créer des applications qui se basent sur les nombreux capteurs présents, à la fois sur le téléphone et sur le wearable device, pour détecter le moment le plus propice pour afficher de l’information.

Concevoir et designer une application Android Wear

Afin d’offrir une expérience unifiée à tous les utilisateurs, Google propose des principes à respecter lors de la conception d’une application Android Wear.
Les développeurs sont invités à adapter à la taille de l’écran l’information à afficher et les actions à réaliser. Il est évident qu’on ne peut pas afficher la même chose sur l’écran d’un smartphone et sur celui d’une montre mais on peut néanmoins proposer une interface unifiée qui prend en compte les spécificités de chaque terminal. La bonne nouvelle c’est que le SDK fourni par google permet de gérer ce cas de figure de manière transparente.

Voici le code pour afficher une notification sur Android :

```

int eventId = 001;
/* On crée un intent chargé d’afficher le résultat de la notification */
Intent viewIntent = new Intent(this, ViewEventActivity.class);
/* On lui ajoute l’event id en paramètre */
viewIntent.putExtra(EXTRA_EVENT_ID, eventId);
PendingIntent viewPendingIntent = PendingIntent.getActivity(this, 0, viewIntent, 0);
/* On utilise le notificationBuilder pour créer la notification */

NotificationCompat.Builder notificationBuilder =

new NotificationCompat.Builder(this)

.setSmallIcon(R.drawable.ic_event)

.setContentTitle(eventTitle)

.setContentText(eventLocation)

.setContentIntent(viewPendingIntent);
/* on récupère le gestionnaire de notification */

NotificationManagerCompat notificationManager = NotificationManagerCompat.from(this);
/* On construit la notification et on l’envoie. */

notificationManager.notify(notificationId, notificationBuilder.build());```

Ce code permettra de générer deux types de notification différentes en fonction de l’appareil la recevant.

Par exemple :

Les éléments composant cette notification sont les mêmes mais leur agencement est différent et pensé pour l’écran sur lesquels ils sont affichés tout cela sans surcoût pour le développeur.
Le SDK permet au développeur d’ajouter des actions à une notification comme ceci :

notificationBuilder.addAction(icone, libelle, pendingAttent);`

Ce genre d’action sera proposé en dessous de la notification sur un téléphone ou grâce à un slide sur le wearable device. On peut également intégrer des actions visibles uniquement sur le wearable device.

```

NotificationCompat.Action action = new NotificationCompat.Action.Builder(icone, libelle, pendingAttent).build();
notificationBuilder.extend(new WearableExtender().addAction(action));```

Afin d’éviter les excès, Google rappelle dans ces principes que pour être utiles les notifications ne doivent pas être émises à tout va et les développeurs sont invités à réfléchir au moment où afficher une notification est le plus pertinent pour l’utilisateur.

De même, il est important de prendre en compte le fait que l’utilisateur ne se servira pas du wearable device comme d’un smartphone : l’information doit donc être aussi réduite que possible afin de pouvoir être traitée du coin de l’oeil par l’utilisateur. On peut voir cette notion dans l’exemple précédent, en un coup d’oeil, l’utilisateur reconnaît l’application à l’origine de la notification, l’expéditeur du message ainsi que le message en lui même.
Le SDK mise sur ce point, accès et manipulation de l’information en un minimum de temps et un minimum de geste(s). De fait, étant donné que ce type de device n’offre pas un écran permettant d’afficher des dizaines d’icônes ou même un clavier, le SDK fournit un autre moyen de réagir aux notifications. On a pu voir les actions associées aux notifications dans l’exemple de code précédent, mais ce n’est pas la seule possibilité offerte par le SDK.
Limiter l’information présente à l’écran ne doit pas empêcher le développeur de fournir le contenu qu’il souhaite. Le SDK permet donc d’ajouter des pages à une notification. Ainsi chaque page contiendra un minimum d’information et c’est l’utilisateur qui fera le choix d’en afficher d’avantage.

```

/* On crée une notification mère contenant peu d’information */
NotificationCompat.Builder notificationBuilder =
        new NotificationCompat.Builder(this)
        .setSmallIcon(R.drawable.new_message)
        .setContentTitle("David Martin")
        .setContentText("@rcadel #ArticleBlog je t’ai fait un retour sur l’article Android Wear…")
        .setContentIntent(viewPendingIntent);
/* On crée un second contenu où le texte prendra plus de place => on est dans une vue détail */

BigTextStyle secondPageStyle = new NotificationCompat.BigTextStyle();

secondPageStyle.setBigContentTitle("David Martin")

.bigText("@rcadel #ArticleBlog je t’ai fait un retour sur l’article Android Wear. Tu devrais demander de l’aide à d’autres personnes pour relecture");
/* On crée la seconde page de notification en lui ajoutant le contenu précédemment créé */

Notification secondPageNotification =

new NotificationCompat.Builder(this)

.setStyle(secondPageStyle)

.build();
/* On crée la notification finale en utilisant notre builder et la seconde page de notification /

Notification twoPageNotification =

new WearableExtender()

.addPage(secondPageNotification)

.extend(notificationBuilder).build();

/ On envoie la notification aux différents devices */

notificationManager = NotificationManagerCompat.from(this);

notificationManager.notify(notificationId, twoPageNotification);```

J’ai pu voir qu’on parlait de moi sur [Tatami](https://github.com/ippontech/tatami "Tatami") et récupérer le message mais il serait dommage de s’arrêter là. Je vais donc ajouter une action permettant de répondre en dictant mon tatam.

```

RemoteInput remoteInput = new RemoteInput.Builder(EXTRA_VOICE_REPLY).setLabel(label).build();
/* Je crée un intent pour la gestion de la réponse */

Intent replyIntent = new Intent(this, ReplyActivity.class);

PendingIntent replyPendingIntent =

PendingIntent.getActivity(this, 0, replyIntent, PendingIntent.FLAG_UPDATE_CURRENT);
/* Je crée une action pour répondre et je la lie au remoteinput */

NotificationCompat.Action action =

new NotificationCompat.Action.Builder(R.drawable.ic_reply_icon,

getString(label), replyPendingIntent)

.addRemoteInput(remoteInput)

.build();

/*je modifie ce code */

Notification twoPageNotification =

new WearableExtender().addPage(secondPageNotification)

.addAction(action).extend(notificationBuilder).build();
/*je peux ensuite récupérer ma réponse dans ma ReplyActivity */
private String response;

protected void onCreate(Bundle savedInstanceState) {

response = getMessageText(Activity.getIntent());

}
private CharSequence getMessageText(Intent intent) {

Bundle remoteInput = RemoteInput.getResultsFromIntent(intent);

if (remoteInput != null) {

return remoteInput.getCharSequence(EXTRA_VOICE_REPLY);

}

}

return null;

}```

De cette manière l’application Tatami respecte les bonnes pratiques recommandées par Google en affichant une information claire et concise qui peut être développée sur un simple swipe de l’utilisateur et qui fournit des actions adaptées au périphérique réceptionnant la notification. Ces exemples illustrent les différentes fonctionnalités apportées par le SDK Android Wear mais ce SDK est encore jeune et les wearable devices sont amenés à évoluer au fur et à mesure de leur adoption par le public.

Le futur de Android Wear

Google, par la voix de David Singleton, directeur de projet Android Wear, a annoncé travailler sur les versions futures du SDK. Le nombre de mises à jour de ce SDK devrait augmenter et une version majeure se profile. Cette nouvelle version devrait donner plus d’autonomie à la montre vis à vis du smartphone. En effet il est prévu d’ajouter des capacités d’appairage à la montre, ce qui permettrait de lier une oreillette ou un casque bluetooth directement à la montre afin d’écouter de la musique sans emmener son téléphone par exemple. Cette mise à jour permettra également, pour les montres équipées d’un GPS, de suivre votre position pendant une séance de jogging par exemple. Ces différentes mises à jour donnent une idée de l’objectif de Google ; à savoir: plus d’autonomie pour les montres vis à vis du smartphone. A terme on peut s’attendre à ce que la montre s’intègre dans un réseau d’autres objets connectés et permette de tirer parti de ses capacités matérielles et de ses capteurs afin de devenir un nouveau périphérique indispensable à nos vies à l’image des smartphones actuellement.