Omówienie MediaRouter

Aby używać platformy MediaRouter w aplikacji, musisz uzyskać instancję obiektu MediaRouter i dołączyć obiekt MediaRouter.Callback, który będzie nasłuchiwać zdarzeń routingu. Treści wysyłane przez trasę multimedialną przechodzą przez powiązany z nią obiekt MediaRouteProvider (z wyjątkiem kilku szczególnych przypadków, takich jak urządzenie wyjściowe Bluetooth). Rysunek 1 przedstawia ogólny widok klas używanych do kierowania treści między urządzeniami.

Rysunek 1. Omówienie najważniejszych klas routera multimediów używanych przez aplikacje.

Uwaga: jeśli chcesz, aby Twoja aplikacja obsługiwała urządzenia Google Cast, użyj pakietu Cast SDK i utwórz aplikację jako nadawcę Cast. Zamiast używać bezpośrednio platformy MediaRouter, postępuj zgodnie ze wskazówkami podanymi w dokumentacji Cast.

Przycisk trasy multimediów

Aplikacje na Androida powinny używać przycisku trasy multimediów do sterowania routingiem multimediów. Platforma MediaRouter udostępnia standardowy interfejs przycisku, który pomaga użytkownikom rozpoznawać i używać routingu, gdy jest on dostępny. Przycisk trasy multimediów jest zwykle umieszczany po prawej stronie paska działań aplikacji, jak pokazano na rysunku 2.

Rysunek 2. Przycisk trasy multimediów na pasku działań.

Gdy użytkownik naciśnie przycisk trasy multimediów, dostępne trasy multimediów pojawią się na liście, jak pokazano na rysunku 3.

Rysunek 3. Lista dostępnych tras multimediów, która wyświetla się po naciśnięciu przycisku trasy multimediów.

Aby utworzyć przycisk trasy multimediów, wykonaj te czynności:

  1. Używanie AppCompatActivity
  2. Definiowanie elementu menu przycisku trasy multimediów
  3. Tworzenie MediaRouteSelector
  4. Dodawanie przycisku trasy multimediów do paska działań
  5. tworzyć metody MediaRouter.Callback i zarządzać nimi w cyklu życia aktywności;

W tej sekcji opisano pierwsze 4 kroki. W następnej sekcji opisujemy metody wywołania zwrotnego.

Używanie AppCompatActivity

Jeśli używasz platformy Media Router w aktywności, musisz rozszerzyć aktywność z AppCompatActivity i zaimportować pakiet androidx.appcompat.app. Do projektu aplikacji musisz dodać biblioteki obsługi androidx.appcompat:appcompat i androidx.mediarouter:mediarouter. Więcej informacji o dodawaniu bibliotek pomocy do projektu znajdziesz w artykule Pierwsze kroki z Androidem Jetpack.

Uwaga: pamiętaj, aby używać implementacji androidx platformy Media Router. Nie używaj starszego pakietu android.media.

Utwórz plik XML, który definiuje element menu dla przycisku trasy multimediów. Działanie elementu powinno być klasą MediaRouteActionProvider. Oto przykładowy plik:

<menu xmlns:android="http://schemas.android.com/apk/res/android"
      xmlns:app="http://schemas.android.com/apk/res-auto"
      >

    <item android:id="@+id/media_route_menu_item"
        android:title="@string/media_route_menu_title"
        app:actionProviderClass="androidx.mediarouter.app.MediaRouteActionProvider"
        app:showAsAction="always"
    />
</menu>

Tworzenie MediaRouteSelector

Trasy, które pojawiają się w menu przycisku trasy multimediów, są określane przez MediaRouteSelector. Rozszerz aktywność z AppCompatActivity i utwórz selektor, gdy aktywność zostanie utworzona, wywołując MediaRouteSelector.Builder z metody onCreate(), jak pokazano w tym przykładowym kodzie. Zwróć uwagę, że selektor jest zapisywany w zmiennej klasy, a dozwolone typy tras są określane przez dodanie obiektów MediaControlIntent:

class MediaRouterPlaybackActivity : AppCompatActivity() {

    private var mSelector: MediaRouteSelector? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // Create a route selector for the type of routes your app supports.
        mSelector = MediaRouteSelector.Builder()
            // These are the framework-supported intents.
            .addControlCategory(MediaControlIntent.CATEGORY_REMOTE_PLAYBACK)
            .build()
    }
}

W przypadku większości aplikacji jedynym potrzebnym typem trasy jest CATEGORY_REMOTE_PLAYBACK. Ten typ trasy traktuje urządzenie, na którym działa aplikacja, jako pilota. Połączone urządzenie odbiorcze obsługuje pobieranie, dekodowanie i odtwarzanie wszystkich danych treści. W ten sposób działają aplikacje obsługujące Google Cast, takie jak Chromecast.

Niektórzy producenci obsługują specjalną opcję routingu o nazwie „wyjście dodatkowe”. Dzięki temu routingowi aplikacja do multimediów pobiera, renderuje i przesyła strumieniowo filmy lub muzykę bezpośrednio na ekran lub głośniki wybranego zdalnego urządzenia odbiorczego. Użyj dodatkowego wyjścia, aby wysyłać treści do systemów muzycznych lub wyświetlaczy wideo z obsługą łączności bezprzewodowej. Aby umożliwić wykrywanie i wybieranie tych urządzeń, musisz dodać do MediaRouteSelector kategorie sterowania CATEGORY_LIVE_AUDIO lub CATEGORY_LIVE_VIDEO. Musisz też utworzyć własne okno Presentation i obsługiwać je.

Dodawanie przycisku trasy multimediów do paska działań

Po zdefiniowaniu menu trasy multimediów i selektora MediaRouteSelector możesz dodać przycisk trasy multimediów do aktywności. Zastąp metodę onCreateOptionsMenu() dla każdej aktywności, aby dodać menu opcji.

override fun onCreateOptionsMenu(menu: Menu): Boolean {
    super.onCreateOptionsMenu(menu)

    // Inflate the menu and configure the media router action provider.
    menuInflater.inflate(R.menu.sample_media_router_menu, menu)

    // Attach the MediaRouteSelector to the menu item.
    val mediaRouteMenuItem = menu.findItem(R.id.media_route_menu_item)
    val mediaRouteActionProvider =
        MenuItemCompat.getActionProvider(mediaRouteMenuItem) as MediaRouteActionProvider

    // Attach the MediaRouteSelector that you built in onCreate().
    selector?.also(mediaRouteActionProvider::setRouteSelector)

    // Return true to show the menu.
    return true
}

Więcej informacji o wdrażaniu paska działań w aplikacji znajdziesz w przewodniku dla programistów.

Możesz też dodać przycisk trasy multimediów jako MediaRouteButton w dowolnym widoku. Musisz dołączyć MediaRouteSelector do przycisku za pomocą metody setRouteSelector(). Wskazówki dotyczące dodawania przycisku trasy multimediów do aplikacji znajdziesz na liście kontrolnej projektowania Google Cast.

Wywołania zwrotne MediaRouter

Wszystkie aplikacje działające na tym samym urządzeniu współdzielą jedną instancję MediaRouter i jej trasy (filtrowane według aplikacji przez MediaRouteSelector aplikacji). Każda aktywność komunikuje się z MediaRouterem za pomocą własnej implementacji metod MediaRouter.Callback. MediaRouter wywołuje metody wywołania zwrotnego, gdy użytkownik wybierze, zmieni lub rozłączy trasę.

W wywołaniu zwrotnym jest kilka metod, które możesz zastąpić, aby otrzymywać informacje o zdarzeniach routingu. Twoja implementacja klasy MediaRouter.Callback powinna co najmniej zastępować metody onRouteSelected() i onRouteUnselected().

MediaRouter jest zasobem udostępnionym, więc aplikacja musi zarządzać wywołaniami zwrotnymi MediaRouter w odpowiedzi na zwykłe wywołania zwrotne cyklu życia działania:

  • Po utworzeniu aktywności (onCreate(Bundle)) pobierz wskaźnik do MediaRouter i zachowaj go przez cały okres działania aplikacji.
  • Dołącz wywołania zwrotne do MediaRouter, gdy aktywność stanie się widoczna (onStart()), i odłącz je, gdy zostanie ukryta (onStop()).

Poniższy przykładowy kod pokazuje, jak utworzyć i zapisać obiekt wywołania zwrotnego, jak uzyskać instancję MediaRouter i jak zarządzać wywołaniami zwrotnymi. Zwróć uwagę na użycie flagi CALLBACK_FLAG_REQUEST_DISCOVERY podczas dołączania wywołań zwrotnych w onStart(). Dzięki temu MediaRouteSelector może odświeżyć listę dostępnych tras przycisku trasy multimediów.

class MediaRouterPlaybackActivity : AppCompatActivity() {

    private var mediaRouter: MediaRouter? = null
    private var mSelector: MediaRouteSelector? = null

    // Variables to hold the currently selected route and its playback client.
    private var mRoute: MediaRouter.RouteInfo? = null
    private var remotePlaybackClient: RemotePlaybackClient? = null

    // Define the Callback object and its methods, save the object in a class variable.
    private val mediaRouterCallback = object : MediaRouter.Callback() {

        override fun onRouteSelected(
            router: MediaRouter,
            route: MediaRouter.RouteInfo,
            reason: Int
        ) {
            Log.d(TAG, "onRouteSelected: route=$route")
            if (route.supportsControlCategory(MediaControlIntent.CATEGORY_REMOTE_PLAYBACK)) {
                // Stop local playback (if necessary).
                // ...

                // Save the new route.
                mRoute = route

                // Attach a new playback client.
                remotePlaybackClient =
                    RemotePlaybackClient(this@MediaRouterPlaybackActivity, route)

                // Start remote playback (if necessary).
                // ...
            }
        }

        override fun onRouteUnselected(
            router: MediaRouter,
            route: MediaRouter.RouteInfo,
            reason: Int
        ) {
            Log.d(TAG, "onRouteUnselected: route=$route")
            if (route.supportsControlCategory(MediaControlIntent.CATEGORY_REMOTE_PLAYBACK)) {

                // Changed route: tear down previous client.
                mRoute?.also {
                    remotePlaybackClient?.release()
                    remotePlaybackClient = null
                }

                // Save the new route.
                mRoute = route

                when {
                    reason != MediaRouter.UNSELECT_REASON_ROUTE_CHANGED -> {
                        // Resume local playback (if necessary).
                        // ...
                    }
                }
            }
        }
    }

    // Retain a pointer to the MediaRouter.
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // Get the media router service.
        mediaRouter = MediaRouter.getInstance(this)
        // ...
    }

    // Use this callback to run your MediaRouteSelector to generate the
    // list of available media routes.
    override fun onStart() {
        mSelector?.also { selector ->
            mediaRouter?.addCallback(
                selector, mediaRouterCallback,
                MediaRouter.CALLBACK_FLAG_REQUEST_DISCOVERY
            )
        }
        super.onStart()
    }

    // Remove the selector on stop to tell the media router that it no longer
    // needs to discover routes for your app.
    override fun onStop() {
        mediaRouter?.removeCallback(mediaRouterCallback)
        super.onStop()
    }
    // ...
}

Platforma routera multimediów udostępnia też klasę MediaRouteDiscoveryFragment, która zajmuje się dodawaniem i usuwaniem wywołania zwrotnego aktywności.

Uwaga: jeśli tworzysz aplikację do odtwarzania muzyki i chcesz, aby odtwarzała muzykę, gdy działa w tle, musisz utworzyć Service do odtwarzania i wywołać platformę routera multimediów z wywołań zwrotnych cyklu życia usługi.

Sterowanie zdalną trasą odtwarzania

Gdy wybierzesz zdalną ścieżkę odtwarzania, aplikacja będzie działać jako pilot. Urządzenie na drugim końcu trasy obsługuje wszystkie funkcje pobierania, dekodowania i odtwarzania treści. Elementy sterujące w interfejsie aplikacji komunikują się z urządzeniem odbiorczym za pomocą obiektu RemotePlaybackClient.

Klasa RemotePlaybackClient udostępnia dodatkowe metody zarządzania odtwarzaniem treści. Oto kilka najważniejszych metod odtwarzania z klasy RemotePlaybackClient:

  • play() – odtwarzanie konkretnego pliku multimedialnego określonego przez Uri.
  • pause() – wstrzymaj odtwarzanie bieżącego utworu.
  • resume() – kontynuuj odtwarzanie bieżącego utworu po poleceniu wstrzymania.
  • seek() – przejdź do określonej pozycji w bieżącym utworze.
  • release() – rozłączanie aplikacji z urządzeniem do zdalnego odtwarzania.

Za pomocą tych metod możesz dołączać działania do elementów sterujących odtwarzaniem, które udostępniasz w aplikacji. Większość z nich umożliwia też dołączenie obiektu wywołania zwrotnego, dzięki czemu możesz monitorować postęp zadania odtwarzania lub żądania sterowania.

Klasa RemotePlaybackClient obsługuje też kolejkowanie wielu elementów multimedialnych do odtwarzania i zarządzanie kolejką multimediów.

Przykładowy kod

Przykłady Android BasicMediaRouter i MediaRouter pokazują, jak korzystać z interfejsu MediaRouter API.