Otrzymuj proste dane z innych aplikacji

Podobnie jak aplikacja może wysyłać dane do innych aplikacji, może też je od nich odbierać. Zastanów się, w jaki sposób 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 treści tekstowych, takich jak ciekawy adres URL, z innej aplikacji.

Użytkownicy innych aplikacji często przesył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. Aplikacja może otrzymywać dane wysyłane przez inną aplikację w następujący sposób:

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

Obiekty docelowe udostępniania bezpośredniego to precyzyjne linki do konkretnego działania w aplikacji. Często reprezentują one osobę lub grupę, a arkusz udostępniania na Androidzie je wyświetla. Na przykład aplikacja do obsługi wiadomości może udostępniać element docelowy udostępniania bezpośredniego dla osoby, która ma precyzyjny link bezpośrednio do rozmowy z tą osobą. Szczegółowe instrukcje znajdziesz w artykule Podawanie celów udostępniania bezpośredniego.

Obsługiwane typy MIME

Aplikacja powinna być w stanie 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 text/*, image/* i video/*. Oto kilka typowych typów MIME do wysyłania i odbierania prostych danych na Androidzie.

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

Tworzenie świetnych odbiorców udostępniania

Gdy użytkownik kliknie element docelowy udostępniania powiązany z określonym 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.

Otrzymywanie danych z aktywnością

Odbieranie danych za pomocą działania obejmuje aktualizację pliku manifestu, obsługę przychodzących treści i zapewnienie, że użytkownik rozpozna 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 odbierać intencje z tym działaniem. Filtr intencji definiuje się w pliku manifestu za pomocą elementu <intent-filter>. Jeśli na przykład Twoja aplikacja obsługuje odbieranie treści tekstowych, manifest zawierający 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 pojawi się jako opcja na arkuszu udostępniania Androida lub w rozwiązaniu intencji. Jeśli użytkownik wybierze Twoją aplikację, rozpocznie się odpowiednia aktywność (.ui.MyActivity w poprzednim przykładzie). Od Ciebie zależy, jak odpowiednio wykorzystasz te treści w kodzie i interfejsie.

Obsługa przychodzących treści

Aby obsłużyć treści dostarczone przez Intent, wywołaj funkcję getIntent(), aby uzyskać obiekt Intent. Gdy uzyskasz dostęp do obiektu, możesz sprawdzić jego zawartość, aby zdecydować, co zrobić dalej. Jeśli tę aktywność można uruchomić z innych części systemu (np. z programu uruchamiającego), weź to pod uwagę podczas analizowania intencji.

Zwróć szczególną uwagę na sprawdzanie danych przychodzących. Nigdy nie wiadomo, co może Ci wysłać inna aplikacja. Na przykład może być 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
    }
}

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

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

Aplikacja jest reprezentowana przez ikonę i etykietę w arkuszu udostępniania i rozwiązywaniu intencji na Androidzie. Oba te elementy są zdefiniowane w pliku manifestu. Możesz ustawić etykiety aktywności lub filtrów intencji, aby zapewnić więcej kontekstu.

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.