Counting how many times my Android app has been opened

Question

I am developing an android app and I want to know how many times it has been opened. Is there a way to do this?

Answer 1

The problem with using onCreate in an Activity is that this will increment the counter even on orientation changes. Using onCreate in an Application also has a downside in that your counter will only be incremented when after the VM has closed - so even if the app exits and reopens this will not necessarily increment.

The truth is there is no fool-proof method for handling this sort of count, however I have come up with a very good way of doing this, that is about as close to 100% accurate as possible. It requires work in both an Application class and your main Activity class, and relies on timestamps to differentiate between orientation changes and actual app launches. To start, add the following Application class:

/**
 * Application class used for correctly counting the number of times an app has been opened.
 * @author Phil Brown
 * @see <a href="http://stackoverflow.com/a/22228198/763080">Stack Overflow</a>
 *
 */
public class CounterApplication extends Application
{
    private long lastConfigChange;

    /** @param buffer the number of milliseconds required after an orientation change to still be considered the same event*/
    public boolean wasLastConfigChangeRecent(int buffer)
    {
        return (new Date().getTime() - lastConfigChange <= buffer);
    }

    @Override
    public void onCreate()
    {
        lastConfigChange = new Date().getTime();
    }

    @Override
    public void onConfigurationChanged(Configuration newConfig)
    {
        super.onConfigurationChanged(newConfig);
        lastConfigChange = new Date().getTime();
    }
}

You should add this Application to your AndroidManifest.xml by specifying the name application attribute:

android:name="path.to.CounterApplication"

Now, in your main Activity, add the following in onCreate:

//note that you can use getPreferences(MODE_PRIVATE), but this is easier to use from Fragments.
SharedPreferences prefs = getSharedPreferences(getPackageName(), MODE_PRIVATE);

int appOpenedCount = prefs.getInt("app_opened_count", 1);
if (!((CounterApplication) getApplication()).wasLastConfigChangeRecent(10000))//within 10 seconds - a huge buffer
{
    appOpenedCount += 1;
    prefs.edit().putInt("app_opened_count", appOpenedCount).commit();
}

//now say you want to do something every 10th time they open the app:
boolean shouldDoThing = (appOpenedCount % 10 == 0);
if (shouldDoThing)
{
    doThing();
    appOpenedCount += 1;
    //this ensures that the thing does not happen again on an orientation change.
    prefs.edit().putInt("app_opened_count", appOpenedCount).commit();
}

Answer 2

Just, declare:

    private SharedPreferences prefs;
    private SharedPreferences.Editor editor;
    private int totalCount;

Initialize in onCreate(...) :

    prefs = getPreferences(Context.MODE_PRIVATE);
    editor = prefs.edit();

Print or count wherever you want (any where in onCreate or any specific click as you specified)

     totalCount = prefs.getInt("counter", 0);
     totalCount++;
     editor.putInt("counter", totalCount);
     editor.commit();

Now print totalcount where you want to count eg.:

     System.out.println("Total Application counter Reach to :"+totalCount);

Answer 3

In your Application or Activity's onCreate() method, increment a counter stored in persistent storage such as SharedPreferences.

Answer 4

You can use shared preferences. Every time the app is opened, retrieve the preferences, increment the count, then store it right away. The only issue is that if a user deletes the app along with all preferences, then the count will be erased too. Here is an example of committing to the preferences. Use getPreferences to retrieve them at the startup of the app.

SharedPreferences prefs=getPreferences(Context.MODE_PRIVATE);
SharedPreferences.Editor editor=prefs.edit();
editor.putString("pref 1", "some text");

editor.commit();

Answer 5

One way:

Keep a property in preferences and on launching activity update preference count by '1', but you may not be able to see this increased value because it stays on phone.

Otherway

Call a service to your server (if you have any) to increment the visit count.

Answer 6

1. For a simple approach, keep a text file where you increment the value by 1, after reading it. Keep the count increment on OnCreate() method of Activity

2. You can use SharedPreference.

3. Well DataBase can also be used...but i think that too over-kill for this....

Answer 7

  Using SharedPreference or the Database.

during OnCreate add 1 to the numberofTimes counter and commit.

OnCreate (Bundle bundle){
  mPref = getPreferences();
  int c = mPref.getInt("numRun",0);
  c++;
  mPref.edit().putInt("numRun",c).commit();
  //do other stuff...
}

OnCreate is called regardless of you start the app or you resume the app, but isFinishing() returns true if and only iff the user (or you) called finish() on the app (and it was not being destroyed by the manager)

This way you only increment when you are doing fresh start.

the onFinishing() Method inside of a OnPause method to check to see if the activity is being finish() or just being paused.

@Override
protected void OnPause(){
  if(!onFinishing()){
    c = mPref.getInt("numRun",0);
    c--;
    mPref.edit().putInt("numRun",c).commit();
  }
  //Other pause stuff.
}

Answer 8

As I have said in another answer, I think the following is the best solution:

private static boolean valueOfLaunchCountModified = false;

@Override
protected void onCreate(Bundle savedInstanceState) {

    if(!valueOfCountModified){
        preferences = getPreferences(MODE_PRIVATE);
        launchCount= preferences.getInt("launchCount", 0);
        if(preferences.edit().putInt("launchCount", ++launchCount).commit()){
            valueOfCountModified = true;
        }
    }

    if(launchCount == 5 && valueOfCountModified){
        //Do whatever you want
    }
}

If we remember the definition of a static variable, we will discover that is perfect for us:

They are associated with the class, rather than with any object. Every instance of the class shares a class variable.

When onPause method or an orientation change is executed the value of valueOfLaunchCountModified doesn't change; however, if the app process is destroyed, the value of valueOfLaunchCountModified changes to false.

---