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 wykorzystywaniu tej intencji do robienia zdjęć, w tym o tworzeniu odpowiedniego elementu Uri dla lokalizacji wyjściowej, znajdziesz w artykule Robienie zdjęć i Robienie filmów.

Przykład filtra 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 sprawdź, czy w przychodzącym Intent jest dodatkowy EXTRA_OUTPUT, a następnie zapisz uchwycony obraz lub film w lokalizacji określonej przez ten dodatkowy Intent i zadzwoń do setResult() z Intent, który zawiera skompresowany miniaturę w dodatku o nazwie "data".

Uruchom aplikację aparatu w trybie zdjęć

Komendy głosowe Google

• „zrób zdjęcie”

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

Działanie

INTENT_ACTION_STILL_IMAGE_CAMERA

Schemat identyfikatora URI danych

Brak

Typ MIME

Brak

Dodatki

Brak

Przykład intencji:

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>

Uruchom aplikację aparatu w trybie wideo.

Komendy głosowe Google

• „Nagrywanie filmu”

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ład intencji:

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ład filtra intencji:

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

Aplikacja Kontakty/Osoby

Poniżej znajdziesz typowe działania dla aplikacji do zarządzania kontaktami, w tym informacje potrzebne do utworzenia filtra intencji, aby reklamować możliwość wykonania danego działania przez aplikację.

Wybierz kontakt

Aby użytkownik wybrał kontakt i przyznał aplikacji dostęp do wszystkich informacji kontaktowych, użyj działania ACTION_PICK i wpisz typ MIME na Contacts.CONTENT_TYPE.

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

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

Działanie

ACTION_PICK

Schemat identyfikatora URI danych

Brak

Typ MIME

Contacts.CONTENT_TYPE

Przykład intencji:

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

Informacje o tym, jak poznać szczegóły kontaktu, gdy znasz jego identyfikator URI, znajdziesz w artykule Pobieranie szczegółów kontaktu.

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

Wybieranie konkretnych danych kontaktowych

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

Uwaga: w wielu przypadkach aplikacja musi mieć uprawnienie READ_CONTACTS do wyświetlania określonych informacji o kontakcie.

Jeśli chcesz pobrać tylko jeden typ danych z kontaktu, ta metoda z użyciem funkcji CONTENT_TYPE z klasy ContactsContract.CommonDataKinds jest bardziej wydajna niż użycie funkcji Contacts.CONTENT_TYPE, jak pokazano w poprzedniej sekcji. Wynik daje bezpośredni dostęp do odpowiednich danych bez konieczności wykonywania bardziej złożonego zapytania do dostawcy usługi Kontakty.

Wynik Intent zwrócony do wywołania zwrotnego onActivityResult() zawiera identyfikator URI content: wskazujący wybrane dane kontaktowe. Odpowiedź przyznaje aplikacji tymczasowe uprawnienia do odczytu danych kontaktów, nawet jeśli aplikacja nie obejmuje uprawnienia 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 kontakty z adresem e-mail.

CommonDataKinds.StructuredPostal.CONTENT_TYPE

Wybierz kontakty z adresem pocztowym.

Możesz też użyć jednej z wielu innych wartości CONTENT_TYPE pod ContactsContract.

Przykład intencji:

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 działania ACTION_VIEW i jako dane intencji podaj identyfikator URI kontaktu 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. Takie podejście nie wymaga żadnych uprawnień aplikacji.
• Bezpośredni dostęp do listy wszystkich kontaktów zgodnie z opisem w sekcji Pobieranie listy kontaktów. To podejście wymaga uprawnienia READ_CONTACTS.

Działanie

ACTION_VIEW

Schemat URI danych

content:<URI>

Typ MIME

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

Przykład intencji:

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 działania ACTION_EDIT, określ kontakt z identyfikatorem URI content: jako dane intencji i dodaj wszelkie znane informacje kontaktowe w elementach dodatkowych określonych przez stałe w elemencie ContactsContract.Intents.Insert.

Istnieją 2 podstawowe sposoby początkowego pobrania identyfikatora URI kontaktu:

• Użyj identyfikatora URI kontaktu zwróconego przez działanie ACTION_PICK pokazane w poprzedniej sekcji. Takie podejście nie wymaga żadnych uprawnień aplikacji.
• Bezpośredni dostęp do listy wszystkich kontaktów zgodnie z opisem w sekcji Pobieranie listy kontaktów. To podejście wymaga uprawnienia READ_CONTACTS.

Działanie

ACTION_EDIT

Schemat URI danych

content:<URI>

Typ MIME

Typ jest określany na podstawie identyfikatora URI kontaktu.

Dodatki

Co najmniej 1 z opcji dodatkowych zdefiniowanych w sekcji ContactsContract.Intents.Insert, aby wypełnić pola danych kontaktowych.

Przykład intencji:

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 o edytowaniu kontaktów znajdziesz w artykule Modyfikowanie kontaktów za pomocą intencji.

Wstawianie kontaktu

Aby wstawić nowy kontakt, użyj działania ACTION_INSERT, określ Contacts.CONTENT_TYPE jako typ MIME i dodaj wszystkie znane informacje o kontakcie w dodatkowych danych określonych za pomocą stałych w ContactsContract.Intents.Insert.

Działanie

ACTION_INSERT

Schemat identyfikatora URI danych

Brak

Typ MIME

Contacts.CONTENT_TYPE

Dodatki

Co najmniej 1 z dodatków zdefiniowanych w ContactsContract.Intents.Insert.

Przykład intencji:

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 o wstawianiu kontaktów znajdziesz w artykule Modyfikowanie kontaktów za pomocą intencji.

Wysyłając e-mailem

Tworzenie e-maila z opcjonalnymi załącznikami jest typową czynnością w aplikacjach poczty e-mail. Utwórz filtr intencji, aby reklamować możliwość wykonania tego działania przez aplikację, korzystając z informacji podanych w poniższej sekcji.

Tworzenie e-maila z opcjonalnymi załącznikami

Aby stworzyć e-maila, użyj jednej z tych czynności w zależności od tego, czy chcesz dołączyć załączniki, a także dodaj szczegóły e-maila, takie jak odbiorca i temat, za pomocą wymienionych dodatkowych kluczy.

Działanie

ACTION_SENDTO (brak załącznika) lub
ACTION_SEND (jeden załącznik) lub
ACTION_SEND_MULTIPLE (wiele 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 adresy e-mail odbiorców z pola „Do”.

Intent.EXTRA_CC

Tablica ciągów tekstowych zawierająca wszystkie adresy e-mail odbiorców w kopii.

Intent.EXTRA_BCC

Tablica ciągów znaków zawierająca wszystkie adresy e-mail odbiorców w kopii „UDW”.

Intent.EXTRA_SUBJECT

Ciąg z tematem e-maila.

Intent.EXTRA_TEXT

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

Intent.EXTRA_STREAM

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

Przykład intencji:

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 Twoja intencja jest obsługiwana tylko przez aplikację poczty e-mail, a nie przez aplikację do obsługi wiadomości tekstowych ani aplikację społecznościową, 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 działania w przypadku aplikacji do przechowywania plików. Poniżej znajdziesz informacje potrzebne do utworzenia filtra intencji reklamującego możliwość wykonywania poszczególnych działań przez aplikację.

Pobieranie określonego typu pliku

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

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

Intencją wyniku przekazaną do metody onActivityResult() są dane z identyfikatorem URI wskazującym na 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ć wybór do plików dostępnych od dostawcy treści (identyfikator URI content:) i dostępnych jako strumień plików z openFileDescriptor(), dodaj kategorię CATEGORY_OPENABLE do swojej intencji.

Na Androidzie 4.3 (poziom interfejsu API 18) i nowszych możesz też zezwolić użytkownikowi na wybranie wielu plików, dodając EXTRA_ALLOW_MULTIPLE do intencji z wartością true. Następnie możesz uzyskać dostęp do wszystkich wybranych plików w obiekcie ClipDatazwróconym 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 urządzenia, a nie wymagać pobrania z usługi zdalnej.

Kategoria (opcjonalna)

CATEGORY_OPENABLE

Aby zwrócić tylko „otwieralne” pliki, które można przedstawić jako strumień plików za pomocą 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 określonego typu pliku

Zamiast pobierać kopię pliku, który musisz zaimportować do aplikacji, za pomocą działania ACTION_GET_CONTENT, gdy aplikacja działa na Androidzie 4.4 lub nowszym, możesz zamiast tego poprosić o otworzenie pliku zarządzanego przez inną aplikację, używając działania ACTION_OPEN_DOCUMENT i określając typ MIME. Aby umożliwić użytkownikowi utworzenie nowego dokumentu, do którego Twoja aplikacja będzie mogła zapisywać dane, użyj zamiast tego działania ACTION_CREATE_DOCUMENT.

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

Intencje przekazywane do metody onActivityResult() z działania ACTION_GET_CONTENT mogą zwracać identyfikator URI dowolnego typu, ale intencje wywołujące działanie ACTION_OPEN_DOCUMENT i ACTION_CREATE_DOCUMENT zawsze określają wybrany plik jako identyfikator URI content:, który jest obsługiwany przez DocumentsProvider. Możesz otworzyć plik za pomocą openFileDescriptor() i zapytać o jego szczegóły za pomocą kolumn z DocumentsContract.Document.

Zwrócony identyfikator URI przyznaje aplikacji długoterminowy dostęp do odczytu pliku, a także ewentualnie dostęp do zapisu. Akcja ACTION_OPEN_DOCUMENT jest szczególnie przydatna, gdy chcesz odczytać istniejący plik bez tworzenia jego kopii w aplikacji lub gdy chcesz otworzyć i edytować plik na miejscu.

Możesz też pozwolić użytkownikowi wybrać wiele plików, dodając do intencji element EXTRA_ALLOW_MULTIPLE z wartością true. Jeśli użytkownik wybierze tylko jeden element, możesz go pobrać z getData(). Jeśli użytkownik wybierze więcej niż 1 element, getData() zwraca wartość null i musisz pobrać każdy element z obiektu ClipData, który jest zwracany przez funkcję getClipData().

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

Działanie

ACTION_OPEN_DOCUMENT lub
ACTION_CREATE_DOCUMENT

Schemat 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 aplikacja potrzebuje. Jeśli korzystasz z tej opcji dodatkowej, musisz ustawić podstawowy typ MIME w setType() na "*/*".

EXTRA_ALLOW_MULTIPLE

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

EXTRA_TITLE

Do użycia z opcją ACTION_CREATE_DOCUMENT w celu określenia początkowej nazwy pliku.

EXTRA_LOCAL_ONLY

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

Kategoria

CATEGORY_OPENABLE

Aby zwrócić tylko „otwieralne” pliki, które można przedstawić jako strumień plików za pomocą 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ą odpowiadać na intencję z działaniem ACTION_OPEN_DOCUMENT. Zamiast tego system otrzymuje tę intencję i wyświetla wszystkie pliki dostępne w różnych aplikacjach w ujednoliconym interfejsie użytkownika.

Aby udostępniać pliki aplikacji w tym interfejsie i umożliwiać otwieranie ich przez inne aplikacje, musisz zaimplementować DocumentsProvider i uwzględnić filtr intencji PROVIDER_INTERFACE("android.content.action.DOCUMENTS_PROVIDER"), jak pokazano w tym przykładzie:

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

Więcej informacji o otwieraniu plików zarządzanych przez Twoją aplikację z innych aplikacji znajdziesz w artykule Otwieranie plików za pomocą platformy Storage Access Framework.

Działania lokalne

Zamawianie taksówki to typowe działanie lokalne. Utwórz filtr intencji, aby reklamować możliwość wykonania tego działania przez aplikację. Aby to zrobić, skorzystaj z informacji w następnej sekcji.

Zamów taksówkę

Komendy głosowe Google

• „Zamów mi taksówkę”
• „Zadzwoń po samochód”

(dotyczy tylko Wear OS)

Aby zamówić taksówkę, użyj czynności ACTION_RESERVE_TAXI_RESERVATION.

Uwaga: aplikacje muszą poprosić 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ład intencji:

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ład filtra 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 jest typowym działaniem w przypadku aplikacji mapowych. Utwórz filtr intencji, aby reklamować możliwość wykonania tego działania przez aplikację. Aby to zrobić, skorzystaj z informacji w następującej sekcji.

Pokaż lokalizację na mapie

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

Działanie

ACTION_VIEW

Schemat URI danych

geo:latitude,longitude

Pokaż mapę z podawaną długością i szerokością geograficzną.

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. Poziom powiększenia 1 pokazuje całą Ziemię, której środek znajduje się w danych współrzędnych lat,lng. Najwyższy (najbliższy) poziom powiększenia to 23.

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

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

Wyświetlanie mapy na podanej długości i szerokości geograficznej z etykietą ciągu znaków.

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

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

Pokaż lokalizację „mój adres ulicy”, która 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 adresie URL geo muszą być zakodowane. Na przykład ciąg tekstowy 1st & Pike, Seattle zmieni się na 1st%20%26%20Pike%2C%20Seattle. Spacje w ciągu są kodowane za pomocą znaku %20 lub zastępowane znakiem plusa (+).

Typ MIME

Brak

Przykład intencji:

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ład filtra 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 najczęstsze działania w przypadku aplikacji muzycznych i wideo, w tym informacje potrzebne do utworzenia filtra intencji, który reklamuje możliwość wykonania danego działania przez Twoją aplikację.

Odtwarzanie pliku multimedialnego

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

Działanie

ACTION_VIEW

Schemat 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ład intencji:

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ład filtra 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

• „play michael jackson billie jean”

Aby odtwarzać muzykę na podstawie zapytania wyszukiwania, użyj intencji INTENT_ACTION_MEDIA_PLAY_FROM_SEARCH. Aplikacja może uruchomić tę intencję w odpowiedzi na polecenie głosowe użytkownika dotyczące odtwarzania muzyki. Aplikacja, która otrzymuje ten intencjonalny obiekt, wyszukuje w swoim katalogu treści pasujące do podanego zapytania i odtwarza je.

W tej intencji uwzględnij ciąg tekstowy EXTRA_MEDIA_FOCUS, który określa zamierzony tryb wyszukiwania. Na przykład tryb wyszukiwania może określać, czy wyszukiwanie dotyczy nazwy wykonawcy czy utworu.

Działanie

INTENT_ACTION_MEDIA_PLAY_FROM_SEARCH

Schemat identyfikatora URI danych

Brak

Typ MIME

Brak

Dodatki

MediaStore.EXTRA_MEDIA_FOCUS (pole wymagane)

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

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

odtwarzać dowolną muzykę, Aplikacja odbiorcza odtwarza muzykę na podstawie inteligentnego wyboru, np. ostatniej playlisty odsłuchanej przez użytkownika.

Dodatkowe funkcje:

• QUERY (wymagany): pusty ciąg znaków. Ta opcja jest zawsze udostępniana ze względu na zgodność wsteczną. Istniejące aplikacje, które nie znają trybów wyszukiwania, mogą przetworzyć tę intencję jako nieuporządkowane wyszukiwanie.

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

odtworzyć konkretny utwór, album lub gatunek na podstawie nieustrukturyzowanego zapytania; W tym trybie wyszukiwania aplikacje mogą generować intencje, gdy nie potrafią określić typu treści, których chce posłuchać. W miarę możliwości używaj bardziej szczegółowych trybów wyszukiwania.

Dodatkowe funkcje:

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

Gatunek –Audio.Genres.ENTRY_CONTENT_TYPE

odtwarzanie muzyki określonego gatunku;

Dodatkowe funkcje:

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

Artysta – Audio.Artists.ENTRY_CONTENT_TYPE

odtwarzanie muzyki konkretnego wykonawcy;

Dodatkowe funkcje:

• EXTRA_MEDIA_ARTIST (wymagany): wykonawca.
• "android.intent.extra.genre": gatunek.
• QUERY (wymagany): ciąg znaków zawierający dowolną kombinację wykonawcy lub gatunku. Ta opcja jest zawsze udostępniana ze względu na zgodność wsteczną. Istniejące aplikacje, które nie znają trybów wyszukiwania, mogą przetworzyć tę intencję jako nieuporządkowane wyszukiwanie.

Album – Audio.Albums.ENTRY_CONTENT_TYPE

włączyć muzykę z konkretnego albumu;

Dodatkowe funkcje:

• EXTRA_MEDIA_ALBUM (wymagany): album.
• EXTRA_MEDIA_ARTIST: wykonawca.
• "android.intent.extra.genre": gatunek.
• QUERY (wymagany): ciąg znaków zawierający dowolną kombinację albumu lub wykonawcy. Ten dodatek jest zawsze udostępniany w celu zapewnienia zgodności wstecznej. Istniejące aplikacje, które nie znają trybów wyszukiwania, mogą przetwarzać ten zamiar jako wyszukiwanie nieustrukturyzowane.

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): nazwa utworu.
• QUERY (wymagany): ciąg znaków zawierający dowolną kombinację albumu, wykonawcy, gatunku lub tytułu. Ten dodatek jest zawsze udostępniany ze względu na zgodność wsteczną. Istniejące aplikacje, które nie znają trybów wyszukiwania, mogą przetworzyć tę intencję jako nieuporządkowane wyszukiwanie.

Playlista – Audio.Playlists.ENTRY_CONTENT_TYPE

odtwarzać określoną playlistę lub playlistę, która spełnia określone kryteria, aby uzyskać dodatkowe opcje;

Dodatkowe funkcje:

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

Przykład intencji:

Jeśli użytkownik chce słuchać muzyki danego wykonawcy, aplikacja wyszukiwania może wygenerować taki zamiar:

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ład filtra intencji:

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

Podczas obsługi tej intencji w swojej aktywności sprawdź wartość dodatkowego parametru EXTRA_MEDIA_FOCUS w wejściowym parametrze Intent, aby określić tryb wyszukiwania. Gdy Twoja aktywność zidentyfikuje tryb wyszukiwania, przeczytaj wartości dodatkowych dodatków. Dzięki tym informacjom aplikacja może przeprowadzić wyszukiwanie w swoich zasobach reklamowych, aby odtworzyć treści pasujące 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

Tworzenie notatek to typowa czynność w przypadku aplikacji do tworzenia notatek. Utwórz filtr intencji, aby reklamować możliwość wykonania tego działania przez aplikację. Aby to zrobić, skorzystaj z informacji w następującej sekcji.

Tworzenie notatki

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

Uwaga: aplikacje muszą poprosić 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 zawierający treść notatki.

Przykład intencji:

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ład filtra 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

Rozpoczynanie połączeń jest częstym działaniem w przypadku aplikacji telefonicznych. Utwórz filtr intencji, aby reklamować możliwość wykonania tego działania przez aplikację. Aby to zrobić, skorzystaj z informacji w następnej sekcji.

Zainicjowanie połączenia głosowego

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

Komendy głosowe Google

• „zadzwoń pod numer 555-5555”
• „Zadzwoń do Boba”
• „wywołanie poczty głosowej”

Aby nawiązać bezpośrednie połączenie telefoniczne, użyj działania ACTION_CALL i podaj numer telefonu zgodnie z poniższym schematem URI. Gdy otworzy się aplikacja Telefon, rozpocznie się połączenie. Użytkownik nie musi klikać przycisku Zadzwoń.

Aby wykonać działanie ACTION_CALL, musisz dodać do pliku manifestu uprawnienia CALL_PHONE:

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

Działanie

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

Schemat URI danych

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

Typ MIME

Brak

Prawidłowe numery telefonów to te zdefiniowane w specyfikacji IETF RFC 3966. Przykłady prawidłowych treści:

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

Dialer w aplikacji Telefon dobrze radzi sobie z normalizacją schematów, takich jak numery telefonów. Oznacza to, że opisana wyżej metoda nie jest wymagana w metodie Uri.parse(). Jeśli jednak nie próbowałeś jeszcze żadnego schematu lub nie masz pewności, czy da się go zastosować, użyj zamiast tego metody Uri.fromParts().

Przykład intencji:

Kotlin

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

Java

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

Szukaj

Poniżej znajdziesz najczęstsze działania związane z aplikacją wyszukiwania, w tym informacje potrzebne do utworzenia filtra intencji, aby reklamować możliwość wykonania danego działania przez aplikację.

Wyszukiwanie w konkretnej aplikacji

Komendy głosowe Google

• „wyszukaj filmy z kotami w myvideoapp”

Aby umożliwić wyszukiwanie w kontekście aplikacji, zadeklaruj w niej filtr intencji z działaniem SEARCH_ACTION, jak w tym przykładzie filtra intencji.

Uwaga: nie zalecamy używania adresu SEARCH_ACTION do wyszukiwania aplikacji. Zamiast tego zastosuj działanieGET_THING, aby skorzystać z wbudowanego w Asystencie Google mechanizmu wyszukiwania w aplikacji. Więcej informacji znajdziesz w dokumentacji Działania aplikacji dotyczącej Asystenta Google.

Działanie

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

Obsługa zapytań wyszukiwania z usług komend głosowych Google.

Dodatki

QUERY

Ciąg tekstowy zawierający zapytanie.

Przykładowy filtr intencji:

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

Przeprowadzanie wyszukiwania w internecie

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

Działanie

ACTION_WEB_SEARCH

Schemat identyfikatora URI danych

Brak

Typ MIME

Brak

Dodatki

SearchManager.QUERY

Ciąg wyszukiwania.

Przykład intencji:

Kotlin

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

Java

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

Ustawienia

Aby otworzyć ekran w aplikacji Ustawienia systemu, gdy aplikacja wymaga od użytkownika wprowadzenia zmian, użyj jednej z tych akcji intencyjnych:

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 URI danych

Brak

Typ MIME

Brak

Przykład intencji:

Kotlin

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

Java

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

Wysyłanie SMS-ów

Tworzenie SMS-ów lub MMS-ów z załącznikiem jest częstym działaniem w przypadku aplikacji do obsługi wiadomości tekstowych. Utwórz filtr intencji, aby reklamować możliwość wykonania tego działania przez aplikację. Aby to zrobić, skorzystaj z informacji w następnej sekcji.

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

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

Działanie

ACTION_SENDTO,
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 taki sam sposób.

Typ MIME

"text/plain"

"image/*"

"video/*"

Dodatki

"subject"

Ciąg znaków dla tematu wiadomości (zwykle tylko w przypadku MMS-ów).

"sms_body"

Ciąg znaków dla wiadomości tekstowej.

EXTRA_STREAM

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

Przykład intencji:

Kotlin

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

Java

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

Jeśli chcesz mieć pewność, że intencja jest obsługiwana tylko przez aplikację do obsługi SMS-ów, a nie przez inne aplikacje e-mail czy społecznościowe, użyj działania ACTION_SENDTO i uwzględnij schemat danych "smsto:" w sposób pokazany 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ład filtra 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 opracowujesz aplikację do obsługi SMS-ów i MMS-ów, musisz zaimplementować filtry intencji dla kilku dodatkowych działań, aby była ona dostępna jako domyślna aplikacja do obsługi SMS-ów w wersji Androida 4.4 lub nowszej. Więcej informacji znajdziesz w dokumentacji na stronie Telephony.

Przeglądarka

Ładowanie adresu URL strony internetowej jest typowym działaniem w przypadku aplikacji przeglądarki internetowej. Utwórz filtr intencji, aby reklamować możliwość wykonania tego działania przez aplikację. Aby to zrobić, skorzystaj z informacji w następnej sekcji.

Ładowanie adresu URL

Komendy głosowe Google

• „otwórz example.com”

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

Działanie

ACTION_VIEW

Schemat URI danych

http:<URL>
https:<URL>

Typ MIME

"text/plain"

"text/html"

"application/xhtml+xml"

"application/vnd.wap.xhtml+xml"

Przykład intencji:

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ład filtra 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 aplikacja na Androida zapewnia funkcje podobne do tych, które oferuje Twoja witryna, dodaj filtr intencji dla adresów URL, które wskazują na Twoją witrynę. Jeśli użytkownicy mają zainstalowaną Twoją aplikację, linki w e-mailach lub na innych stronach internetowych odsyłające do Twojej witryny otwierają aplikację na Androida zamiast strony internetowej. Więcej informacji znajdziesz w artykule Obsługa linków aplikacji na Androida.

Od Androida 12 (poziom interfejsu API 31) ogólny zamiar internetowy jest przekształcany w działanie w aplikacji tylko wtedy, gdy aplikacja została zatwierdzona dla konkretnej domeny zawartej w tym zamiarze. Jeśli aplikacja nie jest zatwierdzona w przypadku domeny, intencja internetowa zostanie przekierowana do domyślnej przeglądarki użytkownika.

Weryfikowanie intencji za pomocą Android Debug Bridge

Aby sprawdzić, czy aplikacja odpowiada na obsługiwane intencje, możesz za pomocą narzędzia adb uruchamiać konkretne intencje w ten sposób:

1. Skonfiguruj urządzenie z Androidem na potrzeby tworzenia aplikacji lub użyj urządzenia wirtualnego.
2. Zainstaluj wersję aplikacji, która obsługuje intencje, które chcesz obsługiwać.
3. Wywołaj intent za pomocą adb:

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

   Na przykład:

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

4. Jeśli zdefiniujesz wymagane filtry intencji, obsługuj intencję.

Więcej informacji znajdziesz w artykule o problemach z poleceniami powłoki.