web-dev-qa-db-fra.com

Comment maintenir la session sous Android?

Quelqu'un peut-il me dire comment maintenir la session pour une connexion utilisateur. Par exemple, lorsque l'utilisateur se connecte à une application, il doit être connecté sauf s'il se déconnecte ou désinstalle l'application similaire à gmail sous Android.

15
june

Faites un cours pour votre SharedPreferences

public class Session {

    private SharedPreferences prefs;

    public Session(Context cntx) {
        // TODO Auto-generated constructor stub
        prefs = PreferenceManager.getDefaultSharedPreferences(cntx);
    }

    public void setusename(String usename) {
        prefs.edit().putString("usename", usename).commit();
    }

    public String getusename() {
        String usename = prefs.getString("usename","");
        return usename;
    }
}

Maintenant, après avoir créé cette classe quand vous voulez l’utiliser, utilisez comme ceci: make objet de cette classe comme

private Session session;//global variable 
session = new Session(cntx); //in oncreate 
//and now we set sharedpreference then use this like

session.setusename("USERNAME");

maintenant, chaque fois que vous voulez obtenir le nom d'utilisateur, le même travail doit être effectué pour un objet de session et appeler ceci

session.getusename();

Faites de même pour le mot de passe

34
Bhanu Sharma

Vous pouvez y parvenir en utilisant AccountManager .

Exemple de code

// method to add account..
private void addAccount(String username, String password) {
    AccountManager accnt_manager = AccountManager
            .get(getApplicationContext());

    Account[] accounts = accnt_manager
            .getAccountsByType(getString(R.string.account_type)); // account name identifier.

    if (accounts.length > 0) {
        return;
    }

    final Account account = new Account(username,
            getString(R.string.account_type));

    accnt_manager.addAccountExplicitly(account, password, null);

    final Intent intent = new Intent();
    intent.putExtra(AccountManager.KEY_ACCOUNT_NAME, username);
    intent.putExtra(AccountManager.KEY_PASSWORD, password);
    intent.putExtra(AccountManager.KEY_ACCOUNT_TYPE,
            getString(R.string.account_type));
    // intent.putExtra(AccountManager.KEY_AUTH_TOKEN_LABEL,
    // PARAM_AUTHTOKEN_TYPE);
    intent.putExtra(AccountManager.KEY_AUTHTOKEN, "token");
    this.setAccountAuthenticatorResult(intent.getExtras());
    this.setResult(RESULT_OK, intent);
    this.finish();
}

// method to retrieve account.
private boolean validateAccount() {
    AccountManagerCallback<Bundle> callback = new AccountManagerCallback<Bundle>() {

        @Override
        public void run(AccountManagerFuture<Bundle> arg0) {
            Log.e("calback", "msg");

            try {
                Bundle b = arg0.getResult();
                if (b.getBoolean(AccountManager.KEY_ACCOUNT_MANAGER_RESPONSE)) {
                    //User account exists!!..
                }    
            } catch (OperationCanceledException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (AuthenticatorException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    };

    AccountManager accnt_manager = AccountManager
            .get(getApplicationContext());

    Account[] accounts = accnt_manager
            .getAccountsByType(getString(R.string.account_type));

    if (accounts.length <= 0) {
        return false;
    } else {
        loginNameVal = accounts[0].name;
        loginPswdVal = accnt_manager.getPassword(accounts[0]);
        return true;
    }
}
7
nikvs

Vous pouvez utiliser une valeur booléenne dans les SharedPreferences.

Chargez-le avant la connexion pour vérifier si une connexion est nécessaire.

Enregistrez-le après la connexion. 

2
Fantômas

J'ai un moyen simple plutôt que de maintenir une session.

il suffit de stocker une variable boolean avec votre nom d'utilisateur et votre mot de passe. par défaut, la valeur est égale à false.

Après la première connexion réussie, définissez sa valeur sur true.

Il vous suffit ensuite de vérifier sa valeur sur votre activité principale. Si elle est vraie, passez à l’activité suivante, sinon passez à l’activité de connexion.

2
Andrain

Utilisez SharedPreferences . Code pour enregistrer une valeur dans les préférences partagées:

SharedPreferences sp=getSharedPreferences("key", Context.MODE_PRIVATE);
SharedPreferences.Editor ed=sp.edit();
ed.putInt("value", your_value);
ed.commit();

Code pour obtenir la valeur des préférences partagées:

SharedPreferences sp=getSharedPreferences("key", Context.MODE_PRIVATE);
int value = sp.getInt("value", default_value);

Vous pouvez vérifier la connexion et la déconnexion en utilisant cette valeur.

1
Shahina

Utilisez le code suivant.

SessionManager.Java

public class SessionManager {
    // Shared Preferences
    SharedPreferences pref;

    // Editor for Shared preferences
    Editor editor;

    // Context
    Context _context;

    // Shared pref mode
    int PRIVATE_MODE = 0;

    // Sharedpref file name
    private static final String PREF_NAME = "Pref";

    // All Shared Preferences Keys
    private static final String IS_LOGIN = "IsLoggedIn";

    // User name (make variable public to access from outside)
    public static final String KEY_NAME = "name";

    // Email address (make variable public to access from outside)
    public static final String KEY_EMAIL = "email";

    // Constructor
    public SessionManager(Context context){
        this._context = context;
        pref = _context.getSharedPreferences(PREF_NAME, PRIVATE_MODE);
        editor = pref.edit();
    }

    /**
     * Create login session
     * */
    public void createLoginSession(String name, String email){
        // Storing login value as TRUE
        editor.putBoolean(IS_LOGIN, true);

        // Storing name in pref
        editor.putString(KEY_NAME, name);

        // Storing email in pref
        editor.putString(KEY_EMAIL, email);

        // commit changes
        editor.commit();
    }   

    /**
     * Check login method wil check user login status
     * If false it will redirect user to login page
     * Else won't do anything
     * */
    public void checkLogin(){
        // Check login status
        if(!this.isLoggedIn()){
            // user is not logged in redirect him to Login Activity
            Intent i = new Intent(_context, LoginActivity.class);
            // Closing all the Activities
            i.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);

            // Add new Flag to start new Activity
            i.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

            // Staring Login Activity
            _context.startActivity(i);
        }

    }



    /**
     * Get stored session data
     * */
    public HashMap<String, String> getUserDetails(){
        HashMap<String, String> user = new HashMap<String, String>();
        // user name
        user.put(KEY_NAME, pref.getString(KEY_NAME, null));

        // user email id
        user.put(KEY_EMAIL, pref.getString(KEY_EMAIL, null));

        // return user
        return user;
    }

    /**
     * Clear session details
     * */
    public void logoutUser(){
        // Clearing all data from Shared Preferences
        editor.clear();
        editor.commit();

        // After logout redirect user to Loing Activity
        Intent i = new Intent(_context, LoginActivity.class);
        // Closing all the Activities
        i.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);

        // Add new Flag to start new Activity
        i.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

        // Staring Login Activity
        _context.startActivity(i);
    }

    /**
     * Quick check for login
     * **/
    // Get Login State
    public boolean isLoggedIn(){
        return pref.getBoolean(IS_LOGIN, false);
    }
}

Et dans MainActivity, aimez ce qui suit.

public class MainActivity extends Activity {

    // Email, password edittext
    EditText txtUsername, txtPassword;

    // login button
    Button btnLogin;

    // Alert Dialog Manager
    AlertDialogManager alert = new AlertDialogManager();

    // Session Manager Class
    SessionManager session;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_login); 

        // Session Manager
        session = new SessionManager(getApplicationContext());                

        // Email, Password input text
        txtUsername = (EditText) findViewById(R.id.txtUsername);
        txtPassword = (EditText) findViewById(R.id.txtPassword); 

        Toast.makeText(getApplicationContext(), "User Login Status: " + session.isLoggedIn(), Toast.LENGTH_LONG).show();


        // Login button
        btnLogin = (Button) findViewById(R.id.btnLogin);


        // Login button click event
        btnLogin.setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick(View arg0) {
                // Get username, password from EditText
                String username = txtUsername.getText().toString();
                String password = txtPassword.getText().toString();

                // Check if username, password is filled                
                if(username.trim().length() > 0 && password.trim().length() > 0){
                    // For testing puspose username, password is checked with sample data
                    // username = test
                    // password = test
                    if(username.equals("test") && password.equals("test")){

                        // Creating user login session
                        // For testing i am stroing name, email as follow
                        // Use user real data
                        session.createLoginSession("ABC", "[email protected]");

                        // Staring MainActivity
                        Intent i = new Intent(getApplicationContext(), MainActivity.class);
                        startActivity(i);
                        finish();

                    }else{
                        // username / password doesn't match
                        alert.showAlertDialog(LoginActivity.this, "Login failed..", "Username/Password is incorrect", false);
                    }               
                }else{
                    // user didn't entered username or password
                    // Show alert asking him to enter the details
                    alert.showAlertDialog(LoginActivity.this, "Login failed..", "Please enter username and password", false);
                }

            }
        });
    }        
}
0
Jitesh Dalsaniya
public class Session {

    private SharedPreferences prefs;

    public Session(Context cntx) {
        // TODO Auto-generated constructor stub
        prefs = PreferenceManager.getDefaultSharedPreferences(cntx);
        editor = prefs.edit();
    }

    public void setusename(String usename) {
        editor.putString("usename", usename).commit();

    }

    public String getusename() {
        String usename = prefs.getString("usename","");
        return usename;
    }
}
0
Trinadh Koya

Vous pouvez obtenir ce comportement de différentes manières, celle que je préfère consiste à définir un indicateur dans les préférences partagées. Si un utilisateur se connecte et le vérifie au démarrage de l'application si vous obtenez la valeur par défaut, il n'est pas loggend, sinon vous devriez avoir le drapeau défini (i use name) et éviter la section de connexion.

0
Ayoub

L'utilisation de cette classe vous aidera à stocker tous les types de sessions

public class Session {

    private SharedPreferences prefs;

    public Session(Context cntx) {
        // TODO Auto-generated constructor stub
        prefs = PreferenceManager.getDefaultSharedPreferences(cntx);
    }

    public void set(String key,String value) {
        prefs.edit().putString(key, value).commit();
    }

    public String get(String key) {
        String value = prefs.getString(key,"");
        return value;
    }
}
0
Nain Abbas

Code source

https://drive.google.com/open?id=0BzBKpZ4nzNzUcUZxeHo0UnJ5UHc

Récupérer l'identifiant de connexion précédent sous Android enter image description here

**After Login save Email ID is SharedPreferences** 

    emaidId = et_Email.getText().toString().trim();

    SharedPreferences ss = getSharedPreferences("loginSession_key", 0);
    Set<String> hs = ss.getStringSet("set", new HashSet<String>());
    hs.add(emaidId);
    SharedPreferences.Editor edit = ss.edit();
    edit.clear();
    edit.putStringSet("set", hs);
    edit.commit();

===================onCreate()====================
===================AutoCompleteTextView set Adapter===================

**Fetch PRevious Login Email id in email EditText**

SharedPreferences sss = getSharedPreferences("loginSession_key", 0);            // todo loginSession_key   key name ALWAYS SAME
Log.i("chauster", "2.set = " + sss.getStringSet("set", new HashSet<String>()));
Log.e("Session", "Value->" + sss.getStringSet("set", new HashSet<String()));
ArrayList<String> al = new ArrayList<>();
al.addAll(sss.getStringSet("set", new HashSet<String>()));
//Creating the instance of ArrayAdapter containing list of language names
ArrayAdapter<String> adapter = new ArrayAdapter<String>
                (this, Android.R.layout.select_dialog_item, al);
//Getting the instance of AutoCompleteTextView
et_Email.setThreshold(1);//will start working from first character
et_Email.setAdapter(adapter);//setting the adapter data into the 
0
Keshav Gera

enregistrer les données utilisateur dans les préférences partagées jusqu'à ce que celui-ci se déconnecte . une fois que l'utilisateur se déconnecte, effacez les données des préférences partagées.

0
Yogamurthy