ApsaraVideo VOD:Système de stratégies

Qu'est-ce qu'un système de stratégies ?

Le système de stratégies est un mécanisme architectural qui unifie la gestion des composants de stratégie. Il est responsable du mécanisme d'enregistrement des stratégies, de la gestion du cycle de vie, de l'injection de contexte et de l'abonnement aux événements. Il gère également la création, le démarrage, la pause, la réinitialisation et la destruction des stratégies pendant l'exécution du lecteur. Grâce à ce mécanisme, les développeurs peuvent activer ou désactiver les stratégies selon leurs besoins, mettre en œuvre rapidement des politiques personnalisées ou remplacer complètement les stratégies par défaut pour répondre aux besoins de personnalisation métier.

Qu'est-ce qu'une stratégie ?

Une stratégie est une unité encapsulée de logique métier du lecteur. Elle met en œuvre une capacité métier spécifique ou une logique personnalisée, telle que les statistiques de temps jusqu'à la première image (TTFF), la détection des saccades, la protection du trafic ou la reprise de la lecture.Caractéristiques principales :

• Responsabilité unique : se concentre sur un objectif fonctionnel indépendant.

• Piloté par les événements : répond au statut du lecteur via le bus d'événements.

• Indépendant et isolé : les stratégies n'interfèrent pas les unes avec les autres.

Grâce à une conception modulaire et composable, les capacités non essentielles sont abstraites en unités de stratégie. Cela maintient le cœur du lecteur simple tout en offrant des capacités d'extension flexibles.

Problèmes résolus

Le système de stratégies répond aux points de douleur suivants :

1. Maintenance difficile : la logique métier dispersée est difficile à maintenir et à réutiliser.

2. Absence de configuration : différents scénarios nécessitent différentes combinaisons de logique, mais il n'existe aucun mécanisme de configuration flexible.

3. Modification du code source : la logique personnalisée nécessite de modifier le code source du framework.

4. Interférence entre instances : dans les scénarios multi-lecteurs, la logique métier entre les instances peut interférer les unes avec les autres.

Valeur principale

Le système de stratégies abstrait et encapsule la logique de surveillance et d'analyse du lecteur. Il permet aux clients de configurer et de combiner les stratégies selon leurs besoins.

Avantages architecturaux :

• Découplage : les stratégies sont séparées de la logique centrale du lecteur, créant des responsabilités claires.

• Réutilisabilité : les stratégies peuvent être réutilisées sur différentes instances de lecteur.

• Extensibilité : vous pouvez personnaliser les stratégies sans modifier le framework.

• Isolation : les stratégies sont indépendantes et n'interfèrent pas les unes avec les autres.

Capacités principales

Politique de temps jusqu'à la première image (TTFF) (FirstFrameStrategy)

Cette stratégie calcule le temps nécessaire au lecteur pour passer de l'étape PREPARING au rendu de la première image. Elle est divisée en trois phases :

Scénarios : surveillance des performances, optimisation de l'expérience utilisateur et réglage du lecteur.

Politique de détection des saccades (StutterDetectStrategy)

Cette stratégie surveille les saccades pendant la lecture et collecte les statistiques de saccades :

Scénarios : surveillance de la qualité de lecture et analyse de l'expérience utilisateur.

Politique de protection du trafic (TrafficProtectionStrategy)

Cette stratégie écoute les changements d'état du réseau et notifie les utilisateurs dans des scénarios spécifiques :

Scénarios : scénarios sensibles au trafic et notifications conviviales.

Méthode 1 : Utiliser les stratégies intégrées

Il s'agit de la méthode la plus simple. Le composant lecteur enregistre automatiquement les stratégies par défaut :

// 1. Create a player controller. Default strategies are registered automatically.
AliPlayerController controller = new AliPlayerController(this);

// 2. Prepare the playback data.
AliPlayerModel model = new AliPlayerModel.Builder()
        .videoSource(videoSource)
        .build();

// 3. Configure the data model.
controller.configure(model);

// 4. Attach the controller to the view.
playerView.attach(controller);

Les stratégies enregistrées par défaut incluent les éléments suivants :

• FirstFrameStrategy (TTFF)

• StutterDetectStrategy (détection des saccades)

• TrafficProtectionStrategy (protection du trafic)

Méthode 2 : Personnaliser les stratégies

Enregistrez uniquement les stratégies dont vous avez besoin et désactivez les autres :

// 1. Create a player controller.
AliPlayerController controller = new AliPlayerController(this);

// 2. Get the strategy manager and clear the default strategies.
StrategyManager strategyManager = controller.getStrategyManager();

// 3. Register only the required strategies.
strategyManager.register(new FirstFrameStrategy());
strategyManager.register(new StutterDetectStrategy());

// 4. Prepare the playback data.
AliPlayerModel model = new AliPlayerModel.Builder()
        .videoSource(videoSource)
        .build();
controller.configure(model);
playerView.attach(controller);

Méthode 3 : Personnaliser entièrement les stratégies

Implémentez des politiques personnalisées pour créer un système de surveillance entièrement personnalisé :

// 1. Create a player controller.
AliPlayerController controller = new AliPlayerController(this);

// 2. Get the strategy manager.
StrategyManager strategyManager = controller.getStrategyManager();

// 3. Register custom policies.
strategyManager.register(new MyCustomStrategy());
strategyManager.register(new MyAnalyticsStrategy());

// 4. Prepare the playback data.
AliPlayerModel model = new AliPlayerModel.Builder()
        .videoSource(videoSource)
        .build();
controller.configure(model);
playerView.attach(controller);

Comment implémenter une politique personnalisée

AliPlayerKit propose deux méthodes d'implémentation. Choisissez celle qui correspond à vos besoins :

Méthode 1 : Hériter de BaseStrategy (recommandé)

L'héritage de BaseStrategy est la méthode la plus simple car le framework a déjà encapsulé l'abonnement aux événements et la gestion du cycle de vie.

Scénario : la plupart des stratégies de surveillance et d'analyse, telles que les statistiques, la détection et la journalisation.

1. Créez une classe de stratégie.

   Héritez de BaseStrategy et implémentez les méthodes nécessaires :

   public class MyAnalyticsStrategy extends BaseStrategy {
   
       private static final String TAG = "MyAnalyticsStrategy";
   
       @NonNull
       @Override
       public String getName() {
           return TAG;  // Return the policy name for logging and debugging.
       }
   
       @Nullable
       @Override
       protected List<Class<? extends PlayerEvent>> observedEvents() {
           // Declare the event types to subscribe to.
           return Arrays.asList(
               PlayerEvents.StateChanged.class,
               PlayerEvents.Prepared.class,
               PlayerEvents.Info.class
           );
       }
   
       @Override
       public void onEvent(@NonNull PlayerEvent event) {
           // Filter out events from other players.
           if (!isCurrentPlayer(event)) return;
   
           // Process the event.
           if (event instanceof PlayerEvents.StateChanged) {
               handleStateChanged((PlayerEvents.StateChanged) event);
           } else if (event instanceof PlayerEvents.Prepared) {
               handlePrepared((PlayerEvents.Prepared) event);
           } else if (event instanceof PlayerEvents.Info) {
               handleInfo((PlayerEvents.Info) event);
           }
       }
   
       @Override
       public void onReset() {
           super.onReset();
           // Reset the internal state to prepare for a new video.
       }
   
       private void handleStateChanged(PlayerEvents.StateChanged event) {
           // Handle state changes.
       }
   
       private void handlePrepared(PlayerEvents.Prepared event) {
           // Handle preparation completion.
       }
   
       private void handleInfo(PlayerEvents.Info event) {
           // Handle playback information updates.
       }
   }

2. Commencez.

   StrategyManager strategyManager = controller.getStrategyManager();
   strategyManager.register(new MyAnalyticsStrategy());

Exemple : pour plus d'informations, consultez strategies/FirstFrameStrategy.java.

Méthode 2 : Implémenter l'interface IStrategy

L'implémentation directe de l'interface IStrategy offre une plus grande flexibilité, mais vous devez gérer vous-même les abonnements aux événements.

Scénario : vous avez besoin d'un contrôle total sur le comportement de la stratégie ou vous avez besoin d'une logique d'initialisation spéciale.

1. Créez une classe de stratégie.

   Implémentez l'interface IStrategy et gérez vous-même les abonnements aux événements :

   public class MyCustomStrategy implements IStrategy, PlayerEventBus.EventListener<PlayerEvent> {
   
       private static final String TAG = "MyCustomStrategy";
   
       private StrategyContext mContext;
   
       @NonNull
       @Override
       public String getName() {
           return TAG;
       }
   
       @Override
       public void onStart(@NonNull StrategyContext context) {
           mContext = context;
           // Manually subscribe to events.
           PlayerEventBus.getInstance().subscribe(PlayerEvents.StateChanged.class, this);
       }
   
       @Override
       public void onStop() {
           // Manually unsubscribe from events.
           PlayerEventBus.getInstance().unsubscribe(PlayerEvents.StateChanged.class, this);
           mContext = null;
       }
   
       @Override
       public void onReset() {
           // Reset the internal state.
       }
   
       @Override
       public void onEvent(@NonNull PlayerEvent event) {
           // Process the event.
       }
   }

2. Inscrivez-vous pour un compte.

   StrategyManager strategyManager = controller.getStrategyManager();
   strategyManager.register(new MyAnalyticsStrategy());

Comment implémenter une stratégie avec des rappels

Les stratégies peuvent utiliser des interfaces de rappel pour notifier la couche métier des résultats :

public class MyAnalyticsStrategy extends BaseStrategy {

    public interface Callback {
        void onAnalysisComplete(AnalysisResult result);
    }

    @Nullable
    private final Callback mCallback;

    // Support a parameterless constructor.
    public MyAnalyticsStrategy() {
        this(null);
    }

    // Support passing a callback.
    public MyAnalyticsStrategy(@Nullable Callback callback) {
        mCallback = callback;
    }

    @Override
    public void onEvent(@NonNull PlayerEvent event) {
        // ... business logic

        // Notify the result through the callback.
        if (mCallback != null) {
            mCallback.onAnalysisComplete(result);
        }
    }
}

Utilisation :

strategyManager.register(new MyAnalyticsStrategy(result -> {
    // Process the analysis result.
    Log.d("Analytics", "Result: " + result);
}));

Exemple : pour plus d'informations, consultez strategies/FirstFrameStrategy.java.

Comment accéder au statut du lecteur

Les stratégies peuvent accéder au statut et aux données du lecteur via StrategyContext :

@Override
public void onEvent(@NonNull PlayerEvent event) {
    if (!isCurrentPlayer(event)) return;

    // Get the player ID.
    String playerId = getPlayerId();

    // Get the playback data model.
    AliPlayerModel model = mContext.getModel();
    if (model != null) {
        String title = model.getVideoTitle();
        VideoSource source = model.getVideoSource();
    }

    // Get the player state store.
    IPlayerStateStore stateStore = mContext.getPlayerStateStore();
    long position = stateStore.getCurrentPosition();
    long duration = stateStore.getDuration();
    PlayerState state = stateStore.getPlayState();
}

Comment enregistrer une stratégie globale

Vous pouvez utiliser StrategyRegistry pour enregistrer une stratégie globale. Elle sera automatiquement appliquée à toutes les nouvelles instances de lecteur créées :

// Register a global strategy.
StrategyRegistry.addGlobalStrategy(() -> new MyAnalyticsStrategy());

// All AliPlayerController instances created after this will automatically register this strategy.
AliPlayerController controller = new AliPlayerController(this);   

Restaurer les configurations par défaut :

StrategyRegistry.resetToDefault();

Gestion du cycle de vie

public class MyStrategy extends BaseStrategy {

    @Overridepublic void onStart(@NonNull StrategyContext context) {
        super.onStart(context);  // Must be called.
        // Initialize resources.
    }

    @Overridepublic void onStop() {
        // Clean up resources.
        super.onStop();  // Must be called.
    }

    @Overridepublic void onReset() {
        super.onReset();
        // Reset the internal state to prepare for a new video.
    }
}

Filtrage des événements

Dans les scénarios multi-lecteurs, filtrez toujours la source de l'événement :

@Overridepublic void onEvent(@NonNull PlayerEvent event) {
    // Filter out events from other players to avoid interference.
    if (!isCurrentPlayer(event)) return;

    // Process events for the current player.
}

Nettoyage des ressources

Si une stratégie possède des ressources asynchrones telles qu'un Handler ou un Runnable, nettoyez-les dans onStop() :

public class MyStrategy extends BaseStrategy {

    private final Handler mHandler = new Handler();
    private Runnable mRunnable;

    @Overridepublic void onStart(@NonNull StrategyContext context) {
        super.onStart(context);
        mRunnable = () -> doSomething();
        mHandler.postDelayed(mRunnable, 1000);
    }

    @Overridepublic void onStop() {
        // Clean up asynchronous tasks to avoid memory leaks.
        mHandler.removeCallbacks(mRunnable);
        super.onStop();
    }
}

Remarques

Fonctionnalités de l'exemple

Exécuter l'exemple

Dans l'application de démonstration, sélectionnez l'exemple Strategy System pour le voir en action.

Interfaces principales

Méthodes BaseStrategy

Méthodes StrategyManager

Méthodes StrategyContext

Architecture globale

Le système de stratégies utilise un modèle architectural piloté par les événements et planifié par un gestionnaire.

Points de conception :

• Les stratégies ne conservent pas de références au lecteur : un découplage complet est réalisé grâce à une conception pilotée par les événements.

• Les stratégies se concentrent uniquement sur les événements : elles ont seulement besoin de déclarer ce à quoi s'abonner et comment le traiter.

• Le gestionnaire gère la planification : le gestionnaire contrôle le cycle de vie et la distribution des événements.

Cycle de vie

Les stratégies utilisent un cycle de vie en trois étapes :

Mécanisme piloté par les événements

Les stratégies s'abonnent aux événements du lecteur via un bus d'événements, en utilisant un modèle publication-abonnement.

Flux d'abonnement aux événements :

1. La stratégie déclare les types d'événements auxquels elle doit s'abonner dans observedEvents().

2. BaseStrategy s'abonne automatiquement à ces événements dans onStart().

3. BaseStrategy se désabonne automatiquement dans onStop().

4. La stratégie traite les événements reçus dans onEvent().

Philosophie de conception : le mécanisme piloté par les événements découple complètement les stratégies du lecteur. Les stratégies n'ont pas besoin de conserver une référence au lecteur. Elles doivent seulement se concentrer sur l'abonnement aux événements et la logique de traitement. Cela permet une séparation des préoccupations.

Isolation multi-lecteur

Dans les scénarios multi-lecteurs, le système de stratégies assure l'isolation grâce aux mécanismes suivants :

1. StrategyManager indépendant : chaque AliPlayerController possède son propre StrategyManager indépendant.

2. StrategyContext indépendant : chaque contexte de stratégie est lié à un ID de lecteur spécifique.

3. Filtrage des événements : les stratégies filtrent les sources d'événements en utilisant isCurrentPlayer(event).

@Overridepublic void onEvent(@NonNull PlayerEvent event) {
    // Events from each player instance carry a playerId.
    // isCurrentPlayer() checks if the event is from the current player.
    if (!isCurrentPlayer(event)) return;

    // Process only events from the current player.
}

Quand une stratégie démarre-t-elle ?

Toutes les stratégies enregistrées démarrent automatiquement lorsque vous appelez playerView.attach().

Comment obtenir le statut actuel du lecteur ?

Utilisez la méthode getPlayerStateStore() de StrategyContext :

IPlayerStateStore stateStore = mContext.getPlayerStateStore();
PlayerState state = stateStore.getPlayState();
long position = stateStore.getCurrentPosition();

Comment déboguer une stratégie ?

Utilisez LogHub pour afficher les journaux. Le format du TAG est Nom de la politique.BaseStrategy ou StrategyManager.

Erreurs courantes provoquant des plantages

Voici les problèmes les plus couramment signalés par les clients qui entraînent des plantages. Évitez ces erreurs.

public class MyStrategy extends BaseStrategy {

    public MyStrategy() {
        super();
        // mContext is null in the constructor.
        String playerId = getPlayerId();  // Returns an empty string.
        AliPlayerModel model = mContext.getModel();  // NullPointerException!
    }
}

@Overridepublic void onStart(@NonNull StrategyContext context) {
    super.onStart(context);  // ✅ Must be called first.
    // mContext can be accessed after onStart.
    String playerId = getPlayerId();  // Gets the ID normally.
    AliPlayerModel model = mContext.getModel();  // Gets the model normally.
}

public class MyStrategy extends BaseStrategy {

    @Overridepublic void onStart(@NonNull StrategyContext context) {
        // Forgot to call super.onStart(context).
        // mContext will be null, and event subscription will not execute.
        initMyResources();
    }

    @Overridepublic void onEvent(@NonNull PlayerEvent event) {
        // This will never be called because event subscription did not execute.
    }
}

@Overridepublic void onStart(@NonNull StrategyContext context) {
    super.onStart(context);  // ✅ Must be called first.
    initMyResources();
}

public class MyStrategy extends BaseStrategy {

    @Overridepublic void onEvent(@NonNull PlayerEvent event) {
            // The event source is not filtered, which causes crosstalk in multi-player scenarios.
            if (event instanceof PlayerEvents.StateChanged) {
            // State changes from all players will trigger this logic.
            updateUI();  // This may update the UI of the wrong player.
        }
    }
}

@Overridepublic void onEvent(@NonNull PlayerEvent event) {
    // First, filter out events that are not from the current player. if (!isCurrentPlayer(event)) return;

    if (event instanceof PlayerEvents.StateChanged) {
        updateUI();  // Only process events from the current player.
    }
}

public class MyStrategy extends BaseStrategy {

    private Handler handler = new Handler();

    @Overridepublic void onStart(@NonNull StrategyContext context) {
        super.onStart(context);
        handler.postDelayed(() -> updateProgress(), 1000);  // Delayed task.
    }

    @Overridepublic void onStop() {
        // Forgot to remove the delayed task.
        super.onStop();
    }
}

@Overridepublic void onStop() {
    handler.removeCallbacksAndMessages(null);  // Clear all delayed tasks
    super.onStop();
}

public class MyStrategy extends BaseStrategy {

    @Nullable@Overrideprotected List<Class<? extends PlayerEvent>> observedEvents() {
        // Returning null will not cause a crash, but the event subscription will not be executed.
        return null;
    }

    @Overridepublic void onEvent(@NonNull PlayerEvent event) {
        // Will never be called.
    }
}

@Nullable@Overrideprotected List<Class<? extends PlayerEvent>> observedEvents() {
    return Arrays.asList(
        PlayerEvents.StateChanged.class,  // Declare the events to subscribe to
        PlayerEvents.Prepared.class
    );
}

@Overridepublic void onEvent(@NonNull PlayerEvent event) {
    // You can now receive events.
}

public class MyStrategy extends BaseStrategy {

    private int mPlayCount = 0;

    @Overridepublic void onEvent(@NonNull PlayerEvent event) {
        if (!isCurrentPlayer(event)) return;

        if (event instanceof PlayerEvents.Prepared) {
            mPlayCount++;  // The count is not reset when the video is switched, so it accumulates.
            Log.d(TAG, "Play count: " + mPlayCount);
        }
    }

    @Overridepublic void onReset() {
        super.onReset();
        // Forgot to reset mPlayCount.
    }
}

@Overridepublic void onReset() {
    super.onReset();
    mPlayCount = 0;  // Reset the internal state.
}