How do I pass data between Activities in Android application?
AndroidAndroid IntentAndroid ActivityAndroid Problem Overview
I have a scenario where, after logging in through a login page, there will be a sign-out button
on each activity
.
On clicking sign-out
, I will be passing the session id
of the signed in user to sign-out. Can anyone guide me on how to keep session id
available to all activities
?
Any alternative to this case
Android Solutions
Solution 1 - Android
In your current Activity, create a new Intent
:
String value="Hello world";
Intent i = new Intent(CurrentActivity.this, NewActivity.class);
i.putExtra("key",value);
startActivity(i);
Then in the new Activity, retrieve those values:
Bundle extras = getIntent().getExtras();
if (extras != null) {
String value = extras.getString("key");
//The key argument here must match that used in the other activity
}
Use this technique to pass variables from one Activity to the other.
Solution 2 - Android
The easiest way to do this would be to pass the session id to the signout activity in the Intent
you're using to start the activity:
Intent intent = new Intent(getBaseContext(), SignoutActivity.class);
intent.putExtra("EXTRA_SESSION_ID", sessionId);
startActivity(intent);
Access that intent on next activity:
String sessionId = getIntent().getStringExtra("EXTRA_SESSION_ID");
The docs for Intents has more information (look at the section titled "Extras").
Solution 3 - Android
Passing Intent extras is a good approach as Erich noted.
The Application object is another way though, and it is sometimes easier when dealing with the same state across multiple activities (as opposed to having to get/put it everywhere), or objects more complex than primitives and Strings.
You can extend Application, and then set/get whatever you want there and access it from any Activity (in the same application) with getApplication().
Also keep in mind that other approaches you might see, like statics, can be problematic because they can lead to memory leaks. Application helps solve this too.
Solution 4 - Android
Source class:
Intent myIntent = new Intent(this, NewActivity.class);
myIntent.putExtra("firstName", "Your First Name Here");
myIntent.putExtra("lastName", "Your Last Name Here");
startActivity(myIntent)
Destination Class (NewActivity class):
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.view);
Intent intent = getIntent();
String fName = intent.getStringExtra("firstName");
String lName = intent.getStringExtra("lastName");
}
Solution 5 - Android
You just have to send extras while calling your intent.
Like this:
Intent intent = new Intent(getApplicationContext(), SecondActivity.class);
intent.putExtra("Variable name", "Value you want to pass");
startActivity(intent);
Now on the OnCreate
method of your SecondActivity
you can fetch the extras like this.
If the value you sent was in long
:
long value = getIntent().getLongExtra("Variable name which you sent as an extra", defaultValue(you can give it anything));
If the value you sent was a String
:
String value = getIntent().getStringExtra("Variable name which you sent as an extra");
If the value you sent was a Boolean
:
Boolean value = getIntent().getBooleanExtra("Variable name which you sent as an extra", defaultValue);
Solution 6 - Android
It helps me to see things in context. Here are two examples.
#Passing Data Forward
###Main Activity
- Put the data you want to send in an Intent with a key-value pair. See this answer for naming conventions for the key.
- Start the Second Activity with
startActivity
.
MainActivity.java
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
// "Go to Second Activity" button click
public void onButtonClick(View view) {
// get the text to pass
EditText editText = (EditText) findViewById(R.id.editText);
String textToPass = editText.getText().toString();
// start the SecondActivity
Intent intent = new Intent(this, SecondActivity.class);
intent.putExtra(Intent.EXTRA_TEXT, textToPass);
startActivity(intent);
}
}
###Second Activity
- You use
getIntent()
to get theIntent
that started the second activity. Then you can extract the data withgetExtras()
and the key you defined in the first activity. Since our data is a String we will just usegetStringExtra
here.
SecondActivity.java
public class SecondActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_second);
// get the text from MainActivity
Intent intent = getIntent();
String text = intent.getStringExtra(Intent.EXTRA_TEXT);
// use the text in a TextView
TextView textView = (TextView) findViewById(R.id.textView);
textView.setText(text);
}
}
#Passing Data Back
###Main Activity
- Start the Second Activity with
startActivityForResult
, providing it an arbitrary result code. - Override
onActivityResult
. This is called when the Second Activity finishes. You can make sure that it is actually the Second Activity by checking the result code. (This is useful when you are starting multiple different activities from the same main activity.) - Extract the data you got from the return
Intent
. The data is extracted using a key-value pair. I could use any string for the key but I'll use the predefinedIntent.EXTRA_TEXT
since I'm sending text.
MainActivity.java
public class MainActivity extends AppCompatActivity {
private static final int SECOND_ACTIVITY_REQUEST_CODE = 0;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
// "Go to Second Activity" button click
public void onButtonClick(View view) {
// Start the SecondActivity
Intent intent = new Intent(this, SecondActivity.class);
startActivityForResult(intent, SECOND_ACTIVITY_REQUEST_CODE);
}
// This method is called when the second activity finishes
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);
// check that it is the SecondActivity with an OK result
if (requestCode == SECOND_ACTIVITY_REQUEST_CODE) {
if (resultCode == RESULT_OK) {
// get String data from Intent
String returnString = data.getStringExtra(Intent.EXTRA_TEXT);
// set text view with string
TextView textView = (TextView) findViewById(R.id.textView);
textView.setText(returnString);
}
}
}
}
###Second Activity
- Put the data that you want to send back to the previous activity into an
Intent
. The data is stored in theIntent
using a key-value pair. I chose to useIntent.EXTRA_TEXT
for my key. - Set the result to
RESULT_OK
and add the intent holding your data. - Call
finish()
to close the Second Activity.
SecondActivity.java
public class SecondActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_second);
}
// "Send text back" button click
public void onButtonClick(View view) {
// get the text from the EditText
EditText editText = (EditText) findViewById(R.id.editText);
String stringToPassBack = editText.getText().toString();
// put the String to pass back into an Intent and close this activity
Intent intent = new Intent();
intent.putExtra(Intent.EXTRA_TEXT, stringToPassBack);
setResult(RESULT_OK, intent);
finish();
}
}
Solution 7 - Android
Updated Note that I had mentioned the use of SharedPreference. It has a simple API and is accessible across an application's activities. But this is a clumsy solution, and is a security risk if you pass around sensitive data. It's best to use intents. It has an extensive list of overloaded methods that can be used to better transfer many different data types between activities. Have a look at intent.putExtra. This link presents the use of putExtra quite well.
In passing data between activities, my preferred approach is to create a static method for the relevant activity that includes the required parameters launch the intent. Which then provides easily setup and retrieve parameters. So it can look like this
public class MyActivity extends Activity {
public static final String ARG_PARAM1 = "arg_param1";
...
public static getIntent(Activity from, String param1, Long param2...) {
Intent intent = new Intent(from, MyActivity.class);
intent.putExtra(ARG_PARAM1, param1);
intent.putExtra(ARG_PARAM2, param2);
return intent;
}
....
// Use it like this.
startActivity(MyActvitiy.getIntent(FromActivity.this, varA, varB, ...));
...
Then you can create an intent for the intended activity and ensure you have all the parameters. You can adapt for fragments to. A simple example above, but you get the idea.
Solution 8 - Android
Try to do the following:
Create a simple "helper" class (factory for your Intents), like this:
import android.content.Intent;
public class IntentHelper {
public static final Intent createYourSpecialIntent(Intent src) {
return new Intent("YourSpecialIntent").addCategory("YourSpecialCategory").putExtras(src);
}
}
This will be the factory for all your Intents. Everytime you need a new Intent, create a static factory method in IntentHelper. To create a new Intent you should just say it like this:
IntentHelper.createYourSpecialIntent(getIntent());
In your activity. When you want to "save" some data in a "session" just use the following:
IntentHelper.createYourSpecialIntent(getIntent()).putExtra("YOUR_FIELD_NAME", fieldValueToSave);
And send this Intent. In the target Activity your field will be available as:
getIntent().getStringExtra("YOUR_FIELD_NAME");
So now we can use Intent like same old session (like in servlets or JSP).
Solution 9 - Android
You can also pass custom class objects by making a parcelable class. Best way to make it parcelable is to write your class and then simply paste it to a site like http://www.parcelabler.com/. Click on build and you will get new code. Copy all of this and replace the original class contents. Then-
Intent intent = new Intent(getBaseContext(), NextActivity.class);
Foo foo = new Foo();
intent.putExtra("foo", foo);
startActivity(intent);
and get the result in NextActivity like-
Foo foo = getIntent().getExtras().getParcelable("foo");
Now you can simply use the foo object like you would have used.
Solution 10 - Android
Another way is to use a public static field in which you store data, i.e.:
public class MyActivity extends Activity {
public static String SharedString;
public static SomeObject SharedObject;
//...
Solution 11 - Android
The most convenient way to pass data between activities is by passing intents. In the first activity from where you want to send data, you should add code,
String str = "My Data"; //Data you want to send
Intent intent = new Intent(FirstActivity.this, SecondActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
intent.putExtra("name",str); //Here you will add the data into intent to pass bw activites
v.getContext().startActivity(intent);
You should also import
import android.content.Intent;
Then in the next Acitvity(SecondActivity), you should retrieve the data from the intent using the following code.
String name = this.getIntent().getStringExtra("name");
Solution 12 - Android
You can use SharedPreferences
...
-
Logging. Time store session id in
SharedPreferences
SharedPreferences preferences = getSharedPreferences("session",getApplicationContext().MODE_PRIVATE); Editor editor = preferences.edit(); editor.putString("sessionId", sessionId); editor.commit();
-
Signout. Time fetch session id in sharedpreferences
SharedPreferences preferences = getSharedPreferences("session", getApplicationContext().MODE_PRIVATE); String sessionId = preferences.getString("sessionId", null);
If you don't have the required session id, then remove sharedpreferences:
SharedPreferences settings = context.getSharedPreferences("session", Context.MODE_PRIVATE);
settings.edit().clear().commit();
That is very useful, because one time you save the value and then retrieve anywhere of activity.
Solution 13 - Android
From Activity
int n= 10;
Intent in = new Intent(From_Activity.this,To_Activity.class);
Bundle b1 = new Bundle();
b1.putInt("integerNumber",n);
in.putExtras(b1);
startActivity(in);
To Activity
Bundle b2 = getIntent().getExtras();
int m = 0;
if(b2 != null)
{
m = b2.getInt("integerNumber");
}
Solution 14 - Android
The standard approach.
Intent i = new Intent(this, ActivityTwo.class);
AutoCompleteTextView textView = (AutoCompleteTextView) findViewById(R.id.autocomplete);
String getrec=textView.getText().toString();
Bundle bundle = new Bundle();
bundle.putString(“stuff”, getrec);
i.putExtras(bundle);
startActivity(i);
Now in your second activity retrieve your data from the bundle:
Get the bundle
Bundle bundle = getIntent().getExtras();
Extract the data…
String stuff = bundle.getString(“stuff”);
Solution 15 - Android
Kotlin
Pass from First Activity
val intent = Intent(this, SecondActivity::class.java)
intent.putExtra("key", "value")
startActivity(intent)
Get in Second Activity
val value = intent.getStringExtra("key")
Suggestion
Always put keys in constant file for more managed way.
companion object {
val KEY = "key"
}
Solution 16 - Android
You can send data between activities using intent object.
Consider you have two activities namely FirstActivity
and SecondActivity
.
Inside FirstActivity:
Using Intent:
i = new Intent(FirstActivity.this,SecondActivity.class);
i.putExtra("key", value);
startActivity(i)
Inside SecondActivity
Bundle bundle= getIntent().getExtras();
Now you can use different bundle class methods to get values passed from FirstActivity by Key.
E.g.
bundle.getString("key")
,bundle.getDouble("key")
,bundle.getInt("key")
etc.
Solution 17 - Android
If you want to tranfer bitmap between Activites/Fragments
Activity
To pass a bitmap between Activites
Intent intent = new Intent(this, Activity.class);
intent.putExtra("bitmap", bitmap);
And in the Activity class
Bitmap bitmap = getIntent().getParcelableExtra("bitmap");
Fragment
To pass a bitmap between Fragments
SecondFragment fragment = new SecondFragment();
Bundle bundle = new Bundle();
bundle.putParcelable("bitmap", bitmap);
fragment.setArguments(bundle);
To receive inside the SecondFragment
Bitmap bitmap = getArguments().getParcelable("bitmap");
Transfering Large Bitmaps
If you are getting failed binder transaction, this means you are exceeding the binder transaction buffer by transferring large element from one activity to another activity.
So in that case you have to compress the bitmap as an byte's array and then uncompress it in another activity, like this
In the FirstActivity
Intent intent = new Intent(this, SecondActivity.class);
ByteArrayOutputStream stream = new ByteArrayOutputStream();
bitmap.compress(Bitmap.CompressFormat.JPG, 100, stream);
byte[] bytes = stream.toByteArray();
intent.putExtra("bitmapbytes",bytes);
And in the SecondActivity
byte[] bytes = getIntent().getByteArrayExtra("bitmapbytes");
Bitmap bmp = BitmapFactory.decodeByteArray(bytes, 0, bytes.length);
Solution 18 - Android
Intent intent = new Intent(YourCurrentActivity.this, YourActivityName.class);
intent.putExtra("NAme","John");
intent.putExtra("Id",1);
startActivity(intent);
You can retrieve it in another activity. Two ways:
int id = getIntent.getIntExtra("id", /* defaltvalue */ 2);
The second way is:
Intent i = getIntent();
String name = i.getStringExtra("name");
Solution 19 - Android
Here is my best practice and it helps a lot when the project is huge and complex.
Suppose that I have 2 activities, LoginActivity
and HomeActivity
.
I want to pass 2 parameters (username & password) from LoginActivity
to HomeActivity
.
First, I create my HomeIntent
public class HomeIntent extends Intent {
private static final String ACTION_LOGIN = "action_login";
private static final String ACTION_LOGOUT = "action_logout";
private static final String ARG_USERNAME = "arg_username";
private static final String ARG_PASSWORD = "arg_password";
public HomeIntent(Context ctx, boolean isLogIn) {
this(ctx);
//set action type
setAction(isLogIn ? ACTION_LOGIN : ACTION_LOGOUT);
}
public HomeIntent(Context ctx) {
super(ctx, HomeActivity.class);
}
//This will be needed for receiving data
public HomeIntent(Intent intent) {
super(intent);
}
public void setData(String userName, String password) {
putExtra(ARG_USERNAME, userName);
putExtra(ARG_PASSWORD, password);
}
public String getUsername() {
return getStringExtra(ARG_USERNAME);
}
public String getPassword() {
return getStringExtra(ARG_PASSWORD);
}
//To separate the params is for which action, we should create action
public boolean isActionLogIn() {
return getAction().equals(ACTION_LOGIN);
}
public boolean isActionLogOut() {
return getAction().equals(ACTION_LOGOUT);
}
}
Here is how I pass the data in my LoginActivity
public class LoginActivity extends AppCompatActivity {
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_login);
String username = "phearum";
String password = "pwd1133";
final boolean isActionLogin = true;
//Passing data to HomeActivity
final HomeIntent homeIntent = new HomeIntent(this, isActionLogin);
homeIntent.setData(username, password);
startActivity(homeIntent);
}
}
Final step, here is how I receive the data in HomeActivity
public class HomeActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_home);
//This is how we receive the data from LoginActivity
//Make sure you pass getIntent() to the HomeIntent constructor
final HomeIntent homeIntent = new HomeIntent(getIntent());
Log.d("HomeActivity", "Is action login? " + homeIntent.isActionLogIn());
Log.d("HomeActivity", "username: " + homeIntent.getUsername());
Log.d("HomeActivity", "password: " + homeIntent.getPassword());
}
}
Done! Cool :) I just want to share my experience. If you working on small project this shouldn't be the big problem. But when your working on big project, it really pain when you want to do refactoring or fixing bugs.
Solution 20 - Android
Supplemental Answer: Naming Conventions for the Key String
The actual process of passing data has already been answered, however most of the answers use hard coded strings for the key name in the Intent. This is usually fine when used only within your app. However, the documentation recommends using the EXTRA_*
constants for standardized data types.
Example 1: Using Intent.EXTRA_*
keys
First activity
Intent intent = new Intent(getActivity(), SecondActivity.class);
intent.putExtra(Intent.EXTRA_TEXT, "my text");
startActivity(intent);
Second activity:
Intent intent = getIntent();
String myText = intent.getExtras().getString(Intent.EXTRA_TEXT);
Example 2: Defining your own static final
key
If one of the Intent.EXTRA_*
Strings does not suit your needs, you can define your own at the beginning of the first activity.
static final String EXTRA_STUFF = "com.myPackageName.EXTRA_STUFF";
Including the package name is just a convention if you are only using the key in your own app. But it is a necessity to avoid naming conflicts if you are creating some sort of service that other apps can call with an Intent.
First activity:
Intent intent = new Intent(getActivity(), SecondActivity.class);
intent.putExtra(EXTRA_STUFF, "my text");
startActivity(intent);
Second activity:
Intent intent = getIntent();
String myText = intent.getExtras().getString(FirstActivity.EXTRA_STUFF);
Example 3: Using a String resource key
Although not mentioned in the documentation, this answer recommends using a String resource to avoid dependencies between activities.
strings.xml
<string name="EXTRA_STUFF">com.myPackageName.MY_NAME</string>
First activity
Intent intent = new Intent(getActivity(), SecondActivity.class);
intent.putExtra(getString(R.string.EXTRA_STUFF), "my text");
startActivity(intent);
Second activity
Intent intent = getIntent();
String myText = intent.getExtras().getString(getString(R.string.EXTRA_STUFF));
Solution 21 - Android
The passing of data between activities is mainly by means of an intent object.
First you have to attach the data to the intent object with the use of the Bundle
class. Then call the activity using either startActivity()
or startActivityForResult()
methods.
You can find more information about it, with an example from the blog post Passing data to an Activity.
Solution 22 - Android
You can use Intent
Intent mIntent = new Intent(FirstActivity.this, SecondActivity.class);
mIntent.putExtra("data", data);
startActivity(mIntent);
Another way could be using singleton pattern also:
public class DataHolder {
private static DataHolder dataHolder;
private List<Model> dataList;
public void setDataList(List<Model>dataList) {
this.dataList = dataList;
}
public List<Model> getDataList() {
return dataList;
}
public synchronized static DataHolder getInstance() {
if (dataHolder == null) {
dataHolder = new DataHolder();
}
return dataHolder;
}
}
From your FirstActivity
private List<Model> dataList = new ArrayList<>();
DataHolder.getInstance().setDataList(dataList);
On SecondActivity
private List<Model> dataList = DataHolder.getInstance().getDataList();
Solution 23 - Android
You can try Shared Preference, it may be a good alternative for sharing data between the activities
To save session id -
SharedPreferences pref = myContexy.getSharedPreferences("Session
Data",MODE_PRIVATE);
SharedPreferences.Editor edit = pref.edit();
edit.putInt("Session ID", session_id);
edit.commit();
To get them -
SharedPreferences pref = myContexy.getSharedPreferences("Session Data", MODE_PRIVATE);
session_id = pref.getInt("Session ID", 0);
Solution 24 - Android
1st way: In your current Activity, when you create object of intent to open new screen:
String value="xyz";
Intent intent = new Intent(CurrentActivity.this, NextActivity.class);
intent.putExtra("key", value);
startActivity(intent);
Then in the nextActivity in onCreate method, retrieve those values which you pass from previous activity:
if (getIntent().getExtras() != null) {
String value = getIntent().getStringExtra("key");
//The key argument must always match that used send and retrive value from one activity to another.
}
2nd way: You can create bundle object and put values in bundle and then put bundle object in intent from your current activity -
String value="xyz";
Intent intent = new Intent(CurrentActivity.this, NextActivity.class);
Bundle bundle = new Bundle();
bundle.putInt("key", value);
intent.putExtra("bundle_key", bundle);
startActivity(intent);
Then in the nextActivity in onCreate method, retrieve those values which you pass from previous activity:
if (getIntent().getExtras() != null) {
Bundle bundle = getIntent().getStringExtra("bundle_key");
String value = bundle.getString("key");
//The key argument must always match that used send and retrive value from one activity to another.
}
You can also use bean class to pass data between classes using serialization.
Solution 25 - Android
Start another activity from this activity pass parameters via Bundle Object
Intent intent = new Intent(getBaseContext(), YourActivity.class);
intent.putExtra("USER_NAME", "[email protected]");
startActivity(intent);
Retrieve on another activity (YourActivity)
String s = getIntent().getStringExtra("USER_NAME");
This is ok for simple kind data type. But if u want to pass complex data in between activity u need to serialize it first.
Here we have Employee Model
class Employee{
private String empId;
private int age;
print Double salary;
getters...
setters...
}
You can use Gson lib provided by google to serialize the complex data like this
String strEmp = new Gson().toJson(emp);
Intent intent = new Intent(getBaseContext(), YourActivity.class);
intent.putExtra("EMP", strEmp);
startActivity(intent);
Bundle bundle = getIntent().getExtras();
String empStr = bundle.getString("EMP");
Gson gson = new Gson();
Type type = new TypeToken<Employee>() {
}.getType();
Employee selectedEmp = gson.fromJson(empStr, type);
Solution 26 - Android
I recently released Vapor API, a jQuery flavored Android framework that makes all sorts of tasks like this simpler. As mentioned, SharedPreferences
is one way you could do this.
VaporSharedPreferences
is implemented as Singleton so that is one option, and in Vapor API it has a heavily overloaded .put(...)
method so you don't have to explicitly worry about the datatype you are committing - providing it is supported. It is also fluent, so you can chain calls:
$.prefs(...).put("val1", 123).put("val2", "Hello World!").put("something", 3.34);
It also optionally autosaves changes, and unifies the reading and writing process under-the-hood so you don't need to explicitly retrieve an Editor like you do in standard Android.
Alternatively you could use an Intent
. In Vapor API you can also use the chainable overloaded .put(...)
method on a VaporIntent
:
$.Intent().put("data", "myData").put("more", 568)...
And pass it as an extra, as mentioned in the other answers. You can retrieve extras from your Activity
, and furthermore if you are using VaporActivity
this is done for you automatically so you can use:
this.extras()
To retrieve them at the other end in the Activity
you switch to.
Hope that is of interest to some :)
Solution 27 - Android
/*
* If you are from transferring data from one class that doesn't
* extend Activity, then you need to do something like this.
*/
public class abc {
Context context;
public abc(Context context) {
this.context = context;
}
public void something() {
context.startactivity(new Intent(context, anyone.class).putextra("key", value));
}
}
Solution 28 - Android
Write following code in CurrentActivity.java
Intent i = new Intent(CurrentActivity.this, SignOutActivity.class);
i.putExtra("SESSION_ID",sessionId);
startActivity(i);
Access SessionId in SignOutActivity.java is following way
public void onCreate(Bundle savedInstanceState){
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_sign_out);
Intent intent = getIntent();
// check intent is null or not
if(intent != null){
String sessionId = intent.getStringExtra("SESSION_ID");
Log.d("Session_id : " + sessionId);
}
else{
Toast.makeText(SignOutActivity.this, "Intent is null", Toast.LENGTH_SHORT).show();
}
}
Solution 29 - Android
First Activity:
Intent intent = new Intent(getApplicationContext(), ClassName.class);
intent.putExtra("Variable name", "Value you want to pass");
startActivity(intent);
Second Activity:
String str= getIntent().getStringExtra("Variable name which you sent as an extra");
Solution 30 - Android
I use static fields in a class, and get/set them:
Like:
public class Info
{
public static int ID = 0;
public static String NAME = "TEST";
}
For getting a value, use this in an Activity:
Info.ID
Info.NAME
For setting a value:
Info.ID = 5;
Info.NAME = "USER!";
Solution 31 - Android
Charlie Collins gave me a perfect answer using the Application.class
. I was not aware that we could subclass it that easily. Here is a simplified example using a custom application class.
###AndroidManifest.xml
Give the android:name
attribute to use your own application class.
...
<application android:name="MyApplication"
android:allowBackup="true"
android:icon="@drawable/ic_launcher"
android:label="@string/app_name"
android:theme="@style/AppTheme" >
....
###MyApplication.java
Use this as a global reference holder. It works fine within a same process.
public class MyApplication extends Application {
private MainActivity mainActivity;
@Override
public void onCreate() {
super.onCreate();
}
public void setMainActivity(MainActivity activity) { this.mainActivity=activity; }
public MainActivity getMainActivity() { return mainActivity; }
}
###MainActivity.java
Set the global "singleton" reference to the application instance.
public class MainActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
((MyApplication)getApplication()).setMainActivity(this);
}
...
}
###MyPreferences.java
A simple example where I use a main activity from another activity instance.
public class MyPreferences extends PreferenceActivity
implements SharedPreferences.OnSharedPreferenceChangeListener {
@SuppressWarnings("deprecation")
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
addPreferencesFromResource(R.xml.preferences);
PreferenceManager.getDefaultSharedPreferences(this)
.registerOnSharedPreferenceChangeListener(this);
}
@Override
public void onSharedPreferenceChanged(SharedPreferences prefs, String key) {
if (!key.equals("autostart")) {
((MyApplication)getApplication()).getMainActivity().refreshUI();
}
}
}
Solution 32 - Android
Use a global class:
public class GlobalClass extends Application
{
private float vitamin_a;
public float getVitaminA() {
return vitamin_a;
}
public void setVitaminA(float vitamin_a) {
this.vitamin_a = vitamin_a;
}
}
You can call the setters and the getters of this class from all other classes. Do do that, you need to make a GlobalClass-Object in every Actitity:
GlobalClass gc = (GlobalClass) getApplication();
Then you can call for example:
gc.getVitaminA()
Solution 33 - Android
Try this:
CurrentActivity.java
Intent intent = new Intent(currentActivity.this, TargetActivity.class);
intent.putExtra("booktype", "favourate");
startActivity(intent);
TargetActivity.java
Bundle b = getIntent().getExtras();
String typesofbook = b.getString("booktype");
Solution 34 - Android
you can communicate between two activities through intent. Whenever you are navigating to any other activity through your login activity, you can put your sessionId into intent and get that in other activities though getIntent(). Following is the code snippet for that :
> LoginActivity:
Intent intent = new
Intent(YourLoginActivity.this,OtherActivity.class);
intent.putExtra("SESSION_ID",sessionId);
startActivity(intent);
finishAfterTransition();
> OtherActivity:
> In onCreate() or wherever you need it call > getIntent().getStringExtra("SESSION_ID"); > Also make sure to check for if the intent is null and key you are passing in the intent should be same in both activities. Here is the > full code snippet:
if(getIntent!=null && getIntent.getStringExtra("SESSION_ID")!=null){
sessionId = getIntent.getStringExtra("SESSION_ID");
}
> However, I would suggest you to use AppSharedPreferences to store > your sessionId and get it from that wherever needed.
Solution 35 - Android
Best way to pass data to one Activity
to AnothetActivity
by using Intent
,
Check the code snipped
ActivityOne.java
Intent myIntent = new Intent(this, NewActivity.class);
myIntent.putExtra("key_name_one", "Your Data value here");
myIntent.putExtra("key_name_two", "Your data value here");
startActivity(myIntent)
On Your SecondActivity
SecondActivity.java
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.view);
Intent intent = getIntent();
String valueOne = intent.getStringExtra("key_name_one");
String valueTwo = intent.getStringExtra("key_name_two");
}
Solution 36 - Android
To access session id in all activities you have to store session id in SharedPreference.
Please see below class that I am using for managing sessions, you can also use same.
import android.content.Context;
import android.content.SharedPreferences;
public class SessionManager {
public static String KEY_SESSIONID = "session_id";
public static String PREF_NAME = "AppPref";
SharedPreferences sharedPreference;
SharedPreferences.Editor editor;
Context mContext;
public SessionManager(Context context) {
this.mContext = context;
sharedPreference = context.getSharedPreferences(PREF_NAME, Context.MODE_PRIVATE);
editor = sharedPreference.edit();
}
public String getSessionId() {
return sharedPreference.getString(KEY_SESSIONID, "");
}
public void setSessionID(String id) {
editor.putString(KEY_SESSIONID, id);
editor.commit();
editor.apply();
}
}
//Now you can access your session using below methods in every activities.
SessionManager sm = new SessionManager(MainActivity.this);
sm.getSessionId();
//below line us used to set session id on after success response on login page.
sm.setSessionID("test");
Solution 37 - Android
For Using the session id in all the activities you can follow the following steps.
1-Define one STATIC VARIABLE session( which will hold the value of session id ) in the APPLICATION file of your app.
2-Now call the session variable with the class reference where you are fetching the session id value and assign it to static variable.
3-Now you can use this session id value anywhere by just calling the static variable by the
Solution 38 - Android
If you use kotlin:
In MainActivity1:
var intent=Intent(this,MainActivity2::class.java)
intent.putExtra("EXTRA_SESSION_ID",sessionId)
startActivity(intent)
In MainActivity2:
if (intent.hasExtra("EXTRA_SESSION_ID")){
var name:String=intent.extras.getString("sessionId")
}
Solution 39 - Android
Your data object should extend Parcelable or Serializable class
Intent mIntent = new Intent(FirstActivity.this, SecondActivity.class);
mIntent.putExtra("data", data);
startActivity(mIntent);
Solution 40 - Android
To do this in Java:
startActivity(new Intent(this, MainActivity.class).putExtra("userId", "2"));
Solution 41 - Android
You can use intent class to send data between Activities. It is basically a message to OS where you describe source and destination of data flow. Like data from A to B activity.
In ACTIVITY A (the source):
Intent intent = new Intent(A.this, B.class);
intent.putExtra("KEY","VALUE");
startActivity(intent);
In Activity B (the destination)->
Intent intent =getIntent();
String data =intent.getString("KEY");
Here you will get data for key "KEY"
FOR BETTER USE ALWAYS KEYS SHOULD BE STORED IN A CLASS FOR SIMPLICITY AND IT WILL HELP IN MINNIMISE THE RISK OF TYPING ERRORS
Like this:
public class Constants{
public static String KEY="KEY"
}
Now In ACTIVITY A:
intent.putExtra(Constants.KEY,"VALUE");
In Activity B:
String data =intent.getString(Constants.KEY);
Solution 42 - Android
New and real time interaction between activites using callbacks:
- STEP 01: Implement a shared interface
public interface SharedCallback {
public String getSharedText(/*you can define arguments here*/);
}
- STEP 02: Implement a shared class
final class SharedMethode {
private static WeakReference<Context> mContext;
private static SharedMethode sharedMethode = new SharedMethode();
private SharedMethode() {
super();
}
public static SharedMethode getInstance() {
return sharedMethode;
}
public void setContext(Context context) {
if (mContext != null)
return;
mContext = new WeakReference<Context>(context);
}
public boolean contextAssigned() {
return mContext != null && mContext.get() != null;
}
public Context getContext() {
return mContext.get();
}
public void freeContext() {
if (mContext != null) mContext.clear();
mContext = null;
}
}
- STEP 03 :: Play with code in First Activity
public class FirstActivity extends Activity implements SharedCallback {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.your_layout);
// call playMe from here or there
playMe();
}
private void playMe() {
SharedMethode.getInstance().setContext(this);
Intent intent = new Intent(this, SecondActivity.class);
startActivity(intent);
}
@Override
public String getSharedText(/*passed arguments*/) {
return "your result";
}
}
- STEP 04 :: Finalize the game in SecondActivity
public class SecondActivity extends Activity {
private SharedCallback sharedCallback;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.your_layout);
if (SharedMethode.getInstance().contextAssigned()) {
if (SharedMethode.getInstance().getContext() instanceof SharedCallback)
sharedCallback = (SharedCallback) SharedMethode.getInstance().getContext();
// to prevent memory leak
SharedMethode.freeContext();
}
// You can now call your implemented methodes from anywhere at any time
if (sharedCallback != null)
Log.d("TAG", "Callback result = " + sharedCallback.getSharedText());
}
@Override
protected void onDestroy() {
sharedCallback = null;
super.onDestroy();
}
}
- STEP 05 :: you can also implement a backword callback (from First to Second) to get some results from SecondAvtivity or call some methods
Solution 43 - Android
Create new Intent
inside your current activity
String myData="Your string/data here";
Intent intent = new Intent(this, SecondActivity.class);
intent.putExtra("your_key",myData);
startActivity(intent);
Inside your SecondActivity.java
onCreate()
Retrieve those value using key your_key
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Bundle extras = getIntent().getExtras();
if (extras != null) {
String myData = extras.getString("your_key");
}
}
Solution 44 - Android
There are more than one ways of passing data between activities and other components of android app. One is using intents and parcelable as mentioned in lot of answers already.
Another elegent way is using Eventbus library.
From emitting activity:
EventBus.getDefault().postSticky("--your Object--");
In recv activity:
EventBus.getDefault().removeStickyEvent("--Object class--")
Other points to consider:
- Gives more freedom, You can pass complex objects without modifying them in any form.
- Not restricted to passing data between activities only, Once you set up the library, you can use it to pass data from one place to another in the app plumbing. For example use this for BottomSheetMenu to activity communication.
- Stable library.
- simplifies the communication between components
- decouples event senders and receivers
- performs well with UI artifacts (e.g. Activities, Fragments) and background threads
- avoids complex and error-prone dependencies and life cycle issues
- is fast; specifically optimized for high performance
- is tiny (~60k jar)
- is proven in practice by apps with 1,000,000,000+ installs
- has advanced features like delivery threads, subscriber priorities, etc.
Solution 45 - Android
Consider using a singleton to hold your session information accessible to all the Activities.
This approach has several advantages compared to extras and static variables:
-
Allows you to extend Info class, adding new user information settings you need. You could make a new class inheriting it or just edit the Info class without the need to change extras handling in all the places.
-
Easy usage - no need to get extras in every activity.
public class Info { private static Info instance; private int id; private String name; //Private constructor is to disallow instances creation outside create() or getInstance() methods private Info() { } //Method you use to get the same information from any Activity. //It returns the existing Info instance, or null if not created yet. public static Info getInstance() { return instance; } //Creates a new Info instance or returns the existing one if it exists. public static synchronized Info create(int id, String name) { if (null == instance) { instance = new Info(); instance.id = id; instance.name = name; } return instance; } }
Solution 46 - Android
I use public static fields to store shared data between activities, but to minimize its side effects, you may:
- Make only one field, or as few as possible, and reuse them, make them of type object and cast it to desired type in the receiving activity.
- Whenever any of them isn't useful anymore, set it explicitly to null to be collected by the garbage collector, before the next assignment.
Solution 47 - Android
//Your problem is you want to store session id after sign in and available that session id for each activity where you want to logout.
//The solution of your problem is you have to store your session id after successful login in a public variable. and whenever you need session id for logout you can access that variable and replace variables value to zero.
//Serializable class
public class YourClass implements Serializable {
public long session_id = 0;
}
Solution 48 - Android
In the Destination activity define like this
public class DestinationActivity extends AppCompatActivity{
public static Model model;
public static void open(final Context ctx, Model model){
DestinationActivity.model = model;
ctx.startActivity(new Intent(ctx, DestinationActivity.class))
}
public void onCreate(/*Parameters*/){
//Use model here
model.getSomething();
}
}
In the first activity, start the second activity like below
DestinationActivity.open(this,model);
Solution 49 - Android
We can pass the values to another Activity by two ways(same kind of answer already posted but redcing code here i posted which tried through intent)
1.through Intent
Activity1:
startActivity(new Intent(getApplicationContext(),Activity2.class).putExtra("title","values"));
InActivity 2:
String recString= getIntent().getStringExtra("title");
2.Through SharedPreference
Activity1:
SharedPreferences pref = getApplicationContext().getSharedPreferences("MyPref", 0);
// 0 - for private mode
Editor editor = pref.edit();
editor.putString("key_name", "string value"); // Storing string
editor.commit(); // commit changes
Activty2:
SharedPreferences pref = getApplicationContext().getSharedPreferences("MyPref", 0);
pref.getString("key_name", null); // getting String
Solution 50 - Android
Intent intent = new Intent(getBaseContext(), SomeActivity.class);
intent.putExtra("USER_ID", UserId);
startActivity(intent);
On SomeActivity :
String userId= getIntent().getStringExtra("("USER_ID");
Solution 51 - Android
You can work with intent
String sessionId = "my session id";
startActivity(new Intent(getApplicationContext(),SignOutActivity.class).putExtra("sessionId",sessionId));
Solution 52 - Android
Using Bundle
@link https://medium.com/@nikhildhyani365/pass-data-from-one-activity-to-another-using-bundle-18df2a701142
//copy from medium
Intent I = new Intent(MainActivity.this,Show_Details.class);
Bundle b = new Bundle();
int x = Integer.parseInt(age.getText().toString());
int y = Integer.parseInt(className.getText().toString());
b.putString("Name",name.getText().toString());
b.putInt("Age",x);
b.putInt("ClassName",y);
I.putExtra("student",b);
startActivity(I);
Using Intent @link https://android.jlelse.eu/passing-data-between-activities-using-intent-in-android-85cb097f3016
Solution 53 - Android
In other way you can pass data using Interfaces.
We have 2 activity A,B then what will I do, create an interface like:
public interface M{
void data(String m);
}
then You Can call assign value to this method like below in Class A as code below:
public class A extends AppCompatActivity{
M m; //inteface name
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.a);
m= (M) getActivity();
//now call method in interface and send data im sending direct you can use same on click
m.data("Rajeev");
}
}
Now You have to implement that interface in class B:
public class B extends AppCompatActivity implements M{
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.b);
}
@Override
public void data(String m) {
you can use m as your data to toast the value here it will be same value what you sent from class A
}
}