How to use

CameraManager

in

android.hardware.camera2

 @Override
public int getOrientation(final int cameraId) {
  try {
    CameraManager manager = (CameraManager) context.getSystemService(Context.CAMERA_SERVICE);
    String[] cameraIds = manager.getCameraIdList();
    CameraCharacteristics characteristics = manager.getCameraCharacteristics(cameraIds[cameraId]);
    return characteristics.get(CameraCharacteristics.SENSOR_ORIENTATION);
  } catch (CameraAccessException e) {
    // TODO handle error properly or pass it on
    return 0;
  }
}

public CameraSupport open(final int cameraId) {
  try {
    String[] cameraIds = manager.getCameraIdList();
    manager.openCamera(cameraIds[cameraId], new CameraDevice.StateCallback() {
      @Override
      public void onOpened(CameraDevice camera) {
public int getOrientation(final int cameraId) {
  try {
    String[] cameraIds = manager.getCameraIdList();
    CameraCharacteristics characteristics = manager.getCameraCharacteristics(cameraIds[cameraId]);
    return characteristics.get(CameraCharacteristics.SENSOR_ORIENTATION);
  } catch (CameraAccessException e) {

  mDevice=null;
CameraCharacteristics c=mCameraManager.getCameraCharacteristics(cameraId+"");
StreamConfigurationMap map=c.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
Size[] sizes=map.getOutputSizes(SurfaceHolder.class);
mCameraManager.openCamera(cameraId + "", new CameraDevice.StateCallback() {
  @Override
  public void onOpened(CameraDevice camera) {

/**
 * <p>Starts opening a camera device.</p>
 * <p>The result will be processed in {@link #mCameraDeviceCallback}.</p>
 */
private void startOpeningCamera() {
  try {
    mCameraManager.openCamera(mCameraId, mCameraDeviceCallback, null);
  } catch (CameraAccessException e) {
    throw new RuntimeException("Failed to open camera: " + mCameraId, e);
  }
}

public int getLevelSupported() {
 try {
  cameraCharacteristics = cameraManager.getCameraCharacteristics("0");
  return cameraCharacteristics.get(CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL);
 } catch (CameraAccessException | IllegalStateException e) {
  Log.e(TAG, "Error", e);
  return -1;
 }
}

@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
private static List<MyCameraInfo> GetAllCameras2(Context context) throws Exception {
  List<MyCameraInfo> cameras = new ArrayList<>();
  CameraManager cameraManager =
      (CameraManager) context.getSystemService(Context.CAMERA_SERVICE);
  for (String cameraId : cameraManager.getCameraIdList()) {
    CameraCharacteristics characteristics = cameraManager.getCameraCharacteristics(cameraId);
    MyCameraInfo cameraInfo = MyCameraInfo.CreateFromCameraCharacteristics(cameraId,
        characteristics);
    cameras.add(cameraInfo);
  }
  return cameras;
}

@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
private void initCamera() {
 try {
  CameraManager cameraManager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);
  String[] cameraIds = cameraManager.getCameraIdList();
  if (cameraIds.length == 0) return;
  String cameraId = cameraIds[0];
  if (ActivityCompat.checkSelfPermission(this,
   Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
   ActivityCompat.requestPermissions(this,
    new String[]{Manifest.permission.CAMERA}, CAMERA_PERMISSIONS_REQUEST);
  }
  cameraManager.openCamera(cameraId, cameraDeviceCallback, null);
 } catch (CameraAccessException e) {
  Log.d(TAG, "No access to the camera.", e);
 }
}

  @Override
  public int getCameraCount() {
    CameraManager cameraManager = (CameraManager)AnkiDroidApp.getInstance().getApplicationContext()
        .getSystemService(Context.CAMERA_SERVICE);
    try {
      if (cameraManager != null) {
        return cameraManager.getCameraIdList().length;
      }
    } catch (CameraAccessException e) {
      Timber.e(e, "Unable to enumerate cameras");
    }
    return 0;
  }
}

@Test
public void testGetCameraCharacteristicsUnrecognizedCameraId() throws CameraAccessException {
 try {
  cameraManager.getCameraCharacteristics(CAMERA_ID_0);
  fail();
 } catch (IllegalArgumentException e) {
  // Expected
 }
}

list = manager.getCameraIdList();
manager.setTorchMode(list[0], true);
isFlashOpened = true;
MyApplication.getMainThreadHandler().post(new Runnable() {
list = manager.getCameraIdList();
manager.setTorchMode(list[0], false);
isFlashOpened = false;
MyApplication.getMainThreadHandler().post(new Runnable() {

  private void setFlash(boolean flashing) {
    if (flashing != fFlashOn) {
      fFlashOn = flashing;
      try {
        if (torchId != null) {
          mCameraManager.setTorchMode(torchId, flashing);
          Log.d(TAG, "Set torchmode " + flashing);
        }
      } catch (CameraAccessException e) {
        if (e.getReason() != CameraAccessException.MAX_CAMERAS_IN_USE) {
          Log.e(TAG, "Failed to toggle flash!", e);
        }
      }
    }
  }
}

  mCameraManager = (CameraManager) context.getSystemService(Context.CAMERA_SERVICE);
  CameraCharacteristics cameraCharacteristics = mCameraManager.getCameraCharacteristics("0");
  boolean flashAvailable = cameraCharacteristics.get(CameraCharacteristics.FLASH_INFO_AVAILABLE);
  if (flashAvailable) {
    mCameraManager.openCamera("0", new MyCameraDeviceStateCallback(), null);
  } else {
Size[] outputSizes = mCameraManager.getCameraCharacteristics(cameraId)
    .get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP)
    .getOutputSizes(SurfaceTexture.class);

/**
 * <p>Starts opening a camera device.</p>
 * <p>The result will be processed in {@link #mCameraDeviceCallback}.</p>
 */
private void startOpeningCamera() {
  try {
    mCameraManager.openCamera(mCameraId, mCameraDeviceCallback, null);
  } catch (CameraAccessException e) {
    throw new RuntimeException("Failed to open camera: " + mCameraId, e);
  }
}

@Override
public int getCameraOrientation() {
  try {
    CameraCharacteristics characteristics
        = mCamManager.getCameraCharacteristics(mCameraId);
    Integer orientation = characteristics.get(CameraCharacteristics.SENSOR_ORIENTATION);
    if (orientation != null) {
      return orientation;
    }
  } catch (CameraAccessException e) {
    Log.e(TAG, "Couldn't find out camera sensor orientation");
  }
  return 0;
}

@Test
public void testGetCameraIdListNoCameras() throws CameraAccessException {
 assertThat(cameraManager.getCameraIdList()).isEmpty();
}

@Test
public void testGetCameraCharacteristicsNullCameraId() throws CameraAccessException {
 try {
  cameraManager.getCameraCharacteristics(null);
  fail();
 } catch (NullPointerException e) {
  // Expected
 }
}

@TargetApi(Build.VERSION_CODES.M)
private static void toggleTorch(Context context, boolean enabled) {
  try {
    final CameraManager cameraManager = (CameraManager) context.getSystemService(Context.CAMERA_SERVICE);
    String torchCameraId = getTorchCameraId(cameraManager);
    if (torchCameraId != null) {
      cameraManager.setTorchMode(torchCameraId, enabled);
    } else {
      Toast.makeText(context, "Torch unavailable on your device", Toast.LENGTH_LONG).show();
    }
  } catch (CameraAccessException e) {
    TermuxApiLogger.error("Error toggling torch", e);
  }
}

@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public static boolean hasCamera2(Context context) {
  if (context == null) return false;
  if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) return false;
  try {
    CameraManager manager = (CameraManager) context.getSystemService(Context.CAMERA_SERVICE);
    String[] idList = manager.getCameraIdList();
    boolean notNull = true;
    if (idList.length == 0) {
      notNull = false;
    } else {
      for (final String str : idList) {
        if (str == null || str.trim().isEmpty()) {
          notNull = false;
          break;
        }
        final CameraCharacteristics characteristics = manager.getCameraCharacteristics(str);
        final int supportLevel = characteristics.get(CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL);
        if (supportLevel == CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LEGACY) {
          notNull = false;
          break;
        }
      }
    }
    return notNull;
  } catch (Throwable ignore) {
    return false;
  }
}

    throw new RuntimeException("Time out waiting to lock camera opening.");
  String cameraId = manager.getCameraIdList()[0];
  CameraCharacteristics characteristics = manager.getCameraCharacteristics(cameraId);
  StreamConfigurationMap map = characteristics
      .get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
  mSensorOrientation = characteristics.get(CameraCharacteristics.SENSOR_ORIENTATION);
  if (map == null) {
    throw new RuntimeException("Cannot get available preview/video sizes");
  manager.openCamera(cameraId, mStateCallback, null);
} catch (CameraAccessException e) {
  Toast.makeText(activity, "Cannot access the camera.", Toast.LENGTH_SHORT).show();

 CameraManager mCameraManager = (CameraManager) context.getSystemService(Context.CAMERA_SERVICE);
//here to judge if flash is available

CameraCharacteristics cameraCharacteristics = mCameraManager.getCameraCharacteristics("0");
boolean flashAvailable = cameraCharacteristics.get(CameraCharacteristics.FLASH_INFO_AVAILABLE);
if (flashAvailable) {
     mCameraManager.openCamera("0", new MyCameraDeviceStateCallback(), null);
} else {
    //todo: throw Exception
}