android parcelable intent,Intent and Parcelable object Android

Primitive Data Types

To share primitive data between Activities/Services in an application,

use Intent.putExtras(). For passing primitive data that needs to

persist use the Preferences storage mechanism. Non-Persistent Objects

For sharing complex non-persistent user-defined objects for short

duration, the following approaches are recommended:

Singleton class

You can take advantage of the fact that your application components

run in the same process through the use of a singleton. This is a

class that is designed to have only one instance. It has a static

method with a name such as getInstance() that returns the instance;

the first time this method is called, it creates the global instance.

Because all callers get the same instance, they can use this as a

point of interaction. For example activity A may retrieve the instance

and call setValue(3); later activity B may retrieve the instance and

call getValue() to retrieve the last set value.

A public static field/method

An alternate way to make data accessible across Activities/Services is

to use public static fields and/or methods. You can access these

static fields from any other class in your application. To share an

object, the activity which creates your object sets a static field to

point to this object and any other activity that wants to use this

object just accesses this static field.

A HashMap of WeakReferences to Objects

You can also use a HashMap of WeakReferences to Objects with Long

keys. When an activity wants to pass an object to another activity, it

simply puts the object in the map and sends the key (which is a unique

Long based on a counter or time stamp) to the recipient activity via

intent extras. The recipient activity retrieves the object using this

key.

Persistent Objects

Even while an application appears to continue running, the system may

choose to kill its process and restart it later. If you have data that

you need to persist from one activity invocation to the next, you need

to represent that data as state that gets saved by an activity when it

is informed that it might go away.

For sharing complex persistent user-defined objects, the following

approaches are recommended:

- Application Preferences

- Files

- contentProviders

- SQLite DB

If the shared data needs to be retained across points where the

application process can be killed, then place that data in persistent

storage like Application Preferences, SQLite DB, Files or

ContentProviders. Please refer to the Data Storage for further details

on how to use these components.