Como transmito dados entre o aplicativo Atividades no Android?

1349

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

UMAR
fonte
14
i usado sharedpreference sua utilidade também para manter os dados de login no recurso de senha lembre
shareef
Isso funciona para mim. stackoverflow.com/a/7325248/2125322 Obrigado Darshan Computing
matasoy
nesses casos, tente fazer a classe commomUtils com o método sharedprefereces ... isso manterá o código limpo e os dados relacionados em um local. E você pode facilmente ser capaz de limpar conjunto específico de dados com apenas um método de compensação que específica prefrencesFile, sem limpar qualquer um dos dados de aplicativos padrão ...
Muahmmad Tayyib

Respostas:

1266

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").

Erich Douglass
fonte
ok se eu passar o id da sessão para sair da atividade no login bem-sucedido e ele funcionará em qualquer página de atividade para sair ou manualmente, terei que atribuir valor a cada atividade ??? usando o procedimento acima?
UMAR
5
Sim, você precisaria disponibilizar o ID da sessão para todas as atividades nas quais deseja permitir que o usuário saia. Como alternativa, você pode armazená-lo no objeto Aplicativo, mas precisará gerenciar o estado da sessão (verifique se é válido antes de usar, etc.).
Erich Douglass
1
Esteja ciente de que a documentação aponta o seguinte: Adicione dados estendidos à intenção. O nome deve incluir um prefixo de pacote, por exemplo, o aplicativo com.android.contacts usaria nomes como "com.android.contacts.ShowAll".
Serguei Fedorov
1
E para ler dados de outro uso AtividadeLong session_ids=getIntent().getExtras().getLong("EXTRA_SESSION_IDS");
Farid
1
Como podemos passar dados usando setDatae qual a diferença entre essas duas abordagens? Qual é o melhor?
Hosein Aqajani
1402

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.

user914425
fonte
58
Apenas uma informação para aqueles que são tão cegos como eu: se você colocar um número inteiro em sua atividade atual, precisará obtê-lo no novo extras.getInt("new_variable_name"). Se você tentar obtê-lo via getString()android, veja que um int foi dado e retorna nulo!
bish
4
e se a atividade já estiver em execução, é necessário fazer startActivity(i);? Quero dizer, posso fazer a atividade A chamar a atividade B e isso retorna os dados à atividade A ? estou confuso?
Francisco Corrales Morales
Eu prefiro variável de string. Você sempre pode converter uma string em número inteiro ou flutuar mais tarde.
user914425
140

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.

Charlie Collins
fonte
8
+1 para o problema de estática. provavelmente a limpeza pode ser resolvida combinando um singleton com o método onCreate / onTerminate Classe Application.
Syd
10
Ei, eu sei que esse tópico já faz um bom tempo, mas o link fornecido agora é um beco sem saída. Existe algum lugar para encontrar o exemplo?
sumo de
Como conseguir isso usando o Application? @CharlieCollins
Banee Ishaque K
Aqui está um exemplo atualizada deste aqui, de um livro muito antigo :) github.com/charlieCollins/android-in-practice/blob/master/ch07/...
Charlie Collins
@JuiCe A postagem do blog Android Developers sobre vazamentos de memória não é mais inválida.
Edric
94

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");
}
Md. Rahman
fonte
3
A intenção pode ser nula? Devemos verificar se não é nulo?
Micro
Esta é uma duplicata dos 3 anos mais velho top mais votado resposta e de resposta de Sahil Mahajan Mj e de resposta de Mayank Saini
Murmel
85

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);
Mayank Saini
fonte
3
Esteja ciente de que a documentação aponta o seguinte: Adicione dados estendidos à intenção. O nome deve incluir um prefixo de pacote, por exemplo, o aplicativo com.android.contacts usaria nomes como "com.android.contacts.ShowAll".
Serguei Fedorov
Esta é uma duplicata da resposta mais votada, que existe há 2 anos antes dessa resposta e da resposta de Sahil Mahajan Mj, que é 1 ano mais velha. Única diferença: exemplos booleane longgetters que valem um comentário IMO, não uma resposta.
Murmel
48

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

Passando dados para a frente

insira a descrição da imagem aqui

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

insira a descrição da imagem aqui

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();
    }
}
Suragch
fonte
3
Uau, obrigada! Era exatamente o que eu estava procurando. É bastante claro ao usar a câmera ou outras fontes externas que espero obter resultados de volta, mas não pensei em usá-la internamente. Você é o primeiro a colocá-lo tão abertamente.
user3195231
45

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.

angryITguy
fonte
2
Gosto mais da sua resposta ... Passá-la através da intenção significa que em quase todos os lugares onde inicio uma atividade você precisará se lembrar de incluir o sessionId. Ao colocá-lo nas SharedPreferences, você pode obtê-lo a qualquer momento em qualquer atividade. : 0)
bytebender 28/02
@bytebender Eu sei que isso é um pouco tarde para a resposta, agradeço que você goste da minha resposta original por sua simplicidade, mas eu seria cuidadoso ao armazenar o ID da sessão em preferências compartilhadas. Se você precisar armazená-lo no armazenamento rígido, use a criptografia. Se você puder usar estruturas de autenticação que empregam JWT, ele incluirá refreshTokens, que são mais seguros para armazenamento de longo prazo, e manterá o token de sessão atual como uma propriedade pública de um objeto Application personalizado para acessar facilmente os tokens de autenticação e reduzir a sobrecarga da atividade. assinaturas de intenção.
angryITguy 27/05/19
38

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

ponkin
fonte
28

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.

Vaibhav Sharma
fonte
23

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;

//...
ComputerSaysNo
fonte
5
Eu realmente me pergunto por que sua sugestão não recebeu votos, é mais simples e mais prática.
Porizm
7
hum ... isso não viola os princípios OO?
Christian Vielma
2
@ChristianVielma bem, é mais como uma área cinzenta ... você pode fazer de várias maneiras, para mim parece um "escape" limpo, então ... cabe a você (o desenvolvedor) tomar a decisão se funciona bem para você ou não, eu gosto desse jeito porque é mais fácil de seguir, mas pode ficar muito sujo muito rápido ... #
ComputerSays
2
por que você diz que isso fica sujo? O iOS não faz isso para passar dados entre os controladores de exibição definindo "propriedades" semelhantes a isso? Isto é muito mais fácil do que usar as intenções
Terry Bu
2
Sim, você passa dados entre os controladores de exibição, mas não com propriedades estáticas . O problema é que não é uma propriedade na instância de atividade desejada. Da maneira como o Android lança atividades via startActivity (), ele não instancia instantaneamente o objeto e permite que o desenvolvedor defina uma variável de instância. É muito chato ...
Shawn
20

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");
Sahil Mahajan Mj
fonte
2
Esta é uma duplicata da resposta mais votada, que existe há mais de 1 ano.
Murmel 21/11
19

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.

Ravi Parsania
fonte
17

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”); 
Ajay Venugopal
fonte
1
Duplicar como já proposto pelo PRABEESH RK em 2012. E poderia ser reduzido para o i.putExtras()/ getIntent().getString()que é proposto por 6 outras respostas ...
Murmel
17

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");
  }
Gavine Joyce
fonte
1
Duplicado: A Bundleabordagem baseada já foi proposta por PRABEESH RK em 2012 e Ajay Venugopal , Krishna . E poderia ser reduzido para o i.putExtras()/ getIntent().getString()que é proposto por 8 outras respostas ...
Murmel
11

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.

Krishna
fonte
1
Duplicado: A Bundleabordagem baseada já foi proposta por PRABEESH RK em 2012 e por Ajay Venugopal . E poderia ser reduzido para o i.putExtras()/ getIntent().getString()que é proposto por 7 outras respostas ...
Murmel
11

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);
capt.swag
fonte
9
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");
Dilavar Malek
fonte
Esta é uma duplicata dos 3 anos mais velho top mais votado resposta e de resposta de Sahil Mahajan Mj e de resposta de Mayank Saini e resposta Md de Rahman.
Murmel
8

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.

THANN Phearum
fonte
7

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

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();
Sachin
fonte
Duplicar: A abordagem intenção já é proposto pelo topo mais votado resposta e de resposta de Sahil Mahajan Mj e de resposta de Mayank Saini e resposta Md de Rahman. , A resposta de Dilavar M , a resposta do desenvolvedor android , sahulab . Singleton: Rodion Altshuler resposta
Murmel
6

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 .

PRABEESH RK
fonte
É mais ou menos o mesmo que usar diretamente os métodos fornecidos pelo Intent ( Intent#putExtra()). Mas acrescenta outro Bundlee torna as coisas mais complicadas.
Murmel
6

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);
Rohit Gurjar
fonte
Duplicado: Essa abordagem já foi adotada por Ravi Parsania em 2014
Murmel
5

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

Intent intent = new Intent(getBaseContext(), YourActivity.class);
intent.putExtra("USER_NAME", "[email protected]");
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);
DroidNinja
fonte
5

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"
}
Khemraj
fonte
4
/*
 * 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));
    }
}
Dip Pokhrel
fonte
4

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();
        }
    }
}
Quem eu
fonte
4

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

Darius
fonte
@BaneeIshaqueK sim, desculpe, não mantive isso por um tempo. Atualize o link para apontar diretamente para o Github para o projeto, caso isso ajude. ps. Não sei o que eu estava pensando para essa licença ... desculpas
Darius
4

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");
suresh madaparthi
fonte
4

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

Lavanya Velusamy
fonte
3

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()
Patricia Heimfarth
fonte
Substituindo aplicação - este é duplicado da resposta de whome
Murmel