Popularne intencje

Intencja umożliwia rozpoczęcie aktywności w innej aplikacji przez opisanie działania, które chcesz wykonać, np. „wyświetl mapę” lub „zrób zdjęcie”, w obiekcie Intent. Ten typ intencji nazywa się intencją niejawną, ponieważ nie określa komponentu aplikacji, który ma zostać uruchomiony, ale określa działanie i dostarcza dane, za pomocą których można wykonać to działanie.

Gdy wywołasz startActivity() lub startActivityForResult() i przekażesz mu niejawny zamiar, system rozwiąże zamiar, aby znaleźć aplikację, która może go obsłużyć, i uruchomi odpowiedni Activity. Jeśli jest więcej niż jedna aplikacja, która może obsłużyć intencję, system wyświetli użytkownikowi okno dialogowe, w którym będzie mógł wybrać aplikację do użycia.

Na tej stronie znajdziesz opis kilku niejawnych intencji, których możesz używać do wykonywania typowych działań. Są one uporządkowane 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ć możliwość wykonania działania przez aplikację.

Ostrzeżenie: jeśli na urządzeniu nie ma aplikacji, które mogą odbierać niejawne intencje, aplikacja ulega awarii, gdy wywołuje startActivity(). Aby najpierw sprawdzić, czy istnieje aplikacja, która może odebrać intencję, wywołaj metodę resolveActivity() na obiekcie Intent. Jeśli wynik nie jest pusty, oznacza to, że co najmniej jedna aplikacja może obsłużyć intencję i można bezpiecznie wywołać funkcję startActivity(). Jeśli wynik to null, nie używaj intencji i w miarę możliwości wyłącz funkcję, która ją wywołuje.

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

Aby dowiedzieć się, jak wywoływać intencje wymienione na tej stronie z hosta deweloperskiego, zapoznaj się z sekcją Weryfikowanie intencji za pomocą Android Debug Bridge.

Komendy głosowe Google

Działania Google Voice uruchamiają niektóre intencje wymienione na tej stronie w odpowiedzi na polecenia głosowe. Więcej informacji znajdziesz w artykule Pierwsze kroki z systemowymi działaniami głosowymi.

Budzik

Poniżej znajdziesz typowe działania aplikacji z budzikiem, a także informacje potrzebne do utworzenia filtra intencji, który będzie reklamować możliwość wykonywania każdego z tych działań przez Twoją aplikację.

Tworzenie alarmu

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 wiadomość, za pomocą tych dodatków:

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

Czynność
ACTION_SET_ALARM
Identyfikator URI danych
Brak
Typ MIME
Brak
Dodatki
EXTRA_HOUR
Godzina alarmu.
EXTRA_MINUTES
 Minuty alarmu.
EXTRA_MESSAGE
Własny komunikat identyfikujący alarm.
EXTRA_DAYS
ArrayList zawierająca każdy dzień tygodnia, w którym alarm ma się powtarzać. Każdy dzień musi być zadeklarowany za pomocą liczby całkowitej z klasy Calendar, np. MONDAY.

W przypadku alarmu jednorazowego nie podawaj tej dodatkowej informacji.

EXTRA_RINGTONE
Identyfikator URI content: określający dzwonek, który ma być używany z alarmem, lub VALUE_RINGTONE_SILENT, jeśli dzwonek nie ma być używany.

Aby użyć domyślnego dzwonka, nie podawaj tego dodatku.

EXTRA_VIBRATE
Wartość logiczna określająca, czy w przypadku tego alarmu ma być włączona wibracja.
EXTRA_SKIP_UI
Wartość logiczna określająca, czy aplikacja odpowiadająca musi pominąć interfejs podczas ustawiania alarmu. Jeśli wartość to „true”, aplikacja musi pominąć interfejs potwierdzenia i ustawić 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>

Tworzenie minutnika

Komendy głosowe Google

  • „ustaw minutnik na 5 minut”

Aby utworzyć odliczanie, użyj działania ACTION_SET_TIMER i określ szczegóły timera, takie jak czas trwania, za pomocą tych dodatków:

Uwaga: ten zamiar jest dostępny w Androidzie 4.4 (interfejs API na poziomie 19) i nowszych wersjach.

Czynność
ACTION_SET_TIMER
Identyfikator URI danych
Brak
Typ MIME
Brak
Dodatki
EXTRA_LENGTH
Długość timera w sekundach.
EXTRA_MESSAGE
Własna wiadomość identyfikująca timer.
EXTRA_SKIP_UI
Wartość logiczna określająca, czy aplikacja odpowiadająca musi pominąć interfejs podczas ustawiania minutnika. Jeśli wartość to „true”, aplikacja musi pominąć interfejs potwierdzenia i uruchomić 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 wywołuje ten zamiar, ponieważ jest on używany głównie przez aplikacje systemowe, każda aplikacja, która działa jak budzik, może zaimplementować ten filtr intencji i odpowiedzieć, wyświetlając listę bieżących alarmów.

Uwaga: ten zamiar jest dostępny w Androidzie 4.4 (interfejs API na poziomie 19) i nowszych wersjach.

Czynność
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 wydarzenia to typowe działanie w aplikacjach kalendarza. Utwórz filtr intencji, aby reklamować możliwość wykonywania tej czynności przez aplikację, korzystając z informacji w sekcji poniżej.

Dodawanie wydarzenia w kalendarzu

Aby dodać nowe wydarzenie do kalendarza użytkownika, użyj działania ACTION_INSERT i określ identyfikator URI danych za pomocą Events.CONTENT_URI. Następnie możesz określić różne szczegóły wydarzenia, korzystając z tych dodatków:

Czynność
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
Godzina rozpoczęcia wydarzenia (w milisekundach od początku epoki).
EXTRA_EVENT_END_TIME
Godzina zakończenia wydarzenia (w milisekundach od początku epoki).
TITLE
Nazwa wydarzenia.
DESCRIPTION
Opis wydarzenia.
EVENT_LOCATION
Lokalizacja wydarzenia.
EXTRA_EMAIL
Lista adresów e-mail zaproszonych osób rozdzielonych przecinkami.

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 aplikacji aparatu, w tym informacje potrzebne do utworzenia filtra intencji, który będzie reklamować możliwość wykonywania każdego z tych działań przez Twoją aplikację.

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

Aby otworzyć aplikację aparatu i otrzymać zdjęcie lub film, użyj działania ACTION_IMAGE_CAPTURE lub ACTION_VIDEO_CAPTURE. Określ też identyfikator URI lokalizacji, w której aparat ma zapisać zdjęcie lub film, w elemencie EXTRA_OUTPUTextra.

Czynność
ACTION_IMAGE_CAPTURElub
ACTION_VIDEO_CAPTURE
Schemat URI danych
Brak
Typ MIME
Brak
Dodatki
EXTRA_OUTPUT
Lokalizacja URI, w której aplikacja aparatu zapisuje zdjęcie lub plik wideo (jako obiekt Uri).

Gdy aplikacja aparatu pomyślnie zwróci fokus do Twojej aktywności, czyli Twoja aplikacja otrzyma wywołanie zwrotne onActivityResult(), możesz uzyskać dostęp do zdjęcia lub filmu pod adresem URI określonym za pomocą wartości EXTRA_OUTPUT.

Uwaga: gdy używasz ACTION_IMAGE_CAPTURE do zrobienia zdjęcia, aparat może też zwrócić pomniejszoną kopię lub miniaturę zdjęcia w wyniku Intent, zapisaną 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ć w przypadku Androida 12 (API na poziomie 31) lub nowszego, 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 tym, jak używać tego zamiaru do robienia zdjęć, w tym o tym, jak utworzyć odpowiedni Uri dla lokalizacji wyjściowej, znajdziesz w artykułach Robienie zdjęćNagrywanie 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 tego zamiaru aktywność powinna sprawdzić dodatkowy element EXTRA_OUTPUT w przychodzącym elemencie Intent, a następnie zapisać przechwycony obraz lub film w lokalizacji określonej przez ten dodatkowy element i wywołać setResult() z elementem Intent, który zawiera skompresowaną miniaturę w dodatkowym elemencie o nazwie "data".

Uruchamianie aplikacji aparatu w trybie zdjęć

Komendy głosowe Google

  • „zrób zdjęcie”,

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

Czynność
INTENT_ACTION_STILL_IMAGE_CAMERA
Schemat 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.

Czynność
INTENT_ACTION_VIDEO_CAMERA
Schemat 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 aplikacji do zarządzania kontaktami, a także informacje potrzebne do utworzenia filtra intencji, który będzie reklamować możliwość wykonywania każdego z tych działań przez Twoją aplikację.

Wybierz kontakt

Aby użytkownik mógł wybrać kontakt i przyznać aplikacji dostęp 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 Contacts Provider, nawet jeśli aplikacja nie zawiera uprawnienia READ_CONTACTS.

Wskazówka: jeśli potrzebujesz dostępu tylko do konkretnych informacji o kontakcie, takich jak numer telefonu lub adres e-mail, zapoznaj się z następną sekcją, w której opisujemy, jak wybrać konkretne dane kontaktu.

Czynność
ACTION_PICK
Schemat 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 URI kontaktu za pomocą tego zamiaru, zwykle nie potrzebujesz uprawnień do odczytywania podstawowych informacji o tym kontakcie, takich jak nazwa wyświetlana czy informacja o tym, czy kontakt jest oznaczony gwiazdką.READ_CONTACTS Jeśli jednak chcesz odczytać bardziej szczegółowe dane o danym kontakcie, takie jak numer telefonu lub adres e-mail, musisz mieć uprawnienie READ_CONTACTS.

Wybieranie konkretnych danych kontaktowych

Aby użytkownik mógł wybrać konkretne informacje z kontaktu, np. numer telefonu, adres e-mail lub inny typ danych, użyj działania ACTION_PICK i określ typ MIME jako jeden z tych typów treści, np. CommonDataKinds.Phone.CONTENT_TYPE, aby uzyskać numer telefonu kontaktu.

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

Jeśli musisz pobrać tylko jeden typ danych z kontaktu, ta technika z użyciem klas CONTENT_TYPEContactsContract.CommonDataKinds jest bardziej wydajna niż użycie Contacts.CONTENT_TYPE, jak pokazano w poprzedniej sekcji. Wynik zapewnia bezpośredni dostęp do żądanych danych bez konieczności wykonywania bardziej złożonego zapytania do dostawcy kontaktów.

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

Czynność
ACTION_PICK
Schemat URI danych
Brak
Typ MIME
CommonDataKinds.Phone.CONTENT_TYPE
Wybierz kontakt z numerem telefonu.
CommonDataKinds.Email.CONTENT_TYPE
Wybierz kontakty z adresem e-mail.
CommonDataKinds.StructuredPostal.CONTENT_TYPE
Wybierz kontakty z adresem pocztowym.

lub jedną z wielu innych wartości CONTENT_TYPE w sekcji 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 za pomocą identyfikatora URI content: jako danych intencji.

URI kontaktu można początkowo pobrać na 2 główne sposoby:

  • Użyj identyfikatora URI kontaktu zwróconego przez działanie ACTION_PICK pokazane w poprzedniej sekcji. To podejście nie wymaga żadnych uprawnień aplikacji.
  • Uzyskaj bezpośredni dostęp do listy wszystkich kontaktów, jak opisano w sekcji Pobieranie listy kontaktów. To podejście wymaga uprawnienia READ_CONTACTS.
Czynność
ACTION_VIEW
Schemat URI danych
content:<URI>
Typ MIME
Brak. Typ jest wywnioskowany z 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, określ kontakt za pomocą identyfikatora URI content: jako danych intencji i uwzględnij wszelkie znane informacje kontaktowe w dodatkach określonych przez stałe w ContactsContract.Intents.Insert.

Adres URI kontaktu można początkowo pobrać na 2 główne sposoby:

  • Użyj identyfikatora URI kontaktu zwróconego przez działanie ACTION_PICK pokazane w poprzedniej sekcji. To podejście nie wymaga żadnych uprawnień aplikacji.
  • Uzyskaj bezpośredni dostęp do listy wszystkich kontaktów, jak opisano w sekcji Pobieranie listy kontaktów. To podejście wymaga uprawnienia READ_CONTACTS.
Czynność
ACTION_EDIT
Schemat URI danych
content:<URI>
Typ MIME
Typ jest wywnioskowany z identyfikatora URI kontaktu.
Dodatki
Co najmniej jeden dodatkowy element zdefiniowany w ContactsContract.Intents.Insert umożliwiający wypełnianie pól danych 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.

Wstawianie kontaktu

Aby wstawić nowy kontakt, użyj działania ACTION_INSERT, określ Contacts.CONTENT_TYPE jako typ MIME i uwzględnij wszelkie znane informacje kontaktowe w dodatkach określonych przez stałe w ContactsContract.Intents.Insert.

Czynność
ACTION_INSERT
Schemat URI danych
Brak
Typ MIME
Contacts.CONTENT_TYPE
Dodatki
Co najmniej 1 dodatek zdefiniowany w pliku 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 artykule Modyfikowanie kontaktów za pomocą intencji.

Wysyłając e-mailem

Tworzenie e-maila z opcjonalnymi załącznikami to typowa czynność w aplikacjach poczty e-mail. Utwórz filtr intencji, aby reklamować możliwość wykonywania tej czynności przez aplikację, korzystając z informacji w sekcji poniżej.

Tworzenie e-maila z opcjonalnymi załącznikami

Aby napisać e-maila, wykonaj jedną z tych czynności (w zależności od tego, czy chcesz dodać załączniki), i podaj szczegóły e-maila, takie jak odbiorca i temat, używając wymienionych dodatkowych klawiszy.

Czynność
ACTION_SENDTO (brak załącznika) lub
ACTION_SEND (jeden załącznik) lub
ACTION_SEND_MULTIPLE (wiele załączników)
Schemat URI danych
Brak
Typ MIME
"text/plain"
"*/*"
Dodatki
Intent.EXTRA_EMAIL
Tablica ciągów zawierająca wszystkie adresy e-mail odbiorców w polu „Do”.
Intent.EXTRA_CC
Tablica ciągów zawierająca wszystkie adresy e-mail odbiorców w polu „DW”.
Intent.EXTRA_BCC
Tablica ciągów zawierająca wszystkie adresy e-mail odbiorców w polu „UDW”.
Intent.EXTRA_SUBJECT
Ciąg znaków z tematem e-maila.
Intent.EXTRA_TEXT
Ciąg znaków z treścią e-maila.
Intent.EXTRA_STREAM
Strzałka Uri wskazująca załącznik. Jeśli używasz działania ACTION_SEND_MULTIPLE, zamiast tego będzie 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 mieć pewność, że intencja użytkownika zostanie obsłużona tylko przez aplikację do obsługi poczty e-mail, a nie przez aplikację do obsługi wiadomości tekstowych lub społecznościową, użyj działania ACTION_SENDTO i uwzględnij schemat danych "mailto:", jak pokazano 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 w aplikacjach do przechowywania plików, a także informacje potrzebne do utworzenia filtra intencji, który będzie reklamować możliwość wykonywania każdego z tych działań przez Twoją aplikację.

Pobieranie określonego typu pliku

Aby poprosić użytkownika o wybranie pliku, np. dokumentu lub zdjęcia, i zwrócenie odwołania do aplikacji, użyj działania ACTION_GET_CONTENT i określ żądany typ MIME. Odwołanie do pliku zwrócone do aplikacji jest tymczasowe w bieżącym cyklu życia aktywności, więc jeśli chcesz uzyskać do niego dostęp później, musisz zaimportować kopię, którą będzie można odczytać w przyszłości.

Ten zamiar umożliwia też użytkownikowi utworzenie nowego pliku. Na przykład zamiast wybierać istniejące zdjęcie, użytkownik może zrobić nowe za pomocą aparatu.

Intencja wyniku dostarczona do Twojej 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 u dostawcy treści (identyfikator URI content:) i są dostępne jako strumień plików z openFileDescriptor(), dodaj do intencji kategorię CATEGORY_OPENABLE.

Na Androidzie 4.3 (API na poziomie 18) i nowszych możesz też zezwolić użytkownikowi na wybieranie wielu plików, dodając do intencji wartość EXTRA_ALLOW_MULTIPLE ustawioną na true. Następnie możesz uzyskać dostęp do każdego z wybranych plików w ClipData obiekcie zwróconym przez getClipData().

Czynność
ACTION_GET_CONTENT
Schemat 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 zwrócony plik musi być dostępny bezpośrednio z urządzenia, zamiast wymagać pobrania z usługi zdalnej.
Kategoria (opcjonalnie)
CATEGORY_OPENABLE
Aby zwracać tylko „otwieralne” pliki, które można przedstawić jako strumień plików z parametrem 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 zwracający 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 określonego typu pliku

Zamiast pobierać kopię pliku, którą musisz zaimportować do aplikacji, możesz użyć działania ACTION_GET_CONTENT. Jeśli korzystasz z Androida 4.4 lub nowszego, możesz poprosić o otwarcie pliku zarządzanego przez inną aplikację, używając działania ACTION_OPEN_DOCUMENT i określając typ MIME. Jeśli chcesz też umożliwić użytkownikowi utworzenie nowego dokumentu, w którym Twoja aplikacja będzie mogła zapisywać dane, użyj działania ACTION_CREATE_DOCUMENT.

Na przykład zamiast wybierać spośród istniejących dokumentów PDF, ACTION_CREATE_DOCUMENT intencja pozwala użytkownikom wybrać miejsce, w którym chcą utworzyć nowy dokument, np. w innej aplikacji zarządzającej przechowywaniem dokumentów. Aplikacja otrzyma wtedy lokalizację URI, w której może zapisać nowy dokument.

Intencja przekazywana do metody onActivityResult() z działania ACTION_GET_CONTENT może zwracać identyfikator URI dowolnego typu, ale intencja wyniku z ACTION_OPEN_DOCUMENTACTION_CREATE_DOCUMENT zawsze określa wybrany plik jako identyfikator URI content:, który jest obsługiwany przez DocumentsProvider. Możesz otworzyć plik za pomocą openFileDescriptor() i sprawdzić jego szczegóły, korzystając z kolumn z DocumentsContract.Document.

Zwrócony identyfikator URI przyznaje aplikacji długoterminowy dostęp do pliku z możliwością odczytu, a także ewentualnie z możliwością zapisu. Działanie ACTION_OPEN_DOCUMENT jest szczególnie przydatne, gdy chcesz odczytać istniejący plik bez kopiowania go do aplikacji lub gdy chcesz otworzyć i edytować plik w miejscu, w którym się znajduje.

Możesz też zezwolić użytkownikowi na wybranie wielu plików, dodając do intencji wartość EXTRA_ALLOW_MULTIPLE ustawioną na true. Jeśli użytkownik wybierze tylko 1 element, możesz go pobrać z getData(). Jeśli użytkownik wybierze więcej niż 1 element, funkcja getData() zwróci wartość null. W takim przypadku musisz pobrać każdy element z obiektu ClipData, który jest zwracany przez funkcję getClipData().

Uwaga: intencja musi określać typ MIME i musi deklarować kategorię CATEGORY_OPENABLE. W razie potrzeby możesz podać więcej niż jeden typ MIME, dodając tablicę typów MIME z parametrem dodatkowym EXTRA_MIME_TYPES. Jeśli to zrobisz, musisz ustawić podstawowy typ MIME w parametrze setType() na "*/*".

Czynność
ACTION_OPEN_DOCUMENT lub
ACTION_CREATE_DOCUMENT
Schemat 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, o które prosi aplikacja. Jeśli używasz tego dodatku, musisz ustawić podstawowy typ MIME w 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żywany z parametrem ACTION_CREATE_DOCUMENT do określania początkowej nazwy pliku.
EXTRA_LOCAL_ONLY
Wartość logiczna określająca, czy zwrócony plik musi być dostępny bezpośrednio z urządzenia, zamiast wymagać pobrania z usługi zdalnej.
Kategoria
CATEGORY_OPENABLE
Aby zwracać tylko „otwieralne” pliki, które można przedstawić jako strumień plików z parametrem 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ą odpowiadać na intencję za pomocą działania ACTION_OPEN_DOCUMENT. Zamiast tego system otrzymuje ten zamiar i wyświetla wszystkie pliki dostępne w różnych aplikacjach w ujednoliconym interfejsie.

Aby udostępnić pliki aplikacji w tym interfejsie i umożliwić ich otwieranie przez inne aplikacje, 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 Storage Access Framework.

Działania lokalne

Zamawianie taksówki to typowe działanie lokalne. Utwórz filtr intencji, aby reklamować możliwość wykonania tej czynności przez aplikację, korzystając z informacji w sekcji poniżej.

Zamów taksówkę

Komendy głosowe Google

  • „zamów taksówkę”,
  • „wezwij dla mnie samochód”,

(tylko Wear OS)

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

Uwaga: przed wykonaniem tej czynności aplikacje muszą poprosić użytkownika o potwierdzenie.

Czynność
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

Wyświetlanie lokalizacji na mapie to typowa funkcja aplikacji do map. Utwórz filtr intencji, aby reklamować możliwość wykonywania tej czynności przez aplikację, korzystając z informacji w sekcji poniżej.

Wyświetlanie lokalizacji na mapie

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

Czynność
ACTION_VIEW
Schemat URI danych
geo:latitude,longitude
Wyświetl mapę na podanej długości i szerokości geograficznej.

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

geo:latitude,longitude?z=zoom
Wyświetla mapę z określonymi współrzędnymi geograficznymi i poziomem powiększenia. Poziom powiększenia 1 pokazuje całą Ziemię wyśrodkowaną na podanych wartościach latlng. 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świetl mapę o podanej długości i szerokości geograficznej z etykietą tekstową.

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

geo:0,0?q=my+street+address
Wyświetl lokalizację dla „mój adres”, który może być konkretnym adresem lub zapytaniem o lokalizację.

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

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

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 w aplikacjach muzycznych i wideo, a także informacje potrzebne do utworzenia filtra intencji, który będzie reklamować możliwość wykonywania każdego z tych działań przez Twoją aplikację.

Odtwarzanie pliku multimedialnego

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

Czynność
ACTION_VIEW
Schemat URI danych
file:<URI>
content:<URI>
http:<URL>
Typ MIME
"audio/*"
"application/ogg"
"application/x-ogg"
"application/itunes"
lub inne, których wymaga Twoja aplikacja.

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

  • „Odtwórz Michael Jackson Billie Jean”

Aby odtworzyć muzykę na podstawie zapytania, użyj intencji INTENT_ACTION_MEDIA_PLAY_FROM_SEARCH. Aplikacja może wywołać tę intencję w odpowiedzi na polecenie głosowe użytkownika, aby odtworzyć muzykę. Aplikacja odbierająca ten intent przeprowadza wyszukiwanie w swoim asortymencie, aby dopasować istniejące treści do podanego zapytania, i rozpoczyna odtwarzanie tych treści.

W tym zamiarze uwzględnij ciąg EXTRA_MEDIA_FOCUSextra, który określa zamierzony tryb wyszukiwania. Na przykład tryb wyszukiwania może określać, czy wyszukiwana jest nazwa wykonawcy czy tytuł utworu.

Czynność
INTENT_ACTION_MEDIA_PLAY_FROM_SEARCH
Schemat URI danych
Brak
Typ MIME
Brak
Dodatki
MediaStore.EXTRA_MEDIA_FOCUS (pole wymagane)

Wskazuje tryb wyszukiwania: czy użytkownik szuka konkretnego wykonawcy, albumu, utworu czy playlisty. Większość trybów wyszukiwania wymaga dodatkowych opłat. Jeśli na przykład użytkownik chce posłuchać konkretnej piosenki, zamiar może mieć 3 dodatkowe elementy: tytuł utworu, wykonawcę i album. Ten zamiar obsługuje te tryby wyszukiwania dla każdej wartości EXTRA_MEDIA_FOCUS:

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

Odtwarzaj dowolną muzykę. Aplikacja odbierająca odtwarza muzykę na podstawie inteligentnego wyboru, np. ostatniej playlisty słuchanej przez użytkownika.

Dodatkowe udogodnienia:

  • QUERY (wymagany): pusty ciąg znaków. Ten dodatkowy element jest zawsze udostępniany ze względu na zgodność wsteczną. Obecne aplikacje, które nie znają trybów wyszukiwania, mogą przetwarzać ten zamiar jako wyszukiwanie nieustrukturyzowane.

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

odtwarzać konkretny utwór, album lub gatunek na podstawie nieustrukturyzowanego zapytania. Aplikacje mogą generować zamiar w tym trybie wyszukiwania, gdy nie mogą określić rodzaju treści, których użytkownik chce posłuchać. W miarę możliwości korzystaj z bardziej szczegółowych trybów wyszukiwania.

Dodatkowe udogodnienia:

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

GatunekAudio.Genres.ENTRY_CONTENT_TYPE

włączyć muzykę określonego gatunku;

Dodatkowe udogodnienia:

  • "android.intent.extra.genre" (wymagany) – gatunek.
  • QUERY (wymagany): gatunek. Ten dodatkowy element jest zawsze udostępniany ze względu na zgodność wsteczną. Obecne aplikacje, które nie znają trybów wyszukiwania, mogą przetwarzać ten zamiar jako wyszukiwanie nieustrukturyzowane.

WykonawcaAudio.Artists.ENTRY_CONTENT_TYPE

włączanie muzyki konkretnego wykonawcy;

Dodatkowe udogodnienia:

  • EXTRA_MEDIA_ARTIST (wymagane): wykonawca.
  • "android.intent.extra.genre": gatunek.
  • QUERY (wymagany): ciąg znaków zawierający dowolną kombinację wykonawcy lub gatunku. Ten dodatkowy element jest zawsze udostępniany ze względu na zgodność wsteczną. Obecne aplikacje, które nie znają trybów wyszukiwania, mogą przetwarzać ten zamiar jako wyszukiwanie bez struktury.

AlbumAudio.Albums.ENTRY_CONTENT_TYPE

odtwarzanie muzyki z konkretnego albumu;

Dodatkowe udogodnienia:

  • EXTRA_MEDIA_ALBUM (wymagany): album.
  • EXTRA_MEDIA_ARTIST: wykonawca;
  • "android.intent.extra.genre": gatunek.
  • QUERY (wymagany): ciąg znaków zawierający dowolną kombinację albumu lub wykonawcy. Ten dodatkowy parametr jest zawsze udostępniany ze względu na zgodność wsteczną. Obecne aplikacje, które nie znają trybów wyszukiwania, mogą przetwarzać ten zamiar jako wyszukiwanie bez struktury.

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

Odtwórz konkretny utwór.

Dodatkowe udogodnienia:

  • EXTRA_MEDIA_ALBUM: album.
  • EXTRA_MEDIA_ARTIST: wykonawca;
  • "android.intent.extra.genre": gatunek.
  • EXTRA_MEDIA_TITLE (wymagany): nazwa utworu.
  • QUERY (wymagany): ciąg znaków zawierający dowolną kombinację albumu, wykonawcy, gatunku lub tytułu. Ten dodatkowy element jest zawsze udostępniany ze względu na zgodność wsteczną. Obecne aplikacje, które nie znają trybów wyszukiwania, mogą przetwarzać ten zamiar jako wyszukiwanie bez struktury.

PlaylistaAudio.Playlists.ENTRY_CONTENT_TYPE

Odtwarzanie konkretnej playlisty lub playlisty spełniającej określone kryteria.

Dodatkowe udogodnienia:

  • EXTRA_MEDIA_ALBUM: album.
  • EXTRA_MEDIA_ARTIST: wykonawca;
  • "android.intent.extra.genre": gatunek.
  • "android.intent.extra.playlist": playlistę.
  • EXTRA_MEDIA_TITLE: nazwa utworu, na którym opiera się playlista.
  • QUERY (wymagany): ciąg znaków zawierający dowolną kombinację albumu, wykonawcy, gatunku, playlisty lub tytułu. Ten dodatkowy element jest zawsze udostępniany ze względu na zgodność wsteczną. Obecne aplikacje, które nie znają trybów wyszukiwania, mogą przetwarzać ten zamiar jako wyszukiwanie nieustrukturyzowane.

Przykładowy zamiar:

Jeśli użytkownik chce posłuchać muzyki konkretnego wykonawcy, aplikacja wyszukiwarki może wygenerować ten zamiar:

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 tego zamiaru w aktywności sprawdź wartość dodatku EXTRA_MEDIA_FOCUS w przychodzącym zamiarze Intent, aby określić tryb wyszukiwania. Gdy aktywność określi tryb wyszukiwania, odczytaj wartości dodatkowych elementów dla tego trybu. Na podstawie tych informacji aplikacja może przeprowadzić wyszukiwanie w swoim asortymencie, aby odtworzyć treści pasujące do wyszukiwanego hasła. Pokazuje to poniższy przykład.

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 notatki to typowe działanie w aplikacjach do robienia notatek. Utwórz filtr intencji, aby reklamować możliwość wykonywania tej czynności przez aplikację, korzystając z informacji 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ą tych dodatków:

Uwaga: przed wykonaniem tej czynności aplikacje muszą poprosić użytkownika o potwierdzenie.

Czynność
ACTION_CREATE_NOTE
Schemat URI danych
Brak
Typ MIME
PLAIN_TEXT_TYPE
"*/*"
Dodatki
EXTRA_NAME
Ciąg tekstowy wskazujący tytuł lub temat notatki.
EXTRA_TEXT
Ciąg znaków wskazujący tekst 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 typowe działanie w przypadku aplikacji telefonicznych. Utwórz filtr intencji, aby reklamować możliwość wykonywania tej czynności przez aplikację, korzystając z informacji w sekcji poniżej.

Zainicjowanie połączenia głosowego

Aby otworzyć aplikację telefonu i wybrać numer, użyj działania ACTION_DIAL i określ numer telefonu za pomocą tego schematu URI: Po otwarciu aplikacji telefonu wyświetli się numer telefonu, a użytkownik musi kliknąć przycisk Zadzwoń, aby rozpocząć połączenie.

Komendy głosowe Google

  • „zadzwoń pod numer 555-5555”
  • „zadzwoń do boba”
  • „zadzwoń na pocztę głosową”,

Aby bezpośrednio zadzwonić, użyj działania ACTION_CALL i podaj numer telefonu, korzystając z tego schematu URI: Gdy otworzy się aplikacja Telefon, rozpocznie się połączenie. Użytkownik nie musi klikać przycisku Zadzwoń.

Działanie ACTION_CALL wymaga dodania uprawnień CALL_PHONE do pliku manifestu:

<uses-permission android:name="android.permission.CALL_PHONE" />
Czynność
  • ACTION_DIAL – otwiera aplikację Telefon.
  • ACTION_CALL – wykonuje połączenie telefoniczne (wymaga uprawnienia CALL_PHONE)
Schemat URI danych
  • tel:<phone-number>
  • voicemail:<phone-number>
Typ MIME
Brak

Prawidłowe numery telefonów to numery zdefiniowane w IETF RFC 3966. Prawidłowe przykłady:

  • tel:2125551212
  • tel:(212) 555 1212

Aplikacja Telefon dobrze normalizuje schematy, takie jak numery telefonów. Opisany schemat nie jest więc ściśle wymagany w metodzie Uri.parse(). Jeśli jednak nie znasz 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);
    }
}

Poniżej znajdziesz typowe działania w aplikacjach do wyszukiwania, a także informacje potrzebne do utworzenia filtra intencji, który będzie reklamować możliwość wykonywania każdego z tych działań przez Twoją aplikację.

Wyszukiwanie za pomocą konkretnej aplikacji

Komendy głosowe Google

  • „wyszukaj filmy z kotami w mojej aplikacji do odtwarzania filmów”

Aby obsługiwać wyszukiwanie w kontekście aplikacji, zadeklaruj w niej filtr intencji z działaniem SEARCH_ACTION, jak pokazano w tym przykładzie:

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

Czynność
"com.google.android.gms.actions.SEARCH_ACTION"
Obsługa zapytań z komend głosowych Google.
Dodatki
QUERY
Ciąg tekstowy zawierający zapytanie.

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>

Wyszukiwanie w internecie

Aby rozpocząć wyszukiwanie w internecie, użyj działania ACTION_WEB_SEARCH i określ ciąg wyszukiwania w SearchManager.QUERY extra.

Czynność
ACTION_WEB_SEARCH
Schemat URI danych
Brak
Typ MIME
Brak
Dodatki
SearchManager.QUERY
Ciąg wyszukiwania.

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

Jeśli aplikacja wymaga od użytkownika zmiany ustawień, aby otworzyć ekran w aplikacji Ustawienia systemowe, użyj jednej z tych działań intencji:

Czynność
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

Dodatkowe ekrany ustawień znajdziesz w Settingsdokumentacji .

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

Wysyłanie SMS-ów

Tworzenie SMS-a lub MMS-a z załącznikiem to typowe działanie w aplikacjach do obsługi wiadomości tekstowych. Utwórz filtr intencji, aby reklamować możliwość wykonywania tej czynności przez aplikację, korzystając z informacji w sekcji poniżej.

Tworzenie SMS-a lub MMS-a z załącznikiem

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

Czynność
ACTION_SENDTO lub
ACTION_SEND lub
ACTION_SEND_MULTIPLE
Schemat URI danych
sms:<phone_number>
smsto:<phone_number>
mms:<phone_number>
mmsto:<phone_number>

Wszystkie te schematy są obsługiwane w ten sam sposób.

Typ MIME
"text/plain"
"image/*"
"video/*"
Dodatki
"subject"
Ciąg znaków dla tematu wiadomości (zwykle tylko w przypadku MMS-ów).
"sms_body"
Ciąg znaków SMS-a.
EXTRA_STREAM
 Uri wskazujący obraz lub film, który chcesz załączyć. Jeśli używasz działania ACTION_SEND_MULTIPLE, ten dodatkowy element to ArrayList 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 mieć pewność, że intencja jest obsługiwana tylko przez aplikację do wysyłania wiadomości tekstowych, a nie przez inne aplikacje do obsługi poczty e-mail lub społecznościowe, użyj działania ACTION_SENDTO i uwzględnij schemat danych "smsto:", jak pokazano 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 urządzeniach z Androidem 4.4 i nowszym. Więcej informacji znajdziesz w dokumentacji pod adresem Telephony.

Przeglądarka

Wczytywanie adresu URL to typowe działanie aplikacji przeglądarki internetowej. Utwórz filtr intencji, aby reklamować możliwość wykonywania tej czynności przez aplikację, korzystając z informacji w sekcji poniżej.

Wczytywanie adresu URL

Komendy głosowe Google

  • „otwórz example.com”

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

Czynność
ACTION_VIEW
Schemat 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 oferuje funkcje podobne do tych w Twojej witrynie, dodaj filtr intencji dla adresów URL, które prowadzą do Twojej witryny. Jeśli użytkownicy mają zainstalowaną Twoją aplikację, linki z e-maili lub innych stron internetowych prowadzące do Twojej witryny będą otwierać aplikację na Androida zamiast strony internetowej. Więcej informacji znajdziesz w artykule Obsługa linków aplikacji na Androida.

Od Androida 12 (API na poziomie 31) ogólny zamiar internetowy jest rozpoznawany jako aktywność w aplikacji tylko wtedy, gdy aplikacja została zatwierdzona w przypadku konkretnej domeny zawartej w tym zamiarze internetowym. Jeśli aplikacja nie zostanie zatwierdzona w domenie, zamiast niej zostanie otwarta domyślna aplikacja przeglądarki użytkownika.

Weryfikowanie intencji za pomocą Android Debug Bridge

Aby sprawdzić, czy aplikacja reaguje na intencje, które chcesz obsługiwać, możesz użyć narzędzia adb do wywoływania określonych intencji, wykonując te czynności:

  1. Skonfiguruj urządzenie z Androidem do programowania lub użyj urządzenia wirtualnego.
  2. Zainstaluj wersję aplikacji, która obsługuje intencje, które chcesz obsługiwać.
  3. Wywołaj intencję za pomocą 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:555-5555 -n org.example.MyApp/.MyActivity
    
  4. Jeśli zdefiniujesz wymagane filtry intencji, obsłuż intencję.

Więcej informacji znajdziesz w artykule Wydawanie poleceń powłoki.