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 używaniu tej intencji do robienia zdjęć, w tym o tworzeniu odpowiedniego obiektu Uri dla lokalizacji wyjściowej, znajdziesz w artykule Robienie zdjęć lub Nagrywanie filmów.

Przykładowy filtr intencji:

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

Podczas obsługi tej intencji aktywność powinna sprawdzać, czy w przychodzącym obiekcie Intent znajduje się dodatkowy obiekt EXTRA_OUTPUT, a następnie zapisywać przechwycony obraz lub film w lokalizacji określonej przez ten dodatkowy obiekt i wywoływać metodę setResult() z obiektem Intent, który zawiera skompresowaną miniaturę w dodatkowym obiekcie 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 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>

Uruchom aplikację 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 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 w aplikacjach do zarządzania kontaktami oraz informacje potrzebne do utworzenia filtra intencji, który będzie reklamować zdolność aplikacji do wykonywania poszczególnych działań.

Wybierz kontakt

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

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

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

Działanie

ACTION_PICK

Schemat 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 tym, jak pobrać dane kontaktowe, gdy masz już identyfikator URI kontaktu, znajdziesz w artykule Pobieranie danych kontaktu.

Gdy pobierasz identyfikator URI kontaktu za pomocą tej intencji, zwykle nie potrzebujesz uprawnienia READ_CONTACTS, aby odczytać podstawowe informacje o tym kontakcie, takie jak wyświetlana nazwa i to, czy kontakt jest oznaczony gwiazdką. Jeśli jednak chcesz odczytać bardziej szczegółowe dane o danym kontakcie, takie jak numer telefonu lub adres e-mail, potrzebujesz uprawnienia READ_CONTACTS.

Wybieranie konkretnych danych kontaktowych

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

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

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

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

Działanie

ACTION_PICK

Schemat URI danych

Brak

Typ MIME

CommonDataKinds.Phone.CONTENT_TYPE

Wybierz z kontaktów z numerem telefonu.

CommonDataKinds.Email.CONTENT_TYPE

Wybierz z kontaktów z adresem e-mail.

CommonDataKinds.StructuredPostal.CONTENT_TYPE

Wybierz kontakt z adresem pocztowym.

Możesz też użyć jednej z wielu innych wartości CONTENT_TYPE w sekcji 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 określ kontakt za pomocą identyfikatora URI content: jako danych intencji.

Istnieją 2 główne sposoby na początkowe pobranie identyfikatora URI kontaktu:

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

Działanie

ACTION_VIEW

Schemat 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 za pomocą identyfikatora URI content: jako danych intencji i uwzględnij wszystkie znane informacje kontaktowe w dodatkach określonych przez stałe w ContactsContract.Intents.Insert.

Istnieją 2 główne sposoby początkowego pobierania identyfikatora URI kontaktu:

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

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 dodatków zdefiniowanych w ContactsContract.Intents.Insert, aby można było wypełnić pola danych kontaktowych.

Przykładowa intencja:

fun editContact(contactUri: Uri, email: String) {
    val intent = Intent(Intent.ACTION_EDIT).apply {
        data = contactUri
        putExtra(ContactsContract.Intents.Insert.EMAIL, email)
    }
    if (intent.resolveActivity(packageManager) != null) {
        startActivity(intent)
    }
}

public void editContact(Uri contactUri, String email) {
    Intent intent = new Intent(Intent.ACTION_EDIT);
    intent.setData(contactUri);
    intent.putExtra(Intents.Insert.EMAIL, email);
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivity(intent);
    }
}

Więcej informacji o edytowaniu kontaktu znajdziesz w artykule Modyfikowanie kontaktów za pomocą intencji.

Wstawianie kontaktu

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

Działanie

ACTION_INSERT

Schemat URI danych

Brak

Typ MIME

Contacts.CONTENT_TYPE

Dodatki

Co najmniej 1 dodatek zdefiniowany 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 kontaktu znajdziesz w artykule Modyfikowanie kontaktów za pomocą intencji.

E-mail

Tworzenie e-maila z opcjonalnymi załącznikami to typowe działanie w aplikacjach do poczty e-mail. Utwórz filtr intencji, aby poinformować o możliwości wykonania tego działania przez aplikację, korzystając z informacji podanych w następnej sekcji.

Utwórz e-maila z opcjonalnymi załącznikami.

Aby utworzyć e-maila, wykonaj jedną z poniższych czynności w zależności od tego, czy chcesz dołączyć załączniki. Dołącz szczegóły e-maila, takie jak odbiorca i temat, używając wymienionych klawiszy dodatkowych.

Działanie

ACTION_SENDTO (brak załącznika) lub
ACTION_SEND (1 załącznik) lub
ACTION_SEND_MULTIPLE (kilka załączników)

Schemat URI danych

Brak

Typ MIME

"text/plain"

"*/*"

Dodatki

Intent.EXTRA_EMAIL

Tablica tekstowa zawierająca wszystkie adresy e-mail odbiorców w polu „Do”.

Intent.EXTRA_CC

Tablica tekstowa zawierająca adresy e-mail wszystkich odbiorców w polu „DW”.

Intent.EXTRA_BCC

Tablica tekstowa zawierająca adresy e-mail wszystkich odbiorców w polu „UDW”.

Intent.EXTRA_SUBJECT

Ciąg tekstowy z tematem e-maila.

Intent.EXTRA_TEXT

Ciąg znaków 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 zostanie obsłużona tylko przez aplikację do poczty e-mail, a nie przez aplikację do SMS-ów lub aplikację społecznościową, użyj działania ACTION_SENDTO i dołącz 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 aplikacji do przechowywania plików, w tym informacje potrzebne do utworzenia filtra intencji, który będzie reklamować zdolność aplikacji do wykonywania poszczególnych działań.

Pobieranie określonego typu pliku

Aby poprosić użytkownika o wybranie pliku, takiego jak dokument lub zdjęcie, i zwrócić odwołanie do aplikacji, użyj działania ACTION_GET_CONTENT i określ odpowiedni typ MIME. Plik referencyjny zwrócony do aplikacji jest tymczasowy w bieżącym cyklu życia aktywności, więc jeśli chcesz uzyskać do niego dostęp później, musisz zaimportować kopię, którą będzie można później odczytać.

Ta intencja umożliwia też użytkownikowi utworzenie nowego pliku w tym procesie. Na przykład zamiast wybierać istniejące zdjęcie, użytkownik może zrobić nowe zdjęcie aparatem.

Intencja wyniku dostarczona do metody onActivityResult() zawiera dane z identyfikatorem URI wskazującym plik. Identyfikator URI może być dowolny, np. http:, file: lub content:. Jeśli jednak chcesz ograniczyć wybór plików tylko do tych, które są dostępne z mechanizmu dostarczania treści (identyfikator URI content:) i jako strumień plików z openFileDescriptor(), dodaj do intencji kategorię CATEGORY_OPENABLE.

Na urządzeniach z Androidem 4.3 (poziom interfejsu API 18) lub nowszym możesz też zezwolić użytkownikowi na wybór wielu plików, dodając do intencji EXTRA_ALLOW_MULTIPLE z ustawieniem true. Następnie możesz uzyskać dostęp do każdego z wybranych plików w obiekcie ClipData zwracanym przez getClipData().

Działanie

ACTION_GET_CONTENT

Schemat URI danych

Brak

Typ MIME

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

Dodatki

EXTRA_ALLOW_MULTIPLE

Wartość logiczna, która określa, 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, a nie wymagać pobrania z usługi zdalnej.

Category (opcjonalny)

CATEGORY_OPENABLE

Aby zwracać tylko pliki, które można otworzyć i które można przedstawić jako strumień plików, użyj openFileDescriptor().

Przykładowa intencja pobrania 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 zwracający zdjęcie:

<activity ...>
    <intent-filter>
        <action android:name="android.intent.action.GET_CONTENT" />
        <data android:type="image/*" />
        <category android:name="android.intent.category.DEFAULT" />
        <!-- The OPENABLE category declares that the returned file is accessible
             from a content provider that supports OpenableColumns
             and ContentResolver.openFileDescriptor(). -->
        <category android:name="android.intent.category.OPENABLE" />
    </intent-filter>
</activity>

Otwieranie określonego typu pliku

Zamiast pobierać kopię pliku, który musisz zaimportować do aplikacji, za pomocą działania ACTION_GET_CONTENT, na Androidzie 4.4 lub nowszym możesz poprosić o otwarcie pliku zarządzanego przez inną aplikację, używając działania ACTION_OPEN_DOCUMENT i określając typ MIME. Aby umożliwić użytkownikowi utworzenie nowego dokumentu, w którym aplikacja może zapisywać dane, użyj 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, która zarządza miejscem na dane dokumentu. Aplikacja otrzyma wtedy lokalizację URI, w której może zapisać nowy dokument.

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

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

Możesz też pozwolić użytkownikowi na wybranie wielu plików, dodając do intencji parametr EXTRA_ALLOW_MULTIPLE ustawiony na true. Jeśli użytkownik wybierze tylko 1 element, możesz go pobrać z getData(). Jeśli użytkownik wybierze więcej niż 1 element, getData() zwraca wartość null i musisz pobrać każdy element z obiektu ClipData zwracanego przez getClipData().

Uwaga: intencja musi określać typ MIME i musi deklarować kategorię CATEGORY_OPENABLE. W razie potrzeby możesz określić więcej niż 1 typ MIME, dodając tablicę typów MIME z dodatkiem EXTRA_MIME_TYPES. W takim przypadku musisz ustawić podstawowy typ MIME w 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 użytkownik musi wybrać.

Dodatki

EXTRA_MIME_TYPES

Tablica typów MIME odpowiadających typom plików, o które prosi aplikacja. Gdy używasz tego dodatku, musisz ustawić podstawowy typ MIME w setType() na "*/*".

EXTRA_ALLOW_MULTIPLE

Wartość logiczna, która określa, czy użytkownik może wybrać więcej niż 1 plik naraz.

EXTRA_TITLE

Do użycia z ACTION_CREATE_DOCUMENT w celu określenia 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, a nie wymagać pobrania z usługi zdalnej.

Kategoria

CATEGORY_OPENABLE

Aby zwracać tylko pliki, które można otworzyć i które można przedstawić jako strumień plików, użyj openFileDescriptor().

Przykładowa intencja pobrania 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ę za pomocą działania ACTION_OPEN_DOCUMENT. Zamiast tego system odbiera tę intencję i wyświetla wszystkie pliki dostępne w różnych aplikacjach w ujednoliconym interfejsie użytkownika.

Aby udostępnić pliki aplikacji w tym interfejsie i umożliwić innym aplikacjom ich otwieranie, musisz zaimplementować DocumentsProvider i uwzględnić filtr intencji dla PROVIDER_INTERFACE ("android.content.action.DOCUMENTS_PROVIDER"), 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 aplikację w innych aplikacjach, znajdziesz w artykule Otwieranie plików za pomocą platformy Storage Access Framework.

Działania lokalne

Zamówienie samochodu to częste działanie lokalne. Utwórz filtr intencji, aby poinformować, że Twoja aplikacja może wykonać to działanie, korzystając z informacji w następnej sekcji.

Zadzwoń po taksówkę

Komendy głosowe Google

• „Zamów mi taksówkę”
• „zamów mi samochód”,

(tylko Wear OS)

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

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

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 typowe działanie w aplikacjach mapowych. Utwórz filtr intencji, aby poinformować o możliwości wykonania tego działania przez aplikację, korzystając z informacji podanych w następnej sekcji.

wyświetlanie lokalizacji na mapie,

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

Działanie

ACTION_VIEW

Schemat URI danych

geo:latitude,longitude

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

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

geo:latitude,longitude?z=zoom

Wyświetlanie mapy z podaną długością i szerokością geograficzną na określonym poziomie powiększenia. Poziom powiększenia 1 pokazuje całą Ziemię wyśrodkowaną na podanych 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świetl mapę z podaną długością i szerokością geograficzną oraz etykietą tekstową.

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

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

Pokaż lokalizację „mój adres”, 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 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 są kodowane jako %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 filmy,

Poniżej znajdziesz typowe działania w aplikacjach muzycznych i wideo oraz informacje potrzebne do utworzenia filtra intencji, który będzie reklamować możliwość wykonywania poszczególnych działań przez aplikację.

Odtwarzanie pliku multimedialnego

Aby odtworzyć plik muzyczny, użyj działania ACTION_VIEW i określ lokalizację identyfikatora 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 inne, których 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 Billie Jean Michaela Jacksona”

Aby odtwarzać muzykę na podstawie wyszukiwanego hasła, użyj intencji INTENT_ACTION_MEDIA_PLAY_FROM_SEARCH. Aplikacja może wywołać tę intencję w odpowiedzi na polecenie głosowe użytkownika, aby odtworzyć muzykę. Aplikacja odbierająca tę intencję wyszukuje w swoich zasobach treści pasujące do danego zapytania i rozpoczyna ich odtwarzanie.

W intencji uwzględnij ciąg znaków EXTRA_MEDIA_FOCUS, który określa zamierzony tryb wyszukiwania. Tryb wyszukiwania może na przykład określać, czy wyszukiwanie dotyczy nazwy wykonawcy czy tytułu utworu.

Działanie

INTENT_ACTION_MEDIA_PLAY_FROM_SEARCH

Schemat URI danych

Brak

Typ MIME

Brak

Dodatki

MediaStore.EXTRA_MEDIA_FOCUS (pole wymagane)

Wskazuje tryb wyszukiwania: czy użytkownik szuka konkretnego wykonawcy, albumu, utworu czy playlisty. Większość trybów wyszukiwania wymaga dodatkowych informacji. Jeśli na przykład użytkownik chce posłuchać konkretnego utworu, intencja może mieć 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/*"

Odtwarzaj dowolną muzykę. Aplikacja odbierająca odtwarza muzykę na podstawie inteligentnego wyboru, np. ostatniej playlisty, której słuchał użytkownik.

Dodatkowe korzyści:

• QUERY (wymagany): pusty ciąg znaków. Ten dodatkowy element jest zawsze udostępniany w celu zapewnienia zgodności wstecznej. Istniejące aplikacje, które nie obsługują trybów wyszukiwania, mogą przetwarzać tę intencję jako wyszukiwanie nieustrukturyzowane.

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

odtwarzać konkretny utwór, album lub gatunek na podstawie nieuporządkowanego zapytania; Aplikacje mogą generować intencję w tym trybie wyszukiwania, gdy nie mogą zidentyfikować typu treści, których użytkownik chce słuchać. Jeśli to możliwe, używaj bardziej szczegółowych trybów wyszukiwania.

Dodatkowe korzyści:

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

Gatunek – Audio.Genres.ENTRY_CONTENT_TYPE

odtwarzać muzykę z konkretnego gatunku;

Dodatkowe korzyści:

• "android.intent.extra.genre" (wymagany) – gatunek.
• QUERY (wymagany): gatunek. Ten dodatkowy element jest zawsze dostępny ze względu na zgodność wsteczną. Istniejące aplikacje, które nie obsługują trybów wyszukiwania, mogą przetwarzać tę intencję jako wyszukiwanie nieustrukturyzowane.

Wykonawca – Audio.Artists.ENTRY_CONTENT_TYPE

odtwarzanie muzyki konkretnego wykonawcy;

Dodatkowe korzyści:

• EXTRA_MEDIA_ARTIST (wymagany): wykonawca.
• "android.intent.extra.genre": gatunek.
• QUERY (wymagany): ciąg znaków zawierający dowolną kombinację wykonawcy lub gatunku. Ten dodatkowy element jest zawsze udostępniany w celu zapewnienia zgodności wstecznej. Istniejące aplikacje, które nie obsługują trybów wyszukiwania, mogą przetwarzać tę intencję jako wyszukiwanie nieuporządkowane.

Album – Audio.Albums.ENTRY_CONTENT_TYPE

odtwarzanie muzyki z konkretnego albumu;

Dodatkowe korzyści:

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

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

odtworzenie konkretnego utworu;

Dodatkowe korzyści:

• EXTRA_MEDIA_ALBUM: album.
• EXTRA_MEDIA_ARTIST: wykonawca.
• "android.intent.extra.genre": gatunek.
• EXTRA_MEDIA_TITLE (wymagany): nazwa utworu.
• QUERY (wymagany): ciąg znaków zawierający dowolną kombinację albumu, wykonawcy, gatunku lub tytułu. Ten dodatkowy element jest zawsze udostępniany w celu zapewnienia zgodności wstecznej. Istniejące aplikacje, które nie obsługują trybów wyszukiwania, mogą przetwarzać tę intencję jako wyszukiwanie nieuporządkowane.

Playlista – Audio.Playlists.ENTRY_CONTENT_TYPE

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

Dodatkowe korzyści:

• 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 opiera się playlista.
• QUERY (wymagany): ciąg znaków zawierający dowolną kombinację albumu, wykonawcy, gatunku, playlisty lub tytułu. Ten dodatkowy element jest zawsze udostępniany w celu zapewnienia zgodności wstecznej. Istniejące aplikacje, które nie obsługują trybów wyszukiwania, mogą przetwarzać tę intencję jako wyszukiwanie nieustrukturyzowane.

Przykładowa intencja:

Jeśli użytkownik chce posłuchać muzyki konkretnego wykonawcy, aplikacja do wyszukiwania może wygenerować taką 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ść dodatku EXTRA_MEDIA_FOCUS w przychodzącym obiekcie Intent, aby określić tryb wyszukiwania. Gdy aktywność zidentyfikuje tryb wyszukiwania, odczytaj wartości dodatkowych parametrów dla tego trybu wyszukiwania. Dzięki tym informacjom aplikacja może przeprowadzić wyszukiwanie w swoich zasobach, aby odtworzyć treści pasujące do zapytania. Zostało to przedstawione w poniższym przykładzie.

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 notatki to typowe działanie w aplikacjach do robienia notatek. Utwórz filtr intencji, aby poinformować o możliwości wykonania tego działania przez aplikację, korzystając z informacji podanych w następnej 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ą tych dodatków.

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

Działanie

ACTION_CREATE_NOTE

Schemat URI danych

Brak

Typ MIME

PLAIN_TEXT_TYPE

"*/*"

Dodatki

EXTRA_NAME

Ciąg tekstowy zawierający tytuł lub temat notatki.

EXTRA_TEXT

Ciąg znaków 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

Inicjowanie połączenia to typowe działanie w aplikacjach na telefon. Utwórz filtr intencji, aby poinformować o możliwości wykonania tego działania przez aplikację, korzystając z informacji podanych 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. Gdy otworzy się aplikacja telefonu, wyświetli się numer telefonu, a użytkownik musi kliknąć przycisk Zadzwoń, aby rozpocząć połączenie.

Komendy głosowe Google

• „Zadzwoń pod numer 555-5555”
• „Zadzwoń do Roberta”
• „Zadzwoń do poczty głosowej”

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

Działanie ACTION_CALL wymaga dodania uprawnienia CALL_PHONE do pliku manifestu:

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

Działanie

• ACTION_DIAL – otwiera aplikację Telefon.
• 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 IETF RFC 3966. Prawidłowe przykłady:

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

Dialer aplikacji Telefon dobrze radzi sobie z normalizacją schematów, takich jak numery telefonów. Dlatego opisany schemat nie jest ściśle wymagany w metodzie Uri.parse(). Jeśli jednak nie masz pewności, czy dany schemat jest obsługiwany, 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 w aplikacjach do wyszukiwania oraz informacje potrzebne do utworzenia filtra intencji, który będzie reklamować zdolność aplikacji do wykonywania poszczególnych działań.

Wyszukiwanie za pomocą konkretnej aplikacji

Komendy głosowe Google

• „Wyszukaj filmiki z kotami w aplikacji myvideoapp”

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

Uwaga: nie zalecamy używania SEARCH_ACTION do wyszukiwania aplikacji. Zamiast tego zaimplementuj działanie GET_THING, aby wykorzystać wbudowaną obsługę wyszukiwania w aplikacji przez Asystenta Google. Więcej informacji znajdziesz w dokumentacji akcji 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>

Wyszukiwanie w internecie

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

Działanie

ACTION_WEB_SEARCH

Schemat URI danych

Brak

Typ MIME

Brak

Dodatki

SearchManager.QUERY

Ciąg wyszukiwania.

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

Działanie

ACTION_SETTINGS
ACTION_WIRELESS_SETTINGS
ACTION_AIRPLANE_MODE_SETTINGS
ACTION_WIFI_SETTINGS
ACTION_APN_SETTINGS
ACTION_BLUETOOTH_SETTINGS
ACTION_DATE_SETTINGS
ACTION_LOCALE_SETTINGS
ACTION_INPUT_METHOD_SETTINGS
ACTION_DISPLAY_SETTINGS
ACTION_SECURITY_SETTINGS
ACTION_LOCATION_SOURCE_SETTINGS
ACTION_INTERNAL_STORAGE_SETTINGS
ACTION_MEMORY_CARD_SETTINGS

Informacje o dodatkowych ekranach ustawień znajdziesz w dokumentacji Settings .

Schemat URI danych

Brak

Typ MIME

Brak

Przykładowa intencja:

Kotlin

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

Java

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

Wysyłanie SMS-ów

Tworzenie SMS-a lub MMS-a z załącznikiem to typowe działanie w aplikacjach do obsługi wiadomości tekstowych. Utwórz filtr intencji, aby poinformować o możliwości wykonania tego działania przez aplikację, korzystając z informacji podanych w następnej sekcji.

Utwórz wiadomość SMS/MMS z załącznikiem

Aby zainicjować tworzenie wiadomości tekstowej SMS lub MMS, użyj jednego z podanych niżej działań intencji 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 lub
ACTION_SEND lub
ACTION_SEND_MULTIPLE

Schemat URI danych

sms:<phone_number>

smsto:<phone_number>

mms:<phone_number>

mmsto:<phone_number>

Wszystkie te schematy są traktowane w ten sam sposób.

Typ MIME

"text/plain"

"image/*"

"video/*"

Dodatki

"subject"

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

"sms_body"

Ciąg znaków dla SMS-a.

EXTRA_STREAM

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

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 będzie obsługiwana tylko przez aplikację do obsługi wiadomości tekstowych, a nie przez inne aplikacje do obsługi poczty e-mail lub aplikacje społecznościowe, użyj działania ACTION_SENDTO i uwzględnij schemat danych "smsto:", jak w tym przykładzie:

Kotlin

fun composeMmsMessage(message: String, attachment: Uri) {
    val intent = Intent(Intent.ACTION_SEND).apply {
        data = Uri.parse("smsto:")  // Only SMS apps respond to this.
        putExtra("sms_body", message)
        putExtra(Intent.EXTRA_STREAM, attachment)
    }
    if (intent.resolveActivity(packageManager) != null) {
        startActivity(intent)
    }
}

Java

public void composeMmsMessage(String message, Uri attachment) {
    Intent intent = new Intent(Intent.ACTION_SEND);
    intent.setData(Uri.parse("smsto:"));  // Only SMS apps respond to this.
    intent.putExtra("sms_body", message);
    intent.putExtra(Intent.EXTRA_STREAM, attachment);
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivity(intent);
    }
}

Przykładowy filtr intencji:

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

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

Przeglądarka

Wczytywanie adresu URL to typowe działanie w przypadku przeglądarek internetowych. Utwórz filtr intencji, aby poinformować o możliwości wykonania tego działania przez aplikację, korzystając z informacji podanych w następnej sekcji.

Wczytaj adres 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 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 zapewnia funkcje podobne do tych w witrynie, dodaj filtr intencji dla adresów URL wskazujących na witrynę. Jeśli użytkownicy mają zainstalowaną Twoją aplikację, linki z e-maili lub innych stron internetowych wskazujące na Twoją witrynę będą otwierać aplikację na Androida zamiast strony internetowej. Więcej informacji znajdziesz w artykule Praca z linkami aplikacji na Androida.

Począwszy od Androida 12 (API na poziomie 31), ogólna intencja internetowa jest rozpoznawana jako aktywność w aplikacji tylko wtedy, gdy aplikacja jest zatwierdzona dla konkretnej domeny zawartej w tej intencji. Jeśli aplikacja nie zostanie zatwierdzona dla domeny, intencja internetowa zostanie przekierowana do przeglądarki domyślnej użytkownika.

Weryfikowanie intencji za pomocą mostka debugowania Androida

Aby sprawdzić, czy aplikacja reaguje na intencje, które chcesz obsługiwać, możesz użyć narzędzia adb, aby wywołać określone intencje. Aby to zrobić:

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 wspierać.
3. Wywołaj intencję za pomocą adb:

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

   Przykład:

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

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

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