Camerax 打开指定摄像头id

安卓上开发摄像头预览应用，参考了谷歌的实现CameraX基本使用；具体使用可查看源码

复制一下关键代码：

private lateinit var viewFinder: PreviewView

private var camera: Camera? =null

private var cameraProvider: ProcessCameraProvider? =null

private var preview: Preview? =null

private var lensFacing: Int = CameraSelector.LENS_FACING_BACK

/** Initialize CameraX, and prepare to bind the camera use cases */

private fun setUpCamera() {

val cameraProviderFuture =       ProcessCameraProvider.getInstance(requireContext())

cameraProviderFuture.addListener(Runnable {

    // CameraProvider

    cameraProvider = cameraProviderFuture.get()

// Select lensFacing depending on the available cameras

    lensFacing =when {

        hasBackCamera() -> CameraSelector.LENS_FACING_BACK

        hasFrontCamera() -> CameraSelector.LENS_FACING_FRONT

        else ->throw IllegalStateException("Back and front camera are unavailable")

  }

// Build and bind the camera use cases

    bindCameraUseCases()

}, ContextCompat.getMainExecutor(requireContext()))

}

/** Declare and bind preview, capture and analysis use cases */

@SuppressLint("RestrictedApi")

private fun bindCameraUseCases() {

// Get screen metrics used to setup camera for full screen resolution

 val metrics = DisplayMetrics().also {         viewFinder.display.getRealMetrics(it)}

  val screenAspectRatio = aspectRatio(metrics.widthPixels,     metrics.heightPixels)

val rotation =viewFinder.display.rotation

val cameraProvider =cameraProvider

            ?:throw IllegalStateException("Camera initialization failed.")

    val cameraSelector = CameraSelector.Builder().requireLensFacing(lensFacing).build()

    preview = Preview.Builder()

            .setTargetAspectRatio(screenAspectRatio)

            .setTargetRotation(rotation)

            .build()

    // Must unbind the use-cases before rebinding them

    cameraProvider.unbindAll()

try {

        camera = cameraProvider.bindToLifecycle(this, cameraSelector, preview)

        preview?.setSurfaceProvider(viewFinder.surfaceProvider)

    }catch (exc: Exception) {

    }

}



/** Returns true if the device has an available back camera. False otherwise */

  private fun hasBackCamera(): Boolean {

return cameraProvider?.hasCamera(CameraSelector.DEFAULT_BACK_CAMERA) ?:false

}

/** Returns true if the device has an available front camera. False otherwise */

  private fun hasFrontCamera(): Boolean {

return cameraProvider?.hasCamera(CameraSelector.DEFAULT_FRONT_CAMERA) ?:false

}

其中选择预览的摄像头是通过

val cameraSelector = CameraSelector.Builder().requireLensFacing(lensFacing).build()

这个是CameraX 中默认的摄像头选择过滤的一个类，实现如下：

 public Builder requireLensFacing(@LensFacing int lensFacing) {

    mCameraFilterSet.add(new LensFacingCameraFilter(lensFacing));

     return this;
  }

继续看LensFacingCameraFilter类的实现，

public class LensFacingCameraFilterimplements CameraFilter {

@CameraSelector.LensFacing

private int mLensFacing;

public LensFacingCameraFilter(@CameraSelector.LensFacing int lensFacing) {

mLensFacing = lensFacing;

}

@NonNull

@Override

public List<CameraInfo>  filter(@NonNull List cameraInfos) {

List result =new ArrayList<CameraInfo>();

    for (CameraInfo cameraInfo : cameraInfos) {

      Preconditions.checkArgument(cameraInfoinstanceof CameraInfoInternal,

                "The camera info doesn't contain internal implementation.");

//拿到摄像头的前置或后置信息，和mLensFacing比较，相同的摄像头加入result返回

//mLensFacing就是requireLensFacing()传入的要打开前置还是后置

        Integer lensFacing = ((CameraInfoInternal) cameraInfo).getLensFacing();

        if (lensFacing !=null && lensFacing ==mLensFacing) {

            result.add(cameraInfo);      
          }

      }

      return result;
  }

}

主要是重写的filter()方法，其中的过滤方式是拿到前后置和你设置的前后置一样的摄像头列表。

/** A camera on the device facing the same direction as the device's screen. */

public static final int LENS_FACING_FRONT =0;

/** A camera on the device facing the opposite direction as the device's screen. */

public static final int LENS_FACING_BACK =1;

当有多个摄像头都是前置或者后置是，默认就会打开列表的第一个；

先看下CameraSelector中的filter方法，

public List <CameraInfo>  filter(@NonNull List cameraInfos) {

List input =new ArrayList<CameraInfo>(cameraInfos);

List output =new ArrayList<CameraInfo>(cameraInfos);

for (CameraFilter filter :mCameraFilterSet) {

  //在这里调用了CameraFilter中的过滤方法filter，默认的是根据前后置来过滤，

//就是LensFacingCameraFilter类中filter的实现

output = filter.filter(Collections.unmodifiableList(output));

    if (output.isEmpty()) {

throw new IllegalArgumentException("No available camera can be found.");

    }else if (!input.containsAll(output)) {

throw new IllegalArgumentException("The output isn't contained in the input.");

    }

input.retainAll(output);

}

return output;

}

在绑定摄像头时，cameraProvider.bindToLifecycle()里的实现；


public CamerabindToLifecycle(

@NonNull LifecycleOwner lifecycleOwner,

        @NonNull CameraSelector cameraSelector,

        @Nullable ViewPort viewPort,

        @NonNull UseCase... useCases) {

...

CameraSelector.Builder selectorBuilder =

CameraSelector.Builder.fromSelector(cameraSelector);

// Append the camera filter required internally if there's any.

for (UseCase useCase : useCases) {

CameraSelector selector = useCase.getCurrentConfig().getCameraSelector(null);

    if (selector !=null) {

for (CameraFilter filter : selector.getCameraFilterSet()) {

selectorBuilder.addCameraFilter(filter);

        }

}

}

CameraSelector modifiedSelector = selectorBuilder.build();

/**在modifiedSelector.filter方法中会根据LensFacingCameraFilter的过滤规则把所有符合前置或后置的摄像头过滤出来*/

LinkedHashSet cameraInternals =

modifiedSelector.filter(mCameraX.getCameraRepository().getCameras());

...

// Try to get the camera before binding to the use case, and throw IllegalArgumentException

// if the camera not found.

//在这里 new CameraUseCaseAdapter（）的时候会把都是前置或者后置的摄像头列表传进入，然后多个前置或后置时默认绑定第一个摄像头，无法指定第几个前置

if (lifecycleCameraToBind ==null) {

lifecycleCameraToBind =

mLifecycleCameraRepository.createLifecycleCamera(lifecycleOwner,

                    new CameraUseCaseAdapter(cameraInternals,

                            mCameraX.getCameraDeviceSurfaceManager(),

                            mCameraX.getDefaultConfigFactory()));

}

}

在CameraUseCaseAdapter初始化时默认选择列表的第一个摄像头：mCameraInternal = cameras.iterator().next();


public CameraUseCaseAdapter(@NonNull LinkedHashSet cameras,

        @NonNull CameraDeviceSurfaceManager cameraDeviceSurfaceManager,

        @NonNull UseCaseConfigFactory useCaseConfigFactory) {

mCameraInternal = cameras.iterator().next();

    mCameraInternals =new LinkedHashSet<>(cameras);

    mId =new CameraId(mCameraInternals);

    mCameraDeviceSurfaceManager = cameraDeviceSurfaceManager;

    mUseCaseConfigFactory = useCaseConfigFactory;

}

一开始使用CameraX，机器只有一个前置或后置时，通过前置或后置来选择摄像头没有问题；

后面遇到插入USB摄像头（我遇到的情况是插入多个USB摄像头时，和本地摄像头都被识别为前置摄像头）或者有多个后置或前置时，就只能打开默认的摄像头，没办法打开指定的摄像头了。

于是自定义自己的CameraFilter，通过摄像头的来过滤要打开的摄像头。

实现如下：


@ExperimentalCameraFilter

class MyCameraFilter(private val mId: String) : CameraFilter {

private val TAG ="CameraIdCameraFilter"

    @SuppressLint("RestrictedApi")

override fun filter(cameraInfos: MutableList): MutableList {

val result = ArrayList()

cameraInfos.forEach {

            Preconditions.checkArgument(

it is CameraInfoInternal,

                "The camera info doesn't contain internal implementation."

            )

it as CameraInfoInternal

val id =it.cameraId
//传入的mId通过CameraManager.cameraIdList获取就可以了
//但是有一个问题：外接的USB摄像头id在机器重启后，原来的摄像头对应的id会发生变化，
//这个时候想打开确定的摄像头的话，可以通过USB摄像头的pid,vid找到对应的摄像头对应
//的id,这个不同机型都不太一样，直接找系统工程师确认吧

      if (id==mId) {

            result.add(it)

            }

}

        return result

}

}

使用时初始化cameraSelector时改一下即可，其他不变：


private var mCameraId =0

val cameraSelector = CameraSelector.Builder()

.addCameraFilter(MyCameraFilter("$mCameraId")).build()