Ejemplo n.º 1
0
  @TargetApi(Build.VERSION_CODES.LOLLIPOP)
  public static void openCamera(CameraDevice.StateCallback stateCallback)
      throws CameraAccessException {
    Context context_holder = ApplicationContextProvider.getContext();
    CameraManager manager = (CameraManager) context_holder.getSystemService(Context.CAMERA_SERVICE);

    try {
      String cameraId = manager.getCameraIdList()[0];
      CameraCharacteristics characteristics = manager.getCameraCharacteristics(cameraId);
      StreamConfigurationMap map =
          characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
      assert map != null;

      manager.openCamera(cameraId, stateCallback, null);

    } catch (CameraAccessException e) {
      e.printStackTrace();
    }
    try {
      Thread.sleep(100);
    } catch (InterruptedException e) {
    }
    ;
    Log.e("camera", "Sleep, re-try");
  }
Ejemplo n.º 2
0
 @Override
 protected void onResume() {
   super.onResume();
   CameraManager manager = (CameraManager) this.getSystemService(Context.CAMERA_SERVICE);
   if (manager == null) {
     showToast(R.string.no_camera_manager);
   } else {
     try {
       mCameraIds = manager.getCameraIdList();
       boolean allCamerasAreLegacy = true;
       for (String id : mCameraIds) {
         CameraCharacteristics characteristics = manager.getCameraCharacteristics(id);
         if (characteristics.get(CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL)
             != CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LEGACY) {
           allCamerasAreLegacy = false;
           break;
         }
       }
       if (allCamerasAreLegacy) {
         showToast(R.string.all_legacy_devices);
         getPassButton().setEnabled(false);
       }
     } catch (CameraAccessException e) {
       Toast.makeText(
               ItsTestActivity.this,
               "Received error from camera service while checking device capabilities: " + e,
               Toast.LENGTH_SHORT)
           .show();
     }
     IntentFilter filter = new IntentFilter(ACTION_ITS_RESULT);
     registerReceiver(mSuccessReceiver, filter);
   }
 }
Ejemplo n.º 3
0
  private void caracteristicasCamera(
      int width, int height) { // metodo responsavel por atribuir as caracteristicas das cameras

    try {
      for (String cameraId : manager.getCameraIdList()) {
        CameraCharacteristics characteristics = manager.getCameraCharacteristics(cameraId);

        StreamConfigurationMap map =
            characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
        if (map == null) {
          continue;
        }

        // serve para atribuir o tamanho da imagem
        Size largest =
            Collections.max(
                Arrays.asList(map.getOutputSizes(ImageFormat.JPEG)), new CompareSizesByArea());
        imageReader =
            ImageReader.newInstance(
                largest.getWidth(), largest.getHeight(), ImageFormat.JPEG, /*maxImages*/ 2);
        imageReader.setOnImageAvailableListener(mOnImageAvailableListener, backgroundHandler);

        // textureView.setAspectRatio(
        //       previewSize.getHeight(), previewSize.getWidth());

        return;
      }
    } catch (CameraAccessException e) {
      e.printStackTrace();
    } catch (NullPointerException e) {
      informaErro
          .newInstance(getString(R.string.camera_error))
          .show(getChildFragmentManager(), FRAGMENT_DIALOG);
    }
  }
  /**
   * Sets up member variables related to camera.
   *
   * @param width The width of available size for camera preview
   * @param height The height of available size for camera preview
   */
  private void setUpCameraOutputs(final int width, final int height) {
    final Activity activity = getActivity();
    final CameraManager manager = (CameraManager) activity.getSystemService(Context.CAMERA_SERVICE);
    try {
      for (final String cameraId : manager.getCameraIdList()) {
        final CameraCharacteristics characteristics = manager.getCameraCharacteristics(cameraId);

        // We don't use a front facing camera in this sample.
        final Integer facing = characteristics.get(CameraCharacteristics.LENS_FACING);
        if (facing != null && facing == CameraCharacteristics.LENS_FACING_FRONT) {
          continue;
        }

        final StreamConfigurationMap map =
            characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);

        if (map == null) {
          continue;
        }

        // For still image captures, we use the largest available size.
        final Size largest =
            Collections.max(
                Arrays.asList(map.getOutputSizes(ImageFormat.YUV_420_888)),
                new CompareSizesByArea());

        sensorOrientation = characteristics.get(CameraCharacteristics.SENSOR_ORIENTATION);

        // Danger, W.R.! Attempting to use too large a preview size could  exceed the camera
        // bus' bandwidth limitation, resulting in gorgeous previews but the storage of
        // garbage capture data.
        previewSize =
            chooseOptimalSize(
                map.getOutputSizes(SurfaceTexture.class), inputSize, inputSize, largest);

        // We fit the aspect ratio of TextureView to the size of preview we picked.
        final int orientation = getResources().getConfiguration().orientation;
        if (orientation == Configuration.ORIENTATION_LANDSCAPE) {
          textureView.setAspectRatio(previewSize.getWidth(), previewSize.getHeight());
        } else {
          textureView.setAspectRatio(previewSize.getHeight(), previewSize.getWidth());
        }

        CameraConnectionFragment.this.cameraId = cameraId;

        cameraConnectionCallback.onPreviewSizeChosen(previewSize, sensorOrientation);
        return;
      }
    } catch (final CameraAccessException e) {
      LOGGER.e(e, "Exception!");
    } catch (final NullPointerException e) {
      // Currently an NPE is thrown when the Camera2API is used but not supported on the
      // device this code runs.
      ErrorDialog.newInstance(getString(R.string.camera_error))
          .show(getChildFragmentManager(), FRAGMENT_DIALOG);
    }
  }
  /**
   * Sets up member variables related to camera.
   *
   * @param width The width of available size for camera preview
   * @param height The height of available size for camera preview
   */
  private void setUpCameraOutputs(String strCameraId, int width, int height) {
    Activity activity = getActivity();
    CameraManager manager = (CameraManager) activity.getSystemService(Context.CAMERA_SERVICE);
    try {
      for (String cameraId : manager.getCameraIdList()) {
        if (!cameraId.equalsIgnoreCase(strCameraId)) continue;

        CameraCharacteristics characteristics = manager.getCameraCharacteristics(cameraId);

        // We don't use a front facing camera in this sample.
        Integer facing = characteristics.get(CameraCharacteristics.LENS_FACING);
        if (facing != null && facing == CameraCharacteristics.LENS_FACING_FRONT) {
          //                    continue;
        }

        StreamConfigurationMap map =
            characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
        if (map == null) {
          continue;
        }

        // For still image captures, we use the largest available size.
        Size largest =
            Collections.max(
                Arrays.asList(map.getOutputSizes(ImageFormat.JPEG)), new CompareSizesByArea());
        mImageReader =
            ImageReader.newInstance(
                largest.getWidth(), largest.getHeight(), ImageFormat.JPEG, /*maxImages*/ 2);
        mImageReader.setOnImageAvailableListener(mOnImageAvailableListener, mBackgroundHandler);

        // Danger, W.R.! Attempting to use too large a preview size could  exceed the camera
        // bus' bandwidth limitation, resulting in gorgeous previews but the storage of
        // garbage capture data.
        mPreviewSize =
            chooseOptimalSize(map.getOutputSizes(SurfaceTexture.class), width, height, largest);

        // We fit the aspect ratio of TextureView to the size of preview we picked.
        int orientation = getResources().getConfiguration().orientation;
        if (orientation == Configuration.ORIENTATION_LANDSCAPE) {
          mTextureView.setAspectRatio(mPreviewSize.getWidth(), mPreviewSize.getHeight());
        } else {
          mTextureView.setAspectRatio(mPreviewSize.getHeight(), mPreviewSize.getWidth());
        }

        mCameraId = cameraId;
        return;
      }
    } catch (CameraAccessException e) {
      e.printStackTrace();
    } catch (NullPointerException e) {
      // Currently an NPE is thrown when the Camera2API is used but not supported on the
      // device this code runs.
      ErrorDialog.newInstance(getString(R.string.camera_error))
          .show(getChildFragmentManager(), FRAGMENT_DIALOG);
    }
  }
 private String getCameraId() throws CameraAccessException {
   String[] ids = mCameraManager.getCameraIdList();
   for (String id : ids) {
     CameraCharacteristics c = mCameraManager.getCameraCharacteristics(id);
     Boolean flashAvailable = c.get(CameraCharacteristics.FLASH_INFO_AVAILABLE);
     Integer lensFacing = c.get(CameraCharacteristics.LENS_FACING);
     if (flashAvailable != null
         && flashAvailable
         && lensFacing != null
         && lensFacing == CameraCharacteristics.LENS_FACING_BACK) {
       return id;
     }
   }
   return null;
 }
 private Size getSmallestSize(String cameraId) throws CameraAccessException {
   Size[] outputSizes =
       mCameraManager
           .getCameraCharacteristics(cameraId)
           .get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP)
           .getOutputSizes(SurfaceTexture.class);
   if (outputSizes == null || outputSizes.length == 0) {
     throw new IllegalStateException("Camera " + cameraId + "doesn't support any outputSize.");
   }
   Size chosen = outputSizes[0];
   for (Size s : outputSizes) {
     if (chosen.getWidth() >= s.getWidth() && chosen.getHeight() >= s.getHeight()) {
       chosen = s;
     }
   }
   return chosen;
 }
Ejemplo n.º 8
0
  private void setupCamera(int width, int height) {

    try {
      if (!mCameraOpenCloseLock.tryAcquire(2500, TimeUnit.MILLISECONDS)) {
        throw new RuntimeException("Time out waiting to lock camera opening.");
      }
      for (String cameraId : cameraManager.getCameraIdList()) {
        CameraCharacteristics characteristics = cameraManager.getCameraCharacteristics(cameraId);
        if ((characteristics.get(CameraCharacteristics.LENS_FACING))
            .equals(CameraCharacteristics.LENS_FACING_BACK)) {
          StreamConfigurationMap configMap =
              characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
          Size largestImageSize =
              Collections.max(
                  Arrays.asList(configMap.getOutputSizes(ImageFormat.YUV_420_888)),
                  new Comparator<Size>() {
                    @Override
                    public int compare(Size lhs, Size rhs) {
                      return Long.signum(
                          lhs.getWidth() * lhs.getWidth() - rhs.getHeight() * rhs.getWidth());
                      // return 0;
                    }
                  });

          imgReader =
              ImageReader.newInstance(
                  largestImageSize.getWidth(),
                  largestImageSize.getHeight(),
                  ImageFormat.YUV_420_888,
                  60 * 600);
          imgReader.setOnImageAvailableListener(barcodeChecker, mHandler);
          prefferedBufferSize =
              getBestSize(configMap.getOutputSizes(SurfaceTexture.class), width, height);
          mCameraId = cameraId;
          return;
        }
      }

    } catch (Exception e) {
      e.printStackTrace();
    }
  }
Ejemplo n.º 9
0
  private static void take_photo_new(
      CameraDevice cameraDevice, ImageView imageviewer_new_picture, String file_name) {
    Context context_holder = ApplicationContextProvider.getContext();
    CameraManager manager = (CameraManager) context_holder.getSystemService(Context.CAMERA_SERVICE);

    HandlerThread mBackgroundThread;
    mBackgroundThread = new HandlerThread("Camera Background");
    mBackgroundThread.start();
    final Handler mBackgroundHandler = new Handler(mBackgroundThread.getLooper());

    try {
      CameraCharacteristics characteristics =
          manager.getCameraCharacteristics(cameraDevice.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 && 0 < jpegSizes.length) {
        width = jpegSizes[0].getWidth();
        height = jpegSizes[0].getHeight();
      }

      ImageReader reader = ImageReader.newInstance((width + 1), (height + 1), ImageFormat.JPEG, 1);

      final CaptureRequest.Builder captureBuilder =
          cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE);
      captureBuilder.addTarget(reader.getSurface());
      captureBuilder.set(CaptureRequest.CONTROL_MODE, CameraMetadata.CONTROL_MODE_AUTO);
      captureBuilder.set(
          CaptureRequest.COLOR_CORRECTION_MODE, CameraMetadata.COLOR_CORRECTION_MODE_FAST);
      captureBuilder.set(CaptureRequest.FLASH_MODE, CameraMetadata.FLASH_MODE_OFF);

      captureBuilder.set(CaptureRequest.JPEG_THUMBNAIL_QUALITY, null);

      List<Surface> outputSurfaces = new ArrayList<Surface>(2);
      outputSurfaces.add(reader.getSurface());

      captureBuilder.build();

      cameraDevice.createCaptureSession(
          outputSurfaces,
          new CameraCaptureSession.StateCallback() {
            @Override
            public void onConfigured(CameraCaptureSession session) {
              try {
                session.capture(captureBuilder.build(), null, null);
              } catch (CameraAccessException e) {
                e.printStackTrace();
              }
            }

            @Override
            public void onConfigureFailed(CameraCaptureSession session) {}
          },
          mBackgroundHandler);

      Log.e("camera", "take picture... sleep");

      try {
        Thread.sleep(2000);
      } catch (InterruptedException e) {
      }

      byte[] bytes;
      Image image = null;
      try {
        //                Log.e("camera", " reader"+reader.getHeight());
        image = reader.acquireLatestImage();
        image.getFormat();
        ByteBuffer buffer = image.getPlanes()[0].getBuffer();
        bytes = new byte[buffer.capacity()];
        buffer.get(bytes);
      } finally {
        if (image != null) {
          image.close();
        }
      }

      // String file_name = "curent_photo";
      FileOutputStream out_put_stream = null;
      try {
        out_put_stream =
            ApplicationContextProvider.getContext()
                .openFileOutput(
                    file_name + ".jpg", ApplicationContextProvider.getContext().MODE_PRIVATE);
      } catch (IOException exception) {
        exception.printStackTrace();
      }
      try {
        out_put_stream.write(bytes);
        Log.e("camera", "saved picture! " + file_name);

        if (imageviewer_new_picture != null) {
          ImageView cap_picture = (ImageView) imageviewer_new_picture;
          Bitmap bitmap_found = FileIO.loadBMPPrivate(file_name, Bitmap.CompressFormat.JPEG);
          cap_picture.setImageBitmap(bitmap_found);
        }

      } catch (IOException e) {
        e.printStackTrace();
      } finally {
        if (null != out_put_stream) {
          try {
            out_put_stream.close();
          } catch (IOException e) {
            e.printStackTrace();
          }
        }
        closeCamera(cameraDevice);
      }
    } catch (CameraAccessException e) {
      e.printStackTrace();
    }
  }
  /**
   * Sets up member variables related to camera.
   *
   * @param width The width of available size for camera preview
   * @param height The height of available size for camera preview
   */
  private void setUpCameraOutputs(int width, int height) {
    Activity activity = getActivity();
    CameraManager manager = (CameraManager) activity.getSystemService(Context.CAMERA_SERVICE);
    try {
      for (String cameraId : manager.getCameraIdList()) {
        CameraCharacteristics characteristics = manager.getCameraCharacteristics(cameraId);

        // We don't use a front facing camera in this sample.
        Integer facing = characteristics.get(CameraCharacteristics.LENS_FACING);
        if (facing != null && facing == CameraCharacteristics.LENS_FACING_FRONT) {
          continue;
        }

        StreamConfigurationMap map =
            characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
        if (map == null) {
          continue;
        }

        // For still image captures, we use the largest available size.
        Size largest =
            Collections.max(
                Arrays.asList(map.getOutputSizes(ImageFormat.JPEG)), new CompareSizesByArea());
        mImageReader =
            ImageReader.newInstance(
                largest.getWidth(), largest.getHeight(), ImageFormat.JPEG, /*maxImages*/ 2);
        mImageReader.setOnImageAvailableListener(mOnImageAvailableListener, mBackgroundHandler);

        // Find out if we need to swap dimension to get the preview size relative to sensor
        // coordinate.
        int displayRotation = activity.getWindowManager().getDefaultDisplay().getRotation();
        //noinspection ConstantConditions
        mSensorOrientation = characteristics.get(CameraCharacteristics.SENSOR_ORIENTATION);
        boolean swappedDimensions = false;
        switch (displayRotation) {
          case Surface.ROTATION_0:
          case Surface.ROTATION_180:
            if (mSensorOrientation == 90 || mSensorOrientation == 270) {
              swappedDimensions = true;
            }
            break;
          case Surface.ROTATION_90:
          case Surface.ROTATION_270:
            if (mSensorOrientation == 0 || mSensorOrientation == 180) {
              swappedDimensions = true;
            }
            break;
          default:
            Log.e(TAG, "Display rotation is invalid: " + displayRotation);
        }

        Point displaySize = new Point();
        activity.getWindowManager().getDefaultDisplay().getSize(displaySize);
        int rotatedPreviewWidth = width;
        int rotatedPreviewHeight = height;
        int maxPreviewWidth = displaySize.x;
        int maxPreviewHeight = displaySize.y;

        if (swappedDimensions) {
          rotatedPreviewWidth = height;
          rotatedPreviewHeight = width;
          maxPreviewWidth = displaySize.y;
          maxPreviewHeight = displaySize.x;
        }

        if (maxPreviewWidth > MAX_PREVIEW_WIDTH) {
          maxPreviewWidth = MAX_PREVIEW_WIDTH;
        }

        if (maxPreviewHeight > MAX_PREVIEW_HEIGHT) {
          maxPreviewHeight = MAX_PREVIEW_HEIGHT;
        }

        // Danger, W.R.! Attempting to use too large a preview size could  exceed the camera
        // bus' bandwidth limitation, resulting in gorgeous previews but the storage of
        // garbage capture data.
        mPreviewSize =
            chooseOptimalSize(
                map.getOutputSizes(SurfaceTexture.class),
                rotatedPreviewWidth,
                rotatedPreviewHeight,
                maxPreviewWidth,
                maxPreviewHeight,
                largest);

        // We fit the aspect ratio of TextureView to the size of preview we picked.
        int orientation = getResources().getConfiguration().orientation;
        if (orientation == Configuration.ORIENTATION_LANDSCAPE) {
          mTextureView.setAspectRatio(mPreviewSize.getWidth(), mPreviewSize.getHeight());
        } else {
          mTextureView.setAspectRatio(mPreviewSize.getHeight(), mPreviewSize.getWidth());
        }

        // Check if the flash is supported.
        Boolean available = characteristics.get(CameraCharacteristics.FLASH_INFO_AVAILABLE);
        mFlashSupported = available == null ? false : available;

        mCameraId = cameraId;
        return;
      }
    } catch (CameraAccessException e) {
      e.printStackTrace();
    } catch (NullPointerException e) {
      // Currently an NPE is thrown when the Camera2API is used but not supported on the
      // device this code runs.
      ErrorDialog.newInstance(getString(R.string.camera_error))
          .show(getChildFragmentManager(), FRAGMENT_DIALOG);
    }
  }