Android
умысел

Вступление

Синтаксис

• Intent Intent ()
• Намерение намерения (намерение намерения)
• Intent Intent (String action)
• Intent Intent (String action, Uri uri)
• Intent Intent (Контекстный пакетContext, Class <?> Cls)
• Intent Intent (String action, Uri uri, Context packageContext, Class <?> Cls)
• void startActivity (намерение намерения)
• void startActivity (намерение намерения, опции пакета)
• void startActivityForResult (намерение намерения, int requestCode)
• void startActivityForResult (Intent intent, int requestCode, Bundle options)
• Intent putExtra (имя строки, double [])
• Intent putExtra (имя строки, значение int)
• Intent putExtra (имя строки, значение CharSequence)
• Intent putExtra (имя строки, значение char)
• Intent putExtra (имя строки, значение привязки)
• Intent putExtra (имя строки, значение Parcelable [])
• Intent putExtra (имя строки, значение Serializable)
• Intent putExtra (имя строки, значение int [])
• Intent putExtra (имя строки, значение поплавка)
• Intent putExtra (имя строки, байт [])
• Intent putExtra (имя строки, длинное значение [])
• Intent putExtra (Имя строки, Исходное значение)
• Intent putExtra (имя строки, значение float [])
• Intent putExtra (имя строки, длинное значение)
• Intent putExtra (имя строки, значение String [])
• Intent putExtra (имя строки, логическое значение)
• Intent putExtra (имя строки, значение boolean [])
• Intent putExtra (имя строки, короткое значение)
• Intent putExtra (имя строки, двойное значение)
• Intent putExtra (имя строки, короткое значение [])
• Intent putExtra (String name, String value)
• Intent putExtra (имя строки, значение байта)
• Intent putExtra (имя строки, значение char [])
• Intent putExtra (имя строки, значение CharSequence [])

параметры

замечания

PackageManager pm = getActivity().getPackageManager();
if (intent.resolveActivity(pm) != null) {
    //intent can be handled
    startActivity(intent);
} else {
     //intent can not be handled
}

Начало деятельности

В этом примере начнется DestinationActivity из OriginActivity .

Здесь конструктор Intent принимает два параметра:

1. Контекст как его первый параметр (это используется, потому что класс Activity является подклассом Context)
2. Класс компонента приложения, которому система должна доставлять намерение (в этом случае, деятельность, которая должна быть запущена)

public class OriginActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_origin);

        Intent intent = new Intent(this, DestinationActivity.class);
        
        startActivity(intent);
        finish(); // Optionally, you can close OriginActivity. In this way when the user press back from DestinationActivity he/she won't land on OriginActivity again.
    }
}

Другой способ создания Intent для открытия DestinationActivity - использовать конструктор по умолчанию для Intent и использовать метод setClass() чтобы сообщить ему, какую активность открыть:

Intent i=new Intent();
i.setClass(this, DestinationActivity.class);
startActivity(intent);
finish(); // Optionally, you can close OriginActivity. In this way when the user press back from DestinationActivity he/she won't land on OriginActivity 

Передача данных между действиями

Этот пример иллюстрирует отправку String со значением как "Some data!" от OriginActivity до DestinationActivity .

ПРИМЕЧАНИЕ. Это самый простой способ отправки данных между двумя действиями. См. Пример использования шаблона стартера для более надежной реализации.

OriginActivity

public class OriginActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_origin);
        
        // Create a new Intent object, containing DestinationActivity as target Activity.
        final Intent intent = new Intent(this, DestinationActivity.class);

        // Add data in the form of key/value pairs to the intent object by using putExtra()
        intent.putExtra(DestinationActivity.EXTRA_DATA, "Some data!");

        // Start the target Activity with the intent object
        startActivity(intent);
    }
} 

DestinationActivity

public class DestinationActivity extends AppCompatActivity {

    public static final String EXTRA_DATA = "EXTRA_DATA";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_destination);

        // getIntent() returns the Intent object which was used to start this Activity
        final Intent intent = getIntent();

        // Retrieve the data from the intent object by using the same key that
        // was previously used to add data to the intent object in OriginActivity.
        final String data = intent.getStringExtra(EXTRA_DATA);
    }
}

Также возможно передавать другие primitive типы данных, а также arrays , данные Bundle и Parcelable . Передача Serializable также возможна, но ее следует избегать, поскольку она более чем в три раза медленнее, чем Parcelable .

Serializable - это стандартный interface Java. Вы просто отмечаете класс как Serializable , реализуя interface Serializable и Java автоматически сериализует его во время необходимых ситуаций.

Parcelable - это специфический для Android interface который может быть реализован на пользовательских типах данных (то есть на ваших собственных объектах / объектах POJO), что позволяет сглаживать и восстанавливать ваш объект без назначения, которое нужно что-либо сделать. Существует пример документации, позволяющий сделать объект более простым .

Как только у вас есть parcelable объект, вы можете отправить его как примитивный тип с целевым объектом:

intent.putExtra(DestinationActivity.EXTRA_DATA, myParcelableObject);

Или в связке / в качестве аргумента для фрагмента:

bundle.putParcelable(DestinationActivity.EXTRA_DATA, myParcelableObject);

а затем также прочитать его с намерением в пункте назначения, используя getParcelableExtra:

final MyParcelableType data = intent.getParcelableExtra(EXTRA_DATA); 

Или при чтении в фрагменте из пакета:

final MyParcelableType data = bundle.getParcelable(EXTRA_DATA); 

Когда у вас есть объект Serializable вы можете поместить его в объект намерения:

bundle.putSerializable(DestinationActivity.EXTRA_DATA, mySerializableObject);

а затем также прочитать его из объекта намерения в пункте назначения, как показано ниже:

final SerializableType data = (SerializableType)bundle.getSerializable(EXTRA_DATA); 

Отправка писем

// Compile a Uri with the 'mailto' schema
Intent emailIntent = new Intent(Intent.ACTION_SENDTO, Uri.fromParts(
        "mailto","[email protected]", null));
// Subject
emailIntent.putExtra(Intent.EXTRA_SUBJECT, "Hello World!");
// Body of email
emailIntent.putExtra(Intent.EXTRA_TEXT, "Hi! I am sending you a test email.");
// File attachment
emailIntent.putExtra(Intent.EXTRA_STREAM, attachedFileUri);

// Check if the device has an email client
if (emailIntent.resolveActivity(getPackageManager()) != null) {
     // Prompt the user to select a mail app
     startActivity(Intent.createChooser(emailIntent,"Choose your mail application"));
} else {
    // Inform the user that no email clients are installed or provide an alternative
}

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

Если вам нужно добавить вложение, вы можете использовать Intent.ACTION_SEND вместо Intent.ACTION_SENDTO . Для нескольких вложений вы можете использовать ACTION_SEND_MULTIPLE

ACTION_SENDTO : не у каждого устройства есть провайдер ACTION_SENDTO и вызов функции startActivity() без проверки с помощью resolveActivity() может сначала вызвать resolveActivity() ActivityNotFoundException.

Получение результата от другой деятельности

Используя startActivityForResult(Intent intent, int requestCode) вы можете начать другую Activity , а затем получить результат от этой Activity в onActivityResult(int requestCode, int resultCode, Intent data) метод. Результат будет возвращен как Intent . Умысел может содержать данные через Bundle

В этом примере MainActivity запустит DetailActivity а затем ожидает от него результата. Каждый тип запроса должен иметь свой собственный int код запроса, так что в перегруженной onActivityResult(int requestCode, int resultCode, Intent data) метод MainActivity , можно определить , какой запрос обрабатывать путем сравнения значений requestCode и REQUEST_CODE_EXAMPLE (хотя в этом Например, есть только один).

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

public class MainActivity extends Activity {

    // Use a unique request code for each use case 
    private static final int REQUEST_CODE_EXAMPLE = 0x9345; 

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // Create a new instance of Intent to start DetailActivity
        final Intent intent = new Intent(this, DetailActivity.class);

        // Start DetailActivity with the request code
        startActivityForResult(intent, REQUEST_CODE_EXAMPLE);
    }

    // onActivityResult only get called 
    // when the other Activity previously started using startActivityForResult
    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);

        // First we need to check if the requestCode matches the one we used.
        if(requestCode == REQUEST_CODE_EXAMPLE) {

            // The resultCode is set by the DetailActivity
            // By convention RESULT_OK means that whatever
            // DetailActivity did was executed successfully
            if(resultCode == Activity.RESULT_OK) {
                // Get the result from the returned Intent
                final String result = data.getStringExtra(DetailActivity.EXTRA_DATA);

                // Use the data - in this case, display it in a Toast.
                Toast.makeText(this, "Result: " + result, Toast.LENGTH_LONG).show();
            } else {
                // setResult wasn't successfully executed by DetailActivity 
                // Due to some error or flow of control. No data to retrieve.
            }
        }
    }
}

DetailActivity:

public class DetailActivity extends Activity {

    // Constant used to identify data sent between Activities.
    public static final String EXTRA_DATA = "EXTRA_DATA";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_detail);

        final Button button = (Button) findViewById(R.id.button);
        // When this button is clicked we want to return a result
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                // Create a new Intent object as container for the result
                final Intent data = new Intent();

                // Add the required data to be returned to the MainActivity
                data.putExtra(EXTRA_DATA, "Some interesting data!");
                
                // Set the resultCode as Activity.RESULT_OK to 
                // indicate a success and attach the Intent
                // which contains our result data
                setResult(Activity.RESULT_OK, data); 

                // With finish() we close the DetailActivity to 
                // return back to MainActivity
                finish();
            }
        });
    }

    @Override
    public void onBackPressed() {
        // When the user hits the back button set the resultCode 
        // as Activity.RESULT_CANCELED to indicate a failure
        setResult(Activity.RESULT_CANCELED);
        super.onBackPressed();
    }
}

Несколько вещей, о которых вы должны знать:

• Данные возвращаются только после вызова finish() . Вам нужно вызвать setResult() перед вызовом finish() , в противном случае результат не будет возвращен.

• Убедитесь, что ваша Activity не использует android:launchMode="singleTask" , или это приведет к тому, что Activity будет выполняться в отдельной задаче, и поэтому вы не получите результат от нее. Если ваша Activity использует singleTask качестве режима запуска, она немедленно вызовет onActivityResult() с результирующим кодом Activity.RESULT_CANCELED .

• Будьте осторожны при использовании android:launchMode="singleInstance" . На устройствах до Lollipop (Android 5.0, API Level 21) действия не возвращают результат.

• Вы можете использовать явные или неявные намерения, когда вы вызываете startActivityForResult() . При запуске одного из ваших собственных действий для получения результата вы должны использовать явное намерение обеспечить получение ожидаемого результата. Явное intent всегда передается его цели, независимо от того, что она содержит; filter не проконсультируется. Но неявное намерение доставляется компоненту только в том случае, если он может проходить через один из фильтров компонента.

Открыть URL-адрес в браузере

Открытие браузера по умолчанию

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

public void onBrowseClick(View v) {
    String url = "http://www.google.com";
    Uri uri = Uri.parse(url);
    Intent intent = new Intent(Intent.ACTION_VIEW, uri);
    // Verify that the intent will resolve to an activity
    if (intent.resolveActivity(getPackageManager()) != null) {
        // Here we use an intent without a Chooser unlike the next example
        startActivity(intent);
    } 
}

Вызов пользователя для выбора браузера

Обратите внимание, что в этом примере используется метод Intent.createChooser() :

public void onBrowseClick(View v) {
    String url = "http://www.google.com";
    Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(url));
    // Note the Chooser below. If no applications match, 
    // Android displays a system message.So here there is no need for try-catch.
    startActivity(Intent.createChooser(intent, "Browse with"));
   
}

В некоторых случаях URL-адрес может начинаться с «www» . Если это так, вы получите это исключение:

android.content.ActivityNotFoundException : активности не найдено для обработки Intent

URL-адрес должен всегда начинаться с «http: //» или «https: //» . Поэтому ваш код должен проверять его, как показано в следующем фрагменте кода:

if (!url.startsWith("https://") && !url.startsWith("http://")){
    url = "http://" + url;
}
Intent openUrlIntent = new Intent(Intent.ACTION_VIEW, Uri.parse(url));
if (openUrlIntent.resolveActivity(getPackageManager()) != null) {
    startActivity(openUrlIntent);
} 

Лучшие практики

Проверьте, нет ли на устройстве приложений, которые могут получить неявное намерение. В противном случае ваше приложение выйдет из startActivity() при startActivity() . Чтобы в первую очередь проверить, существует ли приложение для получения намерения, вызовите resolveActivity() для вашего объекта Intent. Если результат не равен нулю, существует хотя бы одно приложение, которое может обрабатывать намерение, и можно безопасно вызвать startActivity() . Если результат равен нулю, вы не должны использовать намерение и, если возможно, вы должны отключить функцию, которая вызывает намерение.

Очистка стека действий

Иногда вы можете начать новое действие, удаляя предыдущие действия из заднего стека, поэтому кнопка «Назад» не возвращает вас к ним. Одним из примеров этого может быть запуск приложения в активности входа, переход к основному действию вашего приложения, но при выходе из системы вы хотите вернуться в Login без возможности вернуться. В таком случае вы можете установить флаг FLAG_ACTIVITY_CLEAR_TOP для намерения, то есть, если запущенная деятельность уже запущена в текущей задаче (LoginActivity), то вместо запуска нового экземпляра этого действия все остальные действия сверху он будет закрыт, и это намерение будет передано (теперь сверху) старой деятельности в качестве нового намерения.

Intent intent = new Intent(getApplicationContext(), LoginActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
startActivity(intent);

Также можно использовать флаги FLAG_ACTIVITY_NEW_TASK вместе с FLAG_ACTIVITY_CLEAR_TASK если вы хотите очистить все действия в FLAG_ACTIVITY_CLEAR_TASK стеке:

Intent intent = new Intent(getApplicationContext(), LoginActivity.class);
// Closing all the Activities, clear the back stack.
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
startActivity(intent);

URI URI

В этом примере показано, как начать умываться из браузера:

<a href="intent://host.com/path#Intent;package=com.sample.test;scheme=yourscheme;end">Start intent</a>

Это намерение запустит приложение с пакетом com.sample.test или откроет игру Google с этим пакетом.

Также это намерение можно запустить с помощью javascript:

var intent = "intent://host.com/path#Intent;package=com.sample.test;scheme=yourscheme;end";
window.location.replace(intent)

В действии этот хост и путь могут быть получены из данных о намерениях:

@Override
public void onCreate(Bundle bundle) {
    super.onCreate(bundle);
    Uri data = getIntent().getData(); // returns host.com/path
}

Синтаксис URI Intent:

HOST/URI-path // Optional host
#Intent;
    package=[string];
    action=[string];
    category=[string];
    component=[string];
    scheme=[string];
end;

Передача сообщений другим компонентам

Intents могут использоваться для передачи сообщений другим компонентам вашего приложения (например, работающей фоновой службе) или ко всей системе Android.

Чтобы отправить широковещательную рассылку в своем приложении , используйте класс LocalBroadcastManager :

Intent intent = new Intent("com.example.YOUR_ACTION"); // the intent action
intent.putExtra("key", "value"); // data to be passed with your broadcast

LocalBroadcastManager manager = LocalBroadcastManager.getInstance(context);
manager.sendBroadcast(intent);

Чтобы отправить трансляцию компонентам за пределами вашего приложения, используйте метод sendBroadcast() для объекта Context .

Intent intent = new Intent("com.example.YOUR_ACTION"); // the intent action
intent.putExtra("key", "value"); // data to be passed with your broadcast

context.sendBroadcast(intent);

Информацию о получении трансляций можно найти здесь: Broadcast Receiver

CustomTabsIntent для пользовательских вкладок Chrome

String url = "https://www.google.pl/";
CustomTabsIntent intent = new CustomTabsIntent.Builder()
                    .setStartAnimations(getContext(), R.anim.slide_in_right, R.anim.slide_out_left)
                    .setExitAnimations(getContext(), android.R.anim.slide_in_left, android.R.anim.slide_out_right)
                    .setCloseButtonIcon(BitmapFactory.decodeResource(getResources(), R.drawable.ic_arrow_back_white_24dp))
                    .setToolbarColor(Color.parseColor("#43A047"))
                    .enableUrlBarHiding()
                    .build();
            intent.launchUrl(getActivity(), Uri.parse(url));

compile 'com.android.support:customtabs:24.1.1'

Совместное использование нескольких файлов с помощью намерения

Список строк, переданный как параметр для метода share() содержит пути всех файлов, которые вы хотите разделить.

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

  public static void share(AppCompatActivity context,List<String> paths) {

        if (paths == null || paths.size() == 0) {
            return;
        }
        ArrayList<Uri> uris = new ArrayList<>();
        Intent intent = new Intent();
        intent.setAction(android.content.Intent.ACTION_SEND_MULTIPLE);
        intent.setType("*/*");
        for (String path : paths) {
                File file = new File(path);
                uris.add(Uri.fromFile(file));
        }
        intent.putParcelableArrayListExtra(Intent.EXTRA_STREAM, uris);
        context.startActivity(intent);
    }

Стартовый шаблон

Этот шаблон является более строгим подходом к началу Activity . Его цель - улучшить читаемость кода, в то же время уменьшить сложность кода, затраты на обслуживание и соединение ваших компонентов.

В следующем примере реализуется шаблон стартера, который обычно реализуется как статический метод для самой Activity . Этот статический метод принимает все необходимые параметры, строит действительный Intent из этих данных и затем запускает Activity .

Intent - это объект, который обеспечивает привязку времени выполнения между отдельными компонентами, такими как два действия. Intent представляет собой «намерение сделать что-то». Вы можете использовать намерения для самых разных задач, но здесь ваше намерение начинает другую деятельность.

public class ExampleActivity extends AppCompatActivity {

    private static final String EXTRA_DATA = "EXTRA_DATA";

    public static void start(Context context, String data) {
        Intent intent = new Intent(context, ExampleActivity.class);
        intent.putExtra(EXTRA_DATA, data);
        context.startActivity(intent);
    }       

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        Intent intent = getIntent();
        if(!intent.getExtras().containsKey(EXTRA_DATA)){
            throw new UnsupportedOperationException("Activity should be started using the static start method");
        }
        String data = intent.getStringExtra(EXTRA_DATA);
    }
}

Этот шаблон также позволяет принудительно передавать дополнительные данные с намерением.

Затем ExampleActivity может быть запущен следующим образом: context активности:

ExampleActivity.start(context, "Some data!");

Запуск несвязанной службы с использованием намерения

Служба - это компонент, который работает в фоновом режиме (в потоке пользовательского интерфейса) без прямого взаимодействия с пользователем. Несвязанная служба только начинается и не привязана к жизненному циклу любой Деятельности.

Чтобы запустить службу, вы можете сделать это, как показано в следующем примере:

// This Intent will be used to start the service
Intent i= new Intent(context, ServiceName.class);
// potentially add data to the intent extras
i.putExtra("KEY1", "Value to be used by the service");
context.startService(i);

Вы можете использовать любые дополнения из намерения с помощью переопределения onStartCommand() :

public class MyService extends Service {
    public MyService() {
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId)
    {
        if (intent != null) {
            Bundle extras = intent.getExtras();
            String key1 = extras.getString("KEY1", "");
            if (key1.equals("Value to be used by the service")) {
                //do something
            }
        }
        return START_STICKY;
    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

}

Совместное намерение

Поделитесь простой информацией с различными приложениями.

Intent sendIntent = new Intent();
sendIntent.setAction(Intent.ACTION_SEND);
sendIntent.putExtra(Intent.EXTRA_TEXT, "This is my text to send.");
sendIntent.setType("text/plain");
startActivity(Intent.createChooser(sendIntent, getResources().getText(R.string.send_to)));

Поделитесь изображением с различными приложениями.

Intent shareIntent = new Intent();
shareIntent.setAction(Intent.ACTION_SEND);
shareIntent.putExtra(Intent.EXTRA_STREAM, uriToImage);
shareIntent.setType("image/jpeg");
startActivity(Intent.createChooser(shareIntent, getResources().getText(R.string.send_to)));

Запуск дозвона

В этом примере показано, как открыть набор номера по умолчанию (приложение, которое выполняет регулярные вызовы), с предоставленным номером телефона уже на месте:

Intent intent = new Intent(Intent.ACTION_DIAL);
intent.setData(Uri.parse("tel:9988776655")); //Replace with valid phone number. Remember to add the tel: prefix, otherwise it will crash.
startActivity(intent);

Результат выполнения приведенного выше кода:

Откройте карту Google с указанной широтой, долготой

Вы можете передавать широту, долготу из вашего приложения на карту Google, используя Intent

String uri = String.format(Locale.ENGLISH, "http://maps.google.com/maps?q=loc:%f,%f", 28.43242324,77.8977673);
Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(uri));
startActivity(intent);

Передача разных данных через Intent in Activity

1. Передача целочисленных данных:

SenderActivity

Intent myIntent = new Intent(SenderActivity.this, ReceiverActivity.class);
myIntent.putExtra("intVariableName", intValue);
startActivity(myIntent);

ReceiverActivity

Intent mIntent = getIntent();
int intValue = mIntent.getIntExtra("intVariableName", 0); // set 0 as the default value if no value for intVariableName found

2. Передача двойных данных:

SenderActivity

Intent myIntent = new Intent(SenderActivity.this, ReceiverActivity.class);
myIntent.putExtra("doubleVariableName", doubleValue);
startActivity(myIntent);

ReceiverActivity

Intent mIntent = getIntent();
double doubleValue = mIntent.getDoubleExtra("doubleVariableName", 0.00); // set 0.00 as the default value if no value for doubleVariableName found

3. Передача данных строки:

SenderActivity

Intent myIntent = new Intent(SenderActivity.this, ReceiverActivity.class);
myIntent.putExtra("stringVariableName", stringValue);
startActivity(myIntent);

ReceiverActivity

Intent mIntent = getIntent();
String stringValue = mIntent.getExtras().getString("stringVariableName");

или же

Intent mIntent = getIntent();
String stringValue = mIntent.getStringExtra("stringVariableName");

4. Передача данных ArrayList:

SenderActivity

Intent myIntent = new Intent(SenderActivity.this, ReceiverActivity.class);
myIntent.putStringArrayListExtra("arrayListVariableName", arrayList);
startActivity(myIntent);

ReceiverActivity

Intent mIntent = getIntent();
arrayList = mIntent.getStringArrayListExtra("arrayListVariableName");

5. Передача данных объекта:

SenderActivity

Intent myIntent = new Intent(SenderActivity.this, ReceiverActivity.class);
myIntent.putExtra("ObjectVariableName", yourObject);
startActivity(myIntent);

ReceiverActivity

Intent mIntent = getIntent();
yourObj = mIntent.getSerializableExtra("ObjectVariableName");

Примечание. Имейте в виду, что ваш пользовательский класс должен реализовывать интерфейс Serializable .

6. Передача данных HashMap <String, String>:

SenderActivity

HashMap <String, String> hashMap;

Intent mIntent = new Intent(SenderActivity.this, ReceiverActivity.class);
mIntent.putExtra("hashMap", hashMap);
startActivity(mIntent);

ReceiverActivity

Intent mIntent = getIntent();    
HashMap<String, String> hashMap = (HashMap<String, String>)
mIntent.getSerializableExtra("hashMap");

7. Передача данных растрового изображения:

SenderActivity

Intent myIntent = new Intent(SenderActivity.this, ReceiverActivity.class);
myIntent.putExtra("image",bitmap);
startActivity(mIntent);

ReceiverActivity

Intent mIntent = getIntent();
Bitmap bitmap = mIntent.getParcelableExtra("image");

Отображение выбора файла и чтение результата

Запуск операции выбора файла

public void showFileChooser() {
    Intent intent = new Intent(Intent.ACTION_GET_CONTENT);

    // Update with mime types
    intent.setType("*/*");

    // Update with additional mime types here using a String[]. 
    intent.putExtra(Intent.EXTRA_MIME_TYPES, mimeTypes);

    // Only pick openable and local files. Theoretically we could pull files from google drive
    // or other applications that have networked files, but that's unnecessary for this example.
    intent.addCategory(Intent.CATEGORY_OPENABLE);
    intent.putExtra(Intent.EXTRA_LOCAL_ONLY, true);

    // REQUEST_CODE = <some-integer>
    startActivityForResult(intent, REQUEST_CODE);
}

Чтение результата

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    // If the user doesn't pick a file just return
    if (requestCode != REQUEST_CODE || resultCode != RESULT_OK) {
        return;
    }

    // Import the file
    importFile(data.getData());
}

public void importFile(Uri uri) {
    String fileName = getFileName(uri);

    // The temp file could be whatever you want
    File fileCopy = copyToTempFile(uri, File tempFile)

    // Done!
}

/**
 * Obtains the file name for a URI using content resolvers. Taken from the following link
 * https://developer.android.com/training/secure-file-sharing/retrieve-info.html#RetrieveFileInfo
 *
 * @param uri a uri to query
 * @return the file name with no path
 * @throws IllegalArgumentException if the query is null, empty, or the column doesn't exist
 */
private String getFileName(Uri uri) throws IllegalArgumentException {
    // Obtain a cursor with information regarding this uri
    Cursor cursor = getContentResolver().query(uri, null, null, null, null);

    if (cursor.getCount() <= 0) {
        cursor.close();
        throw new IllegalArgumentException("Can't obtain file name, cursor is empty");
    }

    cursor.moveToFirst();

    String fileName = cursor.getString(cursor.getColumnIndexOrThrow(OpenableColumns.DISPLAY_NAME));

    cursor.close();

    return fileName;
}

/**
 * Copies a uri reference to a temporary file
 *
 * @param uri      the uri used as the input stream
 * @param tempFile the file used as an output stream
 * @return the input tempFile for convenience
 * @throws IOException if an error occurs
 */
private File copyToTempFile(Uri uri, File tempFile) throws IOException {
    // Obtain an input stream from the uri
    InputStream inputStream = getContentResolver().openInputStream(uri);

    if (inputStream == null) {
        throw new IOException("Unable to obtain input stream from URI");
    }

    // Copy the stream to the temp file
    FileUtils.copyInputStreamToFile(inputStream, tempFile);

    return tempFile;
}

Передача пользовательского объекта между действиями

Также можно передать свой пользовательский объект другим действиям, используя класс Bundle .

Существует два способа:

• Serializable интерфейс - для Java и Android
• Parcelable интерфейс-память эффективна, только для Android (рекомендуется)

Parcelable

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

public class MyObjects implements Parcelable {
    
    private int age;
    private String name;
    
    private ArrayList<String> address;
    
    public MyObjects(String name, int age, ArrayList<String> address) {
        this.name = name;
        this.age = age;
        this.address = address;
    
    }
    
    public MyObjects(Parcel source) {
        age = source.readInt();
        name = source.readString();
        address = source.createStringArrayList();
    }
    
    @Override
    public int describeContents() {
        return 0;
    }
    
    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeInt(age);
        dest.writeString(name);
        dest.writeStringList(address);
    }
    
    public int getAge() {
        return age;
    }
    
    public String getName() {
        return name;
    }
    
    public ArrayList<String> getAddress() {
        if (!(address == null))
            return address;
        else
            return new ArrayList<String>();
    }
    
    public static final Creator<MyObjects> CREATOR = new Creator<MyObjects>() {
        @Override
        public MyObjects[] newArray(int size) {
            return new MyObjects[size];
        }
    
        @Override
        public MyObjects createFromParcel(Parcel source) {
            return new MyObjects(source);
        }
    };
}

Код операции отправки

MyObject mObject = new MyObject("name","age","Address array here");

//Passing MyOject 
Intent mIntent = new Intent(FromActivity.this, ToActivity.class);
mIntent.putExtra("UniqueKey", mObject);
startActivity(mIntent);

Получение объекта в операции назначения.

//Getting MyObjects 
Intent mIntent = getIntent();
MyObjects workorder = (MyObjects) mIntent.getParcelable("UniqueKey");

Вы можете передать объект Arraylist of Parceble, как показано ниже

//Array of MyObjects
ArrayList<MyObject> mUsers;

//Passing MyObject List
Intent mIntent = new Intent(FromActivity.this, ToActivity.class);
mIntent.putParcelableArrayListExtra("UniqueKey", mUsers);
startActivity(mIntent);

//Getting MyObject List
Intent mIntent = getIntent();
ArrayList<MyObjects> mUsers = mIntent.getParcelableArrayList("UniqueKey");

Примечание. Плагины Android Studio, такие как этот, доступны для создания кода Parcelable

Сериализуемый

Код операции отправки

Product product = new Product();
Bundle bundle = new Bundle();
bundle.putSerializable("product", product);
Intent cartIntent = new Intent(mContext, ShowCartActivity.class);
cartIntent.putExtras(bundle);
mContext.startActivity(cartIntent);

Получение объекта в операции назначения.

protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    Bundle bundle = this.getIntent().getExtras();
    Product product = null;
    if (bundle != null) {
        product = (Product) bundle.getSerializable("product");
    }

Arraylist объекта Serializable: тот же, что и для передачи одного объекта

Пользовательский объект должен реализовывать интерфейс Serializable .

Получение результата из Activity to Fragment

Как и получение результата от другой startActivityForResult(Intent intent, int requestCode) вам нужно вызвать метод Fragment startActivityForResult(Intent intent, int requestCode) . обратите внимание, что вы не должны вызывать getActivity().startActivityForResult() как это возвращает результат к родительской Activity Fragment .

Получение результата может быть сделано с использованием Fragment метода «ы onActivityResult() . Вы должны убедиться, что родительская активность фрагмента также переопределяет onActivityResult() и называет ее super реализацией.

В следующем примере ActivityOne содержит FragmentOne , который запустит ActivityTwo и ожидает от него результата.

ActivityOne

public class ActivityOne extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_one);
    }

    // You must override this method as the second Activity will always send its results to this Activity and then to the Fragment
    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
       super.onActivityResult(requestCode, resultCode, data);
    }
}

activity_one.xml

<fragment android:name="com.example.FragmentOne"
    android:id="@+id/fragment_one"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />

FragmentOne

public class FragmentOne extends Fragment {
    public static final int REQUEST_CODE = 11;
    public static final int RESULT_CODE = 12;
    public static final String EXTRA_KEY_TEST = "testKey";

    // Initializing and starting the second Activity
    private void startSecondActivity() {
        Intent intent = new Intent(getActivity(), ActivityTwo.class);
        startActivityForResult(REQUEST_CODE, intent);
    }

    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        if (requestCode == REQUEST_CODE && resultCode == RESULT_CODE) {
            String testResult = data.getStringExtra(EXTRA_KEY_TEST);
            // TODO: Do something with your extra data
        }
    }
}

ActivityTwo

public class ActivityTwo extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_two);
    }

    private void closeActivity() {
        Intent intent = new Intent();
        intent.putExtra(FragmentOne.EXTRA_KEY_TEST, "Testing passing data back to ActivityOne");
        setResult(FragmentOne.RESULT_CODE, intent); // You can also send result without any data using setResult(int resultCode)
        finish();
    }
}