एंड्रॉइड ऐप में रेट इट सुविधा कैसे लागू करें

Question

मैं एक Android ऐप विकसित कर रहा हूं। जिसमें सब कुछ सही काम कर रहा है। मेरा ऐप लॉन्च करने के लिए तैयार है। लेकिन वहां मुझे एक और फीचर लागू करने की जरूरत है। मुझे एक पॉपअप प्रदर्शित करना होगा जिसमें सम्‍मिलित हो

Rate It तथा Remind me later

यहां यदि कोई उपयोगकर्ता बाजार में ऐप को रेट करता है तो पॉपअप गायब नहीं होगा। मैंने Google में खोजा है और एक लिंक पाया है । इससे मैं समझता हूं कि इसका पता संभव नहीं है। इसलिए मुझे इसके लिए एक सुझाव की आवश्यकता है।

क्या इससे पहले किसी को इस स्थिति का सामना करना पड़ा है? यदि हां, तो क्या इसके लिए कोई समाधान या कोई विकल्प है?

Comments

तो क्या आप इसे रेट करने के लिए कह रहे हैं / बाद में मुझे याद दिलाएं या क्या आप यह जानना चाहते हैं कि किसी विशिष्ट उपयोगकर्ता ने एंड्रॉइड ऐप का मूल्यांकन किया है या नहीं?

— वत्संग ०२

मैंने पॉपअप लागू किया है। लेकिन यह कैसे पता चलेगा कि कोई उपयोगकर्ता ऐप को रेट करता है या नहीं

— नवीन

-1 मुझे इस प्रश्न और लिंक में एक के बीच का अंतर नहीं दिखता है।

— wtsang02

@ wtsang02, हो सकता है कि यह सच हो। लेकिन सवाल देखिए। इस पर पूछा Mar 15 2011। तो लगभग 20 महीने खत्म। मुझे लगता है कि किसी एक के पास मेरी आवश्यकता का समाधान या विकल्प है। वह यहाँ तैनात है।

— नवीन

आप पुस्तकालय का उपयोग कर सकते हैं github.com/Vorlonsoft/AndroidRate ( implementation 'com.vorlonsoft:androidrate:1.0.3')

— अलेक्जेंडर सविन

Answer 1

मैंने कुछ समय पहले इसे लागू किया था। यह जानना असंभव है कि उपयोगकर्ता ने एक ऐप का मूल्यांकन किया है या नहीं, रेटिंग्स को मुद्रा बनने से रोकने के लिए (कुछ डेवलपर्स "इस ऐप को रेट करें और ऐप में मुफ्त में ऐसा करें और प्राप्त करें" जैसे विकल्प जोड़ सकते हैं)।

जिस कक्षा में मैंने लिखा था वह तीन बटन प्रदान करता है, और संवाद को कॉन्फ़िगर करता है ताकि यह केवल ऐप को लॉन्च किए जाने के बाद दिखाया जाए n(उपयोगकर्ताओं के पास ऐप को रेटिंग करने का एक उच्च मौका है यदि उन्होंने इसे पहले इस्तेमाल किया है। उनमें से अधिकांश संभावना नहीं है। यह जानने के लिए कि यह पहले रन पर क्या करता है):

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();        
    }
}

कक्षा को जोड़ना उतना ही सरल है जितना कि जोड़ना:

AppRater.app_launched(this);

आपकी गतिविधि के लिए। इसे संपूर्ण ऐप में केवल एक गतिविधि में जोड़ा जाना चाहिए।

Comments

यह एक ही डिवाइस का उपयोग कर कई उपयोगकर्ताओं का समर्थन नहीं करता है।

— AsafK

@AsafK हां, लेकिन एक ही डिवाइस का उपयोग करने वाले कई उपयोगकर्ताओं को केवल appraterप्रमाणीकरण के बाद संवाद दिखाने और shared preferenceGoogle ईमेल पते को इसमें शामिल करने के लिए बदलकर नियंत्रित किया जा सकता है key।

— स्टीफन

नमस्ते, मेरा सिर्फ एक सवाल है। आपने सब कुछ स्थिर क्यों किया? धन्यवाद राघव!

— रुचिर बारोनिया

नमस्ते, मैं आपके उपरोक्त कोड की कोशिश कर रहा हूं। मैंने AppRater.app_launched(this);अपने onCreate()मेनऐक्टिविटी के अंदर डाल दिया है । मैंने भी आवश्यक न्यूनतम 2 लॉन्च लॉन्च किए हैं। लेकिन, मैं 2 ऐप लॉन्च के बाद संवाद नहीं देख रहा हूं। क्या तुम मेरी मदद कर सकते हो? धन्यवाद!

— अपवाद

बेहतर enum का उपयोग Context.MODE_PRIVATE-context.getSharedPreferences("apprater", Context.MODE_PRIVATE);

— विवेक

Answer 2

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();
    }
}

फिर onCreate()अपने मुख्य FragmentActivity में इसका उपयोग करें :

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

    RateItDialogFragment.show(this, getFragmentManager());

}

Comments

अच्छा था! मैं सिर्फ DialogFragment दिखाने से पहले Editor.commit () लगा दूंगा जब डायलॉग लोड करते समय कुछ गलत हो जाता है।

— नार्को

@narko धन्यवाद। अपडेट किया गया।

— मिश्रण

नोट: यदि आप साझा प्राथमिकता को सहेजने के लिए आवेदन करने के लिए उपयोग करते हैं तो यह मेमोरी रिसाव को जन्म दे सकता है। यदि आप में ध्यान से नोटिस setPositiveButtonऔर setNegativeButton, यह प्रतिबद्ध का उपयोग करके साझा वरीयताओं लिए लिख रहा है, लेकिन आप होता है कि कौन async है और जब तक यह compleats करेंगे और उसके बाद कि इसे खारिज बुला रहा है गतिविधि के संदर्भ रखेंगे का उपयोग करें। बर्खास्तगी को नष्ट करने की कोशिश करेंगे, लेकिन यह इसलिए नहीं हो सकता क्योंकि गतिविधि को साझा प्राथमिकता लागू प्रक्रिया द्वारा आयोजित / उपयोग किया जाता है (मैंने इसे पहना था क्योंकि AndroidStudio उपयोगकर्ता को लागू करने के लिए बदलने के लिए संकेत देगा, जब तक आप ऐसा न करें। कुछ अन्य तर्क का उपयोग करें)

— साईं

@mixel गतिविधि में और खंड के बिना उपयोग करने में सक्षम होने के लिए कोड को कैसे संशोधित किया जाए?

— user1090751

Answer 3

मुझे लगता है कि आप जो करने की कोशिश कर रहे हैं वह संभवत: प्रति-उत्पादक है।

ऐप्स को रेट करना लोगों के लिए आसान बनाना आम तौर पर एक अच्छा विचार है, क्योंकि ज्यादातर लोग जो परेशान करते हैं, क्योंकि वे ऐप को पसंद करते हैं। यह अफवाह है कि रेटिंग की संख्या आपकी बाजार रेटिंग को प्रभावित करती है (हालांकि मुझे इसके बहुत कम प्रमाण मिलते हैं)। उपयोगकर्ताओं को रेटिंग में परेशान करना - नाग स्क्रीन के माध्यम से - लोगों को खराब रेटिंग छोड़ने के माध्यम से नाग को साफ करने की संभावना है।

किसी ऐप को सीधे रेट करने की क्षमता को जोड़ने से मेरे मुफ्त संस्करण के लिए संख्यात्मक रेटिंग में थोड़ी कमी आई है, और मेरे भुगतान किए गए ऐप में थोड़ी वृद्धि हुई है। मुफ्त ऐप के लिए, मेरी 4 स्टार रेटिंग मेरी 5 स्टार रेटिंग से अधिक बढ़ गई, क्योंकि जिन लोगों ने सोचा था कि मेरा ऐप अच्छा था, लेकिन महान ने इसे रेट करना शुरू नहीं किया। परिवर्तन -0.2 के बारे में था। भुगतान के लिए, परिवर्तन +0.1 के बारे में था। मुझे इसे नि: शुल्क संस्करण से हटा देना चाहिए, इसके अलावा मुझे बहुत सारी टिप्पणियां प्राप्त करना पसंद हैं।

मैंने अपने रेटिंग बटन को सेटिंग्स (वरीयता) स्क्रीन में डाला, जहां यह सामान्य ऑपरेशन को प्रभावित नहीं करता है। इसने मेरी रेटिंग दर को 4 या 5 के कारक से बढ़ा दिया। मुझे इसमें कोई संदेह नहीं है कि अगर मैंने अपने उपयोगकर्ताओं को रेटिंग बनाने में नाकाम करने की कोशिश की, तो मुझे विरोध के रूप में बहुत सारे उपयोगकर्ता मिलेंगे।

Comments

100% सच है। यही बात मेरे फ्री ऐप के साथ भी हुई।

— आकाश वरलानी

Answer 4

AndroidRate कुछ दिनों के लिए उपयोग करने के बाद उपयोगकर्ताओं को ऐप को रेट करने के लिए प्रेरित करके अपने एंड्रॉइड ऐप को बढ़ावा देने में मदद करने के लिए एक पुस्तकालय है।

मॉड्यूल ग्रेड:

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);
  }
}

रेट डायलॉग दिखाने के लिए डिफ़ॉल्ट शर्तें निम्नानुसार हैं:

1. ऐप को इंस्टॉलेशन की तुलना में 10 दिन बाद लॉन्च किया जाता है। के माध्यम से बदलेंAppRate#setInstallDays(byte) ।
2. ऐप को 10 से अधिक बार लॉन्च किया गया है। के माध्यम से बदलेंAppRate#setLaunchTimes(byte) ।
3. तटस्थ बटन पर क्लिक करने के 1 दिन बाद ऐप लॉन्च किया गया है। के माध्यम से बदलेंAppRate#setRemindInterval(byte) ।
4. ऐप को X बार और X% 1 = 0. के माध्यम से लॉन्च किया गया है AppRate#setRemindLaunchTimes(byte) ।
5. ऐप डिफ़ॉल्ट रूप से तटस्थ संवाद (मुझे बाद में याद दिलाएं) दिखाता है। के माध्यम से बदलेंsetShowLaterButton(boolean) ।
6. बटन दबाए जाने पर कॉलबैक को निर्दिष्ट करने के लिए। के तर्क में दूसरे मान के समान मान DialogInterface.OnClickListener#onClickदिया जाएगाonClickButton ।
7. सेटिंग AppRate#setDebug(boolean)यह सुनिश्चित करेगी कि हर बार ऐप लॉन्च होने पर रेटिंग अनुरोध दिखाया जाए। यह सुविधा केवल विकास के लिए है! ।

संवाद दिखाने के लिए वैकल्पिक कस्टम इवेंट आवश्यकताएँ

आप डायलॉग दिखाने के लिए अतिरिक्त वैकल्पिक आवश्यकताएं जोड़ सकते हैं। प्रत्येक आवश्यकता को एक अद्वितीय स्ट्रिंग के रूप में जोड़ा / संदर्भित किया जा सकता है। आप इस तरह के प्रत्येक ईवेंट के लिए एक न्यूनतम गणना सेट कर सकते हैं (उदाहरण के लिए "एक्शन_परफॉर्मेड" 3 बार, "बटन_क्लिप्ड" 5 बार, आदि)

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

क्लियर शो डायलॉग झंडा

जब आप फिर से संवाद दिखाना चाहते हैं, तो कॉल करें AppRate#clearAgreeShowDialog()।

AppRate.with(this).clearAgreeShowDialog();

जब बटन दबाता है

बुलाओ AppRate#showRateDialog(Activity)।

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

कस्टम दृश्य सेट करें

बुलाओ 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();

विशिष्ट विषय

आप संवाद को बढ़ाने के लिए एक विशिष्ट विषय का उपयोग कर सकते हैं।

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

कस्टम संवाद

यदि आप अपने स्वयं के संवाद लेबल का उपयोग करना चाहते हैं, तो अपने आवेदन पर स्ट्रिंग xml संसाधनों को ओवरराइड करें।

<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>

जांचें कि Google Play उपलब्ध है

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

}

Answer 5

इस लाइब्रेरी का उपयोग करें, यह सरल और आसान है .. https://github.com/hotchemi/Android-Rate

निर्भरता जोड़कर ।।

dependencies {
  compile 'com.github.hotchemi:android-rate:0.5.6'
}

Comments

आप लाइब्रेरी github.com/Vorlonsoft/AndroidRate ( implementation 'com.vorlonsoft:androidrate:1.0.3') का उपयोग कर सकते हैं । यह आज तक है।

— अलेक्जेंडर सविन

Answer 6

यह समाधान ऊपर प्रस्तुत किए गए लोगों के समान है। अंतर केवल इतना है कि आप लॉन्च और दिनों के अनुसार रेटिंग डायलॉग के संकेत में देरी करने में सक्षम होने जा रहे हैं। अगर बाद में याद दिलाने वाला बटन दबाया जाता है, तो मैं 3 दिन और 10 लॉन्च के लिए पॉप अप में देरी करूंगा। वही उन लोगों के लिए किया जाता है जिन्होंने इसे रेट करने के लिए चुना है, हालांकि देरी अधिक लंबी है (उपयोगकर्ता को इतनी जल्दी परेशान करने की स्थिति में नहीं है कि उसने वास्तव में ऐप को रेट किया है। इसे फिर से नहीं दिखाया जा सकता है, फिर आपको बदलना होगा। अपनी पसंद के अनुसार कोड बदलें)। आशा है कि यह किसी की मदद करता है!

public class AppRater {
    private final static String APP_TITLE = "your_app_name";
    private static String PACKAGE_NAME = "your_package_name";
    private static int DAYS_UNTIL_PROMPT = 5;
    private static int LAUNCHES_UNTIL_PROMPT = 10;
    private static long EXTRA_DAYS;
    private static long EXTRA_LAUCHES;
    private static SharedPreferences prefs;
    private static SharedPreferences.Editor editor;
    private static Activity activity;

    public static void app_launched(Activity activity1) {
        activity = activity1;

        Configs.sendScreenView("Avaliando App", activity);

        PACKAGE_NAME = activity.getPackageName();

        prefs = activity.getSharedPreferences("apprater", Context.MODE_PRIVATE);
        if (prefs.getBoolean("dontshowagain", false)) 
            return;

        editor = prefs.edit();

        EXTRA_DAYS = prefs.getLong("extra_days", 0);
        EXTRA_LAUCHES = prefs.getLong("extra_launches", 0);

        // 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 + EXTRA_LAUCHES))
            if (System.currentTimeMillis() >= date_firstLaunch + (DAYS_UNTIL_PROMPT * 24 * 60 * 60 * 1000) + EXTRA_DAYS)
                showRateDialog();

        editor.commit();
    }   

    public static void showRateDialog() {
        final Dialog dialog = new Dialog(activity);
        dialog.setTitle("Deseja avaliar o aplicativo " + APP_TITLE + "?");

        LinearLayout ll = new LinearLayout(activity);
        ll.setOrientation(LinearLayout.VERTICAL);
        ll.setPadding(5, 5, 5, 5);

        TextView tv = new TextView(activity);
        tv.setTextColor(activity.getResources().getColor(R.color.default_text));
        tv.setText("Ajude-nos a melhorar o aplicativo com sua avaliação no Google Play!");
        tv.setWidth(240);
        tv.setGravity(Gravity.CENTER);
        tv.setPadding(5, 5, 5, 5);
        ll.addView(tv);

        Button b1 = new Button(activity);
        b1.setTextColor(activity.getResources().getColor(R.color.default_text));
        b1.setBackground(activity.getResources().getDrawable(R.drawable.rounded_blue_box));
        b1.setTextColor(Color.WHITE);
        b1.setText("Avaliar aplicativo " + APP_TITLE + "!");
        b1.setOnClickListener(new OnClickListener() {
            public void onClick(View v) {
                Configs.sendHitEvents(Configs.APP_RATER, Configs.CATEGORIA_ANALYTICS, "Clique", "Avaliar", activity);

                activity.startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse("market://details?id=" + PACKAGE_NAME)));
                delayDays(60);
                delayLaunches(30);
                dialog.dismiss();
            }
        });        
        ll.addView(b1);
        LinearLayout.LayoutParams params = (LinearLayout.LayoutParams) b1.getLayoutParams();
        params.setMargins(5, 3, 5, 3);
        b1.setLayoutParams(params);

        Button b2 = new Button(activity);
        b2.setTextColor(activity.getResources().getColor(R.color.default_text));
        b2.setBackground(activity.getResources().getDrawable(R.drawable.rounded_blue_box));
        b2.setTextColor(Color.WHITE);
        b2.setText("Lembre-me mais tarde!");
        b2.setOnClickListener(new OnClickListener() {
            public void onClick(View v) {
                Configs.sendHitEvents(Configs.APP_RATER, Configs.CATEGORIA_ANALYTICS, "Clique", "Avaliar Mais Tarde", activity);
                delayDays(3);
                delayLaunches(10);
                dialog.dismiss();
            }
        });
        ll.addView(b2);
        params = (LinearLayout.LayoutParams) b2.getLayoutParams();
        params.setMargins(5, 3, 5, 3);
        b2.setLayoutParams(params);

        Button b3 = new Button(activity);
        b3.setTextColor(activity.getResources().getColor(R.color.default_text));
        b3.setBackground(activity.getResources().getDrawable(R.drawable.rounded_blue_box));
        b3.setTextColor(Color.WHITE);
        b3.setText("Não, obrigado!");
        b3.setOnClickListener(new OnClickListener() {
            public void onClick(View v) {
                Configs.sendHitEvents(Configs.APP_RATER, Configs.CATEGORIA_ANALYTICS, "Clique", "Não Avaliar", activity);

                if (editor != null) {
                    editor.putBoolean("dontshowagain", true);
                    editor.commit();
                }
                dialog.dismiss();
            }
        });
        ll.addView(b3);
        params = (LinearLayout.LayoutParams) b3.getLayoutParams();
        params.setMargins(5, 3, 5, 0);
        b3.setLayoutParams(params);

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

    private static void delayLaunches(int numberOfLaunches) {
        long extra_launches = prefs.getLong("extra_launches", 0) + numberOfLaunches;
        editor.putLong("extra_launches", extra_launches);
        editor.commit();
    }

    private static void delayDays(int numberOfDays) {
        Long extra_days = prefs.getLong("extra_days", 0) + (numberOfDays * 1000 * 60 * 60 * 24);
        editor.putLong("extra_days", extra_days);
        editor.commit();
    }
}

बटन में एक विशिष्ट रंग और पृष्ठभूमि होती है। पृष्ठभूमि को इस xml फ़ाइल में दिखाया गया है:

<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android"
    android:padding="10dp"
    android:shape="rectangle" >

    <solid android:color="#2E78B9" />

    <corners
        android:bottomLeftRadius="6dp"
        android:bottomRightRadius="6dp"
        android:topLeftRadius="6dp"
        android:topRightRadius="6dp" />

</shape>

स्रोत: "मेरे आवेदन की दर" के लिए Android दृष्टिकोण

Comments

"कन्फिग्स" क्या है यह मुझे नहीं मिला जब मैं कोशिश करता हूं।

— एमडी इमरान चौधरी

@ Md.ImranChoudhury देर से उत्तर के लिए क्षमा करें। कॉन्फ़िगरेशन मेरा एक निजी वर्ग है जिसका उपयोग मैं Google विश्लेषिकी के लिए करता हूं। आप सिर्फ एक समस्या के बिना उस बयान को हटा सकते हैं!

— गुस्तावो बायोची कोस्टा सेप

आपको या तो मूल उत्तर से लिंक करना चाहिए या उसे क्रेडिट देना चाहिए। stackoverflow.com/a/6920848/563735

— रोहित मंडीवाल

Answer 7

मैं इस आसान उपाय का उपयोग कर रहा हूं। आप बस इस लाइब्रेरी को ग्रेडेल के साथ जोड़ सकते हैं: https://github.com/fernandodev/easy-rating-dialog

compile 'com.github.fernandodev.easyratingdialog:easyratingdialog:+'

Answer 8

जैसा कि आप अपने द्वारा लिंक किए गए अन्य पोस्ट से देखते हैं, ऐप में यह जानने का कोई तरीका नहीं है कि उपयोगकर्ता ने समीक्षा छोड़ दी है या नहीं। और अच्छे कारण के लिए।

इसके बारे में सोचें, अगर कोई ऐप बता सकता है कि उपयोगकर्ता ने कोई समीक्षा छोड़ दी है या नहीं, तो डेवलपर कुछ विशेषताओं को प्रतिबंधित कर सकता है जो केवल तभी अनलॉक हो पाएंगे जब उपयोगकर्ता 5/5 रेटिंग छोड़ता है। यह Google Play के अन्य उपयोगकर्ताओं को समीक्षाओं पर भरोसा न करने और रेटिंग प्रणाली को कमजोर करने का नेतृत्व करेगा।

वैकल्पिक समाधान जो मैंने देखा है वह यह है कि ऐप उपयोगकर्ता को जब भी ऐप को एक विशिष्ट संख्या, या एक निर्धारित अंतराल में खोला जाता है, एक रेटिंग जमा करने की याद दिलाता है। उदाहरण के लिए, प्रत्येक 10 वें समय पर ऐप खोला जाता है, उपयोगकर्ता को एक रेटिंग छोड़ने और "पहले से किया हुआ" और "बाद में" बटन को याद दिलाने के लिए कहें। यदि उपयोगकर्ता ने उसे बाद में याद दिलाने के लिए चुना है, तो यह संदेश दिखाते रहें। कुछ अन्य ऐप डेवलपर बढ़ते अंतराल के साथ इस संदेश को दिखाते हैं (जैसे, 5, 10, 15 वीं बार ऐप को खोला जाता है), क्योंकि अगर किसी उपयोगकर्ता ने समीक्षा नहीं छोड़ी है, उदाहरण के लिए, 100 वीं बार ऐप को खोला गया था, यह शायद संभावना है कि वह एक नहीं छोड़ रहा है।

यह समाधान सही नहीं है, लेकिन मुझे लगता है कि यह आपके लिए सबसे अच्छा है। यह आपको उपयोगकर्ता पर भरोसा करने के लिए प्रेरित करता है, लेकिन यह महसूस करता है कि विकल्प का अर्थ ऐप बाजार में सभी के लिए संभावित रूप से बदतर अनुभव होगा।

Answer 9

जावा और कोटलिन समाधान (2020 में Google द्वारा इन-ऐप समीक्षा एपीआई):

सबसे पहले, अपनी build.gradle(app)फ़ाइल में, निम्न निर्भरताएँ जोड़ें ( यहाँ पूरा सेटअप )

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'
}

इस विधि को अपने में जोड़ें 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.
        }
    });
}

इसे किसी अन्य विधि की तरह कहें:

askRatings();

---

कोटलिन कोड यहां पाया जा सकता है

Answer 10

राघव सूद के जवाब का कोटलिन संस्करण

Rater.kt

    class Rater {
      companion object {
        private const val APP_TITLE = "App Name"
        private const val APP_NAME = "com.example.name"

        private const val RATER_KEY = "rater_key"
        private const val LAUNCH_COUNTER_KEY = "launch_counter_key"
        private const val DO_NOT_SHOW_AGAIN_KEY = "do_not_show_again_key"
        private const val FIRST_LAUNCH_KEY = "first_launch_key"

        private const val DAYS_UNTIL_PROMPT: Int = 3
        private const val LAUNCHES_UNTIL_PROMPT: Int = 3

        fun start(mContext: Context) {
            val prefs: SharedPreferences = mContext.getSharedPreferences(RATER_KEY, 0)
            if (prefs.getBoolean(DO_NOT_SHOW_AGAIN_KEY, false)) {
                return
            }

            val editor: Editor = prefs.edit()

            val launchesCounter: Long = prefs.getLong(LAUNCH_COUNTER_KEY, 0) + 1;
            editor.putLong(LAUNCH_COUNTER_KEY, launchesCounter)

            var firstLaunch: Long = prefs.getLong(FIRST_LAUNCH_KEY, 0)
            if (firstLaunch == 0L) {
                firstLaunch = System.currentTimeMillis()
                editor.putLong(FIRST_LAUNCH_KEY, firstLaunch)
            }

            if (launchesCounter >= LAUNCHES_UNTIL_PROMPT) {
                if (System.currentTimeMillis() >= firstLaunch +
                    (DAYS_UNTIL_PROMPT * 24 * 60 * 60 * 1000)
                ) {
                    showRateDialog(mContext, editor)
                }
            }

            editor.apply()
        }

        fun showRateDialog(mContext: Context, editor: Editor) {
            Dialog(mContext).apply {
                setTitle("Rate $APP_TITLE")

                val ll = LinearLayout(mContext)
                ll.orientation = LinearLayout.VERTICAL

                TextView(mContext).apply {
                    text =
                        "If you enjoy using $APP_TITLE, please take a moment to rate it. Thanks for your support!"

                    width = 240
                    setPadding(4, 0, 4, 10)
                    ll.addView(this)
                }

                Button(mContext).apply {
                    text = "Rate $APP_TITLE"
                    setOnClickListener {
                        mContext.startActivity(
                            Intent(
                                Intent.ACTION_VIEW,
                                Uri.parse("market://details?id=$APP_NAME")
                            )
                        );
                        dismiss()
                    }
                    ll.addView(this)
                }

                Button(mContext).apply {
                    text = "Remind me later"
                    setOnClickListener {
                        dismiss()
                    };
                    ll.addView(this)
                }

                Button(mContext).apply {
                    text = "No, thanks"
                    setOnClickListener {
                        editor.putBoolean(DO_NOT_SHOW_AGAIN_KEY, true);
                        editor.commit()
                        dismiss()
                    };
                    ll.addView(this)
                }

                setContentView(ll)
                show()
            }
        }
    }
}

अनुकूलित उत्तर

Rater.kt

class Rater {
    companion object {
        fun start(context: Context) {
            val prefs: SharedPreferences = context.getSharedPreferences(RATER_KEY, 0)
            if (prefs.getBoolean(DO_NOT_SHOW_AGAIN_KEY, false)) {
                return
            }

            val editor: Editor = prefs.edit()

            val launchesCounter: Long = prefs.getLong(LAUNCH_COUNTER_KEY, 0) + 1;
            editor.putLong(LAUNCH_COUNTER_KEY, launchesCounter)

            var firstLaunch: Long = prefs.getLong(FIRST_LAUNCH_KEY, 0)
            if (firstLaunch == 0L) {
                firstLaunch = System.currentTimeMillis()
                editor.putLong(FIRST_LAUNCH_KEY, firstLaunch)
            }

            if (launchesCounter >= LAUNCHES_UNTIL_PROMPT) {
                if (System.currentTimeMillis() >= firstLaunch +
                    (DAYS_UNTIL_PROMPT * 24 * 60 * 60 * 1000)
                ) {
                    showRateDialog(context, editor)
                }
            }

            editor.apply()
        }

        fun showRateDialog(context: Context, editor: Editor) {
            Dialog(context).apply {
                setTitle("Rate $APP_TITLE")
                LinearLayout(context).let { layout ->
                    layout.orientation = LinearLayout.VERTICAL
                    setDescription(context, layout)
                    setPositiveAnswer(context, layout)
                    setNeutralAnswer(context, layout)
                    setNegativeAnswer(context, editor, layout)
                    setContentView(layout)
                    show()       
                }
            }
        }

        private fun setDescription(context: Context, layout: LinearLayout) {
            TextView(context).apply {
                text = context.getString(R.string.rate_description, APP_TITLE)
                width = 240
                setPadding(4, 0, 4, 10)
                layout.addView(this)
            }
        }

        private fun Dialog.setPositiveAnswer(
            context: Context,
            layout: LinearLayout
        ) {
            Button(context).apply {
                text = context.getString(R.string.rate_now)
                setOnClickListener {
                    context.startActivity(
                        Intent(
                            Intent.ACTION_VIEW,
                            Uri.parse(context.getString(R.string.market_uri, APP_NAME))
                        )
                    );
                    dismiss()
                }
                layout.addView(this)
            }
        }

        private fun Dialog.setNeutralAnswer(
            context: Context,
            layout: LinearLayout
        ) {
            Button(context).apply {
                text = context.getString(R.string.remind_later)
                setOnClickListener {
                    dismiss()
                };
                layout.addView(this)
            }
        }

        private fun Dialog.setNegativeAnswer(
            context: Context,
            editor: Editor,
            layout: LinearLayout
        ) {
            Button(context).apply {
                text = context.getString(R.string.no_thanks)
                setOnClickListener {
                    editor.putBoolean(DO_NOT_SHOW_AGAIN_KEY, true);
                    editor.commit()
                    dismiss()
                };
                layout.addView(this)
            }
        }
    }
}

Constants.kt

object Constants {

    const val APP_TITLE = "App Name"
    const val APP_NAME = "com.example.name"

    const val RATER_KEY = "rater_key"
    const val LAUNCH_COUNTER_KEY = "launch_counter_key"
    const val DO_NOT_SHOW_AGAIN_KEY = "do_not_show_again_key"
    const val FIRST_LAUNCH_KEY = "first_launch_key"

    const val DAYS_UNTIL_PROMPT: Int = 3
    const val LAUNCHES_UNTIL_PROMPT: Int = 3

}

strings.xml

<resources>
    <string name="rate_description">If you enjoy using %1$s, please take a moment to rate it. Thanks for your support!</string>
    <string name="rate_now">Rate now</string>
    <string name="no_thanks">No, thanks</string>
    <string name="remind_later">Remind me later</string>
    <string name="market_uri">market://details?id=%1$s</string>
</resources>