Popularne intencje

Intencja umożliwia rozpoczęcie działania w innej aplikacji przez opisanie działania, które chcesz wykonać w obiekcie Intent, np. „wyświetl mapę” lub „zrób zdjęcie”. Ten typ intencji jest nazywany intencją domniemaną, ponieważ nie określa uruchomienia komponentu aplikacji, a zamiast tego określa działanie i dostarcza dane służące do jego wykonania.

Gdy wywołujesz startActivity() lub startActivityForResult() i przekazujesz do niej intencję niejawną, system potwierdza tę intencję w aplikacji, która może obsłużyć intencję i uruchamiać odpowiadającą jej intencję Activity. Jeśli więcej niż 1 aplikacja może obsłużyć intencję, system wyświetla użytkownikowi okno, w którym może wybrać aplikację.

Na tej stronie opisujemy kilka niejawnych intencji, których możesz użyć do wykonywania typowych działań, uporządkowanych według typu aplikacji, która obsługuje daną intencję. W każdej sekcji znajdziesz też informacje o tym, jak utworzyć filtr intencji, aby reklamować zdolność aplikacji do wykonywania danego działania.

Uwaga: jeśli na urządzeniu nie ma aplikacji, które mogą otrzymać intencję pośrednią, aplikacja ulega awarii, gdy wywołuje metodę startActivity(). Aby najpierw sprawdzić, czy aplikacja istnieje i może odbierać intencję, wywołaj resolveActivity() w obiekcie Intent. Jeśli wynik nie ma wartości null, istnieje co najmniej 1 aplikacja, która może obsłużyć intencję. Można bezpiecznie wywołać startActivity(). Jeśli wynik to null, nie używaj intencji i, jeśli to możliwe, wyłącz funkcję wywołującą intencję.

Jeśli nie wiesz, jak tworzyć intencje i filtry intencji, przeczytaj najpierw artykuł Intencje i filtry intencji.

Informacje o tym, jak uruchamiać intencje wymienione na tej stronie z poziomu hosta programowania, znajdziesz w sekcji Weryfikowanie intencji przy użyciu Android Debug Bridge.

Komendy głosowe Google

Komendy głosowe Google uruchamiają niektóre intencje wymienione na tej stronie w odpowiedzi na polecenia głosowe. Więcej informacji znajdziesz w artykule o pierwszych krokach z systemowymi komendami głosowymi.

Budzik

Poniżej znajdziesz typowe działania związane z budzikiem – w tym informacje potrzebne do utworzenia filtra intencji, który reklamuje zdolność Twojej aplikacji do wykonywania poszczególnych działań.

Utwórz alarm

Komendy głosowe Google

• „Ustaw alarm na 7:00”

Aby utworzyć nowy alarm, użyj działania ACTION_SET_ALARM i określ szczegóły alarmu, takie jak godzina i treść wiadomości, za pomocą poniższych elementów.

Uwaga: w Androidzie 2.3 (poziom interfejsu API 9) i starszych wersjach są dostępne tylko godziny, minuty i dodatkowe informacje o wiadomościach. Pozostałe dodatki są dostępne w wyższych wersjach platformy.

Działanie

ACTION_SET_ALARM

Identyfikator URI danych

Brak

Typ MIME

Brak

Dodatki

EXTRA_HOUR

Godzina alarmu.

EXTRA_MINUTES

Minuty alarmu.

EXTRA_MESSAGE

Niestandardowy komunikat identyfikujący alarm.

EXTRA_DAYS

ArrayList, łącznie z każdym dniem tygodnia, w którym ten alarm jest powtarzany. Każdy dzień musi być zadeklarowany liczbą całkowitą z klasy Calendar, np. MONDAY.

W przypadku alarmu jednorazowego nie podawaj tej opcji.

EXTRA_RINGTONE

Identyfikator URI elementu content: określający dzwonek, który ma być używany z alarmem, lub VALUE_RINGTONE_SILENT (brak dzwonka).

Aby użyć domyślnego dzwonka, nie określ tej opcji.

EXTRA_VIBRATE

Wartość logiczna określająca, czy w przypadku tego alarmu mają być włączone wibracje.

EXTRA_SKIP_UI

Wartość logiczna określająca, czy podczas ustawiania alarmu aplikacja odpowiadająca musi pominąć swój interfejs. Jeśli ma wartość true (prawda), aplikacja musi pomijać interfejs potwierdzenia i ustawiać określony alarm.

Przykładowy zamiar:

Kotlin

fun createAlarm(message: String, hour: Int, minutes: Int) {
    val intent = Intent(AlarmClock.ACTION_SET_ALARM).apply {
        putExtra(AlarmClock.EXTRA_MESSAGE, message)
        putExtra(AlarmClock.EXTRA_HOUR, hour)
        putExtra(AlarmClock.EXTRA_MINUTES, minutes)
    }
    if (intent.resolveActivity(packageManager) != null) {
        startActivity(intent)
    }
}

Java

public void createAlarm(String message, int hour, int minutes) {
    Intent intent = new Intent(AlarmClock.ACTION_SET_ALARM)
            .putExtra(AlarmClock.EXTRA_MESSAGE, message)
            .putExtra(AlarmClock.EXTRA_HOUR, hour)
            .putExtra(AlarmClock.EXTRA_MINUTES, minutes);
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivity(intent);
    }
}

Uwaga:

Aby wywołać intencję ACTION_SET_ALARM, aplikacja musi mieć uprawnienie SET_ALARM:

<uses-permission android:name="com.android.alarm.permission.SET_ALARM" />

Przykładowy filtr intencji:

<activity ...>
    <intent-filter>
        <action android:name="android.intent.action.SET_ALARM" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
</activity>

Utwórz minutnik

Komendy głosowe Google

• „ustaw minutnik na 5 minut”

Aby utworzyć odliczanie, użyj działania ACTION_SET_TIMER i określ szczegóły licznika czasu, takie jak czas trwania, za pomocą poniższych dodatków.

Uwaga: ta intencja jest dostępna w Androidzie 4.4 (poziom interfejsu API 19) i nowszych.

Działanie

ACTION_SET_TIMER

Identyfikator URI danych

Brak

Typ MIME

Brak

Dodatki

EXTRA_LENGTH

Długość minutnika w sekundach.

EXTRA_MESSAGE

Niestandardowy komunikat identyfikujący minutnik.

EXTRA_SKIP_UI

Wartość logiczna określająca, czy podczas ustawiania licznika czasu aplikacja odpowiadająca musi pominąć swój interfejs. Jeśli ma wartość prawda, aplikacja musi omijać interfejs potwierdzenia i uruchamiać określony minutnik.

Przykładowy zamiar:

Kotlin

fun startTimer(message: String, seconds: Int) {
    val intent = Intent(AlarmClock.ACTION_SET_TIMER).apply {
        putExtra(AlarmClock.EXTRA_MESSAGE, message)
        putExtra(AlarmClock.EXTRA_LENGTH, seconds)
        putExtra(AlarmClock.EXTRA_SKIP_UI, true)
    }
    if (intent.resolveActivity(packageManager) != null) {
        startActivity(intent)
    }
}

Java

public void startTimer(String message, int seconds) {
    Intent intent = new Intent(AlarmClock.ACTION_SET_TIMER)
            .putExtra(AlarmClock.EXTRA_MESSAGE, message)
            .putExtra(AlarmClock.EXTRA_LENGTH, seconds)
            .putExtra(AlarmClock.EXTRA_SKIP_UI, true);
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivity(intent);
    }
}

Uwaga:

Aby wywołać intencję ACTION_SET_TIMER, aplikacja musi mieć uprawnienie SET_ALARM:

<uses-permission android:name="com.android.alarm.permission.SET_ALARM" />

Przykładowy filtr intencji:

<activity ...>
    <intent-filter>
        <action android:name="android.intent.action.SET_TIMER" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
</activity>

Pokaż wszystkie alarmy

Aby wyświetlić listę alarmów, użyj działania ACTION_SHOW_ALARMS.

Chociaż niewiele aplikacji go wywołuje, ponieważ jest on używany głównie przez aplikacje systemowe, każda aplikacja działająca jak budzik może zaimplementować ten filtr intencji i zareagować, wyświetlając listę bieżących alarmów.

Uwaga: ta intencja jest dostępna w Androidzie 4.4 (poziom interfejsu API 19) i nowszych.

Działanie

ACTION_SHOW_ALARMS

Identyfikator URI danych

Brak

Typ MIME

Brak

Przykładowy filtr intencji:

<activity ...>
    <intent-filter>
        <action android:name="android.intent.action.SHOW_ALARMS" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
</activity>

Kalendarz

Dodawanie wydarzeń jest typowym działaniem w aplikacjach kalendarza. Utwórz filtr intencji, aby reklamować możliwość wykonywania tego działania przez aplikację na podstawie informacji podanych w sekcji poniżej.

Dodaj wydarzenie w kalendarzu

Aby dodać nowe wydarzenie do kalendarza użytkownika, wykonaj czynność ACTION_INSERT i podaj identyfikator URI danych za pomocą polecenia Events.CONTENT_URI. Następnie możesz określić różne szczegóły wydarzenia przy użyciu poniższych dodatków.

Działanie

ACTION_INSERT

Identyfikator URI danych

Events.CONTENT_URI

Typ MIME

"vnd.android.cursor.dir/event"

Dodatki

EXTRA_EVENT_ALL_DAY

Wartość logiczna określająca, czy jest to wydarzenie całodniowe.

EXTRA_EVENT_BEGIN_TIME

Czas rozpoczęcia zdarzenia (milisekundy od początku epoki).

EXTRA_EVENT_END_TIME

Czas zakończenia zdarzenia (milisekundy od początku epoki).

TITLE

Tytuł wydarzenia.

DESCRIPTION

Opis zdarzenia.

EVENT_LOCATION

Lokalizacja wydarzenia.

EXTRA_EMAIL

Lista rozdzielonych przecinkami adresów e-mail osób zaproszonych.

O wiele więcej szczegółów zdarzenia można określić za pomocą stałych zdefiniowanych w klasie CalendarContract.EventsColumns.

Przykładowy zamiar:

Kotlin

fun addEvent(title: String, location: String, begin: Long, end: Long) {
    val intent = Intent(Intent.ACTION_INSERT).apply {
        data = Events.CONTENT_URI
        putExtra(Events.TITLE, title)
        putExtra(Events.EVENT_LOCATION, location)
        putExtra(CalendarContract.EXTRA_EVENT_BEGIN_TIME, begin)
        putExtra(CalendarContract.EXTRA_EVENT_END_TIME, end)
    }
    if (intent.resolveActivity(packageManager) != null) {
        startActivity(intent)
    }
}

Java

public void addEvent(String title, String location, long begin, long end) {
    Intent intent = new Intent(Intent.ACTION_INSERT)
            .setData(Events.CONTENT_URI)
            .putExtra(Events.TITLE, title)
            .putExtra(Events.EVENT_LOCATION, location)
            .putExtra(CalendarContract.EXTRA_EVENT_BEGIN_TIME, begin)
            .putExtra(CalendarContract.EXTRA_EVENT_END_TIME, end);
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivity(intent);
    }
}

Przykładowy filtr intencji:

<activity ...>
    <intent-filter>
        <action android:name="android.intent.action.INSERT" />
        <data android:mimeType="vnd.android.cursor.dir/event" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
</activity>

Aparat

Poniżej znajdziesz typowe działania związane z aplikacjami aparatu. Poniżej znajdziesz informacje potrzebne do utworzenia filtra intencji, który reklamuje jej zdolność do wykonywania poszczególnych działań.

Zrób zdjęcie lub nagraj film i zwróć je

Aby otworzyć aplikację aparatu i pobrać gotowe zdjęcie lub film, użyj działania ACTION_IMAGE_CAPTURE lub ACTION_VIDEO_CAPTURE. W dodatkowym polu EXTRA_OUTPUT określ też lokalizację identyfikatora URI, w którym kamera ma zapisać zdjęcie lub film.

Działanie

ACTION_IMAGE_CAPTURE lub
ACTION_VIDEO_CAPTURE

Schemat identyfikatora URI danych

Brak

Typ MIME

Brak

Dodatki

EXTRA_OUTPUT

Lokalizacja identyfikatora URI, w której aplikacja aparatu zapisuje zdjęcie lub plik wideo (jako obiekt Uri).

Gdy aplikacja aparatu wznowi aktywność (czyli aplikacja otrzyma wywołanie zwrotne onActivityResult()), możesz uzyskać dostęp do zdjęcia lub filmu pod podanym przez Ciebie identyfikatorem URI z wartością EXTRA_OUTPUT.

Uwaga: gdy używasz ACTION_IMAGE_CAPTURE do robienia zdjęć, aparat może też zwrócić w wyniku Intent kopię zdjęcia (miniaturę) zmniejszoną do liczby wyświetleń, która została zapisana jako Bitmap w dodatkowym polu o nazwie "data".

Przykładowy zamiar:

Kotlin

const val REQUEST_IMAGE_CAPTURE = 1
val locationForPhotos: Uri = ...

fun capturePhoto(targetFilename: String) {
    val intent = Intent(MediaStore.ACTION_IMAGE_CAPTURE).apply {
        putExtra(MediaStore.EXTRA_OUTPUT, Uri.withAppendedPath(locationForPhotos, targetFilename))
    }
    if (intent.resolveActivity(packageManager) != null) {
        startActivityForResult(intent, REQUEST_IMAGE_CAPTURE)
    }
}

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent) {
    if (requestCode == REQUEST_IMAGE_CAPTURE && resultCode == Activity.RESULT_OK) {
        val thumbnail: Bitmap = data.getParcelableExtra("data")
        // Do other work with full size photo saved in locationForPhotos.
        ...
    }
}

Java

static final int REQUEST_IMAGE_CAPTURE = 1;
static final Uri locationForPhotos;

public void capturePhoto(String targetFilename) {
    Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
    intent.putExtra(MediaStore.EXTRA_OUTPUT,
            Uri.withAppendedPath(locationForPhotos, targetFilename));
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivityForResult(intent, REQUEST_IMAGE_CAPTURE);
    }
}

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (requestCode == REQUEST_IMAGE_CAPTURE && resultCode == RESULT_OK) {
        Bitmap thumbnail = data.getParcelableExtra("data");
        // Do other work with full size photo saved in locationForPhotos.
        ...
    }
}

Aby to zrobić podczas pracy na Androidzie 12 (poziom interfejsu API 31) lub nowszym, zapoznaj się z tym przykładem intencji.

Przykładowy zamiar:

Kotlin

val REQUEST_IMAGE_CAPTURE = 1

private fun dispatchTakePictureIntent() {
    val takePictureIntent = Intent(MediaStore.ACTION_IMAGE_CAPTURE)
    try {
        startActivityForResult(takePictureIntent, REQUEST_IMAGE_CAPTURE)
    } catch (e: ActivityNotFoundException) {
        // Display error state to the user.
    }
}

Java

static final int REQUEST_IMAGE_CAPTURE = 1;

private void dispatchTakePictureIntent() {
    Intent takePictureIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
    try {
        startActivityForResult(takePictureIntent, REQUEST_IMAGE_CAPTURE);
    } catch (ActivityNotFoundException e) {
        // Display error state to the user.
    }
}
</section></div>

Więcej informacji o używaniu tej intencji do robienia zdjęć, m.in. o tworzeniu odpowiednich obiektów Uri na potrzeby lokalizacji wyjściowej, znajdziesz w artykule Robienie zdjęć i Robienie filmów.

Przykładowy filtr intencji:

<activity ...>
    <intent-filter>
        <action android:name="android.media.action.IMAGE_CAPTURE" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
</activity>

Podczas obsługi tej intencji poproś o sprawdzenie aktywności pod kątem dodatkowego EXTRA_OUTPUT w przychodzącym Intent, a następnie zapisz przechwycony obraz lub film w lokalizacji określonej przez ten dodatkowy obiekt i wywołaj setResult() za pomocą polecenia Intent, który zawiera skompresowaną miniaturę w dodatkowej nazwie "data".

Uruchamianie aplikacji aparatu w trybie nieruchomego

Komendy głosowe Google

• „Zrób zdjęcie”

Aby otworzyć aplikację aparatu w trybie nieruchomym, wykonaj działanie INTENT_ACTION_STILL_IMAGE_CAMERA.

Działanie

INTENT_ACTION_STILL_IMAGE_CAMERA

Schemat identyfikatora URI danych

Brak

Typ MIME

Brak

Dodatki

Brak

Przykładowy zamiar:

Kotlin

private fun dispatchTakePictureIntent() {
    val takePictureIntent = Intent(MediaStore.ACTION_IMAGE_CAPTURE)
    try {
        startActivityForResult(takePictureIntent, REQUEST_IMAGE_CAPTURE)
    } catch (e: ActivityNotFoundException) {
        // Display error state to the user.
    }
}

Java

public void capturePhoto(String targetFilename) {
    Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
    intent.putExtra(MediaStore.EXTRA_OUTPUT,
            Uri.withAppendedPath(locationForPhotos, targetFilename));
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivityForResult(intent, REQUEST_IMAGE_CAPTURE);
    }
}

Przykładowy filtr intencji:

<activity ...>
    <intent-filter>
        <action android:name="android.media.action.STILL_IMAGE_CAMERA" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
</activity>

Uruchamianie aplikacji aparatu w trybie wideo

Komendy głosowe Google

• „nagraj film”

Aby otworzyć aplikację aparatu w trybie wideo, użyj działania INTENT_ACTION_VIDEO_CAMERA.

Działanie

INTENT_ACTION_VIDEO_CAMERA

Schemat identyfikatora URI danych

Brak

Typ MIME

Brak

Dodatki

Brak

Przykładowy zamiar:

Kotlin

fun capturePhoto() {
    val intent = Intent(MediaStore.INTENT_ACTION_VIDEO_CAMERA)
    if (intent.resolveActivity(packageManager) != null) {
        startActivityForResult(intent, REQUEST_IMAGE_CAPTURE)
    }
}

Java

public void capturePhoto() {
    Intent intent = new Intent(MediaStore.INTENT_ACTION_VIDEO_CAMERA);
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivityForResult(intent, REQUEST_IMAGE_CAPTURE);
    }
}

Przykładowy filtr intencji:

<activity ...>
    <intent-filter>
        <action android:name="android.media.action.VIDEO_CAMERA" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
</activity>

Aplikacja Kontakty/Osoby

Poniżej znajdziesz typowe działania wykonywane przez aplikacje do zarządzania kontaktami – w tym informacje potrzebne do utworzenia filtra intencji, który reklamuje umiejętność aplikacji do wykonywania poszczególnych działań.

Wybierz kontakt

Aby poprosić użytkownika o wybranie kontaktu i przyznanie aplikacji dostępu do wszystkich informacji kontaktowych, użyj działania ACTION_PICK i określ typ MIME jako Contacts.CONTENT_TYPE.

Wynik Intent dostarczony do wywołania zwrotnego onActivityResult() zawiera identyfikator URI content: wskazujący wybrany kontakt. Odpowiedź przyznaje aplikacji tymczasowe uprawnienia do odczytu tego kontaktu za pomocą interfejsu API Contacts Provider, nawet jeśli aplikacja nie zawiera uprawnienia READ_CONTACTS.

Wskazówka: jeśli potrzebujesz dostępu tylko do określonych informacji kontaktowych, takich jak numer telefonu lub adres e-mail, przeczytaj następną sekcję dotyczącą wyboru konkretnych danych kontaktowych.

Działanie

ACTION_PICK

Schemat identyfikatora URI danych

Brak

Typ MIME

Contacts.CONTENT_TYPE

Przykładowy zamiar:

Kotlin

const val REQUEST_SELECT_CONTACT = 1

fun selectContact() {
    val intent = Intent(Intent.ACTION_PICK).apply {
        type = ContactsContract.Contacts.CONTENT_TYPE
    }
    if (intent.resolveActivity(packageManager) != null) {
        startActivityForResult(intent, REQUEST_SELECT_CONTACT)
    }
}

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent) {
    if (requestCode == REQUEST_SELECT_CONTACT && resultCode == RESULT_OK) {
        val contactUri: Uri = data.data
        // Do something with the selected contact at contactUri.
        //...
    }
}

Java

static final int REQUEST_SELECT_CONTACT = 1;

public void selectContact() {
    Intent intent = new Intent(Intent.ACTION_PICK);
    intent.setType(ContactsContract.Contacts.CONTENT_TYPE);
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivityForResult(intent, REQUEST_SELECT_CONTACT);
    }
}

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (requestCode == REQUEST_SELECT_CONTACT && resultCode == RESULT_OK) {
        Uri contactUri = data.getData();
        // Do something with the selected contact at contactUri.
        ...
    }
}

Informacje o tym, jak pobrać dane kontaktowe po uzyskaniu identyfikatora URI kontaktu, znajdziesz w artykule Pobieranie szczegółów kontaktu.

Gdy pobierasz identyfikator URI kontaktu za pomocą tej intencji, nie musisz mieć uprawnień READ_CONTACTS do odczytania podstawowych informacji o kontakcie, takich jak wyświetlana nazwa czy to, czy kontakt jest oznaczony gwiazdką. Jeśli jednak chcesz odczytać bardziej szczegółowe dane o danym kontakcie (np. numer telefonu lub adres e-mail), musisz mieć uprawnienie READ_CONTACTS.

Wybierz dane kontaktowe

Aby poprosić użytkownika o wybranie określonej informacji z kontaktu, np. numeru telefonu, adresu e-mail lub innego typu danych, użyj działania ACTION_PICK i określ typ MIME jednego z tych typów treści, np. CommonDataKinds.Phone.CONTENT_TYPE w celu uzyskania numeru telefonu kontaktu.

Uwaga: w wielu przypadkach aplikacja musi mieć uprawnienie READ_CONTACTS, aby wyświetlić określone informacje o określonym kontakcie.

Jeśli chcesz pobierać tylko 1 typ danych z kontaktu, ta metoda wykorzystująca właściwość CONTENT_TYPE z klas ContactsContract.CommonDataKinds jest skuteczniejsza niż użycie Contacts.CONTENT_TYPE, jak pokazano w poprzedniej sekcji. W efekcie masz bezpośredni dostęp do odpowiednich danych bez konieczności wykonywania bardziej złożonego zapytania do dostawcy kontaktów.

Wynik Intent dostarczony do wywołania zwrotnego onActivityResult() zawiera identyfikator URI content: wskazujący wybrane dane kontaktowe. Odpowiedź przyznaje aplikacji tymczasowe uprawnienia do odczytu tych danych kontaktowych, nawet jeśli aplikacja nie ma uprawnienia READ_CONTACTS.

Działanie

ACTION_PICK

Schemat identyfikatora URI danych

Brak

Typ MIME

CommonDataKinds.Phone.CONTENT_TYPE

Wybierz kontakty z numerem telefonu.

CommonDataKinds.Email.CONTENT_TYPE

Wybierz z kontaktów z adresem e-mail.

CommonDataKinds.StructuredPostal.CONTENT_TYPE

Wybierz kontakty z adresem pocztowym.

lub jedną z wielu innych wartości CONTENT_TYPE w kolumnie ContactsContract.

Przykładowy zamiar:

Kotlin

const val REQUEST_SELECT_PHONE_NUMBER = 1

fun selectContact() {
    // Start an activity for the user to pick a phone number from contacts.
    val intent = Intent(Intent.ACTION_PICK).apply {
        type = CommonDataKinds.Phone.CONTENT_TYPE
    }
    if (intent.resolveActivity(packageManager) != null) {
        startActivityForResult(intent, REQUEST_SELECT_PHONE_NUMBER)
    }
}

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent) {
    if (requestCode == REQUEST_SELECT_PHONE_NUMBER && resultCode == Activity.RESULT_OK) {
        // Get the URI and query the content provider for the phone number.
        val contactUri: Uri = data.data
        val projection: Array<String> = arrayOf(CommonDataKinds.Phone.NUMBER)
        contentResolver.query(contactUri, projection, null, null, null).use { cursor ->
            // If the cursor returned is valid, get the phone number.
            if (cursor.moveToFirst()) {
                val numberIndex = cursor.getColumnIndex(CommonDataKinds.Phone.NUMBER)
                val number = cursor.getString(numberIndex)
                // Do something with the phone number.
                ...
            }
        }
    }
}

Java

static final int REQUEST_SELECT_PHONE_NUMBER = 1;

public void selectContact() {
    // Start an activity for the user to pick a phone number from contacts.
    Intent intent = new Intent(Intent.ACTION_PICK);
    intent.setType(CommonDataKinds.Phone.CONTENT_TYPE);
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivityForResult(intent, REQUEST_SELECT_PHONE_NUMBER);
    }
}

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (requestCode == REQUEST_SELECT_PHONE_NUMBER && resultCode == RESULT_OK) {
        // Get the URI and query the content provider for the phone number.
        Uri contactUri = data.getData();
        String[] projection = new String[]{CommonDataKinds.Phone.NUMBER};
        Cursor cursor = getContentResolver().query(contactUri, projection,
                null, null, null);
        // If the cursor returned is valid, get the phone number.
        if (cursor != null && cursor.moveToFirst()) {
            int numberIndex = cursor.getColumnIndex(CommonDataKinds.Phone.NUMBER);
            String number = cursor.getString(numberIndex);
            // Do something with the phone number.
            //...
        }
    }
}

Wyświetlanie kontaktu

Aby wyświetlić szczegóły znanego kontaktu, użyj działania ACTION_VIEW i określ kontakt z identyfikatorem URI content: jako danymi intencji.

Identyfikator URI kontaktu możesz pobrać na 2 główne sposoby:

• Użyj identyfikatora URI kontaktu zwróconego przez działanie ACTION_PICK opisane w poprzedniej sekcji. Ta metoda nie wymaga uprawnień aplikacji.
• Możesz uzyskiwać dostęp do listy wszystkich kontaktów bezpośrednio, zgodnie z opisem w sekcji Pobieranie listy kontaktów. Ta metoda wymaga uprawnienia READ_CONTACTS.

Działanie

ACTION_VIEW

Schemat identyfikatora URI danych

content:<URI>

Typ MIME

Brak. Typ jest określany na podstawie identyfikatora URI kontaktu.

Przykładowy zamiar:

Kotlin

fun viewContact(contactUri: Uri) {
    val intent = Intent(Intent.ACTION_VIEW, contactUri)
    if (intent.resolveActivity(packageManager) != null) {
        startActivity(intent)
    }
}

Java

public void viewContact(Uri contactUri) {
    Intent intent = new Intent(Intent.ACTION_VIEW, contactUri);
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivity(intent);
    }
}

Edytowanie istniejącego kontaktu

Aby edytować znany kontakt, użyj działania ACTION_EDIT, wskaż go za pomocą identyfikatora URI content: jako danych intencji i dodaj wszelkie znane informacje kontaktowe w dodatkach określonych przez stałe w komponencie ContactsContract.Intents.Insert.

Identyfikator URI kontaktu możesz pobrać na 2 główne sposoby:

• Użyj identyfikatora URI kontaktu zwróconego przez działanie ACTION_PICK opisane w poprzedniej sekcji. Ta metoda nie wymaga uprawnień aplikacji.
• Możesz uzyskiwać dostęp do listy wszystkich kontaktów bezpośrednio, zgodnie z opisem w sekcji Pobieranie listy kontaktów. Ta metoda wymaga uprawnienia READ_CONTACTS.

Działanie

ACTION_EDIT

Schemat identyfikatora URI danych

content:<URI>

Typ MIME

Typ jest określany na podstawie identyfikatora URI kontaktu.

Dodatki

Co najmniej jeden dodatek określony w zasadzie ContactsContract.Intents.Insert, który umożliwia wypełnianie pól w szczegółach kontaktowych.

Przykładowy zamiar:

Kotlin

fun editContact(contactUri: Uri, email: String) {
    val intent = Intent(Intent.ACTION_EDIT).apply {
        data = contactUri
        putExtra(ContactsContract.Intents.Insert.EMAIL, email)
    }
    if (intent.resolveActivity(packageManager) != null) {
        startActivity(intent)
    }
}

Java

public void editContact(Uri contactUri, String email) {
    Intent intent = new Intent(Intent.ACTION_EDIT);
    intent.setData(contactUri);
    intent.putExtra(Intents.Insert.EMAIL, email);
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivity(intent);
    }
}

Więcej informacji o edytowaniu kontaktów znajdziesz w artykule Modyfikowanie kontaktów za pomocą intencji.

Wstaw kontakt

Aby wstawić nowy kontakt, użyj działania ACTION_INSERT, określ Contacts.CONTENT_TYPE jako typ MIME i dołącz wszelkie znane informacje kontaktowe w dodatkowych informacjach określonych przez stałe w ContactsContract.Intents.Insert.

Działanie

ACTION_INSERT

Schemat identyfikatora URI danych

Brak

Typ MIME

Contacts.CONTENT_TYPE

Dodatki

Co najmniej jeden dodatek określony w: ContactsContract.Intents.Insert.

Przykładowy zamiar:

Kotlin

fun insertContact(name: String, email: String) {
    val intent = Intent(Intent.ACTION_INSERT).apply {
        type = ContactsContract.Contacts.CONTENT_TYPE
        putExtra(ContactsContract.Intents.Insert.NAME, name)
        putExtra(ContactsContract.Intents.Insert.EMAIL, email)
    }
    if (intent.resolveActivity(packageManager) != null) {
        startActivity(intent)
    }
}

Java

public void insertContact(String name, String email) {
    Intent intent = new Intent(Intent.ACTION_INSERT);
    intent.setType(Contacts.CONTENT_TYPE);
    intent.putExtra(Intents.Insert.NAME, name);
    intent.putExtra(Intents.Insert.EMAIL, email);
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivity(intent);
    }
}

Więcej informacji o wstawianiu kontaktu znajdziesz w sekcji Modyfikowanie kontaktów za pomocą intencji.

E-mail

Tworzenie e-maila z opcjonalnymi załącznikami to czynność typowa w aplikacjach do obsługi poczty e-mail. Utwórz filtr intencji, aby reklamować możliwość wykonywania tego działania przez aplikację na podstawie informacji podanych w sekcji poniżej.

Tworzenie e-maila z opcjonalnymi załącznikami

Aby utworzyć e-maila, wykonaj jedną z tych czynności (w zależności od tego, czy chcesz dodać załączniki) i użyj wymienionych dodatkowych kluczy, aby dołączyć szczegóły e-maila, takie jak adresat i temat.

Działanie

ACTION_SENDTO (bez załącznika) lub
ACTION_SEND (w przypadku jednego załącznika) lub
ACTION_SEND_MULTIPLE (w przypadku wielu załączników)

Schemat identyfikatora URI danych

Brak

Typ MIME

"text/plain"

"*/*"

Dodatki

Intent.EXTRA_EMAIL

Tablica ciągu znaków ze wszystkimi adresami e-mail odbiorców w polu „Do”.

Intent.EXTRA_CC

Tablica ciągu znaków ze wszystkimi adresami e-mail odbiorców w polu „DW”.

Intent.EXTRA_BCC

Tablica ciągu znaków dla wszystkich adresów e-mail odbiorców w polu „UDW”.

Intent.EXTRA_SUBJECT

Ciąg tekstowy z tematem e-maila.

Intent.EXTRA_TEXT

Ciąg tekstowy z treścią e-maila.

Intent.EXTRA_STREAM

Uri wskazujący załącznik. Jeśli używasz działania ACTION_SEND_MULTIPLE, jest to ArrayList zawierający wiele obiektów Uri.

Przykładowy zamiar:

Kotlin

fun composeEmail(addresses: Array<String>, subject: String, attachment: Uri) {
    val intent = Intent(Intent.ACTION_SEND).apply {
        type = "*/*"
        putExtra(Intent.EXTRA_EMAIL, addresses)
        putExtra(Intent.EXTRA_SUBJECT, subject)
        putExtra(Intent.EXTRA_STREAM, attachment)
    }
    if (intent.resolveActivity(packageManager) != null) {
        startActivity(intent)
    }
}

Java

public void composeEmail(String[] addresses, String subject, Uri attachment) {
    Intent intent = new Intent(Intent.ACTION_SEND);
    intent.setType("*/*");
    intent.putExtra(Intent.EXTRA_EMAIL, addresses);
    intent.putExtra(Intent.EXTRA_SUBJECT, subject);
    intent.putExtra(Intent.EXTRA_STREAM, attachment);
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivity(intent);
    }
}

Jeśli chcesz się upewnić, że Twoja intencja zostanie obsługiwana tylko przez aplikację do obsługi poczty e-mail, a nie przez SMS-y czy aplikacje społecznościowe, użyj działania ACTION_SENDTO i uwzględnij schemat danych "mailto:", jak w tym przykładzie:

Kotlin

fun composeEmail(addresses: Array<String>, subject: String) {
    val intent = Intent(Intent.ACTION_SENDTO).apply {
        data = Uri.parse("mailto:") // Only email apps handle this.
        putExtra(Intent.EXTRA_EMAIL, addresses)
        putExtra(Intent.EXTRA_SUBJECT, subject)
    }
    if (intent.resolveActivity(packageManager) != null) {
        startActivity(intent)
    }
}

Java

public void composeEmail(String[] addresses, String subject) {
    Intent intent = new Intent(Intent.ACTION_SENDTO);
    intent.setData(Uri.parse("mailto:")); // Only email apps handle this.
    intent.putExtra(Intent.EXTRA_EMAIL, addresses);
    intent.putExtra(Intent.EXTRA_SUBJECT, subject);
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivity(intent);
    }
}

Przykładowy filtr intencji:

<activity ...>
    <intent-filter>
        <action android:name="android.intent.action.SEND" />
        <data android:type="*/*" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
    <intent-filter>
        <action android:name="android.intent.action.SENDTO" />
        <data android:scheme="mailto" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
</activity>

Miejsce na pliki

Poniżej znajdziesz typowe działania wykonywane przez aplikacje do przechowywania plików. Poniżej znajdziesz informacje potrzebne do utworzenia filtra intencji, który reklamuje zdolność aplikacji do wykonywania poszczególnych działań.

Pobieranie pliku określonego typu

Aby poprosić użytkownika o wybranie pliku, np. dokumentu lub zdjęcia, i zwrócenie odniesienia do aplikacji, użyj działania ACTION_GET_CONTENT i określ odpowiedni typ MIME. Odniesienie do pliku zwrócone do aplikacji jest nieodwracalne w bieżącym cyklu życia aktywności. Jeśli więc chcesz mieć do niego dostęp później, musisz zaimportować jego kopię do przeczytania później.

Ta intencja pozwala też użytkownikowi utworzyć w procesie nowy plik. Na przykład zamiast wybierać istniejące zdjęcie, użytkownik może zrobić nowe aparatem.

Intencja wynikowa dostarczona do metody onActivityResult() zawiera dane z identyfikatorem URI wskazującym plik. Identyfikator URI może być dowolny, np. http:, file: lub content:. Jeśli jednak chcesz ograniczyć wybór plików tylko do tych, które są dostępne przez dostawcę treści (identyfikator URI content:) i są dostępne jako strumień plików z użyciem openFileDescriptor(), dodaj do intencji kategorię CATEGORY_OPENABLE.

W Androidzie 4.3 (poziom interfejsu API 18) i nowszych możesz też zezwolić użytkownikowi na wybranie wielu plików. Aby to zrobić, dodaj do intencji true parametr EXTRA_ALLOW_MULTIPLE. Uzyskane w ten sposób pliki będą dostępne w obiekcie ClipData zwróconym przez getClipData().

Działanie

ACTION_GET_CONTENT

Schemat identyfikatora URI danych

Brak

Typ MIME

Typ MIME odpowiadający typowi pliku, który użytkownik musi wybrać.

Dodatki

EXTRA_ALLOW_MULTIPLE

Wartość logiczna określająca, czy użytkownik może wybrać więcej niż 1 plik naraz.

EXTRA_LOCAL_ONLY

Wartość logiczna określająca, czy zwracany plik musi być dostępny bezpośrednio z urządzenia, a nie musi być pobierany z usługi zdalnej.

Kategoria (opcjonalnie)

CATEGORY_OPENABLE

Aby zwracać tylko pliki „otwierające się”, które można przedstawić jako strumień plików za pomocą openFileDescriptor().

Przykładowy zamiar uzyskania zdjęcia:

Kotlin

const val REQUEST_IMAGE_GET = 1

fun selectImage() {
    val intent = Intent(Intent.ACTION_GET_CONTENT).apply {
        type = "image/*"
    }
    if (intent.resolveActivity(packageManager) != null) {
        startActivityForResult(intent, REQUEST_IMAGE_GET)
    }
}

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent) {
    if (requestCode == REQUEST_IMAGE_GET && resultCode == Activity.RESULT_OK) {
        val thumbnail: Bitmap = data.getParcelableExtra("data")
        val fullPhotoUri: Uri = data.data
        // Do work with photo saved at fullPhotoUri.
        ...
    }
}

Java

static final int REQUEST_IMAGE_GET = 1;

public void selectImage() {
    Intent intent = new Intent(Intent.ACTION_GET_CONTENT);
    intent.setType("image/*");
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivityForResult(intent, REQUEST_IMAGE_GET);
    }
}

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (requestCode == REQUEST_IMAGE_GET && resultCode == RESULT_OK) {
        Bitmap thumbnail = data.getParcelable("data");
        Uri fullPhotoUri = data.getData();
        // Do work with photo saved at fullPhotoUri.
        ...
    }
}

Przykładowy filtr intencji wywołującego zdjęcie:

<activity ...>
    <intent-filter>
        <action android:name="android.intent.action.GET_CONTENT" />
        <data android:type="image/*" />
        <category android:name="android.intent.category.DEFAULT" />
        <!-- The OPENABLE category declares that the returned file is accessible
             from a content provider that supports OpenableColumns
             and ContentResolver.openFileDescriptor(). -->
        <category android:name="android.intent.category.OPENABLE" />
    </intent-filter>
</activity>

Otwieranie pliku określonego typu

Zamiast pobierać kopię pliku, który musisz zaimportować do aplikacji, używając działania ACTION_GET_CONTENT, w Androidzie 4.4 lub nowszym możesz poprosić o otwarcie pliku zarządzanego przez inną aplikację, wykonując działanie ACTION_OPEN_DOCUMENT i określając typ MIME. Aby umożliwić użytkownikowi również utworzenie nowego dokumentu, w którym Twoja aplikacja może zapisywać zapisy, użyj zamiast tego działania ACTION_CREATE_DOCUMENT.

Na przykład zamiast wybierać spośród istniejących dokumentów PDF, intencja ACTION_CREATE_DOCUMENT pozwala użytkownikom wybrać, gdzie chcą utworzyć nowy dokument – np. w innej aplikacji zarządzającej miejscem na dokument. Aplikacja otrzymuje wtedy adres URI miejsca, w którym może zapisać nowy dokument.

Intencja przesłana do metody onActivityResult() z poziomu działania ACTION_GET_CONTENT może zwrócić identyfikator URI dowolnego typu, natomiast intencje wynikające z wyników ACTION_OPEN_DOCUMENT i ACTION_CREATE_DOCUMENT zawsze określają wybrany plik jako identyfikator URI content: oparty na identyfikatorze DocumentsProvider. Możesz otworzyć plik w openFileDescriptor() i zapytać o jego szczegóły, korzystając z kolumn w narzędziu DocumentsContract.Document.

Zwrócony identyfikator URI zapewnia aplikacji długoterminowy dostęp do pliku z uprawnieniami do odczytu, a także z uprawnieniami do zapisu. Działanie ACTION_OPEN_DOCUMENT jest szczególnie przydatne, gdy chcesz odczytać istniejący plik bez tworzenia jego kopii w aplikacji lub gdy chcesz otworzyć i edytować plik.

Możesz też pozwolić użytkownikowi wybrać wiele plików, dodając EXTRA_ALLOW_MULTIPLE do intencji true. Jeśli użytkownik wybierze tylko 1 element, możesz go pobrać ze strony getData(). Jeśli użytkownik wybierze więcej niż 1 element, getData() zwraca wartość null i zamiast tego trzeba pobrać każdy element z obiektu ClipData zwracanego przez getClipData().

Uwaga: intencja musi określać typ MIME i musi zadeklarować kategorię CATEGORY_OPENABLE. W razie potrzeby możesz określić więcej niż 1 typ MIME, dodając tablicę typów MIME z dodatkową wartością EXTRA_MIME_TYPES. W takim przypadku musisz ustawić główny typ MIME w setType() na "*/*".

Działanie

+ ACTION_OPEN_DOCUMENT lub
ACTION_CREATE_DOCUMENT

Schemat identyfikatora URI danych

Brak

Typ MIME

Typ MIME odpowiadający typowi pliku, który użytkownik musi wybrać.

Dodatki

EXTRA_MIME_TYPES

Tablica typów MIME odpowiadających typom plików, których żąda Twoja aplikacja. Jeśli używasz tego dodatku, musisz ustawić podstawowy typ MIME w domenie setType() na "*/*".

EXTRA_ALLOW_MULTIPLE

Wartość logiczna określająca, czy użytkownik może wybrać więcej niż 1 plik naraz.

EXTRA_TITLE

Używaj z ACTION_CREATE_DOCUMENT do określenia początkowej nazwy pliku.

EXTRA_LOCAL_ONLY

Wartość logiczna określająca, czy zwracany plik musi być dostępny bezpośrednio z urządzenia, a nie musi być pobierany z usługi zdalnej.

Category

CATEGORY_OPENABLE

Aby zwracać tylko pliki „otwierające się”, które można przedstawić jako strumień plików za pomocą openFileDescriptor().

Przykładowy zamiar uzyskania zdjęcia:

Kotlin

const val REQUEST_IMAGE_OPEN = 1

fun selectImage2() {
    val intent = Intent(Intent.ACTION_OPEN_DOCUMENT).apply {
        type = "image/*"
        addCategory(Intent.CATEGORY_OPENABLE)
    }
    // Only the system receives the ACTION_OPEN_DOCUMENT, so no need to test.
    startActivityForResult(intent, REQUEST_IMAGE_OPEN)
}

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent) {
    if (requestCode == REQUEST_IMAGE_OPEN && resultCode == Activity.RESULT_OK) {
        val fullPhotoUri: Uri = data.data
        // Do work with full size photo saved at fullPhotoUri.
        ...
    }
}

Java

static final int REQUEST_IMAGE_OPEN = 1;

public void selectImage() {
    Intent intent = new Intent(Intent.ACTION_OPEN_DOCUMENT);
    intent.setType("image/*");
    intent.addCategory(Intent.CATEGORY_OPENABLE);
    // Only the system receives the ACTION_OPEN_DOCUMENT, so no need to test.
    startActivityForResult(intent, REQUEST_IMAGE_OPEN);
}

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (requestCode == REQUEST_IMAGE_OPEN && resultCode == RESULT_OK) {
        Uri fullPhotoUri = data.getData();
        // Do work with full size photo saved at fullPhotoUri.
        ...
    }
}

Aplikacje innych firm nie mogą odpowiedzieć na intencję działaniem ACTION_OPEN_DOCUMENT. Zamiast tego system odbiera te informacje i wyświetla wszystkie pliki dostępne z różnych aplikacji w ujednoliconym interfejsie.

Aby udostępnić pliki aplikacji w tym interfejsie i umożliwić otwieranie ich innym aplikacjom, musisz zaimplementować DocumentsProvider i uwzględnić filtr intencji dla PROVIDER_INTERFACE("android.content.action.DOCUMENTS_PROVIDER"), jak pokazano w tym przykładzie:

<provider ...
    android:grantUriPermissions="true"
    android:exported="true"
    android:permission="android.permission.MANAGE_DOCUMENTS">
    <intent-filter>
        <action android:name="android.content.action.DOCUMENTS_PROVIDER" />
    </intent-filter>
</provider>

Więcej informacji o tym, jak umożliwić otwieranie plików zarządzanych przez aplikację z innych aplikacji, znajdziesz w artykule Otwieranie plików za pomocą platformy dostępu do pamięci.

Działania lokalne

Najczęściej dzwonienie do samochodu jest czynnością lokalną. Utwórz filtr intencji, aby reklamować możliwość wykonania danego działania przez aplikację na podstawie informacji podanych w sekcji poniżej.

Zamów taksówkę

Komendy głosowe Google

• „weź taksówkę”
• „nazwij mi samochód”

(tylko Wear OS)

Aby wezwać taksówkę, użyj działania ACTION_RESERVE_TAXI_RESERVATION.

Uwaga: zanim wykonasz to działanie, aplikacje muszą poprosić o potwierdzenie użytkownika.

Działanie

ACTION_RESERVE_TAXI_RESERVATION

Identyfikator URI danych

Brak

Typ MIME

Brak

Dodatki

Brak

Przykładowy zamiar:

Kotlin

fun callCar() {
    val intent = Intent(ReserveIntents.ACTION_RESERVE_TAXI_RESERVATION)
    if (intent.resolveActivity(packageManager) != null) {
        startActivity(intent)
    }
}

Java

public void callCar() {
    Intent intent = new Intent(ReserveIntents.ACTION_RESERVE_TAXI_RESERVATION);
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivity(intent);
    }
}

Przykładowy filtr intencji:

<activity ...>
    <intent-filter>
        <action android:name="com.google.android.gms.actions.RESERVE_TAXI_RESERVATION" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
</activity>

Mapy firmy Apple

Wyświetlanie lokalizacji na mapie jest typową czynnością w przypadku aplikacji z mapami. Utwórz filtr intencji, aby reklamować możliwość wykonywania tego działania przez aplikację na podstawie informacji podanych w sekcji poniżej.

Pokaż lokalizację na mapie

Aby otworzyć mapę, użyj działania ACTION_VIEW i w danych intencji określ informacje o lokalizacji za pomocą jednego z poniższych schematów.

Działanie

ACTION_VIEW

Schemat identyfikatora URI danych

geo:latitude,longitude

Wyświetlaj mapę o podanej długości i szerokości geograficznej.

Przykład: "geo:47.6,-122.3"

geo:latitude,longitude?z=zoom

Wyświetl mapę dla danej długości i szerokości geograficznej przy określonym powiększeniu. Poziom powiększenia równy 1 pokazuje całą Ziemię wyśrodkowaną na danej pionie długości. Najwyższy (najbliższy) poziom powiększenia to 23.

Przykład: "geo:47.6,-122.3?z=11"

geo:0,0?q=lat,lng(label)

Wyświetlaj mapę o podanej długości i szerokości geograficznej za pomocą etykiety ciągu znaków.

Przykład: "geo:0,0?q=34.99,-106.61(Treasure)"

geo:0,0?q=my+street+address

Pokaż lokalizację dla „mojego adresu pocztowego”, którym może być konkretny adres lub zapytanie o lokalizację.

Przykład: "geo:0,0?q=1600+Amphitheatre+Parkway%2C+CA"

Uwaga: wszystkie ciągi znaków przekazywane w identyfikatorze URI geo muszą być zakodowane. Na przykład ciąg 1st & Pike, Seattle zmieni się na 1st%20%26%20Pike%2C%20Seattle. Spacje w ciągu znaków są kodowane za pomocą %20 lub zastępowane znakiem plusa (+).

Typ MIME

Brak

Przykładowy zamiar:

Kotlin

fun showMap(geoLocation: Uri) {
    val intent = Intent(Intent.ACTION_VIEW).apply {
        data = geoLocation
    }
    if (intent.resolveActivity(packageManager) != null) {
        startActivity(intent)
    }
}

Java

public void showMap(Uri geoLocation) {
    Intent intent = new Intent(Intent.ACTION_VIEW);
    intent.setData(geoLocation);
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivity(intent);
    }
}

Przykładowy filtr intencji:

<activity ...>
    <intent-filter>
        <action android:name="android.intent.action.VIEW" />
        <data android:scheme="geo" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
</activity>

Muzyka lub film

Poniżej znajdziesz typowe działania związane z aplikacjami muzycznymi i wideo. Poniżej znajdziesz informacje potrzebne do utworzenia filtra intencji, który reklamuje umiejętność Twojej aplikacji w zakresie wykonywania poszczególnych działań.

Odtwórz plik multimedialny

Aby odtworzyć plik muzyczny, użyj działania ACTION_VIEW i określ lokalizację identyfikatora URI pliku w danych intencji.

Działanie

ACTION_VIEW

Schemat identyfikatora URI danych

file:<URI>

content:<URI>

http:<URL>

Typ MIME

"audio/*"

"application/ogg"

"application/x-ogg"

"application/itunes"

lub inne informacje wymagane przez aplikację.

Przykładowy zamiar:

Kotlin

fun playMedia(file: Uri) {
    val intent = Intent(Intent.ACTION_VIEW).apply {
        data = file
    }
    if (intent.resolveActivity(packageManager) != null) {
        startActivity(intent)
    }
}

Java

public void playMedia(Uri file) {
    Intent intent = new Intent(Intent.ACTION_VIEW);
    intent.setData(file);
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivity(intent);
    }
}

Przykładowy filtr intencji:

<activity ...>
    <intent-filter>
        <action android:name="android.intent.action.VIEW" />
        <data android:type="audio/*" />
        <data android:type="application/ogg" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
</activity>

Odtwarzanie muzyki na podstawie wyszukiwanego hasła

Komendy głosowe Google

• „zagraj z Michaelem jacksonem Billie jean”

Aby odtwarzać muzykę na podstawie wyszukiwanego hasła, użyj intencji INTENT_ACTION_MEDIA_PLAY_FROM_SEARCH. Aplikacja może uruchomić tę intencję w odpowiedzi na polecenie głosowe użytkownika, aby włączyć muzykę. Aplikacja odbierająca dane w ramach tego zamiaru przeprowadzi wyszukiwanie w swoich zasobach reklamowych, aby dopasować istniejące treści do danego zapytania, a następnie rozpocząć ich odtwarzanie.

W tej intencji uwzględnij dodatkowy ciąg znaków EXTRA_MEDIA_FOCUS, który określa zamierzony tryb wyszukiwania. Tryb wyszukiwania może na przykład określać, czy wyszukiwanie dotyczy tytułu wykonawcy czy utworu.

Działanie

INTENT_ACTION_MEDIA_PLAY_FROM_SEARCH

Schemat identyfikatora URI danych

Brak

Typ MIME

Brak

Dodatki

MediaStore.EXTRA_MEDIA_FOCUS (pole wymagane)

Wskazuje tryb wyszukiwania: określa, czy użytkownik szuka konkretnego wykonawcy, albumu, utworu lub playlisty. Większość trybów wyszukiwania ma dodatkowe funkcje. Jeśli np. użytkownik chce posłuchać konkretnego utworu, intencja może mieć 3 dodatkowe informacje dodatkowe: tytuł utworu, wykonawcę i album. W przypadku każdej wartości EXTRA_MEDIA_FOCUS intencja obsługuje te tryby wyszukiwania:

Dowolny – "vnd.android.cursor.item/*"

Pozwól na dowolną muzykę. Aplikacja odbierająca odtwarza muzykę na podstawie trafnego wyboru, np. ostatnio słuchanej przez użytkownika playlisty.

Dodatkowe materiały:

• QUERY (wymagany): pusty ciąg znaków. Ten dodatek jest zawsze udostępniany w celu zapewnienia zgodności wstecznej. Istniejące aplikacje, które nie wiedzą o trybach wyszukiwania, mogą przetwarzać tę intencję jako wyszukiwanie nieuporządkowane.

Nieuporządkowane – "vnd.android.cursor.item/*"

odtworzenie określonego utworu, albumu lub gatunku z wyszukiwania w nieuporządkowanych danych; Aplikacje mogą generować intencje w tym trybie wyszukiwania, gdy nie mogą zidentyfikować typu treści, które użytkownik chce posłuchać. W miarę możliwości używaj bardziej szczegółowych trybów wyszukiwania.

Dodatkowe materiały:

• QUERY (wymagany): ciąg znaków zawierający dowolną kombinację nazwy wykonawcy, albumu, tytułu utworu lub gatunku.

Genre (Gatunek) – Audio.Genres.ENTRY_CONTENT_TYPE

odtworzenie muzyki konkretnego gatunku;

Dodatkowe materiały:

• "android.intent.extra.genre" (wymagany) – gatunek.
• QUERY (wymagany): gatunek. Ten dodatek jest zawsze udostępniany w celu zapewnienia zgodności wstecznej. Istniejące aplikacje, które nie wiedzą o trybach wyszukiwania, mogą przetwarzać tę intencję jako wyszukiwanie nieuporządkowane.

Wykonawca – Audio.Artists.ENTRY_CONTENT_TYPE

odtworzenie muzyki konkretnego wykonawcy;

Dodatkowe materiały:

• EXTRA_MEDIA_ARTIST (wymagany): wykonawca.
• "android.intent.extra.genre": gatunek.
• QUERY (wymagany): ciąg znaków zawierający dowolną kombinację nazwy wykonawcy lub gatunku. Ten dodatek jest zawsze udostępniany w celu zapewnienia zgodności wstecznej. Istniejące aplikacje, które nie wiedzą o trybach wyszukiwania, mogą przetwarzać tę intencję jako wyszukiwanie nieuporządkowane.

Album – Audio.Albums.ENTRY_CONTENT_TYPE

odtworzenie muzyki z określonego albumu;

Dodatkowe materiały:

• EXTRA_MEDIA_ALBUM (wymagany): album.
• EXTRA_MEDIA_ARTIST: wykonawca;
• "android.intent.extra.genre": gatunek.
• QUERY (wymagany): ciąg znaków zawierający dowolną kombinację nazwy albumu lub wykonawcy. Ten dodatek jest zawsze udostępniany w celu zapewnienia zgodności wstecznej. Istniejące aplikacje, które nie wiedzą o trybach wyszukiwania, mogą przetwarzać tę intencję jako wyszukiwanie nieuporządkowane.

Utwór – "vnd.android.cursor.item/audio"

odtworzenie konkretnego utworu;

Dodatkowe materiały:

• EXTRA_MEDIA_ALBUM: album.
• EXTRA_MEDIA_ARTIST: wykonawca;
• "android.intent.extra.genre": gatunek.
• EXTRA_MEDIA_TITLE (wymagany): tytuł utworu.
• QUERY (wymagany): ciąg znaków zawierający dowolną kombinację albumu, wykonawcy, gatunku lub tytułu. Ten dodatek jest zawsze udostępniany w celu zapewnienia zgodności wstecznej. Istniejące aplikacje, które nie wiedzą o trybach wyszukiwania, mogą przetwarzać tę intencję jako wyszukiwanie nieuporządkowane.

Playlista – Audio.Playlists.ENTRY_CONTENT_TYPE

Playlisty na Androida zostały wycofane. Interfejs API nie jest już obsługiwany, ale jego obecne funkcje zapewniają zgodność.

Odtwórz określoną playlistę lub playlistę spełniającą kryteria określone przez dodatkowe materiały.

Dodatkowe materiały:

• EXTRA_MEDIA_ALBUM: album.
• EXTRA_MEDIA_ARTIST: wykonawca;
• "android.intent.extra.genre": gatunek.
• "android.intent.extra.playlist": playlista.
• EXTRA_MEDIA_TITLE: tytuł utworu, na podstawie którego powstała playlista.
• QUERY (wymagany): ciąg znaków zawierający dowolną kombinację albumu, wykonawcy, gatunku, playlisty lub tytułu. Ten dodatek jest zawsze udostępniany w celu zapewnienia zgodności wstecznej. Istniejące aplikacje, które nie wiedzą o trybach wyszukiwania, mogą przetwarzać tę intencję jako wyszukiwanie nieuporządkowane.

Przykładowy zamiar:

Jeśli użytkownik chce posłuchać muzyki konkretnego wykonawcy, wyszukiwarka może wygenerować taką intencję:

Kotlin

fun playSearchArtist(artist: String) {
    val intent = Intent(MediaStore.INTENT_ACTION_MEDIA_PLAY_FROM_SEARCH).apply {
        putExtra(MediaStore.EXTRA_MEDIA_FOCUS, MediaStore.Audio.Artists.ENTRY_CONTENT_TYPE)
        putExtra(MediaStore.EXTRA_MEDIA_ARTIST, artist)
        putExtra(SearchManager.QUERY, artist)
    }
    if (intent.resolveActivity(packageManager) != null) {
        startActivity(intent)
    }
}

Java

public void playSearchArtist(String artist) {
    Intent intent = new Intent(MediaStore.INTENT_ACTION_MEDIA_PLAY_FROM_SEARCH);
    intent.putExtra(MediaStore.EXTRA_MEDIA_FOCUS,
                    MediaStore.Audio.Artists.ENTRY_CONTENT_TYPE);
    intent.putExtra(MediaStore.EXTRA_MEDIA_ARTIST, artist);
    intent.putExtra(SearchManager.QUERY, artist);
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivity(intent);
    }
}

Przykładowy filtr intencji:

<activity ...>
    <intent-filter>
        <action android:name="android.media.action.MEDIA_PLAY_FROM_SEARCH" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
</activity>

Podczas obsługi tej intencji w aktywności sprawdź wartość dodatkowego EXTRA_MEDIA_FOCUS w przychodzącym pliku Intent, aby określić tryb wyszukiwania. Gdy aktywność wykryje tryb wyszukiwania, przeczytaj wartości dotyczące jego dodatkowych dodatków. Dzięki tym informacjom aplikacja może przeprowadzić wyszukiwanie w swoich zasobach reklamowych, aby odtworzyć treści pasujące do wyszukiwanego hasła. Widać to w przykładzie poniżej.

Kotlin

override fun onCreate(savedInstanceState: Bundle?) {
    ...
    if (intent.action.compareTo(MediaStore.INTENT_ACTION_MEDIA_PLAY_FROM_SEARCH) == 0) {

        val mediaFocus: String? = intent.getStringExtra(MediaStore.EXTRA_MEDIA_FOCUS)
        val query: String? = intent.getStringExtra(SearchManager.QUERY)

        // Some of these extras might not be available depending on the search mode.
        val album: String? = intent.getStringExtra(MediaStore.EXTRA_MEDIA_ALBUM)
        val artist: String? = intent.getStringExtra(MediaStore.EXTRA_MEDIA_ARTIST)
        val genre: String? = intent.getStringExtra("android.intent.extra.genre")
        val playlist: String? = intent.getStringExtra("android.intent.extra.playlist")
        val title: String? = intent.getStringExtra(MediaStore.EXTRA_MEDIA_TITLE)

        // Determine the search mode and use the corresponding extras.
        when {
            mediaFocus == null -> {
                // 'Unstructured' search mode (backward compatible)
                playUnstructuredSearch(query)
            }
            mediaFocus.compareTo("vnd.android.cursor.item/*") == 0 -> {
                if (query?.isNotEmpty() == true) {
                    // 'Unstructured' search mode.
                    playUnstructuredSearch(query)
                } else {
                    // 'Any' search mode.
                    playResumeLastPlaylist()
                }
            }
            mediaFocus.compareTo(MediaStore.Audio.Genres.ENTRY_CONTENT_TYPE) == 0 -> {
                // 'Genre' search mode.
                playGenre(genre)
            }
            mediaFocus.compareTo(MediaStore.Audio.Artists.ENTRY_CONTENT_TYPE) == 0 -> {
                // 'Artist' search mode.
                playArtist(artist, genre)
            }
            mediaFocus.compareTo(MediaStore.Audio.Albums.ENTRY_CONTENT_TYPE) == 0 -> {
                // 'Album' search mode.
                playAlbum(album, artist)
            }
            mediaFocus.compareTo("vnd.android.cursor.item/audio") == 0 -> {
                // 'Song' search mode.
                playSong(album, artist, genre, title)
            }
            mediaFocus.compareTo(MediaStore.Audio.Playlists.ENTRY_CONTENT_TYPE) == 0 -> {
                // 'Playlist' search mode.
                playPlaylist(album, artist, genre, playlist, title)
            }
        }
    }
}

Java

protected void onCreate(Bundle savedInstanceState) {
    //...
    Intent intent = this.getIntent();
    if (intent.getAction().compareTo(MediaStore.INTENT_ACTION_MEDIA_PLAY_FROM_SEARCH) == 0) {

        String mediaFocus = intent.getStringExtra(MediaStore.EXTRA_MEDIA_FOCUS);
        String query = intent.getStringExtra(SearchManager.QUERY);

        // Some of these extras might not be available depending on the search mode.
        String album = intent.getStringExtra(MediaStore.EXTRA_MEDIA_ALBUM);
        String artist = intent.getStringExtra(MediaStore.EXTRA_MEDIA_ARTIST);
        String genre = intent.getStringExtra("android.intent.extra.genre");
        String playlist = intent.getStringExtra("android.intent.extra.playlist");
        String title = intent.getStringExtra(MediaStore.EXTRA_MEDIA_TITLE);

        // Determine the search mode and use the corresponding extras.
        if (mediaFocus == null) {
            // 'Unstructured' search mode (backward compatible).
            playUnstructuredSearch(query);

        } else if (mediaFocus.compareTo("vnd.android.cursor.item/*") == 0) {
            if (query.isEmpty()) {
                // 'Any' search mode.
                playResumeLastPlaylist();
            } else {
                // 'Unstructured' search mode.
                playUnstructuredSearch(query);
            }

        } else if (mediaFocus.compareTo(MediaStore.Audio.Genres.ENTRY_CONTENT_TYPE) == 0) {
            // 'Genre' search mode.
            playGenre(genre);

        } else if (mediaFocus.compareTo(MediaStore.Audio.Artists.ENTRY_CONTENT_TYPE) == 0) {
            // 'Artist' search mode.
            playArtist(artist, genre);

        } else if (mediaFocus.compareTo(MediaStore.Audio.Albums.ENTRY_CONTENT_TYPE) == 0) {
            // 'Album' search mode.
            playAlbum(album, artist);

        } else if (mediaFocus.compareTo("vnd.android.cursor.item/audio") == 0) {
            // 'Song' search mode.
            playSong(album, artist, genre, title);

        } else if (mediaFocus.compareTo(MediaStore.Audio.Playlists.ENTRY_CONTENT_TYPE) == 0) {
            // 'Playlist' search mode.
            playPlaylist(album, artist, genre, playlist, title);
        }
    }
}

Nowa notatka

Tworzenie notatek jest typową czynnością w aplikacjach do notatek. Utwórz filtr intencji, aby reklamować możliwość wykonywania tego działania przez aplikację na podstawie informacji podanych w sekcji poniżej.

Tworzenie notatki

Aby utworzyć nową notatkę, użyj działania ACTION_CREATE_NOTE i określ szczegóły notatki, takie jak temat i tekst, za pomocą poniższych elementów.

Uwaga: zanim wykonasz to działanie, aplikacje muszą poprosić o potwierdzenie użytkownika.

Działanie

ACTION_CREATE_NOTE

Schemat identyfikatora URI danych

Brak

Typ MIME

PLAIN_TEXT_TYPE

"*/*"

Dodatki

EXTRA_NAME

Ciąg znaków wskazujący tytuł lub temat notatki.

EXTRA_TEXT

Ciąg tekstowy wskazujący treść notatki.

Przykładowy zamiar:

Kotlin

fun createNote(subject: String, text: String) {
    val intent = Intent(NoteIntents.ACTION_CREATE_NOTE).apply {
        putExtra(NoteIntents.EXTRA_NAME, subject)
        putExtra(NoteIntents.EXTRA_TEXT, text)
    }
    if (intent.resolveActivity(packageManager) != null) {
        startActivity(intent)
    }
}

Java

public void createNote(String subject, String text) {
    Intent intent = new Intent(NoteIntents.ACTION_CREATE_NOTE)
            .putExtra(NoteIntents.EXTRA_NAME, subject)
            .putExtra(NoteIntents.EXTRA_TEXT, text);
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivity(intent);
    }
}

Przykładowy filtr intencji:

<activity ...>
    <intent-filter>
        <action android:name="com.google.android.gms.actions.CREATE_NOTE" />
        <category android:name="android.intent.category.DEFAULT" />
        <data android:mimeType="*/*" />
    </intent-filter>
</activity>

Telefon

Nawiązywanie połączeń to częste działanie w aplikacjach telefonicznych. Utwórz filtr intencji, aby reklamować możliwość wykonywania tego działania przez aplikację na podstawie informacji podanych w sekcji poniżej.

Zainicjowanie połączenia głosowego

Aby otworzyć aplikację telefoniczną i wybrać numer telefonu, użyj działania ACTION_DIAL i podaj numer telefonu z użyciem tego schematu URI. Po otwarciu aplikacji Telefon wyświetla się numer telefonu, a użytkownik musi kliknąć przycisk Zadzwoń, aby rozpocząć rozmowę telefoniczną.

Komendy głosowe Google

• „zadzwoń pod numer 555-5555”;
• „zadzwoń do Roberta”
• „połącz z pocztą głosową”

Aby nawiązać bezpośrednie połączenie telefoniczne, użyj działania ACTION_CALL i podaj numer telefonu zgodnie z tym schematem URI. Aplikacja Telefon rozpoczyna połączenie. Użytkownik nie musi klikać przycisku Zadzwoń.

Działanie ACTION_CALL wymaga dodania do pliku manifestu uprawnienia CALL_PHONE:

<uses-permission android:name="android.permission.CALL_PHONE" />

Działanie

• ACTION_DIAL – otwiera aplikację telefonu lub telefonu.
• ACTION_CALL – nawiązuje połączenie telefoniczne (wymaga uprawnienia CALL_PHONE)

Schemat identyfikatora URI danych

• tel:<phone-number>
• voicemail:<phone-number>

Typ MIME

Brak

Prawidłowymi numerami telefonów są wymienione w dokumencie IETF RFC 3966. Prawidłowe przykłady:

• tel:[phone]
• tel:[phone]

Klawiatura w aplikacji Telefon dobrze sprawdza się w normalizowaniu schematów, takich jak numery telefonów. Opisany schemat nie jest więc ściśle wymagany w metodzie Uri.parse(). Jeśli jednak nie znasz żadnego schematu lub nie masz pewności, czy można go obsłużyć, użyj metody Uri.fromParts().

Przykładowy zamiar:

Kotlin

fun dialPhoneNumber(phoneNumber: String) {
    val intent = Intent(Intent.ACTION_DIAL).apply {
        data = Uri.parse("tel:$phoneNumber")
    }
    if (intent.resolveActivity(packageManager) != null) {
        startActivity(intent)
    }
}

Java

public void dialPhoneNumber(String phoneNumber) {
    Intent intent = new Intent(Intent.ACTION_DIAL);
    intent.setData(Uri.parse("tel:" + phoneNumber));
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivity(intent);
    }
}

Szukaj

Poniżej znajdziesz typowe działania w aplikacjach do wyszukiwania, w tym informacje potrzebne do utworzenia filtra intencji, który reklamuje umiejętność Twojej aplikacji w zakresie wykonywania poszczególnych działań.

Wyszukiwanie za pomocą konkretnej aplikacji

Komendy głosowe Google

• „wyszukaj filmiki z kotami w mojejaplikacjiwideo”

Aby obsługiwać wyszukiwanie w kontekście aplikacji, zadeklaruj w niej filtr intencji za pomocą działania SEARCH_ACTION, jak pokazano w poniższym przykładzie filtra intencji.

Uwaga: nie zalecamy korzystania z SEARCH_ACTION do wyszukiwania aplikacji. Zamiast tego zaimplementuj działanie GET_THING, aby skorzystać z wbudowanej obsługi wyszukiwania w aplikacji przez Asystenta Google. Więcej informacji znajdziesz w dokumentacji Asystenta Google dotyczącej działań w aplikacji.

Działanie

"com.google.android.gms.actions.SEARCH_ACTION"

Obsługuj zapytania generowane przez komendy głosowe Google.

Dodatki

QUERY

Ciąg tekstowy zawierający wyszukiwane hasło.

Przykładowy filtr intencji:

<activity android:name=".SearchActivity">
    <intent-filter>
        <action android:name="com.google.android.gms.actions.SEARCH_ACTION"/>
        <category android:name="android.intent.category.DEFAULT"/>
    </intent-filter>
</activity>

Przeprowadź wyszukiwanie w internecie

Aby zainicjować wyszukiwanie w internecie, użyj działania ACTION_WEB_SEARCH i określ wyszukiwany ciąg w dodatkowym SearchManager.QUERY.

Działanie

ACTION_WEB_SEARCH

Schemat identyfikatora URI danych

Brak

Typ MIME

Brak

Dodatki

SearchManager.QUERY

Wyszukiwany ciąg.

Przykładowy zamiar:

Kotlin

fun searchWeb(query: String) {
    val intent = Intent(Intent.ACTION_WEB_SEARCH).apply {
        putExtra(SearchManager.QUERY, query)
    }
    if (intent.resolveActivity(packageManager) != null) {
        startActivity(intent)
    }
}

Java

public void searchWeb(String query) {
    Intent intent = new Intent(Intent.ACTION_WEB_SEARCH);
    intent.putExtra(SearchManager.QUERY, query);
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivity(intent);
    }
}

Ustawienia

Aby otworzyć ekran w systemowej aplikacji Ustawienia, gdy aplikacja wymaga od użytkownika wprowadzenia zmian, użyj jednego z tych intencji:

Działanie

ACTION_SETTINGS
ACTION_WIRELESS_SETTINGS
ACTION_AIRPLANE_MODE_SETTINGS
ACTION_WIFI_SETTINGS
ACTION_APN_SETTINGS
ACTION_BLUETOOTH_SETTINGS
ACTION_DATE_SETTINGS
ACTION_LOCALE_SETTINGS
ACTION_INPUT_METHOD_SETTINGS
ACTION_DISPLAY_SETTINGS
ACTION_SECURITY_SETTINGS
ACTION_LOCATION_SOURCE_SETTINGS
ACTION_INTERNAL_STORAGE_SETTINGS
ACTION_MEMORY_CARD_SETTINGS

Informacje o dodatkowych dostępnych ekranach ustawień znajdziesz w dokumentacji Settings .

Schemat identyfikatora URI danych

Brak

Typ MIME

Brak

Przykładowy zamiar:

Kotlin

fun openWifiSettings() {
    val intent = Intent(Settings.ACTION_WIFI_SETTINGS)
    if (intent.resolveActivity(packageManager) != null) {
        startActivity(intent)
    }
}

Java

public void openWifiSettings() {
    Intent intent = new Intent(Settings.ACTION_WIFI_SETTINGS);
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivity(intent);
    }
}

Obsługa SMS-ów

Tworzenie SMS-ów i MMS-ów z załącznikiem jest typową czynnością w aplikacjach do obsługi SMS-ów. Utwórz filtr intencji, aby reklamować możliwość wykonywania tego działania przez aplikację na podstawie informacji podanych w sekcji poniżej.

Tworzenie wiadomości SMS/MMS z załącznikiem

Aby zainicjować SMS-a lub MMS-a, użyj jednego z poniższych intencji i określ szczegóły wiadomości, takie jak numer telefonu, temat i treść wiadomości, za pomocą podanych niżej kluczy dodatkowych.

Działanie

ACTION_SENDTO lub
ACTION_SEND lub
ACTION_SEND_MULTIPLE

Schemat identyfikatora URI danych

sms:<phone_number>

smsto:<phone_number>

mms:<phone_number>

mmsto:<phone_number>

Schematy te są traktowane w ten sam sposób.

Typ MIME

"text/plain"

"image/*"

"video/*"

Dodatki

"subject"

Ciąg tekstowy dotyczący tematu wiadomości (zwykle w przypadku tylko MMS-ów).

"sms_body"

Ciąg tekstowy wiadomości.

EXTRA_STREAM

Element Uri wskazujący obraz lub film do załączenia. Jeśli używasz działania ACTION_SEND_MULTIPLE, ten dodatkowy obiekt to ArrayList z Uri obiektów wskazujących obrazy lub filmy do załączenia.

Przykładowy zamiar:

Kotlin

fun composeMmsMessage(message: String, attachment: Uri) {
    val intent = Intent(Intent.ACTION_SENDTO).apply {
        type = HTTP.PLAIN_TEXT_TYPE
        putExtra("sms_body", message)
        putExtra(Intent.EXTRA_STREAM, attachment)
    }
    if (intent.resolveActivity(packageManager) != null) {
        startActivity(intent)
    }
}

Java

public void composeMmsMessage(String message, Uri attachment) {
    Intent intent = new Intent(Intent.ACTION_SENDTO);
    intent.setType(HTTP.PLAIN_TEXT_TYPE);
    intent.putExtra("sms_body", message);
    intent.putExtra(Intent.EXTRA_STREAM, attachment);
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivity(intent);
    }
}

Jeśli chcesz się upewnić, że Twoja intencja jest obsługiwana tylko przez aplikację do obsługi SMS-ów, a nie przez inne aplikacje e-mail czy społecznościowe, użyj działania ACTION_SENDTO i uwzględnij schemat danych "smsto:", jak w tym przykładzie:

Kotlin

fun composeMmsMessage(message: String, attachment: Uri) {
    val intent = Intent(Intent.ACTION_SEND).apply {
        data = Uri.parse("smsto:")  // Only SMS apps respond to this.
        putExtra("sms_body", message)
        putExtra(Intent.EXTRA_STREAM, attachment)
    }
    if (intent.resolveActivity(packageManager) != null) {
        startActivity(intent)
    }
}

Java

public void composeMmsMessage(String message, Uri attachment) {
    Intent intent = new Intent(Intent.ACTION_SEND);
    intent.setData(Uri.parse("smsto:"));  // Only SMS apps respond to this.
    intent.putExtra("sms_body", message);
    intent.putExtra(Intent.EXTRA_STREAM, attachment);
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivity(intent);
    }
}

Przykładowy filtr intencji:

<activity ...>
    <intent-filter>
        <action android:name="android.intent.action.SEND" />
        <data android:type="text/plain" />
        <data android:type="image/*" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
</activity>

Uwaga: jeśli tworzysz aplikację do obsługi SMS-ów i MMS-ów, musisz zaimplementować filtry intencji dla kilku dodatkowych działań, aby była ona dostępna jako domyślna aplikacja do obsługi SMS-ów na Androidzie 4.4 i nowszych. Więcej informacji znajdziesz w dokumentacji na stronie Telephony.

Przeglądarki

Wczytywanie adresu URL jest typowym działaniem w przeglądarkach. Utwórz filtr intencji, aby reklamować możliwość wykonywania tego działania przez aplikację na podstawie informacji podanych w sekcji poniżej.

Wczytaj adres URL

Komendy głosowe Google

• „otwórz example.com”

Aby otworzyć stronę internetową, użyj działania ACTION_VIEW i wpisz adres URL w danych intencji.

Działanie

ACTION_VIEW

Schemat identyfikatora URI danych

http:<URL>
https:<URL>

Typ MIME

"text/plain"

"text/html"

"application/xhtml+xml"

"application/vnd.wap.xhtml+xml"

Przykładowy zamiar:

Kotlin

fun openWebPage(url: String) {
    val webpage: Uri = Uri.parse(url)
    val intent = Intent(Intent.ACTION_VIEW, webpage)
    if (intent.resolveActivity(packageManager) != null) {
        startActivity(intent)
    }
}

Java

public void openWebPage(String url) {
    Uri webpage = Uri.parse(url);
    Intent intent = new Intent(Intent.ACTION_VIEW, webpage);
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivity(intent);
    }
}

Przykładowy filtr intencji:

<activity ...>
    <intent-filter>
        <action android:name="android.intent.action.VIEW" />
        <!-- Include the host attribute if you want your app to respond
             only to URLs with your app's domain. -->
        <data android:scheme="http" android:host="www.example.com" />
        <category android:name="android.intent.category.DEFAULT" />
        <!-- The BROWSABLE category is required to get links from web pages. -->
        <category android:name="android.intent.category.BROWSABLE" />
    </intent-filter>
</activity>

Wskazówka: jeśli Twoja aplikacja na Androida ma funkcje podobne do Twojej witryny, dodaj filtr intencji dla adresów URL prowadzących do Twojej witryny. Jeśli użytkownicy zainstalowali Twoją aplikację, linki z e-maili lub innych stron prowadzących do Twojej witryny będą otwierać Twoją aplikację na Androida, a nie stronę internetową. Więcej informacji znajdziesz w artykule o obsłudze linków aplikacji na Androida.

Od Androida 12 (poziom interfejsu API 31) ogólna intencja internetowa skutkuje działaniem w aplikacji tylko wtedy, gdy jest zatwierdzona w konkretnej domenie zawartej w tej intencji internetowej. Jeśli Twoja aplikacja nie zostanie zatwierdzona w domenie, intencja internetowa zostanie przypisana do domyślnej przeglądarki użytkownika.

Weryfikowanie intencji za pomocą narzędzia Android Debug Bridge

Aby sprawdzić, czy aplikacja odpowiada na intencje, które chcesz obsługiwać, możesz za pomocą narzędzia adb uruchamiać określone intencje, wykonując te czynności:

1. Skonfiguruj urządzenie z Androidem do tworzenia aplikacji lub użyj urządzenia wirtualnego.
2. Zainstaluj wersję aplikacji obsługującą intencje, które chcesz obsługiwać.
3. Uruchom intencję za pomocą polecenia adb:

   adb shell am start -a <ACTION> -t <MIME_TYPE> -d <DATA> \
     -e <EXTRA_NAME> <EXTRA_VALUE> -n <ACTIVITY>
   

   Na przykład:

   adb shell am start -a android.intent.action.DIAL \
     -d tel:[phone] -n org.example.MyApp/.MyActivity
   

4. Jeśli zdefiniujesz wymagane filtry intencji, przygotuj intencję.

Więcej informacji znajdziesz w artykule o wysyłaniu poleceń powłoki.