ApsaraVideo Live:Referensi API

Daftar Isi

Detail

• createClient: Membuat instans client RTS.

  var aliRts = AliRTS.createClient();

• isSupport: Memeriksa apakah lingkungan penarikan aliran didukung.

  /**
   * isSupport memeriksa apakah lingkungan tersedia.
   * @param {Object} supportInfo Informasi pemeriksaan.
   * @param {boolean} supportInfo.isReceiveVideo Menentukan apakah akan menarik aliran video.
   * @return {Promise}
   */
  aliRts.isSupport({isReceiveVideo: true}).then(re=> {
    // Tersedia
  }).catch(err=> {
    // Tidak tersedia
    console.log(`not support errorCode: ${err.errorCode}`);
    console.log(`not support message: ${err.message}`);
  })

• checkPublishSupport: Memeriksa apakah lingkungan pengambilan aliran didukung.

  /**
    * checkPublishSupport memeriksa apakah lingkungan pengambilan aliran tersedia.
    * @return {Promise}
    */
  aliRts.checkPublishSupport().then(re => {
    console.log('support info',re);
     // re.isAudioMixSupported: boolean; Menentukan apakah pencampuran aliran audio lokal didukung.
     // re.isH264EncodeSupported: boolean; Menentukan apakah encoding H.264 didukung.
     // re.isMediaDevicesSupported: boolean; Menentukan apakah akses ke kamera, mikrofon, dan speaker didukung.
     // re.isScreenCaptureSupported: boolean; Menentukan apakah berbagi layar didukung.
     // re.isWebRTCSupported: boolean; Menentukan apakah WebRTC didukung.
     // re.cameraList: MediaDeviceInfo[]; Daftar perangkat input video.
     // re.micList: MediaDeviceInfo[]; Daftar perangkat input audio.
     // re.speakerList: MediaDeviceInfo[]; Daftar perangkat output audio.
  }).catch(err=> {
    console.log(err);
  })

• subscribe: Menarik aliran RTS.

  /**
   * API untuk memulai penarikan aliran RTS.
   * @param {string} pullStreamUrl URL penarikan aliran. Anda dapat menambahkan @subaudio=no atau @subvideo=no di akhir URL untuk berhenti berlangganan aliran audio atau video.
   * @param {Object} [config] (Opsional) Konfigurasi kustom.
   * @param {string} [config.signalUrl] (Opsional) URL signaling.
   * @param {number} [config.retryTimes] (Opsional) Jumlah maksimum upaya koneksi ulang. Nilai default: 5.
   * @param {number} [config.retryInterval] (Opsional) Interval koneksi ulang. Satuan: ms. Nilai default: 2000.
   * @return {Promise}
   */
   aliRts.subscribe(pullStreamUrl).then((remoteStream) => {
    // mediaElement adalah tag media audio atau video.
    remoteStream.play(mediaElement);
    // Memanggil remoteStream.play menyambungkan aliran media ke tag media dan mencoba mengaktifkan autoplay.
    // Jika Anda tidak ingin mengaktifkan autoplay, Anda dapat memberikan {autoplay:false} sebagai parameter kedua. Fitur ini didukung mulai versi 2.2.4.
    // remoteStream.play(mediaElement, {autoplay:false});
  }).catch((err) => {
    // Berlangganan gagal.
  })

  Penting

  • Saat melakukan decoding audio dan video untuk RTS (RTS), B-frame tidak didukung untuk video, yang dapat menyebabkan tampilan tersendat. Encoding AAC tidak didukung untuk audio, yang dapat menghasilkan kebisingan. Jika diperlukan, Anda dapat melakukan transkoding RTS untuk menghilangkan batasan ini. Untuk informasi selengkapnya, lihat Transkoding RTS.

  • Jika Anda mengimpor Web RTS SDK ke dalam proyek uni-app, metode remoteStream.play() memerlukan HTMLVideoElement aktual. Karena uni-app membungkus tag <video>, Anda dapat merujuk pada metode dalam demo untuk memperoleh HTMLVideoElement aktual. Misalnya, dalam pages/index/index.vue, gunakan remoteStream.play(this.$refs.myVideo.$refs.video).

  • Aliran remoteStream yang dikembalikan dari metode subscribe berisi data audio dan video mentah, yang dapat diakses melalui WebRTC MediaStream.

• unsubscribe: Menghentikan pemutaran RTS.

  aliRts.unsubscribe();

• muted: Mematikan audio.

  remoteStream.muted = true;

• createStream

  • Memperoleh aliran kamera lokal.

    /**
     * Mendapatkan aliran lokal localStream.
     * @param {Object} config Konfigurasi.
     * @param {boolean} config.audio Menentukan apakah akan menggunakan perangkat audio.
     * @param {boolean} config.video Menentukan apakah akan menggunakan perangkat video.
     * @param {boolean} config.skipProfile Menentukan apakah akan melewati profil. Kami menyarankan Anda mengatur parameter ini ke true jika kamera menampilkan layar hitam.
     * @returns {Promise}
     */
    AliRTS.createStream({
      audio: true,
      video: true,
    }).then((localStream) => {
      // Melihat pratinjau aliran yang diambil. mediaElement adalah tag media audio atau video.
      localStream.play(mediaElement);
    }).catch((err) => {
      // Gagal membuat aliran lokal.
    })

  • Memperoleh aliran berbagi layar lokal.

    /**
     * Hanya berbagi layar.
     */
    AliRTS.createStream({ screen: true });
    
    /**
     * Berbagi layar dan menangkap audio layar. Chrome di macOS mendukung penangkapan audio tab. Chrome di Windows mendukung penangkapan audio tab dan sistem.
     */
    AliRTS.createStream({ screen: { audio: true } });
    
    /**
     * Berbagi layar, menangkap audio layar, dan menangkap audio mikrofon.
     */
    AliRTS.createStream({ screen: { audio: true }, audio: true });
    
    /**
     * Parameter tangkapan kustom.
     * - Menonaktifkan pembatalan gema untuk audio.
     * - Chrome memprioritaskan tab saat ini.
     * Kode di atas hanya contoh. Anda dapat memberikan parameter apa pun yang sesuai dengan getDisplayMedia. Efek aktual tergantung pada dukungan browser terhadap parameter tersebut.
     */
    AliRTS.createStream({ screen: { audio: { echoCancellation: false }, preferCurrentTab: true } });

  • Memperoleh aliran kustom.

    /**
     * Mendapatkan aliran lokal localStream.
     * @param {Object} config Konfigurasi.
     * @param {boolean} config.custom Menentukan apakah akan memberikan aliran kustom.
     * @param {boolean} config.mediaStream Aliran kustom yang valid.
     * @returns {Promise}
     */
    AliRTS.createStream({
      // Aliran kustom
      custom: true,
      mediaStream: myStream // Berikan MediaStream yang valid (https://developer.mozilla.org/en-US/docs/Web/API/MediaStream).
    }).then((localStream) => {
      // Melihat pratinjau aliran yang diambil. mediaElement adalah tag media audio atau video.
      localStream.play(mediaElement);
    }).catch((err) => {
      // Gagal membuat aliran lokal.
    })

• publish: Memulai pengambilan aliran.

  /**
   * Memulai pengambilan aliran.
   * @param {string} pushUrl URL ingest.
   * @param {Object} localStream Aliran lokal yang dibuat oleh createStream.
   * @param {Object} [config] (Opsional) Konfigurasi kustom.
   * @param {string} [config.signalUrl] (Opsional) URL signaling.
   * @param {number} [config.retryTimes] (Opsional) Jumlah maksimum upaya koneksi ulang. Nilai default: 5.
   * @param {number} [config.retryInterval] (Opsional) Interval koneksi ulang. Satuan: ms. Nilai default: 2000.
   * @return {Promise}
   */
  aliRts.publish(pushUrl, localStream).then(() => {
    // Pengambilan aliran berhasil.
  }).catch((err) => {
    // Pengambilan aliran gagal.
  })

• unpublish: Menghentikan pengambilan aliran.

  aliRts.unpublish();

• on: Mendaftarkan listener event.

  /*
   * Saat kode kesalahan 10201 dikembalikan dalam onError, audio pada halaman web dimatikan.
   * Pengguna harus secara manual memicu event pada halaman web untuk mengaktifkan kembali audio. Hal ini memerlukan interaksi pengguna dan tidak dapat dikontrol melalui kode.
   * Panggil remoteStream.muted = false untuk mengaktifkan kembali audio.
   */
  aliRts.on("onError", (err)=> {
    console.log(`errorCode: ${err.errorCode}`);
    console.log(`message: ${err.message}`);
  })
  
  aliRts.on('reconnect', function(evt) {
    console.log('reconnect', evt); // Mendengarkan event koneksi ulang. evt adalah penyebab koneksi ulang.
  })
  
  const PLAY_EVENT = {
    CANPLAY: "canplay", // Pemutaran siap.
    WAITING: "waiting", // Terjadi tersendat.
    PLAYING: "playing", // Pemutaran dilanjutkan setelah tersendat.
    MEDIA: "media",     // Melaporkan status media real-time setiap detik.
  }
  aliRts.on('onPlayEvent', function(evt) {
    /* struktur data evt: {
          event: string, // PLAY_EVENT
          data: any, // Data
        } 
      */
    if (evt.event === PLAY_EVENT.CANPLAY) {
      console.log("Pemutaran siap");
    } else if (evt.event === PLAY_EVENT.WAITING) {
      console.log("Terjadi tersendat");
    } else if (evt.event === PLAY_EVENT.PLAYING) {
      console.log("Pemutaran dilanjutkan setelah tersendat");
    } else if (evt.event === PLAY_EVENT.MEDIA) {
      console.log("Data media real-time per detik: ", evt.data);
      /* struktur data evt.data: {
            url: string, // URL pemutaran
            aMsid: stirng, // ID audio. Nilai default: 'rts audio'.
            audio: {                          // (Tidak didukung oleh beberapa browser)
              bytesReceivedPerSecond: number, // bitrate audio
              lossRate: number, // tingkat kehilangan paket audio
              rtt: number, // RTT untuk audio dan video
            },
            vMsid: string, // ID video. Nilai default: 'rts video'.
            video: {                          // (Tidak didukung oleh beberapa browser)
              bytesReceivedPerSecond: number, // bitrate video
              framesDecodedPerSecond: number, // laju frame decoding
              fps: number, // laju frame rendering
              height: number, // tinggi resolusi
              width: number, // lebar resolusi
              lossRate: number, // tingkat kehilangan paket video
              rtt: number, // RTT untuk audio dan video
            },
            networkQuality: number, // skor kualitas jaringan
          }
          // Skor kualitas jaringan (networkQuality) dapat memiliki nilai berikut: 
          // 0: Tidak diketahui, 1: Sangat baik, 2: Baik, 3: Cukup, 4: Buruk, 5: Sangat buruk, 6: Tidak ada jaringan
        */
    }
  });

• off: Menghapus listener event.

  function handle() {};
  aliRts.on('onPlayEvent', handle);
  // Batalkan listener.
  aliRts.off('onPlayEvent', handle);

• once: Mendaftarkan listener event satu kali.

  aliRts.once('onPlayEvent', handle);