Eu tenho um cenário em que, depois de fazer login através de uma página de login, haverá uma saída buttonem cada uma activity.

Ao clicar sign-out, passarei o session idusuário conectado para sair. Alguém pode me orientar sobre como manter a session iddisponibilidade para todos activities?

Qualquer alternativa para este caso

A maneira mais fácil de fazer isso seria passar o ID da sessão para a atividade de logout no site que Intentvocê está usando para iniciar a atividade:

Intent intent = new Intent(getBaseContext(), SignoutActivity.class);
intent.putExtra("EXTRA_SESSION_ID", sessionId);
startActivity(intent);

Acesse essa intenção na próxima atividade:

String sessionId = getIntent().getStringExtra("EXTRA_SESSION_ID");

Os documentos para Intents têm mais informações (consulte a seção "Extras").

Na sua Atividade atual, crie um novo Intent:

String value="Hello world";
Intent i = new Intent(CurrentActivity.this, NewActivity.class);    
i.putExtra("key",value);
startActivity(i);

Em seguida, na nova atividade, recupere esses valores:

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 esta técnica para passar variáveis ​​de uma atividade para outra.

Passar Intenção extras é uma boa abordagem, como observou Erich.

No entanto, o objeto Aplicativo é outra maneira, e às vezes é mais fácil lidar com o mesmo estado em várias atividades (em vez de precisar colocá-lo / colocá-lo em qualquer lugar) ou objetos mais complexos que primitivos e Strings.

Você pode estender o Aplicativo e definir / obter o que quiser lá e acessá-lo em qualquer Atividade (no mesmo aplicativo) com getApplication () .

Lembre-se também de que outras abordagens que você pode ver, como a estática, podem ser problemáticas porque podem levar a vazamentos de memória . Aplicação ajuda a resolver isso também.

Classe de origem:

Intent myIntent = new Intent(this, NewActivity.class);
myIntent.putExtra("firstName", "Your First Name Here");
myIntent.putExtra("lastName", "Your Last Name Here");
startActivity(myIntent)

Classe de destino (classe NewActivity):

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");
}

Você só precisa enviar extras enquanto chama sua intenção.

Como isso:

Intent intent = new Intent(getApplicationContext(), SecondActivity.class);
intent.putExtra("Variable name", "Value you want to pass");
startActivity(intent);

Agora, no seu OnCreatemétodo, SecondActivityvocê pode buscar os extras como este.

Se o valor que você enviou estava emlong :

long value = getIntent().getLongExtra("Variable name which you sent as an extra", defaultValue(you can give it anything));

Se o valor que você enviou foiString :

String value = getIntent().getStringExtra("Variable name which you sent as an extra");

Se o valor que você enviou foiBoolean :

Boolean value = getIntent().getBooleanExtra("Variable name which you sent as an extra", defaultValue);

Isso me ajuda a ver as coisas em contexto. Aqui estão dois exemplos.

Passando dados para a frente

Atividade principal

• Coloque os dados que você deseja enviar em um Intent com um par de valor-chave. Veja esta resposta para convenções de nomenclatura para a chave.
• Inicie a segunda atividade com 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);
    }
}

Segunda atividade

• Você usa getIntent()para iniciar o Intentque iniciou a segunda atividade. Em seguida, você pode extrair os dados com getExtras()e a chave que você definiu na primeira atividade. Como nossos dados são uma String, usaremos apenas getStringExtraaqui.

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);
    }
}

Passando dados de volta

Atividade principal

• Inicie a segunda atividade com startActivityForResult, fornecendo um código de resultado arbitrário.
• Substituir onActivityResult. Isso é chamado quando a Segunda Atividade termina. Você pode ter certeza de que é realmente a segunda atividade, verificando o código do resultado. (Isso é útil quando você está iniciando várias atividades diferentes da mesma atividade principal.)
• Extraia os dados que você obteve do retorno Intent. Os dados são extraídos usando um par de valores-chave. Eu poderia usar qualquer string para a chave, mas usarei o predefinido, Intent.EXTRA_TEXTpois estou enviando texto.

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);
            }
        }
    }
}

Segunda atividade

• Coloque os dados que você deseja enviar de volta para a atividade anterior em um Intent. Os dados são armazenados no Intentpar usando valor-chave. Eu escolhi usar Intent.EXTRA_TEXTa minha chave.
• Defina o resultado como RESULT_OKe adicione a intenção que contém seus dados.
• Ligue finish()para fechar a segunda atividade.

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();
    }
}

Atualizado Observe que eu havia mencionado o uso de SharedPreference . Possui uma API simples e é acessível nas atividades de um aplicativo. Mas essa é uma solução desajeitada e representa um risco de segurança se você passar dados confidenciais. É melhor usar intenções. Possui uma extensa lista de métodos sobrecarregados que podem ser usados ​​para transferir melhor muitos tipos de dados diferentes entre as atividades. Dê uma olhada em intent.putExtra . Este link apresenta o uso do putExtra muito bem.

Ao passar dados entre atividades, minha abordagem preferida é criar um método estático para a atividade relevante que inclua os parâmetros necessários para ativar a intenção. Que, então, fornece facilmente os parâmetros de configuração e recuperação. Então pode ficar assim

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, ...));
...

Em seguida, você pode criar uma intenção para a atividade pretendida e garantir que você tenha todos os parâmetros. Você pode se adaptar a fragmentos. Um exemplo simples acima, mas você entendeu a ideia.

Tente fazer o seguinte:

Crie uma classe "auxiliar" simples (de fábrica para seus Intents), assim:

import android.content.Intent;

public class IntentHelper {
    public static final Intent createYourSpecialIntent(Intent src) {
          return new Intent("YourSpecialIntent").addCategory("YourSpecialCategory").putExtras(src);
    }
}

Esta será a fábrica para todos os seus objetivos. Sempre que você precisar de um novo Intent, crie um método estático de fábrica no IntentHelper. Para criar um novo Intent, basta dizer assim:

IntentHelper.createYourSpecialIntent(getIntent());

Na sua atividade. Quando você quiser "salvar" alguns dados em uma "sessão", use o seguinte:

IntentHelper.createYourSpecialIntent(getIntent()).putExtra("YOUR_FIELD_NAME", fieldValueToSave);

E envie essa intenção. Na atividade de destino, seu campo estará disponível como:

getIntent().getStringExtra("YOUR_FIELD_NAME");

Portanto, agora podemos usar o Intent como a mesma sessão antiga (como em servlets ou JSP ).

Você também pode passar objetos de classe personalizados criando uma classe parcelável . A melhor maneira de torná-lo parcelável é escrever sua turma e simplesmente colá-la em um site como http://www.parcelabler.com/ . Clique no build e você receberá um novo código. Copie tudo isso e substitua o conteúdo da classe original. Então-

Intent intent = new Intent(getBaseContext(), NextActivity.class);
Foo foo = new Foo();
intent.putExtra("foo", foo);
startActivity(intent);

e obtenha o resultado no NextActivity como

Foo foo = getIntent().getExtras().getParcelable("foo");

Agora você pode simplesmente usar o objeto foo como você teria usado.

Outra maneira é usar um campo estático público no qual você armazena dados, ou seja:

public class MyActivity extends Activity {

  public static String SharedString;
  public static SomeObject SharedObject;

//...

A maneira mais conveniente de passar dados entre as atividades é passando as intenções. Na primeira atividade de onde você deseja enviar dados, você deve adicionar código,

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);

Você também deve importar

import android.content.Intent;

Em seguida, na próxima Acitvity (SecondActivity), você deve recuperar os dados da intenção usando o código a seguir.

String name = this.getIntent().getStringExtra("name");

Você pode usar SharedPreferences...

1. Exploração madeireira. ID da sessão do repositório de horasSharedPreferences

   SharedPreferences preferences = getSharedPreferences("session",getApplicationContext().MODE_PRIVATE);
   Editor editor = preferences.edit();
   editor.putString("sessionId", sessionId);
   editor.commit();

2. Sair. ID da sessão de busca por tempo em preferências compartilhadas

   SharedPreferences preferences = getSharedPreferences("session", getApplicationContext().MODE_PRIVATE);
   String sessionId = preferences.getString("sessionId", null);

Se você não tiver o ID de sessão necessário, remova as preferências compartilhadas:

SharedPreferences settings = context.getSharedPreferences("session", Context.MODE_PRIVATE);
settings.edit().clear().commit();

Isso é muito útil, porque uma vez você salva o valor e recupera qualquer lugar da atividade.

A abordagem padrão.

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);

Agora, na sua segunda atividade, recupere seus dados do pacote:

Obter o pacote

Bundle bundle = getIntent().getExtras();

Extraia os dados ...

String stuff = bundle.getString(“stuff”); 

Da atividade

 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);

Para Atividade

 Bundle b2 = getIntent().getExtras();
 int m = 0;
 if(b2 != null)
  {
     m = b2.getInt("integerNumber");
  }

Você pode enviar dados entre atividades usando o objeto de intenção. Considere que você tem duas atividades, a saber FirstActivitye SecondActivity.

Por dentro da FirstActivity:

Usando Intenção:

i = new Intent(FirstActivity.this,SecondActivity.class);
i.putExtra("key", value);
startActivity(i)

Inside SecondActivity

Bundle bundle= getIntent().getExtras();

Agora você pode usar métodos diferentes de classe de pacote configurável para obter valores transmitidos do FirstActivity por Key.

Por exemplo bundle.getString("key"), bundle.getDouble("key"), bundle.getInt("key")etc.

Se você deseja transferir bitmap entre Atividades / Fragmentos

Atividade

Para passar um bitmap entre as atividades

Intent intent = new Intent(this, Activity.class);
intent.putExtra("bitmap", bitmap);

E na classe Activity

Bitmap bitmap = getIntent().getParcelableExtra("bitmap");

Fragmento

Para passar um bitmap entre fragmentos

SecondFragment fragment = new SecondFragment();
Bundle bundle = new Bundle();
bundle.putParcelable("bitmap", bitmap);
fragment.setArguments(bundle);

Para receber dentro do SecondFragment

Bitmap bitmap = getArguments().getParcelable("bitmap");

Transferindo bitmaps grandes

Se você está obtendo uma falha na transação do fichário, isso significa que você está excedendo o buffer da transação do fichário transferindo um elemento grande de uma atividade para outra.

Portanto, nesse caso, você precisa compactar o bitmap como uma matriz de bytes e descompactá-lo em outra atividade , como esta

Na 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);

E na SecondActivity

byte[] bytes = getIntent().getByteArrayExtra("bitmapbytes");
Bitmap bmp = BitmapFactory.decodeByteArray(bytes, 0, bytes.length);

Intent intent = new Intent(YourCurrentActivity.this, YourActivityName.class);
intent.putExtra("NAme","John");
intent.putExtra("Id",1);
startActivity(intent);

Você pode recuperá-lo em outra atividade. Dois caminhos:

int id = getIntent.getIntExtra("id", /* defaltvalue */ 2);

A segunda maneira é:

Intent i = getIntent();
String name = i.getStringExtra("name");

Aqui está minha melhor prática e ajuda muito quando o projeto é enorme e complexo.

Suponha que eu tenha 2 atividades LoginActivitye HomeActivity. Quero passar 2 parâmetros (nome de usuário e senha) de LoginActivitypara HomeActivity.

Primeiro, eu crio meu 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);
    }
}

Aqui está como passo os dados em meu 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);

    }
}

Etapa final, eis como recebo os dados em 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());
    }
}

Feito! Legal :) Eu só quero compartilhar minha experiência. Se você está trabalhando em um projeto pequeno, esse não deve ser o grande problema. Mas quando você está trabalhando em um grande projeto, é realmente doloroso quando você quer refatorar ou corrigir bugs.

Resposta complementar: Convenções de nomenclatura para a sequência de chaves

O processo real de transmissão de dados já foi respondido, no entanto, a maioria das respostas usa seqüências codificadas para o nome da chave no Intent. Geralmente, isso é bom quando usado apenas no seu aplicativo. No entanto, a documentação recomenda o uso de EXTRA_*constantes para tipos de dados padronizados.

Exemplo 1: Usando Intent.EXTRA_*Chaves

Primeira atividade

Intent intent = new Intent(getActivity(), SecondActivity.class);
intent.putExtra(Intent.EXTRA_TEXT, "my text");
startActivity(intent);

Segunda atividade:

Intent intent = getIntent();
String myText = intent.getExtras().getString(Intent.EXTRA_TEXT);

Exemplo 2: Definindo sua própria static finalchave

Se uma das Intent.EXTRA_*Strings não atender às suas necessidades, você poderá definir suas próprias no início da primeira atividade.

static final String EXTRA_STUFF = "com.myPackageName.EXTRA_STUFF";

Incluir o nome do pacote é apenas uma convenção se você estiver usando apenas a chave no seu próprio aplicativo. Mas é necessário evitar conflitos de nomenclatura se você estiver criando algum tipo de serviço que outros aplicativos podem chamar com um Intent.

Primeira atividade:

Intent intent = new Intent(getActivity(), SecondActivity.class);
intent.putExtra(EXTRA_STUFF, "my text");
startActivity(intent);

Segunda atividade:

Intent intent = getIntent();
String myText = intent.getExtras().getString(FirstActivity.EXTRA_STUFF);

Exemplo 3: Usando uma Chave de Recurso String

Embora não mencionado na documentação, esta resposta recomenda o uso de um recurso String para evitar dependências entre as atividades.

strings.xml

 <string name="EXTRA_STUFF">com.myPackageName.MY_NAME</string>

Primeira atividade

Intent intent = new Intent(getActivity(), SecondActivity.class);
intent.putExtra(getString(R.string.EXTRA_STUFF), "my text");
startActivity(intent);

Segunda atividade

Intent intent = getIntent();
String myText = intent.getExtras().getString(getString(R.string.EXTRA_STUFF));

Você pode usar Intent

Intent mIntent = new Intent(FirstActivity.this, SecondActivity.class);
mIntent.putExtra("data", data);
startActivity(mIntent);

Outra maneira poderia estar usando o padrão singleton também:

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;
 }
}

De sua FirstActivity

private List<Model> dataList = new ArrayList<>();
DataHolder.getInstance().setDataList(dataList);

Em SecondActivity

private List<Model> dataList = DataHolder.getInstance().getDataList();

A passagem de dados entre atividades é principalmente por meio de um objeto de intenção.

Primeiro, você deve anexar os dados ao objeto de intenção com o uso da Bundleclasse. Em seguida, chamar a actividade utilizando um startActivity()ou startActivityForResult()métodos.

Você pode encontrar mais informações sobre isso, com um exemplo da postagem do blog Passando dados para uma atividade .

Você pode tentar a preferência compartilhada; pode ser uma boa alternativa para compartilhar dados entre as atividades

Para salvar o ID da sessão -

SharedPreferences pref = myContexy.getSharedPreferences("Session 
Data",MODE_PRIVATE);
SharedPreferences.Editor edit = pref.edit();
edit.putInt("Session ID", session_id);
edit.commit();

Para obtê-los -

SharedPreferences pref = myContexy.getSharedPreferences("Session Data", MODE_PRIVATE);
session_id = pref.getInt("Session ID", 0);

Iniciar outra atividade a partir desta atividade passar parâmetros via Bundle Object

Intent intent = new Intent(getBaseContext(), YourActivity.class);
intent.putExtra("USER_NAME", "xyz@gmail.com");
startActivity(intent);

Recuperar em outra atividade (YourActivity)

String s = getIntent().getStringExtra("USER_NAME");

Isso é bom para tipos de dados simples. Mas se você quiser passar dados complexos entre as atividades, precisará serializá-los primeiro.

Aqui temos o modelo de funcionário

class Employee{
    private String empId;
    private int age;
    print Double salary;

    getters...
    setters...
}

Você pode usar o Gson lib fornecido pelo google para serializar dados complexos como este

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);

Kotlin

Passe da Primeira Atividade

val intent = Intent(this, SecondActivity::class.java)
intent.putExtra("key", "value")
startActivity(intent)

Entre na Segunda Atividade

val value = getIntent().getStringExtra("key")

Sugestão

Sempre coloque as chaves em um arquivo constante para uma maneira mais gerenciada.

companion object {
    val KEY = "key"
}

/*
 * 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));
    }
}

Charlie Collins me deu uma resposta perfeita usando o Application.class. Eu não sabia que poderíamos subclassificar tão facilmente. Aqui está um exemplo simplificado usando uma classe de aplicativo customizada.

AndroidManifest.xml

Atribua o android:nameatributo para usar sua própria classe de aplicativo.

...
<application android:name="MyApplication"
    android:allowBackup="true"
    android:icon="@drawable/ic_launcher"
    android:label="@string/app_name"
    android:theme="@style/AppTheme" >
....

MyApplication.java

Use isso como um detentor de referência global. Funciona bem dentro de um mesmo processo.

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

Defina a referência global "singleton" para a instância do aplicativo.

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

Um exemplo simples em que eu uso uma atividade principal de outra instância de atividade.

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();
        }
    }
}

Lancei recentemente a API Vapor , uma estrutura Android com sabor jQuery que simplifica todos os tipos de tarefas como essa. Como mencionado, SharedPreferencesé uma maneira de fazer isso.

VaporSharedPreferencesé implementado como Singleton, de modo que é uma opção e, na API do Vapor, ele possui um .put(...)método muito sobrecarregado , para que você não precise se preocupar explicitamente com o tipo de dados que está enviando - desde que com suporte. Também é fluente, para que você possa encadear chamadas:

$.prefs(...).put("val1", 123).put("val2", "Hello World!").put("something", 3.34);

Ele também opcionalmente salva automaticamente as alterações e unifica o processo de leitura e gravação por baixo do capô, para que você não precise recuperar explicitamente um editor como no Android padrão.

Alternativamente, você pode usar um Intent. Na API do Vapor, você também pode usar o .put(...)método sobrecarregado encadeável em VaporIntent:

$.Intent().put("data", "myData").put("more", 568)...

E passe-o como um extra, como mencionado nas outras respostas. Você pode recuperar extras do seu Activitye, além disso, se você estiver usando, VaporActivityisso é feito automaticamente para que você possa usar:

this.extras()

Para recuperá-los na outra extremidade na Activityopção para.

Espero que seja do interesse de alguns :)

Primeira atividade:

Intent intent = new Intent(getApplicationContext(), ClassName.class);
intent.putExtra("Variable name", "Value you want to pass");
startActivity(intent);

Segunda atividade:

String str= getIntent().getStringExtra("Variable name which you sent as an extra");

Você pode passar dados entre atividades no aplicativo de 3 maneiras

1. Intenção
2. Preferências Compartilhadas
3. Inscrição

transmitir dados intencionalmente tem algum limite. Para grande quantidade de dados, você pode usar o compartilhamento de dados no nível do aplicativo e armazená-lo no SharedPreference aumenta o tamanho do aplicativo

Use uma classe global:

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;
    }
}

Você pode chamar os setters e os getters desta classe de todas as outras classes. Faça isso, você precisa criar um Objeto GlobalClass em cada Atividade:

GlobalClass gc = (GlobalClass) getApplication();

Então você pode ligar, por exemplo:

gc.getVitaminA()