Самый простой способ сделать это - передать идентификатор сеанса активности выхода в Intent, который вы используете для запуска действия:

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

Доступ к этому намерению по следующему действию:

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

Дополнительная информация содержится в документации для намерений (см. Раздел под названием «Экстра»).

В текущем действии создайте новый Intent:

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

Затем в новом Activity извлеките эти значения:

Bundle extras = getIntent().getExtras();
if (extras != null) {
    String value = extras.getString("key");
    //The key argument here must match that used in the other activity
}

Используйте эту технику для передачи переменных от одного Activity другому.

Как отметил Эрих, передача дополнительных возможностей Intent является хорошим подходом.

Однако объект Application - это другой способ, который иногда бывает проще при работе с с одним и тем же состоянием для нескольких действий (в отличие от необходимости получать / помещать его повсюду) или объекты более сложные, чем примитивы и строки.

Вы можете расширить Application, а затем установить / получить все, что хотите, и получить к нему доступ из любого Activity (в том же приложении) с помощью getApplication ().

Также имейте в виду, что другие подходы, которые вы можете увидеть, например статика, могут быть проблематичными, потому что они может привести к утечке памяти. Приложение также помогает решить эту проблему.

Исходный класс:

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

Класс назначения (класс 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");
}

Вам просто нужно отправить статисту, пока вы называете свое намерение.

Нравится:

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

Теперь с помощью OnCreate метода вашего SecondActivity вы можете получить такие дополнительные функции.

Если отправленное вами значение было в long:

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

Если вы отправили значение String:

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

Если вы отправили значение Boolean:

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

Это помогает мне видеть вещи в контексте. Вот два примера.

Передача данных вперед

Основная деятельность

• Поместите данные, которые вы хотите отправить, в намерение с парой ключ-значение. См. этот ответ для ознакомления с соглашениями об именах для ключа.
• Начните второе занятие с 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);
    }
}

Вторая деятельность

• Вы используете getIntent(), чтобы получить Intent, с которого началось второе действие. Затем вы можете извлечь данные с помощью getExtras() и ключа, который вы определили в первом действии. Поскольку наши данные представляют собой строку, мы просто будем использовать здесь getStringExtra.

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

Передача данных обратно

Основная деятельность

• Начните второе действие с startActivityForResult, предоставив ему произвольный код результата.
• Отменить onActivityResult. Это вызывается, когда заканчивается второе действие. Вы можете убедиться, что это действительно второе действие, проверив код результата. (Это полезно, когда вы начинаете несколько разных занятий из одного и того же основного.)
• Извлеките данные, полученные из возврата Intent. Данные извлекаются с использованием пары "ключ-значение". Я мог бы использовать любую строку для ключа, но я буду использовать предопределенный Intent.EXTRA_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);
            }
        }
    }
}

Вторая деятельность

• Поместите данные, которые вы хотите отправить обратно в предыдущее действие, в Intent. Данные хранятся в Intent с использованием пары "ключ-значение". Я решил использовать для своего ключа Intent.EXTRA_TEXT.
• Установите результат на RESULT_OK и добавьте намерение, в котором хранятся ваши данные.
• Позвоните finish(), чтобы закрыть второе действие.

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

Обновлено Обратите внимание, что я упомянул об использовании SharedPreference . Он имеет простой API и доступен для всех операций приложения. Но это неуклюжее решение, и оно представляет собой угрозу безопасности при передаче конфиденциальных данных. Лучше всего использовать намерения. Он имеет обширный список перегруженных методов, которые можно использовать для лучшей передачи множества различных типов данных между действиями. Взгляните на намерение .putExtra. Эта ссылка хорошо описывает использование putExtra.

При передаче данных между действиями я предпочитаю создать статический метод для соответствующего действия, который включает необходимые параметры запуска намерения. Что затем обеспечивает легкую настройку и получение параметров. Так это может выглядеть так

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

Затем вы можете создать намерение для предполагаемого действия и убедиться, что у вас есть все параметры. Вы можете адаптировать фрагменты к формату. Простой пример выше, но вы поняли идею.

Попробуйте сделать следующее:

Создайте простой «вспомогательный» класс (фабрику для ваших намерений), например:

import android.content.Intent;

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

Это будет фабрика для всех ваших намерений. Каждый раз, когда вам нужен новый Intent, создавайте статический фабричный метод в IntentHelper. Чтобы создать новое намерение, вы должны просто сказать это так:

IntentHelper.createYourSpecialIntent(getIntent());

В вашей деятельности. Если вы хотите «сохранить» некоторые данные в «сеансе», просто используйте следующее:

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

И отправьте это намерение. В целевом Activity ваше поле будет доступно как:

getIntent().getStringExtra("YOUR_FIELD_NAME");

Итак, теперь мы можем использовать Intent как тот же старый сеанс (например, в сервлетах или JSP).

Вы также можете передать объекты настраиваемого класса, создав класс parcelable. Лучший способ сделать его доступным для рассылки - написать свой класс, а затем просто вставить его на сайт вроде http://www.parcelabler.com/. Нажмите на сборку, и вы получите новый код. Скопируйте все это и замените исходное содержимое класса. Потом-

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

и получите результат в NextActivity, например:

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

Теперь вы можете просто использовать объект foo, как обычно.

Другой способ - использовать общедоступное статическое поле, в котором вы храните данные, а именно:

public class MyActivity extends Activity {

  public static String SharedString;
  public static SomeObject SharedObject;

//...

Самый удобный способ передачи данных между действиями - передача намерений. В первом действии, откуда вы хотите отправить данные, вы должны добавить код,

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

Вам также следует импортировать

import android.content.Intent;

Затем в следующем Acitvity (SecondActivity) вы должны получить данные из намерения, используя следующий код.

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

Вы можете использовать _1 _...

1. Логирование. Идентификатор сеанса сохранения времени в SharedPreferences

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

2. Выход. Идентификатор сеанса выборки времени в общих настройках

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

Если у вас нет необходимого идентификатора сеанса, удалите общие настройки:

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

Это очень полезно, потому что один раз вы сохраняете значение, а затем извлекаете любое место активности.

Стандартный подход.

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

Теперь во втором действии извлеките данные из пакета:

Получите комплект

Bundle bundle = getIntent().getExtras();

Извлечь данные…

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

Из действия

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

К действию

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

Вы можете отправлять данные между действиями, используя объект намерения. Предположим, у вас есть два вида деятельности, а именно FirstActivity и SecondActivity.

Внутри FirstActivity:

Использование намерения:

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

Внутри SecondActivity

Bundle bundle= getIntent().getExtras();

Теперь вы можете использовать различные методы класса пакета для получения значений, передаваемых из FirstActivity по ключу.

Например. _5 _, _ 6_, bundle.getInt("key") и т. Д.

Если вы хотите передавать растровое изображение между активностями / фрагментами

Действия

Для передачи растрового изображения между активациями

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

И в классе Activity

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

Фрагмент

Для передачи растрового изображения между фрагментами

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

Получить внутри SecondFragment

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

Перенос больших растровых изображений

Если вы получаете неудачную транзакцию связывания, это означает, что вы превышаете буфер транзакции связывания из-за переноса большого элемента из одного действия в другое.

В этом случае вам нужно сжать растровое изображение как массив байтов, а затем распаковать его в другом действии, например

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

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

Вы можете получить его в другом действии. Два пути:

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

Второй способ:

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

Вот моя лучшая практика, которая очень помогает, когда проект большой и сложный.

Предположим, у меня есть 2 занятия, LoginActivity и HomeActivity. Я хочу передать 2 параметра (имя пользователя и пароль) от LoginActivity до HomeActivity.

Сначала я создаю свой 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);
    }
}

Вот как я передаю данные в моем 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);

    }
}

Последний шаг, вот как я получаю данные в 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());
    }
}

Выполнено! Круто :) Я просто хочу поделиться своим опытом. Если вы работаете над небольшим проектом, это не должно быть большой проблемой. Но когда вы работаете над большим проектом, очень больно, когда вы хотите провести рефакторинг или исправить ошибки.

Дополнительный ответ: правила именования ключевой строки

На фактический процесс передачи данных уже был дан ответ, однако в большинстве ответов используются жестко закодированные строки для имени ключа в намерении. Обычно это нормально, когда используется только в вашем приложении. Однако в документации рекомендуется использовать EXTRA_* константы для стандартизованных типов данных. .

Пример 1. Использование Intent.EXTRA_* ключей

Первое действие

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

Второе действие:

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

Пример 2. Определение собственного static final ключа

Если одна из Intent.EXTRA_* строк не соответствует вашим потребностям, вы можете определить свою собственную в начале первого действия.

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

Включение имени пакета - это просто соглашение, если вы используете ключ только в своем собственном приложении. Но необходимо избегать конфликтов имен, если вы создаете какую-то службу, которую другие приложения могут вызывать с помощью намерения.

Первое действие:

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

Второе действие:

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

Пример 3. Использование строкового ключа ресурса

Хотя это не упоминается в документации, этот ответ рекомендует использовать ресурс String, чтобы избежать зависимостей между действиями.

strings.xml

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

Первое действие

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

Второе действие

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

Котлин

Переход от первого действия

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

Выполните второе действие

val value = intent.getStringExtra("key")

Предложение

Всегда помещайте ключи в постоянный файл для более удобного управления.

companion object {
    val KEY = "key"
}

Передача данных между действиями в основном осуществляется с помощью объекта намерения.

Сначала вы должны прикрепить данные к объекту намерения с использованием класса Bundle. Затем вызовите действие, используя методы startActivity() или startActivityForResult().

Дополнительную информацию об этом можно найти в примере из сообщения в блоге Передача данных в действие.

Вы можете попробовать Shared Preference, это может быть хорошей альтернативой для обмена данными между действиями.

Чтобы сохранить идентификатор сеанса -

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

Чтобы получить их -

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

Вы можете использовать Intent

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

Другой способ - также использовать шаблон singleton:

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

Из вашего FirstActivity

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

На SecondActivity

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

Начать другое действие из этого действия передать параметры через объект Bundle

Intent intent = new Intent(getBaseContext(), YourActivity.class);
intent.putExtra("USER_NAME", "[email protected]");
startActivity(intent);

Получить информацию о другом действии (YourActivity)

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

Это нормально для простого типа данных. Но если вы хотите передавать сложные данные между действиями, вам нужно сначала сериализовать их.

Здесь у нас есть модель сотрудника

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

    getters...
    setters...
}

Вы можете использовать Gson lib, предоставленную Google, для сериализации таких сложных данных, как это

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

1-й способ: в вашей текущей деятельности, когда вы создаете объект намерения открыть новый экран:

  String value="xyz";
  Intent intent = new Intent(CurrentActivity.this, NextActivity.class);    
  intent.putExtra("key", value);
  startActivity(intent);

Затем в методе nextActivity в onCreate извлеките те значения, которые вы передали из предыдущего действия:

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

2-й способ: вы можете создать объект пакета и поместить значения в пакет, а затем поместить объект пакета в намерение из вашего текущего действия -

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

Затем в методе nextActivity в onCreate извлеките те значения, которые вы передали из предыдущего действия:

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

Вы также можете использовать класс bean для передачи данных между классами с помощью сериализации.

Недавно я выпустил Vapor API, фреймворк Android со вкусом jQuery, который упрощает все виды таких задач. . Как уже упоминалось, SharedPreferences - это один из способов сделать это.

_ton_, который реализован как один вариант , а в Vapor API он имеет сильно перегруженный метод .put(...), поэтому вам не нужно явно беспокоиться о типе данных, который вы фиксируете - при условии, что он поддерживается. Он также беглый, поэтому вы можете цеплять звонки:

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

Он также опционально автоматически сохраняет изменения и унифицирует процесс чтения и записи под капотом, поэтому вам не нужно явно извлекать редактор, как в стандартном Android.

В качестве альтернативы вы можете использовать Intent. В Vapor API вы также можете использовать цепной перегруженный метод .put(...) в VaporIntent:

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

И передайте его как дополнительный, как указано в других ответах. Вы можете получить дополнительные сведения со своего Activity, и, кроме того, если вы используете VaporActivity это делается автоматически, поэтому вы можете использовать:

this.extras()

Чтобы получить их на другом конце в Activity, на который вы переключаетесь.

Надеюсь, это кого-то заинтересует :)

Первое действие:

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

Вторая деятельность:

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

Используйте глобальный класс:

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

Вы можете вызывать сеттеры и получатели этого класса из всех других классов. Сделайте это, вам нужно создать GlobalClass-Object в каждом Actitity:

GlobalClass gc = (GlobalClass) getApplication();

Тогда вы можете позвонить например:

gc.getVitaminA()

Я использую статические поля в классе и получаю / устанавливаю их:

Нравиться:

public class Info
{
    public static int ID      = 0;
    public static String NAME = "TEST";
}

Чтобы получить значение, используйте это в Activity:

Info.ID
Info.NAME

Для установки значения:

Info.ID = 5;
Info.NAME = "USER!";

Попробуй это:

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

Чарли Коллинз дал мне идеальный ответ, используя Application.class. Я не знал, что мы можем так легко создать подклассы. Вот упрощенный пример использования пользовательского класса приложения.

AndroidManifest.xml

Задайте атрибут android:name, чтобы использовать собственный класс приложения.

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

MyApplication.java

Используйте его в качестве держателя глобальной ссылки. Он отлично работает в одном и том же процессе.

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

Установите глобальную ссылку «singleton» на экземпляр приложения.

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

Простой пример, в котором я использую основное действие из другого экземпляра действия.

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

вы можете общаться между двумя видами деятельности через намерение. Всякий раз, когда вы переходите к какому-либо другому действию с помощью действия входа в систему, вы можете поместить свой sessionId в намерение и получить его в других действиях с помощью getIntent (). Ниже приведен фрагмент кода для этого:

LoginActivity:

Intent intent = new 
Intent(YourLoginActivity.this,OtherActivity.class);
intent.putExtra("SESSION_ID",sessionId);
startActivity(intent);
finishAfterTransition();

OtherActivity:

В onCreate () или там, где вам это нужно, вызовите getIntent (). GetStringExtra ("SESSION_ID"); Также не забудьте проверить, является ли намерение нулевым, а ключ, который вы передаете в намерении, должен быть одинаковым в обоих действиях. Вот полный фрагмент кода:

        if(getIntent!=null && getIntent.getStringExtra("SESSION_ID")!=null){
          sessionId = getIntent.getStringExtra("SESSION_ID");
}

Однако я бы посоветовал вам использовать AppSharedPreferences для хранения вашего sessionId и получения его оттуда, где это необходимо.

Лучший способ передать данные одному Activity в AnothetActivity с помощью Intent,

Проверьте код, вырезанный

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)

О вашей второй деятельности

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

Чтобы получить доступ к идентификатору сеанса во всех действиях, вы должны сохранить идентификатор сеанса в SharedPreference.

См. Ниже класс, который я использую для управления сеансами, вы также можете использовать его.

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

Для использования идентификатора сеанса во всех действиях вы можете выполнить следующие шаги.

1. Определите один сеанс СТАТИЧЕСКОЙ ПЕРЕМЕННОЙ (который будет содержать значение идентификатора сеанса) в файле ПРИЛОЖЕНИЯ вашего приложения.

2-Теперь вызовите переменную сеанса со ссылкой на класс, из которого вы извлекаете значение идентификатора сеанса, и присвойте его статической переменной.

3-Теперь вы можете использовать это значение идентификатора сеанса где угодно, просто вызывая статическую переменную с помощью

Если вы используете котлин:

В MainActivity1:

var intent=Intent(this,MainActivity2::class.java)
intent.putExtra("EXTRA_SESSION_ID",sessionId)
startActivity(intent)

В MainActivity2:

if (intent.hasExtra("EXTRA_SESSION_ID")){
    var name:String=intent.extras.getString("sessionId")
}

Ваш объект данных должен расширять класс Parcelable или Serializable

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

Вы можете использовать класс намерения для отправки данных между действиями. По сути, это сообщение для ОС, в котором вы описываете источник и место назначения потока данных. Как данные от А до Б.

В ДЕЙСТВИИ А (источник):

Intent intent = new Intent(A.this, B.class);

intent.putExtra("KEY","VALUE");

startActivity(intent);

В действии B (пункт назначения) ->

Intent intent =getIntent();

String data =intent.getString("KEY");

Здесь вы получите данные для ключа "KEY"

ДЛЯ ЛУЧШЕГО ИСПОЛЬЗОВАНИЯ ВСЕГДА КЛЮЧИ ДОЛЖНЫ ХРАНИТЬСЯ В КЛАССЕ ДЛЯ ПРОСТОТЫ, И ЭТО ПОМОЖЕТ СНИЗИТЬ РИСК ОШИБОК НАБОРЫ

Нравится:

public class Constants{
public static String KEY="KEY"
}

Сейчас на ДЕЙСТВИИ А:

intent.putExtra(Constants.KEY,"VALUE");

В действии Б:

String data =intent.getString(Constants.KEY);

Для этого на Java:

startActivity(new Intent(this, MainActivity.class).putExtra("userId", "2"));

Создайте новый Intent внутри вашей текущей деятельности

String myData="Your string/data here";
Intent intent = new Intent(this, SecondActivity.class);    
intent.putExtra("your_key",myData);
startActivity(intent);

Внутри вашего SecondActivity.java onCreate() Получите это значение с помощью ключа 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");
    }  
}

Новое взаимодействие между активностями в реальном времени с помощью обратных вызовов:

- ШАГ 01: Реализуйте общий интерфейс.

public interface SharedCallback {
    public String getSharedText(/*you can define arguments here*/);
}

- ШАГ 02: Реализуйте общий класс

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

- ШАГ 03 :: Играйте с кодом в первом упражнении.

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

}

- ШАГ 04 :: Завершите игру в 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();
    }

}

• ШАГ 05: вы также можете реализовать обратный вызов (от первого до второго), чтобы получить некоторые результаты от SecondAvtivity или вызвать некоторые методы

Существует несколько способов передачи данных между действиями и другими компонентами приложения для Android. Один из них использует намерения и пакеты, как уже упоминалось во многих ответах.

Другой элегантный способ - использовать библиотеку Eventbus.

Из излучающей активности:

EventBus.getDefault().postSticky("--your Object--");

В активности recv:

EventBus.getDefault().removeStickyEvent("--Object class--")

Другие моменты, которые следует учитывать:

1. Дает больше свободы, вы можете передавать сложные объекты, не изменяя их в какой-либо форме.
2. Не ограничивается передачей данных только между действиями. После настройки библиотеки вы можете использовать ее для передачи данных из одного места в другое в канале приложения. Например, используйте это для BottomSheetMenu для связи с действиями.
3. Стабильная библиотека.
4. упрощает связь между компонентами
5. разделяет отправителей и получателей событий
6. хорошо работает с артефактами пользовательского интерфейса (например, действиями, фрагментами) и фоновыми потоками
7. позволяет избежать сложных и подверженных ошибкам зависимостей и проблем жизненного цикла
8. быстро; специально оптимизирован для высокой производительности
9. крошечный (~ 60к банка)
10. проверено на практике приложениями с более чем 1 000 000 000 установок
11. имеет расширенные функции, такие как потоки доставки, приоритеты подписчиков и т. д.

Напишите следующий код в CurrentActivity.java

Intent i = new Intent(CurrentActivity.this, SignOutActivity.class);
i.putExtra("SESSION_ID",sessionId);
startActivity(i);

Доступ к SessionId в SignOutActivity.java осуществляется следующим образом

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

Я использую общедоступные статические поля для хранения общих данных между действиями, но для минимизации побочных эффектов вы можете:

• Создайте только одно поле или как можно меньше и используйте их повторно, сделайте их типом object и приведите его к желаемому типу в принимающей операции.
• Всякий раз, когда какой-либо из них больше не используется, явно установите для него значение null, которое будет собираться сборщиком мусора перед следующим назначением.

// Ваша проблема в том, что вы хотите сохранить идентификатор сеанса после входа в систему и использовать этот идентификатор сеанса для каждого действия, из которого вы хотите выйти.

// Решение вашей проблемы заключается в том, что вы должны сохранить свой идентификатор сеанса после успешного входа в публичную переменную. и всякий раз, когда вам нужен идентификатор сеанса для выхода, вы можете получить доступ к этой переменной и заменить значение переменных на ноль.

//Serializable class

public class YourClass  implements Serializable {
     public long session_id = 0;
}

Рассмотрите возможность использования синглтона для хранения информации о сеансе, доступной для всех действий.

Этот подход имеет несколько преимуществ по сравнению с дополнительными функциями и статическими переменными:

1. Позволяет расширить класс Info, добавив новые необходимые вам параметры пользовательской информации. Вы можете создать новый класс, унаследовавший его, или просто отредактировать класс Info без необходимости изменять обработку дополнительных функций во всех местах.

2. Простота использования - не нужно прибегать к дополнительным услугам.

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

В действии "Назначение" определите вот так

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

В первом действии начните второе, как показано ниже.

DestinationActivity.open(this,model);

Мы можем передать значения в другое действие двумя способами (такой же ответ уже был опубликован, но здесь я опубликовал код, который пытался через намерение)

1. через намерение

  Activity1:
      startActivity(new Intent(getApplicationContext(),Activity2.class).putExtra("title","values"));

InActivity 2:

String recString= getIntent().getStringExtra("title");

2. Через 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

Вы можете работать с намерением

String sessionId = "my session id";

    startActivity(new Intent(getApplicationContext(),SignOutActivity.class).putExtra("sessionId",sessionId));

Использование Bundle @link https://medium.com/@nikhildhyani365/pass-data-from-one-activity-to-another-using-bundle-18df2a701142
// копировать с носителя

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

Использование намерения @link https://android.jlelse.eu/passing-data-between-activities-using-intent-in-android-85cb097f3016