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 dane które chcesz otrzymywać z innych aplikacji. Na przykład kanał społecznościowy aplikacja sieciowa może być zainteresowana otrzymywaniem treści tekstowych, takich jak interesujący adres URL 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. Twoja aplikacja może otrzymywać dane wysyłane przez inną aplikację w 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 być celem bezpośredniego udostępniania dla osoby, która: precyzyjnymi linkami do rozmowy z daną osobą. Zobacz Podaj wartości docelowe bezpośredniego udostępniania, aby za instrukcje.

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 przeznaczona do wysyłania tekstu, zdjęć i filmów najlepiej obsługuje odbieranie text/*, image/* i video/*. Oto kilka najpopularniejsze typy MIME do wysyłania i odbierania prostych danych na Androidzie.

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

Twórz świetne cele udostępniania

Gdy użytkownik kliknie obiekt udostępniania powiązany z określoną aktywnością, powinni być w stanie potwierdzić i edytować udostępnioną treść przed ich użyciem. To jest szczególnie ważne w przypadku danych tekstowych.

Odbieranie danych za pomocą aktywności

Odbieranie danych z działaniem wymaga aktualizacji pliku manifestu, obsługi i upewnij się, że użytkownik rozpoznaje aplikację.

Zaktualizuj plik manifestu

Filtry intencji informują system, które intencje akceptuje komponent aplikacji. Przypomina to sposób, w jaki tworzysz intencję za pomocą działania ACTION_SEND w polu Wysyłanie prostych danych do innych aplikacji utworzysz filtry intencji, które będą otrzymywać intencje związane z tym działaniem. Ty zdefiniować filtr intencji w pliku manifestu za pomocą elementu <intent-filter>. Jeśli na przykład aplikacja obsługuje odbieranie treści tekstowych, plik manifestu, który zawiera 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ć którykolwiek z tych elementów przez utworzenie i przekazywaniu jej do startActivity(), jest wymieniona jako opcja w arkuszu udostępniania Androida lub narzędziu do rozpoznawania intencji. Jeśli użytkownik wybierze aplikację, rozpocznie się odpowiednia aktywność (.ui.MyActivity w poprzedniego przykładu). Od Ciebie zależy, czy poprawisz treść witryny. w kodzie i interfejsie.

Obsługa przychodzących treści

Aby przetworzyć treści dostarczone przez Intent, wywołaj getIntent(), aby pobrać obiekt Intent. Po uzyskaniu obiektu możesz sprawdzić jego zawartość, aby zdecydować, co zrobić dalej. Jeśli to działanie może został uruchomiony z innych części systemu (np. programu uruchamiającego), użyj tego być wzięte pod uwagę podczas badania zamiarów.

Dokładnie sprawdzaj przychodzące dane. Nigdy nie wiadomo, aplikacja może Cię wysłać. 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 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
    }
}

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. Tylko tak jest co dalej z aplikacją.

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

Reprezentacja aplikacji to: icon i label w Androidzie Arkusz udostępniania i resolver intencji. Oba te elementy są zdefiniowane w pliku manifestu. Dostępne opcje ustaw etykiety filtra aktywności lub intencji, aby podać więcej kontekstu.

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.