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ładowy filtr intencji:

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

Podczas obsługi tej intencji poproś o sprawdzenie aktywności pod kątem dodatkowego elementu EXTRA_OUTPUT w przychodzącym elemencie Intent, a następnie zapisz przechwycony obraz lub film w określonej przez niego lokalizacji i wywołaj funkcję setResult() z użyciem Intent, który zawiera skompresowaną miniaturę w elemencie "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

Poniżej znajdziesz typowe działania wykonywane w aplikacjach do zarządzania kontaktami. Obejmuje to m.in. informacje potrzebne do utworzenia filtra intencji, który będzie reklamować zdolność aplikacji do wykonywania poszczególnych działań.

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 aplikacji tymczasowe uprawnienia do odczytu tego kontaktu za pomocą interfejsu API Contacts Provider, nawet jeśli aplikacja nie zawiera uprawnienia READ_CONTACTS.

Wskazówka: jeśli potrzebujesz dostępu tylko do 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ł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.
        ...
    }
}

Informacje o pobieraniu danych kontaktowych po uzyskaniu identyfikatora URI kontaktu 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.

Wybierz konkretne dane kontaktowe

Aby użytkownik wybrał określoną informację z kontaktu, np. numer telefonu, adres e-mail lub inny typ danych, użyj działania ACTION_PICK i określ typ MIME dla jednego z następujących typów treści, np. 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 konkretnej osobie.

Jeśli chcesz pobrać z kontaktu tylko jeden typ danych, ta metoda z użyciem CONTENT_TYPE z klas ContactsContract.CommonDataKinds jest skuteczniejsza niż Contacts.CONTENT_TYPE (jak pokazano w poprzedniej sekcji). Daje on bezpośredni dostęp do odpowiednich danych bez konieczności wykonywania bardziej złożonego zapytania do dostawcy kontaktów.

Wynik Intent dostarczony do wywołania zwrotnego onActivityResult() zawiera identyfikator URI content: wskazujący wybrane dane kontaktu. 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 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 w kolumnie 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 działania ACTION_VIEW i jako dane intencji podaj 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. Ta metoda wymaga uprawnienia READ_CONTACTS.

Działanie

ACTION_VIEW

Schemat identyfikatora URI danych

content:<URI>

Typ MIME

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

Przykł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 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ą 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. Ta metoda wymaga uprawnienia READ_CONTACTS.

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

Wstaw kontakt

Aby wstawić nowy kontakt, użyj działania ACTION_INSERT, określ Contacts.CONTENT_TYPE jako typ MIME i dołącz wszystkie znane informacje kontaktowe w elementach dodatkowych określonych w parametrach 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 o wstawianiu kontaktów znajdziesz w artykule Modyfikowanie kontaktów za pomocą intencji.

E-mail

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ę, korzystając z informacji podanych w poniższej 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 dodaj informacje o e-mailu (takie jak odbiorca i temat) przy użyciu dodatkowych kluczy.

Działanie

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

Schemat identyfikatora URI danych

Brak

Typ MIME

"text/plain"

"*/*"

Dodatki

Intent.EXTRA_EMAIL

Tablica z ciągami znaków zawierająca wszystkie adresy e-mail odbiorców w polu „Do”.

Intent.EXTRA_CC

Tablica z ciągami znaków wszystkich adresów e-mail odbiorców w polu „DW”.

Intent.EXTRA_BCC

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

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 działania ACTION_SEND_MULTIPLE, jest to ArrayList zawierający 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 jest obsługiwana tylko przez aplikację do poczty e-mail, a nie przez aplikację do obsługi SMS-ów lub mediów społecznościowych, użyj działania ACTION_SENDTO i uwzględnij schemat danych "mailto:" w sposób pokazany 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 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 odpowiedni typ MIME. Odwołanie do pliku zwrócone do aplikacji jest przejściowe w bieżącym cyklu życia aktywności, więc jeśli chcesz uzyskać do niego dostęp później, musisz zaimportować jego kopię, którą możesz przeczytać później.

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.

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ć wybór plików tylko do tych, które są dostępne od dostawcy treści (identyfikator URI content:) i są dostępne jako strumień plików w usłudze openFileDescriptor(), dodaj do intencji użytkownika kategorię CATEGORY_OPENABLE.

Na Androidzie 4.3 (poziom interfejsu API 18) i nowszych możesz też zezwolić użytkownikowi na wybieranie wielu plików, dodając do intencji użytkownika EXTRA_ALLOW_MULTIPLE z ustawieniem true. Możesz wtedy uzyskać dostęp do poszczególnych wybranych plików w obiekcie ClipData zwró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, która określa, czy zwrócony plik musi być dostępny bezpośrednio z urządzenia, bez konieczności pobierania z usługi zdalnej.

Kategoria (opcjonalnie)

CATEGORY_OPENABLE

Aby zwrócić tylko pliki „otwierane”, które można przedstawić jako strumień plików za pomocą funkcji 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, przy użyciu działania ACTION_GET_CONTENT możesz użyć działania ACTION_GET_CONTENT. W Androidzie 4.4 lub nowszym możesz zamiast tego poprosić o otwarcie pliku zarządzanego przez inną aplikację. Aby to zrobić, użyj działania ACTION_OPEN_DOCUMENT i określ 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 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.

Intencja dostarczona do metody onActivityResult() z działania ACTION_GET_CONTENT może zwrócić identyfikator URI dowolnego typu, ale intencja wynikowa z usług ACTION_OPEN_DOCUMENT i ACTION_CREATE_DOCUMENT zawsze określa wybrany plik jako identyfikator URI content: oparty na DocumentsProvider. Możesz otworzyć plik w usłudze openFileDescriptor() i zapytać o jego szczegóły za pomocą kolumn z usługi DocumentsContract.Document.

Zwrócony identyfikator URI zapewnia aplikacji długoterminowe uprawnienia do odczytu pliku, w tym także z uprawnieniami do zapisu. Czynność ACTION_OPEN_DOCUMENT jest szczególnie przydatna, gdy chcesz odczytać istniejący plik bez tworzenia kopii w aplikacji lub gdy chcesz otworzyć i edytować plik.

Możesz też pozwolić użytkownikowi wybrać wiele plików, dodając do intencji użytkownika parametr EXTRA_ALLOW_MULTIPLE ustawiony na 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 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 zadeklarować kategorię CATEGORY_OPENABLE. W razie potrzeby możesz określić więcej niż jeden typ MIME, dodając tablicę typów MIME z dodatkowym EXTRA_MIME_TYPES. W takim przypadku ustaw główny typ MIME w setType() na "*/*".

Działanie

ACTION_OPEN_DOCUMENT lub
ACTION_CREATE_DOCUMENT

Schemat identyfikatora URI danych

Brak

Typ MIME

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

Dodatki

EXTRA_MIME_TYPES

Tablica typów MIME odpowiadających typom plików, o które prosi Twoja aplikacja. Jeśli chcesz użyć tego dodatkowego, 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żytku z ACTION_CREATE_DOCUMENT do określania początkowej nazwy pliku.

EXTRA_LOCAL_ONLY

Wartość logiczna, która określa, czy zwrócony plik musi być dostępny bezpośrednio z urządzenia, bez konieczności pobierania z usługi zdalnej.

Kategoria

CATEGORY_OPENABLE

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

Aby wyświetlić pliki aplikacji w tym interfejsie i zezwolić innym aplikacjom na ich otwieranie, musisz zaimplementować DocumentsProvider i dodać 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>

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

Działania lokalne

Dzwonienie pod samochód jest typową czynnością lokalną. Korzystając z informacji podanych w następnej sekcji, utwórz filtr intencji, aby reklamować możliwość wykonania tego działania przez aplikację.

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 działania ACTION_RESERVE_TAXI_RESERVATION.

Uwaga: przed wykonaniem tego działania aplikacje muszą prosić użytkownika o potwierdzenie.

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ę, korzystając z informacji podanych w poniższej 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 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. Poziom powiększenia 1 pokazuje całą Ziemię wyśrodkowaną na określonej długości,długości. Najwyższy (najbliższy) poziom powiększenia to 23.

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

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

Wyś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”. Może to być konkretny adres lub zapytanie o lokalizację.

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

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

Typ MIME

Brak

Przykł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 potrzebne do utworzenia filtra intencji, który będzie reklamować zdolność aplikacji do wykonywania poszczególnych działań.

Odtwarzanie pliku multimedialnego

Aby odtworzyć plik muzyczny, użyj działania ACTION_VIEW i podaj 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 odtwarzać muzykę na podstawie zapytania, 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 odbierająca w przypadku tej intencji wyszukuje w swoich zasobach reklamowych, aby dopasować istniejące treści do danego zapytania, i zaczyna je odtwarzać.

W tej intencji uwzględnij ciąg tekstowy EXTRA_MEDIA_FOCUS, który określa zamierzony tryb wyszukiwania. W trybie wyszukiwania możesz na przykład określić, 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: określa, czy użytkownik szuka konkretnego wykonawcy, albumu, utworu lub playlisty. Większość trybów wyszukiwania wymaga dodatkowych dodatków. Jeśli np. użytkownik chce posłuchać konkretnego utworu, zamiary mogą zawierać 3 dodatkowe informacje: tytuł utworu, wykonawcę i album. Ta intencja obsługuje te tryby wyszukiwania w przypadku każdej wartości EXTRA_MEDIA_FOCUS:

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

Pozwól na dowolną muzykę. Aplikacja odbierająca odtwarza muzykę w zależności od przemyślanego wyboru, np. ostatniej playlisty, której słuchał użytkownik.

Dodatkowe dodatki:

• QUERY (wymagany): pusty ciąg znaków. Ten dodatek jest zawsze udostępniany w celu zapewnienia zgodności wstecznej. Istniejące aplikacje, które nie znają trybów wyszukiwania, mogą przetworzyć 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. 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 dodatki:

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

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

Odtwórz konkretną playlistę lub playlistę spełniającą kryteria określone przez 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: tytuł utworu, na którego podstawie opiera się playlista.
• QUERY (wymagany): ciąg znaków zawierający dowolną kombinację albumu, wykonawcy, gatunku, playlisty lub tytułu. Ten dodatek jest zawsze udostępniany w celu zapewnienia zgodności wstecznej. Istniejące aplikacje, które nie znają trybów wyszukiwania, mogą przetworzyć tę intencję jako nieuporządkowane wyszukiwanie.

Przykładowa intencja:

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

Podczas obsługi tej intencji w aktywności sprawdź wartość dodatkowego EXTRA_MEDIA_FOCUS w wiadomości przychodzących 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

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ę, korzystając z informacji podanych w poniższej 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, używając poniższych dodatków.

Uwaga: przed wykonaniem tego działania aplikacje muszą prosić użytkownika o potwierdzenie.

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ę, korzystając z informacji podanych w poniższej sekcji.

Zainicjowanie połączenia głosowego

Aby otworzyć aplikację Telefon i wybrać numer telefonu, użyj działania ACTION_DIAL i podaj numer telefonu, korzystając z poniższego schematu URI. Po otwarciu aplikacji Telefon wyświetla się numer telefonu. Użytkownik musi kliknąć przycisk Zadzwoń, aby nawiązać połączenie.

Komendy głosowe Google

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

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

Czynność ACTION_CALL wymaga dodania 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 uprawnienia 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 nadaje się do normalizacji schematów, np. numerów telefonów. Opisany schemat nie jest więc ściśle wymagany w metodzie Uri.parse(). Jeśli jednak nie wypróbowałeś(-aś) jeszcze schematu lub nie masz pewności, czy da się go obsługiwać, użyj metody 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

Poniżej znajdziesz typowe działania wykonywane w aplikacjach do wyszukiwania, w tym informacje potrzebne do utworzenia filtra intencji reklamującego możliwość wykonywania 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ą działania SEARCH_ACTION, jak pokazano w tym przykładzie filtra intencji.

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

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 dodatkowym polu 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, który wymaga od użytkownika wprowadzenia zmian, wykonaj jedną z tych działań:

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

Obsługa 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ę, korzystając z informacji podanych w poniższej sekcji.

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

Aby zainicjować SMS-a lub MMS-a, wykonaj jedno z poniższych działań intencji i za pomocą poniższych dodatkowych klawiszy określ szczegóły wiadomości, takie jak numer telefonu, temat i treść wiadomości.

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 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 wskazujący obraz lub film, który chcesz załączyć. Jeśli używasz działania ACTION_SEND_MULTIPLE, ten dodatek zawiera ArrayList z Uri obiektów wskazujących 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 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ładowy filtr intencji:

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

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

Przeglądarki

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ę, korzystając z informacji podanych w poniższej sekcji.

Wczytywanie internetowego adresu URL

Komendy głosowe Google

• „otwórz example.com”

Aby otworzyć stronę internetową, użyj działania ACTION_VIEW i podaj 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 ma funkcje podobne do Twojej witryny, dodaj filtr intencji dla adresów URL prowadzących do Twojej witryny. Następnie, jeśli użytkownicy zainstalowali Twoją aplikację, linki z e-maili lub innych stron internetowych prowadzące do Twojej witryny otwierają aplikację na Androida, a nie stronę internetową. Więcej informacji znajdziesz w artykule Obsługa linków aplikacji na Androida.

Od Androida 12 (poziom interfejsu API 31) ogólna intencja internetowa przestaje być widoczna w działaniu w aplikacji tylko wtedy, gdy zostanie ona zatwierdzona dla określonej domeny zawartej w tej intencji. Jeśli Twoja aplikacja nie zostanie zatwierdzona w domenie, intencja internetowa będzie otwierała się w domyślnej przeglądarce użytkownika.

Weryfikowanie intencji za pomocą narzędzia 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 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 znajdziesz w artykule o problemach z poleceniami powłoki.