Wysyłanie prostych danych do innych aplikacji

Android używa intencji i powiązanych z nimi dodatków, aby umożliwić użytkownikom szybkie i łatwe udostępnianie informacji za pomocą ulubionych aplikacji.

Android umożliwia użytkownikom udostępnianie danych między aplikacjami na 2 sposoby:

  • Panel udostępniania w Androidzie jest przeznaczony przede wszystkim do wysyłania treści poza aplikację lub bezpośrednio do innego użytkownika. na przykład przez udostępnienie adresu URL znajomemu.
  • Rozpoznawanie intencji Androida najlepiej nadaje się do przekazywania danych do kolejny etap dobrze zdefiniowanego zadania. Możesz na przykład otworzyć plik PDF w aplikacji i zezwolić użytkownikom na wybranie preferowanego programu do wyświetlania.

Podczas tworzenia intencji określasz działanie, które ma ona wykonać. Android używa działania ACTION_SENDdo wysyłania danych z jednej czynności do drugiej, nawet poza granicami procesu. Musisz określić i ich rodzaj. System automatycznie identyfikuje zgodne aktywności, które mogą otrzymywać dane, i wyświetla je użytkownikowi. W przypadku rozwiązywania intencji, jeśli tylko jedna aktywność może obsłużyć intencję, ta aktywność uruchamia się natychmiast.

Dlaczego warto korzystać z arkusza udostępniania w Androidzie

Zdecydowanie zalecamy korzystanie z arkusza udostępniania Androida, aby zapewnić użytkownikom spójność aplikacji. Nie wyświetlaj własnej listy docelowych odbiorców aplikacji ani nie twórz własnej Odmiany arkusza udostępniania.

Panel udostępniania w Androidzie umożliwia użytkownikom udostępnianie informacji właściwej osobie z odpowiednimi sugestiami aplikacji – wystarczy jedno kliknięcie. Arkusz udostępniania może sugerować cele niedostępne dla rozwiązań niestandardowych i stosuje spójny ranking. Dzieje się tak, ponieważ panel udostępniania może uwzględniać informacje o aktywności użytkownika i aplikacji, które są dostępne tylko dla systemu.

Panel udostępniania w Androidzie zawiera też wiele przydatnych funkcji dla deweloperów. Możesz na przykład: wykonaj te czynności:

Korzystanie z arkusza udostępniania w Androidzie

W przypadku wszystkich typów udostępniania utwórz intencję i ustaw jej działanie na Intent.ACTION_SEND Aby wyświetlić arkusz udostępniania Androida, wywołaj Intent.createChooser(), i przekazuje jej obiekt Intent. Zwraca wersję intencji, w której zawsze wyświetla się arkusz udostępniania Androida.

Wyślij treść tekstową

Najprostszym i najczęstszym sposobem korzystania z panelu udostępniania na Androidzie jest wysyłanie treści tekstowych z jednego działania do drugiego. Na przykład większość przeglądarek może udostępniać adres URL aktualnie wyświetlanej strony jako tekst innej aplikacji. Jest to przydatne, gdy chcesz udostępnić artykuł lub stronę internetową znajomym za pomocą poczty e-mail lub mediów społecznościowych. Oto przykład:

KotlinJava
val sendIntent: Intent = Intent().apply {
    action = Intent.ACTION_SEND
    putExtra(Intent.EXTRA_TEXT, "This is my text to send.")
    type = "text/plain"
}

val shareIntent = Intent.createChooser(sendIntent, null)
startActivity(shareIntent)
 
Intent sendIntent = new Intent();
sendIntent.setAction(Intent.ACTION_SEND);
sendIntent.putExtra(Intent.EXTRA_TEXT, "This is my text to send.");
sendIntent.setType("text/plain");

Intent shareIntent = Intent.createChooser(sendIntent, null);
startActivity(shareIntent);

Opcjonalnie możesz dodać dodatki zawierające więcej informacji, na przykład odbiorców e-maili. (EXTRA_EMAIL, EXTRA_CC, EXTRA_BCC), temat e-maila (EXTRA_SUBJECT) itp.

Uwaga: niektóre aplikacje do obsługi poczty e-mail, takie jak Gmail, wymagają String[] za dodatki takie jak EXTRA_EMAIL i EXTRA_CC. Użyj putExtra(String, String[]) aby dodać je do intencji.

Wysyłanie danych binarnych

Udostępnianie danych binarnych za pomocą działania ACTION_SEND. Ustaw odpowiedni typ MIME i wpisz identyfikator URI danych w dodatkowym EXTRA_STREAM, jako w poniższym przykładzie. Jest ona często używana do udostępniania obrazu, ale można jej używać do udostępniania dowolnego typu treści binarnych.

KotlinJava
val shareIntent: Intent = Intent().apply {
    action = Intent.ACTION_SEND
    // Example: content://com.google.android.apps.photos.contentprovider/...
    putExtra(Intent.EXTRA_STREAM, uriToImage)
    type = "image/jpeg"
}
startActivity(Intent.createChooser(shareIntent, null))
 
Intent shareIntent = new Intent();
shareIntent.setAction(Intent.ACTION_SEND);
// Example: content://com.google.android.apps.photos.contentprovider/...
shareIntent.putExtra(Intent.EXTRA_STREAM, uriToImage);
shareIntent.setType("image/jpeg");
startActivity(Intent.createChooser(shareIntent, null));

Aplikacja odbiorcza musi mieć uprawnienia dostępu do danych wskazywanych przez Uri. Możesz to zrobić na 2 sposoby:

  • Przechowuj dane w swoim własnym ContentProvider, upewniając się, że inne aplikacje mają odpowiednie uprawnienia dostępu do Twojego dostawcy. Preferowany mechanizm udostępniania dostępu jest użycie uprawnień według identyfikatora URI, które są tymczasowy i przyznawaj dostęp tylko do aplikacji odbierającej. Prosty sposób na utworzenie ContentProvider podobny do tego to użycie FileProvider klasa pomocnicza.
  • Użyj systemu MediaStore. MediaStore jest przeznaczony głównie do obsługi typów MIME plików wideo, audio i graficznych. Jednak od Androida 3.0 (interfejs API) poziomu 11), mogą też przechowywać treści inne niż medialne. Więcej informacji znajdziesz w artykule MediaStore.Files. Pliki można wstawiać do MediaStore za pomocą funkcji scanFile(). Następnie do podanego odwołania funkcji onScanCompleted() przekazywany jest obiekt Uri w formacie content://, który nadaje się do udostępniania. Pamiętaj, że po dodaniu do systemu MediaStore treści są dostępne dla każdej aplikacji na urządzeniu.

Używanie odpowiedniego typu MIME

Podaj najbardziej szczegółowy typ MIME dostępny dla danych, które wysyłasz. Na przykład, podczas udostępniania zwykłego tekstu użyj text/plain. Oto kilka typowe typy MIME podczas wysyłania prostych danych w Androidzie:

Odbiorcy rejestrują się w celu Nadawcy wysyłają
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

Więcej informacji o typach MIME znajdziesz w oficjalnym rejestrze typów multimediów MIME IANA.

W zależności od wybranego typu MIME w arkuszu udostępniania Androida może pojawić się podgląd treści. Niektóre funkcje podglądu są dostępne tylko w przypadku określonych typów.

Udostępnianie wielu elementów treści

Aby udostępnić wiele treści, użyj działania ACTION_SEND_MULTIPLE wraz z listą identyfikatorów URI wskazujących na te treści. Typ MIME różni się w zależności od zestaw udostępnianych treści. Jeśli na przykład udostępniasz 3 obrazy JPEG, użyj typu "image/jpg". W przypadku mieszaniny typów obrazów użyj "image/*", aby dopasować aktywność do dowolnego typu obrazu. Udostępnianie różnych typów plików jest możliwe, ale zdecydowanie odradzamy to robić, ponieważ odbiorca nie wie, co ma być wysłane. Jeśli chcesz przesłać kilka rodzajów danych, użyj "*/*" Zależy to od aplikacji odbierającej i przetwarzania danych. Oto przykład:

KotlinJava
val imageUris: ArrayList<Uri> = arrayListOf(
        // Add your image URIs here
        imageUri1,
        imageUri2
)

val shareIntent = Intent().apply {
    action = Intent.ACTION_SEND_MULTIPLE
    putParcelableArrayListExtra(Intent.EXTRA_STREAM, imageUris)
    type = "image/*"
}
startActivity(Intent.createChooser(shareIntent, null))
 
ArrayList<Uri> imageUris = new ArrayList<Uri>();
imageUris.add(imageUri1); // Add your image URIs here
imageUris.add(imageUri2);

Intent shareIntent = new Intent();
shareIntent.setAction(Intent.ACTION_SEND_MULTIPLE);
shareIntent.putParcelableArrayListExtra(Intent.EXTRA_STREAM, imageUris);
shareIntent.setType("image/*");
startActivity(Intent.createChooser(shareIntent, null));

Upewnij się, że podane obiekty Uri wskazują do danych, do których aplikacja odbierająca ma dostęp.

Dodawanie bogatych treści do podglądów tekstu

Począwszy od Androida 10 (poziom interfejsu API 29) panel udostępniania Androida wyświetla podgląd udostępnianego tekstu. W niektórych przypadkach udostępniany tekst może być trudny do zrozumienia. Rozważ udostępnienie skomplikowany adres URL, np. https://www.google.com/search?ei=2rRVXcLkJajM0PEPoLy7oA4. Bardziej szczegółowy podgląd może pomóc użytkownikom zrozumieć, co jest udostępniane.

Jeśli wyświetlasz podgląd tekstu, możesz ustawić tytuł lub miniaturę lub oba te elementy. Dodaj opis do Intent.EXTRA_TITLE przed nawiązaniem połączenia z numerem Intent.createChooser() i dodaj odpowiednia miniatura za pomocą funkcji ClipData.

Uwaga: identyfikator URI zawartości obrazu jest pobierany z FileProvider, zwykle ze skonfigurowanego celu <cache-path>. Więcej informacji znajdziesz w artykule Udostępnianie plików. Pamiętaj, aby Arkusz udostępniania musi mieć odpowiednie uprawnienia do odczytu dowolnego obrazu, którego chcesz użyć jako miniatury. Aby dowiedzieć się więcej, zobacz Intent.FLAG_GRANT_READ_URI_PERMISSION.

Oto przykład:

KotlinJava
 val share = Intent.createChooser(Intent().apply {
      action = Intent.ACTION_SEND
      putExtra(Intent.EXTRA_TEXT, "https://developer.android.com/training/sharing/")

      // (Optional) Here you're setting the title of the content
      putExtra(Intent.EXTRA_TITLE, "Introducing content previews")

      // (Optional) Here you're passing a content URI to an image to be displayed
      data = contentUri
      flags = Intent.FLAG_GRANT_READ_URI_PERMISSION
  }, null)
  startActivity(share)
 
Intent sendIntent = new Intent(Intent.ACTION_SEND);
sendIntent.putExtra(Intent.EXTRA_TEXT, "https://developer.android.com/training/sharing/");

// (Optional) Here you're setting the title of the content
sendIntent.putExtra(Intent.EXTRA_TITLE, "Introducing content previews");

// (Optional) Here you're passing a content URI to an image to be displayed
sendIntent.setData(contentUri);
sendIntent.setFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);

// Show the Sharesheet
startActivity(Intent.createChooser(sendIntent, null));

Podgląd wygląda mniej więcej tak:

Dodawanie działań niestandardowych do arkusza udostępniania

Zrzut ekranu pokazujący działania niestandardowe w arkuszu udostępniania Androida.

W Androidzie 14 (poziom interfejsu API 34) i nowszych aplikacje mogą dodawać niestandardowe działania do panelu udostępniania. Działania niestandardowe są wyświetlane jako małe ikony u góry arkusza udostępniania Androida. może określać dowolne Intent jako działanie wywoływane po kliknięciu ikony.

Aby dodać niestandardowe działania w arkuszu udostępniania Androida, najpierw utwórz ChooserAction z ChooserAction.Builder Możesz określić PendingIntent jako działanie wywoływane po kliknięciu ikony. Utwórz tablicę zawierającą wszystkie działania niestandardowe i wskaż ją jako EXTRA_CHOOSER_CUSTOM_ACTIONS of the share Intent.

KotlinJava
val sendIntent = Intent(Intent.ACTION_SEND)
    .setType("text/plain")
    .putExtra(Intent.EXTRA_TEXT, text)
val shareIntent = Intent.createChooser(sendIntent, null)
val customActions = arrayOf(
    ChooserAction.Builder(
        Icon.createWithResource(context, R.drawable.ic_custom_action),
        "Custom",
        PendingIntent.getBroadcast(
            context,
            1,
            Intent(Intent.ACTION_VIEW),
            PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_CANCEL_CURRENT
        )
    ).build()
)
shareIntent.putExtra(Intent.EXTRA_CHOOSER_CUSTOM_ACTIONS, customActions)
context.startActivity(shareIntent)
 
Intent sendIntent = new Intent(Intent.ACTION_SEND)
        .setType("text.plain")
        .putExtra(Intent.EXTRA_TEXT, text);
Intent shareIntent = Intent.createChooser(sendIntent, null);
ChooserAction[] actions = new ChooserAction[]{
        new ChooserAction.Builder(
                Icon.createWithResource(context, R.drawable.ic_custom_action),
                "Custom",
                PendingIntent.getBroadcast(
                        context,
                        1,
                        new Intent(Intent.ACTION_VIEW),
                        PendingIntent.FLAG_IMMUTABLE | PendingIntent.FLAG_CANCEL_CURRENT
                )
        ).build()
};
shareIntent.putExtra(Intent.EXTRA_CHOOSER_CUSTOM_ACTIONS, actions);
context.startActivity(shareIntent);

Dodawanie celów niestandardowych

Arkusz udostępniania Androida pozwala określić maksymalnie 2 obiekty ChooserTarget, które są wyświetlane przed wczytaniem skrótów udostępniania i celów wyboru z ChooserTargetServices. Możesz też określ maksymalnie 2 intencje wskazujące działania, które znajdują się na liście przed sugestiami aplikacji:

Dodaj Intent.EXTRA_CHOOSER_TARGETS i Intent.EXTRA_INITIAL_INTENTS do swojej intencji udostępniania po wywołaniu Intent.createChooser():

KotlinJava
val share = Intent.createChooser(myShareIntent, null).apply {
    putExtra(Intent.EXTRA_CHOOSER_TARGETS, myChooserTargetArray)
    putExtra(Intent.EXTRA_INITIAL_INTENTS, myInitialIntentArray)
}
 
Intent shareIntent = Intent.createChooser(sendIntent, null);
share.putExtra(Intent.EXTRA_CHOOSER_TARGETS, myChooserTargetArray);
share.putExtra(Intent.EXTRA_INITIAL_INTENTS, myInitialIntentArray);

Korzystaj z tej funkcji z rozwagą. Co niestandardowe: Intent i ChooserTarget, które dodasz, zmniejszy liczbę sugerowaną przez system. Zasadniczo Odradzamy dodawanie niestandardowych celów. Typowym przykładem dodawania funkcji Intent.EXTRA_INITIAL_INTENTS pozwala użytkownikom na wykonywanie dodatkowych działań na udostępnionych treści. Na przykład użytkownik udostępnia obrazy, a usługa Intent.EXTRA_INITIAL_INTENTS jest używana do: wystarczy wysłać link. Typowy przykład dodawania elementu Intent.EXTRA_CHOOSER_TARGETS jest prezentacja odpowiednich osób lub urządzeń oferowanych przez Twoją aplikację.

Wykluczanie określonych elementów docelowych na podstawie komponentu

Możesz wykluczyć określone miejsca docelowe, podając Intent.EXTRA_EXCLUDE_COMPONENTS. Wykonuj tę czynność tylko wtedy, gdy chcesz usunąć cele, nad którymi masz kontrolę. Typowym przypadkiem użycia jest ukrywanie docelowych elementów do udostępniania w aplikacji, gdy użytkownicy udostępniają treści z poziomu aplikacji, ponieważ prawdopodobnie chcą udostępnić je poza aplikacją.

Dodaj element Intent.EXTRA_EXCLUDE_COMPONENTS do intencji po wywołaniu usługi Intent.createChooser():

KotlinJava
  val share = Intent.createChooser(Intent(), null).apply {
    // Only use for components you have control over
    val excludedComponentNames = arrayOf(ComponentName("com.example.android", "ExampleClass"))
    putExtra(Intent.EXTRA_EXCLUDE_COMPONENTS, excludedComponentNames)
  }
 
  Intent shareIntent = Intent.createChooser(new Intent(), null);
  // Only use for components you have control over
  ComponentName[] excludedComponentNames = {
          new ComponentName("com.example.android", "ExampleClass")
  };
  shareIntent.putExtra(Intent.EXTRA_EXCLUDE_COMPONENTS, excludedComponentNames);

Informacje o udostępnianiu

Warto wiedzieć, kiedy użytkownicy udostępniają treści i jakie cele wybierają. Android Sharesheet umożliwia uzyskanie tych informacji przez podanie ComponentName są kierowane na wybranych użytkowników za pomocą tagu IntentSender.

Najpierw utwórz PendingIntent dla obiektu BroadcastReceiver i podaj jego IntentSender w Intent.createChooser():

KotlinJava
var share = Intent(Intent.ACTION_SEND)
// ...
val pi = PendingIntent.getBroadcast(
    myContext, requestCode,
    Intent(myContext, MyBroadcastReceiver::class.java),
    PendingIntent.FLAG_MUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
)
share = Intent.createChooser(share, null, pi.intentSender)
 
Intent share = new Intent(ACTION_SEND);
...
PendingIntent pi = PendingIntent.getBroadcast(myContext, requestCode,
        new Intent(myContext, MyBroadcastReceiver.class),
        PendingIntent.FLAG_MUTABLE | PendingIntent.FLAG_UPDATE_CURRENT);
share = Intent.createChooser(share, null, pi.getIntentSender());

Odbierz wywołanie zwrotne w MyBroadcastReceiver i sprawdź Intent.EXTRA_CHOSEN_COMPONENT:

KotlinJava
override fun onReceive(context: Context, intent: Intent) {
  ...
  val clickedComponent : ComponentName = intent.getParcelableExtra(EXTRA_CHOSEN_COMPONENT);
}
 
@Override public void onReceive(Context context, Intent intent) {
  ...
  ComponentName clickedComponent = intent.getParcelableExtra(EXTRA_CHOSEN_COMPONENT);
}

Dodawanie działań niestandardowych do arkusza udostępniania

W Androidzie 14 (poziom interfejsu API 34) i nowszych aplikacje mogą dodawać niestandardowe działania do panelu udostępniania. Utwórz ChooserAction za pomocą ChooserAction.Builder. Jako działanie wywoływane po kliknięciu ikony możesz określić PendingIntent. Utwórz tablicę zawierającą wszystkie działania niestandardowe i określoną jako EXTRA_CHOOSER_CUSTOM_ACTIONS udziału Intent.

KotlinJava
val sendIntent = Intent(Intent.ACTION_SEND)
    .setType("text/plain")
    .putExtra(Intent.EXTRA_TEXT, text)
val shareIntent = Intent.createChooser(sendIntent, null)
val customActions = arrayOf(
    ChooserAction.Builder(
        Icon.createWithResource(context, R.drawable.ic_custom_action),
        "Custom",
        PendingIntent.getBroadcast(
            context,
            1,
            Intent(Intent.ACTION_VIEW),
            PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_CANCEL_CURRENT
        )
    ).build()
)
shareIntent.putExtra(Intent.EXTRA_CHOOSER_CUSTOM_ACTIONS, customActions)
context.startActivity(shareIntent)
 
Intent sendIntent = new Intent(Intent.ACTION_SEND)
        .setType("text.plain")
        .putExtra(Intent.EXTRA_TEXT, text);
Intent shareIntent = Intent.createChooser(sendIntent, null);
ChooserAction[] actions = new ChooserAction[]{
        new ChooserAction.Builder(
                Icon.createWithResource(context, R.drawable.ic_custom_action),
                "Custom",
                PendingIntent.getBroadcast(
                        context,
                        1,
                        new Intent(Intent.ACTION_VIEW),
                        PendingIntent.FLAG_IMMUTABLE | PendingIntent.FLAG_CANCEL_CURRENT
                )
        ).build()
};
shareIntent.putExtra(Intent.EXTRA_CHOOSER_CUSTOM_ACTIONS, actions);
context.startActivity(shareIntent);

Używanie rozwiązywania intencji na Androidzie

Zrzut ekranu pokazujący resolver intencji ACTION_SEND.

Rozpoznawanie intencji w Androidzie najlepiej sprawdza się podczas wysyłania danych do innej aplikacji w ramach dobrze zdefiniowanego przepływu zadań.

Aby użyć rozwiązywania intencji na Androidzie, utwórz intencję i dodaj dodatkowe elementy tak, jak w przypadku wywołania panelu udostępniania na Androidzie. Nie dzwoń do numeru Intent.createChooser().

Jeśli masz wiele zainstalowanych aplikacji z pasującymi filtrami ACTION_SEND a typ MIME, system wyświetli okno ujednoznacznienia o nazwie intent resolver. który pozwala użytkownikowi wybrać docelowy obszar udostępniania. Jeśli pasuje do niej tylko jedna aplikacja, zostanie uruchomiona.

Oto przykład użycia rozwiązywania intencji w Androidzie do wysyłania tekstu:

KotlinJava
val sendIntent: Intent = Intent().apply {
    action = Intent.ACTION_SEND
    putExtra(Intent.EXTRA_TEXT, "This is my text to send.")
    type = "text/plain"
}
startActivity(sendIntent)
 
Intent sendIntent = new Intent();
sendIntent.setAction(Intent.ACTION_SEND);
sendIntent.putExtra(Intent.EXTRA_TEXT, "This is my text to send.");
sendIntent.setType("text/plain");
startActivity(sendIntent);

Więcej informacji

Więcej informacji o wysyłaniu danych znajdziesz w artykule Intencje i filtry intencji.

Dalej
Odbieranie prostych danych z innych aplikacji