ApsaraVideo VOD:ストラテジーシステム

ストラテジーシステムとは

ストラテジーシステム は、ストラテジーコンポーネントの管理を統合するアーキテクチャメカニズムです。ストラテジーの登録メカニズム、ライフサイクル管理、コンテキストの注入、イベントサブスクリプションを担います。また、プレーヤーの実行中にストラテジーの作成、開始、一時停止、リセット、破棄も管理します。
このメカニズムにより、開発者は必要に応じてストラテジーを有効化または無効化できます。また、カスタムポリシーを迅速に実装したり、デフォルトのストラテジーを完全に置き換えたりして、ビジネスのカスタマイズ要件に対応できます。

ストラテジーとは

ストラテジー は、プレーヤーのビジネスロジックをカプセル化したユニットです。初回フレームまでの時間 (TTFF) の統計、コマ落ち検出、トラフィック保護、レジューム再生など、特定のビジネス機能またはカスタムロジックを実装します。
コア機能：

• 単一責任：独立した機能目標に集中します。

• イベント駆動：イベントバスを介してプレーヤーの状態に応答します。

• 独立かつ分離：ストラテジー同士が干渉しません。

プラガブルかつコンポーザブルな設計により、コアではない機能をストラテジーユニットとして抽象化します。これにより、プレーヤーコアをシンプルに保ちながら、柔軟な拡張性を提供します。

解決する課題

戦略システムは、以下の課題を解決します。

1. メンテナンスの困難さ： 分散したビジネスロジックはメンテナンスと再利用が困難です。

2. 設定の欠如： 異なるシナリオでは異なるロジックの組み合わせが必要ですが、柔軟な設定メカニズムがありません。

3. ソースコードの変更： カスタムロジックにはフレームワークのソースコードの変更が必要です。

4. インスタンスの干渉： マルチプレーヤーシナリオでは、インスタンス間のビジネスロジックが相互に干渉する可能性があります。

コアバリュー

戦略システムは、プレーヤーのモニタリングおよび分析ロジックを抽象化し、カプセル化します。これにより、お客様は必要に応じて戦略を設定し、組み合わせることができます。

アーキテクチャ上のメリット：

• デカップリング： 戦略はプレーヤーのコアロジックから分離されているため、責任分担が明確になります。

• 再利用性： 戦略は異なるプレーヤーインスタンス間で再利用できます。

• 拡張性： フレームワークを変更することなく戦略をカスタマイズできます。

• アイソレーション： 戦略は独立しており、相互に干渉しません。

コア機能

初回フレーム表示時間 (TTFF) ストラテジー (FirstFrameStrategy)

このストラテジーは、プレーヤーが PREPARING ステージから初回フレームのレンダリングに至るまでに要する時間を算出します。これは 3 つのフェーズに分かれます。

シナリオ：パフォーマンスモニタリング、ユーザーエクスペリエンスの最適化、およびプレーヤーのチューニング。

カクつき検出ストラテジー (StutterDetectStrategy)

このストラテジーは、再生中のカクつきをモニタリングし、カクつきの統計を収集します。

シナリオ：再生品質のモニタリングとユーザーエクスペリエンス分析。

トラフィック保護ストラテジー (TrafficProtectionStrategy)

このストラテジーはネットワークステータスの変化をリッスンし、特定のシナリオでユーザーに通知します。

シナリオ：データ使用量に注意が必要なシナリオと、ユーザーフレンドリーな通知。

方法 1: 組み込みストラテジーの使用

これは最もシンプルな方法です。プレーヤーコンポーネントが自動的にデフォルトストラテジーを登録します。

// 1. プレーヤーコントローラーを作成します。デフォルトのストラテジーが自動的に登録されます。
AliPlayerController controller = new AliPlayerController(this);

// 2. 再生データを準備します。
AliPlayerModel model = new AliPlayerModel.Builder()
        .videoSource(videoSource)
        .build();

// 3. データモデルを設定します。
controller.configure(model);

// 4. コントローラーをビューにアタッチします。
playerView.attach(controller);

デフォルトで登録されるストラテジーには、以下が含まれます：

• FirstFrameStrategy (TTFF)

• StutterDetectStrategy (コマ落ち検出)

• TrafficProtectionStrategy (トラフィック保護)

方法 2: ストラテジーのカスタマイズ

必要なストラテジーのみを登録し、残りを無効にします。

// 1. プレーヤーコントローラーを作成します。
AliPlayerController controller = new AliPlayerController(this);

// 2. ストラテジーマネージャーを取得します。
StrategyManager strategyManager = controller.getStrategyManager();

// 3. 必要なストラテジーのみを登録します。
strategyManager.register(new FirstFrameStrategy());
strategyManager.register(new StutterDetectStrategy());

// 4. 再生データを準備します。
AliPlayerModel model = new AliPlayerModel.Builder()
        .videoSource(videoSource)
        .build();
controller.configure(model);
playerView.attach(controller);

方法 3: ストラテジーの完全なカスタマイズ

カスタムストラテジーを実装して、完全にカスタマイズされたモニタリングシステムを作成します。

// 1. プレーヤーコントローラーを作成します。
AliPlayerController controller = new AliPlayerController(this);

// 2. ストラテジーマネージャーを取得します。
StrategyManager strategyManager = controller.getStrategyManager();

// 3. カスタムストラテジーを登録します。
strategyManager.register(new MyCustomStrategy());
strategyManager.register(new MyAnalyticsStrategy());

// 4. 再生データを準備します。
AliPlayerModel model = new AliPlayerModel.Builder()
        .videoSource(videoSource)
        .build();
controller.configure(model);
playerView.attach(controller);

カスタムストラテジーの実装方法

AliPlayerKit では、2 つの実装方法を提供しています。要件に応じていずれかを選択してください：

方法 1： BaseStrategy の継承 (推奨)

BaseStrategy を継承する方法が最も簡単です。フレームワークがイベントサブスクリプションとライフサイクル管理をすでにカプセル化しているためです。

シナリオ： 統計、検出、ログ記録など、ほとんどのモニタリングおよび分析ストラテジー。

1. ストラテジークラスを作成します。

   BaseStrategy を継承し、必要なメソッドを実装します：

   public class MyAnalyticsStrategy extends BaseStrategy {
   
       private static final String TAG = "MyAnalyticsStrategy";
   
       @NonNull
       @Override
       public String getName() {
           return TAG;  // ログ記録とデバッグのためにストラテジー名を返します。
       }
   
       @Nullable
       @Override
       protected List<Class<? extends PlayerEvent>> observedEvents() {
           // サブスクライブするイベントタイプを宣言します。
           return Arrays.asList(
               PlayerEvents.StateChanged.class,
               PlayerEvents.Prepared.class,
               PlayerEvents.Info.class
           );
       }
   
       @Override
       public void onEvent(@NonNull PlayerEvent event) {
           // 他のプレーヤーからのイベントを除外します。
           if (!isCurrentPlayer(event)) return;
   
           // イベントを処理します。
           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();
           // 新しい動画に備えて内部状態をリセットします。
       }
   
       private void handleStateChanged(PlayerEvents.StateChanged event) {
           // 状態の変更を処理します。
       }
   
       private void handlePrepared(PlayerEvents.Prepared event) {
           // 準備完了を処理します。
       }
   
       private void handleInfo(PlayerEvents.Info event) {
           // 再生情報の更新を処理します。
       }
   }

2. 登録します。

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

例： 詳細については、「 strategies/FirstFrameStrategy.java 」をご参照ください。

方法 2： IStrategy インターフェイスの実装

IStrategy インターフェイスを直接実装すると、より高い柔軟性を得られますが、イベントサブスクリプションは自分で処理する必要があります。

シナリオ： ストラテジーの動作を完全に制御する必要がある場合、または特殊な初期化ロジックが必要な場合。

1. ストラテジークラスを作成します。

   IStrategy インターフェイスを実装し、イベントサブスクリプションを自分で管理します：

   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;
           // 手動でイベントをサブスクライブします。
           PlayerEventBus.getInstance().subscribe(PlayerEvents.StateChanged.class, this);
       }
   
       @Override
       public void onStop() {
           // 手動でイベントをアンサブスクライブします。
           PlayerEventBus.getInstance().unsubscribe(PlayerEvents.StateChanged.class, this);
           mContext = null;
       }
   
       @Override
       public void onReset() {
           // 内部状態をリセットします。
       }
   
       @Override
       public void onEvent(@NonNull PlayerEvent event) {
           // イベントを処理します。
       }
   }

2. 登録します。

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

コールバック付きストラテジーの実装方法

ストラテジーはコールバックインターフェイスを使用して、結果をビジネス層に通知できます：

public class MyAnalyticsStrategy extends BaseStrategy {

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

    @Nullable
    private final Callback mCallback;

    // 引数なしコンストラクターをサポートします。
    public MyAnalyticsStrategy() {
        this(null);
    }

    // コールバックの受け渡しをサポートします。
    public MyAnalyticsStrategy(@Nullable Callback callback) {
        mCallback = callback;
    }

    @Override
    public void onEvent(@NonNull PlayerEvent event) {
        // ... ビジネスロジック

        // コールバックを通じて結果を通知します。
        if (mCallback != null) {
            mCallback.onAnalysisComplete(result);
        }
    }
}

使用方法：

strategyManager.register(new MyAnalyticsStrategy(result -> {
    // 分析結果を処理します。
    Log.d("Analytics", "Result: " + result);
}));

例： 詳細については、「 strategies/FirstFrameStrategy.java 」をご参照ください。

プレーヤー状態へのアクセス方法

ストラテジーは StrategyContext を通じて、プレーヤーの状態とデータにアクセスできます：

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

    // プレーヤー ID を取得します。
    String playerId = getPlayerId();

    // 再生データモデルを取得します。
    AliPlayerModel model = mContext.getModel();
    if (model != null) {
        String title = model.getVideoTitle();
        VideoSource source = model.getVideoSource();
    }

    // プレーヤーの状態ストアを取得します。
    IPlayerStateStore stateStore = mContext.getPlayerStateStore();
    long position = stateStore.getCurrentPosition();
    long duration = stateStore.getDuration();
    PlayerState state = stateStore.getPlayState();
}

グローバルストラテジーの登録方法

StrategyRegistry を使用してグローバルストラテジーを登録できます。登録したストラテジーは、新しく作成されたすべてのプレーヤーインスタンスに自動的に適用されます：

// グローバルストラテジーを登録します。
StrategyRegistry.addGlobalStrategy(() -> new MyAnalyticsStrategy());

// 以降に作成されるすべての AliPlayerController インスタンスに、このストラテジーが自動的に登録されます。
AliPlayerController controller = new AliPlayerController(this);   

デフォルト設定を復元する：

StrategyRegistry.resetToDefault();

ライフサイクル管理

public class MyStrategy extends BaseStrategy {

    @Overridepublic void onStart(@NonNull StrategyContext context) {
        super.onStart(context);  // 必ず呼び出す必要があります。
        // リソースを初期化します。
    }

    @Overridepublic void onStop() {
        // リソースをクリーンアップします。
        super.onStop();  // 必ず呼び出す必要があります。
    }

    @Overridepublic void onReset() {
        super.onReset();
        // 新しいビデオに備えて内部状態をリセットします。
    }
}

イベントフィルタリング

マルチプレイヤーシナリオでは、常にイベントソースをフィルタリングしてください。

@Overridepublic void onEvent(@NonNull PlayerEvent event) {
    // 他のプレーヤーからのイベントをフィルタリングして、干渉を回避します。
    if (!isCurrentPlayer(event)) return;

    // 現在のプレーヤーのイベントを処理します。
}

リソースのクリーンアップ

ストラテジーがハンドラや Runnable などの非同期リソースを持つ場合は、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() {
        // メモリリークを回避するため、非同期タスクをクリーンアップします。
        mHandler.removeCallbacks(mRunnable);
        super.onStop();
    }
}

注意事項

サンプルの機能

サンプルの実行

デモアプリで、[Strategy System] サンプルを選択すると、動作を確認できます。

コアインターフェイス

BaseStrategy メソッド

StrategyManager メソッド

StrategyContext メソッド

全体アーキテクチャ

ストラテジーシステムは、イベント駆動とマネージャーによるスケジュールのアーキテクチャパターンを採用しています。

設計上のポイント：

• ストラテジーはプレーヤー参照を保持しない：イベント駆動設計により、完全なデカップリングを実現します。

• ストラテジーはイベントにのみ注力する：サブスクライブする対象と、その処理方法を宣言するだけで済みます。

• マネージャーがスケジューリングを処理する：マネージャーがライフサイクルとイベントディスパッチを制御します。

ライフサイクル

ストラテジーは 3 段階のライフサイクルを使用します：

イベント駆動メカニズム

ストラテジーは、パブリッシュ/サブスクライブ パターンを使用し、イベントバスを介してプレーヤーイベントをサブスクライブします。

イベントサブスクリプションのフロー：

1. ストラテジーは、observedEvents() でサブスクライブする必要があるイベントタイプを宣言します。

2. BaseStrategy は、onStart() でこれらのイベントを自動的にサブスクライブします。

3. BaseStrategy は、onStop() で自動的にサブスクリプションを解除します。

4. ストラテジーは、onEvent() で受信したイベントを処理します。

設計思想：イベント駆動メカニズムにより、ストラテジーはプレーヤーから完全にデカップリングされます。ストラテジーはプレーヤー参照を保持する必要がありません。イベントサブスクリプションと処理ロジックにのみ注力すればよく、関心の分離を実現します。

複数プレーヤーの分離

複数プレーヤーのシナリオでは、ストラテジーシステムは次のメカニズムにより分離を保証します：

1. 独立した StrategyManager：各 AliPlayerController は、それぞれ独立した StrategyManager を持ちます。

2. 独立した StrategyContext：各ストラテジーコンテキストは、特定のプレーヤー ID にバインドされます。

3. イベントフィルタリング：ストラテジーは isCurrentPlayer(event) を使用してイベントソースをフィルタリングします。

@Overridepublic void onEvent(@NonNull PlayerEvent event) {
    // 各プレーヤーインスタンスからのイベントには playerId が含まれます。
    // isCurrentPlayer() は、イベントが現在のプレーヤーからのものかどうかを確認します。
    if (!isCurrentPlayer(event)) return;

    // 現在のプレーヤーからのイベントのみを処理します。
}

ストラテジーはいつ開始されますか？

playerView.attach() を呼び出すと、登録済みのすべてのストラテジーが自動的に開始されます。

プレーヤーの現在の状態を取得するにはどうすればよいですか？

StrategyContext の getPlayerStateStore() メソッドを使用します：

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

ストラテジーをデバッグするにはどうすればよいですか？

LogHub を使用してログを確認します。TAG の形式は Policy Name.BaseStrategy または StrategyManager です。

クラッシュの原因となるよくある間違い

以下は、クラッシュの原因としてお客様からよく報告される問題です。これらの誤りを避けてください。

public class MyStrategy extends BaseStrategy {

    public MyStrategy() {
        super();
        // コンストラクター内では mContext は null です。
        String playerId = getPlayerId();  // 空文字列を返します。
        AliPlayerModel model = mContext.getModel();  // NullPointerException!
    }
}

@Overridepublic void onStart(@NonNull StrategyContext context) {
    super.onStart(context);  // ✅ 最初に呼び出す必要があります。
    // onStart の後に mContext にアクセスできます。
    String playerId = getPlayerId();  // 通常どおり ID を取得します。
    AliPlayerModel model = mContext.getModel();  // 通常どおりモデルを取得します。
}

public class MyStrategy extends BaseStrategy {

    @Overridepublic void onStart(@NonNull StrategyContext context) {
        // super.onStart(context) の呼び出しを忘れています。
        // mContext は null になり、イベントサブスクリプションも実行されません。
        initMyResources();
    }

    @Overridepublic void onEvent(@NonNull PlayerEvent event) {
        // イベントサブスクリプションが実行されていないため、このメソッドは呼び出されません。
    }
}

@Overridepublic void onStart(@NonNull StrategyContext context) {
    super.onStart(context);  // ✅ 最初に呼び出す必要があります。
    initMyResources();
}

public class MyStrategy extends BaseStrategy {

    @Overridepublic void onEvent(@NonNull PlayerEvent event) {
            // イベントソースがフィルタリングされていないため、マルチプレイヤーのシナリオでクロストークが発生します。
            if (event instanceof PlayerEvents.StateChanged) {
            // すべてのプレーヤーの状態変更が、このロジックをトリガーします。
            updateUI();  // 誤ったプレーヤーの UI を更新する可能性があります。
        }
    }
}

@Overridepublic void onEvent(@NonNull PlayerEvent event) {
    // まず、現在のプレーヤー以外のイベントを除外します。
    if (!isCurrentPlayer(event)) return;

    if (event instanceof PlayerEvents.StateChanged) {
        updateUI();  // 現在のプレーヤーからのイベントのみを処理します。
    }
}

public class MyStrategy extends BaseStrategy {

    private Handler handler = new Handler();

    @Overridepublic void onStart(@NonNull StrategyContext context) {
        super.onStart(context);
        handler.postDelayed(() -> updateProgress(), 1000);  // 遅延タスク。
    }

    @Overridepublic void onStop() {
        // 遅延タスクの削除を忘れています。
        super.onStop();
    }
}

@Overridepublic void onStop() {
    handler.removeCallbacksAndMessages(null);  // すべての遅延タスクをクリアします
    super.onStop();
}

public class MyStrategy extends BaseStrategy {

    @Nullable@Overrideprotected List<Class<? extends PlayerEvent>> observedEvents() {
        // null を返してもクラッシュはしませんが、イベントサブスクリプションは実行されません。
        return null;
    }

    @Overridepublic void onEvent(@NonNull PlayerEvent event) {
        // このメソッドは呼び出されません。
    }
}

@Nullable@Overrideprotected List<Class<? extends PlayerEvent>> observedEvents() {
    return Arrays.asList(
        PlayerEvents.StateChanged.class,  // サブスクライブするイベントを宣言します
        PlayerEvents.Prepared.class
    );
}

@Overridepublic void onEvent(@NonNull PlayerEvent event) {
    // これでイベントを受信できます。
}

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++;  // ビデオ切り替え時にカウントがリセットされないため、蓄積します。
            Log.d(TAG, "Play count: " + mPlayCount);
        }
    }

    @Overridepublic void onReset() {
        super.onReset();
        // mPlayCount のリセットを忘れています。
    }
}

@Overridepublic void onReset() {
    super.onReset();
    mPlayCount = 0;  // 内部状態をリセットします。
}