ApsaraVideo Live:Mengelola perangkat capture video

Referensi API

/**
 * @brief Mengatur zoom kamera.
 * @param zoom Faktor zoom. Nilainya berkisar dari 1 hingga nilai zoom maksimum yang didukung kamera.
 * @return
 * - 0: Berhasil.
 * - Nilai bukan nol: Gagal.
 * @note API ini hanya tersedia di iOS dan Android.
 */
public abstract int setCameraZoom(float zoom);

 /**
 * @brief Mendapatkan faktor zoom maksimum kamera.
 * @return Faktor zoom maksimum kamera.
 */
public abstract float GetCameraMaxZoomFactor();

/**
 * @brief Mendapatkan faktor zoom saat ini dari kamera.
 * @return Faktor zoom saat ini dari kamera.
 */
public abstract float GetCurrentZoom();

Contoh

// Dapatkan informasi zoom.
private void initZoomSeekBar() {
    if (mAliRtcEngine != null) {
        zoomSeekBar.setEnabled(true);
        // Dapatkan nilai zoom maksimum.
        float maxZoom = mAliRtcEngine.GetCameraMaxZoomFactor();
        float currZoom = mAliRtcEngine.GetCurrentZoom();
        // Atur rentang SeekBar (dari 1.0 hingga maxZoom, dengan langkah 0.1).
        if(maxZoom >= 1.0) {
            int maxProgress = (int)((maxZoom - 1) * 10);
            zoomSeekBar.setMax(maxProgress);
            int currProgress = (int)((currZoom - 1) * 10);
            zoomSeekBar.setProgress(currProgress);
        } else{
            zoomSeekBar.setEnabled(false);
        }
    }
}
// Atur zoom.
zoomSeekBar.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() {
    @Override
    public void onProgressChanged(SeekBar seekBar, int i, boolean b) {
        if(mAliRtcEngine != null) {
            float newZoom = (float)((i+10) / 10.0);
            mAliRtcEngine.setCameraZoom(newZoom);
            zoomTextView.setText(String.format("%.1f", newZoom));
        }
    }

    @Override
    public void onStartTrackingTouch(SeekBar seekBar) {
    }

    @Override
    public void onStopTrackingTouch(SeekBar seekBar) {
    }
});

// Dapatkan informasi zoom.
self.cameraZoomSlider.isEnabled = true
let maxZoom = rtcEngine.getCameraMaxZoomFactor()
let currZoom = rtcEngine.getCurrentZoom()
"Get maxZoom=\(maxZoom), currZoom=\(currZoom)".printLog()

self.cameraZoomSlider.minimumValue = 1.0
if maxZoom > 1.0 {
    self.cameraZoomSlider.maximumValue = maxZoom
} else {
    self.cameraZoomSlider.isEnabled = false
}
if currZoom >= 1.0 && currZoom <= maxZoom {
    self.cameraZoomSlider.value = currZoom
    self.cameraZoomValueLabel.text = String(format: "%.1f", self.cameraZoomSlider.value)
}
else {
    self.cameraZoomSlider.value = self.cameraZoomSlider.minimumValue
    self.cameraZoomValueLabel.text = "\(self.cameraZoomSlider.minimumValue)"
}

// Atur zoom.
@IBOutlet weak var cameraZoomSlider: UISlider!
@IBOutlet weak var cameraZoomValueLabel: UILabel!
@IBAction func onCameraZoomChanged(_ sender: UISlider) {
    let currValue = sender.value
    self.cameraZoomValueLabel.text = String(format: "%.1f", currValue)
    self.rtcEngine?.setCameraZoom(currValue)
}

private handleZoomChange(value: number): void {
  if (!this.rtcEngine) {
    return;
  }

  // Hitung nilai zoom berdasarkan progres: zoom = 1.0 + (value / 10.0).
  const newZoom = 1.0 + (value / 10.0);

  // Batasi nilai zoom antara 1.0 dan 10.0.
  const clampedZoom = Math.max(1.0, Math.min(10.0, newZoom));

  this.rtcEngine.setCameraZoom(clampedZoom);
  this.zoomValue = clampedZoom.toFixed(1);

  console.info(`Set zoom: ${clampedZoom}`);
}

Referensi API

/**
 * @brief Mengatur exposure kamera.
 * @param exposure Nilai exposure.
 * @return
 * - 0: Berhasil.
 * - Nilai bukan nol: Gagal.
 */
public abstract int SetExposure(float exposure);

/**
 * @brief Mendapatkan exposure kamera saat ini.
 * @return Exposure kamera saat ini.
 */
public abstract float GetCurrentExposure();

/**
 * @brief Mendapatkan exposure kamera minimum.
 * @return Exposure kamera minimum.
 */
public abstract float GetMinExposure();

/**
 * @brief Mendapatkan exposure kamera maksimum.
 * @return Exposure kamera maksimum.
 */
public abstract float GetMaxExposure();

Contoh

// Dapatkan informasi exposure.
private void initExposureSeekBar() {
    if (mAliRtcEngine != null) {
        exposureSeekBar.setEnabled(true);
        // Dapatkan nilai exposure maksimum.
        float maxExposure = mAliRtcEngine.GetMaxExposure();
        // Dapatkan nilai exposure minimum.
        float minExposure = mAliRtcEngine.GetMinExposure();
        float currExposure = mAliRtcEngine.GetCurrentExposure();
        if(maxExposure > minExposure) {
            // Atur ulang rentang SeekBar.
            int maxProgress = (int)((maxExposure - minExposure) * 10);
            exposureSeekBar.setMax(maxProgress);
            int currProgress = (int)((currExposure - minExposure) * 10);
            exposureSeekBar.setProgress(currProgress);
        } else {
            exposureSeekBar.setEnabled(false);
        }
    }
}
// Atur exposure.
exposureSeekBar.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() {
    @Override
    public void onProgressChanged(SeekBar seekBar, int i, boolean b) {
        if(mAliRtcEngine != null) {
            float minExposure = mAliRtcEngine.GetMinExposure();
            float newExposure = minExposure + (float)(i / 10.0);

            mAliRtcEngine.SetExposure(newExposure);
            exposureTextView.setText(String.format("% .1f", newExposure));
        }
    }

    @Override
    public void onStartTrackingTouch(SeekBar seekBar) {
    }

    @Override
    public void onStopTrackingTouch(SeekBar seekBar) {
    }
});

// Dapatkan informasi exposure perangkat.
self.cameraExposureSlider.isEnabled = true
let minExposure = rtcEngine.getMinExposure()
let maxExposure = rtcEngine.getMaxExposure()
let currExposure = rtcEngine.getCurrentExposure()
"Get minExposure=\(minExposure), maxExposure=\(maxExposure), currExposure=\(currExposure)".printLog()
if maxExposure > minExposure {
    self.cameraExposureSlider.minimumValue = minExposure
    self.cameraExposureSlider.maximumValue = maxExposure
} else {
    self.cameraExposureSlider.isEnabled = false
}
if currExposure >= minExposure && currExposure <= maxExposure {
    self.cameraExposureSlider.value = currExposure
    self.cameraExposureValueLabel.text = String(format: "%.1f", self.cameraExposureSlider.value)
}
else {
    self.cameraExposureSlider.value = self.cameraExposureSlider.minimumValue
    self.cameraExposureValueLabel.text = "\(self.cameraExposureSlider.minimumValue)"
}
// Atur exposure.
@IBOutlet weak var cameraExposureValueLabel: UILabel!
@IBOutlet weak var cameraExposureSlider: UISlider!
@IBAction func onCameraExposureChanged(_ sender: UISlider) {
    let currValue = sender.value
    self.cameraExposureValueLabel.text = String(format: "%.1f", currValue)
    self.rtcEngine?.setExposure(currValue)
}

// Tangani perubahan exposure.
private handleExposureChange(value: number): void {
  if (!this.rtcEngine) {
    return;
  }
  // Rumus konversi: nilai exposure = nilai progres / 10.
  const actualValue = value / 10.0;
  // Batasi nilai exposure antara -12.0 dan 12.0.
  const clampedExposure = Math.max(-12.0, Math.min(12.0, actualValue));
  // Perbarui status.
  this.exposureSliderValue = value;
  this.exposureValue = this.formatExposureValue(clampedExposure);
  // Panggil engine RTC untuk mengatur kompensasi exposure.
  try {
    this.rtcEngine.setExposure(clampedExposure);
    console.info(`Set kompensasi exposure: ${clampedExposure}`);
  } catch (error) {
    console.error('Gagal mengatur kompensasi exposure:', error);
  }
}

Referensi API

/**
 * @brief Memeriksa apakah kamera mendukung pengaturan titik exposure manual.
 * @return
 * - true: Didukung.
 * - false: Tidak didukung.
 * @note API ini hanya tersedia di iOS dan Android dan digunakan untuk memeriksa apakah titik exposure dapat diatur untuk kamera saat ini.
 */
public abstract boolean isCameraExposurePointSupported();
/**
 * @brief Mengatur titik exposure kamera.
 * @param x Koordinat x yang dinormalisasi. Nilainya berkisar dari 0 hingga 1.
 * @param y Koordinat y yang dinormalisasi. Nilainya berkisar dari 0 hingga 1.
 * @return
 * - 0: Berhasil.
 * - Nilai bukan nol: Gagal.
 * @note API ini hanya tersedia di iOS dan Android. Setelah metode ini dipanggil, kamera melakukan penyesuaian exposure satu kali di titik yang ditentukan dan mempertahankan nilai exposure tersebut.
 */
public abstract int setCameraExposurePoint(float x, float y);

Contoh

// Atur titik exposure secara manual.
mLocalViewGestureDetector = new GestureDetector(this, new GestureDetector.SimpleOnGestureListener() {
    @Override
    public boolean onDoubleTap(@NonNull MotionEvent e) {
        // Tangani double-tap.
        // ...
        return true;
    }
    @Override
    public boolean onSingleTapConfirmed(@NonNull MotionEvent e) {
        // Tangani single-tap.
        if(mAliRtcEngine != null && mAliRtcEngine.isCameraExposurePointSupported()) {
            float[] normalizedCoords = getNormalizedCoordinates(e.getX(), e.getY());
            if (normalizedCoords[0] != -1 && normalizedCoords[1] != -1) {
                mAliRtcEngine.setCameraExposurePoint(normalizedCoords[0], normalizedCoords[1]);
                mCameraExposurePointX.setText(String.format("%.2f", normalizedCoords[0]));
                mCameraExposurePointY.setText(String.format("%.2f", normalizedCoords[1]));
            }
        }
        return true;
    }
});

@objc func handleSeatViewTap(_ gesture: UITapGestureRecognizer) {
    guard let localSeatView = self.localPreviewSeatView else {
        return
    }
    guard let rtcEngine = self.rtcEngine, rtcEngine.isCameraExposurePointSupported() else { return }


    let tapPoint = gesture.location(in: localSeatView)
    // Konversi koordinat ketukan menjadi koordinat yang dinormalisasi (rentang 0-1) dari frame video.
    let normalizedX = tapPoint.x / localSeatView.bounds.width
    let normalizedY = tapPoint.y / localSeatView.bounds.height

    rtcEngine.setCameraExposurePoint(CGPoint(x: normalizedX, y: normalizedY))
    self.cameraExposurePointXTextField.text = String(format: "%.2f", normalizedX)
    self.cameraExposurePointYTextField.text = String(format: "%.2f", normalizedY)
}

private handleSingleTap(touchX: number, touchY: number): void {
  if (!this.rtcEngine) {
    return;
  }
  // Dapatkan koordinat yang dinormalisasi.
  const normalizedCoords = this.getNormalizedCoordinates(touchX, touchY);
  if (normalizedCoords[0] !== -1 && normalizedCoords[1] !== -1) {
    this.rtcEngine.setCameraExposurePoint(normalizedCoords[0], normalizedCoords[1]);
    this.exposurePointX = normalizedCoords[0].toFixed(2);
    this.exposurePointY = normalizedCoords[1].toFixed(2);
    console.info('Set titik exposure:', this.exposurePointX, this.exposurePointY);
  }
}

Referensi API

/**
 * @brief Memeriksa apakah kamera mendukung fokus manual.
 * @return
 * - true: Didukung.
 * - false: Tidak didukung.
 * @note API ini hanya tersedia di iOS dan Android dan digunakan untuk memeriksa apakah titik fokus dapat diatur untuk kamera saat ini.
 */
public abstract boolean isCameraFocusPointSupported();
/**
 * @brief Mengatur titik fokus manual untuk kamera.
 * @param x Nilai koordinat x (dinormalisasi).
 * @param y Nilai koordinat y (dinormalisasi).
 * @return
 * - 0: Berhasil.
 * - Nilai bukan nol: Gagal.
 * @note API ini hanya tersedia di iOS dan Android. Setelah metode ini dipanggil, kamera melakukan penyesuaian fokus satu kali di titik yang ditentukan dan mempertahankan nilai fokus tersebut.
 */
public abstract int setCameraFocusPoint(float x, float y);

Contoh

Contoh berikut menunjukkan cara mengatur titik exposure saat single tap dan titik fokus saat double tap.

mLocalViewGestureDetector = new GestureDetector(this, new GestureDetector.SimpleOnGestureListener() {
    @Override
    public boolean onDoubleTap(@NonNull MotionEvent e) {
        // Tangani double-tap.
        if(mAliRtcEngine != null && mAliRtcEngine.isCameraFocusPointSupported()) {
            float[] normalizedCoords = getNormalizedCoordinates(e.getX(), e.getY());
            if (normalizedCoords[0] != -1 && normalizedCoords[1] != -1) {
                mAliRtcEngine.setCameraFocusPoint(normalizedCoords[0], normalizedCoords[1]);
                mCameraFocusPointX.setText(String.format("%.2f", normalizedCoords[0]));
                mCameraFocusPointY.setText(String.format("%.2f", normalizedCoords[1]));
            }
        }
        return true;
    }
    @Override
    public boolean onSingleTapConfirmed(@NonNull MotionEvent e) {
        // Tangani single-tap.
        // ...
        return true;
    }
});

@objc func handleSeatViewDoubleTap(_ gesture: UITapGestureRecognizer) {
    guard let localSeatView = self.localPreviewSeatView else {
        return
    }
    guard let rtcEngine = self.rtcEngine, rtcEngine.isCameraFocusPointSupported() else { return }
    
    let tapPoint = gesture.location(in: localSeatView)
    // Konversi koordinat ketukan menjadi koordinat yang dinormalisasi (rentang 0-1) dari frame video.
    let normalizedX = tapPoint.x / localSeatView.bounds.width
    let normalizedY = tapPoint.y / localSeatView.bounds.height
    
    rtcEngine.setCameraFocus(CGPoint(x: normalizedX, y: normalizedY))
    self.cameraFocusPointXTextField.text = String(format: "%.2f", normalizedX)
    self.cameraFocusPointYTextField.text = String(format: "%.2f", normalizedY)
}

private handleDoubleTap(touchX: number, touchY: number): void {
  if (!this.rtcEngine) {
    return;
  }
  // Dapatkan koordinat yang dinormalisasi.
  const normalizedCoords = this.getNormalizedCoordinates(touchX, touchY);
  if (normalizedCoords[0] !== -1 && normalizedCoords[1] !== -1) {
    this.rtcEngine.setCameraFocusPoint(normalizedCoords[0], normalizedCoords[1]);
    this.focusPointX = normalizedCoords[0].toFixed(2);
    this.focusPointY = normalizedCoords[1].toFixed(2);
    console.info('Set titik fokus:', this.focusPointX, this.focusPointY);
  }
}

Referensi API

/**
 * @brief Memeriksa apakah kamera mendukung fitur auto-focus pada wajah.
 * @return
 * - true: Didukung.
 * - false: Tidak didukung.
 * @note API ini hanya tersedia di iOS dan Android. API ini mengembalikan false jika kamera dimatikan. 
 *       Jika kamera dinyalakan dan mendukung deteksi wajah serta auto-focus, API ini mengembalikan true.
 */
public abstract boolean isCameraAutoFocusFaceModeSupported();

/**
 * @brief Mengaktifkan atau menonaktifkan fitur auto-focus pada wajah.
 * @param enable
 * - true: Aktifkan.
 * - false: Nonaktifkan.
 * @return
 * - true: Berhasil.
 * - false: Gagal.
 * @note API ini hanya tersedia di iOS dan Android. Jika {@link AliRtcEngine#isCameraAutoFocusFaceModeSupported} mengembalikan true
 *       dan Anda mengatur enable ke true, kamera akan terus-menerus memfokuskan pada wajah yang terdeteksi.
 */
public abstract boolean setCameraAutoFocusFaceModeEnabled(boolean enable);

Contoh

if (mAliRtcEngine.isCameraAutoFocusFaceModeSupported()) {
    mAliRtcEngine.setCameraAutoFocusFaceModeEnabled(isChecked);
}

@IBAction func onCameraAudoFocusSwitch(_ sender: UISwitch) {
    if ((self.rtcEngine?.isCameraAutoFocusFaceModeSupported()) != nil) {
        self.rtcEngine?.setCameraAutoFocusFaceModeEnabled(sender.isOn)
    }
}

Referensi API

/**
 * @brief Mengaktifkan atau menonaktifkan senter kamera.
 * @param flash Menentukan apakah senter akan diaktifkan.
 * @return
 * - 0: Berhasil.
 * - Nilai bukan nol: Gagal.
 * @note API ini hanya tersedia di iOS dan Android. Biasanya, hanya kamera belakang yang memiliki senter.
 */
public abstract int setCameraFlash(boolean flash);

Contoh

mCameraFlashSwitch = findViewById(R.id.camera_flash_switch);
mCameraFlashSwitch.setEnabled(false);
mCameraFlashSwitch.setOnCheckedChangeListener((buttonView, isChecked) -> {
    if (mAliRtcEngine != null) {
        mAliRtcEngine.setCameraFlash(isChecked);
    }
});

@IBOutlet weak var cameraFlashSwitch: UISwitch!
@IBAction func onCameraFlashSwitch(_ sender: UISwitch) {
    if self.rtcEngine?.getCurrentCameraDirection() == .back {
        self.rtcEngine?.setCameraFlash(sender.isOn)
    }
}

private handleFlashChange(value: boolean): void {
  if (!this.rtcEngine) {
    return;
  }

  this.rtcEngine.setCameraFlash(value);
}