Otrzymuj proste dane z innych aplikacji

Aplikacja może wysyłać dane do innych aplikacji i może też otrzymywać dane z innych Google Cloud i aplikacjami. Zastanów się, jak użytkownicy korzystają z Twojej aplikacji i jakie typy danych chcesz otrzymywać z innych aplikacji. Na przykład aplikacja do 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ą Androida arkusz udostępniania lub resolver intencji. Aplikacje, które wysyłają dane do aplikacji, muszą mieć skonfigurowany 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 pliku manifestu
• Udostępnianie skrótów opublikowanych przez Twoją aplikację.

Cele udostępniania bezpośredniego to precyzyjne linki do konkretnej aktywności w aplikacji. Często reprezentują osobę lub grupę, co widać w arkuszu udostępniania Androida. 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ługa typów MIME

Najlepiej, gdy aplikacja może odbierać 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 najpopularniejsze typy MIME do wysyłania i odbierania prostych danych na Androidzie.

Odbiorcy rejestrują się w celu	Wysyłane przez nadawców
text/*	text/plain text/rtf text/html text/json
`image/*`	image/jpg image/png image/gif
video/*	video/mp4 video/3gp
Obsługiwane rozszerzenia pliku	application/pdf

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

Uwaga: chociaż możesz otrzymać typ MIME */*, zdecydowanie odradzamy to, chyba że Twoja aplikacja jest w pełni zdolna do obsługi dowolnego typu przychodzących treści.

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 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ę.

Zaktualizuj plik manifestu

Filtry intencji informują system, jakie intencje akceptuje komponent aplikacji. Podobnie jak w lekcji Wysyłanie prostych danych do innych aplikacji, w tym przypadku musisz utworzyć filtry intencji, aby odbierać 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 Twoją aplikację, rozpocznie się odpowiednia aktywność (.ui.MyActivity w poprzednim przykładzie). Od Ciebie zależy, czy poprawisz treść witryny. w kodzie i interfejsie.

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. Po uzyskaniu obiektu możesz sprawdzić jego zawartość, aby zdecydować, co zrobić dalej. 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 wiesz, co może wysłać inna aplikacja. Na przykład może zostać ustawiony nieprawidłowy typ MIME lub może być bardzo duży. 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
    }
}

Aby zaktualizować interfejs po otrzymaniu danych, wystarczy wypełnić pole EditText lub może być większa jest to dość skomplikowane jak dodawanie ciekawego filtra do zdjęcia. Dalsze kroki zależą od Twojej aplikacji.

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

Aplikacja jest reprezentowana przez ikonę i etykietę w panelu udostępniania i rozwiązywania intencji w Androidzie. Oba te elementy są zdefiniowane w pliku manifestu. Dostępne opcje ustawić etykiety filtra aktywności lub intencji, aby zapewnić szerszy kontekst.

Od Androida 10 (poziom interfejsu API 29) w arkuszu udostępniania Androida używane są tylko ikony ustawione w w pliku manifestu w tagu application. Android ignoruje ikony ustawione na 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 odbierającej muszą być na tyle, by użytkownik wiedział, co się dzieje, gdy coś udostępnia.