ApsaraVideo VOD:Sistem strategi

Apa itu sistem strategi?

Sistem Strategi adalah mekanisme arsitektural yang menyatukan pengelolaan komponen strategi. Sistem ini bertanggung jawab atas registrasi strategi, manajemen siklus hidup, injeksi konteks, dan langganan event, serta mengelola pembuatan, start, pause, reset, dan penghapusan strategi selama pemutar berjalan.
Dengan mekanisme ini, developer dapat mengaktifkan atau menonaktifkan strategi sesuai kebutuhan, menerapkan kebijakan kustom secara cepat, atau sepenuhnya mengganti strategi default untuk memenuhi kebutuhan kustomisasi bisnis.

Apa itu strategi?

Strategi adalah unit terenkapsulasi dari logika bisnis pemutar yang mengimplementasikan kemampuan bisnis atau logika kustom tertentu, seperti statistik time-to-first-frame (TTFF), deteksi tersendat, perlindungan trafik, atau melanjutkan pemutaran.
Fitur inti:

• Tanggung jawab tunggal: Fokus pada tujuan fungsional yang independen.

• Berdasar event: Merespons status pemutar melalui event bus.

• Independen dan terisolasi: Strategi tidak saling mengganggu satu sama lain.

Melalui desain yang dapat dipasang (pluggable) dan dikomposisi, kemampuan non-inti diabstraksi menjadi unit strategi. Hal ini menjaga inti pemutar tetap sederhana sekaligus menyediakan kemampuan ekstensi yang fleksibel.

Masalah yang diselesaikan

Sistem Strategi mengatasi permasalahan berikut:

1. Pemeliharaan sulit: Logika bisnis yang tersebar sulit dipelihara dan digunakan kembali.

2. Kurangnya konfigurasi: Skenario berbeda memerlukan kombinasi logika berbeda, tetapi tidak tersedia mekanisme konfigurasi yang fleksibel.

3. Modifikasi kode sumber: Logika kustom memerlukan modifikasi kode sumber framework.

4. Gangguan antar instans: Dalam skenario multi-pemutar, logika bisnis antar instans dapat saling mengganggu.

Nilai inti

Sistem Strategi mengabstraksi dan mengenkapsulasi logika pemantauan dan analisis pemutar, sehingga memungkinkan pelanggan mengonfigurasi dan mengombinasikan strategi sesuai kebutuhan.

Keunggulan arsitektur:

• Penguraian keterkaitan (Decoupling): Strategi dipisahkan dari logika inti pemutar, menciptakan tanggung jawab yang jelas.

• Dapat digunakan kembali (Reusability): Strategi dapat digunakan kembali di berbagai instans pemutar.

• Dapat dikembangkan (Extensibility): Anda dapat mengkustomisasi strategi tanpa mengubah framework.

• Isolasi: Strategi bersifat independen dan tidak saling mengganggu.

Kemampuan inti

Kebijakan Time-to-first-frame (TTFF) (FirstFrameStrategy)

Strategi ini menghitung waktu yang dibutuhkan pemutar untuk berpindah dari tahap PREPARING hingga rendering frame pertama. Strategi ini dibagi menjadi tiga fase:

Skenario: Pemantauan kinerja, optimasi pengalaman pengguna, dan penyetelan pemutar.

Kebijakan deteksi tersendat (StutterDetectStrategy)

Strategi ini memantau tersendat selama pemutaran dan mengumpulkan statistik tersendat:

Skenario: Pemantauan kualitas pemutaran dan analisis pengalaman pengguna.

Kebijakan Perlindungan Trafik (TrafficProtectionStrategy)

Strategi ini mendengarkan perubahan status jaringan dan memberi notifikasi kepada pengguna dalam skenario tertentu:

Skenario: Skenario sensitif terhadap trafik dan notifikasi yang ramah pengguna.

Metode 1: Gunakan strategi bawaan

Ini adalah metode paling sederhana. Komponen pemutar secara otomatis mendaftarkan strategi default:

// 1. Buat controller pemutar. Strategi default didaftarkan secara otomatis.
AliPlayerController controller = new AliPlayerController(this);

// 2. Siapkan data pemutaran.
AliPlayerModel model = new AliPlayerModel.Builder()
        .videoSource(videoSource)
        .build();

// 3. Konfigurasikan model data.
controller.configure(model);

// 4. Sambungkan controller ke tampilan.
playerView.attach(controller);

Strategi default yang terdaftar meliputi:

• FirstFrameStrategy (TTFF)

• StutterDetectStrategy (deteksi tersendat)

• TrafficProtectionStrategy (perlindungan trafik)

Metode 2: Kustomisasi strategi

Hanya daftarkan strategi yang Anda butuhkan dan nonaktifkan strategi lainnya:

// 1. Buat controller pemutar.
AliPlayerController controller = new AliPlayerController(this);

// 2. Dapatkan manager strategi dan hapus strategi default.
StrategyManager strategyManager = controller.getStrategyManager();

// 3. Daftarkan hanya strategi yang diperlukan.
strategyManager.register(new FirstFrameStrategy());
strategyManager.register(new StutterDetectStrategy());

// 4. Siapkan data pemutaran.
AliPlayerModel model = new AliPlayerModel.Builder()
        .videoSource(videoSource)
        .build();
controller.configure(model);
playerView.attach(controller);

Metode 3: Kustomisasi penuh strategi

Implementasikan kebijakan kustom untuk membuat sistem pemantauan yang sepenuhnya personal:

// 1. Buat controller pemutar.
AliPlayerController controller = new AliPlayerController(this);

// 2. Dapatkan manager strategi.
StrategyManager strategyManager = controller.getStrategyManager();

// 3. Daftarkan kebijakan kustom.
strategyManager.register(new MyCustomStrategy());
strategyManager.register(new MyAnalyticsStrategy());

// 4. Siapkan data pemutaran.
AliPlayerModel model = new AliPlayerModel.Builder()
        .videoSource(videoSource)
        .build();
controller.configure(model);
playerView.attach(controller);

Cara mengimplementasikan kebijakan kustom

AliPlayerKit menyediakan dua metode implementasi. Pilih salah satu berdasarkan kebutuhan Anda:

Metode 1: Warisi BaseStrategy (Direkomendasikan)

Mewarisi BaseStrategy adalah metode paling sederhana karena framework telah mengenkapsulasi langganan event dan manajemen siklus hidup.

Skenario: Sebagian besar strategi pemantauan dan analisis, seperti statistik, deteksi, dan pencatatan log.

1. Buat kelas strategi.

   Warisi BaseStrategy dan implementasikan metode yang diperlukan:

   public class MyAnalyticsStrategy extends BaseStrategy {
   
       private static final String TAG = "MyAnalyticsStrategy";
   
       @NonNull
       @Override
       public String getName() {
           return TAG;  // Mengembalikan nama kebijakan untuk logging dan debugging.
       }
   
       @Nullable
       @Override
       protected List<Class<? extends PlayerEvent>> observedEvents() {
           // Deklarasikan jenis event yang akan dilanggankan.
           return Arrays.asList(
               PlayerEvents.StateChanged.class,
               PlayerEvents.Prepared.class,
               PlayerEvents.Info.class
           );
       }
   
       @Override
       public void onEvent(@NonNull PlayerEvent event) {
           // Filter event dari pemutar lain.
           if (!isCurrentPlayer(event)) return;
   
           // Proses 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 status internal untuk mempersiapkan video baru.
       }
   
       private void handleStateChanged(PlayerEvents.StateChanged event) {
           // Tangani perubahan status.
       }
   
       private void handlePrepared(PlayerEvents.Prepared event) {
           // Tangani penyelesaian persiapan.
       }
   
       private void handleInfo(PlayerEvents.Info event) {
           // Tangani pembaruan informasi pemutaran.
       }
   }

2. Mulai penggunaan.

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

Contoh: Untuk informasi lebih lanjut, lihat strategies/FirstFrameStrategy.java.

Cara 2: Implementasikan IStrategy interface

Mengimplementasikan langsung antarmuka IStrategy memberikan fleksibilitas lebih besar, tetapi Anda perlu menangani langganan event sendiri.

Skenario: Anda memerlukan kontrol penuh atas perilaku strategi atau memerlukan logika inisialisasi khusus.

1. Buat kelas strategi.

   Implementasikan antarmuka IStrategy dan kelola langganan event sendiri:

   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;
           // Langganan event secara manual.
           PlayerEventBus.getInstance().subscribe(PlayerEvents.StateChanged.class, this);
       }
   
       @Override
       public void onStop() {
           // Batalkan langganan event secara manual.
           PlayerEventBus.getInstance().unsubscribe(PlayerEvents.StateChanged.class, this);
           mContext = null;
       }
   
       @Override
       public void onReset() {
           // Reset status internal.
       }
   
       @Override
       public void onEvent(@NonNull PlayerEvent event) {
           // Proses event.
       }
   }

2. Daftarkan akun.

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

Cara mengimplementasikan strategi dengan callback

Strategi dapat menggunakan antarmuka callback untuk memberi notifikasi hasil ke lapisan bisnis:

public class MyAnalyticsStrategy extends BaseStrategy {

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

    @Nullable
    private final Callback mCallback;

    // Mendukung konstruktor tanpa parameter.
    public MyAnalyticsStrategy() {
        this(null);
    }

    // Mendukung meneruskan callback.
    public MyAnalyticsStrategy(@Nullable Callback callback) {
        mCallback = callback;
    }

    @Override
    public void onEvent(@NonNull PlayerEvent event) {
        // ... logika bisnis

        // Beri notifikasi hasil melalui callback.
        if (mCallback != null) {
            mCallback.onAnalysisComplete(result);
        }
    }
}

Penggunaan:

strategyManager.register(new MyAnalyticsStrategy(result -> {
    // Proses hasil analisis.
    Log.d("Analytics", "Hasil: " + result);
}));

Contoh: Untuk informasi lebih lanjut, lihat strategies/FirstFrameStrategy.java.

Cara mengakses status pemutar

Strategi dapat mengakses status dan data pemutar melalui StrategyContext:

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

    // Dapatkan ID pemutar.
    String playerId = getPlayerId();

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

    // Dapatkan penyimpan status pemutar.
    IPlayerStateStore stateStore = mContext.getPlayerStateStore();
    long position = stateStore.getCurrentPosition();
    long duration = stateStore.getDuration();
    PlayerState state = stateStore.getPlayState();
}

Cara mendaftarkan strategi global

Anda dapat menggunakan StrategyRegistry untuk mendaftarkan strategi global. Strategi ini akan secara otomatis diterapkan ke semua instans pemutar yang baru dibuat:

// Daftarkan strategi global.
StrategyRegistry.addGlobalStrategy(() -> new MyAnalyticsStrategy());

// Semua instans AliPlayerController yang dibuat setelah ini akan secara otomatis mendaftarkan strategi ini.
AliPlayerController controller = new AliPlayerController(this);   

Kembalikan ke konfigurasi default:

StrategyRegistry.resetToDefault();

Manajemen siklus hidup

public class MyStrategy extends BaseStrategy {

    @Overridepublic void onStart(@NonNull StrategyContext context) {
        super.onStart(context);  // Harus dipanggil.
        // Inisialisasi resource.
    }

    @Overridepublic void onStop() {
        // Bersihkan resource.
        super.onStop();  // Harus dipanggil.
    }

    @Overridepublic void onReset() {
        super.onReset();
        // Reset status internal untuk mempersiapkan video baru.
    }
}

Filtering event

Dalam skenario multi-pemutar, selalu filter sumber event:

@Overridepublic void onEvent(@NonNull PlayerEvent event) {
    // Filter event dari pemutar lain untuk menghindari gangguan.
    if (!isCurrentPlayer(event)) return;

    // Proses event untuk pemutar saat ini.
}

Pembersihan resource

Jika strategi memiliki resource asinkron seperti Handler atau Runnable, bersihkan di 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() {
        // Bersihkan tugas asinkron untuk menghindari kebocoran memori.
        mHandler.removeCallbacks(mRunnable);
        super.onStop();
    }
}

Catatan

Fitur contoh

Jalankan contoh

Di aplikasi demo, pilih contoh Sistem Strategi untuk melihatnya berjalan.

Antarmuka inti

Metode BaseStrategy

Metode StrategyManager

Metode StrategyContext

Arsitektur keseluruhan

Sistem Strategi menggunakan pola arsitektur berdasar event dan dijadwalkan oleh manager.

Poin desain:

• Strategi tidak menyimpan referensi pemutar: Penguraian keterkaitan lengkap dicapai melalui desain berdasar event.

• Strategi hanya fokus pada event: Strategi hanya perlu mendeklarasikan event apa yang akan dilanggankan dan bagaimana menanganinya.

• Manager menangani penjadwalan: Manager mengontrol siklus hidup dan pengiriman event.

Siklus hidup

Strategi menggunakan siklus hidup tiga tahap:

Mekanisme berdasar event

Strategi berlangganan event pemutar melalui event bus, menggunakan pola publish-subscribe.

Alur langganan event:

1. Strategi mendeklarasikan jenis event yang perlu dilanggankan di observedEvents().

2. BaseStrategy secara otomatis berlangganan event tersebut di onStart().

3. BaseStrategy secara otomatis membatalkan langganan di onStop().

4. Strategi memproses event yang diterima di onEvent().

Filosofi desain: Mekanisme berdasar event sepenuhnya memisahkan strategi dari pemutar. Strategi tidak perlu menyimpan referensi pemutar. Strategi hanya perlu fokus pada logika langganan dan penanganan event. Hal ini mencapai pemisahan tanggung jawab.

Isolasi multi-pemutar

Dalam skenario multi-pemutar, Sistem Strategi memastikan isolasi melalui mekanisme berikut:

1. StrategyManager independen: Setiap AliPlayerController memiliki StrategyManager sendiri yang independen.

2. Independent StrategyContext: Setiap StrategyContext terikat pada ID pemain tertentu.

3. Filtering event: Strategi memfilter sumber event menggunakan isCurrentPlayer(event).

@Overridepublic void onEvent(@NonNull PlayerEvent event) {
    // Event dari setiap instans pemutar membawa playerId.
    // isCurrentPlayer() memeriksa apakah event berasal dari pemutar saat ini.
    if (!isCurrentPlayer(event)) return;

    // Proses hanya event dari pemutar saat ini.
}

Kapan strategi dimulai?

Semua strategi yang terdaftar akan otomatis dimulai saat Anda memanggil playerView.attach().

Bagaimana cara mendapatkan status pemutar saat ini?

Gunakan metode getPlayerStateStore() dari StrategyContext:

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

Bagaimana cara melakukan debug strategi?

Gunakan LogHub untuk melihat log. Format TAG adalah Nama Kebijakan.BaseStrategy atau StrategyManager.

Kesalahan umum yang menyebabkan crash

Berikut adalah masalah paling umum yang dilaporkan pelanggan yang menyebabkan crash. Hindari kesalahan ini.

public class MyStrategy extends BaseStrategy {

    public MyStrategy() {
        super();
        // mContext bernilai null di konstruktor.
        String playerId = getPlayerId();  // Mengembalikan string kosong.
        AliPlayerModel model = mContext.getModel();  // NullPointerException!
    }
}

@Overridepublic void onStart(@NonNull StrategyContext context) {
    super.onStart(context);  // ✅ Harus dipanggil terlebih dahulu.
    // mContext dapat diakses setelah onStart.
    String playerId = getPlayerId();  // Mendapatkan ID secara normal.
    AliPlayerModel model = mContext.getModel();  // Mendapatkan model secara normal.
}

public class MyStrategy extends BaseStrategy {

    @Overridepublic void onStart(@NonNull StrategyContext context) {
        // Lupa memanggil super.onStart(context).
        // mContext akan bernilai null, dan langganan event tidak dieksekusi.
        initMyResources();
    }

    @Overridepublic void onEvent(@NonNull PlayerEvent event) {
        // Ini tidak akan pernah dipanggil karena langganan event tidak dieksekusi.
    }
}

@Overridepublic void onStart(@NonNull StrategyContext context) {
    super.onStart(context);  // ✅ Harus dipanggil terlebih dahulu.
    initMyResources();
}

public class MyStrategy extends BaseStrategy {

    @Overridepublic void onEvent(@NonNull PlayerEvent event) {
            // Sumber event tidak difilter, yang menyebabkan crosstalk di skenario multi-pemutar.
            if (event instanceof PlayerEvents.StateChanged) {
            // Perubahan status dari semua pemutar akan memicu logika ini.
            updateUI();  // Ini dapat memperbarui UI pemutar yang salah.
        }
    }
}

@Overridepublic void onEvent(@NonNull PlayerEvent event) {
    // Pertama, filter event yang bukan dari pemutar saat ini. if (!isCurrentPlayer(event)) return;

    if (event instanceof PlayerEvents.StateChanged) {
        updateUI();  // Hanya proses event dari pemutar saat ini.
    }
}

public class MyStrategy extends BaseStrategy {

    private Handler handler = new Handler();

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

    @Overridepublic void onStop() {
        // Lupa menghapus tugas tertunda.
        super.onStop();
    }
}

@Overridepublic void onStop() {
    handler.removeCallbacksAndMessages(null);  // Hapus semua tugas tertunda
    super.onStop();
}

public class MyStrategy extends BaseStrategy {

    @Nullable@Overrideprotected List<Class<? extends PlayerEvent>> observedEvents() {
        // Mengembalikan null tidak menyebabkan crash, tetapi langganan event tidak dieksekusi.
        return null;
    }

    @Overridepublic void onEvent(@NonNull PlayerEvent event) {
        // Tidak akan pernah dipanggil.
    }
}

@Nullable@Overrideprotected List<Class<? extends PlayerEvent>> observedEvents() {
    return Arrays.asList(
        PlayerEvents.StateChanged.class,  // Deklarasikan event yang akan dilanggankan
        PlayerEvents.Prepared.class
    );
}

@Overridepublic void onEvent(@NonNull PlayerEvent event) {
    // Anda sekarang dapat menerima 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++;  // Hitungan tidak direset saat video berganti, sehingga terakumulasi.
            Log.d(TAG, "Jumlah pemutaran: " + mPlayCount);
        }
    }

    @Overridepublic void onReset() {
        super.onReset();
        // Lupa mereset mPlayCount.
    }
}

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