odsyłanie użytkownika do innej aplikacji;

Jedną z najważniejszych funkcji Androida jest możliwość przekierowania użytkownika z jednej aplikacji do innej na podstawie „działania”, które ma zostać wykonane. Jeśli na przykład aplikacja zawiera adres firmy, który chcesz wyświetlić na mapie, nie musisz tworzyć w niej aktywności, która wyświetla mapę. Zamiast tego możesz utworzyć prośbę o wyświetlenie adresu za pomocą Intent. System Android uruchamia aplikację, która może wyświetlić adres na mapie.

Jak wyjaśniono w pierwszej lekcji Tworzenie pierwszej aplikacji, do przechodzenia między aktywnościami we własnej aplikacji musisz używać intencji. Zwykle robi się to za pomocą intencji jawnej, która definiuje dokładną nazwę klasy komponentu, który chcesz uruchomić. Jeśli jednak chcesz, aby osobna aplikacja wykonała działanie, takie jak „wyświetl mapę”, musisz użyć intencji niejawnej.

Z tej lekcji dowiesz się, jak utworzyć intencję niejawną dla konkretnego działania i jak jej użyć do rozpoczęcia działania, które wykonuje akcję w innej aplikacji. Obejrzyj też zamieszczony tu film, aby dowiedzieć się, dlaczego ważne jest, aby uwzględnić kontrole w czasie działania w przypadku intencji niejawnych.

Tworzenie intencji niejawnej

Intencje niejawne nie deklarują nazwy klasy komponentu do uruchomienia, ale deklarują działanie do wykonania. Działanie określa, co chcesz zrobić, np. wyświetlić, edytować, wysłać lub pobrać coś.

Powiąż działania intencji z danymi

Intencje często zawierają też dane powiązane z działaniem, takie jak adres, który chcesz wyświetlić, lub wiadomość e-mail, którą chcesz wysłać. W zależności od intencji, którą chcesz utworzyć, dane mogą być typu Uri lub jednego z kilku innych typów. Intencja może też nie wymagać żadnych danych.

Jeśli Twoje dane to Uri, możesz użyć prostego konstruktora Intent(), aby zdefiniować działanie i dane.

Oto przykład, jak utworzyć intencję, aby rozpocząć połączenie telefoniczne, używając danych Uri do określenia numeru telefonu:

Kotlin

val callIntent: Intent = Uri.parse("tel:5551234").let { number ->
    Intent(Intent.ACTION_DIAL, number)
}

Java

Uri number = Uri.parse("tel:5551234");
Intent callIntent = new Intent(Intent.ACTION_DIAL, number);

Gdy aplikacja wywoła tę intencję, wywołując startActivity(), aplikacja Telefon rozpocznie połączenie z podanym numerem telefonu.

Oto kilka innych intencji oraz ich par działania i danych Uri:

Wyświetlanie mapy

Kotlin

// Map point based on address
val mapIntent: Intent = Uri.parse(
        "geo:0,0?q=1600+Amphitheatre+Parkway,+Mountain+View,+California"
).let { location ->
    // Or map point based on latitude/longitude
    // val location: Uri = Uri.parse("geo:37.422219,-122.08364?z=14") // z param is zoom level
    Intent(Intent.ACTION_VIEW, location)
}

Java

// Map point based on address
Uri location = Uri.parse("geo:0,0?q=1600+Amphitheatre+Parkway,+Mountain+View,+California");
// Or map point based on latitude/longitude
// Uri location = Uri.parse("geo:37.422219,-122.08364?z=14"); // z param is zoom level
Intent mapIntent = new Intent(Intent.ACTION_VIEW, location);

Wyświetlanie strony internetowej

Kotlin

val webIntent: Intent = Uri.parse("https://www.android.com").let { webpage ->
    Intent(Intent.ACTION_VIEW, webpage)
}

Java

Uri webpage = Uri.parse("https://www.android.com");
Intent webIntent = new Intent(Intent.ACTION_VIEW, webpage);

Dodawanie dodatków do intencji

Inne rodzaje intencji niejawnych wymagają „dodatkowych” danych, które dostarczają różne typy danych, np. ciąg znaków. Możesz dodać co najmniej 1 dodatkowy element danych, korzystając z różnych metod putExtra().

Domyślnie system określa odpowiedni typ MIME wymagany przez intencję na podstawie danych Uri. Jeśli nie uwzględnisz w intencji elementu Uri, zwykle musisz użyć elementu setType(), aby określić typ danych powiązanych z intencją. Ustawienie typu MIME dodatkowo określa, które rodzaje aktywności powinny otrzymywać intencję.

Oto kilka dodatkowych intencji, które dodają dodatkowe dane, aby określić żądane działanie:

Wyślij e-maila z załącznikiem

Kotlin

Intent(Intent.ACTION_SEND).apply {
    // The intent does not have a URI, so declare the "text/plain" MIME type
    type = "text/plain"
    putExtra(Intent.EXTRA_EMAIL, arrayOf("jan@example.com")) // recipients
    putExtra(Intent.EXTRA_SUBJECT, "Email subject")
    putExtra(Intent.EXTRA_TEXT, "Email message text")
    putExtra(Intent.EXTRA_STREAM, Uri.parse("content://path/to/email/attachment"))
    // You can also attach multiple items by passing an ArrayList of Uris
}

Java

Intent emailIntent = new Intent(Intent.ACTION_SEND);
// The intent does not have a URI, so declare the "text/plain" MIME type
emailIntent.setType(HTTP.PLAIN_TEXT_TYPE);
emailIntent.putExtra(Intent.EXTRA_EMAIL, new String[] {"jan@example.com"}); // recipients
emailIntent.putExtra(Intent.EXTRA_SUBJECT, "Email subject");
emailIntent.putExtra(Intent.EXTRA_TEXT, "Email message text");
emailIntent.putExtra(Intent.EXTRA_STREAM, Uri.parse("content://path/to/email/attachment"));
// You can also attach multiple items by passing an ArrayList of Uris

Tworzenie wydarzenia w kalendarzu

Uwaga: ta intencja dotycząca wydarzenia w kalendarzu jest obsługiwana tylko na poziomie interfejsu API 14 lub wyższym.

Kotlin

// Event is on January 23, 2021 -- from 7:30 AM to 10:30 AM.
Intent(Intent.ACTION_INSERT, Events.CONTENT_URI).apply {
    val beginTime: Calendar = Calendar.getInstance().apply {
        set(2021, 0, 23, 7, 30)
    }
    val endTime = Calendar.getInstance().apply {
        set(2021, 0, 23, 10, 30)
    }
    putExtra(CalendarContract.EXTRA_EVENT_BEGIN_TIME, beginTime.timeInMillis)
    putExtra(CalendarContract.EXTRA_EVENT_END_TIME, endTime.timeInMillis)
    putExtra(Events.TITLE, "Ninja class")
    putExtra(Events.EVENT_LOCATION, "Secret dojo")
}

Java

// Event is on January 23, 2021 -- from 7:30 AM to 10:30 AM.
Intent calendarIntent = new Intent(Intent.ACTION_INSERT, Events.CONTENT_URI);
Calendar beginTime = Calendar.getInstance();
beginTime.set(2021, 0, 23, 7, 30);
Calendar endTime = Calendar.getInstance();
endTime.set(2021, 0, 23, 10, 30);
calendarIntent.putExtra(CalendarContract.EXTRA_EVENT_BEGIN_TIME, beginTime.getTimeInMillis());
calendarIntent.putExtra(CalendarContract.EXTRA_EVENT_END_TIME, endTime.getTimeInMillis());
calendarIntent.putExtra(Events.TITLE, "Ninja class");
calendarIntent.putExtra(Events.EVENT_LOCATION, "Secret dojo");

Uwaga: ważne jest, aby Intent był jak najbardziej szczegółowy. Jeśli na przykład chcesz wyświetlić obraz za pomocą intencji ACTION_VIEW, musisz określić typ MIME image/*. Zapobiega to wywoływaniu intencji przez aplikacje, które mogą „wyświetlać” inne typy danych (np. aplikacje mapowe).

Uruchamianie aktywności z intencją

Po utworzeniu obiektu Intent i ustawieniu dodatkowych informacji wywołaj metodę startActivity(), aby wysłać go do systemu:

Kotlin

startActivity(intent)

Java

startActivity(intent);

Obsługa sytuacji, w której żadna aplikacja nie może odebrać intencji

Chociaż wiele intencji jest obsługiwanych przez inną aplikację zainstalowaną na urządzeniu, np. aplikację telefonu, poczty e-mail lub kalendarza, Twoja aplikacja powinna być przygotowana na sytuację, w której żadna aktywność nie może obsłużyć intencji aplikacji. Za każdym razem, gdy wywołujesz intencję, musisz być gotowy na przechwycenie wyjątku ActivityNotFoundException, który występuje, gdy nie ma innej aktywności, która mogłaby obsłużyć intencję aplikacji:

Kotlin

try {
    startActivity(intent)
} catch (e: ActivityNotFoundException) {
    // Define what your app should do if no activity can handle the intent.
}

Java

try {
    startActivity(intent);
} catch (ActivityNotFoundException e) {
    // Define what your app should do if no activity can handle the intent.
}

Po przechwyceniu tego wyjątku zdecyduj, co aplikacja powinna zrobić dalej. Kolejny krok zależy od konkretnych cech intencji, którą próbujesz wywołać. Jeśli na przykład znasz konkretną aplikację, która może obsłużyć intencję, podaj link, za pomocą którego użytkownik może ją pobrać. Dowiedz się więcej o tworzeniu linków do usług w Google Play.

Okno uściślania

Jeśli system zidentyfikuje więcej niż 1 aktywność, która może obsłużyć intencję, wyświetli okno (czasami nazywane „oknem uściślania”), w którym użytkownik może wybrać aplikację, której chce użyć, jak pokazano na rysunku 1. Jeśli istnieje tylko jedna aktywność, która obsługuje intencję, system natychmiast ją uruchamia.

U dołu ekranu pojawi się panel. W tym panelu znajdziesz listę różnych aplikacji, które mogą obsłużyć intencję.

Rysunek 1. Przykład okna wyboru, które pojawia się, gdy więcej niż 1 aplikacja może obsłużyć intencję.

Kompletny przykład

Oto kompletny przykład pokazujący, jak utworzyć intencję wyświetlenia mapy, sprawdzić, czy istnieje aplikacja do obsługi tej intencji, a następnie ją uruchomić:

Kotlin

// Build the intent.
val location = Uri.parse("geo:0,0?q=1600+Amphitheatre+Parkway,+Mountain+View,+California")
val mapIntent = Intent(Intent.ACTION_VIEW, location)

// Try to invoke the intent.
try {
    startActivity(mapIntent)
} catch (e: ActivityNotFoundException) {
    // Define what your app should do if no activity can handle the intent.
}

Java

// Build the intent.
Uri location = Uri.parse("geo:0,0?q=1600+Amphitheatre+Parkway,+Mountain+View,+California");
Intent mapIntent = new Intent(Intent.ACTION_VIEW, location);

// Try to invoke the intent.
try {
    startActivity(mapIntent);
} catch (ActivityNotFoundException e) {
    // Define what your app should do if no activity can handle the intent.
}

Wyświetlanie selektora aplikacji

Rysunek 2. Okno wyboru.

Zauważ, że gdy rozpoczynasz aktywność, przekazując Intent do startActivity(), i jest więcej niż 1 aplikacja, która odpowiada na intencję, użytkownik może wybrać, której aplikacji chce używać domyślnie (zaznaczając pole wyboru u dołu okna; patrz rysunek 1). Jest to przydatne, gdy użytkownik wykonuje działanie, do którego zwykle chce używać tej samej aplikacji, np. otwiera stronę internetową (użytkownicy prawdopodobnie używają tylko jednej przeglądarki) lub robi zdjęcie (użytkownicy prawdopodobnie wolą jeden aparat).

Jeśli jednak działanie może być obsługiwane przez wiele aplikacji, a użytkownik może za każdym razem preferować inną aplikację – np. działanie „udostępnij”, w przypadku którego użytkownicy mogą mieć kilka aplikacji, za pomocą których mogą udostępnić element – należy wyraźnie wyświetlić okno wyboru, jak pokazano na rysunku 2. Okno wyboru zmusza użytkownika do każdorazowego wybierania aplikacji, której chce użyć do wykonania działania (użytkownik nie może wybrać domyślnej aplikacji do wykonania działania).

Aby wyświetlić selektor, utwórz Intent za pomocą createChooser() i przekaż go do startActivity(). Przykład:

Kotlin

val intent = Intent(Intent.ACTION_SEND)

// Create intent to show chooser
val chooser = Intent.createChooser(intent, /* title */ null)

// Try to invoke the intent.
try {
    startActivity(chooser)
} catch (e: ActivityNotFoundException) {
    // Define what your app should do if no activity can handle the intent.
}

Java

Intent intent = new Intent(Intent.ACTION_SEND);

// Create intent to show chooser
Intent chooser = Intent.createChooser(intent, /* title */ null);

// Try to invoke the intent.
try {
    startActivity(chooser);
} catch (ActivityNotFoundException e) {
    // Define what your app should do if no activity can handle the intent.
}

Spowoduje to wyświetlenie okna z listą aplikacji, które odpowiadają intencji przekazanej do metody createChooser(). Parametr title może być podany, jeśli działanie nie jest ACTION_SEND ani ACTION_SEND_MULTIPLE