Android应用登录后多角色会话管理与页面跳转方案咨询

Alright, let's break down how to implement session management and role-based navigation for your Android login flow. Here's a step-by-step guide tailored to your requirements:

First, you need a way to persist user session data (userId, designation) across app restarts and navigation. Two reliable options are:

Option 1: Jetpack DataStore (Recommended) #

Jetpack DataStore is a modern replacement for SharedPreferences—it's asynchronous, type-safe, and avoids ANR issues. Use it to store non-sensitive session data (never store plain-text passwords here!):

• Add the DataStore dependency to your build.gradle (Module level):

  implementation "androidx.datastore:datastore-preferences:1.0.0"
  

• Define preferences keys:

  val USER_ID = stringPreferencesKey("user_id")
  val DESIGNATION = intPreferencesKey("designation")
  

• Store session data after successful login (as shown in the navigation section below).

Option 2: Encrypted SharedPreferences #

If you prefer SharedPreferences, use EncryptedSharedPreferences (from Jetpack Security) to protect sensitive data:

• Add dependencies:

  implementation "androidx.security:security-crypto:1.1.0-alpha06"
  

• Initialize encrypted preferences:

  String masterKeyAlias = MasterKeys.getOrCreate(MasterKeys.AES256_GCM_SPEC);
  SharedPreferences sharedPreferences = EncryptedSharedPreferences.create(
      "user_session",
      masterKeyAlias,
      context,
      EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
      EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM
  );
  

Once you get the designation value from your Retrofit response, use a conditional check to launch the corresponding Activity. Don't forget to clear the back stack so users can't navigate back to the login screen accidentally.

Kotlin Example (Retrofit Callback) #

// Assume LoginResponse is your data class holding userId, password, designation
loginApiService.login(username, password).enqueue(object : Callback<LoginResponse> {
    override fun onResponse(call: Call<LoginResponse>, response: Response<LoginResponse>) {
        if (response.isSuccessful) {
            val loginData = response.body() ?: return
            
            // Store session data in DataStore
            val dataStore = context.createDataStore(name = "user_session")
            lifecycleScope.launch {
                dataStore.edit { prefs ->
                    prefs[USER_ID] = loginData.userId
                    prefs[DESIGNATION] = loginData.designation
                    // NEVER store plain-text password locally! Use auth token if backend provides it
                }
            }

            // Navigate to role-specific Activity
            val targetIntent = when(loginData.designation) {
                1 -> Intent(context, Role1Activity::class.java)
                2 -> Intent(context, Role2Activity::class.java)
                3 -> Intent(context, Role3Activity::class.java)
                4 -> Intent(context, Role4Activity::class.java)
                else -> Intent(context, LoginActivity::class.java) // Fallback for invalid designation
            }

            // Clear back stack to prevent returning to login
            targetIntent.flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK
            startActivity(targetIntent)
            finish() // Close login activity
        } else {
            Toast.makeText(context, "Login failed: ${response.message()}", Toast.LENGTH_SHORT).show()
        }
    }

    override fun onFailure(call: Call<LoginResponse>, t: Throwable) {
        Toast.makeText(context, "Network error: ${t.localizedMessage}", Toast.LENGTH_SHORT).show()
    }
})

Java Example (Retrofit Callback) #

loginApiService.login(username, password).enqueue(new Callback<LoginResponse>() {
    @Override
    public void onResponse(Call<LoginResponse> call, Response<LoginResponse> response) {
        if (response.isSuccessful()) {
            LoginResponse loginData = response.body();
            if (loginData == null) return;

            // Store session data in EncryptedSharedPreferences
            SharedPreferences sharedPrefs = getEncryptedSharedPreferences(context);
            SharedPreferences.Editor editor = sharedPrefs.edit();
            editor.putString("user_id", loginData.getUserId());
            editor.putInt("designation", loginData.getDesignation());
            editor.apply();

            // Navigate to role-specific Activity
            Intent targetIntent;
            switch (loginData.getDesignation()) {
                case 1:
                    targetIntent = new Intent(context, Role1Activity.class);
                    break;
                case 2:
                    targetIntent = new Intent(context, Role2Activity.class);
                    break;
                case 3:
                    targetIntent = new Intent(context, Role3Activity.class);
                    break;
                case 4:
                    targetIntent = new Intent(context, Role4Activity.class);
                    break;
                default:
                    targetIntent = new Intent(context, LoginActivity.class);
            }

            targetIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
            startActivity(targetIntent);
            finish();
        } else {
            Toast.makeText(context, "Login failed: " + response.message(), Toast.LENGTH_SHORT).show();
        }
    }

    @Override
    public void onFailure(Call<LoginResponse> call, Throwable t) {
        Toast.makeText(context, "Network error: " + t.getLocalizedMessage(), Toast.LENGTH_SHORT).show();
    }
});

// Helper method for EncryptedSharedPreferences
private SharedPreferences getEncryptedSharedPreferences(Context context) {
    try {
        String masterKeyAlias = MasterKeys.getOrCreate(MasterKeys.AES256_GCM_SPEC);
        return EncryptedSharedPreferences.create(
            "user_session",
            masterKeyAlias,
            context,
            EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
            EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM
        );
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

To skip the login screen if the user is already logged in, add a check in your splash screen or main launcher activity:

Kotlin Example #

lifecycleScope.launch {
    val dataStore = context.createDataStore(name = "user_session")
    val designation = dataStore.data.first()[DESIGNATION]
    
    val intent = if (designation != null) {
        when(designation) {
            1 -> Intent(context, Role1Activity::class.java)
            2 -> Intent(context, Role2Activity::class.java)
            3 -> Intent(context, Role3Activity::class.java)
            4 -> Intent(context, Role4Activity::class.java)
            else -> Intent(context, LoginActivity::class.java)
        }
    } else {
        Intent(context, LoginActivity::class.java)
    }
    
    intent.flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK
    startActivity(intent)
}

• Never store plain-text passwords: If your backend returns an auth token (like JWT), store that instead. Tokens can be invalidated remotely, which is far safer than storing passwords.
• Encrypt all session data: Use Jetpack Security to encrypt any stored user-related data, even if it's not a password.
• Handle session expiration: Implement logic to check if the session is expired (e.g., store an expiration timestamp, or validate the token with your backend on app launch). Redirect to login if the session is invalid.
• Clear session on logout: When the user logs out, delete all stored session data and launch the login screen with a cleared back stack.

内容的提问来源于stack exchange，提问作者Aditya Dabas