ApsaraVideo Live：Metode

Ikhtisar

Detail

• createClient: Membuat objek klien.

  var aliRts = AliRTS.createClient();

• isSupport: Memeriksa apakah lingkungan saat ini mendukung penarikan aliran.

  /**
   * 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(`tidak didukung kode kesalahan: ${err.errorCode}`);
    console.log(`tidak didukung pesan: ${err.message}`);
  })

• checkPublishSupport: Memeriksa apakah lingkungan saat ini mendukung pengambilan aliran.

  /**
    * checkPublishSupport memeriksa apakah lingkungan pengambilan aliran tersedia.
    * @return {Promise}
    */
  aliRts.checkPublishSupport().then(re => {
    console.log('informasi dukungan',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 kamera, mikrofon, dan speaker dapat diquery.
     // re.isScreenCaptureSupported: boolean; Menentukan apakah berbagi layar didukung.
     // re.isWebRTCSupported: boolean; Menentukan apakah Komunikasi Web Real-Time (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: Berlangganan aliran RTS.

  /**
   * Memulai penarikan aliran RTS.
   * @param {string} pullStreamUrl URL penarikan aliran. Tambahkan @subaudio=no atau @subvideo=no di akhir URL untuk tidak berlangganan aliran audio atau video.
   * @param {Object} [config] (Opsional) Konfigurasi kustom.
   * @param {string} [config.signalUrl] (Opsional) URL sinyal.
   * @param {number} [config.retryTimes] (Opsional) Jumlah maksimum upaya penyambungan ulang. Nilai default: 5.
   * @param {number} [config.retryInterval] (Opsional) Interval penyambungan ulang dalam milidetik. Nilai default: 2000.
   * @return {Promise}
   */
   aliRts.subscribe(pullStreamUrl).then((remoteStream) => {
    // mediaElement adalah tag media audio atau video.
    remoteStream.play(mediaElement);
    // Memanggil remoteStream.play mengikat aliran media ke tag media dan mencoba putar otomatis.
    // Jika Anda tidak ingin putar otomatis, lewatkan {autoplay:false} sebagai parameter kedua. Ini didukung mulai versi 2.2.4.
    // remoteStream.play(mediaElement, {autoplay:false});
  }).catch((err) => {
    // Berlangganan gagal.
  })

  Penting

  • Selama decoding audio dan video, RTS (RTS) tidak mendukung video yang berisi B-frame atau audio dalam format AAC. Jika video berisi B-frame, frame skipping mungkin terjadi. Jika audio dalam format AAC, kebisingan dapat muncul. Anda dapat mentranskode aliran untuk menghapus B-frame dari video dan mengonversi audio dari AAC ke format lain. Untuk informasi lebih lanjut, lihat Transcoding RTS.

  • Jika Anda mengimpor Web RTS SDK ke proyek uni-app, lewatkan HTMLVideoElement aktual ke metode remoteStream.play(). Uni-app membungkus tag <video>. Untuk mendapatkan HTMLVideoElement aktual, lihat metode dalam Demo. Sebagai contoh, di pages/index/index.vue, gunakan remoteStream.play(this.$refs.myVideo.$refs.video).

  • Jika Anda menggunakan metode subscribe untuk menarik aliran, objek remoteStream yang dikembalikan berisi data audio dan video asli. Anda dapat mengambil data ini menggunakan API MediaStream WebRTC.

• unsubscribe: Menghentikan pemutaran RTS.

  aliRts.unsubscribe();

• muted: Membisukan aliran.

  remoteStream.muted = true;

• createStream

  • Membuat aliran dari kamera lokal.

    /**
     * Dapatkan 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. Atur ini ke true jika kamera menampilkan layar hitam.
     * @returns {Promise}
     */
    AliRTS.createStream({
      audio: true,
      video: true,
    }).then((localStream) => {
      // Pratinjau konten aliran ingest. mediaElement adalah tag media audio atau video.
      localStream.play(mediaElement);
    }).catch((err) => {
      // Gagal membuat aliran lokal.
    })

  • Membuat aliran dari berbagi layar lokal.

    /**
     * Bagikan hanya video layar.
     */
    AliRTS.createStream({ screen: true });
    
    /**
     * Bagikan video layar dan tangkap audio layar. Chrome di macOS mendukung penangkapan tab audio. Chrome di Windows mendukung penangkapan tab dan sistem audio.
     */
    AliRTS.createStream({ screen: { audio: true } });
    
    /**
     * Bagikan video layar, tangkap audio layar, dan tangkap audio mikrofon.
     */
    AliRTS.createStream({ screen: { audio: true }, audio: true });
    
    /**
     * Parameter penangkapan kustom.
     * - Nonaktifkan pembatalan gema audio.
     * - Preferensi tab saat ini di Chrome.
     * Kode sebelumnya adalah contoh. Anda dapat melewatkan parameter apa pun yang sesuai dengan getDisplayMedia. Efek sebenarnya bergantung pada dukungan browser.
     */
    AliRTS.createStream({ screen: { audio: { echoCancellation: false }, preferCurrentTab: true } });

  • Dapatkan aliran kustom.

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

• publish: Memulai pengambilan aliran.

  /**
   * Mulai pengambilan aliran.
   * @param {string} pushUrl URL pengambilan.
   * @param {Object} localStream Aliran lokal yang dibuat oleh createStream.
   * @param {Object} [config] (Opsional) Konfigurasi kustom.
   * @param {string} [config.signalUrl] (Opsional) URL sinyal.
   * @param {number} [config.retryTimes] (Opsional) Jumlah maksimum upaya penyambungan ulang. Nilai default: 5.
   * @param {number} [config.retryInterval] (Opsional) Interval penyambungan ulang dalam milidetik. 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 pendengar callback untuk suatu event.

  /*
   * Jika kode kesalahan 10201 dikembalikan di onError, audio di halaman web dimatikan.
   * Pengguna harus secara manual memicu event di halaman web. Ini tidak dapat dikontrol oleh kode.
   * Panggil remoteStream.muted = false untuk membunyikan kembali.
   */
  aliRts.on("onError", (err)=> {
    console.log(`kode kesalahan: ${err.errorCode}`);
    console.log(`pesan: ${err.message}`);
  })
  
  aliRts.on('reconnect', function(evt) {
    console.log('reconnect', evt); // Dengarkan event reconnect. evt adalah alasan untuk penyambungan ulang.
  })
  
  const PLAY_EVENT = {
    CANPLAY: "canplay", // Pemutaran siap.
    WAITING: "waiting", // Tersendat.
    PLAYING: "playing", // Pemutaran pulih setelah tersendat.
    MEDIA: "media",     // Laporkan 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("Tersendat terjadi.");
    } 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 (default: 'rts audio').
            audio: {                          // (Tidak didukung oleh beberapa browser)
              bytesReceivedPerSecond: number, // Bitrate audio.
              lossRate: number, // Tingkat kehilangan paket audio.
              rtt: number, // RTT (dibagikan oleh audio dan video).
            },
            vMsid: string, // ID video (default: 'rts video').
            video: {                          // (Tidak didukung oleh beberapa browser)
              bytesReceivedPerSecond: number, // Bitrate video.
              framesDecodedPerSecond: number, // Laju frame yang didekode.
              fps: number, // Laju frame rendering.
              height: number, // Tinggi resolusi.
              width: number, // Lebar resolusi.
              lossRate: number, // Tingkat kehilangan paket video.
              rtt: number, // RTT (dibagikan oleh audio dan video).
            },
            networkQuality: number, // Skor kualitas jaringan.
          }
          // nilai skor networkQuality: 
          // 0: Tidak diketahui, 1: Sangat baik, 2: Baik, 3: Cukup, 4: Buruk, 5: Sangat buruk, 6: Tidak ada jaringan
        */
    }
  });

• off: Menghapus pendengar callback.

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

• once: Mendaftarkan pendengar satu kali untuk suatu event.

  aliRts.once('onPlayEvent', handle);