Je suis très nouveau sur Android et récemment, je me suis retrouvé dans une situation où je dois utiliser SharedPreferences: j'ai une variable qui est modifiée au fur et à mesure du projet, et l'application démarre dans un écran différent en fonction de la valeur de la variable, pour Par exemple, si la valeur est 0, l'application doit démarrer dans LoginManager.class et si elle vaut 1, elle démarre dans MainActivity.class.

Ainsi, chaque fois que je me connecte avec succès, l'état passe à 1 (donc je n'ai pas à me connecter à chaque fois) ou si je me déconnecte, l'état est 0.
Compte tenu de cela, bien sûr, la variable doit être enregistrée en externe afin que la valeur ne soit pas perdue, et la récupérer lorsque je crée le premier écran.

Donc, ma logique était que je crée une méthode onDestroy donc lorsque l'écran se ferme, quelle que soit la variable globale "state" a, c'est ce que la variable SharedPreference "sharedstate" va obtenir (cela provient de mon activité initiale):

private SharedPreferences sharedPref;
public static int state=0;


protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    requestWindowFeature(Window.FEATURE_NO_TITLE);
    getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
            WindowManager.LayoutParams.FLAG_FULLSCREEN);
    setContentView(R.layout.activity_first);
    pb = (ProgressBar) findViewById(R.id.pb);
    mContext = IntroManager.this;
    pb.setVisibility(ProgressBar.VISIBLE);
    CountDownTimer mCountDownTimer;
    pb.setProgress(i);
    sharedPref = mContext.getSharedPreferences("Apathy", Context.MODE_PRIVATE);
    getProfile();
    mCountDownTimer=new CountDownTimer(1500,1000) {
        @Override
        public void onTick(long millisUntilFinished) {
            Log.v("Log_tag", "Tick of Progress"+ i+ millisUntilFinished);
            i++;
            pb.setProgress((int)i*100/(1500/1000));
        }

        @Override
        public void onFinish() {
            check();
            i++;
            pb.setProgress(100);
        }
    };
    mCountDownTimer.start();
}

@Override
protected void onDestroy (){
    super.onDestroy();
    SharedPreferences.Editor editor = sharedPref.edit();
    editor.putInt("sharedstate", 1);
    editor.commit();
}

private void getProfile() {
    String sharedstate = sharedPref.getString("state", "");
    state= Integer.parseInt(sharedstate);
}

public void check(){
    if(state == 0){
        Intent mcrIntent = new Intent(IntroManager.this, LoginManager.class);
        startActivity(mcrIntent);
        overridePendingTransition(R.anim.slide_in, R.anim.slide_out);
    }else{
        if(state == 1){
            Intent mcrIntent = new Intent(IntroManager.this, MainActivity.class);
            startActivity(mcrIntent);
            overridePendingTransition(R.anim.slide_in, R.anim.slide_out);
        }
    }
}

Alors je me suis retrouvé pris dans un dilemme: si je mets la même méthode onDestroy dans tous mes écrans (puisque je ne peux pas prédire où l'application va se fermer), le même "état partagé" change sa valeur ou crée-t-il un tas de variables qui s'appellent Sharedstate? Et sont-ils sauvés dans la même chose d '«apathie»?

1
Hillary Rj 20 nov. 2018 à 18:11

3 réponses

Meilleure réponse

Il remplacera la même valeur à chaque fois qu'une activité appelle onDestroy. Les préférences partagées sont des fichiers propres enregistrés sur le téléphone sur lequel elles ont été créées. La balise «Apathy» est le nom du fichier et «sharedstate» est la clé de la valeur enregistrée.

C'est la puissance de SharedPreferences, vous pouvez enregistrer des données primitives assez facilement. Mais lorsque l'application est désinstallée, les préférences ont également disparu.

Cherchez peut-être des vidéos et des tutoriels, il y en a beaucoup. La Documentation est également très utile (mais parfois difficile à comprendre pour les débutants )

0
Tommy 20 nov. 2018 à 18:06

Au cas où quelqu'un le chercherait vraiment, j'ai réussi à le faire, j'ai créé une nouvelle classe qui gère tout cela et dans ce cas appelée "Util_Preferencias":

package com.example.user.mkpos;

import android.content.Context;
import android.content.SharedPreferences;
import static com.example.user.mkpos.IntroManager.state;


public class Util_Preferencias {

    Context miContexto;
    private SharedPreferences PreferenciasConfiguaracion;
    private  SharedPreferences.Editor editorPrefConfig;

    public Util_Preferencias(Context elContexto){
        miContexto=elContexto;
        PreferenciasConfiguaracion = miContexto.getSharedPreferences("PrefConfig",miContexto.MODE_PRIVATE);
        editorPrefConfig = PreferenciasConfiguaracion.edit();
    }


    public void GuardaPrefConfig(String estado){
        editorPrefConfig.putString("estado",estado);
        editorPrefConfig.commit();
    }

    public void CargaPref_Configuracion(){
        SharedPreferences prefs = miContexto.getSharedPreferences("PrefConfig",miContexto.MODE_PRIVATE);
        state = Integer.parseInt(prefs.getString("estado","0"));
    }

}

Chaque fois que j'avais besoin de donner à l'état une nouvelle valeur, j'appelais GuardaPrefConfig et lorsque j'avais besoin de récupérer, j'utilisais CargaPref_Configuracion (en appelant la classe Uitl_Activity dans l'activité souhaitée comme ceci :)

Util_Preferencias UtilPreferencias = new Util_Preferencias(getApplicationContext());
0
Hillary Rj 20 nov. 2018 à 16:52

Je crois que ce code mettra à jour la même valeur encore et encore et ne fera pas de doublons.

Si vous voulez voir à quoi ressemblent vos préférences partagées, vous pouvez jeter un œil à cette réponse: Comment afficher le fichier de préférences partagées à l'aide d'Android Studio?

Cela étant dit, comme l'a écrit Vivart, il ne serait pas nécessaire de mettre à jour le pref à chaque fois que onDestroy est appelé, vous ne devriez avoir besoin de le mettre à jour qu'en cas de réussite de la connexion ou lors de la déconnexion.

0
Quinn 20 nov. 2018 à 16:22