Otrzymuj proste dane z innych aplikacji

Aplikacja może nie tylko wysyłać dane do innych aplikacji, ale też je od nich odbierać. Zastanów się, jak użytkownicy wchodzą w interakcje z Twoją aplikacją i jakie typy danych chcesz otrzymywać z innych aplikacji. Na przykład aplikacja społecznościowa może być zainteresowana otrzymywaniem z innej aplikacji treści tekstowych, takich jak ciekawe adresy URL.

Użytkownicy innych aplikacji często wysyłają dane do Twojej aplikacji za pomocą arkusza udostępniania Androida lub narzędzia do rozwiązywania intencji. Aplikacje, które wysyłają dane do Twojej aplikacji, muszą ustawić typ MIME tych danych. Twoja aplikacja może odbierać dane wysyłane przez inną aplikację na te sposoby:

• Activity z pasującym tagiem intent-filter w pliku manifestu.
• Skróty udostępniania opublikowane przez Twoją aplikację.

Odbiorcy udostępniania bezpośredniego to precyzyjne linki do konkretnego Activity w Twojej aplikacji. Często reprezentują one osobę lub grupę i są wyświetlane w arkuszu udostępniania w Androidzie. Na przykład aplikacja do obsługi wiadomości może udostępniać odbiorcę udostępniania bezpośredniego dla osoby, który prowadzi bezpośrednio do rozmowy z tą osobą. Szczegółowe instrukcje znajdziesz w artykule Udostępnianie odbiorców udostępniania bezpośredniego.

Obsługa typów MIME

Idealnie byłoby, gdyby aplikacja mogła odbierać jak najszerszy zakres typów MIME. Na przykład aplikacja do obsługi wiadomości przeznaczona do wysyłania tekstu, obrazów i filmów powinna obsługiwać odbieranie typów text/*, image/* i video/*. Oto kilka typowych typów MIME do wysyłania i odbierania prostych danych w Androidzie.

Zapoznaj się z oficjalnym rejestrem typów MIME IANA.

Tworzenie skutecznych odbiorców udostępniania

Gdy użytkownik kliknie odbiorcę udostępniania powiązanego z konkretnym działaniem, powinien mieć możliwość potwierdzenia i edytowania udostępnianych treści przed ich użyciem. Jest to szczególnie ważne w przypadku danych tekstowych.

Odbieranie danych za pomocą działania

Odbieranie danych za pomocą działania obejmuje aktualizację pliku manifestu, obsługę treści przychodzących i upewnienie się, że użytkownik rozpoznaje Twoją aplikację.

Aktualizowanie manifestu

Filtry intencji informują system, które intencje akceptuje komponent aplikacji. Podobnie jak w przypadku tworzenia intencji z działaniem ACTION_SEND w lekcji Wysyłanie prostych danych do innych aplikacji , tworzysz filtry intencji, aby odbierać intencje z tym działaniem. Filtr intencji definiujesz w pliku manifestu za pomocą elementu <intent-filter>. Jeśli na przykład Twoja aplikacja obsługuje odbieranie treści tekstowych, manifest, który zawiera co najmniej 1 obraz dowolnego typu, będzie wyglądać jak ten fragment kodu:

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

Gdy inna aplikacja spróbuje udostępnić dowolny z tych elementów, tworząc intencję i przekazując ją do startActivity(), Twoja aplikacja zostanie wymieniona jako opcja w arkuszu udostępniania w Androidzie lub narzędziu do rozwiązywania intencji. Jeśli użytkownik wybierze Twoją aplikację, uruchomi to odpowiednie działanie (.ui.MyActivity w poprzednim przykładzie). Następnie musisz odpowiednio obsłużyć treści w kodzie i interfejsie.

Obsługa treści przychodzących

Aby obsługiwać treści dostarczane przez Intent, wywołaj getIntent(), aby uzyskać obiekt Intent. Gdy masz już obiekt, możesz sprawdzić jego zawartość, aby określić, co zrobić dalej. Jeśli to działanie można uruchomić z innych części systemu (np. z programu uruchamiającego), weź to pod uwagę podczas sprawdzania intencji.

Zachowaj szczególną ostrożność podczas sprawdzania danych przychodzących, ponieważ nigdy nie wiesz, co może wysłać Ci inna aplikacja. Może na przykład zostać ustawiony nieprawidłowy typ MIME lub wysyłany obraz może być bardzo duży. Pamiętaj też, aby przetwarzać dane binarne w osobnym wątku, a nie w wątku głównym („UI”).

override fun onCreate(savedInstanceState: Bundle?) {
    ...
    when {
        intent?.action == Intent.ACTION_SEND -> {
            if ("text/plain" == intent.type) {
                handleSendText(intent) // Handle text being sent
            } else if (intent.type?.startsWith("image/") == true) {
                handleSendImage(intent) // Handle single image being sent
            }
        }
        intent?.action == Intent.ACTION_SEND_MULTIPLE
                && intent.type?.startsWith("image/") == true -> {
                handleSendMultipleImages(intent) // Handle multiple images being sent
        }
        else -> {
            // Handle other intents, such as being started from the home screen
        }
    }
    ...
}

private fun handleSendText(intent: Intent) {
    intent.getStringExtra(Intent.EXTRA_TEXT)?.let {
        // Update UI to reflect text being shared
    }
}

private fun handleSendImage(intent: Intent) {
    (intent.getParcelableExtra<Parcelable>(Intent.EXTRA_STREAM) as? Uri)?.let {
        // Update UI to reflect image being shared
    }
}

private fun handleSendMultipleImages(intent: Intent) {
    intent.getParcelableArrayListExtra<Parcelable>(Intent.EXTRA_STREAM)?.let {
        // Update UI to reflect multiple images being shared
    }
}

void onCreate (Bundle savedInstanceState) {
    ...
    // Get intent, action and MIME type
    Intent intent = getIntent();
    String action = intent.getAction();
    String type = intent.getType();

    if (Intent.ACTION_SEND.equals(action) && type != null) {
        if ("text/plain".equals(type)) {
            handleSendText(intent); // Handle text being sent
        } else if (type.startsWith("image/")) {
            handleSendImage(intent); // Handle single image being sent
        }
    } else if (Intent.ACTION_SEND_MULTIPLE.equals(action) && type != null) {
        if (type.startsWith("image/")) {
            handleSendMultipleImages(intent); // Handle multiple images being sent
        }
    } else {
        // Handle other intents, such as being started from the home screen
    }
    ...
}

void handleSendText(Intent intent) {
    String sharedText = intent.getStringExtra(Intent.EXTRA_TEXT);
    if (sharedText != null) {
        // Update UI to reflect text being shared
    }
}

void handleSendImage(Intent intent) {
    Uri imageUri = (Uri) intent.getParcelableExtra(Intent.EXTRA_STREAM);
    if (imageUri != null) {
        // Update UI to reflect image being shared
    }
}

void handleSendMultipleImages(Intent intent) {
    ArrayList<Uri> imageUris = intent.getParcelableArrayListExtra(Intent.EXTRA_STREAM);
    if (imageUris != null) {
        // Update UI to reflect multiple images being shared
    }
}

Aktualizowanie interfejsu po otrzymaniu danych może być tak proste jak wypełnienie pola EditText lub bardziej skomplikowane, np. zastosowanie ciekawego filtra do zdjęcia. To, co stanie się dalej, zależy od Twojej aplikacji.

Udostępnianie adresu URL zrzutu ekranu

Podczas robienia zrzutu ekranu możesz udostępnić go wraz z powiązanym adresem URL. Zapewnia to lepsze wrażenia użytkownika. Podczas odbierania adresu URL pamiętaj, aby pobrać pole EXTRA_TEXT z intencji, jak pokazano w tym przykładzie:

override fun onCreate(savedInstanceState: Bundle?) {
    ...
    when {
        intent?.action == Intent.ACTION_SEND -> {
            if (intent.type?.startsWith("image/") == true) {
                handleSendImage(intent)
            }
         }
    ...
}
private fun handleSendImage(intent: Intent) {
    (intent.getParcelableExtra<Parcelable>(Intent.EXTRA_STREAM) as? Uri)?.let {
     // Handle the EXTRA_TEXT as well
     intent.getCharSequenceExtra(Intent.EXTRA_TEXT)
    // Update UI to reflect image being shared and the EXTRA_TEXT
    // if available
    }
}
...
}

Upewnianie się, że użytkownicy rozpoznają Twoją aplikację

Twoja aplikacja jest reprezentowana przez jej ikonę i etykietę w arkuszu udostępniania Androida i narzędziu do rozwiązywania intencji. Oba te elementy są zdefiniowane w pliku manifestu. Aby zapewnić więcej kontekstu, możesz ustawić etykiety działania lub filtra intencji.

Od Androida 10 (poziom interfejsu API 29) arkusz udostępniania w Androidzie używa tylko ikon ustawionych w pliku manifestu w tagu application. Android ignoruje ikony ustawione w tagach intent-filter i activity.