Realizowanie typowych przypadków użycia przy ograniczonej widoczności przesyłek.

W tym dokumencie opisujemy kilka typowych przypadków użycia, w których aplikacja wchodzi w interakcję z innymi aplikacjami. W każdej sekcji znajdziesz wskazówki, jak zapewnić działanie aplikacji przy ograniczonej widoczności pakietów. Musisz je wziąć pod uwagę, jeśli aplikacja jest kierowana na Androida 11 (poziom API 30) lub nowszego.

Gdy aplikacja kierowana na Androida 11 lub nowszego używa intencji rozpoczęcia działania w innej aplikacji, najprostszym sposobem jest wywołanie intencji i obsługa wyjątku ActivityNotFoundException w sytuacji, gdy żadna aplikacja nie jest dostępna.

Jeśli część Twojej aplikacji zależy od tego, czy wywołanie startActivity() może się powieść (np. wyświetlenie interfejsu), dodaj element do elementu <queries> w pliku manifestu aplikacji. Zwykle jest to element <intent>.

Otwórz adresy URL

W tej sekcji opisujemy różne sposoby otwierania adresów URL w aplikacjach kierowanych na Androida 11 lub nowszego.

Otwieraj adresy URL w przeglądarce lub innej aplikacji

Aby otworzyć adres URL, użyj intencji zawierającej działanie intencji ACTION_VIEW zgodnie z opisem w przewodniku pobierania adresu URL. Po wywołaniu funkcji startActivity() za pomocą tej intencji zachodzi jedna z tych sytuacji:

• Adres URL otwiera się w przeglądarce.
• Adres URL otwiera się w aplikacji, która może używać go jako precyzyjnego linku.
• Pojawi się okno ujednoznacznienia, które pozwala użytkownikowi wybrać aplikację, która ma otworzyć adres URL.

• Błąd ActivityNotFoundException występuje, ponieważ na urządzeniu nie ma zainstalowanej aplikacji, która może otworzyć adres URL. (Jest to nietypowe).

  Zalecamy, aby aplikacja przechwytywała i obsługowała parametr ActivityNotFoundException, jeśli wystąpi.

Ponieważ metoda startActivity() nie wymaga widoczności pakietu, aby rozpocząć działanie innej aplikacji, nie musisz dodawać elementu <queries> do pliku manifestu aplikacji ani wprowadzać żadnych zmian w istniejącym elemencie <queries>. Dotyczy to zarówno niejawnych, jak i jawnych intencji, które otwierają adres URL.

Sprawdzanie, czy przeglądarka jest dostępna

W niektórych przypadkach przed próbą otwarcia adresu URL aplikacja może chcieć sprawdzić, czy na urządzeniu jest dostępna co najmniej jedna przeglądarka lub czy określona przeglądarka jest przeglądarką domyślną. W takich przypadkach w elemencie <queries> w pliku manifestu umieść ten element <intent>:

<!-- Place inside the <queries> element. -->
<intent>
  <action android:name="android.intent.action.VIEW" />
  <category android:name="android.intent.category.BROWSABLE" />
  <data android:scheme="https" />
</intent>

Gdy wywołujesz funkcję queryIntentActivities() i jako argument przekazujesz intencję internetową, zwrócona lista zawiera w niektórych przypadkach dostępne aplikacje przeglądarki. Lista nie obejmuje przeglądarek, jeśli użytkownik domyślnie skonfigurował adres URL w aplikacji innej niż przeglądarka.

Otwieraj adresy URL na kartach niestandardowych

Karty niestandardowe pozwalają aplikacji dostosować wygląd i działanie przeglądarki. Możesz otworzyć adres URL na karcie niestandardowej bez konieczności dodawania ani zmieniania elementu <queries> w manifeście aplikacji.

Możesz jednak sprawdzić, czy urządzenie ma przeglądarkę, która obsługuje karty niestandardowe, lub wybrać konkretną przeglądarkę, której chcesz używać z kartami niestandardowymi przy użyciu CustomTabsClient.getPackageName(). W takich przypadkach w elemencie <queries> w pliku manifestu umieść ten element <intent>:

<!-- Place inside the <queries> element. -->
<intent>
  <action android:name="android.support.customtabs.action.CustomTabsService" />
</intent>

Zezwalaj aplikacjom innym niż przeglądarki na obsługę adresów URL

Nawet jeśli aplikacja może otwierać adresy URL za pomocą kart niestandardowych, zalecamy, aby w miarę możliwości zezwolić na otwieranie adresów URL aplikacji innych niż przeglądarka. Aby udostępnić tę funkcję w swojej aplikacji, spróbuj wywołać funkcję startActivity() za pomocą intencji ustawiającej flagę intencji FLAG_ACTIVITY_REQUIRE_NON_BROWSER. Jeśli system zgłosi ActivityNotFoundException, aplikacja może otworzyć adres URL na karcie niestandardowej.

Jeśli intencja zawiera tę flagę, wywołanie startActivity() powoduje wywołanie ActivityNotFoundException, gdy zaistnieje jeden z tych warunków:

• Połączenie spowodowałoby bezpośrednie uruchomienie aplikacji przeglądarki.
• W wyniku tego wywołania użytkownik zobaczy okno ujednoznacznienia, w którym jedyne opcje to przeglądarki.

Ten fragment kodu pokazuje, jak zaktualizować logikę, aby używać flagi intencji FLAG_ACTIVITY_REQUIRE_NON_BROWSER:

try {
    val intent = Intent(ACTION_VIEW, Uri.parse(url)).apply {
        // The URL should either launch directly in a non-browser app (if it's
        // the default) or in the disambiguation dialog.
        addCategory(CATEGORY_BROWSABLE)
        flags = FLAG_ACTIVITY_NEW_TASK or FLAG_ACTIVITY_REQUIRE_NON_BROWSER
    }
    startActivity(intent)
} catch (e: ActivityNotFoundException) {
    // Only browser apps are available, or a browser is the default.
    // So you can open the URL directly in your app, for example in a
    // Custom Tab.
    openInCustomTabs(url)
}

try {
    Intent intent = new Intent(ACTION_VIEW, Uri.parse(url));
    // The URL should either launch directly in a non-browser app (if it's the
    // default) or in the disambiguation dialog.
    intent.addCategory(CATEGORY_BROWSABLE);
    intent.setFlags(FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_REQUIRE_NON_BROWSER);
    startActivity(intent);
} catch (ActivityNotFoundException e) {
    // Only browser apps are available, or a browser is the default.
    // So you can open the URL directly in your app, for example in a
    // Custom Tab.
    openInCustomTabs(url);
}

Unikaj okna ujednoznacznienia

Jeśli chcesz uniknąć wyświetlania okna ujednoznacznienia, które użytkownicy mogą zobaczyć po otwarciu adresu URL, i wolisz robić to samodzielnie, możesz użyć intencji ustawiającej flagę intencji FLAG_ACTIVITY_REQUIRE_DEFAULT.

Jeśli intencja zawiera tę flagę, wywołanie startActivity() powoduje wywołanie ActivityNotFoundException, gdy wywołanie wyświetli użytkownikowi okno wyboru.

Jeśli intencja zawiera zarówno tę flagę, jak i flagę intencji FLAG_ACTIVITY_REQUIRE_NON_BROWSER, wywołanie startActivity() powoduje zgłoszenie zdarzenia ActivityNotFoundException, gdy zaistnieje jeden z tych warunków:

• Połączenie spowodowałoby bezpośrednie uruchomienie aplikacji przeglądarki.
• W wyniku połączenia wyświetli się okno umożliwiające wybór użytkownika.

Ten fragment kodu pokazuje, jak używać jednocześnie flag FLAG_ACTIVITY_REQUIRE_NON_BROWSER i FLAG_ACTIVITY_REQUIRE_DEFAULT:

val url = URL_TO_LOAD
try {
    // For this intent to be invoked, the system must directly launch a
    // non-browser app.
    val intent = Intent(ACTION_VIEW, Uri.parse(url)).apply {
        addCategory(CATEGORY_BROWSABLE)
        flags = FLAG_ACTIVITY_NEW_TASK or FLAG_ACTIVITY_REQUIRE_NON_BROWSER or
                FLAG_ACTIVITY_REQUIRE_DEFAULT
    }
    startActivity(intent)
} catch (e: ActivityNotFoundException) {
    // This code executes in one of the following cases:
    // 1. Only browser apps can handle the intent.
    // 2. The user has set a browser app as the default app.
    // 3. The user hasn't set any app as the default for handling this URL.
    openInCustomTabs(url)
}

String url = URL_TO_LOAD;
try {
    // For this intent to be invoked, the system must directly launch a
    // non-browser app.
    Intent intent = new Intent(ACTION_VIEW, Uri.parse(url));
    intent.addCategory(CATEGORY_BROWSABLE);
    intent.setFlags(FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_REQUIRE_NON_BROWSER |
            FLAG_ACTIVITY_REQUIRE_DEFAULT);
    startActivity(intent);
} catch (ActivityNotFoundException e) {
    // This code executes in one of the following cases:
    // 1. Only browser apps can handle the intent.
    // 2. The user has set a browser app as the default app.
    // 3. The user hasn't set any app as the default for handling this URL.
    openInCustomTabs(url);
}

Otwórz plik

Jeśli aplikacja obsługuje pliki lub załączniki, na przykład sprawdza, czy urządzenie może otworzyć dany plik, zwykle najlepiej jest spróbować uruchomić działanie obsługujące ten plik. Aby to zrobić, użyj intencji zawierającej działanie intencji ACTION_VIEW i identyfikator URI reprezentujący określony plik. Jeśli na urządzeniu nie ma aplikacji, aplikacja może przechwycić plik ActivityNotFoundException. W swojej logice obsługi wyjątków możesz wyświetlić błąd lub spróbować samodzielnie przetworzyć plik.

Jeśli Twoja aplikacja musi z wyprzedzeniem wiedzieć, czy inna aplikacja może otworzyć dany plik, w elemencie <queries> w pliku manifestu umieść element <intent> w poniższym fragmencie kodu. Dodaj typ pliku, jeśli wiesz już, co to jest, przy kompilowaniu.

<!-- Place inside the <queries> element. -->
<intent>
  <action android:name="android.intent.action.VIEW" />
  <!-- If you don't know the MIME type in advance, set "mimeType" to "*/*". -->
  <data android:mimeType="application/pdf" />
</intent>

Następnie możesz sprawdzić, czy aplikacja jest dostępna, wywołając resolveActivity() z intencją.

Przyznaj dostęp do identyfikatora URI

W przypadku aplikacji kierowanych na Androida 11 lub nowszego w celu dostępu do identyfikatora URI treści intencja aplikacji musi zadeklarować uprawnienia dostępu z identyfikatorem URI przez ustawienie co najmniej 1 z tych flag intencji: FLAG_GRANT_READ_URI_PERMISSION i FLAG_GRANT_WRITE_URI_PERMISSION.

W Androidzie 11 i nowszych uprawnienia dostępu do identyfikatora URI dają aplikacji odbierającej intencję następujące możliwości:

• W zależności od określonych uprawnień identyfikatora URI może odczytywać lub zapisywać dane reprezentowane przez identyfikator URI treści.
• Uzyskaj wgląd w aplikację zawierającą dostawcę treści pasującego do identyfikatora URI. Aplikacja zawierająca dostawcę treści może się różnić od aplikacji wysyłającej intencję.

Ten fragment kodu pokazuje, jak dodać flagę intencji uprawnień do identyfikatora URI, aby inna aplikacja kierowana na Androida 11 lub nowszego mogła wyświetlać dane w identyfikatorze URI treści:

val shareIntent = Intent(Intent.ACTION_VIEW).apply {
    flags = Intent.FLAG_GRANT_READ_URI_PERMISSION
    data = CONTENT_URI_TO_SHARE_WITH_OTHER_APP
}

Intent shareIntent = new Intent(Intent.ACTION_VIEW);
shareIntent.setFlags(FLAG_GRANT_READ_URI_PERMISSION);
shareIntent.setData(CONTENT_URI_TO_SHARE_WITH_OTHER_APP);

Połącz z usługami

Jeśli aplikacja musi wejść w interakcję z usługą, która nie jest widoczna automatycznie, możesz zadeklarować odpowiednie działanie intencji w elemencie <queries>. W sekcjach poniżej znajdziesz przykłady korzystania z często używanych usług.

Połącz z mechanizmem zamiany tekstu na mowę

Jeśli Twoja aplikacja współpracuje z mechanizmem zamiany tekstu na mowę, w elemencie <queries> w pliku manifestu umieść ten element <intent>:

<!-- Place inside the <queries> element. -->
<intent>
  <action android:name="android.intent.action.TTS_SERVICE" />
</intent>

Połącz się z usługą rozpoznawania mowy

Jeśli Twoja aplikacja współpracuje z usługą rozpoznawania mowy, w elemencie <queries> w pliku manifestu umieść ten element <intent>:

<!-- Place inside the <queries> element. -->
<intent>
  <action android:name="android.speech.RecognitionService" />
</intent>

Połącz z usługami przeglądarki multimediów

Jeśli Twoja aplikacja jest przeglądarką kliencką przeglądarki multimediów, w pliku manifestu umieść ten element <intent>:<queries>

<!-- Place inside the <queries> element. -->
<intent>
  <action android:name="android.media.browse.MediaBrowserService" />
</intent>

Dodaj niestandardowe funkcje

Jeśli aplikacja musi wykonywać działania niestandardowe lub wyświetlać dostosowywane informacje na podstawie interakcji z innymi aplikacjami, możesz przedstawić to działanie niestandardowe, używając sygnałów filtra intencji jako części elementu <queries> w pliku manifestu. W sekcjach poniżej znajdziesz szczegółowe wskazówki dotyczące kilku typowych scenariuszy.

Zapytanie dotyczące aplikacji do SMS-ów

Jeśli Twoja aplikacja potrzebuje informacji o zestawie aplikacji do obsługi SMS-ów zainstalowanych na urządzeniu, np. aby sprawdzić, która jest domyślną aplikacją do obsługi SMS-ów na urządzeniu, w elemencie <queries> w pliku manifestu umieść ten element <intent>:

<!-- Place inside the <queries> element. -->
<intent>
  <action android:name="android.intent.action.SENDTO"/>
  <data android:scheme="smsto" android:host="*" />
</intent>

Tworzenie niestandardowego arkusza udostępniania

W miarę możliwości korzystaj z arkusza udostępniania udostępnionego przez system. Możesz też uwzględnić ten element <intent> w elemencie <queries> w pliku manifestu:

<!-- Place inside the <queries> element. -->
<intent>
  <action android:name="android.intent.action.SEND" />
  <!-- Replace with the MIME type that your app works with, if needed. -->
  <data android:mimeType="image/jpeg" />
</intent>

Proces tworzenia arkusza udostępniania w logice aplikacji, np. wywołanie queryIntentActivities(), pozostaje bez zmian w porównaniu z wersjami Androida starszym niż Android 11.

Pokaż niestandardowe działania dotyczące zaznaczania tekstu

Gdy użytkownicy zaznaczają tekst w aplikacji, na pasku narzędzi wyboru tekstu wyświetla się zestaw operacji, które można wykonać na zaznaczonym tekście. Jeśli na pasku narzędzi widać działania niestandardowe z innych aplikacji, w elemencie <queries> w pliku manifestu umieść ten element <intent>:

<!-- Place inside the <queries> element. -->
<intent>
  <action android:name="android.intent.action.PROCESS_TEXT" />
  <data android:mimeType="text/plain" />
</intent>

Pokazywanie niestandardowych wierszy danych kontaktu

Aplikacje mogą dodawać niestandardowe wiersze danych do dostawcy kontaktów. Aby aplikacja do obsługi kontaktów wyświetlała te dane niestandardowe, musi mieć możliwość:

1. Przeczytaj plik contacts.xml z innych aplikacji.
2. Wczytaj ikonę odpowiadającą niestandardowemu typowi MIME.

Jeśli Twoja aplikacja to aplikacja do obsługi kontaktów, w pliku manifestu umieść te elementy <intent> w elemencie <queries>:

<!-- Place inside the <queries> element. -->
<!-- Lets the app read the contacts.xml file from other apps. -->
<intent>
  <action android:name="android.accounts.AccountAuthenticator" />
</intent>
<!-- Lets the app load an icon corresponding to the custom MIME type. -->
<intent>
  <action android:name="android.intent.action.VIEW" />
  <data android:scheme="content" android:host="com.android.contacts"
        android:mimeType="vnd.android.cursor.item/*" />
</intent>