Bachamada a atteint les 1000 téléchargements !

Bachamada, pour mon coeur bat la chamade, est une application disponible sur le Play Store :
Disponible sur Google Play

Elle permet de suivre sa fréquence cardiaque sur le long terme, notamment avec une montre connectée :

Bachamada a atteint les 1 000 téléchargements, la semaine dernière, ceci grâce à mon expertise en App Store Optimisation (ASO).
D’ailleurs, vous trouverez quelques astuces et conseils à ce sujet dans le livre blanc Réussir la publication d’une app Android, disponible ici.

Réussir la Publication d’une App Android

C’est officiel, le Play Store compte plus de deux millions d’applications ! Dans ce contexte, il est très difficile de sortir du lot.

Le livre blanc Réussir la Publication d’une App Android fournit des astuces pour donner de la visibilité sur le Play Store à une application (nommé app dans la suite). Il est accessible depuis la barre latérale de ce blog.

L’ABC pour Réussir la Publication d’une App Android

Plus de 80% des app présentes sur le Play Store sont des zombies, c’est-à-dire que leur nombre de téléchargements ne dépasse pas les 500. Il est donc primordial d’optimiser la publication et de travailler la promotion d’une app, tout en respectant l’utilisateur et ses intérêts.
La présentation L’ABC pour Réussir la Publication d’une App Android et le livre blanc Réussir la Publication d’une App Android détaillent des techniques d’App Store Optimization mis en application sur l’app BaChamada qui dépasse à présent les 1000 téléchargements !

Votre livre gratuit :


Formation en Développement Android

Cette formation en développement Android s’adresse aux développeurs ayant déjà des connaissances en programmation orientée objet avec Java. En particulier, elle s’adresse aux personnes souhaitant se lancer dans le développement d’applications mobiles.

L’apprentissage se fait via des cours interactifs et des exercices pratiques, réalisés en langage Java sur Android Studio. Tout au long des séances, afin d’augmenter sa productivité, il est indiqué des astuces pour utiliser au mieux les outils de développement (raccourcis clavier, auto-génération de codes, librairies, références, etc.). De plus, les bonnes pratiques de développement seront mises en lumière.

Prérequis : Maitrise de Java.

La formation est basée sur un tronc commun de 4 séances. De manière générale, ces dernières sont d’une durée de 2 à 4 heures.

Séance 1 : ABC d’Android

  • Théorie
    • Plateforme Android
    • Environnement de Développement Android Studio
    • Principe de Programmation
  • Pratique
    • Création d’un premier projet ‘Hello Android’
    • Arborescence de ‘Hello Android’, fichiers clés
    • Familiarisation via la réalisation de tâches simples
    • Déploiement sur simulateur et appareil physique

Un aperçu est disponible dans l’article L’extraordinaire humanoïde.

Séance 2 : Outils du développeur

  • Théorie
    • Messages Systèmes
    • Débugage
    • Déploiement
    • Tests
  • Pratique
    • Import de projets exemples
    • Messages d’erreur et débuggage
    • Utilisation de librairies
    • Partage des connaissances sur les projets explorés

Séance 3 : Interface Utilisateur Native

  • Théorie
    • Vue
      (Combinaison avec Fragment et Activity, Layout)
    • Ressource
    • Élément Graphique Natif
      (Indispensable, conteneur, navigation)
    • Message Utilisateur
      (Notifications, Popup)
    • Material design
  • Pratique
    • Construction d’une interface avec un agencement élaboré
    • Mise en pratique de quelques composants graphiques

Séance 4 : Contrôleurs d’Interface Utilisateur

  • Théorie
    • Adapter
    • Adapter et Vue Liste
    • Gestion des Interactions
    • Navigation entre Écrans
    • Compatibilité des Versions Android
  • Pratique
    • Utilisation des Fragments avec Tabs (Menu à onglets)
    • Communication d’informations entre deux Tabs
    • Gestion des différentes versions d’Android

 
Les séances suivantes sont à la carte, elles permettent d’adapter la formation en fonction des besoins.

Séance 5 : Vue Personnalisée

  • Théorie
    • Animation
      (Transition, objet, images)
    • Vue Personnalisée
      (Création, utilisation, animation, interaction)
    • Son, Vibreur, Accéléromètre
  • Pratique
    • Création d’une vue simple en code Java avec un Canvas
    • Animation graphiques et sonores d’éléments

Séance 6 : Persistance des Données

  • Cours sur la gestion des données en Android
  • Pratique
    • Préférences de l’utilisateur
    • Utilisation de la librairie Realm (comparaison avec SQLite)

Séance 7 : Communication avec un Serveur

  • Cours sur la communication Client Mobile / Serveur
  • Pratique
    • Utilisation de la librairie Retrofit
    • Recevoir des données d’un Web Service
    • Envoyer des données à un Web Service

Séance 8 : Réussir une Publication sur le Play Store

  • Introduction à l’App Store Optimization
  • Publication
    (Éléments requis et optionnels)
  • Utilisateur
    (Test, retours, note)
  • Promotion
    (Influenceurs, publication alternative, revue d’application)
  • Console de Publication, Fiche de description, Statistiques

Un aperçu est disponible dans l’article Réussir la Publication d’une App Android.

Séance 9 : Android Wear

  • Cours sur Android Wear
    • Interface et ses différents modes
    • Configuration d’un projet Android Wear
    • Communication des données entre les modules
  • Pratique
    • Déploiement d’un projet sur la montre

Un aperçu est disponible dans l’article Déployer une App Android Wear sur une Smartwatch.

 
Pour aller plus loin :

Séance 10  : Choix de la Technologie Mobile

  • Comparaison des Environnements de Développement Hybride
  • Hybride ou Natif ? Étude de cas

Top 6 des raccourcis dans Android Studio

Cet article présente une sélection de raccourcis clavier sur Android Studio pour augmenter votre rapidité de développement.

  1. Aller sur la classe ou l’élément : Cmd/Ctrl+click sur l’élément
  2. Indenter le code et revoir les imports : Cmd/Ctrl+Alt+L
  3. Renommer une variable : Shift+F6
  4. Auto-Générateur de getter/setter, constructeur, méthodes surchargées : Cmd/Ctrl+N
  5. Auto-complétion : Cmd/Ctrl+Space
  6. Correction automatique : se placer sur la ligne, Alt+Enter

Remarque : Il est possible de voir tous les raccourcis à partir d’Android Studio > Preferences > Keymap.

Pour aller plus loin : Afin d’augmenter ses performances, il est préconisé de re-construire, Builder, votre projet Android, le moins souvent possible. En effet, le processus de construction des fichiers exécutables (.dex) prend du temps. Pour éviter de re-construire votre projet, il faut utiliser au maximum l’outils de visualisation d’Android Studio, soit la preview des fichiers xml (cf. Android Developer Perf Matters).
Source :
Android Studio Tips and Tricks
Android Developer Perf Matters

 

 

GatHaba sur Play Store

GatHaba est une application Android cliente du service GitHub. Elle permet de suivre des répertoires de plusieurs utilisateurs GitHub, ceci sans avoir à créer de compte.
Il est possible d’ajouter les répertoires d’un utilisateur GitHub via le menu Ajouter, ensuite il s’agit de choisir les répertoires à suivre.
Une vue détaillé de chaque répertoire est disponible, dans laquelle il est présenté la description du projet, le langage technique,  la taille en byte, le nombre de star, et la date du dernier push.

GatHaba en image

gathaba_homegathaba_follow gathaba_repo_detailsgathaba_add_repo

GatHaba sur Play Store

disponible sur googleplay

Faire une requête HTTP GET avec Retrofit en Android

Ce tutoriel va vous donner les clés pour faire une requête HTTP GET au format JSON, en Android, avec la librairie Retrofit 2.0.

Tout d’abord, il faut au préalable avoir importé la librairie Retrofit 2.0 et un convertisseur de requête dans le projet Android (cf. Configurer un projet Android pour utiliser Retrofit).

Ensuite, il s’agit de faire la requête HTTP GET. En particulier, nous nous intéressons à récupérer un objet au format JSON depuis un serveur distant.

Créer la classe JAVA relative à l’objet JSON à récupérer

Par exemple, nous souhaitons récupérer la liste des répertoires d’un utilisateur GitHub.

La requête permettant d’obtenir la liste de repertoires est https://api.github.com/users/machadacosta/repos. Avec Postman, l’execution de cette requête renvoie :

[
{
"id": 39936429,
"name": "bachamada",
"full_name": "machadaCosta/bachamada",
"owner": {
"login": "machadaCosta",
"id": 2046403,
"avatar_url": "https://avatars.githubusercontent.com/u/2046403?v=3",
"gravatar_id": "",
"url": "https://api.github.com/users/machadaCosta",
"html_url": "https://github.com/machadaCosta",
"followers_url": "https://api.github.com/users/machadaCosta/followers",
"following_url": "https://api.github.com/users/machadaCosta/following{/other_user}",
"gists_url": "https://api.github.com/users/machadaCosta/gists{/gist_id}",
"starred_url": "https://api.github.com/users/machadaCosta/starred{/owner}{/repo}",
"subscriptions_url": "https://api.github.com/users/machadaCosta/subscriptions",
"organizations_url": "https://api.github.com/users/machadaCosta/orgs",
"repos_url": "https://api.github.com/users/machadaCosta/repos",
"events_url": "https://api.github.com/users/machadaCosta/events{/privacy}",
"received_events_url": "https://api.github.com/users/machadaCosta/received_events",
"type": "User",
"site_admin": false
},
"private": false,
"html_url": "https://github.com/machadaCosta/bachamada",
"description": "This project is about monitoring Heart Rate, in Beat Per Minute (BPM), with an Android App.",
"fork": false,
"url": "https://api.github.com/repos/machadaCosta/bachamada",
"forks_url": "https://api.github.com/repos/machadaCosta/bachamada/forks",
"keys_url": "https://api.github.com/repos/machadaCosta/bachamada/keys{/key_id}",
"collaborators_url": "https://api.github.com/repos/machadaCosta/bachamada/collaborators{/collaborator}",
"teams_url": "https://api.github.com/repos/machadaCosta/bachamada/teams",
"hooks_url": "https://api.github.com/repos/machadaCosta/bachamada/hooks",
"issue_events_url": "https://api.github.com/repos/machadaCosta/bachamada/issues/events{/number}",
"events_url": "https://api.github.com/repos/machadaCosta/bachamada/events",
"assignees_url": "https://api.github.com/repos/machadaCosta/bachamada/assignees{/user}",
"branches_url": "https://api.github.com/repos/machadaCosta/bachamada/branches{/branch}",
"tags_url": "https://api.github.com/repos/machadaCosta/bachamada/tags",
"blobs_url": "https://api.github.com/repos/machadaCosta/bachamada/git/blobs{/sha}",
"git_tags_url": "https://api.github.com/repos/machadaCosta/bachamada/git/tags{/sha}",
"git_refs_url": "https://api.github.com/repos/machadaCosta/bachamada/git/refs{/sha}",
"trees_url": "https://api.github.com/repos/machadaCosta/bachamada/git/trees{/sha}",
"statuses_url": "https://api.github.com/repos/machadaCosta/bachamada/statuses/{sha}",
"languages_url": "https://api.github.com/repos/machadaCosta/bachamada/languages",
"stargazers_url": "https://api.github.com/repos/machadaCosta/bachamada/stargazers",
"contributors_url": "https://api.github.com/repos/machadaCosta/bachamada/contributors",
"subscribers_url": "https://api.github.com/repos/machadaCosta/bachamada/subscribers",
"subscription_url": "https://api.github.com/repos/machadaCosta/bachamada/subscription",
"commits_url": "https://api.github.com/repos/machadaCosta/bachamada/commits{/sha}",
"git_commits_url": "https://api.github.com/repos/machadaCosta/bachamada/git/commits{/sha}",
"comments_url": "https://api.github.com/repos/machadaCosta/bachamada/comments{/number}",
"issue_comment_url": "https://api.github.com/repos/machadaCosta/bachamada/issues/comments{/number}",
"contents_url": "https://api.github.com/repos/machadaCosta/bachamada/contents/{+path}",
"compare_url": "https://api.github.com/repos/machadaCosta/bachamada/compare/{base}...{head}",
"merges_url": "https://api.github.com/repos/machadaCosta/bachamada/merges",
"archive_url": "https://api.github.com/repos/machadaCosta/bachamada/{archive_format}{/ref}",
"downloads_url": "https://api.github.com/repos/machadaCosta/bachamada/downloads",
"issues_url": "https://api.github.com/repos/machadaCosta/bachamada/issues{/number}",
"pulls_url": "https://api.github.com/repos/machadaCosta/bachamada/pulls{/number}",
"milestones_url": "https://api.github.com/repos/machadaCosta/bachamada/milestones{/number}",
"notifications_url": "https://api.github.com/repos/machadaCosta/bachamada/notifications{?since,all,participating}",
"labels_url": "https://api.github.com/repos/machadaCosta/bachamada/labels{/name}",
"releases_url": "https://api.github.com/repos/machadaCosta/bachamada/releases{/id}",
"created_at": "2015-07-30T07:08:22Z",
"updated_at": "2015-08-07T13:34:41Z",
"pushed_at": "2015-10-17T14:27:40Z",
"git_url": "git://github.com/machadaCosta/bachamada.git",
"ssh_url": "git@github.com:machadaCosta/bachamada.git",
"clone_url": "https://github.com/machadaCosta/bachamada.git",
"svn_url": "https://github.com/machadaCosta/bachamada",
"homepage": null,
"size": 2144,
"stargazers_count": 1,
"watchers_count": 1,
"language": "Java",
"has_issues": true,
"has_downloads": true,
"has_wiki": true,
"has_pages": false,
"forks_count": 0,
"mirror_url": null,
"open_issues_count": 1,
"forks": 0,
"open_issues": 1,
"watchers": 1,
"default_branch": "master"
},
...
}
]

Afin de modéliser un objet répertoire renvoyé par le serveur, il faut créer une classe JAVA représentant l’objet. Par exemple, la classe Repo :

private static class Repo {

    final String name;
       
    public Repo(String name) {
        this.name = name;
    }
}

Avec l’attribut de classe name correspondant à un élément de la réponse du serveur.

Faire la requête HTTP GET

  1. Créer l’interface JAVA listant les requêtes à réaliser, ici nous déclarons une seule requête HTTP GET, listRepos :
    public interface GitHubService {
        @GET("/users/{user}/repos")
        Call<List<Repo>> listRepos(@Path("user") String user);
    }

    Note : En début de méthode, figure ce qui est attendu du serveur dans un Call, soit une liste de RepoCall<List<Repo>>.
    En paramètre de méthode, est placé le(s) paramètre(s) pour la requête, soit l’utilisateur GitHub.
    En header, il y a le type de la requête ainsi que les paramètres, soit @GET(« /users/{user}/repos ») avec {user} qui référence le paramètre @Path(« user »).
    Remarque : Cette syntaxe est spécifique à la librairie Retrofit, version 2.0.

  2. Préparer la création de la requête :
    Retrofit retrofit = new Retrofit.Builder()
        .baseUrl("https://api.github.com")
        .addConverterFactory(GsonConverterFactory.create())
        .build();
    
    GitHubService service = retrofit.create(GitHubService.class);
    
  3. Créer la requête avec le paramètre machadacosta pour l’utilisateur :
    Call<List<Repo>> repos = service.listRepos("machadacosta");
    
  4. Executer la requête en asynchrone :
    repos.enqueue(new Callback<List<Repo>>() { 
    @Override public void onResponse(Response<List<Repo>> response, Retrofit retrofit) { 
    Toast.makeText(getApplicationContext(), String.format("OK"), Toast.LENGTH_SHORT).show(); 
    List<Repo> allRepos = response.body(); 
    } 
    @Override public void onFailure(Throwable t) { 
    Toast.makeText(getActivity(), String.format("KO"), Toast.LENGTH_SHORT).show(); } 
    });

    Note : La réponse du serveur est accessible depuis la méthode onResponse. Dans notre cas, la liste des Repo attendue se situe dans l’objet response.body(). Le nom du premier répertoire de l’utilisateur machadacosta est dans la variable allRepos.get(0).getName(); .

  5. Vérifier les librairies importées dans la classe JAVA :
    import java.util.List;
    
    import retrofit.Call;
    import retrofit.Callback;
    import retrofit.GsonConverterFactory;
    import retrofit.Response;
    import retrofit.Retrofit;
    import retrofit.http.GET;
    import retrofit.http.Path;

En Android, il n’est pas possible d’envoyer directement la requête :
– soit la requête est envoyé dans un Thread en synchrone avec la méthode .execute()
– soit la requête est envoyé en asynchrone avec la méthode .enqueue(…)

En effet, Android interdit d’envoyer des requêtes HTTP en direct car elles pourraient bloquer l’application si elles ne sont pas réalisées assez rapidement. La requête doit être envoyée en parallèle de l’execution de l’application, pour cela elle est envoyée dans un Thread Android ou bien en asynchrone avec la méthode enqueue de Retrofit.

Finalement, nous avons vu comment réaliser une requête HTTP GET avec la librairie Retrofit (version 2) en JAVA Android, tout en utilisant les services GitHub. L’envoie d’une requête HTTP POST est très similaire, vous pouvez le vérifier dans cet article.

Faire une requête HTTP POST avec Retrofit en Android

Ce tutoriel va vous donner les clés pour faire une requête HTTP POST au format JSON, en Android, avec la librairie Retrofit 2.0.

Tout d’abord, il faut au préalable avoir Configurer un projet Android pour utiliser la librairie Retrofit.

Ensuite, il s’agit de faire la requête HTTP POST. En particulier, nous nous intéressons à envoyer un objet au format JSON à un serveur distant.

Créer la classe JAVA relative à l’objet JSON à envoyer

Par exemple, nous souhaitons envoyez un utilisateur, user, définit par un nom (name), da costa, et un prénom (first_name), macha au format JSON :

{"name":"da costa",
"first_name":"macha"}

Il faut créer la classe JAVA User suivante :

 private static class User {

        final String name;
        final String first_name;

        public User(String name, String first_name) {
            this.name = name;
            this.first_name = first_name;

        }
    }

Créer la variable et la classe JAVA relative à la requête HTTP POST

Par exemple, nous souhaitons envoyer une instance de User en POST à l’adresse example.server.com/lists/arcadegame/members.
Il faut créer la variable API_URL, de préférence dans l’Activity principale :

    public static final String API_URL = "https://example.server.com";

et la classe PostTo représentant la requête POST :

interface PostTo {
        @POST("/lists/arcadegame/members/")
        Call<Repo> sendUser(@Body SubscribeUser body);
    }

Executer la requête HTTP POST

Il s’agit à présent de créer le client avec la librairie Retrofit dans l’Activity principale, la classe JAVA depuis laquelle la requête sera lancée. Par exemple, nous exécutons  la requête dans une méthode appelé sur l’évènement d’un bouton, présent dans une Activity Android.

  1. Créer le client HTTP, dans l’Activity principale :
     public void sendUserInfo(View view) {
     Retrofit retrofit = new Retrofit.Builder()
                    .baseUrl(API_URL)
                    .addConverterFactory(GsonConverterFactory.create())
                    .build();
    }
    
  2. Créer l’utilisateur à envoyer :
     User user = new User("macha", "da costa");
    
  3. Envoyer la requête via le client en asynchrone:
     public void sendUserInfo(View view) {
    ...
     PostTo post = retrofit.create(PostTo.class);
    
            Call<Repo> call = post.sendUser(user);
    
       call.enqueue(new Callback<Repo>() {
                @Override
                public void onResponse(Response<Repo> response, Retrofit retrofit) {
                    Toast.makeText(getActivity(), String.format("OK"), Toast.LENGTH_SHORT).show();
                    
                }
    
                @Override
                public void onFailure(Throwable t) {
                    Toast.makeText(getActivity(), String.format("KO"), Toast.LENGTH_SHORT).show();
    
                }
            });
    }
    

En Android, il n’est pas possible d’envoyer directement la requête :
– soit la requête est envoyé dans un Thread en synchrone avec la méthode .execute()
– soit la requête est envoyé en asynchrone avec la méthode .enqueue(…)

En effet, Android interdit d’envoyer des requêtes HTTP en direct car elles pourraient bloquer l’application si elles ne sont pas réalisées assez rapidement. La requête doit être envoyée en parallèle de l’execution de l’application, pour cela elle envoyé depuis un Thread Android ou bien en asynchrone avec la méthode enqueue de Retrofit.

Finalement, dans ce tutoriel il a été envoyé une requête HTTP POST via une application cliente Android, ceci en asynchrone, sans attente de retour du server. L’envoie d’une requête HTTP GET est très similaire : faire une requête HTTP GET avec Retrofit en Android.

Source :

Principaux changements de Retrofit avec la version 2

Simple POST avec Retrofit en Android Version 1.9

Retrofit 2.0 API Spec, issue on Github by Jake Wharton

Configurer un projet Android pour utiliser Retrofit

Ce tutoriel explique comment configurer un projet Android pour utiliser la librairie Retrofit 2.0.

Une brève étude sur les librairies Android permettant de faire des requêtes HTTP (cf. question « What is the best library to make HTTP calls from Java/Android » sur Quora) m’a orienté vers la librairie Retrofit pour le transfert de données textuelles (hors chargement d’image).

Importer les librairies nécessaires dans Android Studio

Il s’agit d’importer la librairie Retrofit développée par Square. De plus, depuis la version 2 de Retrofit, il faut également importer un convertisseur de requête pour le format utilisé, JSON dans notre cas.

  1. Dans le fichier gradle de votre projet Android Studio, celui lié au module app/,  importer la librairie Retrofit :
    dependencies {
    compile 'com.squareup.retrofit:retrofit:2.0.0-beta2'
    }
  2. Importer également un convertisseur JSON, soit la librairie converter-gson :
    compile 'com.squareup.retrofit:converter-gson:2.0.0-beta2'

Il existe d’autres convertisseurs, voici la liste proposé par Square :

  • Gsoncom.squareup.retrofit:converter-gson (JSON)
  • Jacksoncom.squareup.retrofit:converter-jackson (JSON)
  • Moshicom.squareup.retrofit:converter-mosh (JSON)
  • Protobufcom.squareup.retrofit:converter-protobuf (Protocol Buffer binary)
  • Wirecom.squareup.retrofit:converter-wire (Wire pour protocol buffer-compatible)
  • Simple XMLcom.squareup.retrofit:converter-simplexml (XML)

 

Ajouter les permissions de se connecter à Internet

Afin de pouvoir executer des requêtes HTTP sur un serveur distant, il faut également ajouter, à l’application Android, les permissions de se connecter à Internet.

  1. Dans le fichier Manifest de votre projet Android Studio, ajouter :
<uses-permission android:name="android.permission.INTERNET" /> 

 

Finalement, dans ce tutoriel, il est expliqué comment importer les librairies de Retrofit, pour le transfert HTTP, avec le format JSON, dans un projet Android. Ceci peut facilement être transposé pour l’import d’autres librairies.
De plus, à présent vous pouvez réaliser des requêtes HTTP GET et HTTP POST, avec Retrofit dans une application Android.

De bons présages pour Android Wear

Les montres connectées ont la côte en 2015 et il y en a pour tous les goûts, que ce soit celles de grandes marques comme la Tag Heuer Connected, l’Apple Watch, la Moto 360, les Pebbles, la Garmin Connect Mobile ou bien celles de marques moins connues. Depuis sa sortie en 2014, le système d’exploitation Android Wear a ouvert le marché des montres connectées, ou smartwatchs. En effet, le système Android est publique et peut être installé sur n’importe quelle montre.

Diverses montres connectées Android

Diverses montres connectées

Les premières montres connectées Android ont vu le jour en juin 2014 avec la Samsung Galaxy Gear Live et la LG  G Watch. Elles ont été suivies par la Moto 360 de Motorola, la Zen Watch d’Asus, etc. D’une part, les constructeurs font la course pour sortir la smartwatch avec la batterie la plus performante à un prix accessible. D’autre part, les développeurs s’affairent pour sortir des applications innovantes.

Dans cet article, il est sondé le marché des smartwatchs à partir de chiffres clés relevés dans différentes études, ils montrent la taille du marché et les tendances à venir.

4 000 000 smartwatchs Android vendues d’ici 2015

Selon une étude de canalys,  720 000 smartwatch Android ont été vendu en 2014, soit 720 000 montres en 6 mois. Selon un article de l’IDC, datant du 14 septembre 2015, d’ici la fin de l’année 4,1 million de montre Android devront être livrées et 32,6 million d’ici 2019. Cela représente un peu plus 4 000 000 potentiels utilisateurs d’application Android Wear pour les prochains mois, dans le monde.

table_android_wear_2014_2015

Part de marché des principaux systèmes d’exploitation pour montre

4000 apps Android Wear disponible sur le Play Store en mai 2015

Selon la keynote de Google datant du 28 mai 2015, le Play Store compte un peu plus de 4 000 apps Android Wear. Les apps ‘Watch Face’ ont le plus de succès, elles permettent de personnaliser le fond d’écran de la montre, ensuite viennent les utilitaires puis les jeux.

App Prix Nb téléchargements Note Catégorie
SkymasterPilot
Skymaster
0,99€ 3661 download 4,4 star Personnalisation
findMyPhone
Find My Phone
gratuit 2551 download 4,2 star Outils
Hole19
Hole 19
gratuit 1585 download 4,3 star Sports
flopsyDroid
Flopsy Droid
gratuit 1504 download 4,1 star Arcade

Ce tableau présente 4 applications Android Wear. Le succès de Skymaster montre bien que les utilisateurs de smartwatch sont prêts à payer lorsqu’il s’agit de personnaliser leur gadget. De plus, de même que pour les smartphones, les applications les plus affectionnées sont les outils comme Find My Phone et les Jeux.

Tendances pour 2016

Selon une étude réalisée aux États Unis, sur 1000 candidats, 42% de personnes seraient prêtes à acheter une Apple Watch (cf. Graphique des potentiels acheteur d’Apple Watch). Par extension à Android Wear, cela est très prometteur pour le marché.

smartwatch_potentiels_acheteurs

Graphique des potentiels acheteurs d’Apple Watch

Concernant les caractéristiques smartwatch les plus demandés, on remarque un prix raisonnable, l’étanchéité de la montre, une batterie tenant la charge une semaine, l’enregistrement pour la Fitness, etc. (cf. Graphique des qualités smartwatch les plus demandées).

smartwatch_qualités_demandées

Pour conclure, le marché des montres connectées est très prometteur. En effet, nous attendons 4 000 000 utilisateurs juste pour Android Wear d’ici la fin de l’année. D’ailleurs, bien que la concurrence avec l’Apple Watch est rude, la sortie de la Tag Heuer Connected peut encore changer la donne.
En addition, le Play Store pour Wear dénombre peu d’application ce qui facilite la visibilité d’une nouvelle application spécialement conçue pour une montre connectée.

Source : 

Official Android Wear – wear what you wan’t

Canalys : Over 720 000 Android Wear devices shipped in 2014

IDC : Fueled by Growing Demand for Smart Wearables

Wearable Tech in 2019

Statistique IDC sur les wearables

Swiss Watchmaker joins Smartwatch Fray As More Consumers Express Interest