Comment implémenter la fonction Rate It dans une application Android

Question

Je suis en train de développer une application Android. Dans laquelle tout fonctionne correctement. Mon application est prête à être lancée. Mais là, j'ai besoin d'implémenter une fonctionnalité supplémentaire. J'ai besoin d'afficher une popup qui contient

Rate It y Remind me later

Ici, si un utilisateur évalue l'application sur le marché, le popup ne disparaîtra pas. J'ai cherché dans Google et j'en ai trouvé un lien . Avec cela, je comprends que ce n'est pas possible de savoir. J'ai donc besoin d'une suggestion à ce sujet.

Quelqu'un a-t-il déjà été confronté à cette situation ? Si oui, existe-t-il une solution ou une alternative ?

Answer 1

Je l'ai mis en œuvre il y a quelque temps, dans une certaine mesure. Il est impossible de savoir si un utilisateur a noté ou non une application, pour éviter que les notes ne deviennent une monnaie d'échange (certains développeurs pourraient ajouter une option du type "Notez cette application et obtenez gratuitement telle ou telle chose dans l'application").

La classe que j'ai écrite fournit trois boutons et configure le dialogue de manière à ce qu'il ne s'affiche qu'après le lancement de l'application. n Les utilisateurs ont plus de chances d'évaluer l'application s'ils l'ont déjà un peu utilisée. Il est peu probable que la plupart d'entre eux sachent ce qu'elle fait à la première utilisation) :

public class AppRater {
    private final static String APP_TITLE = "App Name";// App Name
    private final static String APP_PNAME = "com.example.name";// Package Name

    private final static int DAYS_UNTIL_PROMPT = 3;//Min number of days
    private final static int LAUNCHES_UNTIL_PROMPT = 3;//Min number of launches

    public static void app_launched(Context mContext) {
        SharedPreferences prefs = mContext.getSharedPreferences("apprater", 0);
        if (prefs.getBoolean("dontshowagain", false)) { return ; }

        SharedPreferences.Editor editor = prefs.edit();

        // Increment launch counter
        long launch_count = prefs.getLong("launch_count", 0) + 1;
        editor.putLong("launch_count", launch_count);

        // Get date of first launch
        Long date_firstLaunch = prefs.getLong("date_firstlaunch", 0);
        if (date_firstLaunch == 0) {
            date_firstLaunch = System.currentTimeMillis();
            editor.putLong("date_firstlaunch", date_firstLaunch);
        }

        // Wait at least n days before opening
        if (launch_count >= LAUNCHES_UNTIL_PROMPT) {
            if (System.currentTimeMillis() >= date_firstLaunch + 
                    (DAYS_UNTIL_PROMPT * 24 * 60 * 60 * 1000)) {
                showRateDialog(mContext, editor);
            }
        }

        editor.commit();
    }   

    public static void showRateDialog(final Context mContext, final SharedPreferences.Editor editor) {
        final Dialog dialog = new Dialog(mContext);
        dialog.setTitle("Rate " + APP_TITLE);

        LinearLayout ll = new LinearLayout(mContext);
        ll.setOrientation(LinearLayout.VERTICAL);

        TextView tv = new TextView(mContext);
        tv.setText("If you enjoy using " + APP_TITLE + ", please take a moment to rate it. Thanks for your support!");
        tv.setWidth(240);
        tv.setPadding(4, 0, 4, 10);
        ll.addView(tv);

        Button b1 = new Button(mContext);
        b1.setText("Rate " + APP_TITLE);
        b1.setOnClickListener(new OnClickListener() {
            public void onClick(View v) {
                mContext.startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse("market://details?id=" + APP_PNAME)));
                dialog.dismiss();
            }
        });        
        ll.addView(b1);

        Button b2 = new Button(mContext);
        b2.setText("Remind me later");
        b2.setOnClickListener(new OnClickListener() {
            public void onClick(View v) {
                dialog.dismiss();
            }
        });
        ll.addView(b2);

        Button b3 = new Button(mContext);
        b3.setText("No, thanks");
        b3.setOnClickListener(new OnClickListener() {
            public void onClick(View v) {
                if (editor != null) {
                    editor.putBoolean("dontshowagain", true);
                    editor.commit();
                }
                dialog.dismiss();
            }
        });
        ll.addView(b3);

        dialog.setContentView(ll);        
        dialog.show();        
    }
}

L'intégration de la classe est aussi simple que l'ajout :

AppRater.app_launched(this);

A votre activité. Il ne doit être ajouté qu'à une seule activité dans toute l'application.

Answer 2

Le mien utilise DialogFragment :

public class RateItDialogFragment extends DialogFragment {
    private static final int LAUNCHES_UNTIL_PROMPT = 10;
    private static final int DAYS_UNTIL_PROMPT = 3;
    private static final int MILLIS_UNTIL_PROMPT = DAYS_UNTIL_PROMPT * 24 * 60 * 60 * 1000;
    private static final String PREF_NAME = "APP_RATER";
    private static final String LAST_PROMPT = "LAST_PROMPT";
    private static final String LAUNCHES = "LAUNCHES";
    private static final String DISABLED = "DISABLED";

    public static void show(Context context, FragmentManager fragmentManager) {
        boolean shouldShow = false;
        SharedPreferences sharedPreferences = getSharedPreferences(context);
        SharedPreferences.Editor editor = sharedPreferences.edit();
        long currentTime = System.currentTimeMillis();
        long lastPromptTime = sharedPreferences.getLong(LAST_PROMPT, 0);
        if (lastPromptTime == 0) {
            lastPromptTime = currentTime;
            editor.putLong(LAST_PROMPT, lastPromptTime);
        }

        if (!sharedPreferences.getBoolean(DISABLED, false)) {
            int launches = sharedPreferences.getInt(LAUNCHES, 0) + 1;
            if (launches > LAUNCHES_UNTIL_PROMPT) {
                if (currentTime > lastPromptTime + MILLIS_UNTIL_PROMPT) {
                    shouldShow = true;
                }
            }
            editor.putInt(LAUNCHES, launches);
        }

        if (shouldShow) {
            editor.putInt(LAUNCHES, 0).putLong(LAST_PROMPT, System.currentTimeMillis()).commit();
            new RateItDialogFragment().show(fragmentManager, null);
        } else {
            editor.commit();
        }
    }

    private static SharedPreferences getSharedPreferences(Context context) {
        return context.getSharedPreferences(PREF_NAME, 0);
    }

    @Override
    public Dialog onCreateDialog(Bundle savedInstanceState) {
        return new AlertDialog.Builder(getActivity())
                .setTitle(R.string.rate_title)
                .setMessage(R.string.rate_message)
                .setPositiveButton(R.string.rate_positive, new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                        startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse("market://details?id=" + getActivity().getPackageName())));
                        getSharedPreferences(getActivity()).edit().putBoolean(DISABLED, true).commit();
                        dismiss();
                    }
                })
                .setNeutralButton(R.string.rate_remind_later, new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                        dismiss();
                    }
                })
                .setNegativeButton(R.string.rate_never, new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                        getSharedPreferences(getActivity()).edit().putBoolean(DISABLED, true).commit();
                        dismiss();
                    }
                }).create();
    }
}

Utilisez-le ensuite dans onCreate() de votre FragmentActivity principale :

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    ...

    RateItDialogFragment.show(this, getFragmentManager());

}

Answer 3

Solution Java & Kotlin (API de révision in-app par Google en 2020) :

D'abord, dans votre build.gradle(app) ajoutez les dépendances suivantes (installation complète aquí )

dependencies {
    // This dependency is downloaded from the Google’s Maven repository.
    // So, make sure you also include that repository in your project's build.gradle file.
    implementation 'com.google.android.play:core:1.8.0'
}

Ajoutez cette méthode à votre Activity :

void askRatings() {
    ReviewManager manager = ReviewManagerFactory.create(this);
    Task<ReviewInfo> request = manager.requestReviewFlow();
    request.addOnCompleteListener(task -> {
        if (task.isSuccessful()) {
            // We can get the ReviewInfo object
            ReviewInfo reviewInfo = task.getResult();
            Task<Void> flow = manager.launchReviewFlow(this, reviewInfo);
            flow.addOnCompleteListener(task2 -> {
                // The flow has finished. The API does not indicate whether the user
                // reviewed or not, or even whether the review dialog was shown. Thus, no
                // matter the result, we continue our app flow.
            });
        } else {
            // There was some problem, continue regardless of the result.
        }
    });
}

Appelez-la comme n'importe quelle autre méthode :

askRatings();

---

Le code Kotlin peut être trouvé aquí

Answer 4

Je pense que ce que vous essayez de faire est probablement contre-productif.

Faciliter l'évaluation des applications est généralement une bonne idée, car la plupart des personnes qui s'en donnent la peine le font parce qu'elles aiment l'application. La rumeur veut que le nombre d'évaluations influe sur votre cote de marché (bien que je n'en voie pas la preuve). Le fait de harceler les utilisateurs pour qu'ils évaluent - par le biais d'écrans de harcèlement - est susceptible d'inciter les gens à se débarrasser du harcèlement en laissant une mauvaise évaluation.

L'ajout de la possibilité de noter directement une application a entraîné une légère diminution des notes numériques pour ma version gratuite, et une légère augmentation pour mon application payante. Pour l'application gratuite, mes notes 4 étoiles ont augmenté plus que mes notes 5 étoiles, car les personnes qui trouvaient mon application bonne mais pas géniale ont commencé à la noter également. Le changement a été d'environ -0,2. Pour la version payante, le changement était d'environ +0,1. Je devrais le supprimer de la version gratuite, sauf que j'aime recevoir beaucoup de commentaires.

J'ai placé mon bouton d'évaluation dans un écran de paramètres (préférences), où il n'affecte pas le fonctionnement normal. Cela a quand même augmenté mon taux d'évaluation par un facteur de 4 ou 5. Je ne doute pas que si j'essayais de pousser mes utilisateurs à faire une évaluation, ils seraient nombreux à me donner de mauvaises évaluations en guise de protestation.

Answer 5

AndroidRate est une bibliothèque qui vous aide à promouvoir votre application Android en invitant les utilisateurs à évaluer l'application après l'avoir utilisée pendant quelques jours.

Module Gradle :

dependencies {
  implementation 'com.vorlonsoft:androidrate:1.0.8'
}

MainActivity.java :

@Override
protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.activity_main);

  AppRate.with(this)
      .setStoreType(StoreType.GOOGLEPLAY) //default is GOOGLEPLAY (Google Play), other options are
                                          //           AMAZON (Amazon Appstore) and
                                          //           SAMSUNG (Samsung Galaxy Apps)
      .setInstallDays((byte) 0) // default 10, 0 means install day
      .setLaunchTimes((byte) 3) // default 10
      .setRemindInterval((byte) 2) // default 1
      .setRemindLaunchTimes((byte) 2) // default 1 (each launch)
      .setShowLaterButton(true) // default true
      .setDebug(false) // default false
      //Java 8+: .setOnClickButtonListener(which -> Log.d(MainActivity.class.getName(), Byte.toString(which)))
      .setOnClickButtonListener(new OnClickButtonListener() { // callback listener.
          @Override
          public void onClickButton(byte which) {
              Log.d(MainActivity.class.getName(), Byte.toString(which));
          }
      })
      .monitor();

  if (AppRate.with(this).getStoreType() == StoreType.GOOGLEPLAY) {
      //Check that Google Play is available
      if (GoogleApiAvailability.getInstance().isGooglePlayServicesAvailable(this) != ConnectionResult.SERVICE_MISSING) {
          // Show a dialog if meets conditions
          AppRate.showRateDialogIfMeetsConditions(this);
      }
  } else {
      // Show a dialog if meets conditions
      AppRate.showRateDialogIfMeetsConditions(this);
  }
}

Les conditions par défaut pour afficher le dialogue de taux sont les suivantes :

1. L'application est lancée plus de 10 jours après l'installation. Changement via AppRate#setInstallDays(byte) .
2. L'application est lancée plus de 10 fois. Changement via AppRate#setLaunchTimes(byte) .
3. L'application est lancée plus d'un jour après le clic sur le bouton neutre. Changement via AppRate#setRemindInterval(byte) .
4. L'application est lancée X fois et X % 1 = 0. Changement via AppRate#setRemindLaunchTimes(byte) .
5. L'application affiche un dialogue neutre (Remind me later) par défaut. Changement via setShowLaterButton(boolean) .
6. Pour spécifier le rappel lorsque le bouton est pressé. La même valeur que le deuxième argument de DialogInterface.OnClickListener#onClick sera passé dans l'argument de onClickButton .
7. Réglage de AppRate#setDebug(boolean) permettra de s'assurer que la demande de classement s'affiche à chaque fois que l'application est lancée. Cette fonctionnalité est uniquement destinée au développement ! .

Exigences relatives aux événements personnalisés facultatifs pour l'affichage du dialogue

Vous pouvez ajouter des exigences supplémentaires facultatives pour l'affichage du dialogue. Chaque exigence peut être ajoutée/référencée comme une chaîne unique. Vous pouvez définir un nombre minimum pour chacun de ces événements (par exemple, "action_performed" 3 fois, "button_clicked" 5 fois, etc.).

AppRate.with(this).setMinimumEventCount(String, short);
AppRate.with(this).incrementEventCount(String);
AppRate.with(this).setEventCountValue(String, short);

Effacer le drapeau de dialogue d'affichage

Lorsque vous voulez afficher à nouveau la boîte de dialogue, appelez AppRate#clearAgreeShowDialog() .

AppRate.with(this).clearAgreeShowDialog();

Lorsque le bouton appuie sur

appelez AppRate#showRateDialog(Activity) .

AppRate.with(this).showRateDialog(this);

Définir une vue personnalisée

appelez AppRate#setView(View) .

LayoutInflater inflater = (LayoutInflater)this.getSystemService(LAYOUT_INFLATER_SERVICE);
View view = inflater.inflate(R.layout.custom_dialog, (ViewGroup)findViewById(R.id.layout_root));
AppRate.with(this).setView(view).monitor();

Thème spécifique

Vous pouvez utiliser un thème spécifique pour gonfler le dialogue.

AppRate.with(this).setThemeResId(int);

Dialogue personnalisé

Si vous souhaitez utiliser vos propres étiquettes de dialogue, remplacez les ressources string xml dans votre application.

<resources>
    <string name="rate_dialog_title">Rate this app</string>
    <string name="rate_dialog_message">If you enjoy playing this app, would you mind taking a moment to rate it? It won\'t take more than a minute. Thanks for your support!</string>
    <string name="rate_dialog_ok">Rate It Now</string>
    <string name="rate_dialog_cancel">Remind Me Later</string>
    <string name="rate_dialog_no">No, Thanks</string>
</resources>

Vérifiez que Google Play est disponible

if (GoogleApiAvailability.getInstance().isGooglePlayServicesAvailable(this) != ConnectionResult.SERVICE_MISSING) {

}