Popularne intencje

Intencja umożliwia rozpoczęcie aktywności w innej aplikacji przez opisanie Działanie, które chcesz wykonać, na przykład „wyświetlenie mapy”. lub „Zrób obraz”, w obiekcie Intent. Ten typ zamiaru jest nazywany intencją implicit, ponieważ nie określa aplikacji , ale zamiast tego określa action i zapewnia dane potrzebne do wykonania działania.

Gdy dzwonisz pod numer startActivity() lub startActivityForResult() i przekazać jej intencję niejawną, system rozwiązuje intencję do aplikacji, która może obsłużyć intencję i rozpocznie odpowiadające wartości Activity. Jeśli istnieje więcej niż jedna aplikacja który potrafi obsłużyć intencję, system wyświetla użytkownikowi wybrać aplikację, której chcesz użyć.

Na tej stronie opisujemy kilka niejawnych intencji, których można użyć do wykonania typowe czynności, pogrupowane według typu aplikacji, która obsługuje intencję. Każdy pokazuje też, jak możesz utworzyć intencję , by reklamować możliwość wykonania danego działania przez aplikację.

Uwaga: jeśli na urządzeniu nie ma aplikacji, których można użyć uzyskać pośrednią intencję, a aplikacja ulega awarii, gdy wywołuje metodę startActivity(). Najpierw sprawdź, czy istnieje aplikacja do odbierania intencji, wywołaj resolveActivity() w obiekcie Intent. Jeśli wynik ma wartość inną niż null, jest co najmniej jedną aplikację, która może obsłużyć intencję, i bezpiecznie można wywołać funkcję startActivity(). Jeśli wynik to null, nie używaj intencji i, jeśli to możliwe, wyłącz która wywołuje intencję.

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

Aby dowiedzieć się, jak uruchamiać w aplikacji intencje wymienione na tej stronie Więcej informacji znajdziesz w artykule Weryfikowanie intencji w narzędziu Android Debugowanie. Mostek.

Komendy głosowe Google

Google Voice, Actions uruchamia niektóre z intencji wymienionych na tej stronie w odpowiedzi na poleceń głosowych. Więcej informacji można znaleźć w sekcji Pierwsze kroki z systemowymi komendami głosowymi

Budzik

Poniżej znajdziesz typowe działania związane z aplikacjami budzików, w tym potrzebne informacje aby utworzyć filtr intencji i reklamować możliwość wykonania poszczególnych działań przez aplikację.

Utwórz alarm

Komendy głosowe Google

  • „Ustaw alarm na 7:00”

Aby utworzyć nowy alarm, użyj opcji ACTION_SET_ALARM i określ szczegóły alarmu, takie jak godzina i komunikat, używając tych dodatków.

Uwaga: dostępne są tylko godziny, minuty i dodatkowe wiadomości. w Androidzie 2.3 (poziom API 9) i starszych. Inne 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
Własny komunikat identyfikujący alarm.
EXTRA_DAYS
ArrayList, łącznie z każdym dniem tygodnia, w którym ten alarm i powtarzania. Każdy dzień musi być zadeklarowany liczbą całkowitą z Calendar klasę, na przykład MONDAY.

W przypadku alarmu jednorazowego nie podawaj informacji o opcji dodatkowej.

EXTRA_RINGTONE
Identyfikator URI content: określający dzwonek dla alarmu lub VALUE_RINGTONE_SILENT bez dzwonka.

Aby użyć domyślnego dzwonka, nie określaj dodatkowego.

EXTRA_VIBRATE
Wartość logiczna określająca, czy mają być wibrowane w przypadku tego alarmu.
EXTRA_SKIP_UI
Wartość logiczna określająca, czy odpowiadająca aplikacja musi pominąć swój interfejs użytkownika podczas ustawiania alarmu. Jeśli ma wartość prawda, aplikacja musi pominąć każdy interfejs potwierdzenia i ustawić określony alarm.

Przykładowa intencja:

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 można było 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 wsteczne, użyj działania ACTION_SET_TIMER i określ licznik czasu takie jak czas trwania przy użyciu następujących dodatków.

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

Działanie
ACTION_SET_TIMER
Identyfikator URI danych
Brak
Typ MIME
Brak
.
Dodatki
EXTRA_LENGTH
Czas trwania samowyzwalacza w sekundach.
EXTRA_MESSAGE
Własny komunikat wskazujący minutnik.
EXTRA_SKIP_UI
Wartość logiczna określająca, czy podczas ustawiania minutnika aplikacja odpowiadająca musi pominąć swój interfejs. Jeśli ma wartość prawda, aplikacja musi pominąć każdy interfejs potwierdzenia i uruchomić określony minutnik.

Przykładowa intencja:

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 można było 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 funkcji ACTION_SHOW_ALARMS działania.

Chociaż niewiele aplikacji wywołuje tę intencję, jest ona używana głównie przez aplikacje systemowe, każda aplikacja działająca jak budzik może zaimplementować ten filtr intencji i zareagować, pokazując listę bieżących alarmów.

Uwaga: ta intencja jest dostępna w Androidzie 4.4 (poziom 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 wydarzenia to typowa czynność w aplikacjach kalendarza. Utwórz filtr intencji, aby reklamować możliwość wykonania tego działania przez aplikację za pomocą Więcej informacji na ten temat znajdziesz w następnej sekcji.

Dodaj wydarzenie w kalendarzu

Aby dodać nowe wydarzenie do kalendarza użytkownika, użyj 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 poniższych opcji dodatkowych.

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 (w milisekundach od początku epoki).
EXTRA_EVENT_END_TIME
Czas zakończenia zdarzenia (w milisekundach od początku epoki).
TITLE
Tytuł wydarzenia.
DESCRIPTION
Opis wydarzenia.
EVENT_LOCATION
Miejsce wydarzenia.
EXTRA_EMAIL
Rozdzielona przecinkami lista adresów e-mail, które określają zaproszone osoby.

Więcej szczegółów zdarzenia można określić za pomocą stałych zdefiniowanych w parametrze CalendarContract.EventsColumns zajęcia.

Przykładowa intencja:

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 dotyczące aplikacji aparatu, w tym potrzebne informacje aby utworzyć filtr intencji i reklamować możliwość wykonania poszczególnych działań przez aplikację.

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

Aby otworzyć aplikację aparatu i odebrać zdjęcie lub film, użyj działania ACTION_IMAGE_CAPTURE lub ACTION_VIDEO_CAPTURE. Podaj również lokalizację identyfikatora URI, w której np. aparat, aby zapisać zdjęcie lub film, w EXTRA_OUTPUT dodatkowe.

Działanie
+ ACTION_IMAGE_CAPTURE lub
ACTION_VIDEO_CAPTURE
Schemat identyfikatora URI danych
Brak
Typ MIME
Brak
Dodatki
EXTRA_OUTPUT
identyfikator URI, w którym aplikacja aparatu zapisuje zdjęcie, lub wideo (jako obiekt Uri).

Po powrocie aplikacji aparatu koncentruje się na Twojej aktywności, czyli aplikacja otrzymuje wywołanie zwrotne onActivityResult(). ma dostęp do zdjęcia lub filmu pod podanym identyfikatorem URI wartością EXTRA_OUTPUT.

Uwaga: jeśli używasz ACTION_IMAGE_CAPTURE zrobić zdjęcie, aparat może też zwrócić pomniejszona kopia lub miniatura zdjęcia w wyniku Intent, zapisana jako Bitmap w dodatkowym polu o nazwie "data".

Przykładowa intencja:

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 (poziom interfejsu API 31) lub nowszego, zapoznaj się z poniższym przykładem intencji.

Przykładowa intencja:

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 zrobić zdjęcie za pomocą tej intencji, jak utworzyć odpowiedni element Uri dla lokalizacji wyjściowej, przeczytaj artykuł Zrób zdjęcia lub Nagrywaj filmy.

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 dla dodatkowego EXTRA_OUTPUT w przychodzących Intent, a następnie zapisz przechwycony obraz lub film lokalizacja wskazana przez ten dodatkowy element i wywołaj setResult() z Intent, który zawiera skompresowaną miniaturę w dodatkowym miejscu o nazwie "data".

Uruchamianie aplikacji aparatu w trybie zdjęć

Komendy głosowe Google

  • „zrób zdjęcie”

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

Działanie
INTENT_ACTION_STILL_IMAGE_CAMERA
Schemat identyfikatora URI danych
Brak
Typ MIME
Brak
Dodatki
Brak

Przykładowa intencja:

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ładowa intencja:

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

Oto typowe czynności w aplikacjach do zarządzania kontaktami, w tym potrzebne informacje aby utworzyć filtr intencji i reklamować możliwość wykonania poszczególnych działań przez aplikację.

Wybierz kontakt

Aby użytkownik wybrał kontakt i zapewnił aplikacji dostęp do wszystkich informacji kontaktowych, użyj działania ACTION_PICK i określ typ MIME Contacts.CONTENT_TYPE

Wynik Intent dostarczony do wywołania zwrotnego onActivityResult() zawiera Identyfikator URI content: wskazujący wybrany kontakt. Odpowiedź przyzna tymczasowe uprawnienia aplikacji do odczytu danych kontaktu przy użyciu interfejsu API Contacts Provider, nawet jeśli aplikacja nie zawiera uprawnienia READ_CONTACTS.

Wskazówka: jeśli potrzebujesz dostępu tylko do określonej osoby kontaktowej takich jak numer telefonu lub adres e-mail, zapoznaj się z następną sekcją, w której wyjaśniamy, wybierz konkretne dane kontaktowe.

Działanie
ACTION_PICK
Schemat identyfikatora URI danych
Brak
Typ MIME
Contacts.CONTENT_TYPE

Przykładowa intencja:

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

Aby dowiedzieć się, jak pobrać dane kontaktowe po uzyskaniu identyfikatora URI kontaktu, przeczytaj artykuł Pobierz szczegóły dla kontaktu.

Pobierając identyfikator URI kontaktu za pomocą tej intencji, potrzebują READ_CONTACTS uprawnienia do odczytu podstawowych informacji o danym kontakcie, takich jak wyświetlana nazwa czy kontakt jest oznaczony gwiazdką. Jeśli jednak starasz się odczytywać bardziej szczegółowe dane o danym kontakcie, takie jak jak jej numer telefonu lub adres e-mail – potrzebujesz READ_CONTACTS uprawnienia.

Wybierz konkretne dane kontaktowe

Aby użytkownik wybrał z kontaktu określoną informację, na przykład: numeru telefonu, adresu e-mail lub innego typu danych, użyj funkcji ACTION_PICK i określ typ MIME na 1 następujących typów treści, takich jak CommonDataKinds.Phone.CONTENT_TYPE, aby uzyskać numer telefonu tego kontaktu.

Uwaga: w wielu przypadkach aplikacja musi mieć READ_CONTACTS uprawnienia do wyświetlania konkretnych informacji o konkretnym kontakcie.

Jeśli chcesz pobierać z konta kontaktu tylko jeden typ danych, ta metoda korzysta z tagu CONTENT_TYPE w Klasy ContactsContract.CommonDataKinds to większa wydajność niż za pomocą funkcji Contacts.CONTENT_TYPE, jak pokazano w poprzedniej sekcji. Wynik ten pokazuje, uzyskiwania dostępu do odpowiednich danych bez konieczności wykonywania bardziej skomplikowanego zapytania dostawcy kontaktów.

Wynik Intent dostarczony do wywołania zwrotnego onActivityResult() zawiera Identyfikator URI content: wskazujący wybrane dane kontaktu. Odpowiedź przyzna tymczasowe uprawnienia aplikacji do odczytu danych kontaktów, nawet jeśli aplikacja nie ma uprawnień READ_CONTACTS.

Działanie
ACTION_PICK
Schemat identyfikatora URI danych
Brak
Typ MIME
CommonDataKinds.Phone.CONTENT_TYPE
Wybierać z kontaktów za pomocą numeru telefonu.
CommonDataKinds.Email.CONTENT_TYPE
Wybierz z kontaktów z adresem e-mail.
CommonDataKinds.StructuredPostal.CONTENT_TYPE
Wybierz spośród kontaktów z adresem pocztowym.

Lub jedną z wielu innych wartości CONTENT_TYPE poniżej ContactsContract.

Przykładowa intencja:

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 ACTION_VIEW a jako dane intencji wskaż kontakt, używając identyfikatora URI content:.

Istnieją dwa główne sposoby pobrania identyfikatora URI kontaktu:

  • Użyj identyfikatora URI kontaktu zwróconego przez działanie ACTION_PICK pokazane w poprzedniej sekcji. W tym przypadku nie są wymagane żadne uprawnienia aplikacji.
  • Bezpośredni dostęp do listy wszystkich kontaktów, zgodnie z opisem w sekcji Pobieranie listy kontaktów kontaktów. Ta metoda wymaga READ_CONTACTS uprawnienia.
Działanie
ACTION_VIEW
Schemat identyfikatora URI danych
content:<URI>
Typ MIME
Brak. Typ jest określany na podstawie identyfikatora URI kontaktu.

Przykładowa intencja:

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 ACTION_EDIT działanie, określ kontakt za pomocą identyfikatora URI content: jako dane intencji oraz uwzględnić wszelkie znane informacje kontaktowe w dodatkach określonych przez stałe w polu ContactsContract.Intents.Insert.

Istnieją dwa główne sposoby pobrania identyfikatora URI kontaktu:

  • Użyj identyfikatora URI kontaktu zwróconego przez działanie ACTION_PICK pokazane w poprzedniej sekcji. W tym przypadku nie są wymagane żadne uprawnienia aplikacji.
  • Bezpośredni dostęp do listy wszystkich kontaktów, zgodnie z opisem w sekcji Pobieranie listy kontaktów kontaktów. Ta metoda wymaga READ_CONTACTS uprawnienia.
Działanie
ACTION_EDIT
Schemat identyfikatora URI danych
content:<URI>
Typ MIME
Typ jest ustalany na podstawie identyfikatora URI kontaktu.
Dodatki
Co najmniej jeden dodatek określony w ContactsContract.Intents.Insert aby można było wypełnić pola danych kontaktowych.

Przykładowa intencja:

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 na temat edytowania kontaktów można znaleźć w sekcji Modyfikowanie kontaktów 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 oraz uwzględnij wszelkie znane informacje kontaktowe w opcjach dodatkowych określonych przez stałe w polu 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ładowa intencja:

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 na temat wstawiania kontaktów znajdziesz w sekcji Modyfikowanie kontaktów kontaktów za pomocą intencji.

Wysyłając e-mailem

Tworzenie e-maila z opcjonalnymi załącznikami to typowa czynność w aplikacjach do obsługi poczty e-mail. Utwórz filtr intencji, aby reklamować możliwość wykonania tego działania przez aplikację za pomocą Więcej informacji na ten temat znajdziesz w następnej sekcji.

Tworzenie e-maila z opcjonalnymi załącznikami

Aby utworzyć e-maila, wykonaj jedną z poniższych czynności w zależności od tego, czy dołączasz załączniki: i dołączyć szczegóły e-maila, takie jak adresat i temat, korzystając z dodatkowych kluczy.

Działanie
ACTION_SENDTO (bez załącznika) lub
ACTION_SEND (na 1 załącznik) lub
ACTION_SEND_MULTIPLE (dla wielu załączników)
Schemat identyfikatora URI danych
Brak
Typ MIME
"text/plain"
"*/*"
Dodatki
Intent.EXTRA_EMAIL
Tablica ciągów znaków zawierająca wszystkie dane „To” adresy e-mail odbiorców.
Intent.EXTRA_CC
Tablica ciągów zawierająca wszystkie ciągi znaków „CC” adresy e-mail odbiorców.
Intent.EXTRA_BCC
Tablica ciągów zawierająca wszystkie wartości „UDW” adresy e-mail odbiorców.
Intent.EXTRA_SUBJECT
Ciąg z tematem e-maila.
Intent.EXTRA_TEXT
Ciąg z treścią e-maila.
Intent.EXTRA_STREAM
Uri wskazujący załącznik. Jeśli używasz tagu ACTION_SEND_MULTIPLE to działanie, ArrayList zawierające wiele obiektów Uri.

Przykładowa intencja:

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 będzie obsługiwana tylko przez aplikację do poczty e-mail, a nie SMS-ów lub aplikacji społecznościowych, a następnie 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 czynności dla aplikacji do przechowywania plików, w tym potrzebne informacje. aby utworzyć filtr intencji i reklamować możliwość wykonania poszczególnych działań przez aplikację.

Pobieranie pliku określonego typu

Aby poprosić użytkownika o wybranie pliku, na przykład dokumentu lub zdjęcia, i zwrócenie odwołania do aplikacji, użyj działania ACTION_GET_CONTENT i określ Typ MIME. Odwołanie do pliku zwrócone do aplikacji jest tymczasowe w stosunku do bieżącej aktywności cyklu życia, więc jeśli chcesz uzyskać do niej dostęp później, musisz zaimportować kopię, którą możesz przeczytać później.

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

Intencja wynikowa dostarczona do metody onActivityResult() zawiera dane z identyfikatorem URI wskazującym plik. Identyfikator URI może być dowolny, na przykład identyfikator URI http:, identyfikator URI file: lub content: Identyfikator URI. Jeśli jednak chcesz ograniczyć pliki do wyboru tylko do tych, które są dostępne od dostawcy treści (identyfikator URI content:) dostępne jako strumień plików z openFileDescriptor(), dodaj kategorię CATEGORY_OPENABLE.

W Androidzie 4.3 (poziom interfejsu API 18) i nowszych Możesz też pozwolić użytkownikowi wybrać wiele plików, dodając EXTRA_ALLOW_MULTIPLE określa intencję, ustaw wartość true. Wszystkie wybrane pliki będą dostępne w folderze ClipData obiekt zwrócony przez funkcję getClipData().

Działanie
ACTION_GET_CONTENT
Schemat identyfikatora URI danych
Brak
Typ MIME
Typ MIME odpowiadający typowi pliku, który musi wybrać użytkownik.
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 do urządzenia, bez konieczności pobierania z usługi zdalnej.
Kategoria (opcjonalnie)
CATEGORY_OPENABLE
Aby zwrócić tylko stan „otwarty” pliki, które mogą być reprezentowane jako strumień plików; dzięki openFileDescriptor().

Przykład zamiaru zrobienia 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, który wyświetli 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 trzeba zaimportować do aplikacji, na Androidzie za pomocą działania ACTION_GET_CONTENT w wersji 4.4 lub nowszej możesz zamiast tego poprosić o otwarcie pliku zarządzanego przez inną aplikację przez za pomocą działania ACTION_OPEN_DOCUMENT i określić typ MIME. Aby też umożliwić użytkownikowi tworzenie nowego dokumentu, w którym aplikacja może zapisywać, użyj zamiast tego działania ACTION_CREATE_DOCUMENT.

Na przykład zamiast wybierając spośród istniejących dokumentów PDF, ACTION_CREATE_DOCUMENT pozwala użytkownikom wybrać, gdzie chcą utworzyć nowy dokument, np. w innej aplikacji która zarządza przechowywaniem dokumentu. Aplikacja otrzymuje lokalizację identyfikatora URI, gdzie znajduje i może utworzyć nowy dokument.

Z kolei intencja pozwoliła dotrzeć do onActivityResult() z działania ACTION_GET_CONTENT może zwraca identyfikator URI dowolnego typu, intencję wynikową z ACTION_OPEN_DOCUMENT i ACTION_CREATE_DOCUMENT zawsze określają wybrany plik jako identyfikator URI content: oparty na DocumentsProvider. Plik cookie możesz otworzyć plik z: openFileDescriptor() i zapytanie o jego szczegóły za pomocą kolumn z kolumny DocumentsContract.Document.

Zwrócony identyfikator URI zapewnia aplikacji długoterminowy dostęp do pliku z możliwością odczytu. z uprawnieniami do zapisu. Działanie ACTION_OPEN_DOCUMENT to 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 określa intencję, ustaw wartość true. Jeśli użytkownik wybierze tylko 1 element, możesz go pobrać z usługi getData(). Jeśli użytkownik wybierze więcej niż 1 element, getData() zwraca wartość null. W takim przypadku musisz pobierz każdy element z ClipData obiekt zwracany przez funkcję getClipData().

Uwaga: intencja musi określać typ MIME musi zadeklarować kategorię CATEGORY_OPENABLE. Jeśli możesz określić więcej niż jeden, dodając tablicę typów MIME Dodatkowe EXTRA_MIME_TYPES – jeśli to zrobisz, musisz ustawić parametr podstawowy typ MIME od setType() do "*/*".

Działanie
+ ACTION_OPEN_DOCUMENT lub
ACTION_CREATE_DOCUMENT
Schemat identyfikatora URI danych
Brak
Typ MIME
Typ MIME odpowiadający typowi pliku, który musi wybrać użytkownik.
Dodatki
EXTRA_MIME_TYPES
Tablica typów MIME odpowiadających typom plików, których używa Twoja aplikacja z prośbą o zgodę na wykorzystanie danych. Jeśli chcesz użyć tego dodatkowego, musisz ustawić podstawowy typ MIME w setType() do "*/*".
EXTRA_ALLOW_MULTIPLE
Wartość logiczna określająca, czy użytkownik może wybrać więcej niż 1 plik naraz.
EXTRA_TITLE
Do użytku z zasadą ACTION_CREATE_DOCUMENT, aby określić pierwszą nazwę pliku.
EXTRA_LOCAL_ONLY
Wartość logiczna określająca, czy zwrócony plik musi być dostępny bezpośrednio z do urządzenia, bez konieczności pobierania z usługi zdalnej.
Kategoria
CATEGORY_OPENABLE
Aby zwrócić tylko stan „otwarty” pliki, które mogą być reprezentowane jako strumień plików; dzięki openFileDescriptor().

Przykład zamiaru zrobienia 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ę za pomocą parametru Działanie ACTION_OPEN_DOCUMENT. Zamiast tego system otrzymuje i wyświetla wszystkie pliki dostępne w różnych aplikacjach w ujednoliconym interfejsie.

Aby udostępniać pliki aplikacji w tym interfejsie i umożliwić otwieranie ich innym aplikacjom, musisz zaimplementować element DocumentsProvider i uwzględnij filtr intencji dla: PROVIDER_INTERFACE ("android.content.action.DOCUMENTS_PROVIDER"), tak jak 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>

Aby dowiedzieć się więcej o tym, jak umożliwić otwieranie plików zarządzanych przez Twoją aplikację z innych aplikacji, przeczytaj artykuł Otwieranie plików za pomocą platformy dostępu do pamięci masowej.

Działania lokalne

Dzwonienie pod samochód jest typową czynnością lokalną. Utwórz filtr intencji, aby reklamować możliwości wykonania tej czynności przy użyciu informacji podanych w następnej sekcji.

Zamów taksówkę

Komendy głosowe Google

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

(Tylko Wear OS)

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

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

Działanie
ACTION_RESERVE_TAXI_RESERVATION
Identyfikator URI danych
Brak
Typ MIME
Brak
Dodatki
Brak

Przykładowa intencja:

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 czynność w przypadku aplikacji z mapami. Utwórz filtr intencji, aby reklamować możliwość wykonania tego działania przez aplikację za pomocą Więcej informacji na ten temat znajdziesz w następnej sekcji.

Pokaż lokalizację na mapie

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

Działanie
ACTION_VIEW
Schemat identyfikatora URI danych
geo:latitude,longitude
Pokaż mapę dla danej długości i szerokości geograficznej.

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

geo:latitude,longitude?z=zoom
Wyświetl mapę z określoną długością i szerokością geograficzną na określonym poziomie powiększenia. Powiększenie: 1 wskazuje całą Ziemię w środku współrzędnych geograficznych. Najwyższa (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ę z określoną długością i szerokością geograficzną za pomocą etykiety w postaci ciągu znaków.

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

geo:0,0?q=my+street+address
Pokaż lokalizację w polu „mój adres pocztowy”, 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 identyfikatorze URI geo muszą zakodować. Na przykład ciąg 1st & Pike, Seattle stanie się 1st%20%26%20Pike%2C%20Seattle Spacje w ciągu znaków są zakodowane za pomocą %20 lub zastąp znakiem plusa (+).

Typ MIME
Brak

Przykładowa intencja:

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 – w tym informacje, których potrzebujesz aby utworzyć filtr intencji i reklamować możliwość wykonania poszczególnych działań przez aplikację.

Odtwarzanie pliku multimedialnego

Aby odtworzyć plik muzyczny, użyj działania ACTION_VIEW i określić 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 dowolny inny, którego wymaga Twoja aplikacja.

Przykładowa intencja:

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 zapytania

Komendy głosowe Google

  • „włącz michaela jacksona Billie jean”

Aby odtworzyć muzykę na podstawie zapytania, użyj Intencja INTENT_ACTION_MEDIA_PLAY_FROM_SEARCH. Aplikacja może się uruchomić w odpowiedzi na polecenie głosowe użytkownika dotyczące odtwarzania muzyki. Aplikacja odbierająca określone intencja przeprowadza wyszukiwanie w swoich zasobach reklamowych, aby dopasować istniejącą treść do danego zapytania rozpocznie odtwarzanie tych treści.

W tej intencji uwzględnij 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 nazwy wykonawcy lub 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: czy użytkownik szuka konkretnego wykonawcy, albumu, utworu, lub playlistę. Większość trybów wyszukiwania wymaga dodatkowych dodatków. Jeśli na przykład użytkownik jest zainteresowany słuchaniem konkretnego utworu, zamiar może mieć 3 dodatkowe materiały: tytuł utworu, wykonawcę i album. Ta intencja obsługuje następujące tryby wyszukiwania dla każda wartość EXTRA_MEDIA_FOCUS:

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

Pozwól na dowolną muzykę. Aplikacja odbierająca odtwarza muzykę na podstawie inteligentnego wyboru, takiego jak jako ostatniej playlisty, której odsłuchiwał użytkownik.

Dodatkowe dodatki:

  • QUERY (wymagany): pusty ciąg znaków. Ten dodatek jest zawsze zapewnia zgodność wsteczną. Istniejące aplikacje, które nie wiedzą o trybach wyszukiwania, i traktują tę intencję jako nieuporządkowane wyszukiwanie.

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

Odtwarzanie określonego utworu, albumu lub gatunku przy użyciu nieuporządkowanego zapytania. Aplikacje mogą generować użytkowników korzystających z tego trybu wyszukiwania, gdy nie potrafią określić, jakiego rodzaju treści chce których słuchają. W miarę możliwości używaj bardziej szczegółowych trybów wyszukiwania.

Dodatkowe dodatki:

  • QUERY (wymagany): ciąg znaków zawierający dowolną kombinację. informacje o wykonawcy, albumie, tytule lub gatunku.

Gatunek – Audio.Genres.ENTRY_CONTENT_TYPE

odtwarzać muzyki z konkretnego gatunku;

Dodatkowe dodatki:

  • "android.intent.extra.genre" (wymagany) – gatunek.
  • QUERY (wymagany): gatunek. Ten dodatek jest zawsze podawany dla zgodności wstecznej. Dotychczasowe aplikacje, które nie znają trybów wyszukiwania, mogą jako nieustrukturyzowane wyszukiwanie.

Wykonawca – Audio.Artists.ENTRY_CONTENT_TYPE

odtworzenie muzyki konkretnego wykonawcy;

Dodatkowe dodatki:

  • EXTRA_MEDIA_ARTIST (wymagany): wykonawca.
  • "android.intent.extra.genre": gatunek.
  • QUERY (wymagany): ciąg znaków zawierający dowolną kombinację od wykonawcy lub gatunku. Ten dodatek zawsze zapewnia zgodność wsteczną. Istniejące aplikacje, które nie znają trybów wyszukiwania, mogą przetworzyć tę intencję jako nieustrukturyzowaną .

Album – Audio.Albums.ENTRY_CONTENT_TYPE

włączyć muzykę z konkretnego albumu;

Dodatkowe dodatki:

  • EXTRA_MEDIA_ALBUM (wymagany): album.
  • EXTRA_MEDIA_ARTIST: wykonawca.
  • "android.intent.extra.genre": gatunek.
  • QUERY (wymagany): ciąg znaków zawierający dowolną kombinację album lub wykonawcę. Ten dodatek jest zawsze podawany w odniesieniu do poprzedniej zgodność. Istniejące aplikacje, które nie wiedzą o trybach wyszukiwania, mogą przetworzyć tę intencję jako wyszukiwania w nieuporządkowanych danych.

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

odtworzenie konkretnego utworu;

Dodatkowe dodatki:

  • 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ę album, wykonawcę, gatunek lub tytuł. Ten dodatek jest zawsze podawany w przypadku zgodność wsteczną. Istniejące aplikacje, które nie znają trybów wyszukiwania, mogą to zrobić jako nieuporządkowanego wyszukiwania.

Playlista – Audio.Playlists.ENTRY_CONTENT_TYPE

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

Dodatkowe dodatki:

  • EXTRA_MEDIA_ALBUM: album.
  • EXTRA_MEDIA_ARTIST: wykonawca.
  • "android.intent.extra.genre": gatunek.
  • "android.intent.extra.playlist": playlista.
  • EXTRA_MEDIA_TITLE: nazwa utworu, który jest przypisany do playlisty; na podstawie modelu atrybucji.
  • QUERY (wymagany): ciąg znaków zawierający dowolną kombinację. albumu, wykonawcy, gatunku, playlisty lub tytułu. Ten dodatek jest zawsze zapewnia zgodność wsteczną. Istniejące aplikacje, które nie wiedzą o trybach wyszukiwania, i traktują tę intencję jako nieuporządkowane wyszukiwanie.

Przykładowa intencja:

Jeśli użytkownik chce posłuchać muzyki konkretnego wykonawcy, aplikacja do wyszukiwania może wygenerować tę 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>

Wykonując tę intencję w swojej aktywności, sprawdź wartość parametru Czeka na Ciebie EXTRA_MEDIA_FOCUS dodatkowy Intent, aby wybrać tryb wyszukiwania. Gdy aktywność zidentyfikuje przeczytaj wartości dodatkowych dodatków do tego trybu. Dzięki tym informacjom aplikacja może przeprowadzić wyszukiwanie w zasobach reklamowych, aby odtworzyć które pasują do zapytania. 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

W aplikacjach do robienia notatek tworzenie notatek jest typową czynnością. Utwórz filtr intencji, aby reklamować możliwość wykonania tego działania przez aplikację za pomocą Więcej informacji na ten temat znajdziesz w następnej sekcji.

Tworzenie notatki

Aby utworzyć nową notatkę, skorzystaj z ACTION_CREATE_NOTE i określ szczegóły notatki, takie jak temat i tekst, korzystając z następujących dodatków.

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

Działanie
ACTION_CREATE_NOTE
Schemat identyfikatora URI danych
Brak
Typ MIME
PLAIN_TEXT_TYPE
„*/*”
Dodatki
EXTRA_NAME
Ciąg tekstowy wskazujący tytuł lub temat notatki.
EXTRA_TEXT
Ciąg tekstowy wskazujący tekst notatki.

Przykładowa intencja:

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łączenia to typowa czynność w aplikacjach do obsługi telefonu. Utwórz filtr intencji, aby reklamować możliwość wykonania tego działania przez aplikację za pomocą Więcej informacji na ten temat znajdziesz w następnej sekcji.

Zainicjowanie połączenia głosowego

Aby otworzyć aplikację Telefon i wybrać numer telefonu, wykonaj działanie ACTION_DIAL i wpisz numer telefonu, używając następujący schemat URI. Po otwarciu aplikacji Telefon wyświetli się numer telefonu, i użytkownik musi kliknąć przycisk Zadzwoń, aby rozpocząć połączenie.

Komendy głosowe Google

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

Aby zadzwonić bezpośrednio, użyj działania ACTION_CALL i podaj numer telefonu, używając poniższego schematu URI. Po otwarciu aplikacji Telefon rozpocznie połączenie telefoniczne. Użytkownik nie musi klikać przycisku Zadzwoń.

Działanie ACTION_CALL wymaga dodania makra Uprawnienia CALL_PHONE do pliku manifestu:

<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 CALL_PHONE)
Schemat identyfikatora URI danych
  • tel:<phone-number>
  • voicemail:<phone-number>
Typ MIME
Brak

Prawidłowe numery telefonów to te określone w specyfikacji IETF RFC 3966. Prawidłowe przykłady:

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

Telefon w aplikacji Telefon dobrze sobie radzi z normalizacją schematów, takich jak: numerów telefonów. Opisany schemat nie jest więc wymagany Metoda Uri.parse(). Jeśli jednak nie wypróbowali Państwo schematu lub nie mają Państwo pewności, czy można przetworzyć, użyj funkcji Uri.fromParts() .

Przykładowa intencja:

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

Oto typowe czynności w przypadku aplikacji do wyszukiwania, w tym potrzebne informacje aby utworzyć filtr intencji i reklamować możliwość wykonania poszczególnych działań przez aplikację.

Wyszukiwanie przy użyciu konkretnej aplikacji

Komendy głosowe Google

  • „wyszukaj filmy z kotami w myvideoapp”

Aby obsługiwać wyszukiwanie w kontekście aplikacji, zadeklaruj w niej filtr intencji za pomocą parametru działanie SEARCH_ACTION, jak widać w tym przykładzie filtra intencji.

Uwaga: nie zalecamy używania adresu SEARCH_ACTION do wyszukiwania aplikacji. Zamiast tego zaimplementuj funkcję GET_THING by wykorzystać wbudowaną obsługę wyszukiwania w aplikacji przez Asystenta Google. Więcej informacji: Asystenta Google Działania w aplikacji.

Działanie
"com.google.android.gms.actions.SEARCH_ACTION"
Obsługa zapytań z komend głosowych 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>

Wyszukaj w internecie

Aby rozpocząć wyszukiwanie w internecie, użyj działania ACTION_WEB_SEARCH i podaj szukany ciąg w polu Dodatkowo SearchManager.QUERY.

Działanie
ACTION_WEB_SEARCH
Schemat identyfikatora URI danych
Brak
Typ MIME
Brak
Dodatki
SearchManager.QUERY
Wyszukiwany ciąg znaków.

Przykładowa intencja:

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ć w systemowej aplikacji Ustawienia ekran, gdy aplikacja wymaga od użytkownika wprowadzenia zmian: użyj jednego z tych działań 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

Dodatkowe ekrany ustawień znajdziesz w dokumentacji Settings .

Schemat identyfikatora URI danych
Brak
Typ MIME
Brak

Przykładowa intencja:

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 wiadomości SMS/MMS z załącznikiem to typowa czynność w aplikacjach do obsługi SMS-ów. Utwórz filtr intencji, aby reklamować możliwość wykonania tego działania przez aplikację za pomocą Więcej informacji na ten temat znajdziesz w następnej sekcji.

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

Aby zainicjować SMS-a lub MMS-a, użyj jednego z poniższych działań intencji i określ wiadomość takie jak numer telefonu, temat i treść wiadomości, używając następujących dodatkowych klawiszy:

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>

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

Typ MIME
"text/plain"
"image/*"
"video/*"
Dodatki
"subject"
Ciąg znaków tematu wiadomości (zwykle tylko w przypadku MMS-ów).
"sms_body"
Ciąg tekstowy.
EXTRA_STREAM
Uri wskazuje zdjęcie lub film, które chcesz załączyć. Jeśli używasz działania ACTION_SEND_MULTIPLE, ten dodatek ma ArrayList w wysokości Uri obiekty wskazujące obrazy lub filmy, które chcesz załączyć.

Przykładowa intencja:

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, aby intencja była obsługiwana tylko przez aplikację do obsługi SMS-ów, a nie przez e-maili lub aplikacji społecznościowych, a następnie 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, zastosuj filtry intencji w kilku dodatkowych działaniach. domyślna aplikacja do SMS-ów na Androidzie 4.4 lub nowszym. Więcej informacji znajdziesz w dokumentacji o Telephony.

Przeglądarka

Wczytywanie adresu URL to częste działanie w przeglądarkach. Utwórz filtr intencji, aby reklamować możliwość wykonania tego działania przez aplikację za pomocą Więcej informacji na ten temat znajdziesz w następnej sekcji.

Wczytywanie internetowego adresu URL

Komendy głosowe Google

  • „otwórz example.com”

Aby otworzyć stronę internetową, użyj działania ACTION_VIEW i określić 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ładowa intencja:

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 w swojej witrynie, dodaj filtr intencji dla adresów URL, które prowadzą do Twojej witryny. Następnie: czy użytkownicy zainstalowali Twoją aplikację, linki w e-mailach lub na innych stronach internetowych kierujące do Twojej witryny; otwórz aplikację na Androida, a nie stronę internetową. Więcej informacji: Obsługa linków aplikacji na Androida

Począwszy od Androida 12 (poziom interfejsu API 31) ogólna intencja internetowa przestaje być aktywność w aplikacji tylko wtedy, gdy została ona zatwierdzona w określonej domenie zawartą w tej intencji internetowej. Jeśli aplikacja nie zostanie zatwierdzona w domenie, będzie wskazywać domyślną przeglądarkę użytkownika.

Weryfikowanie intencji za pomocą narzędzia Android Debug Bridge

Aby sprawdzić, czy aplikacja odpowiada na obsługiwane intencje, możesz użyć metody adb, aby wywoływać określone intencje poprzez wykonanie następujące:

  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. 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:555-5555 -n org.example.MyApp/.MyActivity
  4. Jeśli zdefiniujesz wymagane filtry intencji, zrób obsługę intencji.

Więcej informacji: Wydaj polecenia powłoki.