Otrzymuj proste dane z innych aplikacji

Aplikacja może wysyłać dane do innych aplikacji, ale może też odbierać dane z innych aplikacji. Zastanów się, jak użytkownicy korzystają z Twojej aplikacji i jakie typy danych chcesz otrzymywać z innych aplikacji. Na przykład aplikacja sieci społecznościowej może być zainteresowana otrzymywaniem z innej aplikacji treści tekstowych, takich jak interesujący adres URL.

Użytkownicy innych aplikacji często wysyłają dane do Twojej aplikacji za pomocą arkusza udostępniania Androida lub resolvera intencji. Aplikacje wysyłające dane do aplikacji muszą mieć ustawiony typ MIME tych danych. Aplikacja może otrzymywać dane wysyłane przez inną aplikację na te sposoby:

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

Cele udostępniania bezpośredniego to precyzyjne linki do określonej aktywności w Twojej aplikacji. Często reprezentują osobę lub grupę, co jest widoczne w arkuszu udostępniania Androida. Na przykład aplikacja do obsługi wiadomości może służyć jako cel udostępniania bezpośredniego w przypadku osoby, która prowadzi precyzyjny link do rozmowy z tą osobą. Szczegółowe instrukcje znajdziesz w artykule Określanie wartości docelowych udostępniania bezpośredniego.

Obsługa typów MIME

W idealnej sytuacji aplikacja musi być w stanie odbierać jak największy zakres typów MIME. Na przykład aplikacja do obsługi wiadomości przeznaczona do wysyłania tekstu, obrazów i filmów najlepiej obsługuje odbieranie elementów 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 mediów MIME IANA.

Twórz świetne cele udostępniania

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

Odbieranie danych za pomocą aktywności

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

Zaktualizuj plik manifestu

Filtry intencji informują system, które intencje akceptuje komponent aplikacji. Podobnie jak w przypadku intencji za pomocą działania ACTION_SEND z lekcji Wysyłanie prostych danych do innych aplikacji możesz tworzyć filtry intencji, które pozwolą Ci docierać do intencji związanych z tym działaniem. Filtr intencji możesz zdefiniować w pliku manifestu za pomocą elementu <intent-filter>. Jeśli na przykład aplikacja obsługuje odbieranie treści tekstowych, plik manifestu zawierający co najmniej jeden 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ć cokolwiek z tych elementów, tworząc intencję i przekazując ją do startActivity(), aplikacja jest widoczna jako opcja w arkuszu udostępniania Androida lub w mechanizmie rozpoznawania intencji. Jeśli użytkownik wybierze Twoją aplikację, rozpocznie się odpowiednie działanie (.ui.MyActivity w poprzednim przykładzie). Następnie musisz zadbać o prawidłowe postępowanie z treścią w kodzie i interfejsie.

Obsługa treści przychodzących

Aby obsłużyć treści dostarczone przez Intent, wywołaj getIntent() w celu uzyskania obiektu Intent. Po przygotowaniu obiektu możesz sprawdzić jego zawartość, by zdecydować, co zrobić dalej. Jeśli działanie to można uruchomić z innych części systemu (np. programu uruchamiającego), weź to pod uwagę podczas analizy intencji.

Dokładnie sprawdzaj przychodzące dane. Nigdy nie wiadomo, co wyśle Ci inne aplikacje. 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.

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

Zaktualizowanie interfejsu po otrzymaniu danych może być proste i jedynie w EditText, a bardziej skomplikowane, na przykład przez zastosowanie ciekawego filtra do zdjęcia. Od Twojej aplikacji zależy, co się wydarzy.

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

Twoja aplikacja jest reprezentowana przez ikonę i etykietę w arkuszu udostępniania Androida i mechanizmie rozpoznawania intencji. Są one zdefiniowane w pliku manifestu. Możesz ustawić etykiety filtra działań lub intencji, aby dać więcej kontekstu.

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