I have one activity which is the main activity used throughout the app and it has a number of variables. I have two other activities which I would like to be able to use the data from the first activity. Now I know I can do something like this:
GlobalState gs = (GlobalState) getApplication();
String s = gs.getTestMe();
However I want to share a lot of variables and some might be rather large so I don't want to be creating copies of them like above.
Is there a way to directly get and change the variables without using get and set methods? I remember reading an article on the Google dev site saying this is not recommended for performance on Android.
Well I have a few ideas, but I don't know if they are what your looking for.
You could use a service that holds all of the data and then just bind your activities to the service for data retrival.
Or package your data into a serializable or parcelable and attach them to a bundle and pass the bundle between activities.
This one may not be at all what your looking for, but you could also try using a SharedPreferences or a preference in general.
Either way let me know what you decide.
There is a new and better way to share data between activities, and it is LiveData. Notice in particular this quote from the Android developer's page:
The fact that LiveData objects are lifecycle-aware means that you can share them between multiple activities, fragments, and services. To keep the example simple, you can implement the LiveData class as a singleton
The implication of this is huge - any model data can be shared in a common singleton class inside a LiveData wrapper. It can be injected from the activities into their respective ViewModel for the sake of testability. And you no longer need to worry about weak references to prevent memory leaks.
There are various way to share data between activities
1: Passing data between activities using Intent
Intent intent=new Intent(this, desirableActivity.class);
intent.putExtra("KEY", "Value");
startActivity(intent)
2: Using static keyword , define variable as public static and use any where in project
public static int sInitialValue=0;
use anywhere in project using classname.variableName;
3: Using Database
but its bit lengthy process, you have to use query for inserting data and iterate data using cursor when need. But there are no chance of losing data without cleaning cache.
4: Using shared Preferences
much easier than database. but there is some limitation you can not save ArrayList ,List and custome objects.
5: Create getter setter in Aplication class and access any where in project.
private String data;
public String getData() {
return data;
}
public void setData(String data) {
this.data = data;
}
here set and get from activities
((YourApplicationClass)getApplicationContext()).setData("abc");
String data=((YourApplicationClass)getApplicationContext()).getData();
All of the aforementioned answers are great... I'm just adding one no one had mentioned yet about persisting data through activities and that is to use the built in android SQLite database to persist relevant data... In fact you can place your databaseHelper in the application state and call it as needed throughout the activates.. Or just make a helper class and make the DB calls when needed... Just adding another layer for you to consider... But all of the other answers would suffice as well.. Really just preference
Sharing data between activites example passing an email after login
"email" is the name that can be used to reference the value on the activity that's being requested
1 Code on the login page
Intent openLoginActivity = new Intent(getBaseContext(), Home.class);
openLoginActivity.putExtra("email", getEmail);
2 code on the home page
Bundle extras = getIntent().getExtras();
accountEmail = extras.getString("email");
Using the hashmap of weak reference approach, described above, and in http://developer.android.com/guide/faq/framework.html seems problematic to me. How are entire entries reclaimed, not just the map value? What scope do you allocate it in? As the framework is in control of the Activity lifecycle, having one of the participating Activities own it risks runtime errors when the owner is destroyed in advance of its clients. If the Application owns it, some Activity must explicitly remove the entry to avoid the hashmap from holding on to entries with a valid key and a potentially garbaged collected weak reference. Furthermore, what should a client do when the value returned for a key is null?
It seems to me that a WeakHashMap owned by the Application or within a singleton is a better choice. An value in the map is accessed via a key object, and when no strong references to the key exist (i.e. all Activities are done with the key and what it maps to), GC can reclaim the map entry.
And if you wanna work with data object, this two implements very important:
public class User implements Parcelable
check more in here
Assuming you are calling activity two from activity one using an Intent.
You can pass the data with the intent.putExtra(),
Take this for your reference. Sending arrays with Intent.putExtra
Hope that's what you want.
What you can use:
What you choose depends on your needs. Probably you will use more than one way when you have "a lot of"
Here a compilation of most common ways to achieve this:
WeakReferencesTL;DR: there are two ways of sharing data: passing data in the intent's extras or saving it somewhere else. If data is primitives, Strings or user-defined objects: send it as part of the intent extras (user-defined objects must implement Parcelable). If passing complex objects save an instance in a singleton somewhere else and access them from the launched activity.
Some examples of how and why to implement each approach:
Intent intent = new Intent(FirstActivity.this, SecondActivity.class);
intent.putExtra("some_key", value);
intent.putExtra("some_other_key", "a value");
startActivity(intent);
On the second activity:
Bundle bundle = getIntent().getExtras();
int value = bundle.getInt("some_key");
String value2 = bundle.getString("some_other_key");
Use this method if you are passing primitive data or Strings. You can also pass objects that implements Serializable.
Although tempting, you should think twice before using Serializable: it's error prone and horribly slow. So in general: stay away from Serializable if possible. If you want to pass complex user-defined objects, take a look at the Parcelable interface. It's harder to implement, but it has considerable speed gains compared to Serializable.
It is possible to share data between activities by saving it in memory given that, in most cases, both activities run in the same process.
Note: sometimes, when the user leaves your activity (without quitting it), Android may decide to kill your application. In such scenario, I have experienced cases in which android attempts to launch the last activity using the intent provided before the app was killed. In this cases, data stored in a singleton (either yours or Application) will be gone and bad things could happen. To avoid such cases, you either persist objects to disk or check data before using it to make sure its valid.
Have a class to hold the data:
public class DataHolder {
private String data;
public String getData() {return data;}
public void setData(String data) {this.data = data;}
private static final DataHolder holder = new DataHolder();
public static DataHolder getInstance() {return holder;}
}
From the launched activity:
String data = DataHolder.getInstance().getData();
The application singleton is an instance of android.app.Application which is created when the app is launched. You can provide a custom one by extending Application:
import android.app.Application;
public class MyApplication extends Application {
private String data;
public String getData() {return data;}
public void setData(String data) {this.data = data;}
}
Before launching the activity:
MyApplication app = (MyApplication) getApplicationContext();
app.setData(someData);
Then, from the launched activity:
MyApplication app = (MyApplication) getApplicationContext();
String data = app.getData();
The idea is basically the same as the singleton, but in this case you provide static access to the data:
public class DataHolder {
private static String data;
public static String getData() {return data;}
public static void setData(String data) {DataHolder.data = data;}
}
From the launched activity:
String data = DataHolder.getData();
WeakReferencesSame idea, but allowing the garbage collector to removed unreferenced objects (e.g. when the user quits the activity):
public class DataHolder {
Map<String, WeakReference<Object>> data = new HashMap<String, WeakReference<Object>>();
void save(String id, Object object) {
data.put(id, new WeakReference<Object>(object));
}
Object retrieve(String id) {
WeakReference<Object> objectWeakReference = data.get(id);
return objectWeakReference.get();
}
}
Before launching the activity:
DataHolder.getInstance().save(someId, someObject);
From the launched activity:
DataHolder.getInstance().retrieve(someId);
You may or may not have to pass the object id using the intent’s extras. It all depends on your specific problem.
The idea is to save the data in disk before launching the other activity.
Advantages: you can launch the activity from other places and, if the data is already persisted, it should work just fine.
Disadvantages: it’s cumbersome and takes more time to implement. Requires more code and thus more chance of introducing bugs. It will also be much slower.
Some of the ways to persist objects include:
If your intention is to call other Activities from the current Activity, you should use Intents. Your focus could be less on persisting data than on sharing it on an as-needed basis.
However, if you really need to persist these values then you could persist them in some kind of structured text file or database on local storage. A properties file, XML file, or JSON file could store your data and be easily parsed during activity creation. Don't forget also that you have SQLite on all Android devices, so you could store them in a database table. You could also use a Map to store key-value pairs and serialize the map to local storage, but this might be too cumbersome to be useful for simple data structures.
Do what google commands you to do! here: http://developer.android.com/resources/faq/framework.html#3
"However I want to share alot of variables and some might be rather large so I don't want to be creating copies of them like above."
That doesn't make a copy (especially with String, but even objects are pass by value of the reference, not the object itself, and getter's like that are fine to use -- arguably better to use than other means because they are common and well understood). The older "performance myths," such as not using getters and setters, still have some value, but have also been updated in the docs.
But if you don't want to do that, you could also just make the variables public or protected in GlobalState and access them directly. And, you can make a static singleton as the Application object JavaDoc indicates:
There is normally no need to subclass Application. In most situation, static singletons can provide the same functionality in a more modular way. If your singleton needs a global context (for example to register broadcast receivers), the function to retrieve it can be given a Context which internally uses Context.getApplicationContext() when first constructing the singleton.
Using Intent data, as other answers here note is another way to pass data, but it's usually used for smaller data and simple types. You can pass larger/more complex data, but it's more involved than just using a static singleon. The Application object is still my personal favorite for sharing larger/more complex non persistent data between Android application components though (because it has a well defined lifecycle in an Android app).
Also, as others have noted, if the data gets very complex and needs to be persistent then you can use SQLite or the filesystem too.
You could extend the Application class and tag on any objects you want there, they are then available anywhere in your application
Source: Stackoverflow.com