Popularne intencje

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

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:

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

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:

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

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:

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

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:

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

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:

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

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:

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

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:

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

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:

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

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:

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

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:

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

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:

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

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:

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

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:

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

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:

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

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ę:

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

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.

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

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

Szukaj

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.