Dodaj zaawansowane funkcje do swojej aplikacji na Androida

Przerwy na reklamy

Pakiet Android Sender SDK zapewnia obsługę przerw na reklamy i reklam towarzyszących danego strumienia multimediów.

Zobacz Omówienie przerw na reklamy w odbiorniku internetowym, aby dowiedzieć się więcej jak działają przerwy na reklamę.

Chociaż przerwy można określić zarówno u nadawcy, jak i u odbiorcy, zalecamy, aby były one określone na odbiorniku internetowym oraz Odbiornik Android TV, aby zachować spójność zachowania użytkowników na różnych platformach.

W Androidzie przerwy na reklamę należy określić w poleceniu ładowania za pomocą: AdBreakClipInfo i AdBreakInfo:

Kotlin
val breakClip1: AdBreakClipInfo =
    AdBreakClipInfo.Builder("bc0")
        .setTitle("Clip title")
        .setPosterUrl("https://www.some.url")
        .setDuration(60000)
        .setWhenSkippableInMs(5000)  // Set this field so that the ad is skippable
        .build()

val breakClip2: AdBreakClipInfo = …
val breakClip3: AdBreakClipInfo = …

val break1: AdBreakClipInfo =
    AdBreakInfo.Builder(/* playbackPositionInMs= */ 10000)
        .setId("b0")
        .setBreakClipIds({"bc0","bc1","bc2"})
        …
        .build()

val mediaInfo: MediaInfo = MediaInfo.Builder()
    …
    .setAdBreaks({break1})
    .setAdBreakClips({breakClip1, breakClip2, breakClip3})
    .build()

val mediaLoadRequestData: MediaLoadRequestData = MediaInfo.Builder()
    …
    .setMediaInfo(mediaInfo)
    .build()

remoteMediaClient.load(mediaLoadRequestData)
Java
AdBreakClipInfo breakClip1 =
    new AdBreakClipInfo.Builder("bc0")
        .setTitle("Clip title")
        .setPosterUrl("https://www.some.url")
        .setDuration(60000)
        .setWhenSkippableInMs(5000)  // Set this field so that the ad is skippable
        .build();

AdBreakClipInfo breakClip2 = …
AdBreakClipInfo breakClip3 = …

AdBreakInfo break1 =
    new AdBreakInfo.Builder(/* playbackPositionInMs= */ 10000)
        .setId("b0")
        .setBreakClipIds({"bc0","bc1","bc2"})
        …
        .build();

MediaInfo mediaInfo = new MediaInfo.Builder()
    …
    .setAdBreaks({break1})
    .setAdBreakClips({breakClip1, breakClip2, breakClip3})
    .build();

MediaLoadRequestData mediaLoadRequestData = new MediaInfo.Builder()
    …
    .setMediaInfo(mediaInfo)
    .build();

remoteMediaClient.load(mediaLoadRequestData);

Dodaj działania niestandardowe

Aplikacja nadawcy może rozszerzać zasięg MediaIntentReceiver obsługi niestandardowych działań lub zastępowania ich działania. Jeśli masz zaimplementowane MediaIntentReceiver, musisz dodać go do pliku manifestu i ustawić także w polu CastMediaOptions. Ten przykład pokazuje niestandardowe działania, które zastępowanie zdalnego odtwarzania multimediów, naciśnięcie przycisku multimediów i innych typów działań.

// In AndroidManifest.xml
<receiver android:name="com.example.MyMediaIntentReceiver" />
Kotlin
// In your OptionsProvider
var mediaOptions = CastMediaOptions.Builder()
    .setMediaIntentReceiverClassName(MyMediaIntentReceiver::class.java.name)
    .build()

// Implementation of MyMediaIntentReceiver
internal class MyMediaIntentReceiver : MediaIntentReceiver() {
    override fun onReceiveActionTogglePlayback(currentSession: Session) {
    }

    override fun onReceiveActionMediaButton(currentSession: Session, intent: Intent) {
    }

    override fun onReceiveOtherAction(context: Context?, action: String, intent: Intent) {
    }
}
Java
// In your OptionsProvider
CastMediaOptions mediaOptions = new CastMediaOptions.Builder()
        .setMediaIntentReceiverClassName(MyMediaIntentReceiver.class.getName())
        .build();

// Implementation of MyMediaIntentReceiver
class MyMediaIntentReceiver extends MediaIntentReceiver {
    @Override
    protected void onReceiveActionTogglePlayback(Session currentSession) {
    }

    @Override
    protected void onReceiveActionMediaButton(Session currentSession, Intent intent) {
    }

    @Override
    protected void onReceiveOtherAction(Context context, String action, Intent intent) {
    }
}

Dodawanie kanału niestandardowego

Aby aplikacja nadawcy mogła komunikować się z aplikacją adresata, musi ona spełniać te warunki: utworzyć kanał niestandardowy. Nadawca może użyć kanału niestandardowego do wysyłania ciągu tekstowego wiadomości do odbiorcy. Każdy kanał niestandardowy jest definiowany przez i musi zaczynać się od prefiksu urn:x-cast:, na przykład urn:x-cast:com.example.custom Istnieje możliwość skonfigurowania wielu niestandardowych komponentów z unikalną przestrzenią nazw. Aplikacja odbiornika może też wysyłanie i odbieranie wiadomości przy użyciu tej samej przestrzeni nazw.

Kanał niestandardowy jest zaimplementowany za pomocą Cast.MessageReceivedCallback interfejs:

Kotlin
class HelloWorldChannel : MessageReceivedCallback {
    val namespace: String
        get() = "urn:x-cast:com.example.custom"

    override fun onMessageReceived(castDevice: CastDevice, namespace: String, message: String) {
        Log.d(TAG, "onMessageReceived: $message")
    }
}
Java
class HelloWorldChannel implements Cast.MessageReceivedCallback {
    public String getNamespace() {
        return "urn:x-cast:com.example.custom";
    }
    @Override
    public void onMessageReceived(CastDevice castDevice, String namespace, String message) {
        Log.d(TAG, "onMessageReceived: " + message);
    }
}

Gdy aplikacja nadawcy połączy się z aplikacją adresata, kanał niestandardowy utworzona za pomocą setMessageReceivedCallbacks :

Kotlin
try {
    mCastSession.setMessageReceivedCallbacks(
        mHelloWorldChannel.namespace,
        mHelloWorldChannel)
} catch (e: IOException) {
    Log.e(TAG, "Exception while creating channel", e)
}
Java
try {
    mCastSession.setMessageReceivedCallbacks(
            mHelloWorldChannel.getNamespace(),
            mHelloWorldChannel);
} catch (IOException e) {
    Log.e(TAG, "Exception while creating channel", e);
}

Po utworzeniu kanału niestandardowego nadawca może użyć funkcji sendMessage , która pozwala wysłać za pomocą tego kanału komunikaty z ciągiem znaków do odbiorcy:

Kotlin
private fun sendMessage(message: String) {
    if (mHelloWorldChannel != null) {
        try {
            mCastSession.sendMessage(mHelloWorldChannel.namespace, message)
                .setResultCallback { status ->
                    if (!status.isSuccess) {
                        Log.e(TAG, "Sending message failed")
                    }
                }
        } catch (e: Exception) {
            Log.e(TAG, "Exception while sending message", e)
        }
    }
}
Java
private void sendMessage(String message) {
    if (mHelloWorldChannel != null) {
        try {
            mCastSession.sendMessage(mHelloWorldChannel.getNamespace(), message)
                .setResultCallback( status -> {
                    if (!status.isSuccess()) {
                        Log.e(TAG, "Sending message failed");
                    }
                });
        } catch (Exception e) {
            Log.e(TAG, "Exception while sending message", e);
        }
    }
}

Obsługa autoodtwarzania

Więcej informacji znajdziesz w sekcji Autoodtwarzanie API do kolejkowania.

Zastępowanie wyboru obrazów w widżetach UX

Różne komponenty platformy (takie jak okno Cast, mini a kontroler UIMediaController, jeśli został skonfigurowany) dotyczące aktualnie przesyłanych multimediów. Adresy URL grafiki grafiki są zwykle zawarte w polu MediaMetadata dla multimediów, ale aplikacja nadawcy może mieć tag alternatywnego źródła adresów URL.

ImagePicker klasa określa sposób wyboru odpowiedniego obrazu z listy obrazów w MediaMetadata, na podstawie użycia obrazu, np. powiadomienia miniatury lub pełnego ekranu. Domyślna implementacja ImagePicker zawsze wybiera pierwszy obraz lub zwraca wartość null, jeśli w MediaMetadata Aplikacja może podklasa ImagePicker i zastępować onPickImage(MediaMetadata, ImageHints) aby udostępnić alternatywną implementację, a następnie wybierz tę podklasę z setImagePicker metody CastMediaOptions.Builder. ImageHints informuje ImagePicker o typie i rozmiarze obrazu, który ma zostać użyty wybrany do wyświetlenia w interfejsie użytkownika.

Dostosowywanie okien przesyłania

Zarządzanie cyklem życia sesji

SessionManager to centralne miejsce do zarządzania cyklem życia sesji. SessionManager odsłuchanie na Androida MediaRouter Stan wyboru trasy zmienia się na rozpoczęcie, wznawianie i zakończenie sesji. Gdy trasa jest zaznaczono, SessionManager utworzy Session i próbuje go uruchomić lub wznowić. Gdy nie wybierzesz trasy, Aplikacja SessionManager zakończy bieżącą sesję.

Dlatego, aby mieć pewność, że SessionManager zarządza cyklami życia sesji prawidłowo, musi zapewnić, że:

W zależności od sposobu tworzenia okien przesyłania konieczne może być wykonanie dodatkowych czynności. gotowe:

Stan zero urządzeń

Jeśli tworzysz niestandardowe okna przesyłania, Funkcja MediaRouteChooserDialog powinna prawidłowo obsługiwać przypadek braku urządzeń . Okno powinno zawierać wskaźniki jasno wskazujące użytkownikom, aplikacja nadal próbuje znaleźć urządzenia, ale próba wykrycia zakończy się niepowodzeniem są dłużej aktywne.

Jeśli używasz domyślnego ustawienia MediaRouteChooserDialog, stan zero urządzeń jest już obsługiwany.

Dalsze kroki

To już wszystkie funkcje, które możesz dodać do aplikacji Android Sender. Teraz możesz utworzyć aplikację nadawcy dla innej platformy (iOS lub w przeglądarce) albo utwórz aplikację Web Receiver.

Wstecz
Przełącznik wyjścia
Dalej
Integracja z ExoPlayer