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 w Androidzie. Na przykład aplikacja do obsługi wiadomości może udostępnić osobie docelowo ustawionej do bezpośredniego udostępniania 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.

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

Tworzenie świetnych celów udostępniania

Gdy użytkownik kliknie element udostępniania powiązany z określoną aktywnością, powinien mieć możliwość potwierdzenia i edytowania udostępnionych treści przed ich użyciem. Jest to szczególnie ważne w przypadku danych tekstowych.

Odbieranie danych z 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 na przykład 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 Twoją aplikację, rozpocznie się odpowiednia aktywność (.ui.MyActivity w poprzednim przykładzie). Odpowiednie przetwarzanie treści w kodzie i interfejsie należy do Ciebie.

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”).

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 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) panel udostępniania Androida używa tylko ikon ustawionych w pliku manifestu w tagu application. Android ignoruje ikony ustawione w tagach intent-filter i activity.