introduction
L’un des outils de marketing les plus efficaces est sans aucun doute le bouche à oreille. La preuve sociale est un stimulant très puissant pour la prise de décision. Alors que les gens ignorent facilement la publicité traditionnelle, peu de gens ont tendance à ignorer les conseils d’une source fiable, comme un ami.
En 2011, Google et Ipsos OTX ont mené une enquête qui a révélé des résultats intéressants. Si les recommandations sont complétées par des coupons de réduction que les destinataires peuvent utiliser, la probabilité qu’ils téléchargent l’application ou recommencent à l’utiliser est beaucoup plus élevée. C’est quelque chose que les développeurs et les éditeurs d’applications voudront peut-être garder à l’esprit.
La vérité est que très peu d’éditeurs et de développeurs d’applications mobiles utilisent un système de référence basé sur des recommandations. La raison est presque toujours technique. Le suivi des codes de réduction, la mise en œuvre de liens profonds dans les applications et la configuration d’un backend sont quelques-uns des obstacles que les développeurs doivent surmonter pour que cela fonctionne. En conséquence, la plupart des gens ne se dérangent pas et n’abandonnent pas.
Heureusement, Google a développé un système qui surmonte ces obstacles, Invitations d’applications. Avec App Invites, Google propose une interface puissante grâce à laquelle les développeurs peuvent accroître l’audience de leur application mobile en permettant aux utilisateurs existants d’inviter leurs contacts à essayer l’application.
Les invitations d’application sont incluses dans les services Google Play et sont également disponibles sur iOS. Il optimise les taux d’installation de votre application en réduisant les frictions et en fournissant du contexte, comme les informations générales de l’application et sa note sur l’App Store, à chaque étape du flux d’invitation des utilisateurs.
Dans ce tutoriel, je vais vous montrer comment implémenter cet outil puissant dans votre propre application Android.
1. Configuration du projet
Étape 1: créer le projet
J’utiliserai un projet très simple pour vous montrer comment partager des invitations pour votre application. La première chose à faire est de créer un nouveau projet. Dans Android Studio, choisissez Fichier> Nouveau> Nouveau projet. Nommez votre application et définissez le domaine Web de votre entreprise pour laisser Android Studio définir le nom du package de votre application.
La version minimale du SDK que l’application peut prendre en charge peut être aussi basse qu’Android Gingerbread (niveau d’API 9). Cela signifie que vous pouvez cibler presque tous les appareils exécutant Android, 99,97% au moment de la rédaction. Cependant, gardez à l’esprit que les invitations d’application ne fonctionnent que sur les appareils qui incluent le Play Store de Google, car ils sont basés sur le plug-in de services Google Play.
Générer un blanc Activity et nommez-le MainActivity.java.
Étape 2: Ajouter les services et bibliothèques d’assistance Google Play
Une fois le nouveau projet ouvert dans Android Studio, ouvrez le Projet onglet sur la gauche et développez Scripts Gradle. Il contient deux fichiers du même nom, build.gradle. Le premier fichier est le build.gradle de niveau supérieur. Le deuxième fichier est le build.gradle au niveau de l’application.
Ouvrez le niveau supérieur build.gradle et ajoutez ce qui suit classpath pour les services Google Play.
classpath 'com.google.gms:google-services:1.5.0-beta2'
Ouvrez le niveau de l’application build.gradle et ajoutez-y les dépendances de compilation suivantes.
compile 'com.android.support:support-v4:23.1.1' compile 'com.android.support:design:23.1.1' compile 'com.google.android.gms:play-services:8.3.0'
Pour activer le plugin des services Google Play, ajoutez la ligne suivante ci-dessous apply plugin: 'com.android.application'.
apply plugin: 'com.google.gms.google-services'
Android Studio vous demandera de synchroniser les fichiers du projet. Avant de le faire, cependant, ouvrez AndroidManifest.xml et ajoutez la version des services Google Play dans le application marque.
<meta-data
android:name="com.google.android.gms.version"
android:value="@integer/google_play_services_version" />
Enregistrez les modifications et cliquez sur Synchroniser maintenant. Nous n’avons pas encore fini. Android Studio lancera une erreur vous indiquant que le plugin des services Google Play nécessite un fichier de configuration, google-services.json. Corrigeons ça maintenant.
2. Ajouter un fichier de configuration
Étape 1: visitez Google Developer Platform
Vous devez d’abord visiter le Site Web des développeurs Google pour activer les services Google pour votre application. Le projet est ensuite ajouté à votre console de développeur personnelle, ce qui signifie que vous devez être authentifié en tant qu’utilisateur Google avant de continuer.
Entrez le nom que vous avez choisi pour votre application et spécifiez son nom de package. Si vous ne vous souvenez pas du nom du package de l’application, ouvrez le niveau de l’application build.gradle. Vous pouvez le trouver sous defaultConfig> applicationId.
Remplissez le reste du formulaire et cliquez sur le bouton en bas étiqueté Choisissez et configurez les services.
Étape 2: Générer l’empreinte digitale du certificat
La partie suivante est un peu plus délicate. Google vous demandera l’empreinte digitale du certificat. Pour obtenir l’empreinte du certificat, vous devez ouvrir la ligne de commande et exécuter la commande suivante.
keytool -exportcert -list -v -alias <your-key-name> -keystore <path-to-production-keystore>
Il existe deux scénarios possibles:
- Vous testez votre application localement.
- Vous déployez l’APK sur le Console développeur de Google Play.
Si vous testez votre application localement, le nom de la clé est androiddebugekey et son emplacement par défaut est %USERPROFILE%.androiddebug.keystore sous Windows et ~/.android/debug.keystore sur les systèmes Unix, tels que OS X et Linux. Voici à quoi ressemble la commande pour tester localement.
keytool -exportcert -list -v -alias androiddebugkey -keystore ~/.android/debug.keystore
le keytool L’utilitaire vous demandera d’entrer un mot de passe. Le mot de passe par défaut du fichier de clés de débogage est Android. Cela donnera l’empreinte SHA1 de votre certificat de débogage, qui ressemble à ceci.
Certificate fingerprint: SHA1: DA:39:A3:EE:5E:6B:4B:0D:32:55:BF:EF:95:60:1H:90:AF:D8:07:09.
Cependant, si vous avez besoin du certificat de sortie
empreinte digitale, vous devez alors spécifier le nom, l’emplacement et le mot de passe du certificat.
Étape 3: Ajouter un fichier de configuration
Après avoir entré l’empreinte digitale du certificat, vous pouvez activer les invitations d’application en cliquant sur le bouton Activer les invitations d’application bouton en bas. Vous devriez maintenant pouvoir télécharger le fichier de configuration en cliquant sur Téléchargez google-services.json.
Pour terminer cette étape, copiez le fichier téléchargé dans le app / ou mobile/
répertoire de votre projet.
3. Envoi d’invitations
Étape 1: définir la disposition
Avec le projet configuré, nous sommes prêts pour la prochaine étape. Pour le lanceur Activity, définissez une mise en page simple comme celle illustrée ci-dessous. Il contient un bouton et une étiquette.
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="https://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:id="@+id/container"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
android:paddingBottom="@dimen/activity_vertical_margin" tools:context=".MainActivity">
<TextView
android:id="@+id/title"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_centerInParent="true"
android:gravity="center"
android:text="Hi."
android:textAppearance="@style/TextAppearance.AppCompat.Title"
android:textSize="45sp" />
<Button
android:id="@+id/invite"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_centerHorizontal="true"
android:layout_alignParentBottom="true"
android:layout_marginBottom="100dp"
android:colorButtonNormal="#3F51B5"
android:text="Wanna bring in your friends?"/>
</RelativeLayout>
Le résultat devrait ressembler à ceci.
dans le onCreate méthode la MainActivity classe, ajoutez un
onCreateListener sur le bouton.
button = findViewById(R.id.invite);
button.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
// do something, will you?
}
});
L’invitation sera envoyée sous forme de Intent. Vous pouvez spécifier un message que les utilisateurs peuvent personnaliser avant d’envoyer les invitations à leurs amis. Vous pouvez également définir un appel à l’action, une image d’arrière-plan et un lien profond que votre application peut gérer une fois l’invitation reçue. Vous pouvez même définir la version minimale du SDK (setAndroidMinimumVersionCode) et un ID d’application cible pour d’autres plates-formes, telles que iOS (setOtherPlatformsTargetApplication).
Créer le Intent dans le corps du onClick méthode.
Intent intent = new AppInviteInvitation.IntentBuilder(INVITATION_TITLE)
.setMessage(INVITATION_MESSAGE)
.setCallToActionText(INVITATION_CALL_TO_ACTION)
.build();
startActivityForResult(intent, REQUEST_INVITE);
Ajoutez les chaînes suivantes pour que tout cela fonctionne.
private static final
String INVITATION_TITLE = "Call your friends",
INVITATION_MESSAGE = "Hey! Would you like to get a 50% discount for this awesome app? :)",
INVITATION_CALL_TO_ACTION = "Share";
C’est tout ce qu’on peut en dire. Quand le Intent est lancé, une coutume Activity s’affiche et permet à l’utilisateur de choisir comment il souhaite envoyer l’invitation (e-mail ou SMS), le message de l’invitation et les destinataires.
L’intention est lancée en appelant startActivityForResult. Il est possible de récupérer le résultat de l’intention. Une fois que l’utilisateur a cliqué sur le bouton d’envoi, il est ramené à l’activité qui a lancé l’intention. À ce moment-là, vous pouvez faire tout ce qui est nécessaire pour onActivityResult, comme masquer le bouton ou suivre les invitations via des analyses.
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);
if (requestCode == REQUEST_INVITE) {
if (resultCode == RESULT_OK) {
// You successfully sent the invite,
// we can dismiss the button.
button.setVisibility(View.GONE);
String[] ids = AppInviteInvitation.getInvitationIds(resultCode, data);
StringBuilder sb = new StringBuilder();
sb.append("Sent ").append(Integer.toString(ids.length)).append(" invitations: ");
for (String id : ids) sb.append("[").append(id).append("]");
Log.d(getString(R.string.app_name), sb.toString());
} else {
// Sending failed or it was canceled using the back button
showMessage("Sorry, I wasn't able to send the invites");
}
}
}
4. Lien profond
Étape 1: envoyer des données Deep Link
Lorsqu’un utilisateur reçoit l’invitation et clique sur le lien inclus, le flux d’invitation se ramifie selon que l’application est déjà installée ou non sur le smartphone du destinataire. Si l’application est déjà présente, elle recevra automatiquement un Intent contenant les données facultatives de lien profond.
Cependant, si le destinataire n’a pas installé l’application, il a la possibilité de le faire. Lorsque l’application est lancée pour la première fois, l’application recevra un Intent contenant les données du lien profond. De cette façon, la remise que vous voudrez peut-être offrir sera toujours disponible pour le destinataire. Cela surmonte les problèmes dont nous avons parlé plus tôt.
Explorons les liens profonds plus en détail. Définissez le lien profond du Intent nous avons créé dans le onCreate méthode.
Intent intent = new AppInviteInvitation.IntentBuilder(INVITATION_TITLE)
.setMessage(INVITATION_MESSAGE)
.setDeepLink(Uri.parse("tutsplus://code.coupon/50"))
.setCallToActionText(INVITATION_CALL_TO_ACTION)
.build();
Étape 2: Filtrage d’intention pour les URL personnalisées
La première chose à faire pour gérer les liens profonds personnalisés est d’indiquer à votre application comment ils sont créés et lesquels Activity devrait prendre soin d’eux. Ajouter un nouveau Activity à votre projet et nommez-le DétailsActivité.
Ouvert AndroidManifest.xml et ajoutez l’extrait suivant au <activity android:name=".DetailsActivity"> marque.
<intent-filter>
<action android:name="android.intent.action.VIEW" />
<category android:name="android.intent.category.DEFAULT" />
<category android:name="android.intent.category.BROWSABLE" />
<data
android:host="code.coupon"
android:scheme="tutsplus" />
</intent-filter>
Nous disons au système ce qui suit. S’il invoque l’action VUE sur une URL dont le schéma est tutsplus et dont l’hôte est code.coupon, votre application peut le gérer à l’aide de DetailsActivity classe.
Afin de recevoir et d’analyser l’URL personnalisée, vous devez d’abord créer un GoogleApiClient avec accès aux invitations d’applications. Nous faisons cela dans le onCreate méthode de la MainActivity classe.
GoogleApiClient googleApiClient = new GoogleApiClient.Builder(this)
.addApi(AppInvite.API)
.enableAutoManage(this, new GoogleApiClient.OnConnectionFailedListener() {
@Override
public void onConnectionFailed(ConnectionResult connectionResult) {
Log.d(getString(R.string.app_name), "onConnectionFailed:" + connectionResult);
showMessage("Sorry, the connection has failed.");
}
})
.build();
Étape 3: réception et analyse du lien profond
Pour vérifier les invitations et lancer le lien profond Activity, vous pouvez utiliser le getInvitation méthode, qui a été introduite dans les services Google Play 8.3. Ajoutez l’extrait de code suivant au onCreate méthode de la MainActivity classe.
AppInvite.AppInviteApi.getInvitation(googleApiClient, this, true)
.setResultCallback(
new ResultCallback<AppInviteInvitationResult>() {
@Override
public void onResult(AppInviteInvitationResult result) {}
});
Définition du dernier paramètre de la méthode sur true dit au plugin d’appeler automatiquement l’activité responsable de la gestion du lien profond, le DetailsActivity class dans notre exemple. C’est la raison pour laquelle le corps du onResult méthode est vide.
Ouvert activity_details.xml et ajoutez deux TextView objets comme indiqué ci-dessous.
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent"
android:layout_height="match_parent" android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
android:paddingBottom="@dimen/activity_vertical_margin"
tools:context="com.tutsplus.code.appinvites.DetailsActivity">
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_centerInParent="true"
android:gravity="center"
android:text="Awesome!"
android:textAppearance="@style/TextAppearance.AppCompat.Title"
android:textSize="45sp" />
<TextView
android:id="@+id/discount"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_centerHorizontal="true"
android:layout_alignParentBottom="true"
android:layout_marginBottom="100dp"
android:gravity="center"
android:text="You accepted the invitation, and this gives you the right to a %s percent discount :)"
android:textAppearance="@style/TextAppearance.AppCompat.Body1"
android:textSize="20sp" />
</RelativeLayout>
Ensuite, ouvrez DetailsActivity et remplacer le onStart méthode. Pour vérifier si le Intent contient des données de liens profonds, vous devez vous fier au hasReferral méthode. L’analyse d’URL est très simple comme vous pouvez le voir ci-dessous.
@Override
protected void onStart() {
super.onStart();
Intent intent = getIntent();
if (AppInviteReferral.hasReferral(intent)) {
// Extract the information from the Intent
String deepLink = AppInviteReferral.getDeepLink(intent);
Log.d(getString(R.string.app_name),
"Found Referral: " + AppInviteReferral.getInvitationId(intent) + ":" + deepLink);
String[] array = deepLink.split("/");
if (array.length > 0) {
TextView tv = (TextView) findViewById(R.id.discount);
tv.setText(String.format(tv.getText().toString(), array[array.length-1]));
}
}
}
Conclusion
Dans cet article, vous avez appris à implémenter les invitations d’applications de Google dans votre application, à l’aide du plug-in de services Google Play. Cet outil vous permet d’augmenter l’audience de votre application en permettant aux utilisateurs d’envoyer des invitations à leurs contacts Google. Vous devriez maintenant être en mesure de développer un système de référence en tirant parti des invitations d’applications, permettant à vos utilisateurs de recommander votre application à leurs amis à l’aide d’invitations contextuelles personnalisées.
