title: Flash mode selected but camera2 wont capture image with those flash modes
body: <p>I am working on an application that involves a manual camera in which it has its own flash button it rotates through from OFF to ON to AUTO. I am calling a switch statement with an onClickListener to do this.</p>
  
  <pre><code>   private void setFlash() {
      switch (mFlashMode) {
          case CONTROL_AE_MODE_OFF:
              mCaptureRequestBuilder.set(CaptureRequest.CONTROL_AE_MODE, CameraMetadata.CONTROL_AE_MODE_ON);
              useFlashButton.setImageResource(R.drawable.flash_on);
              mFlashMode = CONTROL_AE_MODE_ON;
              break;
          case CONTROL_AE_MODE_ON:
              mCaptureRequestBuilder.set(CaptureRequest.CONTROL_AE_MODE, CameraMetadata.CONTROL_AE_MODE_ON);
              useFlashButton.setImageResource(R.drawable.flash_automatic);
              mFlashMode = CONTROL_AE_MODE_ON_AUTO_FLASH;
              break;
          case CONTROL_AE_MODE_ON_AUTO_FLASH:
              mCaptureRequestBuilder.set(CaptureRequest.CONTROL_AE_MODE, CameraMetadata.CONTROL_AE_MODE_OFF);
              useFlashButton.setImageResource(R.drawable.flash_off);
              mFlashMode = CONTROL_AE_MODE_OFF;
              break;
      }
  }
  </code></pre>
  
  <p>So what I need to do now is depending on what flash mode is selected, the camera will capture appropriately. at the moment no matter what mode I select, no flash happens.</p>
  
  <p>what can I do?</p>
  
  <p>more code to help.</p>
  
  <pre><code>       protected void onImageCaptureClick() {
          if (null == mCameraDevice) {
              Log.e(TAG, "cameraDevice is null");
              return;
          }
          CameraManager manager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);
  
          try {
              CameraCharacteristics characteristics = manager.getCameraCharacteristics(mCameraDevice.getId());
              Size[] jpegSizes = null;
              if (characteristics != null) {
                  jpegSizes = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP).getOutputSizes(ImageFormat.JPEG);
              }
              int width = 640;
              int height = 480;
              if (jpegSizes != null &amp;&amp; 0 &lt; jpegSizes.length) {
                  width = jpegSizes[0].getWidth();
                  height = jpegSizes[0].getHeight();
              }
              ImageReader reader = ImageReader.newInstance(width, height, ImageFormat.JPEG, 1);
              List&lt;Surface&gt; outputSurfaces = new ArrayList&lt;&gt;(2);
              outputSurfaces.add(reader.getSurface());
              outputSurfaces.add(new Surface(mTextureView.getSurfaceTexture()));
              final CaptureRequest.Builder captureBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE);
              captureBuilder.addTarget(reader.getSurface());
              // Use the same AE and AF modes as the preview.
  
              captureBuilder.set(CaptureRequest.SCALER_CROP_REGION, zoom);
              // Orientation
              int rotation = getWindowManager().getDefaultDisplay().getRotation();
              captureBuilder.set(CaptureRequest.JPEG_ORIENTATION, ORIENTATIONS.get(rotation));
  
              final File file = new File(_pictureUri.getPath());
              ImageReader.OnImageAvailableListener readerListener = new ImageReader.OnImageAvailableListener() {
                  @Override
                  public void onImageAvailable(ImageReader reader) {
                      Image image = null;
                      try {
                          image = reader.acquireLatestImage();
                          ByteBuffer buffer = image.getPlanes()[0].getBuffer();
                          byte[] bytes = new byte[buffer.capacity()];
                          buffer.get(bytes);
                          save(bytes);
                      } catch (FileNotFoundException e) {
                          e.printStackTrace();
                      } catch (IOException e) {
                          e.printStackTrace();
                      } finally {
                          if (image != null) {
                              image.close();
                          }
                      }
                  }
  
  
                  private void save(byte[] bytes) throws IOException {
                      OutputStream output = null;
                      try {
                          output = new FileOutputStream(file);
                          output.write(bytes);
                      } finally {
                          if (null != output) {
                              output.close();
                          }
                      }
                  }
              };
              reader.setOnImageAvailableListener(readerListener, mBackgroundHandler);
              final CameraCaptureSession.CaptureCallback captureListener = new CameraCaptureSession.CaptureCallback() {
                  //byte[] data;
                  @Override
                  public void onCaptureCompleted(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull TotalCaptureResult result) {
                      super.onCaptureCompleted(session, request, result);
  
  
                      Intent intent = new Intent (CameraActivity.this, CameraReviewPhotoActivity.class);
                      intent.putExtra (MediaStore.EXTRA_OUTPUT, _pictureUri);
                      startActivityForResult (intent, CameraActivity.kRequest_Code_Approve_Image);
  
                  }
              };
              mCameraDevice.createCaptureSession(outputSurfaces, new CameraCaptureSession.StateCallback() {
                  @Override
                  public void onConfigured(CameraCaptureSession session) {
                      try {
                          session.capture(captureBuilder.build(), captureListener, mBackgroundHandler);
                      } catch (CameraAccessException e) {
                          e.printStackTrace();
                      }
                  }
  
                  @Override
                  public void onConfigureFailed(CameraCaptureSession session) {
                  }
              }, mBackgroundHandler);
          } catch (CameraAccessException e) {
              e.printStackTrace();
          }
      }
  
  
      private void runPrecaptureSequence() {
      try {
  
          setFlash();
          mCaptureRequestBuilder.set(CaptureRequest.CONTROL_AE_PRECAPTURE_TRIGGER,
                  CaptureRequest.CONTROL_AE_PRECAPTURE_TRIGGER_START);
  
          mState = STATE_WAITING_PRE_CAPTURE;
          mCameraCaptureSessions.capture(mCaptureRequestBuilder.build(), mCaptureCallback,
                  mBackgroundHandler);
      } catch (CameraAccessException e) {
          e.printStackTrace();
      }
  
  }
  </code></pre>