สถาปัตยกรรม CameraX

หน้านี้จะกล่าวถึงสถาปัตยกรรมของ CameraX รวมถึงโครงสร้าง, วิธีทำงานกับ API, วิธีทำงานกับวงจร และวิธีรวมกรณีการใช้งาน

โครงสร้าง CameraX

คุณสามารถใช้ CameraX เพื่อเชื่อมต่อกับกล้องของอุปกรณ์ผ่าน Abstraction ที่เรียกว่า Use Case กรณีการใช้งานมีดังนี้

• ดูตัวอย่าง: ยอมรับแพลตฟอร์มสำหรับแสดงตัวอย่าง เช่น PreviewView
• การวิเคราะห์รูปภาพ: ให้บัฟเฟอร์ที่ CPU เข้าถึงได้สำหรับการวิเคราะห์ เช่น แมชชีนเลิร์นนิง
• การจับภาพ: จับภาพและบันทึกรูปภาพ
• การจับภาพวิดีโอ: จับภาพวิดีโอและเสียงด้วย VideoCapture

กรณีการใช้งานสามารถรวมกันและใช้งานพร้อมกันได้ เช่น แอปอาจอนุญาตให้ผู้ใช้ดูรูปภาพที่กล้องเห็นโดยใช้กรณีการใช้งานตัวอย่าง มีกรณีการใช้งานการวิเคราะห์รูปภาพที่ระบุว่าผู้คนในรูปภาพยิ้มหรือไม่ และรวมกรณีการใช้งานการจับภาพเพื่อถ่ายภาพเมื่อผู้คนยิ้ม

รูปแบบ API

หากต้องการใช้งานไลบรารี คุณต้องระบุสิ่งต่อไปนี้

• กรณีการใช้งานที่ต้องการพร้อมด้วยตัวเลือกการกำหนดค่า
• สิ่งที่ต้องทำกับข้อมูลเอาต์พุตโดยการแนบ Listener
• ขั้นตอนที่ต้องการ เช่น กรณีที่ควรเปิดใช้กล้องและกรณีที่ควรสร้างข้อมูล โดยเชื่อมโยง Use Case กับวงจรชีวิตของสถาปัตยกรรม Android

วิธีเขียนแอป CameraX มี 2 วิธี ได้แก่ CameraController (เหมาะมากหาก คุณต้องการวิธีที่ง่ายที่สุดในการใช้ CameraX) หรือ CameraProvider (เหมาะอย่างยิ่งหากคุณ ต้องการความยืดหยุ่นมากขึ้น)

คอนโทรลเลอร์กล้อง

CameraController มีฟังก์ชันหลักส่วนใหญ่ของ CameraX อยู่ใน ต้องใช้โค้ดการตั้งค่าเพียงเล็กน้อย และจัดการกับกล้องโดยอัตโนมัติ ไม่ว่าจะเป็นการเริ่มต้นใช้งาน การจัดการ Use Case การหมุนเป้าหมาย การแตะเพื่อโฟกัส การบีบนิ้วเพื่อซูม และอื่นๆ คลาสที่เฉพาะเจาะจงซึ่งขยาย CameraController คือ LifecycleCameraController

Kotlin

val previewView: PreviewView = viewBinding.previewView
var cameraController = LifecycleCameraController(baseContext)
cameraController.bindToLifecycle(this)
cameraController.cameraSelector = CameraSelector.DEFAULT_BACK_CAMERA
previewView.controller = cameraController

Java

PreviewView previewView = viewBinding.previewView;
LifecycleCameraController cameraController = new LifecycleCameraController(baseContext);
cameraController.bindToLifecycle(this);
cameraController.setCameraSelector(CameraSelector.DEFAULT_BACK_CAMERA);
previewView.setController(cameraController);

UseCase เริ่มต้นของ CameraController คือ Preview, ImageCapture และ ImageAnalysis หากต้องการปิดImageCaptureหรือImageAnalysis หรือเพื่อปิด VideoCapture เปิดอยู่ ให้ใช้ setEnabledUseCases()

สำหรับการใช้งาน CameraController เพิ่มเติม โปรดดู ตัวอย่างตัวสแกนคิวอาร์โค้ด หรือ วิดีโอข้อมูลเบื้องต้นเกี่ยวกับ CameraController

ผู้ให้บริการกล้อง

CameraProvider ยังคงใช้งานง่าย แต่เนื่องจากนักพัฒนาแอปเป็นผู้จัดการ ในการตั้งค่ามากขึ้น คุณก็จะมีโอกาสปรับแต่งการกำหนดค่าได้มากขึ้น เช่น การเปิดใช้การหมุนภาพเอาต์พุตหรือการตั้งค่ารูปแบบภาพเอาต์พุตใน ImageAnalysis คุณยังใช้ Surface ที่กําหนดเองเพื่อให้แสดงตัวอย่างจากกล้องได้ เพื่อความยืดหยุ่นที่มากขึ้น ในขณะที่สำหรับ CameraController คุณจะต้องใช้ PreviewView การใช้รหัส Surface ที่มีอยู่อาจเป็นประโยชน์หาก ไปยังส่วนอื่นๆ ของแอปอยู่แล้ว

คุณกําหนดค่า Use Case โดยใช้เมธอด set() และสรุปด้วยเมธอด build() ออบเจ็กต์ Use Case แต่ละรายการจะมีชุด API สำหรับ Use Case ที่เฉพาะเจาะจง สำหรับ ตัวอย่างเช่น Use Case การจับภาพจะมีการเรียกเมธอด takePicture()

แทนที่แอปพลิเคชันจะเรียกใช้เมธอดเริ่มต้นและหยุดที่เจาะจงใน onResume() และ onPause() แอปพลิเคชันจะระบุวงจรเพื่อเชื่อมโยงกล้องโดยใช้ cameraProvider.bindToLifecycle() จากนั้นวงจรดังกล่าวจะแจ้งให้ CameraX ทราบเมื่อใดควรกำหนดค่าเซสชันการจับภาพของกล้อง และตรวจสอบว่าสถานะของกล้องมีการเปลี่ยนแปลงอย่างเหมาะสมเพื่อให้สอดคล้องกับการเปลี่ยนผ่านของวงจร

โปรดดูขั้นตอนการติดตั้งใช้งานสำหรับแต่ละกรณีการใช้งานที่หัวข้อติดตั้งใช้งาน แสดงตัวอย่าง, วิเคราะห์ รูปภาพ, รูปภาพ จับภาพและการจับภาพวิดีโอ

กรณีการใช้งานตัวอย่างโต้ตอบกับ Surface เพื่อแสดงผล แอปพลิเคชันสร้าง Use Case ด้วยตัวเลือกการกําหนดค่าโดยใช้โค้ดต่อไปนี้

Kotlin

val preview = Preview.Builder().build()
val viewFinder: PreviewView = findViewById(R.id.previewView)

// The use case is bound to an Android Lifecycle with the following code
val camera = cameraProvider.bindToLifecycle(lifecycleOwner, cameraSelector, preview)

// PreviewView creates a surface provider and is the recommended provider
preview.setSurfaceProvider(viewFinder.getSurfaceProvider())

Java

Preview preview = new Preview.Builder().build();
PreviewView viewFinder = findViewById(R.id.view_finder);

// The use case is bound to an Android Lifecycle with the following code
Camera camera = cameraProvider.bindToLifecycle(lifecycleOwner, cameraSelector, preview);

// PreviewView creates a surface provider, using a Surface from a different
// kind of view will require you to implement your own surface provider.
preview.previewSurfaceProvider = viewFinder.getSurfaceProvider();

ดูโค้ดตัวอย่างเพิ่มเติมได้ในแอปตัวอย่างอย่างเป็นทางการของ CameraX

วงจรชีวิตของ CameraX

CameraX จะตรวจสอบวงจรเพื่อกำหนดเวลาเปิดกล้อง เวลาสร้างเซสชันการจับภาพ และเวลาหยุดและปิด Use Case API มีวิธีการเรียกและ Callback เพื่อตรวจสอบความคืบหน้า

ตามที่อธิบายไว้ในรวมกรณีการใช้งาน คุณสามารถเชื่อมโยง ให้เป็นวงจรเดียว เมื่อแอปของคุณต้องรองรับกรณีการใช้งานที่ ไม่สามารถรวมได้ คุณสามารถทำอย่างใดอย่างหนึ่งต่อไปนี้

• จัดกลุ่มกรณีการใช้งานที่เข้ากันได้ไว้ด้วยกันเป็นส่วนมากกว่า 1 ส่วน แล้วสลับไปมาระหว่างส่วนต่างๆ
• สร้างคอมโพเนนต์วงจรที่กําหนดเองและใช้เพื่อควบคุมวงจรของกล้องด้วยตนเอง

หากคุณยกเลิกการเชื่อมโยงเจ้าของวงจรชีวิตของมุมมองและ Use Case ของกล้อง (เช่น หากคุณใช้วงจรที่กำหนดเองหรือ retain fragment) คุณต้องตรวจสอบว่า Use Case ทั้งหมดไม่ได้เชื่อมโยงกับ CameraX โดยใช้ ProcessCameraProvider.unbindAll() หรือยกเลิกการเชื่อมโยงแต่ละ Use Case แยกกัน หรือเมื่อคุณผูก ไปจนถึงวงจร คุณสามารถให้ CameraX จัดการการเปิดและปิดเซสชันการบันทึก รวมถึงยกเลิกการเชื่อมโยงกรณีการใช้งาน

หากฟังก์ชันการทำงานของกล้องทั้งหมดสอดคล้องกับวงจรชีวิตของคอมโพเนนต์ที่รับรู้วงจรชีวิตรายการเดียว เช่น AppCompatActivity หรือเศษ AppCompat การใช้วงจรชีวิตของคอมโพเนนต์นั้นเมื่อเชื่อมโยง Use Case ที่ต้องการทั้งหมดจะช่วยให้ฟังก์ชันการทำงานของกล้องพร้อมใช้งานเมื่อคอมโพเนนต์ที่รับรู้วงจรชีวิตทำงานอยู่ และระบบจะกำจัดคอมโพเนนต์ดังกล่าวอย่างปลอดภัยโดยไม่สิ้นเปลืองทรัพยากร

LifecycleOwners ที่กำหนดเอง

สำหรับกรณีขั้นสูง คุณสามารถสร้าง LifecycleOwnerเพื่อเปิดใช้ เพื่อควบคุมวงจรเซสชัน CameraX อย่างชัดเจนแทนที่จะผูกกับ Android มาตรฐาน LifecycleOwner

ตัวอย่างโค้ดต่อไปนี้แสดงวิธีสร้าง LifecycleOwner ที่กำหนดเองอย่างง่าย

Kotlin

class CustomLifecycle : LifecycleOwner {
    private val lifecycleRegistry: LifecycleRegistry

    init {
        lifecycleRegistry = LifecycleRegistry(this);
        lifecycleRegistry.markState(Lifecycle.State.CREATED)
    }
    ...
    fun doOnResume() {
        lifecycleRegistry.markState(State.RESUMED)
    }
    ...
    override fun getLifecycle(): Lifecycle {
        return lifecycleRegistry
    }
}

Java

public class CustomLifecycle implements LifecycleOwner {
    private LifecycleRegistry lifecycleRegistry;
    public CustomLifecycle() {
        lifecycleRegistry = new LifecycleRegistry(this);
        lifecycleRegistry.markState(Lifecycle.State.CREATED);
    }
   ...
   public void doOnResume() {
        lifecycleRegistry.markState(State.RESUMED);
    }
   ...
    public Lifecycle getLifecycle() {
        return lifecycleRegistry;
    }
}

เมื่อใช้ LifecycleOwner นี้ แอปของคุณสามารถใส่การเปลี่ยนสถานะได้ตามต้องการ ในโค้ด หากต้องการข้อมูลเพิ่มเติมเกี่ยวกับการใช้ฟังก์ชันนี้ในแอป ดูการติดตั้งใช้งานคู่มือที่กำหนดเอง LifecycleOwner

กรณีการใช้งานพร้อมกัน

กรณีการใช้งานสามารถทํางานพร้อมกันได้ แม้ว่าคุณจะเชื่อมโยง Use Case กับวงจรการทํางานตามลําดับได้ แต่การเชื่อมโยง Use Case ทั้งหมดด้วยการเรียกใช้ CameraProcessProvider.bindToLifecycle() ครั้งเดียวจะดีกว่า ดูข้อมูลเพิ่มเติมเกี่ยวกับแนวทางปฏิบัติแนะนำสำหรับการเปลี่ยนแปลงการกำหนดค่าได้ที่จัดการการเปลี่ยนแปลงการกำหนดค่า

ในตัวอย่างโค้ดต่อไปนี้ แอปจะระบุ Use Case 2 รายการที่จะสร้างและเรียกใช้พร้อมกัน และยังระบุวงจรที่ใช้สำหรับทั้ง 2 กรณีการใช้งานด้วย เพื่อให้ทั้ง 2 รายการเริ่มต้นและหยุดตามวงจร

Kotlin

private lateinit var imageCapture: ImageCapture

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)

    val cameraProviderFuture = ProcessCameraProvider.getInstance(this)

    cameraProviderFuture.addListener(Runnable {
        // Camera provider is now guaranteed to be available
        val cameraProvider = cameraProviderFuture.get()

        // Set up the preview use case to display camera preview.
        val preview = Preview.Builder().build()

        // Set up the capture use case to allow users to take photos.
        imageCapture = ImageCapture.Builder()
                .setCaptureMode(ImageCapture.CAPTURE_MODE_MINIMIZE_LATENCY)
                .build()

        // Choose the camera by requiring a lens facing
        val cameraSelector = CameraSelector.Builder()
                .requireLensFacing(CameraSelector.LENS_FACING_FRONT)
                .build()

        // Attach use cases to the camera with the same lifecycle owner
        val camera = cameraProvider.bindToLifecycle(
                this as LifecycleOwner, cameraSelector, preview, imageCapture)

        // Connect the preview use case to the previewView
        preview.setSurfaceProvider(
                previewView.getSurfaceProvider())
    }, ContextCompat.getMainExecutor(this))
}

Java

private ImageCapture imageCapture;

@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    PreviewView previewView = findViewById(R.id.previewView);

    ListenableFuture<ProcessCameraProvider> cameraProviderFuture =
            ProcessCameraProvider.getInstance(this);

    cameraProviderFuture.addListener(() -> {
        try {
            // Camera provider is now guaranteed to be available
            ProcessCameraProvider cameraProvider = cameraProviderFuture.get();

            // Set up the view finder use case to display camera preview
            Preview preview = new Preview.Builder().build();

            // Set up the capture use case to allow users to take photos
            imageCapture = new ImageCapture.Builder()
                    .setCaptureMode(ImageCapture.CAPTURE_MODE_MINIMIZE_LATENCY)
                    .build();

            // Choose the camera by requiring a lens facing
            CameraSelector cameraSelector = new CameraSelector.Builder()
                    .requireLensFacing(lensFacing)
                    .build();

            // Attach use cases to the camera with the same lifecycle owner
            Camera camera = cameraProvider.bindToLifecycle(
                    ((LifecycleOwner) this),
                    cameraSelector,
                    preview,
                    imageCapture);

            // Connect the preview use case to the previewView
            preview.setSurfaceProvider(
                    previewView.getSurfaceProvider());
        } catch (InterruptedException | ExecutionException e) {
            // Currently no exceptions thrown. cameraProviderFuture.get()
            // shouldn't block since the listener is being called, so no need to
            // handle InterruptedException.
        }
    }, ContextCompat.getMainExecutor(this));
}

CameraX สามารถใช้ 1 อินสแตนซ์ต่อ Preview พร้อมกันได้ VideoCapture, ImageAnalysis และ ImageCapture นอกจากนี้

• กรณีการใช้งานทุกอย่างทำงานได้ในตัวเอง เช่น แอปสามารถบันทึกวิดีโอได้โดยไม่ต้องใช้การแสดงตัวอย่าง
• เมื่อเปิดใช้ส่วนขยาย จะมีเพียงชุดค่าผสม ImageCapture และ Preview เท่านั้นที่รับประกันว่าจะใช้งานได้ คุณอาจเพิ่ม ImageAnalysis ไม่ได้ ทั้งนี้ขึ้นอยู่กับการใช้งาน OEM และส่วนขยายจะเปิดใช้งานไม่ได้สำหรับ Use Case ของ VideoCapture ดูวิธีการตั้งค่า เอกสารอ้างอิงส่วนขยาย เพื่อดูรายละเอียด
• กล้องบางตัวอาจรองรับการใช้งานร่วมกันที่ โหมดความละเอียดที่ต่ำลง แต่ไม่สามารถรองรับชุดค่าผสมเดียวกันในบางโหมด ความละเอียดที่สูงขึ้นได้
• ในอุปกรณ์ที่มีฮาร์ดแวร์ของกล้องระดับ FULL หรือต่ำกว่า ซึ่งรวม Preview VideoCapture และ ImageCapture หรือ ImageAnalysis อาจบังคับใช้ CameraX เพื่อทำสำเนาสตรีม PRIV ของกล้องสำหรับ Preview และ VideoCapture ช่วงเวลานี้ การทำซ้ำที่เรียกว่าการแชร์สตรีม จะช่วยให้สามารถใช้ แต่มาพร้อมกับค่าใช้จ่ายเมื่อความต้องการในการประมวลผลเพิ่มขึ้น คุณอาจพบปัญหาเวลาในการตอบสนองที่นานขึ้นเล็กน้อยและอายุการใช้งานแบตเตอรี่ที่ลดลง

คุณสามารถดูระดับฮาร์ดแวร์ที่รองรับได้จาก Camera2CameraInfo ตัวอย่างเช่น โค้ดต่อไปนี้จะตรวจสอบว่ากล้องหลังเริ่มต้นเป็นอุปกรณ์ LEVEL_3 หรือไม่

Kotlin

@androidx.annotation.OptIn(ExperimentalCamera2Interop::class)
fun isBackCameraLevel3Device(cameraProvider: ProcessCameraProvider) : Boolean {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
        return CameraSelector.DEFAULT_BACK_CAMERA
            .filter(cameraProvider.availableCameraInfos)
            .firstOrNull()
            ?.let { Camera2CameraInfo.from(it) }
            ?.getCameraCharacteristic(CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL) ==
            CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_3
    }
    return false
}

Java

@androidx.annotation.OptIn(markerClass = ExperimentalCamera2Interop.class)
Boolean isBackCameraLevel3Device(ProcessCameraProvider cameraProvider) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
        List\<CameraInfo\> filteredCameraInfos = CameraSelector.DEFAULT_BACK_CAMERA
                .filter(cameraProvider.getAvailableCameraInfos());
        if (!filteredCameraInfos.isEmpty()) {
            return Objects.equals(
                Camera2CameraInfo.from(filteredCameraInfos.get(0)).getCameraCharacteristic(
                        CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL),
                CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_3);
        }
    }
    return false;
}

หมายเหตุ: หากสร้าง Use Case ที่ใช้ร่วมกันไม่ได้ ข้อผิดพลาดรันไทม์จะเป็นดังนี้ ส่งครั้งแรก createCaptureSession() จะถูกเรียก หากเพิ่ม Use Case อื่นๆ ลงในเซสชันที่ทํางานอยู่ คุณอาจต้องกําหนดค่าใหม่ ซึ่งอาจทําให้เกิดข้อบกพร่องที่มองเห็นได้

สิทธิ์

แอปของคุณจะต้องมี CAMERA หากต้องการบันทึกรูปภาพไปยังไฟล์ แอปจะต้องได้รับสิทธิ์WRITE_EXTERNAL_STORAGEด้วย ยกเว้นในอุปกรณ์ที่ใช้ Android 10 ขึ้นไป

ดูข้อมูลเพิ่มเติมเกี่ยวกับการกำหนดค่าสิทธิ์สำหรับแอปได้ที่หัวข้อขอสิทธิ์ของแอป

ข้อกำหนด

CameraX มีข้อกำหนดขั้นต่ำเวอร์ชันต่อไปนี้

• Android API ระดับ 21
• คอมโพเนนต์สถาปัตยกรรม Android 1.1.1

สำหรับกิจกรรมที่คำนึงถึงวงจร ให้ใช้ FragmentActivity หรือ AppCompatActivity

ประกาศทรัพยากร Dependency

หากต้องการเพิ่มทรัพยากร Dependency ใน CameraX คุณต้องเพิ่มแพ็กเกจ Google Maven ลงในโปรเจ็กต์ของคุณ

เปิดไฟล์ settings.gradle ของโปรเจ็กต์ แล้วเพิ่มที่เก็บ google() ดังที่แสดงต่อไปนี้

ดึงดูด

dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
    }
}

Kotlin

dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
    }
}

เพิ่มข้อมูลต่อไปนี้ที่ส่วนท้ายของบล็อก Android

Groovy

android {
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
    // For Kotlin projects
    kotlinOptions {
        jvmTarget = "1.8"
    }
}

Kotlin

android {
    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_1_8
        targetCompatibility = JavaVersion.VERSION_1_8
    }
    // For Kotlin projects
    kotlinOptions {
        jvmTarget = "1.8"
    }
}

เพิ่มโค้ดต่อไปนี้ลงในไฟล์ build.gradle ของแต่ละโมดูลสำหรับแอป

Groovy

dependencies {
  // CameraX core library using the camera2 implementation
  def camerax_version = "1.5.0-alpha03"
  // The following line is optional, as the core library is included indirectly by camera-camera2
  implementation "androidx.camera:camera-core:${camerax_version}"
  implementation "androidx.camera:camera-camera2:${camerax_version}"
  // If you want to additionally use the CameraX Lifecycle library
  implementation "androidx.camera:camera-lifecycle:${camerax_version}"
  // If you want to additionally use the CameraX VideoCapture library
  implementation "androidx.camera:camera-video:${camerax_version}"
  // If you want to additionally use the CameraX View class
  implementation "androidx.camera:camera-view:${camerax_version}"
  // If you want to additionally add CameraX ML Kit Vision Integration
  implementation "androidx.camera:camera-mlkit-vision:${camerax_version}"
  // If you want to additionally use the CameraX Extensions library
  implementation "androidx.camera:camera-extensions:${camerax_version}"
}

Kotlin

dependencies {
    // CameraX core library using the camera2 implementation
    val camerax_version = "1.5.0-alpha03"
    // The following line is optional, as the core library is included indirectly by camera-camera2
    implementation("androidx.camera:camera-core:${camerax_version}")
    implementation("androidx.camera:camera-camera2:${camerax_version}")
    // If you want to additionally use the CameraX Lifecycle library
    implementation("androidx.camera:camera-lifecycle:${camerax_version}")
    // If you want to additionally use the CameraX VideoCapture library
    implementation("androidx.camera:camera-video:${camerax_version}")
    // If you want to additionally use the CameraX View class
    implementation("androidx.camera:camera-view:${camerax_version}")
    // If you want to additionally add CameraX ML Kit Vision Integration
    implementation("androidx.camera:camera-mlkit-vision:${camerax_version}")
    // If you want to additionally use the CameraX Extensions library
    implementation("androidx.camera:camera-extensions:${camerax_version}")
}

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับการกำหนดค่าแอปให้เป็นไปตามข้อกำหนดเหล่านี้ ดูการประกาศ ทรัพยากร Dependency

ความสามารถในการทำงานร่วมกันของ CameraX กับ Camera2

CameraX สร้างขึ้นจาก Camera2 และ CameraX จะแสดงวิธีอ่านและเขียนพร็อพเพอร์ตี้ในการใช้งาน Camera2 ดูรายละเอียดทั้งหมดได้ที่ แพ็กเกจการทำงานร่วมกัน

สําหรับข้อมูลเพิ่มเติมเกี่ยวกับวิธีที่ CameraX กําหนดค่าคุณสมบัติของ Camera2 ให้ใช้ Camera2CameraInfo เพื่ออ่าน CameraCharacteristics ที่เกี่ยวข้อง นอกจากนี้ คุณยังเลือกเขียนพร็อพเพอร์ตี้ Camera2 ที่เกี่ยวข้องในเส้นทางใดเส้นทางหนึ่งต่อไปนี้ได้ด้วย

• ใช้ Camera2CameraControl, ซึ่งช่วยให้คุณตั้งค่าพร็อพเพอร์ตี้ CaptureRequest เช่น โหมดโฟกัสอัตโนมัติ

• ขยาย CameraX UseCase ด้วย Camera2Interop.Extender ซึ่งจะช่วยให้คุณตั้งค่าพร็อพเพอร์ตี้ใน CaptureRequest ได้เช่นเดียวกับ Camera2CameraControl นอกจากนี้ คุณยังมีการควบคุมเพิ่มเติมบางอย่าง เช่น การตั้งค่า Use Case ของสตรีมเพื่อเพิ่มประสิทธิภาพกล้องให้เหมาะกับการใช้งานของคุณ ดูข้อมูลได้ที่ใช้ Use Case ของสตรีมเพื่อประสิทธิภาพที่ดียิ่งขึ้น

หมายเหตุ: การตั้งค่าคุณสมบัติของ Camera2 ที่เกี่ยวข้องจะมีสถานะเป็น "ทดลอง" ใน CameraX เนื่องจาก Google คาดหวังให้นักพัฒนาซอฟต์แวร์เข้าใจการใช้งาน ค่าที่คุณตั้งไว้จะลบล้างค่าที่ CameraX ตั้งไว้ เราเท่านั้น แนะนำให้ดำเนินการนี้เมื่อจำเป็น และเราขอแนะนำ ในฝั่งคุณ

ตัวอย่างโค้ดต่อไปนี้ใช้กรณีการใช้งานของสตรีมเพื่อเพิ่มประสิทธิภาพสำหรับวิดีโอคอล ใช้ Camera2CameraInfo เพื่อดึงข้อมูลว่ากรณีการใช้งานสตรีมวิดีโอคอลพร้อมใช้งานหรือไม่ จากนั้นใช้ Camera2Interop.Extender เพื่อตั้งค่ากรณีการใช้งานสตรีมพื้นฐาน

Kotlin

// Set underlying Camera2 stream use case to optimize for video calls.

val videoCallStreamId =
    CameraMetadata.SCALER_AVAILABLE_STREAM_USE_CASES_VIDEO_CALL.toLong()

// Check available CameraInfos to find the first one that supports
// the video call stream use case.
val frontCameraInfo = cameraProvider.getAvailableCameraInfos()
    .first { cameraInfo ->
        val isVideoCallStreamingSupported = Camera2CameraInfo.from(cameraInfo)
            .getCameraCharacteristic(
                CameraCharacteristics.SCALER_AVAILABLE_STREAM_USE_CASES
            )?.contains(videoCallStreamId)
        val isFrontFacing = (cameraInfo.getLensFacing() == 
                             CameraSelector.LENS_FACING_FRONT)
        (isVideoCallStreamingSupported == true) && isFrontFacing
    }

val cameraSelector = frontCameraInfo.cameraSelector

// Start with a Preview Builder.
val previewBuilder = Preview.Builder()
    .setTargetAspectRatio(screenAspectRatio)
    .setTargetRotation(rotation)

// Use Camera2Interop.Extender to set the video call stream use case.
Camera2Interop.Extender(previewBuilder).setStreamUseCase(videoCallStreamId)

// Bind the Preview UseCase and the corresponding CameraSelector.
val preview = previewBuilder.build()
camera = cameraProvider.bindToLifecycle(this, cameraSelector, preview)

Java

// Set underlying Camera2 stream use case to optimize for video calls.

Long videoCallStreamId =
    CameraMetadata.SCALER_AVAILABLE_STREAM_USE_CASES_VIDEO_CALL.toLong();

// Check available CameraInfos to find the first one that supports
// the video call stream use case.
List<CameraInfo> cameraInfos = cameraProvider.getAvailableCameraInfos();
CameraInfo frontCameraInfo = null;
for (cameraInfo in cameraInfos) {
    Long[] availableStreamUseCases = Camera2CameraInfo.from(cameraInfo)
        .getCameraCharacteristic(
            CameraCharacteristics.SCALER_AVAILABLE_STREAM_USE_CASES
        );
    boolean isVideoCallStreamingSupported = Arrays.List(availableStreamUseCases)
                .contains(videoCallStreamId);
    boolean isFrontFacing = (cameraInfo.getLensFacing() ==
                             CameraSelector.LENS_FACING_FRONT);

    if (isVideoCallStreamingSupported && isFrontFacing) {
        frontCameraInfo = cameraInfo;
    }
}

if (frontCameraInfo == null) {
    // Handle case where video call streaming is not supported.
}

CameraSelector cameraSelector = frontCameraInfo.getCameraSelector();

// Start with a Preview Builder.
Preview.Builder previewBuilder = Preview.Builder()
    .setTargetAspectRatio(screenAspectRatio)
    .setTargetRotation(rotation);

// Use Camera2Interop.Extender to set the video call stream use case.
Camera2Interop.Extender(previewBuilder).setStreamUseCase(videoCallStreamId);

// Bind the Preview UseCase and the corresponding CameraSelector.
Preview preview = previewBuilder.build()
Camera camera = cameraProvider.bindToLifecycle(this, cameraSelector, preview)

แหล่งข้อมูลเพิ่มเติม

ดูข้อมูลเพิ่มเติมเกี่ยวกับ CameraX ได้จากแหล่งข้อมูลเพิ่มเติมต่อไปนี้

Codelab

การเริ่มต้นใช้งาน CameraX

ตัวอย่างโค้ด

ตัวอย่างแอป CameraX