久久国产成人av_抖音国产毛片_a片网站免费观看_A片无码播放手机在线观看,色五月在线观看,亚洲精品m在线观看,女人自慰的免费网址,悠悠在线观看精品视频,一级日本片免费的,亚洲精品久,国产精品成人久久久久久久

搜索
分享

Android 基于Zxing的二維碼掃描優(yōu)化

 卡瑞吉 2020-04-16

最近公司項(xiàng)目App中要集成二維碼掃描來適應(yīng)在戶外工作的時(shí)候,對(duì)碼頭集裝箱等上面貼的A4紙張打印的二維碼進(jìn)行識(shí)別, 一般App二維碼集成后,能掃出來就不管了,但是我們?cè)诩沙晒?根據(jù)用戶反饋,在戶外的環(huán)境下,很多二維碼識(shí)別不了,或者識(shí)別速度慢,我們自己也是適用了一下,發(fā)現(xiàn)也確實(shí)是這樣.

  一般造成這個(gè)識(shí)別不出來的原因,我們總結(jié)了以下幾點(diǎn):

  1. A4紙張打印的標(biāo)簽二維碼, 本來打印就不是特別清晰,有些像素點(diǎn),不一定都打印了出來,

  2. 戶外環(huán)境,多變,灰塵,粉塵影響

  3. 日曬雨淋,還有各種劃痕,造成了二維碼破損和有污漬

  4. Android手機(jī)配置不一樣,有的手機(jī)好一點(diǎn),像素高,有的用戶的像素低

大概就是這些,但是用基于QBar(在Zxing上做了優(yōu)化)的微信,卻能很快的識(shí)別出上面幾種情況造成的二維碼; 基于libqrencode 庫集成的支付寶或者釘釘二維碼掃描,一樣也能識(shí)別出來;還有IOS也就是調(diào)用系統(tǒng)的掃描,也一樣能夠掃描出來,為啥我們大android不行?

老板不管這些,只是說了,別人的可以,為啥你的不可以,那就是你的問題.......

網(wǎng)上找了很多各種幾千個(gè)贊的第三方集成的二維碼,根本就不能滿足上面的需求,當(dāng)時(shí)感覺真心不知道怎么辦好了.

  唯獨(dú)網(wǎng)上找的這個(gè)還可以一點(diǎn):https://github.com/vondear/RxTool 但是破損一些的還是掃描不出來;那個(gè)網(wǎng)上幾千個(gè)贊的一片楓葉的 ,這種環(huán)境下的二維碼掃描根本邊都摸不到.

  還有郭林推薦的:https://github.com/al4fun/SimpleScanner 這個(gè)庫,雖然是大神推薦的,但是比上面的這個(gè),還要差那么好幾點(diǎn),郭林的推薦的二維碼掃描鏈接:https://mp.weixin.qq.com/s/aPqSK1FlsPiENzSE48BVUA

 沒辦法,最后只能自己動(dòng)手,網(wǎng)上找的,沒有找到合適的,目前我們修改的二維碼掃描基本可以做到:除了破損的識(shí)別不了,其他的都能識(shí)別,就是有時(shí)候速度慢了點(diǎn),要多對(duì)一下焦,勉強(qiáng)能夠比上面好那么一點(diǎn)點(diǎn)而已.

代碼如下: (這里面很多類都在原有類的基礎(chǔ)上有改動(dòng),雖然類名相同,但是里面的方法有些有變動(dòng)!)

build.gradle

  1. dependencies{
  2. api fileTree(include: ['*.jar'], dir: 'libs')
  3. api files('libs/core-3.3.0.jar')
  4. //    provided 'com.android.support:appcompat-v7:26.1.0'
  5. compileOnly 'com.android.support:design:26.1.0'
  6. compileOnly 'com.android.support:support-vector-drawable:26.1.0'
  7. }

文件目錄如下:

ZxingConfig.java
  1. public class ZxingConfig implements Serializable {
  4. /*是否播放聲音*/
  5. private boolean isPlayBeep = true;
  6. /*是否震動(dòng)*/
  7. private boolean isShake = false;
  8. /*是否顯示下方的其他功能布局*/
  9. private boolean isShowbottomLayout = true;
  10. /*是否顯示閃光燈按鈕*/
  11. private boolean isShowFlashLight = true;
  12. /*是否顯示相冊(cè)按鈕*/
  13. private boolean isShowAlbum = true;
  17. public boolean isPlayBeep() {
  18. return isPlayBeep;
  19. }
  21. public void setPlayBeep(boolean playBeep) {
  22. isPlayBeep = playBeep;
  23. }
  25. public boolean isShake() {
  26. return isShake;
  27. }
  29. public void setShake(boolean shake) {
  30. isShake = shake;
  31. }
  33. public boolean isShowbottomLayout() {
  34. return isShowbottomLayout;
  35. }
  37. public void setShowbottomLayout(boolean showbottomLayout) {
  38. isShowbottomLayout = showbottomLayout;
  39. }
  41. public boolean isShowFlashLight() {
  42. return isShowFlashLight;
  43. }
  45. public void setShowFlashLight(boolean showFlashLight) {
  46. isShowFlashLight = showFlashLight;
  47. }
  49. public boolean isShowAlbum() {
  50. return isShowAlbum;
  51. }
  53. public void setShowAlbum(boolean showAlbum) {
  54. isShowAlbum = showAlbum;
  55. }
  56. }
CameraFacing.java
  1. public enum CameraFacing {
  3. BACK,  // must be value 0!
  4. FRONT, // must be value 1!
  6. }
OpenCamera.java
  1. public final class OpenCamera {
  3. private final int          index;
  4. private final Camera       camera;
  5. private final CameraFacing facing;
  6. private final int          orientation;
  8. public OpenCamera(int index, Camera camera, CameraFacing facing, int orientation) {
  9. this.index = index;
  10. this.camera = camera;
  11. this.facing = facing;
  12. this.orientation = orientation;
  13. }
  15. public Camera getCamera() {
  16. return camera;
  17. }
  19. public CameraFacing getFacing() {
  20. return facing;
  21. }
  23. public int getOrientation() {
  24. return orientation;
  25. }
  27. @Override
  28. public String toString() {
  29. return "Camera #" + index + " : " + facing + ',' + orientation;
  30. }
  32. }
OpenCameraInterface.java
  1. public final class OpenCameraInterface {
  3. private static final String TAG = OpenCameraInterface.class.getName();
  5. private OpenCameraInterface() {
  6. }
  8. /**
  9. * For {@link #open(int)}, means no preference for which camera to open.
  10. */
  11. public static final int NO_REQUESTED_CAMERA = -1;
  13. /**
  14. * Opens the requested camera with {@link Camera#open(int)}, if one exists.
  15. *
  16. * @param cameraId camera ID of the camera to use. A negative value
  17. *                 or {@link #NO_REQUESTED_CAMERA} means "no preference", in which case a rear-facing
  18. *                 camera is returned if possible or else any camera
  19. * @return handle to {@link OpenCamera} that was opened
  20. */
  21. public static OpenCamera open(int cameraId) {
  23. int numCameras = Camera.getNumberOfCameras();
  24. if (numCameras == 0) {
  25. Log.w(TAG, "No cameras!");
  26. return null;
  27. }
  29. boolean explicitRequest = cameraId >= 0;
  31. Camera.CameraInfo selectedCameraInfo = null;
  32. int index;
  33. if (explicitRequest) {
  34. index = cameraId;
  35. selectedCameraInfo = new Camera.CameraInfo();
  36. Camera.getCameraInfo(index, selectedCameraInfo);
  37. } else {
  38. index = 0;
  39. while (index < numCameras) {
  40. Camera.CameraInfo cameraInfo = new Camera.CameraInfo();
  41. Camera.getCameraInfo(index, cameraInfo);
  42. CameraFacing reportedFacing = CameraFacing.values()[cameraInfo.facing];
  43. if (reportedFacing == CameraFacing.BACK) {
  44. selectedCameraInfo = cameraInfo;
  45. break;
  46. }
  47. index++;
  48. }
  49. }
  51. Camera camera;
  52. if (index < numCameras) {
  53. Log.i(TAG, "Opening camera #" + index);
  54. camera = Camera.open(index);
  55. } else {
  56. if (explicitRequest) {
  57. Log.w(TAG, "Requested camera does not exist: " + cameraId);
  58. camera = null;
  59. } else {
  60. Log.i(TAG, "No camera facing " + CameraFacing.BACK + "; returning camera #0");
  61. camera = Camera.open(0);
  62. selectedCameraInfo = new Camera.CameraInfo();
  63. Camera.getCameraInfo(0, selectedCameraInfo);
  64. }
  65. }
  67. if (camera == null) {
  68. return null;
  69. }
  70. return new OpenCamera(index,
  71. camera,
  72. CameraFacing.values()[selectedCameraInfo.facing],
  73. selectedCameraInfo.orientation);
  74. }
  76. }
AutoFocusManager.java
  1. final class AutoFocusManager implements Camera.AutoFocusCallback {
  3. private static final String TAG = AutoFocusManager.class.getSimpleName();
  5. private static final long AUTO_FOCUS_INTERVAL_MS = 2000L;
  6. private static final Collection<String> FOCUS_MODES_CALLING_AF;
  7. static {
  8. FOCUS_MODES_CALLING_AF = new ArrayList<>(2);
  9. FOCUS_MODES_CALLING_AF.add(Camera.Parameters.FOCUS_MODE_AUTO);
  10. FOCUS_MODES_CALLING_AF.add(Camera.Parameters.FOCUS_MODE_MACRO);
  11. }
  13. private boolean stopped;
  14. private boolean focusing;
  15. private final boolean useAutoFocus;
  16. private final Camera camera;
  17. private AsyncTask<?,?,?> outstandingTask;
  19. AutoFocusManager(Context context, Camera camera) {
  20. this.camera = camera;
  21. SharedPreferences sharedPrefs = PreferenceManager.getDefaultSharedPreferences(context);
  22. String currentFocusMode = camera.getParameters().getFocusMode();
  23. useAutoFocus =
  24. sharedPrefs.getBoolean(QRConstants.KEY_AUTO_FOCUS, true) &&
  25. FOCUS_MODES_CALLING_AF.contains(currentFocusMode);
  26. Log.i(TAG, "Current focus mode '" + currentFocusMode + "'; use auto focus? " + useAutoFocus);
  27. start();
  28. }
  30. @Override
  31. public synchronized void onAutoFocus(boolean success, Camera theCamera) {
  32. focusing = false;
  33. autoFocusAgainLater();
  34. }
  36. private synchronized void autoFocusAgainLater() {
  37. if (!stopped && outstandingTask == null) {
  38. AutoFocusTask newTask = new AutoFocusTask();
  39. try {
  40. newTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
  41. outstandingTask = newTask;
  42. } catch (RejectedExecutionException ree) {
  43. Log.w(TAG, "Could not request auto focus", ree);
  44. }
  45. }
  46. }
  48. synchronized void start() {
  49. //    if (useAutoFocus) {
  50. outstandingTask = null;
  51. if (!stopped && !focusing) {
  52. try {
  53. camera.autoFocus(this);
  54. focusing = true;
  55. } catch (RuntimeException re) {
  56. // Have heard RuntimeException reported in Android 4.0.x+; continue?
  57. Log.w(TAG, "Unexpected exception while focusing", re);
  58. // Try again later to keep cycle going
  59. autoFocusAgainLater();
  60. }
  61. }
  62. //    }
  63. }
  65. private synchronized void cancelOutstandingTask() {
  66. if (outstandingTask != null) {
  67. if (outstandingTask.getStatus() != AsyncTask.Status.FINISHED) {
  68. outstandingTask.cancel(true);
  69. }
  70. outstandingTask = null;
  71. }
  72. }
  74. synchronized void stop() {
  75. stopped = true;
  76. //    if (useAutoFocus) {
  77. cancelOutstandingTask();
  78. // Doesn't hurt to call this even if not focusing
  79. try {
  80. camera.cancelAutoFocus();
  81. } catch (RuntimeException re) {
  82. // Have heard RuntimeException reported in Android 4.0.x+; continue?
  83. Log.w(TAG, "Unexpected exception while cancelling focusing", re);
  84. }
  85. //    }
  86. }
  88. private final class AutoFocusTask extends AsyncTask<Object,Object,Object> {
  89. @Override
  90. protected Object doInBackground(Object... voids) {
  91. try {
  92. Thread.sleep(AUTO_FOCUS_INTERVAL_MS);
  93. } catch (InterruptedException e) {
  94. // continue
  95. }
  96. start();
  97. return null;
  98. }
  99. }
  101. }
CameraConfigurationManager.java
  1. final class CameraConfigurationManager {
  3. private static final String TAG = "CameraConfiguration";
  5. private final Context context;
  6. private int cwNeededRotation;
  7. private int cwRotationFromDisplayToCamera;
  8. private Point screenResolution;
  9. private Point cameraResolution;
  10. private Point bestPreviewSize;
  11. private Point previewSizeOnScreen;
  13. CameraConfigurationManager(Context context) {
  14. this.context = context;
  15. }
  17. /**
  18. * Reads, one time, values from the camera that are needed by the app.
  19. */
  20. void initFromCameraParameters(OpenCamera camera) {
  21. Camera.Parameters parameters = camera.getCamera().getParameters();
  22. WindowManager manager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
  23. Display display = manager.getDefaultDisplay();
  25. int displayRotation = display.getRotation();
  26. int cwRotationFromNaturalToDisplay;
  27. switch (displayRotation) {
  28. case Surface.ROTATION_0:
  29. cwRotationFromNaturalToDisplay = 0;
  30. break;
  31. case Surface.ROTATION_90:
  32. cwRotationFromNaturalToDisplay = 90;
  33. break;
  34. case Surface.ROTATION_180:
  35. cwRotationFromNaturalToDisplay = 180;
  36. break;
  37. case Surface.ROTATION_270:
  38. cwRotationFromNaturalToDisplay = 270;
  39. break;
  40. default:
  41. // Have seen this return incorrect values like -90
  42. if (displayRotation % 90 == 0) {
  43. cwRotationFromNaturalToDisplay = (360 + displayRotation) % 360;
  44. } else {
  45. throw new IllegalArgumentException("Bad rotation: " + displayRotation);
  46. }
  47. }
  48. Log.i(TAG, "Display at: " + cwRotationFromNaturalToDisplay);
  50. int cwRotationFromNaturalToCamera = camera.getOrientation();
  51. Log.i(TAG, "Camera at: " + cwRotationFromNaturalToCamera);
  53. // Still not 100% sure about this. But acts like we need to flip this:
  54. if (camera.getFacing() == CameraFacing.FRONT) {
  55. cwRotationFromNaturalToCamera = (360 - cwRotationFromNaturalToCamera) % 360;
  56. Log.i(TAG, "Front camera overriden to: " + cwRotationFromNaturalToCamera);
  57. }
  59. /*
  60. SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
  61. String overrideRotationString;
  62. if (camera.getFacing() == CameraFacing.FRONT) {
  63. overrideRotationString = prefs.getString(PreferencesActivity.KEY_FORCE_CAMERA_ORIENTATION_FRONT, null);
  64. } else {
  65. overrideRotationString = prefs.getString(PreferencesActivity.KEY_FORCE_CAMERA_ORIENTATION, null);
  66. }
  67. if (overrideRotationString != null && !"-".equals(overrideRotationString)) {
  68. Log.i(TAG, "Overriding camera manually to " + overrideRotationString);
  69. cwRotationFromNaturalToCamera = Integer.parseInt(overrideRotationString);
  70. }
  71. */
  73. cwRotationFromDisplayToCamera =
  74. (360 + cwRotationFromNaturalToCamera - cwRotationFromNaturalToDisplay) % 360;
  75. Log.i(TAG, "Final display orientation: " + cwRotationFromDisplayToCamera);
  76. if (camera.getFacing() == CameraFacing.FRONT) {
  77. Log.i(TAG, "Compensating rotation for front camera");
  78. cwNeededRotation = (360 - cwRotationFromDisplayToCamera) % 360;
  79. } else {
  80. cwNeededRotation = cwRotationFromDisplayToCamera;
  81. }
  82. Log.i(TAG, "Clockwise rotation from display to camera: " + cwNeededRotation);
  84. Point theScreenResolution = new Point();
  85. display.getSize(theScreenResolution);
  86. screenResolution = theScreenResolution;
  87. Log.i(TAG, "Screen resolution in current orientation: " + screenResolution);
  88. cameraResolution = CameraConfigurationUtils.findBestPreviewSizeValue(parameters, screenResolution);
  89. Log.i(TAG, "Camera resolution: " + cameraResolution);
  90. bestPreviewSize = CameraConfigurationUtils.findBestPreviewSizeValue(parameters, screenResolution);
  91. Log.i(TAG, "Best available preview size: " + bestPreviewSize);
  93. boolean isScreenPortrait = screenResolution.x < screenResolution.y;
  94. boolean isPreviewSizePortrait = bestPreviewSize.x < bestPreviewSize.y;
  96. if (isScreenPortrait == isPreviewSizePortrait) {
  97. previewSizeOnScreen = bestPreviewSize;
  98. } else {
  99. previewSizeOnScreen = new Point(bestPreviewSize.y, bestPreviewSize.x);
  100. }
  101. Log.i(TAG, "Preview size on screen: " + previewSizeOnScreen);
  102. }
  104. void setDesiredCameraParameters(OpenCamera camera, boolean safeMode) {
  106. Camera theCamera = camera.getCamera();
  107. Camera.Parameters parameters = theCamera.getParameters();
  109. if (parameters == null) {
  110. Log.w(TAG, "Device error: no camera parameters are available. Proceeding without configuration.");
  111. return;
  112. }
  114. Log.i(TAG, "Initial camera parameters: " + parameters.flatten());
  116. if (safeMode) {
  117. Log.w(TAG, "In camera config safe mode -- most settings will not be honored");
  118. }
  120. //        SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
  122. initializeTorch(parameters, safeMode, QRConstants.disableExposure);
  125. CameraConfigurationUtils.setFocus(
  126. parameters,
  127. //是否支持自動(dòng)對(duì)焦
  128. QRConstants.autoFocus,
  129. true,
  130. safeMode);
  132. if (!safeMode) {
  133. //
  134. //CameraConfigurationUtils.setInvertColor(parameters);
  136. CameraConfigurationUtils.setBarcodeSceneMode(parameters);
  138. CameraConfigurationUtils.setVideoStabilization(parameters);
  139. CameraConfigurationUtils.setFocusArea(parameters);
  140. CameraConfigurationUtils.setMetering(parameters);
  142. }
  144. parameters.setPreviewSize(bestPreviewSize.x, bestPreviewSize.y);
  146. theCamera.setParameters(parameters);
  148. theCamera.setDisplayOrientation(cwRotationFromDisplayToCamera);
  150. Camera.Parameters afterParameters = theCamera.getParameters();
  151. Camera.Size afterSize = afterParameters.getPreviewSize();
  152. if (afterSize != null && (bestPreviewSize.x != afterSize.width || bestPreviewSize.y != afterSize.height)) {
  153. Log.w(TAG, "Camera said it supported preview size " + bestPreviewSize.x + 'x' + bestPreviewSize.y +
  154. ", but after setting it, preview size is " + afterSize.width + 'x' + afterSize.height);
  155. bestPreviewSize.x = afterSize.width;
  156. bestPreviewSize.y = afterSize.height;
  157. }
  158. }
  160. Point getBestPreviewSize() {
  161. return bestPreviewSize;
  162. }
  164. Point getPreviewSizeOnScreen() {
  165. return previewSizeOnScreen;
  166. }
  168. Point getCameraResolution() {
  169. return cameraResolution;
  170. }
  172. Point getScreenResolution() {
  173. return screenResolution;
  174. }
  176. int getCWNeededRotation() {
  177. return cwNeededRotation;
  178. }
  180. boolean getTorchState(Camera camera) {
  181. if (camera != null) {
  182. Camera.Parameters parameters = camera.getParameters();
  183. if (parameters != null) {
  184. String flashMode = camera.getParameters().getFlashMode();
  185. return flashMode != null &&
  186. (Camera.Parameters.FLASH_MODE_ON.equals(flashMode) ||
  187. Camera.Parameters.FLASH_MODE_TORCH.equals(flashMode));
  188. }
  189. }
  190. return false;
  191. }
  193. void setTorch(Camera camera, boolean newSetting) {
  194. Camera.Parameters parameters = camera.getParameters();
  195. doSetTorch(parameters, newSetting, false, QRConstants.disableExposure);
  196. camera.setParameters(parameters);
  197. }
  199. private void initializeTorch(Camera.Parameters parameters, boolean safeMode, boolean disableExposure) {
  200. boolean currentSetting = QRConstants.frontLightMode == FrontLightMode.ON;
  201. doSetTorch(parameters, currentSetting, safeMode, disableExposure);
  202. }
  204. private void doSetTorch(Camera.Parameters parameters, boolean newSetting, boolean safeMode, boolean disableExposure) {
  205. CameraConfigurationUtils.setTorch(parameters, newSetting);
  206. if (!safeMode && !disableExposure) {
  207. CameraConfigurationUtils.setBestExposure(parameters, newSetting);
  208. }
  209. }
  211. }
CameraConfigurationUtils.java
  1. @TargetApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH_MR1)
  2. public final class CameraConfigurationUtils {
  4. private static final String TAG = "CameraConfiguration";
  6. private static final Pattern SEMICOLON = Pattern.compile(";");
  8. private static final int MIN_PREVIEW_PIXELS = 480 * 320; // normal screen
  9. private static final float MAX_EXPOSURE_COMPENSATION = 1.5f;
  10. private static final float MIN_EXPOSURE_COMPENSATION = 0.0f;
  11. private static final double MAX_ASPECT_DISTORTION = 0.15;
  12. private static final int MIN_FPS = 10;
  13. private static final int MAX_FPS = 20;
  14. private static final int AREA_PER_1000 = 400;
  16. private CameraConfigurationUtils() {
  17. }
  19. public static void setFocus(Camera.Parameters parameters,
  20. boolean autoFocus,
  21. boolean disableContinuous,
  22. boolean safeMode) {
  23. List<String> supportedFocusModes = parameters.getSupportedFocusModes();
  24. String focusMode = null;
  25. if (autoFocus) {
  26. if (safeMode || disableContinuous) {
  27. focusMode = findSettableValue("focus mode",
  28. supportedFocusModes,
  29. Camera.Parameters.FOCUS_MODE_AUTO);
  30. } else {
  31. focusMode = findSettableValue("focus mode",
  32. supportedFocusModes,
  33. Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE,
  34. Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO,
  35. Camera.Parameters.FOCUS_MODE_AUTO);
  36. }
  37. }
  38. // Maybe selected auto-focus but not available, so fall through here:
  39. if (!safeMode && focusMode == null) {
  40. focusMode = findSettableValue("focus mode",
  41. supportedFocusModes,
  42. Camera.Parameters.FOCUS_MODE_MACRO,
  43. Camera.Parameters.FOCUS_MODE_EDOF);
  44. }
  45. if (focusMode != null) {
  46. if (focusMode.equals(parameters.getFocusMode())) {
  47. Log.i(TAG, "Focus mode already set to " + focusMode);
  48. } else {
  49. parameters.setFocusMode(focusMode);
  50. }
  51. }
  52. }
  54. public static void setTorch(Camera.Parameters parameters, boolean on) {
  55. List<String> supportedFlashModes = parameters.getSupportedFlashModes();
  56. String flashMode;
  57. if (on) {
  58. flashMode = findSettableValue("flash mode",
  59. supportedFlashModes,
  60. Camera.Parameters.FLASH_MODE_TORCH,
  61. Camera.Parameters.FLASH_MODE_ON);
  62. } else {
  63. flashMode = findSettableValue("flash mode",
  64. supportedFlashModes,
  65. Camera.Parameters.FLASH_MODE_OFF);
  66. }
  67. if (flashMode != null) {
  68. if (flashMode.equals(parameters.getFlashMode())) {
  69. Log.i(TAG, "Flash mode already set to " + flashMode);
  70. } else {
  71. Log.i(TAG, "Setting flash mode to " + flashMode);
  72. parameters.setFlashMode(flashMode);
  73. }
  74. }
  75. }
  77. public static void setBestExposure(Camera.Parameters parameters, boolean lightOn) {
  78. int minExposure = parameters.getMinExposureCompensation();
  79. int maxExposure = parameters.getMaxExposureCompensation();
  80. float step = parameters.getExposureCompensationStep();
  81. if ((minExposure != 0 || maxExposure != 0) && step > 0.0f) {
  82. // Set low when light is on
  83. float targetCompensation = lightOn ? MIN_EXPOSURE_COMPENSATION : MAX_EXPOSURE_COMPENSATION;
  84. int compensationSteps = Math.round(targetCompensation / step);
  85. float actualCompensation = step * compensationSteps;
  86. // Clamp value:
  87. compensationSteps = Math.max(Math.min(compensationSteps, maxExposure), minExposure);
  88. if (parameters.getExposureCompensation() == compensationSteps) {
  89. Log.i(TAG, "Exposure compensation already set to " + compensationSteps + " / " + actualCompensation);
  90. } else {
  91. Log.i(TAG, "Setting exposure compensation to " + compensationSteps + " / " + actualCompensation);
  92. parameters.setExposureCompensation(compensationSteps);
  93. }
  94. } else {
  95. Log.i(TAG, "Camera does not support exposure compensation");
  96. }
  97. }
  99. public static void setBestPreviewFPS(Camera.Parameters parameters) {
  100. setBestPreviewFPS(parameters, MIN_FPS, MAX_FPS);
  101. }
  103. public static void setBestPreviewFPS(Camera.Parameters parameters, int minFPS, int maxFPS) {
  104. List<int[]> supportedPreviewFpsRanges = parameters.getSupportedPreviewFpsRange();
  105. Log.i(TAG, "Supported FPS ranges: " + toString(supportedPreviewFpsRanges));
  106. if (supportedPreviewFpsRanges != null && !supportedPreviewFpsRanges.isEmpty()) {
  107. int[] suitableFPSRange = null;
  108. for (int[] fpsRange : supportedPreviewFpsRanges) {
  109. int thisMin = fpsRange[Camera.Parameters.PREVIEW_FPS_MIN_INDEX];
  110. int thisMax = fpsRange[Camera.Parameters.PREVIEW_FPS_MAX_INDEX];
  111. if (thisMin >= minFPS * 1000 && thisMax <= maxFPS * 1000) {
  112. suitableFPSRange = fpsRange;
  113. break;
  114. }
  115. }
  116. if (suitableFPSRange == null) {
  117. Log.i(TAG, "No suitable FPS range?");
  118. } else {
  119. int[] currentFpsRange = new int[2];
  120. parameters.getPreviewFpsRange(currentFpsRange);
  121. if (Arrays.equals(currentFpsRange, suitableFPSRange)) {
  122. Log.i(TAG, "FPS range already set to " + Arrays.toString(suitableFPSRange));
  123. } else {
  124. Log.i(TAG, "Setting FPS range to " + Arrays.toString(suitableFPSRange));
  125. parameters.setPreviewFpsRange(suitableFPSRange[Camera.Parameters.PREVIEW_FPS_MIN_INDEX],
  126. suitableFPSRange[Camera.Parameters.PREVIEW_FPS_MAX_INDEX]);
  127. }
  128. }
  129. }
  130. }
  132. public static void setFocusArea(Camera.Parameters parameters) {
  133. if (parameters.getMaxNumFocusAreas() > 0) {
  134. Log.i(TAG, "Old focus areas: " + toString(parameters.getFocusAreas()));
  135. List<Camera.Area> middleArea = buildMiddleArea(AREA_PER_1000);
  136. Log.i(TAG, "Setting focus area to : " + toString(middleArea));
  137. parameters.setFocusAreas(middleArea);
  138. } else {
  139. Log.i(TAG, "Device does not support focus areas");
  140. }
  141. }
  143. public static void setMetering(Camera.Parameters parameters) {
  144. if (parameters.getMaxNumMeteringAreas() > 0) {
  145. Log.i(TAG, "Old metering areas: " + parameters.getMeteringAreas());
  146. List<Camera.Area> middleArea = buildMiddleArea(AREA_PER_1000);
  147. Log.i(TAG, "Setting metering area to : " + toString(middleArea));
  148. parameters.setMeteringAreas(middleArea);
  149. } else {
  150. Log.i(TAG, "Device does not support metering areas");
  151. }
  152. }
  154. private static List<Camera.Area> buildMiddleArea(int areaPer1000) {
  155. return Collections.singletonList(
  156. new Camera.Area(new Rect(-areaPer1000, -areaPer1000, areaPer1000, areaPer1000), 1));
  157. }
  159. public static void setVideoStabilization(Camera.Parameters parameters) {
  160. if (parameters.isVideoStabilizationSupported()) {
  161. if (parameters.getVideoStabilization()) {
  162. Log.i(TAG, "Video stabilization already enabled");
  163. } else {
  164. Log.i(TAG, "Enabling video stabilization...");
  165. parameters.setVideoStabilization(true);
  166. }
  167. } else {
  168. Log.i(TAG, "This device does not support video stabilization");
  169. }
  170. }
  172. public static void setBarcodeSceneMode(Camera.Parameters parameters) {
  173. if (Camera.Parameters.SCENE_MODE_BARCODE.equals(parameters.getSceneMode())) {
  174. Log.i(TAG, "Barcode scene mode already set");
  175. return;
  176. }
  177. String sceneMode = findSettableValue("scene mode",
  178. parameters.getSupportedSceneModes(),
  179. Camera.Parameters.SCENE_MODE_BARCODE);
  180. if (sceneMode != null) {
  181. parameters.setSceneMode(sceneMode);
  182. }
  183. }
  185. public static void setZoom(Camera.Parameters parameters, double targetZoomRatio) {
  186. if (parameters.isZoomSupported()) {
  187. Integer zoom = indexOfClosestZoom(parameters, targetZoomRatio);
  188. if (zoom == null) {
  189. return;
  190. }
  191. if (parameters.getZoom() == zoom) {
  192. Log.i(TAG, "Zoom is already set to " + zoom);
  193. } else {
  194. Log.i(TAG, "Setting zoom to " + zoom);
  195. parameters.setZoom(zoom);
  196. }
  197. } else {
  198. Log.i(TAG, "Zoom is not supported");
  199. }
  200. }
  202. private static Integer indexOfClosestZoom(Camera.Parameters parameters, double targetZoomRatio) {
  203. List<Integer> ratios = parameters.getZoomRatios();
  204. Log.i(TAG, "Zoom ratios: " + ratios);
  205. int maxZoom = parameters.getMaxZoom();
  206. if (ratios == null || ratios.isEmpty() || ratios.size() != maxZoom + 1) {
  207. Log.w(TAG, "Invalid zoom ratios!");
  208. return null;
  209. }
  210. double target100 = 100.0 * targetZoomRatio;
  211. double smallestDiff = Double.POSITIVE_INFINITY;
  212. int closestIndex = 0;
  213. for (int i = 0; i < ratios.size(); i++) {
  214. double diff = Math.abs(ratios.get(i) - target100);
  215. if (diff < smallestDiff) {
  216. smallestDiff = diff;
  217. closestIndex = i;
  218. }
  219. }
  220. Log.i(TAG, "Chose zoom ratio of " + (ratios.get(closestIndex) / 100.0));
  221. return closestIndex;
  222. }
  224. public static void setInvertColor(Camera.Parameters parameters) {
  225. if (Camera.Parameters.EFFECT_NEGATIVE.equals(parameters.getColorEffect())) {
  226. Log.i(TAG, "Negative effect already set");
  227. return;
  228. }
  229. String colorMode = findSettableValue("color effect",
  230. parameters.getSupportedColorEffects(),
  231. Camera.Parameters.EFFECT_NEGATIVE);
  232. if (colorMode != null) {
  233. parameters.setColorEffect(colorMode);
  234. }
  235. }
  237. public static Point findBestPreviewSizeValue(Camera.Parameters parameters, Point screenResolution) {
  239. List<Camera.Size> rawSupportedSizes = parameters.getSupportedPreviewSizes();
  240. if (rawSupportedSizes == null) {
  241. Log.w(TAG, "Device returned no supported preview sizes; using default");
  242. Camera.Size defaultSize = parameters.getPreviewSize();
  243. if (defaultSize == null) {
  244. throw new IllegalStateException("Parameters contained no preview size!");
  245. }
  246. return new Point(defaultSize.width, defaultSize.height);
  247. }
  249. // Sort by size, descending
  250. List<Camera.Size> supportedPreviewSizes = new ArrayList<>(rawSupportedSizes);
  251. Collections.sort(supportedPreviewSizes, new Comparator<Camera.Size>() {
  252. @Override
  253. public int compare(Camera.Size a, Camera.Size b) {
  254. int aPixels = a.height * a.width;
  255. int bPixels = b.height * b.width;
  256. if (bPixels < aPixels) {
  257. return -1;
  258. }
  259. if (bPixels > aPixels) {
  260. return 1;
  261. }
  262. return 0;
  263. }
  264. });
  266. if (Log.isLoggable(TAG, Log.INFO)) {
  267. StringBuilder previewSizesString = new StringBuilder();
  268. for (Camera.Size supportedPreviewSize : supportedPreviewSizes) {
  269. previewSizesString.append(supportedPreviewSize.width).append('x')
  270. .append(supportedPreviewSize.height).append(' ');
  271. }
  272. Log.i(TAG, "Supported preview sizes: " + previewSizesString);
  273. }
  275. double screenAspectRatio = (double) screenResolution.x / (double) screenResolution.y;
  277. // Remove sizes that are unsuitable
  278. Iterator<Camera.Size> it = supportedPreviewSizes.iterator();
  279. while (it.hasNext()) {
  280. Camera.Size supportedPreviewSize = it.next();
  281. int realWidth = supportedPreviewSize.width;
  282. int realHeight = supportedPreviewSize.height;
  283. if (realWidth * realHeight < MIN_PREVIEW_PIXELS) {
  284. it.remove();
  285. continue;
  286. }
  288. boolean isCandidatePortrait = realWidth < realHeight;
  289. int maybeFlippedWidth = isCandidatePortrait ? realHeight : realWidth;
  290. int maybeFlippedHeight = isCandidatePortrait ? realWidth : realHeight;
  291. double aspectRatio = (double) maybeFlippedWidth / (double) maybeFlippedHeight;
  292. double distortion = Math.abs(aspectRatio - screenAspectRatio);
  293. if (distortion > MAX_ASPECT_DISTORTION) {
  294. it.remove();
  295. continue;
  296. }
  298. if (maybeFlippedWidth == screenResolution.x && maybeFlippedHeight == screenResolution.y) {
  299. Point exactPoint = new Point(realWidth, realHeight);
  300. Log.i(TAG, "Found preview size exactly matching screen size: " + exactPoint);
  301. return exactPoint;
  302. }
  303. }
  305. // If no exact match, use largest preview size. This was not a great idea on older devices because
  306. // of the additional computation needed. We're likely to get here on newer Android 4+ devices, where
  307. // the CPU is much more powerful.
  308. if (!supportedPreviewSizes.isEmpty()) {
  309. Camera.Size largestPreview = supportedPreviewSizes.get(0);
  310. Point largestSize = new Point(largestPreview.width, largestPreview.height);
  311. Log.i(TAG, "Using largest suitable preview size: " + largestSize);
  312. return largestSize;
  313. }
  315. // If there is nothing at all suitable, return current preview size
  316. Camera.Size defaultPreview = parameters.getPreviewSize();
  317. if (defaultPreview == null) {
  318. throw new IllegalStateException("Parameters contained no preview size!");
  319. }
  320. Point defaultSize = new Point(defaultPreview.width, defaultPreview.height);
  321. Log.i(TAG, "No suitable preview sizes, using default: " + defaultSize);
  322. return defaultSize;
  323. }
  325. private static String findSettableValue(String name,
  326. Collection<String> supportedValues,
  327. String... desiredValues) {
  328. Log.i(TAG, "Requesting " + name + " value from among: " + Arrays.toString(desiredValues));
  329. Log.i(TAG, "Supported " + name + " values: " + supportedValues);
  330. if (supportedValues != null) {
  331. for (String desiredValue : desiredValues) {
  332. if (supportedValues.contains(desiredValue)) {
  333. Log.i(TAG, "Can set " + name + " to: " + desiredValue);
  334. return desiredValue;
  335. }
  336. }
  337. }
  338. Log.i(TAG, "No supported values match");
  339. return null;
  340. }
  342. private static String toString(Collection<int[]> arrays) {
  343. if (arrays == null || arrays.isEmpty()) {
  344. return "[]";
  345. }
  346. StringBuilder buffer = new StringBuilder();
  347. buffer.append('[');
  348. Iterator<int[]> it = arrays.iterator();
  349. while (it.hasNext()) {
  350. buffer.append(Arrays.toString(it.next()));
  351. if (it.hasNext()) {
  352. buffer.append(", ");
  353. }
  354. }
  355. buffer.append(']');
  356. return buffer.toString();
  357. }
  359. private static String toString(Iterable<Camera.Area> areas) {
  360. if (areas == null) {
  361. return null;
  362. }
  363. StringBuilder result = new StringBuilder();
  364. for (Camera.Area area : areas) {
  365. result.append(area.rect).append(':').append(area.weight).append(' ');
  366. }
  367. return result.toString();
  368. }
  370. public static String collectStats(Camera.Parameters parameters) {
  371. return collectStats(parameters.flatten());
  372. }
  374. public static String collectStats(CharSequence flattenedParams) {
  375. StringBuilder result = new StringBuilder(1000);
  377. result.append("BOARD=").append(Build.BOARD).append('\n');
  378. result.append("BRAND=").append(Build.BRAND).append('\n');
  379. result.append("CPU_ABI=").append(Build.CPU_ABI).append('\n');
  380. result.append("DEVICE=").append(Build.DEVICE).append('\n');
  381. result.append("DISPLAY=").append(Build.DISPLAY).append('\n');
  382. result.append("FINGERPRINT=").append(Build.FINGERPRINT).append('\n');
  383. result.append("HOST=").append(Build.HOST).append('\n');
  384. result.append("ID=").append(Build.ID).append('\n');
  385. result.append("MANUFACTURER=").append(Build.MANUFACTURER).append('\n');
  386. result.append("MODEL=").append(Build.MODEL).append('\n');
  387. result.append("PRODUCT=").append(Build.PRODUCT).append('\n');
  388. result.append("TAGS=").append(Build.TAGS).append('\n');
  389. result.append("TIME=").append(Build.TIME).append('\n');
  390. result.append("TYPE=").append(Build.TYPE).append('\n');
  391. result.append("USER=").append(Build.USER).append('\n');
  392. result.append("VERSION.CODENAME=").append(Build.VERSION.CODENAME).append('\n');
  393. result.append("VERSION.INCREMENTAL=").append(Build.VERSION.INCREMENTAL).append('\n');
  394. result.append("VERSION.RELEASE=").append(Build.VERSION.RELEASE).append('\n');
  395. result.append("VERSION.SDK_INT=").append(Build.VERSION.SDK_INT).append('\n');
  397. if (flattenedParams != null) {
  398. String[] params = SEMICOLON.split(flattenedParams);
  399. Arrays.sort(params);
  400. for (String param : params) {
  401. result.append(param).append('\n');
  402. }
  403. }
  405. return result.toString();
  406. }
  408. }
CameraManager.java
  1. public final class CameraManager {
  3. private static final String TAG = CameraManager.class.getSimpleName();
  5. private static final int MIN_FRAME_WIDTH = 240;
  6. private static final int MIN_FRAME_HEIGHT = 240;
  7. private static final int MAX_FRAME_WIDTH = 1200; // = 5/8 * 1920
  8. private static final int MAX_FRAME_HEIGHT = 675; // = 5/8 * 1080
  10. private final Context                    context;
  11. private final CameraConfigurationManager configManager;
  12. private       OpenCamera                 camera;
  13. private       AutoFocusManager           autoFocusManager;
  14. private       Rect                       framingRect;
  15. private       Rect                       framingRectInPreview;
  16. private       boolean                    initialized;
  17. private       boolean                    previewing;
  18. private int requestedCameraId = OpenCameraInterface.NO_REQUESTED_CAMERA;
  19. private int requestedFramingRectWidth;
  20. private int requestedFramingRectHeight;
  21. /**
  22. * Preview frames are delivered here, which we pass on to the registered handler. Make sure to
  23. * clear the handler so it will only receive one message.
  24. */
  25. private final PreviewCallback previewCallback;
  27. public CameraManager(Context context) {
  28. this.context = context;
  29. this.configManager = new CameraConfigurationManager(context);
  30. previewCallback = new PreviewCallback(configManager);
  31. }
  33. /**
  34. * Opens the camera driver and initializes the hardware parameters.
  35. *
  36. * @param holder The surface object which the camera will draw preview frames into.
  37. * @throws IOException Indicates the camera driver failed to open.
  38. */
  39. public synchronized void openDriver(SurfaceHolder holder) throws IOException {
  40. OpenCamera theCamera = camera;
  41. if (theCamera == null) {
  42. theCamera = OpenCameraInterface.open(requestedCameraId);
  43. if (theCamera == null) {
  44. throw new IOException("Camera.open() failed to return object from driver");
  45. }
  46. camera = theCamera;
  47. }
  49. if (!initialized) {
  50. initialized = true;
  51. configManager.initFromCameraParameters(theCamera);
  52. if (requestedFramingRectWidth > 0 && requestedFramingRectHeight > 0) {
  53. setManualFramingRect(requestedFramingRectWidth, requestedFramingRectHeight);
  54. requestedFramingRectWidth = 0;
  55. requestedFramingRectHeight = 0;
  56. }
  57. }
  59. Camera cameraObject = theCamera.getCamera();
  60. Camera.Parameters parameters = cameraObject.getParameters();
  61. String parametersFlattened = parameters == null ? null : parameters.flatten(); // Save these, temporarily
  62. try {
  63. configManager.setDesiredCameraParameters(theCamera, false);
  64. } catch (RuntimeException re) {
  65. // Driver failed
  66. Log.w(TAG, "Camera rejected parameters. Setting only minimal safe-mode parameters");
  67. Log.i(TAG, "Resetting to saved camera params: " + parametersFlattened);
  68. // Reset:
  69. if (parametersFlattened != null) {
  70. parameters = cameraObject.getParameters();
  71. parameters.unflatten(parametersFlattened);
  72. try {
  73. cameraObject.setParameters(parameters);
  74. configManager.setDesiredCameraParameters(theCamera, true);
  75. } catch (RuntimeException re2) {
  76. // Well, darn. Give up
  77. Log.w(TAG, "Camera rejected even safe-mode parameters! No configuration");
  78. }
  79. }
  80. }
  81. cameraObject.setPreviewDisplay(holder);
  83. }
  85. public synchronized boolean isOpen() {
  86. return camera != null;
  87. }
  89. /**
  90. * Closes the camera driver if still in use.
  91. */
  92. public synchronized void closeDriver() {
  93. if (camera != null) {
  94. camera.getCamera().release();
  95. camera = null;
  96. // Make sure to clear these each time we close the camera, so that any scanning rect
  97. // requested by intent is forgotten.
  98. framingRect = null;
  99. framingRectInPreview = null;
  100. }
  101. }
  103. /**
  104. * Asks the camera hardware to begin drawing preview frames to the screen.
  105. */
  106. public synchronized void startPreview() {
  107. OpenCamera theCamera = camera;
  108. if (theCamera != null && !previewing) {
  109. theCamera.getCamera().startPreview();
  110. previewing = true;
  111. autoFocusManager = new AutoFocusManager(context, theCamera.getCamera());
  112. }
  113. }
  115. /**
  116. * Tells the camera to stop drawing preview frames.
  117. */
  118. public synchronized void stopPreview() {
  119. if (autoFocusManager != null) {
  120. autoFocusManager.stop();
  121. autoFocusManager = null;
  122. }
  123. if (camera != null && previewing) {
  124. camera.getCamera().stopPreview();
  125. previewCallback.setHandler(null, 0);
  126. previewing = false;
  127. }
  128. }
  130. /**
  131. * Convenience method for {@link CaptureActivity}
  132. *
  133. * @param newSetting if {@code true}, light should be turned on if currently off. And vice versa.
  134. */
  135. public synchronized void setTorch(boolean newSetting) {
  136. OpenCamera theCamera = camera;
  137. if (theCamera != null) {
  138. if (newSetting != configManager.getTorchState(theCamera.getCamera())) {
  139. boolean wasAutoFocusManager = autoFocusManager != null;
  140. if (wasAutoFocusManager) {
  141. autoFocusManager.stop();
  142. autoFocusManager = null;
  143. }
  144. configManager.setTorch(theCamera.getCamera(), newSetting);
  145. if (wasAutoFocusManager) {
  146. autoFocusManager = new AutoFocusManager(context, theCamera.getCamera());
  147. autoFocusManager.start();
  148. }
  149. }
  150. }
  151. }
  153. /**
  154. * A single preview frame will be returned to the handler supplied. The data will arrive as byte[]
  155. * in the message.obj field, with width and height encoded as message.arg1 and message.arg2,
  156. * respectively.
  157. *
  158. * @param handler The handler to send the message to.
  159. * @param message The what field of the message to be sent.
  160. */
  161. public synchronized void requestPreviewFrame(Handler handler, int message) {
  162. OpenCamera theCamera = camera;
  163. if (theCamera != null && previewing) {
  164. previewCallback.setHandler(handler, message);
  165. theCamera.getCamera().setOneShotPreviewCallback(previewCallback);
  166. }
  167. }
  169. /**
  170. * Calculates the framing rect which the UI should draw to show the user where to place the
  171. * barcode. This target helps with alignment as well as forces the user to hold the device
  172. * far enough away to ensure the image will be in focus.
  173. *
  174. * @return The rectangle to draw on screen in window coordinates.
  175. */
  176. public synchronized Rect getFramingRect() {
  177. if (framingRect == null) {
  178. if (camera == null) {
  179. return null;
  180. }
  181. Point screenResolution = configManager.getScreenResolution();
  182. if (screenResolution == null) {
  183. // Called early, before init even finished
  184. return null;
  185. }
  187. int width = findDesiredDimensionInRange(screenResolution.x, MIN_FRAME_WIDTH, MAX_FRAME_WIDTH);
  188. int height = findDesiredDimensionInRange(screenResolution.y, MIN_FRAME_HEIGHT, MAX_FRAME_HEIGHT);
  190. //保持掃描框?qū)捀咭恢?/div>
  191. int finalSize = height;
  192. if (height > width) {
  193. finalSize = width;
  194. }
  195. int leftOffset = (screenResolution.x - finalSize) / 2;
  196. int topOffset = (screenResolution.y - finalSize) / 2;
  198. framingRect = new Rect(leftOffset, topOffset, leftOffset + finalSize, topOffset + finalSize);
  199. Log.d(TAG, "Calculated framing rect: " + framingRect + " width =" + width + " height = " + height +
  200. " screenResolution.x = " + screenResolution.x + " screenResolution.y = " + screenResolution.y);
  201. }
  202. return framingRect;
  203. }
  205. private static int findDesiredDimensionInRange(int resolution, int hardMin, int hardMax) {
  206. int dim = 5 * resolution / 8; // Target 5/8 of each dimension
  207. if (dim < hardMin) {
  208. return hardMin;
  209. }
  210. if (dim > hardMax) {
  211. return hardMax;
  212. }
  213. return dim;
  214. }
  216. /**
  217. * Like {@link #getFramingRect} but coordinates are in terms of the preview frame,
  218. * not UI / screen.
  219. *
  220. * @return {@link Rect} expressing barcode scan area in terms of the preview size
  221. */
  222. public synchronized Rect getFramingRectInPreview() {
  223. if (framingRectInPreview == null) {
  224. Rect framingRect = getFramingRect();
  225. if (framingRect == null) {
  226. return null;
  227. }
  228. Rect rect = new Rect(framingRect);
  229. Point cameraResolution = configManager.getCameraResolution();
  230. Point screenResolution = configManager.getScreenResolution();
  231. if (cameraResolution == null || screenResolution == null) {
  232. // Called early, before init even finished
  233. return null;
  234. }
  235. rect.left = rect.left * cameraResolution.x / screenResolution.x;
  236. rect.right = rect.right * cameraResolution.x / screenResolution.x;
  237. rect.top = rect.top * cameraResolution.y / screenResolution.y;
  238. rect.bottom = rect.bottom * cameraResolution.y / screenResolution.y;
  239. framingRectInPreview = rect;
  240. }
  241. return framingRectInPreview;
  242. }
  245. /**
  246. * Allows third party apps to specify the camera ID, rather than determine
  247. * it automatically based on available cameras and their orientation.
  248. *
  249. * @param cameraId camera ID of the camera to use. A negative value means "no preference".
  250. */
  251. public synchronized void setManualCameraId(int cameraId) {
  252. requestedCameraId = cameraId;
  253. }
  255. /**
  256. * Allows third party apps to specify the scanning rectangle dimensions, rather than determine
  257. * them automatically based on screen resolution.
  258. *
  259. * @param width  The width in pixels to scan.
  260. * @param height The height in pixels to scan.
  261. */
  262. public synchronized void setManualFramingRect(int width, int height) {
  263. if (initialized) {
  264. Point screenResolution = configManager.getScreenResolution();
  265. if (width > screenResolution.x) {
  266. width = screenResolution.x;
  267. }
  268. if (height > screenResolution.y) {
  269. height = screenResolution.y;
  270. }
  271. int leftOffset = (screenResolution.x - width) / 2;
  272. int topOffset = (screenResolution.y - height) / 2;
  273. framingRect = new Rect(leftOffset, topOffset, leftOffset + width, topOffset + height);
  274. Log.d(TAG, "Calculated manual framing rect: " + framingRect);
  275. framingRectInPreview = null;
  276. } else {
  277. requestedFramingRectWidth = width;
  278. requestedFramingRectHeight = height;
  279. }
  280. }
  282. /**
  283. * A factory method to build the appropriate LuminanceSource object based on the format
  284. * of the preview buffers, as described by Camera.Parameters.
  285. *
  286. * @param data   A preview frame.
  287. * @param width  The width of the image.
  288. * @param height The height of the image.
  289. * @return A PlanarYUVLuminanceSource instance.
  290. */
  291. public PlanarYUVLuminanceSource buildLuminanceSource(byte[] data, int width, int height) {
  292. Rect rect = getFramingRectInPreview();
  293. if (rect == null) {
  294. return null;
  295. }
  296. // Go ahead and assume it's YUV rather than die.
  297. return new PlanarYUVLuminanceSource(data, width, height, rect.left, rect.top,
  298. rect.width(), rect.height(), false);
  299. }
  301. public void openLight() {
  302. if (camera != null && camera.getCamera() != null) {
  303. Camera.Parameters parameter = camera.getCamera().getParameters();
  304. parameter.setFlashMode(Camera.Parameters.FLASH_MODE_TORCH);
  305. camera.getCamera().setParameters(parameter);
  306. }
  307. }
  309. public void offLight() {
  310. if (camera != null && camera.getCamera() != null) {
  311. Camera.Parameters parameter = camera.getCamera().getParameters();
  312. parameter.setFlashMode(Camera.Parameters.FLASH_MODE_OFF);
  313. camera.getCamera().setParameters(parameter);
  314. }
  315. }
  319. }
FrontLightMode.java
  1. public enum FrontLightMode {
  3. /** Always on. */
  4. ON,
  5. /** On only when ambient light is low. */
  6. AUTO,
  7. /** Always off. */
  8. OFF
  10. /* private static FrontLightMode parse(String modeString) {
  11. return modeString == null ? OFF : valueOf(modeString);
  12. }
  14. public static FrontLightMode readPref(SharedPreferences sharedPrefs) {
  15. return parse(sharedPrefs.getString(PreferencesActivity.KEY_FRONT_LIGHT_MODE, OFF.toString()));
  16. }*/
  18. }
PreviewCallback.java
  1. final class PreviewCallback implements Camera.PreviewCallback {
  3. private static final String TAG = PreviewCallback.class.getSimpleName();
  5. private final CameraConfigurationManager configManager;
  6. private       Handler                    previewHandler;
  7. private       int                        previewMessage;
  9. PreviewCallback(CameraConfigurationManager configManager) {
  10. this.configManager = configManager;
  11. }
  13. void setHandler(Handler previewHandler, int previewMessage) {
  14. this.previewHandler = previewHandler;
  15. this.previewMessage = previewMessage;
  16. }
  18. @Override
  19. public void onPreviewFrame(byte[] data, Camera camera) {
  20. Point cameraResolution = configManager.getCameraResolution();
  21. Handler thePreviewHandler = previewHandler;
  22. if (cameraResolution != null && thePreviewHandler != null) {
  23. //給DecodeHandler發(fā)消息
  24. Message message = thePreviewHandler.obtainMessage(previewMessage, cameraResolution.x,
  25. cameraResolution.y, data);
  26. message.sendToTarget();
  27. previewHandler = null;
  28. } else {
  29. Log.d(TAG, "Got preview callback, but no handler or resolution available");
  30. }
  31. }
  33. }
QRConstants.java
  1. public class QRConstants {
  3. public static       boolean        vibrateEnable   = true;
  4. public static       boolean        beepEnable      = true;
  5. public static       FrontLightMode frontLightMode  = FrontLightMode.OFF;
  6. public static       boolean        disableExposure = true;
  7. public static       boolean        autoFocus       = true;
  8. public static final String         KEY_AUTO_FOCUS  = "preferences_auto_focus";
  10. }
Constant.java
  1. public class Constant {
  2. public static final int DECODE = 1;
  3. public static final int DECODE_FAILED = 2;
  4. public static final int DECODE_SUCCEEDED = 3;
  5. public static final int LAUNCH_PRODUCT_QUERY = 4;
  6. public static final int QUIT = 5;
  7. public static final int RESTART_PREVIEW = 6;
  8. public static final int RETURN_SCAN_RESULT = 7;
  9. public static final int FLASH_OPEN = 8;
  10. public static final int FLASH_CLOSE = 9;
  11. public static final int REQUEST_IMAGE = 10;
  12. public static final String CODED_CONTENT = "codedContent";
  13. public static final String CODED_BITMAP = "codedBitmap";
  16. /*傳遞的zxingconfing*/
  18. public static final String INTENT_ZXING_CONFIG = "zxingConfig";
  21. }
AmbientLightManager.java
  1. public final class AmbientLightManager implements SensorEventListener {
  3. private static final float TOO_DARK_LUX = 45.0f;
  4. private static final float BRIGHT_ENOUGH_LUX = 450.0f;
  6. private final Context       context;
  7. private       CameraManager cameraManager;
  8. private       Sensor        lightSensor;
  10. public AmbientLightManager(Context context) {
  11. this.context = context;
  12. }
  14. public void start(CameraManager cameraManager) {
  15. this.cameraManager = cameraManager;
  16. SharedPreferences sharedPrefs = PreferenceManager.getDefaultSharedPreferences(context);
  17. if (QRConstants.frontLightMode == FrontLightMode.AUTO) {
  18. SensorManager sensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
  19. lightSensor = sensorManager.getDefaultSensor(Sensor.TYPE_LIGHT);
  20. if (lightSensor != null) {
  21. sensorManager.registerListener(this, lightSensor, SensorManager.SENSOR_DELAY_NORMAL);
  22. }
  23. }
  24. }
  26. public void stop() {
  27. if (lightSensor != null) {
  28. SensorManager sensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
  29. sensorManager.unregisterListener(this);
  30. cameraManager = null;
  31. lightSensor = null;
  32. }
  33. }
  35. @Override
  36. public void onSensorChanged(SensorEvent sensorEvent) {
  37. float ambientLightLux = sensorEvent.values[0];
  38. if (cameraManager != null) {
  39. if (ambientLightLux <= TOO_DARK_LUX) {
  40. cameraManager.setTorch(true);
  41. } else if (ambientLightLux >= BRIGHT_ENOUGH_LUX) {
  42. cameraManager.setTorch(false);
  43. }
  44. }
  45. }
  47. @Override
  48. public void onAccuracyChanged(Sensor sensor, int accuracy) {
  49. // do nothing
  50. }
  52. }
BeepManager.java
  1. public final class BeepManager implements MediaPlayer.OnCompletionListener,
  2. MediaPlayer.OnErrorListener, Closeable {
  4. private static final String TAG = BeepManager.class.getSimpleName();
  6. private static final float BEEP_VOLUME = 0.10f;
  7. private static final long VIBRATE_DURATION = 200L;
  9. private final Activity activity;
  10. private MediaPlayer mediaPlayer;
  11. private boolean playBeep;
  12. private boolean vibrate;
  14. public BeepManager(Activity activity) {
  15. this.activity = activity;
  16. this.mediaPlayer = null;
  17. updatePrefs();
  18. }
  21. public boolean isPlayBeep() {
  22. return playBeep;
  23. }
  25. public void setPlayBeep(boolean playBeep) {
  26. this.playBeep = playBeep;
  27. }
  29. public boolean isVibrate() {
  30. return vibrate;
  31. }
  33. public void setVibrate(boolean vibrate) {
  34. this.vibrate = vibrate;
  35. }
  37. public synchronized void updatePrefs() {
  41. if (playBeep && mediaPlayer == null) {
  42. // The volume on STREAM_SYSTEM is not adjustable, and users found it
  43. // too loud,
  44. // so we now play on the music stream.
  45. // 設(shè)置activity音量控制鍵控制的音頻流
  46. activity.setVolumeControlStream(AudioManager.STREAM_MUSIC);
  47. mediaPlayer = buildMediaPlayer(activity);
  48. }
  49. }
  51. /**
  52. * 開啟響鈴和震動(dòng)
  53. */
  54. @SuppressLint("MissingPermission")
  55. public synchronized void playBeepSoundAndVibrate() {
  56. if (playBeep && mediaPlayer != null) {
  57. mediaPlayer.start();
  58. }
  59. if (vibrate) {
  60. Vibrator vibrator = (Vibrator) activity
  61. .getSystemService(Context.VIBRATOR_SERVICE);
  62. vibrator.vibrate(VIBRATE_DURATION);
  63. }
  64. }
  66. /**
  67. * 創(chuàng)建MediaPlayer
  68. *
  69. * @param activity
  70. * @return
  71. */
  72. private MediaPlayer buildMediaPlayer(Context activity) {
  73. MediaPlayer mediaPlayer = new MediaPlayer();
  74. mediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
  75. // 監(jiān)聽是否播放完成
  76. mediaPlayer.setOnCompletionListener(this);
  77. mediaPlayer.setOnErrorListener(this);
  78. // 配置播放資源
  79. try {
  80. AssetFileDescriptor file = activity.getResources()
  81. .openRawResourceFd(R.raw.beep);
  82. try {
  83. mediaPlayer.setDataSource(file.getFileDescriptor(),
  84. file.getStartOffset(), file.getLength());
  85. } finally {
  86. file.close();
  87. }
  88. // 設(shè)置音量
  89. mediaPlayer.setVolume(BEEP_VOLUME, BEEP_VOLUME);
  90. mediaPlayer.prepare();
  91. return mediaPlayer;
  92. } catch (IOException ioe) {
  93. Log.w(TAG, ioe);
  94. mediaPlayer.release();
  95. return null;
  96. }
  97. }
  99. @Override
  100. public void onCompletion(MediaPlayer mp) {
  101. // When the beep has finished playing, rewind to queue up another one.
  102. mp.seekTo(0);
  103. }
  105. @Override
  106. public synchronized boolean onError(MediaPlayer mp, int what, int extra) {
  107. if (what == MediaPlayer.MEDIA_ERROR_SERVER_DIED) {
  108. // we are finished, so put up an appropriate error toast if required
  109. // and finish
  110. activity.finish();
  111. } else {
  112. // possibly media player error, so release and recreate
  113. mp.release();
  114. mediaPlayer = null;
  115. updatePrefs();
  116. }
  117. return true;
  118. }
  120. @Override
  121. public synchronized void close() {
  122. if (mediaPlayer != null) {
  123. mediaPlayer.release();
  124. mediaPlayer = null;
  125. }
  126. }
  128. }
CaptureActivity.java
  1. public class CaptureActivity extends Activity implements SurfaceHolder.Callback, View.OnClickListener {
  3. static {
  4. AppCompatDelegate.setCompatVectorFromResourcesEnabled(true);//處理api 5.1以下手機(jī)不兼容問題
  5. }
  7. private static final String TAG = CaptureActivity.class.getSimpleName();
  8. private ImageView mBackmImg;
  9. private TextView  mTitle;
  10. public int REQ_ID_GALLERY = 0;
  13. public static boolean isLightOn = false;
  15. private IMResUtil mImResUtil;
  17. public static void startAction(Activity activity, Bundle bundle, int requestCode) {
  18. Intent intent = new Intent(activity, CaptureActivity.class);
  19. intent.putExtras(bundle);
  20. activity.startActivityForResult(intent, requestCode);
  21. }
  23. private CameraManager             cameraManager;
  24. private CaptureActivityHandler    handler;
  25. private ViewfinderView            viewfinderView;
  26. private boolean                   hasSurface;
  27. private Collection<BarcodeFormat> decodeFormats;
  28. private String                    characterSet;
  29. private InactivityTimer           inactivityTimer;
  30. private BeepManager               beepManager;
  31. private AmbientLightManager       ambientLightManager;
  34. private LinearLayout bottomLayout;
  35. private TextView     flashLightTv;
  36. private ImageView    flashLightIv;
  37. private LinearLayout flashLightLayout;
  38. private LinearLayout albumLayout;
  39. private ZxingConfig  config;
  40. private ImageView    img_phone;
  42. public ViewfinderView getViewfinderView() {
  43. return viewfinderView;
  44. }
  46. public Handler getHandler() {
  47. return handler;
  48. }
  50. public CameraManager getCameraManager() {
  51. return cameraManager;
  52. }
  54. @Override
  55. protected void onCreate(Bundle savedInstanceState) {
  56. super.onCreate(savedInstanceState);
  57. mImResUtil = new IMResUtil(this);
  58. setContentView(mImResUtil.getLayout("activity_device_qrcode_capture"));
  59. //設(shè)置浸入式狀態(tài)欄
  60. setColor(this, Color.BLACK);
  61. hasSurface = false;
  62. inactivityTimer = new InactivityTimer(this);
  65. ambientLightManager = new AmbientLightManager(this);
  67. /*先獲取配置信息*/
  68. try {
  69. config = (ZxingConfig) getIntent().getExtras().get(Constant.INTENT_ZXING_CONFIG);
  70. } catch (Exception e) {
  72. Log.i("config", e.toString());
  73. }
  75. if (config == null) {
  76. config = new ZxingConfig();
  77. }
  78. beepManager = new BeepManager(this);
  80. beepManager.setPlayBeep(config.isPlayBeep());
  81. beepManager.setVibrate(config.isShake());
  83. initView(getIntent().getExtras());
  84. onEvent(getIntent().getExtras());
  85. }
  88. private void initView(Bundle bundle) {
  89. //判斷是否為橫屏狀態(tài)
  90. if ("landscape".equals(bundle.getString("portraitOrLandscape"))) {
  91. setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
  92. }
  93. mBackmImg = (ImageView) findViewById(mImResUtil.getId("iv_qr_back"));
  94. mTitle = (TextView) findViewById(mImResUtil.getId("tv_qr_title"));
  95. viewfinderView = (ViewfinderView) findViewById(mImResUtil.getId("vv_qr_viewfinderView"));
  97. flashLightTv = (TextView) findViewById(mImResUtil.getId("flashLightTv"));
  98. bottomLayout = (LinearLayout) findViewById(mImResUtil.getId("bottomLayout"));
  99. flashLightIv = (ImageView) findViewById(mImResUtil.getId("flashLightIv"));
  100. img_phone = (ImageView) findViewById(mImResUtil.getId("img_phone"));
  101. flashLightLayout = (LinearLayout) findViewById(mImResUtil.getId("flashLightLayout"));
  102. flashLightLayout.setOnClickListener(this);
  103. albumLayout = (LinearLayout) findViewById(mImResUtil.getId("albumLayout"));
  104. albumLayout.setOnClickListener(this);
  107. }
  109. private void onEvent(Bundle bundle) {
  110. switchVisibility(bottomLayout, config.isShowbottomLayout());
  111. switchVisibility(flashLightLayout, config.isShowFlashLight());
  112. switchVisibility(albumLayout, config.isShowAlbum());
  113. flashLightIv.setImageResource(R.drawable.device_qrcode_scan_flash_off);
  114. img_phone.setImageResource(R.drawable.ic_photo);
  115. /*有閃光燈就顯示手電筒按鈕  否則不顯示*/
  116. if (isSupportCameraLedFlash(getPackageManager())) {
  117. flashLightLayout.setVisibility(View.VISIBLE);
  118. } else {
  119. flashLightLayout.setVisibility(View.GONE);
  120. }
  121. /********************新增 END*****************************/
  122. mBackmImg.setOnClickListener(this);
  123. if (bundle == null) {
  124. return;
  125. }
  126. String titileText = bundle.getString("titileText");
  127. if (titileText != null && !titileText.isEmpty()) {
  128. mTitle.setText(titileText);
  129. }
  130. String headColor = bundle.getString("headColor");
  131. mTitle.setTextColor(Color.parseColor(headColor));
  132. float headSize = bundle.getFloat("headSize");
  133. if (headSize > 0) {
  134. mTitle.setTextSize(headSize);
  136. }
  137. }
  139. /**
  140. * 沉浸式狀態(tài)欄
  141. *
  142. * @param activity
  143. * @param color
  144. */
  145. public static void setColor(Activity activity, int color) {
  146. if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
  147. // 設(shè)置狀態(tài)欄透明
  148. activity.getWindow().addFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS);
  149. // 生成一個(gè)狀態(tài)欄大小的矩形
  150. View statusView = createStatusView(activity, color);
  151. // 添加 statusView 到布局中
  152. ViewGroup decorView = (ViewGroup) activity.getWindow().getDecorView();
  153. decorView.addView(statusView);
  154. // 設(shè)置根布局的參數(shù)
  155. ViewGroup rootView = (ViewGroup) ((ViewGroup) activity.findViewById(android.R.id.content)).getChildAt(0);
  156. rootView.setFitsSystemWindows(true);
  157. rootView.setClipToPadding(true);
  158. }
  159. }
  161. /**
  162. * 繪制一個(gè)和狀態(tài)欄登高的矩形
  163. *
  164. * @param activity
  165. * @param color
  166. */
  167. private static View createStatusView(Activity activity, int color) {
  168. // 獲得狀態(tài)欄高度
  169. int resourceId = activity.getResources().getIdentifier("status_bar_height", "dimen", "android");
  170. int statusBarHeight = activity.getResources().getDimensionPixelSize(resourceId);
  172. View statusView = new View(activity);
  173. LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, statusBarHeight);
  174. statusView.setLayoutParams(params);
  175. statusView.setBackgroundColor(color);
  176. return statusView;
  177. }
  180. @Override
  181. public void onClick(View v) {
  183. int id = v.getId();
  184. if (id == mImResUtil.getId("iv_qr_back")) {
  185. this.finish();
  186. } else if (id == mImResUtil.getId("albumLayout")) {//打開相冊(cè)
  187. //            Intent intent = new Intent();
  188. //            intent.setType("image/*");
  189. //            intent.setAction(Intent.ACTION_GET_CONTENT);
  190. //            intent.addCategory(Intent.CATEGORY_OPENABLE);
  191. //            startActivityForResult(intent, REQ_ID_GALLERY);
  194. /*打開相冊(cè)*/
  195. Intent intent = new Intent();
  196. intent.setAction(Intent.ACTION_PICK);
  197. intent.setType("image/*");
  198. startActivityForResult(intent, REQ_ID_GALLERY);
  199. } else if (id == mImResUtil.getId("flashLightLayout")) {//打開手電筒感應(yīng)部分
  200. if (isLightOn) {
  201. isLightOn = false;
  202. cameraManager.offLight();
  203. switchFlashImg(9);
  204. } else {
  205. isLightOn = true;
  206. cameraManager.openLight();
  207. switchFlashImg(8);
  208. }
  209. }
  212. }
  214. @Override
  215. protected void onActivityResult(int requestCode, int resultCode, Intent data) {
  216. super.onActivityResult(requestCode, resultCode, data);
  217. if (requestCode == REQ_ID_GALLERY) {
  218. if (resultCode == RESULT_OK) {
  219. Uri uri = data.getData();
  220. if (uri != null) {
  221. String path = FileUtil.checkPicturePath(CaptureActivity.this, uri);//Device.getActivity()
  222. BitmapFactory.Options bmOptions = new BitmapFactory.Options();
  223. bmOptions.inJustDecodeBounds = false;
  224. bmOptions.inPurgeable = true;
  226. Bitmap bmp = BitmapFactory.decodeFile(path, bmOptions);
  227. decodeQRCode(bmp, this);
  228. }
  229. }
  230. }
  233. //-----------------------------------------------------
  234. if (requestCode == Constant.REQUEST_IMAGE && resultCode == RESULT_OK) {
  235. String path = ImageUtil.getImageAbsolutePath(this, data.getData());
  236. Log.e(TAG, "onActivityResult: -------二維碼:path" + path);
  237. BitmapFactory.Options bmOptions = new BitmapFactory.Options();
  238. bmOptions.inJustDecodeBounds = false;
  239. bmOptions.inPurgeable = true;
  240. Bitmap bmp = BitmapFactory.decodeFile(path, bmOptions);
  241. decodeQRCode(bmp, this);
  243. }
  245. }
  247. /**
  248. * 解析二維碼圖片
  249. *
  250. * @param bitmap   要解析的二維碼圖片
  251. */
  252. public final Map<DecodeHintType, Object> HINTS = new EnumMap<>(DecodeHintType.class);
  254. @SuppressLint("StaticFieldLeak")
  255. public void decodeQRCode(final Bitmap bitmap, final Activity activity) {
  256. new AsyncTask<Void, Void, String>() {
  257. @Override
  258. protected String doInBackground(Void... params) {
  259. try {
  260. int width = bitmap.getWidth();
  261. int height = bitmap.getHeight();
  262. int[] pixels = new int[width * height];
  263. bitmap.getPixels(pixels, 0, width, 0, 0, width, height);
  264. RGBLuminanceSource source = new RGBLuminanceSource(width, height, pixels);
  265. Result result = new MultiFormatReader().decode(new BinaryBitmap(new HybridBinarizer(source)), HINTS);
  266. String url = "解析失敗";
  267. if (result != null && result.getText() != null) {
  268. url = result.getText();
  269. }
  270. Intent resultIntent = new Intent();
  271. Bundle bundle = new Bundle();
  272. bundle.putString(Constant.CODED_CONTENT, url);
  273. resultIntent.putExtras(bundle);
  274. activity.setResult(RESULT_OK, resultIntent);
  275. CaptureActivity.this.finish();
  276. return result.getText();
  277. } catch (Exception e) {
  278. return null;
  279. }
  280. }
  282. @Override
  283. protected void onPostExecute(String result) {
  284. Log.d("CaptureActivity", "result=" + result);
  285. Toast.makeText(CaptureActivity.this, "解析失敗,換個(gè)圖片試一下", Toast.LENGTH_LONG).show();
  286. }
  287. }.execute();
  289. }
  291. @Override
  292. protected void onResume() {
  293. super.onResume();
  294. cameraManager = new CameraManager(getApplication());
  295. viewfinderView.setCameraManager(cameraManager);
  296. handler = null;
  298. beepManager.updatePrefs();
  299. ambientLightManager.start(cameraManager);
  301. inactivityTimer.onResume();
  304. decodeFormats = null;
  305. characterSet = null;
  306. SurfaceView surfaceView = (SurfaceView) findViewById(mImResUtil.getId("device_qrcode_preview_view"));
  307. SurfaceHolder surfaceHolder = surfaceView.getHolder();
  308. if (hasSurface) {
  309. initCamera(surfaceHolder);
  310. } else {
  311. surfaceHolder.addCallback(this);
  312. }
  313. }
  315. @Override
  316. protected void onPause() {
  317. if (handler != null) {
  318. handler.quitSynchronously();
  319. handler = null;
  320. }
  321. inactivityTimer.onPause();
  322. ambientLightManager.stop();
  323. beepManager.close();
  324. cameraManager.closeDriver();
  325. if (!hasSurface) {
  326. SurfaceView surfaceView = (SurfaceView) findViewById(mImResUtil.getId("device_qrcode_preview_view"));
  327. SurfaceHolder surfaceHolder = surfaceView.getHolder();
  328. surfaceHolder.removeCallback(this);
  329. }
  330. super.onPause();
  331. }
  333. @Override
  334. protected void onDestroy() {
  335. inactivityTimer.shutdown();
  336. super.onDestroy();
  337. }
  339. private void initCamera(SurfaceHolder surfaceHolder) {
  340. if (surfaceHolder == null) {
  341. throw new IllegalStateException("No SurfaceHolder provided");
  342. }
  343. if (cameraManager.isOpen()) {
  344. Log.w(TAG, "initCamera() while already open -- late SurfaceView callback?");
  345. return;
  346. }
  347. try {
  348. cameraManager.openDriver(surfaceHolder);
  349. // Creating the handler starts the preview, which can also throw a RuntimeException.
  350. if (handler == null) {
  351. handler = new CaptureActivityHandler(this, decodeFormats, characterSet, cameraManager);
  352. }
  353. } catch (IOException ioe) {
  354. Log.w(TAG, ioe);
  355. } catch (RuntimeException e) {
  356. // Barcode Scanner has seen crashes in the wild of this variety:
  357. // java.?lang.?RuntimeException: Fail to connect to camera service
  358. Log.e(TAG, "Unexpected error initializing camera", e);
  359. }
  360. }
  362. public void drawViewfinder() {
  363. viewfinderView.drawViewfinder();
  364. }
  366. public void handleDecode(Result rawResult, Bitmap barcode, float scaleFactor) {
  367. Log.d("wxl", "rawResult=" + rawResult);
  369. boolean fromLiveScan = barcode != null;
  370. if (fromLiveScan) {
  371. String resultString = rawResult.getText();
  372. Log.e("wxl", "rawResult=" + rawResult.getText());
  373. beepManager.playBeepSoundAndVibrate();
  374. Intent resultIntent = new Intent();
  375. Bundle bundle = new Bundle();
  376. bundle.putString(Constant.CODED_CONTENT, resultString);
  377. resultIntent.putExtras(bundle);
  378. this.setResult(RESULT_OK, resultIntent);
  379. } else {
  380. //            this.setResult(RESULT_OK, resultIntent);
  381. Toast.makeText(CaptureActivity.this, "掃描失敗", Toast.LENGTH_SHORT).show();
  382. }
  383. CaptureActivity.this.finish();
  384. }
  387. @Override
  388. public void surfaceCreated(SurfaceHolder holder) {
  389. if (holder == null) {
  390. Log.e(TAG, "*** WARNING *** surfaceCreated() gave us a null surface!");
  391. }
  392. if (!hasSurface) {
  393. hasSurface = true;
  394. initCamera(holder);
  395. }
  396. }
  398. @Override
  399. public void surfaceDestroyed(SurfaceHolder holder) {
  400. hasSurface = false;
  401. }
  403. @Override
  404. public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
  406. }
  409. /********************新增代碼 start: **************************/
  410. private void switchVisibility(View view, boolean b) {
  411. if (b) {
  412. view.setVisibility(View.VISIBLE);
  413. } else {
  414. view.setVisibility(View.GONE);
  415. }
  416. }
  418. /**
  419. * @param pm
  420. *
  421. * @return 是否有閃光燈
  422. */
  423. public static boolean isSupportCameraLedFlash(PackageManager pm) {
  424. if (pm != null) {
  425. FeatureInfo[] features = pm.getSystemAvailableFeatures();
  426. if (features != null) {
  427. for (FeatureInfo f : features) {
  428. if (f != null && PackageManager.FEATURE_CAMERA_FLASH.equals(f.name)) {
  429. return true;
  430. }
  431. }
  432. }
  433. }
  434. return false;
  435. }
  437. /**
  438. * @param flashState 切換閃光燈圖片
  439. */
  440. public void switchFlashImg(int flashState) {
  442. if (flashState == Constant.FLASH_OPEN) {
  443. flashLightIv.setImageResource(R.drawable.device_qrcode_scan_flash_on);//ic_open
  444. flashLightTv.setText("關(guān)閉閃光燈");
  445. } else {
  446. flashLightIv.setImageResource(R.drawable.device_qrcode_scan_flash_off);//ic_close
  447. flashLightTv.setText("打開閃光燈");
  448. }
  450. }
  451. /********************新增代碼 END*****************************/
  452. }
CaptureActivityHandler.java
  1. public final class CaptureActivityHandler extends Handler {
  3. private static final String TAG = CaptureActivityHandler.class.getSimpleName();
  5. private final CaptureActivity activity;
  6. private final DecodeThread    decodeThread;
  7. private       State           state;
  8. private final CameraManager   cameraManager;
  9. private final IMResUtil       mImResUtil;
  10. //    private       RelativeLayout  mLightLinearLay;//LinearLayout  手電筒的線性布局
  12. private enum State {
  13. PREVIEW, SUCCESS, DONE
  14. }
  16. public CaptureActivityHandler(CaptureActivity activity, Collection<BarcodeFormat> decodeFormats, String characterSet, CameraManager cameraManager) {
  17. this.activity = activity;
  18. mImResUtil = new IMResUtil(activity);
  20. decodeThread = new DecodeThread(activity, decodeFormats, characterSet, new ViewfinderResultPointCallback(activity.getViewfinderView()));
  21. decodeThread.start();
  22. state = State.SUCCESS;
  24. // Start ourselves capturing previews and decoding.
  25. this.cameraManager = cameraManager;
  26. cameraManager.startPreview();
  27. Log.d(TAG, "CaptureActivityHandler " + CaptureActivityHandler.class.toString());
  28. restartPreviewAndDecode();
  29. }
  31. @Override
  32. public void handleMessage(Message message) {
  34. int what = message.what;
  35. if (what == mImResUtil.getId("device_qrcode_restart_preview")) {
  36. restartPreviewAndDecode();
  38. } else if (what == mImResUtil.getId("device_qrcode_decode_succeeded")) {
  39. state = State.SUCCESS;
  40. Bundle bundle = message.getData();
  41. Bitmap barcode = null;
  42. float scaleFactor = 1.0f;
  43. if (bundle != null) {
  44. byte[] compressedBitmap = bundle.getByteArray(DecodeThread.BARCODE_BITMAP);
  45. if (compressedBitmap != null) {
  46. barcode = BitmapFactory.decodeByteArray(compressedBitmap, 0, compressedBitmap.length, null);
  47. // Mutable copy:
  48. barcode = barcode.copy(Bitmap.Config.ARGB_8888, true);
  49. }
  50. scaleFactor = bundle.getFloat(DecodeThread.BARCODE_SCALED_FACTOR);
  51. }
  52. activity.handleDecode((Result) message.obj, barcode, scaleFactor);
  54. } else if (what == mImResUtil.getId("device_qrcode_decode_failed")) {
  55. state = State.PREVIEW;
  57. cameraManager.requestPreviewFrame(decodeThread.getHandler(), mImResUtil.getId("device_qrcode_decode"));
  59. } else if (what == mImResUtil.getId("device_qrcode_return_scan_result")) {
  60. activity.setResult(Activity.RESULT_OK, (Intent) message.obj);
  61. activity.finish();
  63. } else if (what == mImResUtil.getId("device_qrcode_launch_product_query")) {
  64. String url = (String) message.obj;
  65. Intent intent = new Intent(Intent.ACTION_VIEW);
  66. intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET);
  67. intent.setData(Uri.parse(url));
  69. ResolveInfo resolveInfo = activity.getPackageManager().resolveActivity(intent, PackageManager.MATCH_DEFAULT_ONLY);
  70. String browserPackageName = null;
  71. if (resolveInfo != null && resolveInfo.activityInfo != null) {
  72. browserPackageName = resolveInfo.activityInfo.packageName;
  73. Log.d(TAG, "Using browser in package " + browserPackageName);
  74. }
  76. // Needed for default Android browser / Chrome only apparently
  77. if ("com.android.browser".equals(browserPackageName) || "com.android.chrome".equals(browserPackageName)) {
  78. intent.setPackage(browserPackageName);
  79. intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
  80. intent.putExtra(Browser.EXTRA_APPLICATION_ID, browserPackageName);
  81. }
  83. try {
  84. activity.startActivity(intent);
  85. } catch (ActivityNotFoundException ignored) {
  86. Log.w(TAG, "Can't find anything to handle VIEW of URI " + url);
  87. }
  88. }
  89. }
  91. public void quitSynchronously() {
  92. state = State.DONE;
  93. cameraManager.stopPreview();
  95. Message quit = Message.obtain(decodeThread.getHandler(), mImResUtil.getId("device_qrcode_quit"));
  96. quit.sendToTarget();
  97. try {
  98. // Wait at most half a second; should be enough time, and onPause() will timeout quickly
  99. decodeThread.join(500L);
  100. } catch (InterruptedException e) {
  101. // continue
  102. }
  104. // Be absolutely sure we don't send any queued up messages
  105. removeMessages(mImResUtil.getId("device_qrcode_decode_succeeded"));
  106. removeMessages(mImResUtil.getId("device_qrcode_decode_failed"));
  107. }
  109. private void restartPreviewAndDecode() {
  110. if (state == State.SUCCESS) {
  111. state = State.PREVIEW;
  112. //decodeThread.getHandler()拿到DecodeHandler
  113. cameraManager.requestPreviewFrame(decodeThread.getHandler(), mImResUtil.getId("device_qrcode_decode"));
  114. activity.drawViewfinder();
  115. }
  116. }
  118. }
DecodeFormatManager.java
  1. final class DecodeFormatManager {
  3. private static final Pattern COMMA_PATTERN = Pattern.compile(",");
  5. //  static final Set<BarcodeFormat> PRODUCT_FORMATS;
  6. //  static final Set<BarcodeFormat> INDUSTRIAL_FORMATS;
  7. //  private static final Set<BarcodeFormat> ONE_D_FORMATS;
  8. static final Set<BarcodeFormat> QR_CODE_FORMATS = EnumSet.of(BarcodeFormat.QR_CODE);
  9. //  static final Set<BarcodeFormat> DATA_MATRIX_FORMATS = EnumSet.of(BarcodeFormat.DATA_MATRIX);
  10. //  static final Set<BarcodeFormat> AZTEC_FORMATS = EnumSet.of(BarcodeFormat.AZTEC);
  11. //  static final Set<BarcodeFormat> PDF417_FORMATS = EnumSet.of(BarcodeFormat.PDF_417);
  12. /*static {
  13. PRODUCT_FORMATS = EnumSet.of(BarcodeFormat.UPC_A,
  14. BarcodeFormat.UPC_E,
  15. BarcodeFormat.EAN_13,
  16. BarcodeFormat.EAN_8,
  17. BarcodeFormat.RSS_14,
  18. BarcodeFormat.RSS_EXPANDED);
  19. INDUSTRIAL_FORMATS = EnumSet.of(BarcodeFormat.CODE_39,
  20. BarcodeFormat.CODE_93,
  21. BarcodeFormat.CODE_128,
  22. BarcodeFormat.ITF,
  23. BarcodeFormat.CODABAR);
  24. ONE_D_FORMATS = EnumSet.copyOf(PRODUCT_FORMATS);
  25. ONE_D_FORMATS.addAll(INDUSTRIAL_FORMATS);
  26. }*/
  27. private static final Map<String,Set<BarcodeFormat>> FORMATS_FOR_MODE;
  28. static {
  29. FORMATS_FOR_MODE = new HashMap<>();
  30. //    FORMATS_FOR_MODE.put(Intents.Scan.ONE_D_MODE, ONE_D_FORMATS);
  31. //    FORMATS_FOR_MODE.put(Intents.Scan.PRODUCT_MODE, PRODUCT_FORMATS);
  32. FORMATS_FOR_MODE.put(Intents.Scan.QR_CODE_MODE, QR_CODE_FORMATS);
  33. //    FORMATS_FOR_MODE.put(Intents.Scan.DATA_MATRIX_MODE, DATA_MATRIX_FORMATS);
  34. //    FORMATS_FOR_MODE.put(Intents.Scan.AZTEC_MODE, AZTEC_FORMATS);
  35. //    FORMATS_FOR_MODE.put(Intents.Scan.PDF417_MODE, PDF417_FORMATS);
  36. }
  38. private DecodeFormatManager() {}
  40. static Set<BarcodeFormat> parseDecodeFormats(Intent intent) {
  41. Iterable<String> scanFormats = null;
  42. CharSequence scanFormatsString = intent.getStringExtra(Intents.Scan.FORMATS);
  43. if (scanFormatsString != null) {
  44. scanFormats = Arrays.asList(COMMA_PATTERN.split(scanFormatsString));
  45. }
  46. return parseDecodeFormats(scanFormats, intent.getStringExtra(Intents.Scan.MODE));
  47. }
  49. static Set<BarcodeFormat> parseDecodeFormats(Uri inputUri) {
  50. List<String> formats = inputUri.getQueryParameters(Intents.Scan.FORMATS);
  51. if (formats != null && formats.size() == 1 && formats.get(0) != null){
  52. formats = Arrays.asList(COMMA_PATTERN.split(formats.get(0)));
  53. }
  54. return parseDecodeFormats(formats, inputUri.getQueryParameter(Intents.Scan.MODE));
  55. }
  57. private static Set<BarcodeFormat> parseDecodeFormats(Iterable<String> scanFormats, String decodeMode) {
  58. if (scanFormats != null) {
  59. Set<BarcodeFormat> formats = EnumSet.noneOf(BarcodeFormat.class);
  60. try {
  61. for (String format : scanFormats) {
  62. formats.add(BarcodeFormat.valueOf(format));
  63. }
  64. return formats;
  65. } catch (IllegalArgumentException iae) {
  66. // ignore it then
  67. }
  68. }
  69. if (decodeMode != null) {
  70. return FORMATS_FOR_MODE.get(decodeMode);
  71. }
  72. return null;
  73. }
  75. }
DecodeHandler.java
  1. final class DecodeHandler extends Handler {
  3. private static final String TAG = DecodeHandler.class.getSimpleName();
  4. public static boolean isWeakLight  = false;
  6. private final CaptureActivity   activity;
  7. private final MultiFormatReader multiFormatReader;
  8. private boolean running = true;
  9. private final IMResUtil mImResUtil;
  11. DecodeHandler(CaptureActivity activity, Map<DecodeHintType, Object> hints) {
  13. multiFormatReader = new MultiFormatReader();
  14. multiFormatReader.setHints(hints);
  15. this.activity = activity;
  16. mImResUtil = new IMResUtil(activity);
  17. }
  19. @Override
  20. public void handleMessage(Message message) {
  21. if (!running) {
  22. return;
  23. }
  24. int what = message.what;
  25. if (what == mImResUtil.getId("device_qrcode_decode")) {
  26. decode((byte[]) message.obj, message.arg1, message.arg2);
  27. } else if (what == mImResUtil.getId("device_qrcode_quit")) {
  28. isWeakLight  = false;
  29. CaptureActivity.isLightOn = false;
  30. running = false;
  31. Looper.myLooper().quit();
  32. }
  33. }
  35. /**
  36. * Decode the data within the viewfinder rectangle, and time how long it took. For efficiency,
  37. * reuse the same reader objects from one decode to the next.
  38. *
  39. * @param data   The YUV preview frame.
  40. * @param width  The width of the preview frame.
  41. * @param height The height of the preview frame.
  42. */
  43. private void decode(byte[] data, int width, int height) {
  45. Log.i(TAG, "decode");
  47. //弱光檢測(cè)
  48. analysisColor(data,width,height);
  50. long start = System.currentTimeMillis();
  51. Result rawResult = null;
  52. PlanarYUVLuminanceSource source = activity.getCameraManager().buildLuminanceSource(data, width, height);
  53. if (source != null) {
  54. BinaryBitmap bitmap = new BinaryBitmap(new HybridBinarizer(source));
  55. try {
  56. rawResult = multiFormatReader.decodeWithState(bitmap);
  57. } catch (ReaderException re) {
  58. // continue
  59. } finally {
  60. multiFormatReader.reset();
  61. }
  62. }
  63. Handler handler = activity.getHandler();//拿到CaptureActivityHandler
  64. Log.d(TAG, "Found handler " + handler);
  65. if (rawResult != null) {
  66. // Don't log the barcode contents for security.
  67. long end = System.currentTimeMillis();
  68. Log.d(TAG, "Found barcode in " + (end - start) + " ms");
  69. if (handler != null) {
  70. //給CaptureActivityHandler發(fā)消息
  71. Message message = Message.obtain(handler, mImResUtil.getId("device_qrcode_decode_succeeded"), rawResult);
  72. Bundle bundle = new Bundle();
  73. bundleThumbnail(source, bundle);
  74. message.setData(bundle);
  75. message.sendToTarget();
  76. }
  77. } else {
  78. if (handler != null) {
  79. Message message = Message.obtain(handler, mImResUtil.getId("device_qrcode_decode_failed"));
  80. message.sendToTarget();
  81. }
  82. }
  83. }
  85. private static void bundleThumbnail(PlanarYUVLuminanceSource source, Bundle bundle) {
  86. int[] pixels = source.renderThumbnail();
  87. int width = source.getThumbnailWidth();
  88. int height = source.getThumbnailHeight();
  89. Bitmap bitmap = Bitmap.createBitmap(pixels, 0, width, width, height, Bitmap.Config.ARGB_8888);
  90. ByteArrayOutputStream out = new ByteArrayOutputStream();
  91. bitmap.compress(Bitmap.CompressFormat.JPEG, 50, out);
  92. bundle.putByteArray(DecodeThread.BARCODE_BITMAP, out.toByteArray());
  93. bundle.putFloat(DecodeThread.BARCODE_SCALED_FACTOR, (float) width / source.getWidth());
  94. }
  95. private  int[] decodeYUV420SP(byte[] yuv420sp, int width, int height) {
  96. final int frameSize = width * height;
  98. int rgb[] = new int[width * height];
  99. for (int j = 0, yp = 0; j < height; j++) {
  100. int uvp = frameSize + (j >> 1) * width, u = 0, v = 0;
  101. for (int i = 0; i < width; i++, yp++) {
  102. int y = (0xff & ((int) yuv420sp[yp])) - 16;
  103. if (y < 0) y = 0;
  104. if ((i & 1) == 0) {
  105. v = (0xff & yuv420sp[uvp++]) - 128;
  106. u = (0xff & yuv420sp[uvp++]) - 128;
  107. }
  109. int y1192 = 1192 * y;
  110. int r = (y1192 + 1634 * v);
  111. int g = (y1192 - 833 * v - 400 * u);
  112. int b = (y1192 + 2066 * u);
  114. if (r < 0) r = 0;
  115. else if (r > 262143) r = 262143;
  116. if (g < 0) g = 0;
  117. else if (g > 262143) g = 262143;
  118. if (b < 0) b = 0;
  119. else if (b > 262143) b = 262143;
  121. rgb[yp] = 0xff000000 | ((r << 6) & 0xff0000) | ((g >> 2) &
  122. 0xff00) | ((b >> 10) & 0xff);
  125. }
  126. }
  127. return rgb;
  128. }
  129. private  int getAverageColor(Bitmap bitmap) {
  130. int redBucket = 0;
  131. int greenBucket = 0;
  132. int blueBucket = 0;
  133. int pixelCount = 0;
  135. for (int y = 0; y < bitmap.getHeight(); y++) {
  136. for (int x = 0; x < bitmap.getWidth(); x++) {
  137. int c = bitmap.getPixel(x, y);
  139. pixelCount++;
  140. redBucket += Color.red(c);
  141. greenBucket += Color.green(c);
  142. blueBucket += Color.blue(c);
  143. }
  144. }
  146. int averageColor = Color.rgb(redBucket / pixelCount, greenBucket
  147. / pixelCount, blueBucket / pixelCount);
  148. return averageColor;
  149. }
  150. //分析預(yù)覽幀中圖片的arg 取平均值
  152. public  void analysisColor(byte[] data, int width, int height) {
  153. int[] rgb = decodeYUV420SP(data, width / 8, height / 8);
  154. Bitmap bmp = Bitmap.createBitmap(rgb, width / 8, height / 8, Bitmap.Config.ARGB_8888);//這里報(bào)錯(cuò)
  155. if (bmp != null) {
  156. //取以中心點(diǎn)寬高10像素的圖片來分析
  157. Bitmap resizeBitmap = Bitmap.createBitmap(bmp, bmp.getWidth() / 2, bmp.getHeight() / 2, 10, 10);
  158. float color = (float) getAverageColor(resizeBitmap);
  159. DecimalFormat decimalFormat1 = new DecimalFormat("0.00");
  160. String percent = decimalFormat1.format(color / -16777216);
  161. float floatPercent = Float.parseFloat(percent);
  162. isWeakLight = floatPercent >= 0.99 && floatPercent <= 1.00;
  163. //            Log.i(TAG,"isWeakLight "+isWeakLight);
  164. if (null != resizeBitmap) {
  165. resizeBitmap.recycle();
  166. }
  167. bmp.recycle();
  168. }
  169. }
  170. }
DecodeHintManager.java
  1. final class DecodeHintManager {
  3. private static final String TAG = DecodeHintManager.class.getSimpleName();
  5. // This pattern is used in decoding integer arrays.
  6. private static final Pattern COMMA = Pattern.compile(",");
  8. private DecodeHintManager() {}
  10. /**
  11. * <p>Split a query string into a list of name-value pairs.</p>
  12. *
  13. * <p>This is an alternative to the {@link Uri#getQueryParameterNames()} and
  14. * {@link Uri#getQueryParameters(String)}, which are quirky and not suitable
  15. * for exist-only Uri parameters.</p>
  16. *
  17. * <p>This method ignores multiple parameters with the same name and returns the
  18. * first one only. This is technically incorrect, but should be acceptable due
  19. * to the method of processing Hints: no multiple values for a hint.</p>
  20. *
  21. * @param query query to split
  22. * @return name-value pairs
  23. */
  24. private static Map<String,String> splitQuery(String query) {
  25. Map<String,String> map = new HashMap<>();
  26. int pos = 0;
  27. while (pos < query.length()) {
  28. if (query.charAt(pos) == '&') {
  29. // Skip consecutive ampersand separators.
  30. pos ++;
  31. continue;
  32. }
  33. int amp = query.indexOf('&', pos);
  34. int equ = query.indexOf('=', pos);
  35. if (amp < 0) {
  36. // This is the last element in the query, no more ampersand elements.
  37. String name;
  38. String text;
  39. if (equ < 0) {
  40. // No equal sign
  41. name = query.substring(pos);
  42. name = name.replace('+', ' '); // Preemptively decode +
  43. name = Uri.decode(name);
  44. text = "";
  45. } else {
  46. // Split name and text.
  47. name = query.substring(pos, equ);
  48. name = name.replace('+', ' '); // Preemptively decode +
  49. name = Uri.decode(name);
  50. text = query.substring(equ + 1);
  51. text = text.replace('+', ' '); // Preemptively decode +
  52. text = Uri.decode(text);
  53. }
  54. if (!map.containsKey(name)) {
  55. map.put(name, text);
  56. }
  57. break;
  58. }
  59. if (equ < 0 || equ > amp) {
  60. // No equal sign until the &: this is a simple parameter with no value.
  61. String name = query.substring(pos, amp);
  62. name = name.replace('+', ' '); // Preemptively decode +
  63. name = Uri.decode(name);
  64. if (!map.containsKey(name)) {
  65. map.put(name, "");
  66. }
  67. pos = amp + 1;
  68. continue;
  69. }
  70. String name = query.substring(pos, equ);
  71. name = name.replace('+', ' '); // Preemptively decode +
  72. name = Uri.decode(name);
  73. String text = query.substring(equ+1, amp);
  74. text = text.replace('+', ' '); // Preemptively decode +
  75. text = Uri.decode(text);
  76. if (!map.containsKey(name)) {
  77. map.put(name, text);
  78. }
  79. pos = amp + 1;
  80. }
  81. return map;
  82. }
  84. static Map<DecodeHintType,?> parseDecodeHints(Uri inputUri) {
  85. String query = inputUri.getEncodedQuery();
  86. if (query == null || query.isEmpty()) {
  87. return null;
  88. }
  90. // Extract parameters
  91. Map<String, String> parameters = splitQuery(query);
  93. Map<DecodeHintType, Object> hints = new EnumMap<>(DecodeHintType.class);
  95. for (DecodeHintType hintType: DecodeHintType.values()) {
  97. if (hintType == DecodeHintType.CHARACTER_SET ||
  98. hintType == DecodeHintType.NEED_RESULT_POINT_CALLBACK ||
  99. hintType == DecodeHintType.POSSIBLE_FORMATS) {
  100. continue; // This hint is specified in another way
  101. }
  103. String parameterName = hintType.name();
  104. String parameterText = parameters.get(parameterName);
  105. if (parameterText == null) {
  106. continue;
  107. }
  108. if (hintType.getValueType().equals(Object.class)) {
  109. // This is an unspecified type of hint content. Use the value as is.
  110. // TODO: Can we make a different assumption on this?
  111. hints.put(hintType, parameterText);
  112. continue;
  113. }
  114. if (hintType.getValueType().equals(Void.class)) {
  115. // Void hints are just flags: use the constant specified by DecodeHintType
  116. hints.put(hintType, Boolean.TRUE);
  117. continue;
  118. }
  119. if (hintType.getValueType().equals(String.class)) {
  120. // A string hint: use the decoded value.
  121. hints.put(hintType, parameterText);
  122. continue;
  123. }
  124. if (hintType.getValueType().equals(Boolean.class)) {
  125. // A boolean hint: a few values for false, everything else is true.
  126. // An empty parameter is simply a flag-style parameter, assuming true
  127. if (parameterText.isEmpty()) {
  128. hints.put(hintType, Boolean.TRUE);
  129. } else if ("0".equals(parameterText) ||
  130. "false".equalsIgnoreCase(parameterText) ||
  131. "no".equalsIgnoreCase(parameterText)) {
  132. hints.put(hintType, Boolean.FALSE);
  133. } else {
  134. hints.put(hintType, Boolean.TRUE);
  135. }
  137. continue;
  138. }
  139. if (hintType.getValueType().equals(int[].class)) {
  140. // An integer array. Used to specify valid lengths.
  141. // Strip a trailing comma as in Java style array initialisers.
  142. if (!parameterText.isEmpty() && parameterText.charAt(parameterText.length() - 1) == ',') {
  143. parameterText = parameterText.substring(0, parameterText.length() - 1);
  144. }
  145. String[] values = COMMA.split(parameterText);
  146. int[] array = new int[values.length];
  147. for (int i = 0; i < values.length; i++) {
  148. try {
  149. array[i] = Integer.parseInt(values[i]);
  150. } catch (NumberFormatException ignored) {
  151. Log.w(TAG, "Skipping array of integers hint " + hintType + " due to invalid numeric value: '" + values[i] + '\'');
  152. array = null;
  153. break;
  154. }
  155. }
  156. if (array != null) {
  157. hints.put(hintType, array);
  158. }
  159. continue;
  160. }
  161. Log.w(TAG, "Unsupported hint type '" + hintType + "' of type " + hintType.getValueType());
  162. }
  164. Log.i(TAG, "Hints from the URI: " + hints);
  165. return hints;
  166. }
  168. static Map<DecodeHintType, Object> parseDecodeHints(Intent intent) {
  169. Bundle extras = intent.getExtras();
  170. if (extras == null || extras.isEmpty()) {
  171. return null;
  172. }
  173. Map<DecodeHintType,Object> hints = new EnumMap<>(DecodeHintType.class);
  175. for (DecodeHintType hintType: DecodeHintType.values()) {
  177. if (hintType == DecodeHintType.CHARACTER_SET ||
  178. hintType == DecodeHintType.NEED_RESULT_POINT_CALLBACK ||
  179. hintType == DecodeHintType.POSSIBLE_FORMATS) {
  180. continue; // This hint is specified in another way
  181. }
  183. String hintName = hintType.name();
  184. if (extras.containsKey(hintName)) {
  185. if (hintType.getValueType().equals(Void.class)) {
  186. // Void hints are just flags: use the constant specified by the DecodeHintType
  187. hints.put(hintType, Boolean.TRUE);
  188. } else {
  189. Object hintData = extras.get(hintName);
  190. if (hintType.getValueType().isInstance(hintData)) {
  191. hints.put(hintType, hintData);
  192. } else {
  193. Log.w(TAG, "Ignoring hint " + hintType + " because it is not assignable from " + hintData);
  194. }
  195. }
  196. }
  197. }
  199. Log.i(TAG, "Hints from the Intent: " + hints);
  200. return hints;
  201. }
  203. }
DecodeThread.java
  1. final class DecodeThread extends Thread {
  3. public static final String BARCODE_BITMAP = "barcode_bitmap";
  4. public static final String BARCODE_SCALED_FACTOR = "barcode_scaled_factor";
  6. private final CaptureActivity             activity;
  7. private final Map<DecodeHintType, Object> hints;
  8. private Handler                           handler;
  9. private final CountDownLatch              handlerInitLatch;
  11. public DecodeThread(CaptureActivity activity,
  12. Collection<BarcodeFormat> decodeFormats,
  13. String characterSet,
  14. ResultPointCallback resultPointCallback) {
  16. this.activity = activity;
  17. handlerInitLatch = new CountDownLatch(1);
  19. hints = new EnumMap<>(DecodeHintType.class);
  21. // The prefs can't change while the thread is running, so pick them up once here.
  22. if (decodeFormats == null || decodeFormats.isEmpty()) {
  23. //            SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(activity);
  24. decodeFormats = EnumSet.noneOf(BarcodeFormat.class);
  25. /*if (prefs.getBoolean(PreferencesActivity.KEY_DECODE_1D_PRODUCT, true)) {
  26. decodeFormats.addAll(DecodeFormatManager.PRODUCT_FORMATS);
  27. }
  28. if (prefs.getBoolean(PreferencesActivity.KEY_DECODE_1D_INDUSTRIAL, true)) {
  29. decodeFormats.addAll(DecodeFormatManager.INDUSTRIAL_FORMATS);
  30. }*/
  31. //            if (prefs.getBoolean(PreferencesActivity.KEY_DECODE_QR, true)) {
  32. decodeFormats.addAll(DecodeFormatManager.QR_CODE_FORMATS);
  33. //            }
  34. /* if (prefs.getBoolean(PreferencesActivity.KEY_DECODE_DATA_MATRIX, true)) {
  35. decodeFormats.addAll(DecodeFormatManager.DATA_MATRIX_FORMATS);
  36. }
  37. if (prefs.getBoolean(PreferencesActivity.KEY_DECODE_AZTEC, false)) {
  38. decodeFormats.addAll(DecodeFormatManager.AZTEC_FORMATS);
  39. }
  40. if (prefs.getBoolean(PreferencesActivity.KEY_DECODE_PDF417, false)) {
  41. decodeFormats.addAll(DecodeFormatManager.PDF417_FORMATS);
  42. }*/
  43. }
  44. hints.put(DecodeHintType.POSSIBLE_FORMATS, DecodeFormatManager.QR_CODE_FORMATS);
  46. if (characterSet != null) {
  47. hints.put(DecodeHintType.CHARACTER_SET, characterSet);
  48. }
  49. hints.put(DecodeHintType.NEED_RESULT_POINT_CALLBACK, resultPointCallback);
  50. Log.i("DecodeThread", "Hints: " + hints);
  51. }
  53. Handler getHandler() {
  54. try {
  55. handlerInitLatch.await();
  56. } catch (InterruptedException ie) {
  57. // continue?
  58. }
  59. return handler;
  60. }
  62. @Override
  63. public void run() {
  64. Looper.prepare();
  65. handler = new DecodeHandler(activity, hints);
  66. handlerInitLatch.countDown();
  67. Looper.loop();
  68. }
  70. }
ImageUtil.java
  1. public class ImageUtil {
  3. @TargetApi(19)
  4. public static String getImageAbsolutePath(Context context, Uri imageUri) {
  5. if (context == null || imageUri == null)
  6. return null;
  7. if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.KITKAT && DocumentsContract.isDocumentUri(context, imageUri)) {
  8. if (isExternalStorageDocument(imageUri)) {
  9. String docId = DocumentsContract.getDocumentId(imageUri);
  10. String[] split = docId.split(":");
  11. String type = split[0];
  12. if ("primary".equalsIgnoreCase(type)) {
  13. return Environment.getExternalStorageDirectory() + "/" + split[1];
  14. }
  15. } else if (isDownloadsDocument(imageUri)) {
  16. String id = DocumentsContract.getDocumentId(imageUri);
  17. Uri contentUri = ContentUris.withAppendedId(Uri.parse("content://downloads/public_downloads"), Long.valueOf(id));
  18. return getDataColumn(context, contentUri, null, null);
  19. } else if (isMediaDocument(imageUri)) {
  20. String docId = DocumentsContract.getDocumentId(imageUri);
  21. String[] split = docId.split(":");
  22. String type = split[0];
  23. Uri contentUri = null;
  24. if ("image".equals(type)) {
  25. contentUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
  26. } else if ("video".equals(type)) {
  27. contentUri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
  28. } else if ("audio".equals(type)) {
  29. contentUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
  30. }
  31. String selection = MediaStore.Images.Media._ID + "=?";
  32. String[] selectionArgs = new String[]{split[1]};
  33. return getDataColumn(context, contentUri, selection, selectionArgs);
  34. }
  35. } // MediaStore (and general)
  36. else if ("content".equalsIgnoreCase(imageUri.getScheme())) {
  37. // Return the remote address
  38. if (isGooglePhotosUri(imageUri))
  39. return imageUri.getLastPathSegment();
  40. return getDataColumn(context, imageUri, null, null);
  41. }
  42. // File
  43. else if ("file".equalsIgnoreCase(imageUri.getScheme())) {
  44. return imageUri.getPath();
  45. }
  46. return null;
  47. }
  49. public static String getDataColumn(Context context, Uri uri, String selection, String[] selectionArgs) {
  50. Cursor cursor = null;
  51. String column = MediaStore.Images.Media.DATA;
  52. String[] projection = {column};
  53. try {
  54. cursor = context.getContentResolver().query(uri, projection, selection, selectionArgs, null);
  55. if (cursor != null && cursor.moveToFirst()) {
  56. int index = cursor.getColumnIndexOrThrow(column);
  57. return cursor.getString(index);
  58. }
  59. } finally {
  60. if (cursor != null)
  61. cursor.close();
  62. }
  63. return null;
  64. }
  66. /**
  67. * @param uri The Uri to check.
  68. * @return Whether the Uri authority is ExternalStorageProvider.
  69. */
  70. public static boolean isExternalStorageDocument(Uri uri) {
  71. return "com.android.externalstorage.documents".equals(uri.getAuthority());
  72. }
  74. /**
  75. * @param uri The Uri to check.
  76. * @return Whether the Uri authority is DownloadsProvider.
  77. */
  78. public static boolean isDownloadsDocument(Uri uri) {
  79. return "com.android.providers.downloads.documents".equals(uri.getAuthority());
  80. }
  82. /**
  83. * @param uri The Uri to check.
  84. * @return Whether the Uri authority is MediaProvider.
  85. */
  86. public static boolean isMediaDocument(Uri uri) {
  87. return "com.android.providers.media.documents".equals(uri.getAuthority());
  88. }
  90. /**
  91. * @param uri The Uri to check.
  92. * @return Whether the Uri authority is Google Photos.
  93. */
  94. public static boolean isGooglePhotosUri(Uri uri) {
  95. return "com.google.android.apps.photos.content".equals(uri.getAuthority());
  96. }
  97. }
InactivityTimer.java
  1. public final class InactivityTimer {
  3. private static final String TAG = InactivityTimer.class.getSimpleName();
  5. private static final long INACTIVITY_DELAY_MS = 5 * 60 * 1000L;
  7. private final Activity activity;
  8. private final BroadcastReceiver powerStatusReceiver;
  9. private boolean registered;
  10. private AsyncTask<Object, Object, Object> inactivityTask;
  12. public InactivityTimer(Activity activity) {
  13. this.activity = activity;
  14. powerStatusReceiver = new PowerStatusReceiver();
  15. registered = false;
  16. onActivity();
  17. }
  19. public synchronized void onActivity() {
  20. cancel();
  21. inactivityTask = new InactivityAsyncTask();
  22. inactivityTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
  23. }
  25. public synchronized void onPause() {
  26. cancel();
  27. if (registered) {
  28. activity.unregisterReceiver(powerStatusReceiver);
  29. registered = false;
  30. } else {
  31. Log.w(TAG, "PowerStatusReceiver was never registered?");
  32. }
  33. }
  35. public synchronized void onResume() {
  36. if (registered) {
  37. Log.w(TAG, "PowerStatusReceiver was already registered?");
  38. } else {
  39. activity.registerReceiver(powerStatusReceiver, new IntentFilter(Intent.ACTION_BATTERY_CHANGED));
  40. registered = true;
  41. }
  42. onActivity();
  43. }
  45. private synchronized void cancel() {
  46. AsyncTask<?, ?, ?> task = inactivityTask;
  47. if (task != null) {
  48. task.cancel(true);
  49. inactivityTask = null;
  50. }
  51. }
  53. public void shutdown() {
  54. cancel();
  55. }
  57. private final class PowerStatusReceiver extends BroadcastReceiver {
  58. @Override
  59. public void onReceive(Context context, Intent intent) {
  60. if (Intent.ACTION_BATTERY_CHANGED.equals(intent.getAction())) {
  61. // 0 indicates that we're on battery
  62. boolean onBatteryNow = intent.getIntExtra(BatteryManager.EXTRA_PLUGGED, -1) <= 0;
  63. if (onBatteryNow) {
  64. InactivityTimer.this.onActivity();
  65. } else {
  66. InactivityTimer.this.cancel();
  67. }
  68. }
  69. }
  70. }
  72. private final class InactivityAsyncTask extends AsyncTask<Object, Object, Object> {
  73. @Override
  74. protected Object doInBackground(Object... objects) {
  75. try {
  76. Thread.sleep(INACTIVITY_DELAY_MS);
  77. Log.i(TAG, "Finishing activity due to inactivity");
  78. activity.finish();
  79. } catch (InterruptedException e) {
  80. // continue without killing
  81. }
  82. return null;
  83. }
  84. }
  86. }
Intents.java
  1. public final class Intents {
  2. private Intents() {
  3. }
  5. public static final class Scan {
  6. /**
  7. * Send this intent to open the Barcodes app in scanning mode, find a barcode, and return
  8. * the results.
  9. */
  10. public static final String ACTION = "com.google.zxing.client.android.SCAN";
  12. /**
  13. * By default, sending this will decode all barcodes that we understand. However it
  14. * may be useful to limit scanning to certain formats. Use
  15. * {@link android.content.Intent#putExtra(String, String)} with one of the values below.
  16. *
  17. * Setting this is effectively shorthand for setting explicit formats with {@link #FORMATS}.
  18. * It is overridden by that setting.
  19. */
  20. public static final String MODE = "SCAN_MODE";
  22. /**
  23. * Decode only UPC and EAN barcodes. This is the right choice for shopping apps which get
  24. * prices, reviews, etc. for products.
  25. */
  26. public static final String PRODUCT_MODE = "PRODUCT_MODE";
  28. /**
  29. * Decode only 1D barcodes.
  30. */
  31. public static final String ONE_D_MODE = "ONE_D_MODE";
  33. /**
  34. * Decode only QR codes.
  35. */
  36. public static final String QR_CODE_MODE = "QR_CODE_MODE";
  38. /**
  39. * Decode only Data Matrix codes.
  40. */
  41. public static final String DATA_MATRIX_MODE = "DATA_MATRIX_MODE";
  43. /**
  44. * Decode only Aztec.
  45. */
  46. public static final String AZTEC_MODE = "AZTEC_MODE";
  48. /**
  49. * Decode only PDF417.
  50. */
  51. public static final String PDF417_MODE = "PDF417_MODE";
  53. /**
  54. * Comma-separated list of formats to scan for. The values must match the names of
  55. * {@link com.google.zxing.BarcodeFormat}s, e.g. {@link com.google.zxing.BarcodeFormat#EAN_13}.
  56. * Example: "EAN_13,EAN_8,QR_CODE". This overrides {@link #MODE}.
  57. */
  58. public static final String FORMATS = "SCAN_FORMATS";
  60. /**
  61. * Optional parameter to specify the id of the camera from which to recognize barcodes.
  62. * Overrides the default camera that would otherwise would have been selected.
  63. * If provided, should be an int.
  64. */
  65. public static final String CAMERA_ID = "SCAN_CAMERA_ID";
  67. /**
  68. * @see com.google.zxing.DecodeHintType#CHARACTER_SET
  69. */
  70. public static final String CHARACTER_SET = "CHARACTER_SET";
  72. /**
  73. * Optional parameters to specify the width and height of the scanning rectangle in pixels.
  74. * The app will try to honor these, but will clamp them to the size of the preview frame.
  75. * You should specify both or neither, and pass the size as an int.
  76. */
  77. public static final String WIDTH = "SCAN_WIDTH";
  78. public static final String HEIGHT = "SCAN_HEIGHT";
  80. /**
  81. * Desired duration in milliseconds for which to pause after a successful scan before
  82. * returning to the calling intent. Specified as a long, not an integer!
  83. * For example: 1000L, not 1000.
  84. */
  85. public static final String RESULT_DISPLAY_DURATION_MS = "RESULT_DISPLAY_DURATION_MS";
  87. /**
  88. * Prompt to show on-screen when scanning by intent. Specified as a {@link String}.
  89. */
  90. public static final String PROMPT_MESSAGE = "PROMPT_MESSAGE";
  92. /**
  93. * If a barcode is found, Barcodes returns {@link android.app.Activity#RESULT_OK} to
  94. * {@link android.app.Activity#onActivityResult(int, int, android.content.Intent)}
  95. * of the app which requested the scan via
  96. * {@link android.app.Activity#startActivityForResult(android.content.Intent, int)}
  97. * The barcodes contents can be retrieved with
  98. * {@link android.content.Intent#getStringExtra(String)}.
  99. * If the user presses Back, the result code will be {@link android.app.Activity#RESULT_CANCELED}.
  100. */
  101. public static final String RESULT = "SCAN_RESULT";
  103. /**
  104. * Call {@link android.content.Intent#getStringExtra(String)} with {@link #RESULT_FORMAT}
  105. * to determine which barcode format was found.
  106. * See {@link com.google.zxing.BarcodeFormat} for possible values.
  107. */
  108. public static final String RESULT_FORMAT = "SCAN_RESULT_FORMAT";
  110. /**
  111. * Call {@link android.content.Intent#getStringExtra(String)} with {@link #RESULT_UPC_EAN_EXTENSION}
  112. * to return the content of any UPC extension barcode that was also found. Only applicable
  113. * to {@link com.google.zxing.BarcodeFormat#UPC_A} and {@link com.google.zxing.BarcodeFormat#EAN_13}
  114. * formats.
  115. */
  116. public static final String RESULT_UPC_EAN_EXTENSION = "SCAN_RESULT_UPC_EAN_EXTENSION";
  118. /**
  119. * Call {@link android.content.Intent#getByteArrayExtra(String)} with {@link #RESULT_BYTES}
  120. * to get a {@code byte[]} of raw bytes in the barcode, if available.
  121. */
  122. public static final String RESULT_BYTES = "SCAN_RESULT_BYTES";
  124. /**
  125. * Key for the value of {@link com.google.zxing.ResultMetadataType#ORIENTATION}, if available.
  126. * Call {@link android.content.Intent#getIntArrayExtra(String)} with {@link #RESULT_ORIENTATION}.
  127. */
  128. public static final String RESULT_ORIENTATION = "SCAN_RESULT_ORIENTATION";
  130. /**
  131. * Key for the value of {@link com.google.zxing.ResultMetadataType#ERROR_CORRECTION_LEVEL}, if available.
  132. * Call {@link android.content.Intent#getStringExtra(String)} with {@link #RESULT_ERROR_CORRECTION_LEVEL}.
  133. */
  134. public static final String RESULT_ERROR_CORRECTION_LEVEL = "SCAN_RESULT_ERROR_CORRECTION_LEVEL";
  136. /**
  137. * Prefix for keys that map to the values of {@link com.google.zxing.ResultMetadataType#BYTE_SEGMENTS},
  138. * if available. The actual values will be set under a series of keys formed by adding 0, 1, 2, ...
  139. * to this prefix. So the first byte segment is under key "SCAN_RESULT_BYTE_SEGMENTS_0" for example.
  140. * Call {@link android.content.Intent#getByteArrayExtra(String)} with these keys.
  141. */
  142. public static final String RESULT_BYTE_SEGMENTS_PREFIX = "SCAN_RESULT_BYTE_SEGMENTS_";
  144. /**
  145. * Setting this to false will not save scanned codes in the history. Specified as a {@code boolean}.
  146. */
  147. public static final String SAVE_HISTORY = "SAVE_HISTORY";
  149. private Scan() {
  150. }
  151. }
  153. public static final class History {
  155. public static final String ITEM_NUMBER = "ITEM_NUMBER";
  157. private History() {
  158. }
  159. }
  161. public static final class Encode {
  162. /**
  163. * Send this intent to encode a piece of data as a QR code and display it full screen, so
  164. * that another person can scan the barcode from your screen.
  165. */
  166. public static final String ACTION = "com.google.zxing.client.android.ENCODE";
  168. /**
  169. * The data to encode. Use {@link android.content.Intent#putExtra(String, String)} or
  170. * {@link android.content.Intent#putExtra(String, android.os.Bundle)},
  171. * depending on the type and format specified. Non-QR Code formats should
  172. * just use a String here. For QR Code, see Contents for details.
  173. */
  174. public static final String DATA = "ENCODE_DATA";
  176. /**
  177. * The type of data being supplied if the format is QR Code. Use
  178. * {@link android.content.Intent#putExtra(String, String)} with one of {@link Contents.Type}.
  179. */
  180. public static final String TYPE = "ENCODE_TYPE";
  182. /**
  183. * The barcode format to be displayed. If this isn't specified or is blank,
  184. * it defaults to QR Code. Use {@link android.content.Intent#putExtra(String, String)}, where
  185. * format is one of {@link com.google.zxing.BarcodeFormat}.
  186. */
  187. public static final String FORMAT = "ENCODE_FORMAT";
  189. /**
  190. * Normally the contents of the barcode are displayed to the user in a TextView. Setting this
  191. * boolean to false will hide that TextView, showing only the encode barcode.
  192. */
  193. public static final String SHOW_CONTENTS = "ENCODE_SHOW_CONTENTS";
  195. private Encode() {
  196. }
  197. }
  199. public static final class SearchBookContents {
  200. /**
  201. * Use Google Book Search to search the contents of the book provided.
  202. */
  203. public static final String ACTION = "com.google.zxing.client.android.SEARCH_BOOK_CONTENTS";
  205. /**
  206. * The book to search, identified by ISBN number.
  207. */
  208. public static final String ISBN = "ISBN";
  210. /**
  211. * An optional field which is the text to search for.
  212. */
  213. public static final String QUERY = "QUERY";
  215. private SearchBookContents() {
  216. }
  217. }
  219. public static final class WifiConnect {
  220. /**
  221. * Internal intent used to trigger connection to a wi-fi network.
  222. */
  223. public static final String ACTION = "com.google.zxing.client.android.WIFI_CONNECT";
  225. /**
  226. * The network to connect to, all the configuration provided here.
  227. */
  228. public static final String SSID = "SSID";
  230. /**
  231. * The network to connect to, all the configuration provided here.
  232. */
  233. public static final String TYPE = "TYPE";
  235. /**
  236. * The network to connect to, all the configuration provided here.
  237. */
  238. public static final String PASSWORD = "PASSWORD";
  240. private WifiConnect() {
  241. }
  242. }
  244. public static final class Share {
  245. /**
  246. * Give the user a choice of items to encode as a barcode, then render it as a QR Code and
  247. * display onscreen for a friend to scan with their phone.
  248. */
  249. public static final String ACTION = "com.google.zxing.client.android.SHARE";
  251. private Share() {
  252. }
  253. }
  254. }
ViewfinderResultPointCallback.java
  1. final class ViewfinderResultPointCallback implements ResultPointCallback {
  3. private final ViewfinderView viewfinderView;
  5. ViewfinderResultPointCallback(ViewfinderView viewfinderView) {
  6. this.viewfinderView = viewfinderView;
  7. }
  9. @Override
  10. public void foundPossibleResultPoint(ResultPoint point) {
  11. viewfinderView.addPossibleResultPoint(point);
  12. }
  14. }
CodeCreator.java
  1. public class CodeCreator {
  3. /*logo*/
  4. private static Bitmap logoBitmap;
  6. /*生成二維碼*/
  7. public static Bitmap createQRCode(String content, int w, int h,Bitmap logo) throws WriterException {
  10. if (TextUtils.isEmpty(content)) {
  11. return null;
  12. }
  13. /*偏移量*/
  14. int offsetX = w / 2;
  15. int offsetY = h / 2;
  17. /*生成logo*/
  18. if (logo!=null){
  19. Matrix matrix = new Matrix();
  20. float scaleFactor = Math.min(w * 1.0f / 5 / logo.getWidth(), h * 1.0f / 5 /logo.getHeight());
  21. matrix.postScale(scaleFactor,scaleFactor);
  22. logoBitmap= Bitmap.createBitmap(logo, 0, 0, logo.getWidth(),   logo.getHeight(), matrix, true);
  23. }
  26. /*如果log不為null,重新計(jì)算偏移量*/
  27. int logoW = 0;
  28. int logoH = 0;
  29. if (logoBitmap != null) {
  30. logoW = logoBitmap.getWidth();
  31. logoH = logoBitmap.getHeight();
  32. offsetX = (w - logoW) / 2;
  33. offsetY = (h - logoH) / 2;
  34. }
  36. /*指定為UTF-8*/
  37. Hashtable<EncodeHintType, Object> hints = new Hashtable<EncodeHintType, Object>();
  38. hints.put(EncodeHintType.CHARACTER_SET, "utf-8");
  39. //容錯(cuò)級(jí)別
  40. hints.put(EncodeHintType.ERROR_CORRECTION, ErrorCorrectionLevel.H);
  41. //設(shè)置空白邊距的寬度
  42. hints.put(EncodeHintType.MARGIN, 0);
  43. // 生成二維矩陣,編碼時(shí)指定大小,不要生成了圖片以后再進(jìn)行縮放,這樣會(huì)模糊導(dǎo)致識(shí)別失敗
  44. BitMatrix matrix = new MultiFormatWriter().encode(content,
  45. BarcodeFormat.QR_CODE, w, h, hints);
  47. // 二維矩陣轉(zhuǎn)為一維像素?cái)?shù)組,也就是一直橫著排了
  48. int[] pixels = new int[w * h];
  49. for (int y = 0; y < h; y++) {
  50. for (int x = 0; x < w; x++) {
  51. if(x >= offsetX && x < offsetX + logoW && y>= offsetY && y < offsetY + logoH){
  52. int pixel = logoBitmap.getPixel(x-offsetX,y-offsetY);
  53. if(pixel == 0){
  54. if(matrix.get(x, y)){
  55. pixel = 0xff000000;
  56. }else{
  57. pixel = 0xffffffff;
  58. }
  59. }
  60. pixels[y * w + x] = pixel;
  61. }else{
  62. if (matrix.get(x, y)) {
  63. pixels[y * w + x] = 0xff000000;
  64. } else {
  65. pixels[y * w + x] = 0xffffffff;
  66. }
  67. }
  68. }
  69. }
  71. Bitmap bitmap = Bitmap.createBitmap(w, h,
  72. Bitmap.Config.ARGB_8888);
  73. bitmap.setPixels(pixels, 0, w, 0, 0, w, h);
  74. return bitmap;
  75. }
  77. }
QRCodeEncoder.java
  1. public final class QRCodeEncoder {
  3. private static final String TAG = QRCodeEncoder.class.getSimpleName();
  5. private static final int WHITE = 0xFFFFFFFF;
  6. private static final int BLACK = 0xFF000000;
  9. public static Bitmap encodeAsBitmap(String contents, int dimension) throws WriterException {
  11. String contentsToEncode = contents;
  12. if (contentsToEncode == null) {
  13. return null;
  14. }
  15. Map<EncodeHintType, Object> hints = null;
  16. String encoding = guessAppropriateEncoding(contentsToEncode);
  17. if (encoding != null) {
  18. hints = new EnumMap<>(EncodeHintType.class);
  19. hints.put(EncodeHintType.CHARACTER_SET, encoding);
  20. }
  21. BitMatrix result;
  22. try {
  23. result = new MultiFormatWriter().encode(contentsToEncode, BarcodeFormat.QR_CODE, dimension, dimension, hints);
  24. } catch (IllegalArgumentException iae) {
  25. // Unsupported format
  26. return null;
  27. }
  28. int width = result.getWidth();
  29. int height = result.getHeight();
  30. int[] pixels = new int[width * height];
  31. for (int y = 0; y < height; y++) {
  32. int offset = y * width;
  33. for (int x = 0; x < width; x++) {
  34. pixels[offset + x] = result.get(x, y) ? BLACK : WHITE;
  35. }
  36. }
  38. Bitmap bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
  39. bitmap.setPixels(pixels, 0, width, 0, 0, width, height);
  40. return bitmap;
  41. }
  43. private static String guessAppropriateEncoding(CharSequence contents) {
  44. // Very crude at the moment
  45. for (int i = 0; i < contents.length(); i++) {
  46. if (contents.charAt(i) > 0xFF) {
  47. return "UTF-8";
  48. }
  49. }
  50. return null;
  51. }
  53. }
ViewfinderResultPointCallback.java
  1. public final class ViewfinderResultPointCallback implements ResultPointCallback {
  3. private final ViewfinderView viewfinderView;
  5. public ViewfinderResultPointCallback(ViewfinderView viewfinderView) {
  6. this.viewfinderView = viewfinderView;
  7. }
  9. @Override
  10. public void foundPossibleResultPoint(ResultPoint point) {
  11. viewfinderView.addPossibleResultPoint(point);
  12. }
  14. }
ViewfinderView.java
  1. public final class ViewfinderView extends View{
  2. private static final long ANIMATION_DELAY = 10;
  3. private static final int CORNER_RECT_HEIGHT = 40;
  4. private static final int CORNER_RECT_WIDTH = 8;
  5. private static final int OPAQUE = 255;
  6. private static final int[] SCANNER_ALPHA = new int[]{0, 64, 128, 192, OPAQUE, 192, 128, 64};
  7. private static final int SCANNER_LINE_HEIGHT = 10;
  8. private static final int SCANNER_LINE_MOVE_DISTANCE = 5;
  9. public static int scannerEnd = 0;
  10. public static int scannerStart = 0;
  11. private       CameraManager           cameraManager;
  12. private final int                     cornerColor;
  13. private final int                     frameColor;
  14. private       String                  labelText;
  15. private       int                     labelTextColor;
  16. private       float                   labelTextSize;
  17. private final int                     laserColor;
  18. private       Collection<ResultPoint> lastPossibleResultPoints;
  19. private final IMResUtil               mImResUtil;
  20. private final int                     maskColor;
  21. private final Paint paint = new Paint();
  22. private Collection<ResultPoint> possibleResultPoints;
  23. private Bitmap                  resultBitmap;
  24. private final int               resultColor;
  25. private final int               resultPointColor;
  26. private int                     scannerAlpha;
  28. public ViewfinderView(Context context, AttributeSet attrs) {
  29. super(context, attrs);
  30. this.mImResUtil = new IMResUtil(context);
  31. TypedArray array = context.obtainStyledAttributes(attrs, this.mImResUtil.getStyleableArray("ViewfinderView"));
  32. this.laserColor = array.getColor(this.mImResUtil.getStyleable("ViewfinderView_device_qrcode_laser_color"), 65280);
  33. this.cornerColor = array.getColor(this.mImResUtil.getStyleable("ViewfinderView_device_qrcode_corner_color"), 65280);
  34. this.frameColor = array.getColor(this.mImResUtil.getStyleable("ViewfinderView_device_qrcode_frame_color"), 16777215);
  35. this.resultPointColor = array.getColor(this.mImResUtil.getStyleable("ViewfinderView_device_qrcode_result_point_color"), -1056964864);
  36. this.maskColor = array.getColor(this.mImResUtil.getStyleable("ViewfinderView_device_qrcode_mask_color"), 1610612736);
  37. this.resultColor = array.getColor(this.mImResUtil.getStyleable("ViewfinderView_device_qrcode_result_color"), -1342177280);
  38. this.labelTextColor = array.getColor(this.mImResUtil.getStyleable("ViewfinderView_device_qrcode_label_text_color"), -1862270977);
  39. this.labelText = array.getString(this.mImResUtil.getStyleable("ViewfinderView_device_qrcode_label_text"));
  40. this.labelTextSize = (float) array.getDimensionPixelSize(this.mImResUtil.getStyleable("ViewfinderView_device_qrcode_label_text_size"), (int) TypedValue.applyDimension(2, 16.0f, getResources().getDisplayMetrics()));
  41. this.paint.setAntiAlias(true);
  42. this.scannerAlpha = 0;
  43. this.possibleResultPoints = new HashSet(5);
  44. }
  46. public void setCameraManager(CameraManager cameraManager) {
  47. this.cameraManager = cameraManager;
  48. }
  50. public void onDraw(Canvas canvas) {
  51. Rect frame = this.cameraManager.getFramingRect();
  52. if (frame != null) {
  53. if (scannerStart == 0 || scannerEnd == 0) {
  54. scannerStart = frame.top;
  55. scannerEnd = frame.bottom;
  56. }
  57. drawExterior(canvas, frame, canvas.getWidth(), canvas.getHeight());
  58. if (this.resultBitmap != null) {
  59. this.paint.setAlpha(OPAQUE);
  60. canvas.drawBitmap(this.resultBitmap, (float) frame.left, (float) frame.top, this.paint);
  61. return;
  62. }
  63. drawFrame(canvas, frame);
  64. drawCorner(canvas, frame);
  65. drawLaserScanner(canvas, frame);
  66. drawTextInfo(canvas, frame);
  67. Collection<ResultPoint> currentPossible = this.possibleResultPoints;
  68. Collection<ResultPoint> currentLast = this.lastPossibleResultPoints;
  69. if (currentPossible.isEmpty()) {
  70. this.lastPossibleResultPoints = null;
  71. } else {
  72. this.possibleResultPoints = new HashSet(5);
  73. this.lastPossibleResultPoints = currentPossible;
  74. this.paint.setAlpha(OPAQUE);
  75. this.paint.setColor(this.resultPointColor);
  76. for (ResultPoint point : currentPossible) {
  77. canvas.drawCircle(((float) frame.left) + point.getX(), ((float) frame.top) + point.getY(), 6.0f, this.paint);
  78. }
  79. }
  80. if (currentLast != null) {
  81. this.paint.setAlpha(127);
  82. this.paint.setColor(this.resultPointColor);
  83. for (ResultPoint point2 : currentLast) {
  84. canvas.drawCircle(((float) frame.left) + point2.getX(), ((float) frame.top) + point2.getY(), 3.0f, this.paint);
  85. }
  86. }
  87. postInvalidateDelayed(ANIMATION_DELAY, frame.left, frame.top, frame.right, frame.bottom);
  88. }
  89. }
  91. private void drawTextInfo(Canvas canvas, Rect frame) {
  92. this.paint.setColor(this.labelTextColor);
  93. this.paint.setTextSize(TypedValue.applyDimension(2, this.labelTextSize, getResources().getDisplayMetrics()));
  94. this.paint.setTextAlign(Align.CENTER);
  96. }
  98. private void drawCorner(Canvas canvas, Rect frame) {
  99. this.paint.setColor(this.cornerColor);
  100. canvas.drawRect((float) frame.left, (float) frame.top, (float) (frame.left + CORNER_RECT_WIDTH), (float) (frame.top + CORNER_RECT_HEIGHT), this.paint);
  101. canvas.drawRect((float) frame.left, (float) frame.top, (float) (frame.left + CORNER_RECT_HEIGHT), (float) (frame.top + CORNER_RECT_WIDTH), this.paint);
  102. canvas.drawRect((float) (frame.right - 8), (float) frame.top, (float) frame.right, (float) (frame.top + CORNER_RECT_HEIGHT), this.paint);
  103. canvas.drawRect((float) (frame.right - 40), (float) frame.top, (float) frame.right, (float) (frame.top + CORNER_RECT_WIDTH), this.paint);
  104. canvas.drawRect((float) frame.left, (float) (frame.bottom - 8), (float) (frame.left + CORNER_RECT_HEIGHT), (float) frame.bottom, this.paint);
  105. canvas.drawRect((float) frame.left, (float) (frame.bottom - 40), (float) (frame.left + CORNER_RECT_WIDTH), (float) frame.bottom, this.paint);
  106. canvas.drawRect((float) (frame.right - 8), (float) (frame.bottom - 40), (float) frame.right, (float) frame.bottom, this.paint);
  107. canvas.drawRect((float) (frame.right - 40), (float) (frame.bottom - 8), (float) frame.right, (float) frame.bottom, this.paint);
  108. }
  110. private void drawLaserScanner(Canvas canvas, Rect frame) {
  111. this.paint.setColor(this.laserColor);
  112. LinearGradient linearGradient = new LinearGradient((float) frame.left, (float) scannerStart, (float) frame.left, (float) (scannerStart + 10), shadeColor(this.laserColor), this.laserColor, TileMode.MIRROR);
  113. RadialGradient radialGradient = new RadialGradient((float) (frame.left + (frame.width() / 2)), (float) (scannerStart + 5), 360.0f, this.laserColor, shadeColor(this.laserColor), TileMode.MIRROR);
  114. SweepGradient sweepGradient = new SweepGradient((float) (frame.left + (frame.width() / 2)), (float) (scannerStart + 10), shadeColor(this.laserColor), this.laserColor);
  115. ComposeShader composeShader = new ComposeShader(radialGradient, linearGradient, Mode.ADD);
  116. this.paint.setShader(radialGradient);
  117. if (scannerStart <= scannerEnd) {
  118. canvas.drawOval(new RectF((float) (frame.left + 20), (float) scannerStart, (float) (frame.right - 20), (float) (scannerStart + 10)), this.paint);
  119. scannerStart += 5;
  120. } else {
  121. scannerStart = frame.top;
  122. }
  123. this.paint.setShader(null);
  124. }
  126. public int shadeColor(int color) {
  127. return Integer.valueOf("20" + Integer.toHexString(color).substring(2), 16).intValue();
  128. }
  130. private void drawFrame(Canvas canvas, Rect frame) {
  131. this.paint.setColor(this.frameColor);
  132. canvas.drawRect((float) frame.left, (float) frame.top, (float) (frame.right + 1), (float) (frame.top + 2), this.paint);
  133. canvas.drawRect((float) frame.left, (float) (frame.top + 2), (float) (frame.left + 2), (float) (frame.bottom - 1), this.paint);
  134. canvas.drawRect((float) (frame.right - 1), (float) frame.top, (float) (frame.right + 1), (float) (frame.bottom - 1), this.paint);
  135. canvas.drawRect((float) frame.left, (float) (frame.bottom - 1), (float) (frame.right + 1), (float) (frame.bottom + 1), this.paint);
  136. }
  138. private void drawExterior(Canvas canvas, Rect frame, int width, int height) {
  139. this.paint.setColor(this.resultBitmap != null ? this.resultColor : this.maskColor);
  140. canvas.drawRect(0.0f, 0.0f, (float) width, (float) frame.top, this.paint);
  141. canvas.drawRect(0.0f, (float) frame.top, (float) frame.left, (float) (frame.bottom + 1), this.paint);
  142. canvas.drawRect((float) (frame.right + 1), (float) frame.top, (float) width, (float) (frame.bottom + 1), this.paint);
  143. canvas.drawRect(0.0f, (float) (frame.bottom + 1), (float) width, (float) height, this.paint);
  144. }
  146. public void drawViewfinder() {
  147. this.resultBitmap = null;
  148. invalidate();
  149. }
  151. public void drawResultBitmap(Bitmap barcode) {
  152. this.resultBitmap = barcode;
  153. invalidate();
  154. }
  156. public void addPossibleResultPoint(ResultPoint point) {
  157. this.possibleResultPoints.add(point);
  158. }
  160. public void setLabelText(String labelText) {
  161. this.labelText = labelText;
  162. }
  164. public void setLabelTextColor(int labelTextColor) {
  165. this.labelTextColor = labelTextColor;
  166. }
  168. public void setLabelTextSize(float labelTextSize) {
  169. this.labelTextSize = labelTextSize;
  170. }
  171. }
FileUtil.java
  1. public class FileUtil {
  3. private static String TAG = "FileUtil";
  5. public static String randomFileName(String ext) {
  6. return Long.toString(System.currentTimeMillis()) + ext;
  7. }
  9. public static boolean deleteFile(String name) {
  10. File file = new File(name);
  11. if (file.exists()) {
  12. return file.delete();
  13. }
  14. return false;
  15. }
  17. @SuppressWarnings("deprecation")
  18. public static String rotateAndSaveBitmap(File file, int outW, int outH, String outPath, Bitmap.CompressFormat format, int quality) {
  20. int originW;
  21. int originH;
  22. int orientation = ExifInterface.ORIENTATION_NORMAL;
  24. try {
  25. ExifInterface exif = new ExifInterface(file.getAbsolutePath());
  26. orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL);
  27. int w = exif.getAttributeInt(ExifInterface.TAG_IMAGE_WIDTH, 0);
  28. int h = exif.getAttributeInt(ExifInterface.TAG_IMAGE_LENGTH, 0);
  30. switch (orientation) {
  31. case ExifInterface.ORIENTATION_UNDEFINED:
  32. return null;
  33. case ExifInterface.ORIENTATION_ROTATE_90:
  34. case ExifInterface.ORIENTATION_ROTATE_270:
  35. originW = h;
  36. originH = w;
  37. break;
  38. default:
  39. originW = w;
  40. originH = h;
  41. break;
  42. }
  44. } catch (Exception e) {
  45. return null;
  46. }
  48. // boost decode bitmap performance
  49. int sampleSize;
  50. if (outW <= 0 && outH <= 0) {
  51. sampleSize = 1;
  52. outW = originW;
  53. outH = originH;
  54. } else if (outW <= 0 || outH <= 0) {
  55. if (outW <= 0) {
  56. sampleSize = originH / outH;
  57. outW = (int) (originW * (outH / (float) originH));
  58. } else {
  59. sampleSize = originW / outW;
  60. outH = (int) (originH * (outW / (float) originW));
  61. }
  62. } else {
  63. sampleSize = Math.min(originW / outW, originH / outH);
  64. }
  66. BitmapFactory.Options bmOptions = new BitmapFactory.Options();
  67. bmOptions.inJustDecodeBounds = false;
  68. bmOptions.inSampleSize = sampleSize;
  69. bmOptions.inPurgeable = true;
  71. Bitmap bmp = BitmapFactory.decodeFile(file.getAbsolutePath(), bmOptions);
  73. float scaleX = outW;
  74. float scaleY = outH;
  76. Matrix matrix = new Matrix();
  77. switch (orientation) {
  78. case ExifInterface.ORIENTATION_NORMAL:
  79. scaleX /= bmp.getWidth();
  80. scaleY /= bmp.getHeight();
  81. matrix.postScale(scaleX, scaleY);
  82. break;
  83. case ExifInterface.ORIENTATION_FLIP_HORIZONTAL:
  84. scaleX /= bmp.getWidth();
  85. scaleY /= bmp.getHeight();
  86. matrix.setScale(-1, 1);
  87. matrix.postScale(scaleX, scaleY);
  88. break;
  89. case ExifInterface.ORIENTATION_ROTATE_180:
  90. scaleX /= bmp.getWidth();
  91. scaleY /= bmp.getHeight();
  92. matrix.setRotate(180);
  93. matrix.postScale(scaleX, scaleY);
  94. break;
  95. case ExifInterface.ORIENTATION_FLIP_VERTICAL:
  96. scaleX /= bmp.getWidth();
  97. scaleY /= bmp.getHeight();
  98. matrix.setRotate(180);
  99. matrix.postScale(-1, 1);
  100. matrix.postScale(scaleX, scaleY);
  101. break;
  102. case ExifInterface.ORIENTATION_TRANSPOSE:
  103. scaleX /= bmp.getWidth();
  104. scaleY /= bmp.getHeight();
  105. matrix.setRotate(90);
  106. matrix.postScale(-1, 1);
  107. matrix.postScale(scaleX, scaleY);
  108. break;
  109. case ExifInterface.ORIENTATION_ROTATE_90:
  110. scaleX /= bmp.getHeight();
  111. scaleY /= bmp.getWidth();
  112. matrix.setRotate(90);
  113. matrix.postScale(scaleX, scaleY);
  114. break;
  115. case ExifInterface.ORIENTATION_TRANSVERSE:
  116. scaleX /= bmp.getWidth();
  117. scaleY /= bmp.getHeight();
  118. matrix.setRotate(-90);
  119. matrix.postScale(-1, 1);
  120. matrix.postScale(scaleX, scaleY);
  121. break;
  122. case ExifInterface.ORIENTATION_ROTATE_270:
  123. scaleX /= bmp.getHeight();
  124. scaleY /= bmp.getWidth();
  125. matrix.setRotate(-90);
  126. matrix.postScale(scaleX, scaleY);
  127. break;
  128. default:
  129. break;
  130. }
  132. Bitmap bmpNew = Bitmap.createBitmap(bmp, 0, 0, bmp.getWidth(), bmp.getHeight(), matrix, true);
  133. String newFile = bmp2File(bmpNew, outPath, format, quality);
  134. bmpNew.recycle();
  135. return newFile;
  136. }
  138. private static Point getBitmapSize(String file) {
  139. BitmapFactory.Options bmOptions = new BitmapFactory.Options();
  140. bmOptions.inJustDecodeBounds = true;
  141. BitmapFactory.decodeFile(file, bmOptions);
  142. int originW = bmOptions.outWidth;
  143. int originH = bmOptions.outHeight;
  144. return new Point(originW, originH);
  145. }
  147. @SuppressWarnings("deprecation")
  148. public static String saveBitmap(File f, int outW, int outH, String outPath, Bitmap.CompressFormat format, int quality) {
  149. String rotateFile = rotateAndSaveBitmap(f, outW, outH, outPath, format, quality);
  150. if (null != rotateFile)
  151. return rotateFile;
  153. if (f == null) return "";
  155. String file = f.getAbsolutePath();
  156. // Get the dimensions of the bitmap
  157. Point size = getBitmapSize(file);
  158. int originW = size.x;
  159. int originH = size.y;
  161. // Determine how much to scale down the image
  162. int scaleFactor;
  163. if (outW <= 0 && outH <= 0) {
  164. scaleFactor = 1;
  165. outW = originW;
  166. outH = originH;
  167. } else if (outW <= 0 || outH <= 0) {
  168. if (outW <= 0) {
  169. scaleFactor = originH / outH;
  170. outW = (int) (originW * (outH / (float) originH));
  171. } else {
  172. scaleFactor = originW / outW;
  173. outH = (int) (originH * (outW / (float) originW));
  174. }
  175. } else {
  176. scaleFactor = Math.min(originW / outW, originH / outH);
  177. }
  179. // Decode the image file into a Bitmap sized to fit out size
  180. BitmapFactory.Options bmOptions = new BitmapFactory.Options();
  181. bmOptions.inJustDecodeBounds = false;
  182. bmOptions.inSampleSize = scaleFactor;
  183. bmOptions.inPurgeable = true;
  185. Bitmap bmp = BitmapFactory.decodeFile(file, bmOptions);
  187. String newFile;
  188. if (bmp == null) {
  189. return "";
  190. }
  191. if (bmp.getWidth() != outW && bmp.getHeight() != outH) {
  192. Bitmap bmpNew = Bitmap.createScaledBitmap(bmp, outW, outH, true);
  193. newFile = bmp2File(bmpNew, outPath, format, quality);
  194. bmpNew.recycle();
  195. } else {
  196. newFile = bmp2File(bmp, outPath, format, quality);
  197. }
  198. bmp.recycle();
  199. return newFile;
  200. }
  202. public static Point calcScaleSize(String file, int outW, int outH) {
  204. int originW = 0;
  205. int originH = 0;
  207. try {
  208. ExifInterface exif = new ExifInterface(file);
  209. int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL);
  210. int w = exif.getAttributeInt(ExifInterface.TAG_IMAGE_WIDTH, 0);
  211. int h = exif.getAttributeInt(ExifInterface.TAG_IMAGE_LENGTH, 0);
  213. switch (orientation) {
  214. case ExifInterface.ORIENTATION_UNDEFINED:
  215. break;
  216. case ExifInterface.ORIENTATION_ROTATE_90:
  217. case ExifInterface.ORIENTATION_ROTATE_270:
  218. originW = h;
  219. originH = w;
  220. break;
  221. default:
  222. originW = w;
  223. originH = h;
  224. break;
  225. }
  227. } catch (Exception e) {
  229. }
  231. if (0 == originW || 0 == originH) {
  232. Point size = getBitmapSize(file);
  233. originW = size.x;
  234. originH = size.y;
  235. }
  237. if (outW <= 0 && outH <= 0) {
  238. outW = originW;
  239. outH = originH;
  240. } else if (outW <= 0 || outH <= 0) {
  241. if (outW <= 0) {
  242. outW = (int) (originW * (outH / (float) originH));
  243. } else {
  244. outH = (int) (originH * (outW / (float) originW));
  245. }
  246. } else {
  247. }
  249. return new Point(outW, outH);
  250. }
  252. public static String bmp2File(Bitmap bmp, String filePath, Bitmap.CompressFormat format, int quality) {
  253. String fileName = FileUtil.randomFileName(Bitmap.CompressFormat.PNG == format ? ".png" : ".jpg");
  254. String fullPath = filePath + fileName;
  255. deleteFile(fileName);
  256. File file = new File(fullPath);
  257. try {
  258. file.createNewFile();
  259. } catch (IOException e) {
  260. e.printStackTrace();
  261. return null;
  262. }
  263. FileOutputStream fOut = null;
  264. try {
  265. fOut = new FileOutputStream(file);
  266. } catch (FileNotFoundException e) {
  267. e.printStackTrace();
  268. return null;
  269. }
  270. bmp.compress(format, quality, fOut);
  271. try {
  272. fOut.flush();
  273. fOut.close();
  274. fOut = null;
  275. } catch (IOException e) {
  276. e.printStackTrace();
  277. return null;
  278. } finally {
  279. try {
  280. if (null != fOut) {
  281. fOut.close();
  282. fOut = null;
  283. }
  285. } catch (Exception e) {
  286. e.printStackTrace();
  287. return null;
  288. }
  289. }
  290. return fileName;
  291. }
  293. public static final String insertImage(ContentResolver cr, String imagePath, String name, String description) throws FileNotFoundException {
  294. FileInputStream inStream = new FileInputStream(imagePath);
  295. return insertImage(cr, inStream, name, description);
  296. }
  298. /**
  299. * A copy of the Android internals insertImage method, this method populates
  300. * the meta data with DATE_ADDED and DATE_TAKEN. This fixes a common problem
  301. * where media that is inserted manually gets saved at the end of the
  302. * gallery (because date is not populated).
  303. *
  304. * @see Images.Media#insertImage(ContentResolver,
  305. * Bitmap, String, String)
  306. */
  307. public static final String insertImage(ContentResolver cr, FileInputStream inStream, String title, String description) {
  309. ContentValues values = new ContentValues();
  310. values.put(Images.Media.TITLE, title);
  311. values.put(Images.Media.DISPLAY_NAME, title);
  312. values.put(Images.Media.DESCRIPTION, description);
  313. values.put(Images.Media.MIME_TYPE, "image/jpeg");
  314. // Add the date meta data to ensure the image is added at the front of
  315. // the gallery
  316. values.put(Images.Media.DATE_ADDED, System.currentTimeMillis());
  317. values.put(Images.Media.DATE_TAKEN, System.currentTimeMillis());
  319. Uri url = null;
  320. String stringUrl = null; /* value to be returned */
  322. try {
  323. url = cr.insert(Images.Media.EXTERNAL_CONTENT_URI, values);
  325. if (inStream != null) {
  326. OutputStream imageOut = cr.openOutputStream(url);
  327. byte[] buffer = new byte[1024];
  328. int count = 0;
  329. while ((count = inStream.read(buffer)) >= 0) {
  330. imageOut.write(buffer, 0, count);
  331. }
  332. imageOut.flush();
  333. inStream.close();
  334. long id = ContentUris.parseId(url);
  335. // Wait until MINI_KIND thumbnail is generated.
  336. Bitmap miniThumb = Images.Thumbnails.getThumbnail(cr, id, Images.Thumbnails.MINI_KIND, null);
  337. // This is for backward compatibility.
  338. storeThumbnail(cr, miniThumb, id, 50F, 50F, Images.Thumbnails.MICRO_KIND);
  339. } else {
  340. cr.delete(url, null, null);
  341. url = null;
  342. }
  343. } catch (Exception e) {
  344. e.printStackTrace();
  345. if (url != null) {
  346. cr.delete(url, null, null);
  347. url = null;
  348. }
  349. }
  351. if (url != null) {
  352. stringUrl = url.toString();
  353. }
  355. return stringUrl;
  356. }
  358. /**
  359. * A copy of the Android internals StoreThumbnail method, it used with the
  360. * insertImage to populate the
  361. * android.provider.MediaStore.Images.Media#insertImage with all the correct
  362. * meta data. The StoreThumbnail method is private so it must be duplicated
  363. * here.
  364. *
  365. * @see Images.Media (StoreThumbnail private
  366. * method)
  367. */
  368. private static final Bitmap storeThumbnail(ContentResolver cr, Bitmap source, long id, float width, float height, int kind) {
  370. // create the matrix to scale it
  371. Matrix matrix = new Matrix();
  373. float scaleX = width / source.getWidth();
  374. float scaleY = height / source.getHeight();
  376. matrix.setScale(scaleX, scaleY);
  378. Bitmap thumb = Bitmap.createBitmap(source, 0, 0, source.getWidth(), source.getHeight(), matrix, true);
  380. ContentValues values = new ContentValues(4);
  381. values.put(Images.Thumbnails.KIND, kind);
  382. values.put(Images.Thumbnails.IMAGE_ID, (int) id);
  383. values.put(Images.Thumbnails.HEIGHT, thumb.getHeight());
  384. values.put(Images.Thumbnails.WIDTH, thumb.getWidth());
  386. Uri url = cr.insert(Images.Thumbnails.EXTERNAL_CONTENT_URI, values);
  388. try {
  389. OutputStream thumbOut = cr.openOutputStream(url);
  390. thumb.compress(Bitmap.CompressFormat.JPEG, 100, thumbOut);
  391. thumbOut.close();
  392. return thumb;
  393. } catch (FileNotFoundException ex) {
  394. return null;
  395. } catch (IOException ex) {
  396. return null;
  397. }
  398. }
  400. // /////////////////////////////////////////////////
  401. @SuppressLint("NewApi")
  402. public static String checkPicturePath(final Context context, final Uri uri) {
  404. final boolean isKitKat = Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT;
  406. // DocumentProvider
  407. if (isKitKat && DocumentsContract.isDocumentUri(context, uri)) {
  408. // ExternalStorageProvider
  409. if (isExternalStorageDocument(uri)) {
  410. final String docId = DocumentsContract.getDocumentId(uri);
  411. final String[] split = docId.split(":");
  412. final String type = split[0];
  414. if ("primary".equalsIgnoreCase(type)) {
  415. return Environment.getExternalStorageDirectory() + "/" + split[1];
  416. }
  418. }
  419. // DownloadsProvider
  420. else if (isDownloadsDocument(uri)) {
  421. final String id = DocumentsContract.getDocumentId(uri);
  422. final Uri contentUri = ContentUris.withAppendedId(Uri.parse("content://downloads/public_downloads"), Long.valueOf(id));
  424. return getDataColumn(context, contentUri, null, null);
  425. }
  426. // MediaProvider
  427. else if (isMediaDocument(uri)) {
  428. final String docId = DocumentsContract.getDocumentId(uri);
  429. final String[] split = docId.split(":");
  430. final String type = split[0];
  432. Uri contentUri = null;
  433. if ("image".equals(type)) {
  434. contentUri = Images.Media.EXTERNAL_CONTENT_URI;
  435. } else if ("video".equals(type)) {
  436. contentUri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
  437. } else if ("audio".equals(type)) {
  438. contentUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
  439. }
  441. final String selection = "_id=?";
  442. final String[] selectionArgs = new String[]{split[1]};
  444. return getDataColumn(context, contentUri, selection, selectionArgs);
  445. }
  446. }
  447. // MediaStore (and general)
  448. else if ("content".equalsIgnoreCase(uri.getScheme())) {
  449. // Return the remote address
  450. if (isGooglePhotosUri(uri))
  451. return uri.getLastPathSegment();
  453. return getDataColumn(context, uri, null, null);
  454. }
  455. // File
  456. else if ("file".equalsIgnoreCase(uri.getScheme())) {
  457. return uri.getPath();
  458. }
  459. return null;
  460. }
  462. /**
  463. * Get the value of the data column for this Uri. This is useful for
  464. * MediaStore Uris, and other file-based ContentProviders.
  465. *
  466. * @param context       The context.
  467. * @param uri           The Uri to query.
  468. * @param selection     (Optional) Filter used in the query.
  469. * @param selectionArgs (Optional) Selection arguments used in the query.
  470. * @return The value of the _data column, which is typically a file path.
  471. */
  472. private static String getDataColumn(Context context, Uri uri, String selection, String[] selectionArgs) {
  474. Cursor cursor = null;
  475. final String column = "_data";
  476. final String[] projection = {column};
  478. try {
  479. cursor = context.getContentResolver().query(uri, projection, selection, selectionArgs, null);
  480. if (cursor != null && cursor.moveToFirst()) {
  481. final int index = cursor.getColumnIndexOrThrow(column);
  482. return cursor.getString(index);
  483. }
  484. } catch (Exception e) {
  485. e.printStackTrace();
  486. } finally {
  487. if (cursor != null)
  488. cursor.close();
  489. }
  490. return null;
  491. }
  493. /**
  494. * @param uri The Uri to check.
  495. * @return Whether the Uri authority is ExternalStorageProvider.
  496. */
  497. private static boolean isExternalStorageDocument(Uri uri) {
  498. return "com.android.externalstorage.documents".equals(uri.getAuthority());
  499. }
  501. /**
  502. * @param uri The Uri to check.
  503. * @return Whether the Uri authority is DownloadsProvider.
  504. */
  505. private static boolean isDownloadsDocument(Uri uri) {
  506. return "com.android.providers.downloads.documents".equals(uri.getAuthority());
  507. }
  509. /**
  510. * @param uri The Uri to check.
  511. * @return Whether the Uri authority is MediaProvider.
  512. */
  513. private static boolean isMediaDocument(Uri uri) {
  514. return "com.android.providers.media.documents".equals(uri.getAuthority());
  515. }
  517. /**
  518. * @param uri The Uri to check.
  519. * @return Whether the Uri authority is Google Photos.
  520. */
  521. private static boolean isGooglePhotosUri(Uri uri) {
  522. return "com.google.android.apps.photos.content".equals(uri.getAuthority());
  523. }
  524. }
IMResUtil.java
  1. public class IMResUtil {
  3. private static final String TAG = "IMResUtil";
  4. private static IMResUtil instance;
  5. private        Context   context;
  6. private static Class id = null;
  7. private static Class layout = null;
  8. private static Class style = null;
  9. private static Class attr = null;
  10. private static Class styleable = null;
  12. public IMResUtil(Context paramContext) {
  13. this.context = paramContext.getApplicationContext();
  15. try {
  16. layout = Class.forName(this.context.getPackageName() + ".R$layout");
  17. } catch (ClassNotFoundException localClassNotFoundException2) {
  18. Log.e(TAG,"localClassNotFoundException2 = " + localClassNotFoundException2.toString());
  19. }
  20. try {
  21. id = Class.forName(this.context.getPackageName() + ".R$id");
  22. } catch (ClassNotFoundException localClassNotFoundException3) {
  23. Log.e(TAG,"localClassNotFoundException3 = " + localClassNotFoundException3.toString());
  24. }
  26. try {
  27. style = Class.forName(this.context.getPackageName() + ".R$style");
  28. } catch (ClassNotFoundException localClassNotFoundException5) {
  29. Log.e(TAG,"localClassNotFoundException5 = " + localClassNotFoundException5.toString());
  30. }
  32. try {
  33. attr = Class.forName(this.context.getPackageName() + ".R$attr");
  34. } catch (ClassNotFoundException localClassNotFoundException10) {
  35. Log.e(TAG,"localClassNotFoundException10 = " + localClassNotFoundException10.toString());
  36. }
  38. try {
  39. styleable = Class.forName(this.context.getPackageName() + ".R$styleable");
  40. } catch (ClassNotFoundException localClassNotFoundException10) {
  41. Log.e(TAG,"localClassNotFoundException10 = " + localClassNotFoundException10.toString());
  42. }
  43. }
  45. public static IMResUtil getResofR(Context paramContext) {
  46. if (instance == null)
  47. instance = new IMResUtil(paramContext);
  48. return instance;
  49. }
  52. public int getId(String paramString) {
  53. return getResofR(id, paramString);
  54. }
  56. public  int getLayout(String paramString) {
  57. return getResofR(layout, paramString);
  58. }
  60. public int getStyle(String paramString) {
  61. return getResofR(style, paramString);
  62. }
  64. public  int getAttr(String paramString) {return getResofR(attr, paramString);}
  66. public  int getStyleable(String paramString) {return getResofR(styleable, paramString);}
  68. public int [] getStyleableArray(String paramString){
  69. try {
  70. Class clz = Class.forName(context.getPackageName()+".R$styleable");
  71. Field field = clz.getField(paramString);
  72. Object object = field.get(clz);
  73. int[] attr = (int[]) object;
  74. for (int i = 0; i < attr.length; i++) {
  75. Log.d(TAG, attr[i]+"");
  76. }
  77. return attr;
  78. } catch (Exception e) {
  79. Log.d(TAG, e.getMessage());
  80. e.printStackTrace();
  81. }
  82. return null;
  83. }
  84. private  int getResofR(Class<?> paramClass, String paramString) {
  85. if (paramClass == null) {
  86. Log.d(TAG,"getRes(null," + paramString + ")");
  87. Log.d(TAG,"Class is null ,ResClass is not initialized.");
  88. return -1;
  89. //            throw new IllegalArgumentException("ResClass is not initialized.");
  90. }
  91. try {
  92. Field localField = paramClass.getField(paramString);
  93. int k = localField.getInt(paramString);
  94. return k;
  95. } catch (Exception localException) {
  96. Log.e(TAG,"getRes(" + paramClass.getName() + ", " + paramString + ")");
  97. Log.e(TAG,"Error getting resource. Make sure you have copied all resources (res/) from SDK to your project. ");
  98. Log.e(TAG,localException.getMessage());
  99. }
  100. return -1;
  101. }
  102. }

xml

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <RelativeLayout xmlns:android="http://schemas./apk/res/android"
  3. xmlns:app="http://schemas./apk/res-auto"
  4. xmlns:tools="http://schemas./tools"
  5. android:layout_width="match_parent"
  6. android:layout_height="match_parent">
  8. <!--抬頭部分-->
  10. <RelativeLayout
  11. android:id="@+id/rl"
  12. android:layout_width="fill_parent"
  13. android:layout_height="50dp"
  14. android:background="#000000"
  15. android:paddingLeft="6dp"
  16. android:paddingStart="6dp">
  18. <ImageView
  19. android:id="@+id/iv_qr_back"
  20. android:layout_width="30dp"
  21. android:layout_height="24dp"
  22. android:layout_centerVertical="true"
  23. android:src="@drawable/arrow_back"/>
  26. <TextView
  27. android:id="@+id/tv_qr_title"
  28. android:layout_width="wrap_content"
  29. android:layout_height="match_parent"
  30. android:layout_centerHorizontal="true"
  31. android:clickable="true"
  32. android:focusable="true"
  33. android:gravity="center"
  34. android:textColor="#ffffff"
  35. android:textSize="20sp"/>
  37. <TextView
  38. android:id="@+id/tv_qr_open_image"
  39. android:layout_width="wrap_content"
  40. android:layout_height="match_parent"
  41. android:layout_alignParentEnd="true"
  42. android:layout_alignParentRight="true"
  43. android:layout_marginEnd="15dp"
  44. android:layout_marginRight="15dp"
  45. android:clickable="true"
  46. android:focusable="true"
  47. android:gravity="center"
  48. android:textColor="#ffffff"
  49. android:textSize="20sp"/>
  50. </RelativeLayout>
  52. <!--主體部分--><SurfaceView
  53. android:id="@+id/device_qrcode_preview_view"
  54. android:layout_width="fill_parent"
  55. android:layout_height="fill_parent"
  56. android:layout_below="@+id/rl"/>
  58. <com.yzq.zxinglibrary.view.ViewfinderView
  59. android:id="@+id/vv_qr_viewfinderView"
  60. android:layout_width="wrap_content"
  61. android:layout_height="wrap_content"
  62. android:layout_gravity="center"
  63. app:device_qrcode_corner_color="#005699"
  64. app:device_qrcode_frame_color="#90FFFFFF"
  65. app:device_qrcode_laser_color="#005699"
  66. app:device_qrcode_mask_color="#60000000"
  67. app:device_qrcode_result_color="#B0000000"
  68. app:device_qrcode_result_point_color="#C0FFFF00"/>
  69. <!--app:label_text="將二維碼放入框中，即可掃描"
  70. app:label_text_color="#ffffff"
  71. app:label_text_size="16sp"-->
  73. <!--掃描燈光-->
  75. <LinearLayout
  76. android:id="@+id/bottomLayout"
  77. android:layout_width="match_parent"
  78. android:layout_height="96dp"
  79. android:layout_alignParentBottom="true"
  80. android:layout_gravity="bottom"
  81. android:background="#99000000"
  82. android:orientation="horizontal">
  84. <LinearLayout
  85. android:id="@+id/flashLightLayout"
  86. android:layout_width="0dp"
  87. android:layout_height="match_parent"
  88. android:layout_weight="1"
  89. android:gravity="center"
  90. android:orientation="vertical">
  92. <!--android:background="@drawable/device_qrcode_scan_flash_off"-->
  94. <ImageView
  95. android:id="@+id/flashLightIv"
  96. android:layout_width="36dp"
  97. android:layout_height="36dp"
  98. android:scaleType="centerCrop"
  99. android:tint="#ffffffff"/>
  101. <TextView
  102. android:id="@+id/flashLightTv"
  103. android:layout_width="match_parent"
  104. android:layout_height="wrap_content"
  105. android:layout_marginTop="5dp"
  106. android:gravity="center"
  107. android:text="打開閃光燈"
  108. android:textColor="@color/result_text"/>
  110. </LinearLayout>
  112. <LinearLayout
  113. android:id="@+id/albumLayout"
  114. android:layout_width="0dp"
  115. android:layout_height="match_parent"
  116. android:layout_weight="1"
  117. android:gravity="center"
  118. android:orientation="vertical">
  120. <ImageView
  121. android:id="@+id/img_phone"
  122. android:layout_width="36dp"
  123. android:layout_height="36dp"
  124. android:scaleType="centerCrop"
  125. android:tint="#ffffffff"
  126. android:src="@drawable/ic_photo"
  127. />
  129. <TextView
  130. android:layout_width="match_parent"
  131. android:layout_height="wrap_content"
  132. android:layout_marginTop="5dp"
  133. android:gravity="center"
  134. android:text="相冊(cè)"
  136. android:textColor="@color/result_text"/>
  137. </LinearLayout>
  140. </LinearLayout>
  142. </RelativeLayout>

清單文件:

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <manifest xmlns:android="http://schemas./apk/res/android"
  3. package="com.xxx.zxinglibrary">
  5. <uses-permission android:name="android.permission.CAMERA" />
  6. <uses-permission android:name="android.permission.FLASHLIGHT" />
  8. <uses-feature android:name="android.hardware.camera" />
  9. <uses-feature android:name="android.hardware.camera.autofocus" />
  11. <uses-permission android:name="android.permission.VIBRATE" />
  12. <uses-permission android:name="android.permission.WAKE_LOCK" />
  13. <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
  14. <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
  16. <application>
  17. <activity
  18. android:name=".decode.CaptureActivity"
  19. android:configChanges="orientation|screenSize"
  20. android:screenOrientation="portrait"
  21. android:theme="@android:style/Theme.NoTitleBar"
  22. android:windowSoftInputMode="adjustPan|stateHidden" />
  23. </application>
  25. </manifest>

以上的總結(jié)如果能夠幫助到你,希望給個(gè)贊,如果不能,或者有更好的推薦,不管是拍磚,還是怎樣,煩請(qǐng)留言,提供鏈接,改動(dòng)方案,或者提供更好的優(yōu)化建議,謝謝!我們定會(huì)虛心采納,謝謝!

    本站是提供個(gè)人知識(shí)管理的網(wǎng)絡(luò)存儲(chǔ)空間,，所有內(nèi)容均由用戶發(fā)布,，不代表本站觀點(diǎn),。請(qǐng)注意甄別內(nèi)容中的聯(lián)系方式,、誘導(dǎo)購買等信息，謹(jǐn)防詐騙,。如發(fā)現(xiàn)有害或侵權(quán)內(nèi)容,，請(qǐng)點(diǎn)擊一鍵舉報(bào)。
    轉(zhuǎn)藏 分享 獻(xiàn)花（0）

    0條評(píng)論

    發(fā)表

    請(qǐng)遵守用戶 評(píng)論公約

    類似文章 更多