[HTML payload içeriği buraya]
30.9 C
Jakarta
Monday, November 25, 2024

CameraX replace makes twin concurrent digital camera even simpler



Posted by Donovan McMurray – Developer Relations Engineer

CameraX, Android’s Jetpack digital camera library, is getting an thrilling replace to its Twin Concurrent Digital camera function, making it even simpler to combine this function into your app. This function permits you to stream from 2 completely different cameras on the similar time. The unique model of Twin Concurrent Digital camera was launched in CameraX 1.3.0, and it was already an enormous leap in making this function simpler to implement.

Beginning with 1.5.0-alpha01, CameraX will now deal with the composition of the two digital camera streams as nicely. This replace is extra performance, and it doesn’t take away any prior performance neither is it a breaking change to your current Twin Concurrent Digital camera code. To inform CameraX to deal with the composition, merely use the new SingleCameraConfig constructor which has a brand new parameter for a CompositionSettings object. Because you’ll be creating 2 SingleCameraConfigs, you need to be in step with what constructor you employ.

Nothing has modified in the way in which you test for concurrent digital camera help from the prior model of this function. As a reminder, here’s what that code appears like.

// Arrange main and secondary digital camera selectors if supported on system.
var primaryCameraSelector: CameraSelector? = null
var secondaryCameraSelector: CameraSelector? = null

for (cameraInfos in cameraProvider.availableConcurrentCameraInfos) {
    primaryCameraSelector = cameraInfos.first {
        it.lensFacing == CameraSelector.LENS_FACING_FRONT
    }.cameraSelector
    secondaryCameraSelector = cameraInfos.first {
        it.lensFacing == CameraSelector.LENS_FACING_BACK
    }.cameraSelector

    if (primaryCameraSelector == null || secondaryCameraSelector == null) {
        // If both a main or secondary selector wasn't discovered, reset each
        // to maneuver on to the following listing of CameraInfos.
        primaryCameraSelector = null
        secondaryCameraSelector = null
    } else {
        // If each main and secondary digital camera selectors had been discovered, we will
        // conclude the search.
        break
    }
}

if (primaryCameraSelector == null || secondaryCameraSelector == null) {
    // Back and front concurrent digital camera not accessible. Deal with accordingly.
}

Right here’s the up to date code snippet exhibiting find out how to implement picture-in-picture, with the entrance digital camera stream scaled down to suit into the decrease proper nook. On this instance, CameraX handles the composition of the digital camera streams.

// If 2 concurrent digital camera selectors had been discovered, create 2 SingleCameraConfigs
// and compose them in a picture-in-picture structure.
val main = SingleCameraConfig(
    cameraSelectorPrimary,
    useCaseGroup,
    CompositionSettings.Builder()
        .setAlpha(1.0f)
        .setOffset(0.0f, 0.0f)
        .setScale(1.0f, 1.0f)
        .construct(),
    lifecycleOwner);
val secondary = SingleCameraConfig(
    cameraSelectorSecondary,
    useCaseGroup,
    CompositionSettings.Builder()
        .setAlpha(1.0f)
        .setOffset(2 / 3f - 0.1f, -2 / 3f + 0.1f)
        .setScale(1 / 3f, 1 / 3f)
        .construct()
    lifecycleOwner);

// Bind to lifecycle
ConcurrentCamera concurrentCamera =
    cameraProvider.bindToLifecycle(listOf(main, secondary));

You aren’t constrained to a picture-in-picture structure. As an illustration, you possibly can outline a side-by-side structure by setting the offsets and scaling elements accordingly. You need to preserve each dimensions scaled by the identical quantity to keep away from a stretched preview. Right here’s how that may look.

// If 2 concurrent digital camera selectors had been discovered, create 2 SingleCameraConfigs
// and compose them in a picture-in-picture structure.
val main = SingleCameraConfig(
    cameraSelectorPrimary,
    useCaseGroup,
    CompositionSettings.Builder()
        .setAlpha(1.0f)
        .setOffset(0.0f, 0.25f)
        .setScale(0.5f, 0.5f)
        .construct(),
    lifecycleOwner);
val secondary = SingleCameraConfig(
    cameraSelectorSecondary,
    useCaseGroup,
    CompositionSettings.Builder()
        .setAlpha(1.0f)
        .setOffset(0.5f, 0.25f)
        .setScale(0.5f, 0.5f)
        .construct()
    lifecycleOwner);

// Bind to lifecycle
ConcurrentCamera concurrentCamera =
    cameraProvider.bindToLifecycle(listOf(main, secondary));

We’re excited to supply this enchancment to an already developer-friendly function. Actually the CameraX method! CompositionSettings in Twin Concurrent Digital camera is at the moment in alpha, so in case you have function requests to enhance upon it earlier than the API is locked in, please give us suggestions within the CameraX Dialogue Group. And take a look at the full CameraX 1.5.0-alpha01 launch notes to see what else is new in CameraX.

Related Articles

LEAVE A REPLY

Please enter your comment!
Please enter your name here

Latest Articles