Tentukan apakah aplikasi Android digunakan untuk pertama kali

Saya sedang mengembangkan aplikasi android. Saya perlu melakukan sesuatu saat aplikasi diluncurkan untuk pertama kali, yaitu kode hanya berjalan saat pertama kali program diluncurkan.

Ide lainnya adalah menggunakan pengaturan di Preferensi Bersama. Ide umum yang sama seperti memeriksa file kosong, tetapi Anda tidak memiliki file kosong yang mengambang, tidak digunakan untuk menyimpan apa pun

Anda dapat menggunakan SharedPreferences untuk mengidentifikasi apakah ini "Pertama kali" aplikasi diluncurkan. Cukup gunakan variabel Boolean ("my_first_time") dan ubah nilainya menjadi false ketika tugas Anda untuk "pertama kali" selesai.

Ini adalah kode saya untuk mengetahui saat pertama kali Anda membuka aplikasi:

final String PREFS_NAME = "MyPrefsFile";

SharedPreferences settings = getSharedPreferences(PREFS_NAME, 0);

if (settings.getBoolean("my_first_time", true)) {
    //the app is being launched for first time, do something        
    Log.d("Comments", "First time");

             // first time task

    // record the fact that the app has been started at least once
    settings.edit().putBoolean("my_first_time", false).commit(); 
}

Saya menyarankan untuk tidak hanya menyimpan bendera boolean, tetapi juga kode versi lengkapnya. Dengan cara ini Anda juga dapat membuat kueri di awal jika ini adalah permulaan pertama dalam versi baru. Anda dapat menggunakan informasi ini untuk menampilkan dialog "Yang baru", misalnya.

Kode berikut harus bekerja dari kelas android apa pun yang "merupakan konteks" (aktivitas, layanan, ...). Jika Anda lebih suka memilikinya dalam kelas terpisah (POJO), Anda dapat mempertimbangkan untuk menggunakan "konteks statis", seperti yang dijelaskan di sini misalnya.

/**
 * Distinguishes different kinds of app starts: <li>
 * <ul>
 * First start ever ({@link #FIRST_TIME})
 * </ul>
 * <ul>
 * First start in this version ({@link #FIRST_TIME_VERSION})
 * </ul>
 * <ul>
 * Normal app start ({@link #NORMAL})
 * </ul>
 * 
 * @author schnatterer
 * 
 */
public enum AppStart {
    FIRST_TIME, FIRST_TIME_VERSION, NORMAL;
}

/**
 * The app version code (not the version name!) that was used on the last
 * start of the app.
 */
private static final String LAST_APP_VERSION = "last_app_version";

/**
 * Finds out started for the first time (ever or in the current version).<br/>
 * <br/>
 * Note: This method is <b>not idempotent</b> only the first call will
 * determine the proper result. Any subsequent calls will only return
 * {@link AppStart#NORMAL} until the app is started again. So you might want
 * to consider caching the result!
 * 
 * @return the type of app start
 */
public AppStart checkAppStart() {
    PackageInfo pInfo;
    SharedPreferences sharedPreferences = PreferenceManager
            .getDefaultSharedPreferences(this);
    AppStart appStart = AppStart.NORMAL;
    try {
        pInfo = getPackageManager().getPackageInfo(getPackageName(), 0);
        int lastVersionCode = sharedPreferences
                .getInt(LAST_APP_VERSION, -1);
        int currentVersionCode = pInfo.versionCode;
        appStart = checkAppStart(currentVersionCode, lastVersionCode);
        // Update version in preferences
        sharedPreferences.edit()
                .putInt(LAST_APP_VERSION, currentVersionCode).commit();
    } catch (NameNotFoundException e) {
        Log.w(Constants.LOG,
                "Unable to determine current app version from pacakge manager. Defenisvely assuming normal app start.");
    }
    return appStart;
}

public AppStart checkAppStart(int currentVersionCode, int lastVersionCode) {
    if (lastVersionCode == -1) {
        return AppStart.FIRST_TIME;
    } else if (lastVersionCode < currentVersionCode) {
        return AppStart.FIRST_TIME_VERSION;
    } else if (lastVersionCode > currentVersionCode) {
        Log.w(Constants.LOG, "Current version code (" + currentVersionCode
                + ") is less then the one recognized on last startup ("
                + lastVersionCode
                + "). Defenisvely assuming normal app start.");
        return AppStart.NORMAL;
    } else {
        return AppStart.NORMAL;
    }
}

Ini bisa digunakan dari aktivitas seperti ini:

public class MainActivity extends Activity {        
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        switch (checkAppStart()) {
        case NORMAL:
            // We don't want to get on the user's nerves
            break;
        case FIRST_TIME_VERSION:
            // TODO show what's new
            break;
        case FIRST_TIME:
            // TODO show a tutorial
            break;
        default:
            break;
        }

        // ...
    }
    // ...
}

Logika dasar dapat diverifikasi menggunakan uji JUnit ini:

public void testCheckAppStart() {
    // First start
    int oldVersion = -1;
    int newVersion = 1;
    assertEquals("Unexpected result", AppStart.FIRST_TIME,
            service.checkAppStart(newVersion, oldVersion));

    // First start this version
    oldVersion = 1;
    newVersion = 2;
    assertEquals("Unexpected result", AppStart.FIRST_TIME_VERSION,
            service.checkAppStart(newVersion, oldVersion));

    // Normal start
    oldVersion = 2;
    newVersion = 2;
    assertEquals("Unexpected result", AppStart.NORMAL,
            service.checkAppStart(newVersion, oldVersion));
}

Dengan sedikit usaha, Anda mungkin bisa menguji hal-hal terkait android (PackageManager dan SharedPreferences) juga. Ada yang tertarik menulis tes? :)

Perhatikan bahwa kode di atas hanya akan berfungsi dengan baik jika Anda tidak main-main dengan android:versionCodeAndroidManifest.xml Anda!

Saya memecahkan untuk menentukan apakah aplikasi tersebut pertama kali Anda atau tidak, tergantung pada apakah itu pembaruan.

private int appGetFirstTimeRun() {
    //Check if App Start First Time
    SharedPreferences appPreferences = getSharedPreferences("MyAPP", 0);
    int appCurrentBuildVersion = BuildConfig.VERSION_CODE;
    int appLastBuildVersion = appPreferences.getInt("app_first_time", 0);

    //Log.d("appPreferences", "app_first_time = " + appLastBuildVersion);

    if (appLastBuildVersion == appCurrentBuildVersion ) {
        return 1; //ya has iniciado la appp alguna vez

    } else {
        appPreferences.edit().putInt("app_first_time",
                appCurrentBuildVersion).apply();
        if (appLastBuildVersion == 0) {
            return 0; //es la primera vez
        } else {
            return 2; //es una versión nueva
        }
    }
}

Hasil perhitungan:

• 0: Jika ini pertama kalinya.
• 1: Ini telah dimulai.
• 2: Ini telah dimulai sekali, tetapi bukan versi itu, yaitu pembaruan.

Anda dapat menggunakan Android SharedPreferences .

Android SharedPreferences memungkinkan kita menyimpan data aplikasi primitif pribadi dalam bentuk key-value pair.

KODE

Buat kelas khusus SharedPreference

 public class SharedPreference {

    android.content.SharedPreferences pref;
    android.content.SharedPreferences.Editor editor;
    Context _context;
    private static final String PREF_NAME = "testing";

    // All Shared Preferences Keys Declare as #public
    public static final String KEY_SET_APP_RUN_FIRST_TIME       =        "KEY_SET_APP_RUN_FIRST_TIME";


    public SharedPreference(Context context) // Constructor
    {
        this._context = context;
        pref = _context.getSharedPreferences(PREF_NAME, 0);
        editor = pref.edit();

    }

    /*
    *  Set Method Generally Store Data;
    *  Get Method Generally Retrieve Data ;
    * */


    public void setApp_runFirst(String App_runFirst)
    {
        editor.remove(KEY_SET_APP_RUN_FIRST_TIME);
        editor.putString(KEY_SET_APP_RUN_FIRST_TIME, App_runFirst);
        editor.apply();
    }

    public String getApp_runFirst()
    {
        String  App_runFirst= pref.getString(KEY_SET_APP_RUN_FIRST_TIME, "FIRST");
        return  App_runFirst;
    }

}

Sekarang Buka Aktivitas Anda & Inisialisasi .

 private     SharedPreference                sharedPreferenceObj; // Declare Global

Sekarang Panggil ini di bagian OnCreate

 sharedPreferenceObj=new SharedPreference(YourActivity.this);

Sekarang Memeriksa

if(sharedPreferenceObj.getApp_runFirst().equals("FIRST"))
 {
   // That's mean First Time Launch
   // After your Work , SET Status NO
   sharedPreferenceObj.setApp_runFirst("NO");
 }
else
 { 
   // App is not First Time Launch
 }

Berikut beberapa kode untuk ini -

String path = Environment.getExternalStorageDirectory().getAbsolutePath() +
                    "/Android/data/myapp/files/myfile.txt";

boolean exists = (new File(path)).exists(); 

if (!exists) {
    doSomething();                                      
}
else {
    doSomethingElse();
}

Anda cukup memeriksa keberadaan file kosong, jika tidak ada, lalu jalankan kode Anda dan buat file.

misalnya

if(File.Exists("emptyfile"){
    //Your code here
    File.Create("emptyfile");
}

Saya membuat kelas sederhana untuk memeriksa apakah kode Anda berjalan untuk pertama kalinya / n-kali!

Contoh

Buat preferensi unik

FirstTimePreference prefFirstTime = new FirstTimePreference(getApplicationContext());

Gunakan runTheFirstTime, pilih kunci untuk memeriksa acara Anda

if (prefFirstTime.runTheFirstTime("myKey")) {
    Toast.makeText(this, "Test myKey & coutdown: " + prefFirstTime.getCountDown("myKey"),
                   Toast.LENGTH_LONG).show();
}

Gunakan runTheFirstNTimes, pilih kunci dan berapa kali dieksekusi

if(prefFirstTime.runTheFirstNTimes("anotherKey" , 5)) {
    Toast.makeText(this, "ciccia Test coutdown: "+ prefFirstTime.getCountDown("anotherKey"),
                   Toast.LENGTH_LONG).show();
}

• Gunakan getCountDown () untuk menangani kode Anda dengan lebih baik

FirstTimePreference.java

Hanya ada dukungan untuk ini di revisi pustaka dukungan 23.3.0 (di v4 yang berarti kompatibilitas kembali ke Android 1.6).

Dalam aktivitas Launcher Anda, panggilan pertama:

AppLaunchChecker.onActivityCreate(activity);

Kemudian hubungi:

AppLaunchChecker.hasStartedFromLauncher(activity);

Yang akan ditampilkan jika ini pertama kali aplikasi diluncurkan.

Jika Anda mencari cara sederhana, ini dia.

Buat kelas utilitas seperti ini,

public class ApplicationUtils {

  /**
  * Sets the boolean preference value
  *
  * @param context the current context
  * @param key     the preference key
  * @param value   the value to be set
  */
 public static void setBooleanPreferenceValue(Context context, String key, boolean value) {
     SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(context);
     sp.edit().putBoolean(key, value).apply();
 }

 /**
  * Get the boolean preference value from the SharedPreference
  *
  * @param context the current context
  * @param key     the preference key
  * @return the the preference value
  */
 public static boolean getBooleanPreferenceValue(Context context, String key) {
     SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(context);
     return sp.getBoolean(key, false);
 }

}

Di Aktivitas Utama Anda, onCreate ()

if(!ApplicationUtils.getBooleanPreferenceValue(this,"isFirstTimeExecution")){
Log.d(TAG, "First time Execution");
ApplicationUtils.setBooleanPreferenceValue(this,"isFirstTimeExecution",true);
// do your first time execution stuff here,
}

untuk kotlin

    fun checkFirstRun() {

    var prefs_name = "MyPrefsFile"
    var pref_version_code_key = "version_code"
    var doesnt_exist: Int = -1;

    // Get current version code
    var currentVersionCode = BuildConfig.VERSION_CODE

    // Get saved version code
    var prefs: SharedPreferences = getSharedPreferences(prefs_name, MODE_PRIVATE)
    var savedVersionCode: Int = prefs.getInt(pref_version_code_key, doesnt_exist)

    // Check for first run or upgrade
    if (currentVersionCode == savedVersionCode) {

        // This is just a normal run
        return;

    } else if (savedVersionCode == doesnt_exist) {

        // TODO This is a new install (or the user cleared the shared preferences)


    } else if (currentVersionCode > savedVersionCode) {

        // TODO This is an upgrade
    }

    // Update the shared preferences with the current version code
    prefs.edit().putInt(pref_version_code_key, currentVersionCode).apply();

}

Mengapa tidak menggunakan Pembantu Database? Ini akan memiliki onCreate bagus yang hanya dipanggil saat pertama kali aplikasi dimulai. Ini akan membantu orang-orang yang ingin melacak ini setelah ada aplikasi awal diinstal tanpa pelacakan.

Saya ingin memiliki "jumlah pembaruan" dalam preferensi bersama saya. Jika tidak ada (atau nilai nol default) maka ini adalah "penggunaan pertama" aplikasi saya.

private static final int UPDATE_COUNT = 1;    // Increment this on major change
...
if (sp.getInt("updateCount", 0) == 0) {
    // first use
} else if (sp.getInt("updateCount", 0) < UPDATE_COUNT) {
    // Pop up dialog telling user about new features
}
...
sp.edit().putInt("updateCount", UPDATE_COUNT);

Jadi sekarang, setiap kali ada pembaruan pada aplikasi yang harus diketahui pengguna, saya menaikkan UPDATE_COUNT

    /**
     * @author ALGO
     */
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.RandomAccessFile;
    import java.util.UUID;

    import android.content.Context;

    public class Util {
        // ===========================================================
        //
        // ===========================================================

        private static final String INSTALLATION = "INSTALLATION";

        public synchronized static boolean isFirstLaunch(Context context) {
            String sID = null;
            boolean launchFlag = false;
            if (sID == null) {
                File installation = new File(context.getFilesDir(), INSTALLATION);
                try {
                    if (!installation.exists()) {

                        writeInstallationFile(installation);
                    }
                    sID = readInstallationFile(installation);
launchFlag = true;
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }
            return launchFlag;
        }

        private static String readInstallationFile(File installation) throws IOException {
            RandomAccessFile f = new RandomAccessFile(installation, "r");// read only mode
            byte[] bytes = new byte[(int) f.length()];
            f.readFully(bytes);
            f.close();

            return new String(bytes);
        }

        private static void writeInstallationFile(File installation) throws IOException {
            FileOutputStream out = new FileOutputStream(installation);
            String id = UUID.randomUUID().toString();
            out.write(id.getBytes());
            out.close();
        }
    }

> Usage (in class extending android.app.Activity)

Util.isFirstLaunch(this);

Hai teman-teman, saya melakukan sesuatu seperti ini. Dan itu berhasil untuk saya

buat bidang Boolean dalam preferensi bersama. Nilai default adalah true {isFirstTime: true} setelah pertama kali disetel ke false. Tidak ada yang sederhana dan dapat diandalkan selain ini di sistem android.