Cette page a été traduite par l'API Cloud Translation.

Ajouter des fonctionnalités avancées à votre application Android

Coupures publicitaires

Le SDK Android Sender est compatible avec les coupures publicitaires et les annonces associées dans un flux multimédia donné.

Pour en savoir plus sur le fonctionnement des coupures publicitaires, consultez la présentation des coupures publicitaires du Web Receiver.

Bien que les coupures puissent être spécifiées à la fois sur l'émetteur et le récepteur, il est recommandé de les spécifier sur le récepteur Web et le récepteur Android TV afin de maintenir un comportement cohérent sur les plates-formes.

Sur Android, spécifiez les coupures publicitaires dans une commande de chargement à l'aide de AdBreakClipInfo et 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);

Ajouter des actions personnalisées

Une application d'expéditeur peut étendre MediaIntentReceiver pour gérer des actions personnalisées ou remplacer son comportement. Si vous avez implémenté votre propre MediaIntentReceiver, vous devez l'ajouter au fichier manifeste et définir son nom dans CastMediaOptions. Cet exemple fournit des actions personnalisées qui remplacent l'activation/la désactivation de la lecture multimédia à distance, l'appui sur le bouton multimédia et d'autres types d'actions.

// 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) {
    }
}

Ajouter un canal personnalisé

Pour que l'application d'envoi puisse communiquer avec l'application réceptrice, votre application doit créer un canal personnalisé. L'expéditeur peut utiliser le canal personnalisé pour envoyer des messages de chaîne au destinataire. Chaque canal personnalisé est défini par un espace de noms unique et doit commencer par le préfixe urn:x-cast:, par exemple urn:x-cast:com.example.custom. Vous pouvez avoir plusieurs canaux personnalisés, chacun avec un espace de noms unique. L'application destinataire peut également envoyer et recevoir des messages à l'aide du même espace de noms.

Le canal personnalisé est implémenté avec l'interface Cast.MessageReceivedCallback:

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);
    }
}

Une fois l'application d'envoi connectée à l'application de réception, le canal personnalisé peut être créé à l'aide de la méthode 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);
}

Une fois le canal personnalisé créé, l'expéditeur peut utiliser la méthode sendMessage pour envoyer des messages de chaîne au destinataire via ce canal:

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);
        }
    }
}

Prendre en charge la lecture automatique

Consultez la section API de lecture automatique et de mise en file d'attente.

Forcer la sélection d'une image pour les widgets d'expérience utilisateur

Divers composants du framework (à savoir la boîte de dialogue Cast, le mini-contrôleur et l'UIMediaController, le cas échéant) affichent l'illustration du contenu multimédia en cours de diffusion. Les URL des illustrations d'image sont généralement incluses dans le MediaMetadata du contenu multimédia, mais l'application d'envoi peut disposer d'une autre source pour les URL.

La classe ImagePicker définit un moyen de sélectionner une image appropriée dans la liste des images d'un MediaMetadata, en fonction de l'utilisation de l'image, par exemple une vignette de notification ou un arrière-plan en plein écran. L'implémentation par défaut de ImagePicker choisit toujours la première image ou renvoie la valeur nulle si aucune image n'est disponible dans MediaMetadata. Votre application peut sous-classer ImagePicker et remplacer la méthode onPickImage(MediaMetadata, ImageHints) pour fournir une autre implémentation, puis sélectionner cette sous-classe avec la méthode setImagePicker de CastMediaOptions.Builder. ImageHints fournit des indices à un ImagePicker sur le type et la taille d'une image à sélectionner pour l'afficher dans l'UI.

Personnaliser les boîtes de dialogue Cast

Gérer le cycle de vie des sessions

SessionManager est l'emplacement central pour gérer le cycle de vie des sessions. SessionManager écoute les modifications de l'état de sélection d'itinéraire Android MediaRouter pour démarrer, reprendre et terminer les sessions. Lorsqu'un parcours est sélectionné, SessionManager crée un objet Session et tente de le démarrer ou de le reprendre. Lorsqu'un itinéraire est désélectionné, SessionManager met fin à la session en cours.

Par conséquent, pour vous assurer que SessionManager gère correctement les cycles de vie des sessions, vous devez vous assurer que:

Dans la boîte de dialogue de sélection de route, appelez MediaRouter.selectRoute(MediaRouter.RouteInfo) lorsqu'un utilisateur sélectionne un appareil.
Dans la boîte de dialogue du contrôleur de parcours (état connecté ou état de diffusion), appelez MediaRouter.unselect(int) lorsque l'utilisateur arrête la diffusion.

Selon la manière dont vous créez les boîtes de dialogue de diffusion, vous devrez peut-être effectuer d'autres actions:

Si vous créez des boîtes de dialogue Cast à l'aide de MediaRouteChooserDialog et de MediaRouteControllerDialog, elles mettront automatiquement à jour la sélection de l'itinéraire dans MediaRouter. Aucune action n'est donc requise.
Si vous configurez votre bouton Cast à l'aide de CastButtonFactory.setUpMediaRouteButton(Context, Menu, int) ou de CastButtonFactory.setUpMediaRouteButton(Context, MediaRouteButton), les boîtes de dialogue sont créées à l'aide de MediaRouteChooserDialog et de MediaRouteControllerDialog. Vous n'avez donc rien à faire.
Dans d'autres cas, vous allez créer des boîtes de dialogue Cast personnalisées. Vous devez donc suivre les instructions ci-dessus pour mettre à jour l'état de sélection de l'itinéraire dans MediaRouter.

État "Aucun appareil"

Si vous créez des boîtes de dialogue Cast personnalisées, votre MediaRouteChooserDialog personnalisée doit gérer correctement le cas où aucun appareil n'est détecté. La boîte de dialogue doit comporter des indicateurs indiquant clairement aux utilisateurs quand votre application tente toujours de trouver des appareils et quand la tentative de découverte n'est plus active.

Si vous utilisez le MediaRouteChooserDialog par défaut, l'état "aucun appareil" est déjà géré.

Étapes suivantes

Vous avez terminé d'ajouter des fonctionnalités à votre application d'envoi Android. Vous pouvez maintenant créer une application d'envoi pour une autre plate-forme (iOS ou Web) ou une application de réception Web.

Sélecteur de sortie

Intégration d'ExoPlayer