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

W tym dokumencie opisujemy kilka typowych przypadków użycia aplikacji, z innymi aplikacjami. W każdej sekcji znajdują się wskazówki na temat tego, jak osiągnąć funkcji z ograniczoną widocznością pakietów, co należy wziąć pod uwagę, aplikacja jest kierowana na Androida 11 (poziom interfejsu API 30) lub nowszego.

Gdy aplikacja kierowana na Androida 11 lub nowszego używa zamiaru rozpocznie się aktywność w innej aplikacji, najprostszym sposobem jest wywołanie intencję i obsługują ActivityNotFoundException w sytuacji, gdy żadna aplikacja nie jest dostępna.

Czy jej część zależy od informacji, czy wywołanie startActivity() mogą odnieść sukces, np. wyświetlając UI, dodać element do <queries> elementu aplikacji pliku manifestu. Zwykle jest to element <intent>.

Otwórz adresy URL

W tej sekcji opisujemy różne sposoby otwierania adresów URL w aplikacjach, które są kierowane Androida 11 lub nowszego,

Otwieraj adresy URL w przeglądarce lub innej aplikacji

Aby otworzyć adres URL, użyj intencji zawierającej ACTION_VIEW. opisane w przewodniku pobierania Adres URL. Po nawiązaniu połączenia z numerem startActivity() używając tej intencji, zachodzi jedna z tych sytuacji:

• Adres URL otworzy się w aplikacji przeglądarki.
• Adres URL otwiera się w aplikacji, która obsługuje precyzyjny adres URL .
• Wyświetli się okno z prośbą o rozstrzygnięcie, w której użytkownik może wybrać aplikację, która otworzy adres URL.

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

  Zalecamy, aby aplikacja przechwytywała i obsługiwała błąd ActivityNotFoundException, jeśli wystąpi.

Metoda startActivity() nie wymaga widoczności pakietów, aby rozpocząć aktywność w innej aplikacji, nie musisz dodawać <queries> element w pliku manifestu aplikacji lub wprowadź zmiany w dotychczasowym 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 aplikacja może sprawdzać, czy istnieje co najmniej jedna przeglądarka. dostępna na urządzeniu lub określona przeglądarka jest ustawiona jako domyślna; przed próbą otwarcia adresu URL. W takich przypadkach musisz dodać: Element <intent> w elemencie <queries> w pliku manifestu:

<!-- 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 przekazujesz intencję internetową jako argument, zwrócona lista zawiera w niektórych przypadkach dostępne aplikacje przeglądarki. Lista nie uwzględnia aplikacji przeglądarek, jeśli użytkownik skonfigurował adres URL w taki sposób, aby otwierał się w nie jest domyślną aplikacją.

Otwieranie adresów URL na kartach niestandardowych

Niestandardowe karty umożliwiają aplikacji dostosowywanie wyglądu i działania przeglądarki. Możesz otworzyć adres URL w karta niestandardowa bez konieczności dodawania ani zmieniania elementu <queries> w manifeście aplikacji.

Warto jednak sprawdzić, czy urządzenie ma przeglądarkę, która obsługuje Karty niestandardowe lub wybierz konkretną przeglądarkę, którą chcesz uruchomić za pomocą kart niestandardowych CustomTabsClient.getPackageName(). W takich przypadkach dodaj element <intent> w ramach elementu <queries> w pliku manifestu:

<!-- 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 jeśli to możliwe, zezwól aplikacji innej niż przeglądarka na otwarcie adresu URL. Aby udostępnić tę funkcję w aplikacji, spróbuj wywołać startActivity() za pomocą intencji, która ustawia flagę intencji FLAG_ACTIVITY_REQUIRE_NON_BROWSER. Jeśli system zgłosi ActivityNotFoundException, aplikacja może a potem otwórz ten URL na karcie niestandardowej.

Jeśli intencja zawiera ten flag, wywołanie funkcji startActivity() powoduje wywołanie funkcji ActivityNotFoundException, gdy spełniony jest jeden z tych warunków:

• Połączenie spowodowałoby bezpośrednie uruchomienie aplikacji przeglądarki.
• W wyniku połączenia wyświetli się okno dialogowe, w którym opcje to przeglądarki.

Fragment kodu poniżej pokazuje, jak zaktualizować funkcje logiczne, aby korzystały z Flaga 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);
}

Unikanie okna z prośbą o rozstrzygnięcie wątpliwości

Jeśli chcesz uniknąć wyświetlania okna ujednoznacznienia, które użytkownicy mogą zobaczyć, otwiera adres URL i wolą robić to samodzielnie w tych możesz użyć intencji, która ustawi FLAG_ACTIVITY_REQUIRE_DEFAULT flagę intencji.

Jeśli intencja zawiera tę flagę, wywołanie startActivity() powoduje wywołanie ActivityNotFoundException musi być zgłaszany, gdy wywołanie wyświetliło

Jeśli intencja zawiera zarówno tę flagę, jak i parametr FLAG_ACTIVITY_REQUIRE_NON_BROWSER flagę intencji, wywołanie do startActivity() wywołuje ActivityNotFoundException musi zostać zgłoszona, 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.

Fragment kodu poniżej pokazuje, jak używać tabeli FLAG_ACTIVITY_REQUIRE_NON_BROWSER i FLAG_ACTIVITY_REQUIRE_DEFAULT razem:

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 Twoja aplikacja obsługuje pliki lub załączniki, na przykład sprawdza, czy urządzenie może otworzyć dany plik, najłatwiej jest uruchomić działanie, które może obsłużyć plik. Aby to zrobić, użyj intencji obejmującej intencję ACTION_VIEW wraz z identyfikatorem URI odpowiadającym konkretnemu plikowi. Jeśli na urządzenia, aplikacja może wychwytywać ActivityNotFoundException. W obsługi wyjątków, możesz wyświetlić błąd lub spróbować obsłużyć plik siebie.

Jeśli Twoja aplikacja musi wiedzieć z wyprzedzeniem, czy inna aplikacja może otworzyć dany plik, uwzględnij element <intent> w tym fragmencie kodu jako część elementu <queries> w pliku manifestu. Podaj typ pliku, jeśli znasz go już w momencie kompilacji.

<!-- 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łując resolveActivity()z zapytaniem.

Przyznawanie dostępu do identyfikatora URI

W przypadku aplikacji kierowanych na Androida 11 lub nowszego na dostępu do identyfikatora URI treści, intencja aplikacji musi zadeklarować dostęp URI uprawnienia Możesz to zrobić, ustawiając jedną lub obie z tych flag intencji: FLAG_GRANT_READ_URI_PERMISSION. oraz FLAG_GRANT_WRITE_URI_PERMISSION

W Androidzie 11 i nowszych uprawnienia dostępu do identyfikatora URI zapewniają następujące funkcje do aplikacji, która odbiera intencję:

• odczytywać lub zapisywać dane reprezentowane przez identyfikator URI treści, w zależności od uprawnień danego identyfikatora URI.
• uzyskać wgląd w aplikację zawierającą dostawcę treści pasującego do zapytania, Uprawnienia dla identyfikatora URI. Aplikacja zawierająca dostawcę treści może być inna z aplikacji, która wysyła intencję.

Ten fragment kodu pokazuje, jak dodać flagę intencji uprawnień do identyfikatora URI aby inna aplikacja kierowana na Androida 11 lub nowszego mogła 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

Gdy aplikacja musi wchodzić w interakcję z usługą, która nie jest widoczna , możesz zadeklarować odpowiednie działanie intencji w elemencie <queries>. W poniższych sekcjach podać przykłady za pomocą 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ę, dodaj te elementy Element <intent> w elemencie <queries> w pliku manifestu:

<!-- 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, dodaj te elementy: Element <intent> w elemencie <queries> w pliku manifestu:

<!-- 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ą multimediów kliencką aplikacji, uwzględnij następujący element <intent> jako część elementu <queries> plik manifestu:

<!-- 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ć elementy możliwe do dostosowania informacji na podstawie jego interakcji z innymi aplikacjami, niestandardowe zachowanie za pomocą filtra intencji podpisy jako elementu <queries> w pliku manifestu. W sekcjach poniżej 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ądzenia, na przykład aby sprawdzić, która jest jego domyślną modułem do obsługi SMS-ów, dodaj ten element <intent> jako część elementu <queries> w Twój plik manifestu:

<!-- 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 używaj arkusza udostępniania udostępnianego przez system. Ewentualnie dodaj ten element <intent> jako część elementu <queries> w Twój plik 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 karty udostępniania w logice aplikacji, np. wywołanie funkcji queryIntentActivities(), pozostaje niezmieniony w porównaniu z wersjami Androida starszymi niż 11.

Pokaż niestandardowe działania dotyczące zaznaczania tekstu

Gdy użytkownik zaznaczy tekst w aplikacji, pojawi się tekst zaznaczenia pasek narzędzi pokazuje zestaw operacji, które można wykonać na zaznaczonym tekście. Jeśli pasek narzędzi pokazuje niestandardowe działania z innych aplikacji, w tym: Element <intent> w elemencie <queries> w pliku manifestu:

<!-- 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ć dane niestandardowe wiersze Dostawca. Aby aplikacja do obsługi kontaktów mogła wyświetlać te dane niestandardowe, musi być mogą wykonywać te czynności:

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, umieść w niej te elementy <intent> elementu <queries> w pliku manifestu:

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