Otrzymuj proste dane z innych aplikacji

Aplikacja może nie tylko wysyłać dane do innych aplikacji, ale też otrzymywać dane z nich. Zastanów się, jak użytkownicy korzystają z Twojej aplikacji i jakie typy danych chcesz otrzymywać z innych aplikacji. Na przykład aplikacja do obsługi sieci społecznościowych może być zainteresowana otrzymaniem tekstu, np. interesującego adresu URL strony internetowej, z innej aplikacji.

Użytkownicy innych aplikacji często wysyłają dane do Twojej aplikacji za pomocą panelu udostępniania Androida lub rozwiązywania intencji. Aplikacje, które wysyłają dane do Twojej aplikacji, muszą ustawić dla tych danych typ MIME. Aplikacja może otrzymywać dane wysyłane przez inną aplikację w następujący sposób:

• Activity z pasującym tagiem intent-filter w pliku manifestu
• Udostępnianie skrótów opublikowanych przez Twoją aplikację.

Docelowe miejsca udostępniania bezpośredniego to precyzyjne linki do określonych działań w aplikacji. Często reprezentują one osobę lub grupę i wyświetlają się w panelu udostępniania na Androidzie. Na przykład aplikacja do obsługi wiadomości może udostępnić osobie docelowo ustawionej w ramach funkcji Direct Share precyzyjny link do rozmowy z tą osobą. Szczegółowe instrukcje znajdziesz w artykule Podawanie docelowych odbiorców udostępniania bezpośredniego.

Obsługiwane typy MIME

W idealnej sytuacji aplikacja powinna obsługiwać jak najszerszy zakres typów MIME. Na przykład aplikacja do obsługi wiadomości, która służy do wysyłania tekstu, obrazów i filmów, powinna w najlepszym przypadku obsługiwać text/*, image/* i video/*. Oto kilka typów MIME, które są często używane do wysyłania i odbierania prostych danych na Androidzie.

Odbiorcy rejestrują się w ramach	Nadawcy wysyłają
text/*	text/plain text/rtf text/html text/json
`image/*`	image/jpg image/png image/gif
video/*	video/mp4 video/3gp
Obsługiwane rozszerzenia plików	application/pdf

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

Uwaga: możesz otrzymać typ MIME */*, ale zdecydowanie odradzamy korzystanie z tego typu wiadomości, jeśli aplikacja w pełni obsługuje wszystkie rodzaje przychodzących treści.

Tworzenie świetnych celów udostępniania

Po kliknięciu celu udostępniania powiązanego z konkretną aktywnością użytkownik powinien być w stanie potwierdzić i edytować udostępnioną treść, zanim będzie mogła ich użyć. Jest to szczególnie ważne w przypadku danych tekstowych.

Odbieranie danych za pomocą aktywności

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

Aktualizowanie pliku 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 otrzymywać intencje z tym działaniem. Filtr intencji definiujesz w pliku manifestu za pomocą elementu <intent-filter>. Jeśli np. Twoja aplikacja obsługuje odbieranie treści tekstowych, manifest zawierający co najmniej 1 obraz dowolnego typu będzie wyglądać tak:

<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 próbuje udostępnić dowolną z tych rzeczy, tworząc intencję i przekazując ją do startActivity(), Twoja aplikacja jest wyświetlana jako opcja w panelu udostępniania lub rozwiązywaczu intencji Androida. Jeśli użytkownik wybierze aplikację, rozpocznie się odpowiednie działanie (.ui.MyActivity w poprzednim przykładzie). Odpowiednie przetwarzanie treści w kodzie i interfejsie należy do Ciebie.

Uwaga: więcej informacji o filtrach intencji i rozwiązywaniu intencji znajdziesz w artykule Intencje i filtry intencji.

Obsługa przychodzących treści

Aby obsłużyć treści dostarczane przez Intent, wywołaj funkcję getIntent(), aby uzyskać obiekt Intent. Gdy już go otrzymasz, możesz sprawdzić jego zawartość, aby określić dalsze działania. Jeśli tę aktywność można rozpocząć z innych części systemu (np. z poziomu programu uruchamiającego), weź to pod uwagę podczas sprawdzania intencji.

Uważnie sprawdzaj przychodzące dane, ponieważ nigdy nie wiadomo, co może wysłać inna aplikacja. Może to być na przykład spowodowane błędnym ustawieniem typu MIME lub bardzo dużym rozmiarem wysyłanego obrazu. Pamiętaj też, aby przetwarzać dane binarne w osobnym wątku, a nie w głównym („UI”).

Kotlin

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

Java

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

Aktualizacja interfejsu po otrzymaniu danych może być tak prosta jak wypełnienie pola EditText lub bardziej skomplikowana, np. zastosowanie ciekawego filtra do zdjęcia. Dalsze kroki zależą od Twojej aplikacji.

Zadbaj o to, aby użytkownicy rozpoznawali Twoją aplikację

Aplikacja jest reprezentowana przez ikonę i etykietę w panelu udostępniania i rozwiązywania intencji w Androidzie. Oba są zdefiniowane w manifeście. Aby uzyskać więcej kontekstu, możesz ustawić etykiety filtra aktywności lub zamiaru.

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

Uwaga: docelowe udziały w ruchu nie wymagają etykiety ani ikony w powiązanym filtrze aktywności lub zamiaru. Nazwa i ikona aplikacji odbiorcy muszą być wystarczające, aby użytkownik wiedział, co się dzieje, gdy udostępnia.