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.

Jeśli aplikacja przeznaczona na Androida 11 lub nowszego używa intencji do uruchamiania aktywności w innej aplikacji, najprostszym rozwiązaniem jest wywołanie intencji i obsługa wyjątku ActivityNotFoundException, jeśli ż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 aplikacji kierowanej na Androida 11 lub nowszego.

otwierać adresy URL w przeglądarce lub innej aplikacji;

Aby otworzyć adres URL, użyj intencji zawierającej działanie intencji ACTION_VIEW, jak opisano w przewodniku dotyczącym ładowania adresu URL. Gdy wywołasz startActivity() za pomocą tego zamiaru, dzieje się jedno z tych działań:

• Adres URL otwiera się w przeglądarce.
• 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, która mogłaby otworzyć adres URL. (To nietypowa sytuacja).

  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 dodaj element <intent> w ramach elementu <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

Karty niestandardowe umożliwiają pozwala dostosować wygląd i działanie przeglądarki. Możesz otwierać adres URL na karcie niestandardowej bez konieczności dodawania ani zmieniania elementu <queries> w pliku manifestu 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 Twoja aplikacja może otwierać adresy URL za pomocą kart niestandardowych, zalecamy, aby w miarę możliwości otworzyć adres URL w innej aplikacji niż przeglądarka. 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 tę flagę, wywołanie startActivity() powoduje wywołanie ActivityNotFoundException, który ma być zwrócony, gdy dowolny z tych elementów zachodzi sytuacja:

• Połączenie spowodowałoby bezpośrednie uruchomienie aplikacji przeglądarki.
• W ramach tego wywołania użytkownik zobaczyłby okno rozróżniania, w którym jedynymi opcjami byłyby aplikacje 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);
}

Unikaj okna ujednoznacznienia

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 okno ujednoznacznienia.

Jeśli intencja zawiera ten parametr i parametr FLAG_ACTIVITY_REQUIRE_NON_BROWSER, wywołanie funkcji startActivity() powoduje wyjątek 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 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 aplikacja obsługuje pliki lub załączniki, na przykład sprawdza, czy urządzenie otworzyć dany plik, zwykle najlepiej jest spróbować uruchomić aktywność, zarządzać plikiem. Aby to zrobić, użyj intencji obejmującej intencję ACTION_VIEW do działania i identyfikatora URI reprezentującego określony plik. 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 już go znasz co jest na etapie kompilowania.

<!-- 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 adresu URI zapewniają aplikacji, która odbiera intencję, następujące możliwości:

• odczytywać lub zapisywać dane reprezentowane przez identyfikator URI treści, w zależności od uprawnień tego identyfikatora;
• 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ń 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);

Łączenie 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 kolejnych sekcjach 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ę, 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 wchodzi w interakcję z usługą rozpoznawania mowy, dodaj element <intent> w ramach elementu <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 to aplikacja przeglądarki multimediów klienta, w pliku manifestu dodaj element <intent> w ramach elementu <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ć 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 o aplikacje do obsługi 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. Możesz też umieścić w elemencie <queries> w pliku manifestu element <intent>:

<!-- 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żytkownicy zaznaczą tekst w aplikacji, pasek narzędzi do zaznaczania tekstu wyświetli zestaw możliwych operacji, które można wykonać na zaznaczonym tekście. Jeśli tą toolbar wyświetla działania niestandardowe z innych aplikacji, w pliku manifestu dodaj element <intent> w ramach elementu <queries>:

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

Wyświetlanie wierszy danych niestandardowych dotyczących kontaktu

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

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

Jeśli Twoja aplikacja jest aplikacją kontaktów, w pliku manifestu umieść te elementy <intent> w elementach <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>