deniedPermissions) {
+ Toast.makeText(MainActivity.this, "您没有给权限，请检查", Toast.LENGTH_LONG).show();
+ }
+ }).start();
+ }
+
+ @Override
+ protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+ super.onActivityResult(requestCode, resultCode, data);
+
+ // 扫描二维码/条码回传
+ if (requestCode == REQUEST_CODE_SCAN && resultCode == RESULT_OK) {
+ if (data != null) {
+ String content = data.getStringExtra(DECODED_CONTENT_KEY);
+ resultTv.setText("扫描结果为：" + content);
+ }
+ }
+ }
+}
diff --git a/app/src/main/res/layout/activity_main.xml b/app/src/main/res/layout/activity_main.xml
new file mode 100644
index 0000000..61fdba2
--- /dev/null
+++ b/app/src/main/res/layout/activity_main.xml
@@ -0,0 +1,23 @@
+
+
+
+
+
+
+
+
diff --git a/app/src/main/res/mipmap-hdpi/ic_launcher.png b/app/src/main/res/mipmap-hdpi/ic_launcher.png
new file mode 100644
index 0000000..cde69bc
Binary files /dev/null and b/app/src/main/res/mipmap-hdpi/ic_launcher.png differ
diff --git a/app/src/main/res/mipmap-hdpi/ic_launcher_round.png b/app/src/main/res/mipmap-hdpi/ic_launcher_round.png
new file mode 100644
index 0000000..9a078e3
Binary files /dev/null and b/app/src/main/res/mipmap-hdpi/ic_launcher_round.png differ
diff --git a/app/src/main/res/mipmap-mdpi/ic_launcher.png b/app/src/main/res/mipmap-mdpi/ic_launcher.png
new file mode 100644
index 0000000..c133a0c
Binary files /dev/null and b/app/src/main/res/mipmap-mdpi/ic_launcher.png differ
diff --git a/app/src/main/res/mipmap-mdpi/ic_launcher_round.png b/app/src/main/res/mipmap-mdpi/ic_launcher_round.png
new file mode 100644
index 0000000..efc028a
Binary files /dev/null and b/app/src/main/res/mipmap-mdpi/ic_launcher_round.png differ
diff --git a/app/src/main/res/mipmap-xhdpi/ic_launcher.png b/app/src/main/res/mipmap-xhdpi/ic_launcher.png
new file mode 100644
index 0000000..bfa42f0
Binary files /dev/null and b/app/src/main/res/mipmap-xhdpi/ic_launcher.png differ
diff --git a/app/src/main/res/mipmap-xhdpi/ic_launcher_round.png b/app/src/main/res/mipmap-xhdpi/ic_launcher_round.png
new file mode 100644
index 0000000..3af2608
Binary files /dev/null and b/app/src/main/res/mipmap-xhdpi/ic_launcher_round.png differ
diff --git a/app/src/main/res/mipmap-xxhdpi/ic_launcher.png b/app/src/main/res/mipmap-xxhdpi/ic_launcher.png
new file mode 100644
index 0000000..324e72c
Binary files /dev/null and b/app/src/main/res/mipmap-xxhdpi/ic_launcher.png differ
diff --git a/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.png b/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.png
new file mode 100644
index 0000000..9bec2e6
Binary files /dev/null and b/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.png differ
diff --git a/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png b/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png
new file mode 100644
index 0000000..aee44e1
Binary files /dev/null and b/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png differ
diff --git a/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.png b/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.png
new file mode 100644
index 0000000..34947cd
Binary files /dev/null and b/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.png differ
diff --git a/app/src/main/res/values/colors.xml b/app/src/main/res/values/colors.xml
new file mode 100644
index 0000000..3ab3e9c
--- /dev/null
+++ b/app/src/main/res/values/colors.xml
@@ -0,0 +1,6 @@
+
+
+ #3F51B5
+ #303F9F
+ #FF4081
+
diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml
new file mode 100644
index 0000000..c803474
--- /dev/null
+++ b/app/src/main/res/values/strings.xml
@@ -0,0 +1,3 @@
+
+ Zxing
+
diff --git a/app/src/main/res/values/styles.xml b/app/src/main/res/values/styles.xml
new file mode 100644
index 0000000..5885930
--- /dev/null
+++ b/app/src/main/res/values/styles.xml
@@ -0,0 +1,11 @@
+
+
+
+
+
+
diff --git a/build.gradle b/build.gradle
new file mode 100644
index 0000000..c2eea8e
--- /dev/null
+++ b/build.gradle
@@ -0,0 +1,23 @@
+// Top-level build file where you can add configuration options common to all sub-projects/modules.
+
+buildscript {
+ repositories {
+ jcenter()
+ }
+ dependencies {
+ classpath 'com.android.tools.build:gradle:2.3.3'
+
+ // NOTE: Do not place your application dependencies here; they belong
+ // in the individual module build.gradle files
+ }
+}
+
+allprojects {
+ repositories {
+ jcenter()
+ }
+}
+
+task clean(type: Delete) {
+ delete rootProject.buildDir
+}
diff --git a/gradle.properties b/gradle.properties
new file mode 100644
index 0000000..aac7c9b
--- /dev/null
+++ b/gradle.properties
@@ -0,0 +1,17 @@
+# Project-wide Gradle settings.
+
+# IDE (e.g. Android Studio) users:
+# Gradle settings configured through the IDE *will override*
+# any settings specified in this file.
+
+# For more details on how to configure your build environment visit
+# http://www.gradle.org/docs/current/userguide/build_environment.html
+
+# Specifies the JVM arguments used for the daemon process.
+# The setting is particularly useful for tweaking memory settings.
+org.gradle.jvmargs=-Xmx1536m
+
+# When configured, Gradle will run in incubating parallel mode.
+# This option should only be used with decoupled projects. More details, visit
+# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
+# org.gradle.parallel=true
diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar
new file mode 100644
index 0000000..13372ae
Binary files /dev/null and b/gradle/wrapper/gradle-wrapper.jar differ
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
new file mode 100644
index 0000000..1f1d1b8
--- /dev/null
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -0,0 +1,6 @@
+#Thu Jul 20 15:52:56 CST 2017
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-3.3-all.zip
diff --git a/gradlew b/gradlew
new file mode 100644
index 0000000..9d82f78
--- /dev/null
+++ b/gradlew
@@ -0,0 +1,160 @@
+#!/usr/bin/env bash
+
+##############################################################################
+##
+## Gradle start up script for UN*X
+##
+##############################################################################
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn ( ) {
+ echo "$*"
+}
+
+die ( ) {
+ echo
+ echo "$*"
+ echo
+ exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+case "`uname`" in
+ CYGWIN* )
+ cygwin=true
+ ;;
+ Darwin* )
+ darwin=true
+ ;;
+ MINGW* )
+ msys=true
+ ;;
+esac
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+ ls=`ls -ld "$PRG"`
+ link=`expr "$ls" : '.*-> \(.*\)$'`
+ if expr "$link" : '/.*' > /dev/null; then
+ PRG="$link"
+ else
+ PRG=`dirname "$PRG"`"/$link"
+ fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+ if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+ # IBM's JDK on AIX uses strange locations for the executables
+ JAVACMD="$JAVA_HOME/jre/sh/java"
+ else
+ JAVACMD="$JAVA_HOME/bin/java"
+ fi
+ if [ ! -x "$JAVACMD" ] ; then
+ die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+ fi
+else
+ JAVACMD="java"
+ which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
+ MAX_FD_LIMIT=`ulimit -H -n`
+ if [ $? -eq 0 ] ; then
+ if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+ MAX_FD="$MAX_FD_LIMIT"
+ fi
+ ulimit -n $MAX_FD
+ if [ $? -ne 0 ] ; then
+ warn "Could not set maximum file descriptor limit: $MAX_FD"
+ fi
+ else
+ warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+ fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+ GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+ APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+ CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+ JAVACMD=`cygpath --unix "$JAVACMD"`
+
+ # We build the pattern for arguments to be converted via cygpath
+ ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+ SEP=""
+ for dir in $ROOTDIRSRAW ; do
+ ROOTDIRS="$ROOTDIRS$SEP$dir"
+ SEP="|"
+ done
+ OURCYGPATTERN="(^($ROOTDIRS))"
+ # Add a user-defined pattern to the cygpath arguments
+ if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+ OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+ fi
+ # Now convert the arguments - kludge to limit ourselves to /bin/sh
+ i=0
+ for arg in "$@" ; do
+ CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+ CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option
+
+ if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition
+ eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+ else
+ eval `echo args$i`="\"$arg\""
+ fi
+ i=$((i+1))
+ done
+ case $i in
+ (0) set -- ;;
+ (1) set -- "$args0" ;;
+ (2) set -- "$args0" "$args1" ;;
+ (3) set -- "$args0" "$args1" "$args2" ;;
+ (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+ (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+ (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+ (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+ (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+ (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+ esac
+fi
+
+# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
+function splitJvmOpts() {
+ JVM_OPTS=("$@")
+}
+eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
+JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
+
+exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"
diff --git a/gradlew.bat b/gradlew.bat
new file mode 100644
index 0000000..8a0b282
--- /dev/null
+++ b/gradlew.bat
@@ -0,0 +1,90 @@
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS=
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto init
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto init
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:init
+@rem Get command-line arguments, handling Windowz variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+if "%@eval[2+2]" == "4" goto 4NT_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+goto execute
+
+:4NT_args
+@rem Get arguments from the 4NT Shell from JP Software
+set CMD_LINE_ARGS=%$
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega
diff --git a/settings.gradle b/settings.gradle
new file mode 100644
index 0000000..4e7dd9d
--- /dev/null
+++ b/settings.gradle
@@ -0,0 +1 @@
+include ':app', ':zxinglibrary'
diff --git a/zxinglibrary/.gitignore b/zxinglibrary/.gitignore
new file mode 100644
index 0000000..796b96d
--- /dev/null
+++ b/zxinglibrary/.gitignore
@@ -0,0 +1 @@
+/build
diff --git a/zxinglibrary/build.gradle b/zxinglibrary/build.gradle
new file mode 100644
index 0000000..baa48bb
--- /dev/null
+++ b/zxinglibrary/build.gradle
@@ -0,0 +1,31 @@
+apply plugin: 'com.android.library'
+
+android {
+ compileSdkVersion 26
+ buildToolsVersion "26.0.0"
+
+ defaultConfig {
+ minSdkVersion 15
+ targetSdkVersion 25
+ versionCode 1
+ versionName "1.0"
+
+ testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
+
+ }
+ buildTypes {
+ release {
+ minifyEnabled false
+ proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+ }
+ }
+}
+
+dependencies {
+ compile fileTree(include: ['*.jar'], dir: 'libs')
+ androidTestCompile('com.android.support.test.espresso:espresso-core:2.2.2', {
+ exclude group: 'com.android.support', module: 'support-annotations'
+ })
+ testCompile 'junit:junit:4.12'
+ compile files('libs/core-3.3.0.jar')
+}
diff --git a/zxinglibrary/libs/core-3.3.0.jar b/zxinglibrary/libs/core-3.3.0.jar
new file mode 100644
index 0000000..94f7406
Binary files /dev/null and b/zxinglibrary/libs/core-3.3.0.jar differ
diff --git a/zxinglibrary/proguard-rules.pro b/zxinglibrary/proguard-rules.pro
new file mode 100644
index 0000000..f8aec7c
--- /dev/null
+++ b/zxinglibrary/proguard-rules.pro
@@ -0,0 +1,25 @@
+# Add project specific ProGuard rules here.
+# By default, the flags in this file are appended to flags specified
+# in D:\sdk/tools/proguard/proguard-android.txt
+# You can edit the include path and order by changing the proguardFiles
+# directive in build.gradle.
+#
+# For more details, see
+# http://developer.android.com/guide/developing/tools/proguard.html
+
+# Add any project specific keep options here:
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+# public *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile
diff --git a/zxinglibrary/src/androidTest/java/com/yzq/zxinglibrary/ExampleInstrumentedTest.java b/zxinglibrary/src/androidTest/java/com/yzq/zxinglibrary/ExampleInstrumentedTest.java
new file mode 100644
index 0000000..5955eff
--- /dev/null
+++ b/zxinglibrary/src/androidTest/java/com/yzq/zxinglibrary/ExampleInstrumentedTest.java
@@ -0,0 +1,26 @@
+package com.yzq.zxinglibrary;
+
+import android.content.Context;
+import android.support.test.InstrumentationRegistry;
+import android.support.test.runner.AndroidJUnit4;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static org.junit.Assert.*;
+
+/**
+ * Instrumentation test, which will execute on an Android device.
+ *
+ * @see Testing documentation
+ */
+@RunWith(AndroidJUnit4.class)
+public class ExampleInstrumentedTest {
+ @Test
+ public void useAppContext() throws Exception {
+ // Context of the app under test.
+ Context appContext = InstrumentationRegistry.getTargetContext();
+
+ assertEquals("com.yzq.zxinglibrary.test", appContext.getPackageName());
+ }
+}
diff --git a/zxinglibrary/src/main/AndroidManifest.xml b/zxinglibrary/src/main/AndroidManifest.xml
new file mode 100644
index 0000000..9b36792
--- /dev/null
+++ b/zxinglibrary/src/main/AndroidManifest.xml
@@ -0,0 +1,19 @@
+
+
+
+
+
+
+
+
+
diff --git a/zxinglibrary/src/main/java/com/yzq/zxinglibrary/Consants.java b/zxinglibrary/src/main/java/com/yzq/zxinglibrary/Consants.java
new file mode 100644
index 0000000..cb4a5ae
--- /dev/null
+++ b/zxinglibrary/src/main/java/com/yzq/zxinglibrary/Consants.java
@@ -0,0 +1,18 @@
+package com.yzq.zxinglibrary;
+
+/**
+ * Created by yzq on 2017/7/20.
+ *
+ * zxing常量
+ */
+
+public class Consants {
+ public static final int DECODE = 1;
+ public static final int DECODE_FAILED = 2;
+ public static final int DECODE_SUCCEEDED = 3;
+ public static final int LAUNCH_PRODUCT_QUERY = 4;
+ public static final int QUIT = 5;
+ public static final int RESTART_PREVIEW = 6;
+ public static final int RETURN_SCAN_RESULT = 7;
+
+}
diff --git a/zxinglibrary/src/main/java/com/yzq/zxinglibrary/android/BeepManager.java b/zxinglibrary/src/main/java/com/yzq/zxinglibrary/android/BeepManager.java
new file mode 100644
index 0000000..fd97c3c
--- /dev/null
+++ b/zxinglibrary/src/main/java/com/yzq/zxinglibrary/android/BeepManager.java
@@ -0,0 +1,169 @@
+/*
+ * Copyright (C) 2010 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.yzq.zxinglibrary.android;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.content.res.AssetFileDescriptor;
+import android.media.AudioManager;
+import android.media.MediaPlayer;
+import android.os.Vibrator;
+import android.preference.PreferenceManager;
+import android.util.Log;
+
+import com.yzq.zxinglibrary.R;
+
+import java.io.Closeable;
+import java.io.IOException;
+
+
+/**
+ * Manages beeps and vibrations for {@link CaptureActivity}. 管理声音和震动
+ */
+public final class BeepManager implements MediaPlayer.OnCompletionListener,
+ MediaPlayer.OnErrorListener, Closeable {
+
+ private static final String TAG = BeepManager.class.getSimpleName();
+
+ private static final float BEEP_VOLUME = 0.10f;
+ private static final long VIBRATE_DURATION = 200L;
+
+ private final Activity activity;
+ private MediaPlayer mediaPlayer;
+ private boolean playBeep;
+ private boolean vibrate;
+
+ public BeepManager(Activity activity) {
+ this.activity = activity;
+ this.mediaPlayer = null;
+ updatePrefs();
+ }
+
+ public synchronized void updatePrefs() {
+ SharedPreferences prefs = PreferenceManager
+ .getDefaultSharedPreferences(activity);
+ playBeep = shouldBeep(prefs, activity);
+ vibrate = prefs.getBoolean(PreferencesActivity.KEY_VIBRATE, false);
+ if (playBeep && mediaPlayer == null) {
+ // The volume on STREAM_SYSTEM is not adjustable, and users found it
+ // too loud,
+ // so we now play on the music stream.
+ // 设置activity音量控制键控制的音频流
+ activity.setVolumeControlStream(AudioManager.STREAM_MUSIC);
+ mediaPlayer = buildMediaPlayer(activity);
+ }
+ }
+
+ /**
+ * 开启响铃和震动
+ */
+ public synchronized void playBeepSoundAndVibrate() {
+ if (playBeep && mediaPlayer != null) {
+ mediaPlayer.start();
+ }
+ if (vibrate) {
+ Vibrator vibrator = (Vibrator) activity
+ .getSystemService(Context.VIBRATOR_SERVICE);
+ vibrator.vibrate(VIBRATE_DURATION);
+ }
+ }
+
+ /**
+ * 判断是否需要响铃
+ *
+ * @param prefs
+ * @param activity
+ * @return
+ */
+ private static boolean shouldBeep(SharedPreferences prefs, Context activity) {
+ boolean shouldPlayBeep = prefs.getBoolean(
+ PreferencesActivity.KEY_PLAY_BEEP, true);
+ if (shouldPlayBeep) {
+ // See if sound settings overrides this
+ AudioManager audioService = (AudioManager) activity
+ .getSystemService(Context.AUDIO_SERVICE);
+ if (audioService.getRingerMode() != AudioManager.RINGER_MODE_NORMAL) {
+ shouldPlayBeep = false;
+ }
+ }
+ return shouldPlayBeep;
+ }
+
+ /**
+ * 创建MediaPlayer
+ *
+ * @param activity
+ * @return
+ */
+ private MediaPlayer buildMediaPlayer(Context activity) {
+ MediaPlayer mediaPlayer = new MediaPlayer();
+ mediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
+ // 监听是否播放完成
+ mediaPlayer.setOnCompletionListener(this);
+ mediaPlayer.setOnErrorListener(this);
+ // 配置播放资源
+ try {
+ AssetFileDescriptor file = activity.getResources()
+ .openRawResourceFd(R.raw.beep);
+ try {
+ mediaPlayer.setDataSource(file.getFileDescriptor(),
+ file.getStartOffset(), file.getLength());
+ } finally {
+ file.close();
+ }
+ // 设置音量
+ mediaPlayer.setVolume(BEEP_VOLUME, BEEP_VOLUME);
+ mediaPlayer.prepare();
+ return mediaPlayer;
+ } catch (IOException ioe) {
+ Log.w(TAG, ioe);
+ mediaPlayer.release();
+ return null;
+ }
+ }
+
+ @Override
+ public void onCompletion(MediaPlayer mp) {
+ // When the beep has finished playing, rewind to queue up another one.
+ mp.seekTo(0);
+ }
+
+ @Override
+ public synchronized boolean onError(MediaPlayer mp, int what, int extra) {
+ if (what == MediaPlayer.MEDIA_ERROR_SERVER_DIED) {
+ // we are finished, so put up an appropriate error toast if required
+ // and finish
+ activity.finish();
+ } else {
+ // possibly media player error, so release and recreate
+ mp.release();
+ mediaPlayer = null;
+ updatePrefs();
+ }
+ return true;
+ }
+
+ @Override
+ public synchronized void close() {
+ if (mediaPlayer != null) {
+ mediaPlayer.release();
+ mediaPlayer = null;
+ }
+ }
+
+}
diff --git a/zxinglibrary/src/main/java/com/yzq/zxinglibrary/android/CaptureActivity.java b/zxinglibrary/src/main/java/com/yzq/zxinglibrary/android/CaptureActivity.java
new file mode 100644
index 0000000..c258897
--- /dev/null
+++ b/zxinglibrary/src/main/java/com/yzq/zxinglibrary/android/CaptureActivity.java
@@ -0,0 +1,239 @@
+package com.yzq.zxinglibrary.android;
+
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.content.Intent;
+import android.graphics.Bitmap;
+import android.os.Bundle;
+import android.os.Handler;
+import android.util.Log;
+import android.view.SurfaceHolder;
+import android.view.SurfaceView;
+import android.view.View;
+import android.view.Window;
+import android.view.WindowManager;
+import android.widget.ImageButton;
+import android.widget.Toast;
+
+import com.google.zxing.BarcodeFormat;
+import com.google.zxing.DecodeHintType;
+import com.google.zxing.Result;
+import com.yzq.zxinglibrary.R;
+import com.yzq.zxinglibrary.camera.CameraManager;
+import com.yzq.zxinglibrary.view.ViewfinderView;
+
+import java.io.IOException;
+import java.util.Collection;
+import java.util.Map;
+
+/**
+ * 这个activity打开相机，在后台线程做常规的扫描；它绘制了一个结果view来帮助正确地显示条形码，在扫描的时候显示反馈信息，
+ * 然后在扫描成功的时候覆盖扫描结果
+ */
+public final class CaptureActivity extends Activity implements
+ SurfaceHolder.Callback {
+
+ private static final String TAG = CaptureActivity.class.getSimpleName();
+
+ // 相机控制
+ private CameraManager cameraManager;
+ private CaptureActivityHandler handler;
+ private ViewfinderView viewfinderView;
+ private boolean hasSurface;
+ private IntentSource source;
+ private Collection decodeFormats;
+ private Map decodeHints;
+ private String characterSet;
+ // 电量控制
+ private InactivityTimer inactivityTimer;
+ // 声音、震动控制
+ private BeepManager beepManager;
+
+ private ImageButton imageButton_back;
+
+ public ViewfinderView getViewfinderView() {
+ return viewfinderView;
+ }
+
+ public Handler getHandler() {
+ return handler;
+ }
+
+ public CameraManager getCameraManager() {
+ return cameraManager;
+ }
+
+ public void drawViewfinder() {
+ viewfinderView.drawViewfinder();
+ }
+
+ /**
+ * OnCreate中初始化一些辅助类，如InactivityTimer（休眠）、Beep（声音）以及AmbientLight（闪光灯）
+ */
+ @Override
+ public void onCreate(Bundle icicle) {
+ super.onCreate(icicle);
+ // 保持Activity处于唤醒状态
+ Window window = getWindow();
+ window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
+ setContentView(R.layout.capture);
+
+ hasSurface = false;
+
+ inactivityTimer = new InactivityTimer(this);
+ beepManager = new BeepManager(this);
+
+ imageButton_back = (ImageButton) findViewById(R.id.capture_imageview_back);
+ imageButton_back.setOnClickListener(new View.OnClickListener() {
+
+ @Override
+ public void onClick(View v) {
+ finish();
+ }
+ });
+ }
+
+ @Override
+ protected void onResume() {
+ super.onResume();
+
+ // CameraManager必须在这里初始化，而不是在onCreate()中。
+ // 这是必须的，因为当我们第一次进入时需要显示帮助页，我们并不想打开Camera,测量屏幕大小
+ // 当扫描框的尺寸不正确时会出现bug
+ cameraManager = new CameraManager(getApplication());
+
+ viewfinderView = (ViewfinderView) findViewById(R.id.viewfinder_view);
+ viewfinderView.setCameraManager(cameraManager);
+
+ handler = null;
+
+ SurfaceView surfaceView = (SurfaceView) findViewById(R.id.preview_view);
+ SurfaceHolder surfaceHolder = surfaceView.getHolder();
+ if (hasSurface) {
+ // activity在paused时但不会stopped,因此surface仍旧存在；
+ // surfaceCreated()不会调用，因此在这里初始化camera
+ initCamera(surfaceHolder);
+ } else {
+ // 重置callback，等待surfaceCreated()来初始化camera
+ surfaceHolder.addCallback(this);
+ }
+
+ beepManager.updatePrefs();
+ inactivityTimer.onResume();
+
+ source = IntentSource.NONE;
+ decodeFormats = null;
+ characterSet = null;
+ }
+
+ @Override
+ protected void onPause() {
+ if (handler != null) {
+ handler.quitSynchronously();
+ handler = null;
+ }
+ inactivityTimer.onPause();
+ beepManager.close();
+ cameraManager.closeDriver();
+ if (!hasSurface) {
+ SurfaceView surfaceView = (SurfaceView) findViewById(R.id.preview_view);
+ SurfaceHolder surfaceHolder = surfaceView.getHolder();
+ surfaceHolder.removeCallback(this);
+ }
+ super.onPause();
+ }
+
+ @Override
+ protected void onDestroy() {
+ inactivityTimer.shutdown();
+ super.onDestroy();
+ }
+
+ @Override
+ public void surfaceCreated(SurfaceHolder holder) {
+ if (!hasSurface) {
+ hasSurface = true;
+ initCamera(holder);
+ }
+ }
+
+ @Override
+ public void surfaceDestroyed(SurfaceHolder holder) {
+ hasSurface = false;
+ }
+
+ @Override
+ public void surfaceChanged(SurfaceHolder holder, int format, int width,
+ int height) {
+
+ }
+
+ /**
+ * 扫描成功，处理反馈信息
+ *
+ * @param rawResult
+ * @param barcode
+ * @param scaleFactor
+ */
+ public void handleDecode(Result rawResult, Bitmap barcode, float scaleFactor) {
+ inactivityTimer.onActivity();
+
+ boolean fromLiveScan = barcode != null;
+ //这里处理解码完成后的结果，此处将参数回传到Activity处理
+ if (fromLiveScan) {
+ beepManager.playBeepSoundAndVibrate();
+
+ Toast.makeText(this, "扫描成功", Toast.LENGTH_SHORT).show();
+
+ Intent intent = getIntent();
+ intent.putExtra("codedContent", rawResult.getText());
+ intent.putExtra("codedBitmap", barcode);
+ setResult(RESULT_OK, intent);
+ finish();
+ }
+
+ }
+
+ /**
+ * 初始化Camera
+ *
+ * @param surfaceHolder
+ */
+ private void initCamera(SurfaceHolder surfaceHolder) {
+ if (surfaceHolder == null) {
+ throw new IllegalStateException("No SurfaceHolder provided");
+ }
+ if (cameraManager.isOpen()) {
+ return;
+ }
+ try {
+ // 打开Camera硬件设备
+ cameraManager.openDriver(surfaceHolder);
+ // 创建一个handler来打开预览，并抛出一个运行时异常
+ if (handler == null) {
+ handler = new CaptureActivityHandler(this, decodeFormats,
+ decodeHints, characterSet, cameraManager);
+ }
+ } catch (IOException ioe) {
+ Log.w(TAG, ioe);
+ displayFrameworkBugMessageAndExit();
+ } catch (RuntimeException e) {
+ Log.w(TAG, "Unexpected error initializing camera", e);
+ displayFrameworkBugMessageAndExit();
+ }
+ }
+
+ /**
+ * 显示底层错误信息并退出应用
+ */
+ private void displayFrameworkBugMessageAndExit() {
+ AlertDialog.Builder builder = new AlertDialog.Builder(this);
+ builder.setTitle("扫一扫");
+ builder.setMessage(getString(R.string.msg_camera_framework_bug));
+ builder.setPositiveButton(R.string.button_ok, new FinishListener(this));
+ builder.setOnCancelListener(new FinishListener(this));
+ builder.show();
+ }
+
+}
diff --git a/zxinglibrary/src/main/java/com/yzq/zxinglibrary/android/CaptureActivityHandler.java b/zxinglibrary/src/main/java/com/yzq/zxinglibrary/android/CaptureActivityHandler.java
new file mode 100644
index 0000000..f0c89da
--- /dev/null
+++ b/zxinglibrary/src/main/java/com/yzq/zxinglibrary/android/CaptureActivityHandler.java
@@ -0,0 +1,188 @@
+/*
+ * Copyright (C) 2008 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.yzq.zxinglibrary.android;
+
+import android.app.Activity;
+import android.content.ActivityNotFoundException;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.content.pm.ResolveInfo;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.net.Uri;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Message;
+import android.provider.Browser;
+import android.util.Log;
+
+import com.google.zxing.BarcodeFormat;
+import com.google.zxing.DecodeHintType;
+import com.google.zxing.Result;
+import com.yzq.zxinglibrary.Consants;
+import com.yzq.zxinglibrary.camera.CameraManager;
+import com.yzq.zxinglibrary.decode.DecodeThread;
+import com.yzq.zxinglibrary.view.ViewfinderResultPointCallback;
+
+
+import java.util.Collection;
+import java.util.Map;
+
+/**
+ * This class handles all the messaging which comprises the state machine for
+ * capture. 该类用于处理有关拍摄状态的所有信息
+ *
+ * @author dswitkin@google.com (Daniel Switkin)
+ */
+public final class CaptureActivityHandler extends Handler {
+
+ private static final String TAG = CaptureActivityHandler.class
+ .getSimpleName();
+
+ private final CaptureActivity activity;
+ private final DecodeThread decodeThread;
+ private State state;
+ private final CameraManager cameraManager;
+
+ private enum State {
+ PREVIEW, SUCCESS, DONE
+ }
+
+ public CaptureActivityHandler(CaptureActivity activity,
+ Collection decodeFormats,
+ Map baseHints, String characterSet,
+ CameraManager cameraManager) {
+ this.activity = activity;
+ decodeThread = new DecodeThread(activity, decodeFormats, baseHints,
+ characterSet, new ViewfinderResultPointCallback(
+ activity.getViewfinderView()));
+ decodeThread.start();
+ state = State.SUCCESS;
+
+ // Start ourselves capturing previews and decoding.
+ // 开始拍摄预览和解码
+ this.cameraManager = cameraManager;
+ cameraManager.startPreview();
+ restartPreviewAndDecode();
+ }
+
+ @Override
+ public void handleMessage(Message message) {
+ switch (message.what) {
+ case Consants.RESTART_PREVIEW:
+ // 重新预览
+ restartPreviewAndDecode();
+ break;
+ case Consants.DECODE_SUCCEEDED:
+ // 解码成功
+ state = State.SUCCESS;
+ Bundle bundle = message.getData();
+ Bitmap barcode = null;
+ float scaleFactor = 1.0f;
+ if (bundle != null) {
+ byte[] compressedBitmap = bundle
+ .getByteArray(DecodeThread.BARCODE_BITMAP);
+ if (compressedBitmap != null) {
+ barcode = BitmapFactory.decodeByteArray(compressedBitmap,
+ 0, compressedBitmap.length, null);
+ // Mutable copy:
+ barcode = barcode.copy(Bitmap.Config.ARGB_8888, true);
+ }
+ scaleFactor = bundle
+ .getFloat(DecodeThread.BARCODE_SCALED_FACTOR);
+ }
+ activity.handleDecode((Result) message.obj, barcode, scaleFactor);
+ break;
+ case Consants.DECODE_FAILED:
+ // We're decoding as fast as possible, so when one decode fails,
+ // start another.
+ // 尽可能快的解码，以便可以在解码失败时，开始另一次解码
+ state = State.PREVIEW;
+ cameraManager.requestPreviewFrame(decodeThread.getHandler(),
+ Consants.DECODE);
+ break;
+ case Consants.RETURN_SCAN_RESULT:
+ //扫描结果，返回CaptureActivity处理
+ activity.setResult(Activity.RESULT_OK, (Intent) message.obj);
+ activity.finish();
+ break;
+ case Consants.LAUNCH_PRODUCT_QUERY:
+ String url = (String) message.obj;
+
+ Intent intent = new Intent(Intent.ACTION_VIEW);
+ intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET);
+ intent.setData(Uri.parse(url));
+
+ ResolveInfo resolveInfo = activity.getPackageManager()
+ .resolveActivity(intent, PackageManager.MATCH_DEFAULT_ONLY);
+ String browserPackageName = null;
+ if (resolveInfo != null && resolveInfo.activityInfo != null) {
+ browserPackageName = resolveInfo.activityInfo.packageName;
+ Log.d(TAG, "Using browser in package " + browserPackageName);
+ }
+
+ // Needed for default Android browser / Chrome only apparently
+ //需要默认的Android浏览器或者Google
+ if ("com.android.browser".equals(browserPackageName)
+ || "com.android.chrome".equals(browserPackageName)) {
+ intent.setPackage(browserPackageName);
+ intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+ intent.putExtra(Browser.EXTRA_APPLICATION_ID,
+ browserPackageName);
+ }
+
+ try {
+ activity.startActivity(intent);
+ } catch (ActivityNotFoundException ignored) {
+ Log.w(TAG, "Can't find anything to handle VIEW of URI " + url);
+ }
+ break;
+ }
+ }
+
+ /**
+ * 完全退出
+ */
+ public void quitSynchronously() {
+ state = State.DONE;
+ cameraManager.stopPreview();
+ Message quit = Message.obtain(decodeThread.getHandler(), Consants.QUIT);
+ quit.sendToTarget();
+ try {
+ // Wait at most half a second; should be enough time, and onPause()
+ // will timeout quickly
+ decodeThread.join(500L);
+ } catch (InterruptedException e) {
+ // continue
+ }
+
+ // Be absolutely sure we don't send any queued up messages
+ //确保不会发送任何队列消息
+ removeMessages(Consants.DECODE_SUCCEEDED);
+ removeMessages(Consants.DECODE_FAILED);
+ }
+
+ public void restartPreviewAndDecode() {
+ if (state == State.SUCCESS) {
+ state = State.PREVIEW;
+ cameraManager.requestPreviewFrame(decodeThread.getHandler(),
+ Consants.DECODE);
+ activity.drawViewfinder();
+ }
+ }
+
+}
diff --git a/zxinglibrary/src/main/java/com/yzq/zxinglibrary/android/FinishListener.java b/zxinglibrary/src/main/java/com/yzq/zxinglibrary/android/FinishListener.java
new file mode 100644
index 0000000..4e09445
--- /dev/null
+++ b/zxinglibrary/src/main/java/com/yzq/zxinglibrary/android/FinishListener.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2010 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.yzq.zxinglibrary.android;
+
+import android.app.Activity;
+import android.content.DialogInterface;
+
+/**
+ * Simple listener used to exit the app in a few cases.
+ * 用于在少数情况下退出App的监听
+ *
+ * @author Sean Owen
+ */
+public final class FinishListener implements DialogInterface.OnClickListener, DialogInterface.OnCancelListener {
+
+ private final Activity activityToFinish;
+
+ public FinishListener(Activity activityToFinish) {
+ this.activityToFinish = activityToFinish;
+ }
+
+ @Override
+ public void onCancel(DialogInterface dialogInterface) {
+ run();
+ }
+
+ @Override
+ public void onClick(DialogInterface dialogInterface, int i) {
+ run();
+ }
+
+ private void run() {
+ activityToFinish.finish();
+ }
+
+}
diff --git a/zxinglibrary/src/main/java/com/yzq/zxinglibrary/android/InactivityTimer.java b/zxinglibrary/src/main/java/com/yzq/zxinglibrary/android/InactivityTimer.java
new file mode 100644
index 0000000..8efb0d7
--- /dev/null
+++ b/zxinglibrary/src/main/java/com/yzq/zxinglibrary/android/InactivityTimer.java
@@ -0,0 +1,136 @@
+/*
+ * Copyright (C) 2010 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.yzq.zxinglibrary.android;
+
+import android.annotation.SuppressLint;
+import android.app.Activity;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.os.AsyncTask;
+import android.os.BatteryManager;
+import android.util.Log;
+
+/**
+ *
+ * Finishes an activity after a period of inactivity if the device is on battery
+ * power. 如果设备使用电池供电，一段时间不活动之后结束activity
+ *
+ * 供电控制
+ */
+public final class InactivityTimer {
+
+ private static final String TAG = InactivityTimer.class.getSimpleName();
+
+ private static final long INACTIVITY_DELAY_MS = 5 * 60 * 1000L;
+
+ private final Activity activity;
+ private final BroadcastReceiver powerStatusReceiver;
+ private boolean registered;
+ private AsyncTask inactivityTask;
+
+ public InactivityTimer(Activity activity) {
+ this.activity = activity;
+ powerStatusReceiver = new PowerStatusReceiver();
+ registered = false;
+ onActivity();
+ }
+
+ @SuppressLint("NewApi")
+ public
+ synchronized void onActivity() {
+ cancel();
+ inactivityTask = new InactivityAsyncTask();
+ inactivityTask.execute();
+ }
+
+ public synchronized void onPause() {
+ cancel();
+ if (registered) {
+ activity.unregisterReceiver(powerStatusReceiver);
+ registered = false;
+ } else {
+ Log.w(TAG, "PowerStatusReceiver was never registered?");
+ }
+ }
+
+ public synchronized void onResume() {
+ if (registered) {
+ Log.w(TAG, "PowerStatusReceiver was already registered?");
+ } else {
+ activity.registerReceiver(powerStatusReceiver, new IntentFilter(
+ Intent.ACTION_BATTERY_CHANGED));
+ registered = true;
+ }
+ onActivity();
+ }
+
+ private synchronized void cancel() {
+ AsyncTask task = inactivityTask;
+ if (task != null) {
+ task.cancel(true);
+ inactivityTask = null;
+ }
+ }
+
+ public void shutdown() {
+ cancel();
+ }
+
+ /**
+ * 电量状态receiver
+ * @author qichunjie
+ *
+ */
+ private final class PowerStatusReceiver extends BroadcastReceiver {
+ @Override
+ public void onReceive(Context context, Intent intent) {
+ if (Intent.ACTION_BATTERY_CHANGED.equals(intent.getAction())) {
+ // 0 indicates that we're on battery
+ boolean onBatteryNow = intent.getIntExtra(
+ BatteryManager.EXTRA_PLUGGED, -1) <= 0;
+ if (onBatteryNow) {
+ InactivityTimer.this.onActivity();
+ } else {
+ InactivityTimer.this.cancel();
+ }
+ }
+ }
+ }
+
+ /**
+ * 设备休眠5分钟，关闭activity
+ * @author qichunjie
+ *
+ */
+ private final class InactivityAsyncTask extends
+ AsyncTask {
+ @Override
+ protected Object doInBackground(Object... objects) {
+ try {
+ Thread.sleep(INACTIVITY_DELAY_MS);
+ Log.i(TAG, "Finishing activity due to inactivity");
+ activity.finish();
+ } catch (InterruptedException e) {
+ // continue without killing
+ }
+ return null;
+ }
+ }
+
+}
diff --git a/zxinglibrary/src/main/java/com/yzq/zxinglibrary/android/IntentSource.java b/zxinglibrary/src/main/java/com/yzq/zxinglibrary/android/IntentSource.java
new file mode 100644
index 0000000..7dc5a7b
--- /dev/null
+++ b/zxinglibrary/src/main/java/com/yzq/zxinglibrary/android/IntentSource.java
@@ -0,0 +1,10 @@
+package com.yzq.zxinglibrary.android;
+
+public enum IntentSource {
+
+ NATIVE_APP_INTENT,
+ PRODUCT_SEARCH_LINK,
+ ZXING_LINK,
+ NONE
+
+}
diff --git a/zxinglibrary/src/main/java/com/yzq/zxinglibrary/android/Intents.java b/zxinglibrary/src/main/java/com/yzq/zxinglibrary/android/Intents.java
new file mode 100644
index 0000000..ca3673b
--- /dev/null
+++ b/zxinglibrary/src/main/java/com/yzq/zxinglibrary/android/Intents.java
@@ -0,0 +1,278 @@
+/*
+ * Copyright (C) 2008 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.yzq.zxinglibrary.android;
+
+/**
+ * This class provides the constants to use when sending an Intent to Barcode Scanner.
+ * These strings are effectively API and cannot be changed.
+ *
+ * @author dswitkin@google.com (Daniel Switkin)
+ */
+public final class Intents {
+ private Intents() {
+ }
+
+ public static final class Scan {
+ /**
+ * Send this intent to open the Barcodes app in scanning mode, find a barcode, and return
+ * the results.
+ */
+ public static final String ACTION = "com.google.zxing.client.android.SCAN";
+
+ /**
+ * By default, sending this will decode all barcodes that we understand. However it
+ * may be useful to limit scanning to certain formats. Use
+ * {@link android.content.Intent#putExtra(String, String)} with one of the values below.
+ *
+ * Setting this is effectively shorthand for setting explicit formats with {@link #FORMATS}.
+ * It is overridden by that setting.
+ */
+ public static final String MODE = "SCAN_MODE";
+
+ /**
+ * Decode only UPC and EAN barcodes. This is the right choice for shopping apps which get
+ * prices, reviews, etc. for products.
+ */
+ public static final String PRODUCT_MODE = "PRODUCT_MODE";
+
+ /**
+ * Decode only 1D barcodes.
+ */
+ public static final String ONE_D_MODE = "ONE_D_MODE";
+
+ /**
+ * Decode only QR codes.
+ */
+ public static final String QR_CODE_MODE = "QR_CODE_MODE";
+
+ /**
+ * Decode only Data Matrix codes.
+ */
+ public static final String DATA_MATRIX_MODE = "DATA_MATRIX_MODE";
+
+ /**
+ * Decode only Aztec.
+ */
+ public static final String AZTEC_MODE = "AZTEC_MODE";
+
+ /**
+ * Decode only PDF417.
+ */
+ public static final String PDF417_MODE = "PDF417_MODE";
+
+ /**
+ * Comma-separated list of formats to scan for. The values must match the names of
+ * {@link com.google.zxing.BarcodeFormat}s, e.g. {@link com.google.zxing.BarcodeFormat#EAN_13}.
+ * Example: "EAN_13,EAN_8,QR_CODE". This overrides {@link #MODE}.
+ */
+ public static final String FORMATS = "SCAN_FORMATS";
+
+ /**
+ * Optional parameter to specify the id of the camera from which to recognize barcodes.
+ * Overrides the default camera that would otherwise would have been selected.
+ * If provided, should be an int.
+ */
+ public static final String CAMERA_ID = "SCAN_CAMERA_ID";
+
+ /**
+ * @see com.google.zxing.DecodeHintType#CHARACTER_SET
+ */
+ public static final String CHARACTER_SET = "CHARACTER_SET";
+
+ /**
+ * Optional parameters to specify the width and height of the scanning rectangle in pixels.
+ * The app will try to honor these, but will clamp them to the size of the preview frame.
+ * You should specify both or neither, and pass the size as an int.
+ */
+ public static final String WIDTH = "SCAN_WIDTH";
+ public static final String HEIGHT = "SCAN_HEIGHT";
+
+ /**
+ * Desired duration in milliseconds for which to pause after a successful scan before
+ * returning to the calling intent. Specified as a long, not an integer!
+ * For example: 1000L, not 1000.
+ */
+ public static final String RESULT_DISPLAY_DURATION_MS = "RESULT_DISPLAY_DURATION_MS";
+
+ /**
+ * Prompt to show on-screen when scanning by intent. Specified as a {@link String}.
+ */
+ public static final String PROMPT_MESSAGE = "PROMPT_MESSAGE";
+
+ /**
+ * If a barcode is found, Barcodes returns {@link android.app.Activity#RESULT_OK} to
+ * {@link android.app.Activity#onActivityResult(int, int, android.content.Intent)}
+ * of the app which requested the scan via
+ * {@link android.app.Activity#startActivityForResult(android.content.Intent, int)}
+ * The barcodes contents can be retrieved with
+ * {@link android.content.Intent#getStringExtra(String)}.
+ * If the user presses Back, the result code will be {@link android.app.Activity#RESULT_CANCELED}.
+ */
+ public static final String RESULT = "SCAN_RESULT";
+
+ /**
+ * Call {@link android.content.Intent#getStringExtra(String)} with {@link #RESULT_FORMAT}
+ * to determine which barcode format was found.
+ * See {@link com.google.zxing.BarcodeFormat} for possible values.
+ */
+ public static final String RESULT_FORMAT = "SCAN_RESULT_FORMAT";
+
+ /**
+ * Call {@link android.content.Intent#getStringExtra(String)} with {@link #RESULT_UPC_EAN_EXTENSION}
+ * to return the content of any UPC extension barcode that was also found. Only applicable
+ * to {@link com.google.zxing.BarcodeFormat#UPC_A} and {@link com.google.zxing.BarcodeFormat#EAN_13}
+ * formats.
+ */
+ public static final String RESULT_UPC_EAN_EXTENSION = "SCAN_RESULT_UPC_EAN_EXTENSION";
+
+ /**
+ * Call {@link android.content.Intent#getByteArrayExtra(String)} with {@link #RESULT_BYTES}
+ * to get a {@code byte[]} of raw bytes in the barcode, if available.
+ */
+ public static final String RESULT_BYTES = "SCAN_RESULT_BYTES";
+
+ /**
+ * Key for the value of {@link com.google.zxing.ResultMetadataType#ORIENTATION}, if available.
+ * Call {@link android.content.Intent#getIntArrayExtra(String)} with {@link #RESULT_ORIENTATION}.
+ */
+ public static final String RESULT_ORIENTATION = "SCAN_RESULT_ORIENTATION";
+
+ /**
+ * Key for the value of {@link com.google.zxing.ResultMetadataType#ERROR_CORRECTION_LEVEL}, if available.
+ * Call {@link android.content.Intent#getStringExtra(String)} with {@link #RESULT_ERROR_CORRECTION_LEVEL}.
+ */
+ public static final String RESULT_ERROR_CORRECTION_LEVEL = "SCAN_RESULT_ERROR_CORRECTION_LEVEL";
+
+ /**
+ * Prefix for keys that map to the values of {@link com.google.zxing.ResultMetadataType#BYTE_SEGMENTS},
+ * if available. The actual values will be set under a series of keys formed by adding 0, 1, 2, ...
+ * to this prefix. So the first byte segment is under key "SCAN_RESULT_BYTE_SEGMENTS_0" for example.
+ * Call {@link android.content.Intent#getByteArrayExtra(String)} with these keys.
+ */
+ public static final String RESULT_BYTE_SEGMENTS_PREFIX = "SCAN_RESULT_BYTE_SEGMENTS_";
+
+ /**
+ * Setting this to false will not save scanned codes in the history. Specified as a {@code boolean}.
+ */
+ public static final String SAVE_HISTORY = "SAVE_HISTORY";
+
+ private Scan() {
+ }
+ }
+
+ public static final class History {
+
+ public static final String ITEM_NUMBER = "ITEM_NUMBER";
+
+ private History() {
+ }
+ }
+
+ public static final class Encode {
+ /**
+ * Send this intent to encode a piece of data as a QR code and display it full screen, so
+ * that another person can scan the barcode from your screen.
+ */
+ public static final String ACTION = "com.google.zxing.client.android.ENCODE";
+
+ /**
+ * The data to encode. Use {@link android.content.Intent#putExtra(String, String)} or
+ * {@link android.content.Intent#putExtra(String, android.os.Bundle)},
+ * depending on the type and format specified. Non-QR Code formats should
+ * just use a String here. For QR Code, see Contents for details.
+ */
+ public static final String DATA = "ENCODE_DATA";
+
+ /**
+ * The type of data being supplied if the format is QR Code. Use
+ * {@link android.content.Intent#putExtra(String, String)} with one of {@link Contents.Type}.
+ */
+ public static final String TYPE = "ENCODE_TYPE";
+
+ /**
+ * The barcode format to be displayed. If this isn't specified or is blank,
+ * it defaults to QR Code. Use {@link android.content.Intent#putExtra(String, String)}, where
+ * format is one of {@link com.google.zxing.BarcodeFormat}.
+ */
+ public static final String FORMAT = "ENCODE_FORMAT";
+
+ /**
+ * Normally the contents of the barcode are displayed to the user in a TextView. Setting this
+ * boolean to false will hide that TextView, showing only the encode barcode.
+ */
+ public static final String SHOW_CONTENTS = "ENCODE_SHOW_CONTENTS";
+
+ private Encode() {
+ }
+ }
+
+ public static final class SearchBookContents {
+ /**
+ * Use Google Book Search to search the contents of the book provided.
+ */
+ public static final String ACTION = "com.google.zxing.client.android.SEARCH_BOOK_CONTENTS";
+
+ /**
+ * The book to search, identified by ISBN number.
+ */
+ public static final String ISBN = "ISBN";
+
+ /**
+ * An optional field which is the text to search for.
+ */
+ public static final String QUERY = "QUERY";
+
+ private SearchBookContents() {
+ }
+ }
+
+ public static final class WifiConnect {
+ /**
+ * Internal intent used to trigger connection to a wi-fi network.
+ */
+ public static final String ACTION = "com.google.zxing.client.android.WIFI_CONNECT";
+
+ /**
+ * The network to connect to, all the configuration provided here.
+ */
+ public static final String SSID = "SSID";
+
+ /**
+ * The network to connect to, all the configuration provided here.
+ */
+ public static final String TYPE = "TYPE";
+
+ /**
+ * The network to connect to, all the configuration provided here.
+ */
+ public static final String PASSWORD = "PASSWORD";
+
+ private WifiConnect() {
+ }
+ }
+
+ public static final class Share {
+ /**
+ * Give the user a choice of items to encode as a barcode, then render it as a QR Code and
+ * display onscreen for a friend to scan with their phone.
+ */
+ public static final String ACTION = "com.google.zxing.client.android.SHARE";
+
+ private Share() {
+ }
+ }
+}
diff --git a/zxinglibrary/src/main/java/com/yzq/zxinglibrary/android/PreferencesActivity.java b/zxinglibrary/src/main/java/com/yzq/zxinglibrary/android/PreferencesActivity.java
new file mode 100644
index 0000000..0260d6d
--- /dev/null
+++ b/zxinglibrary/src/main/java/com/yzq/zxinglibrary/android/PreferencesActivity.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2008 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.yzq.zxinglibrary.android;
+
+import android.app.Activity;
+
+/**
+ * The main settings activity.
+ * 设置相关的常量
+ *
+ * @author dswitkin@google.com (Daniel Switkin)
+ * @author Sean Owen
+ */
+public final class PreferencesActivity extends Activity {
+
+ public static final String KEY_DECODE_1D_PRODUCT = "preferences_decode_1D_product";
+ public static final String KEY_DECODE_1D_INDUSTRIAL = "preferences_decode_1D_industrial";
+ public static final String KEY_DECODE_QR = "preferences_decode_QR";
+ public static final String KEY_DECODE_DATA_MATRIX = "preferences_decode_Data_Matrix";
+ public static final String KEY_DECODE_AZTEC = "preferences_decode_Aztec";
+ public static final String KEY_DECODE_PDF417 = "preferences_decode_PDF417";
+
+ public static final String KEY_CUSTOM_PRODUCT_SEARCH = "preferences_custom_product_search";
+
+ public static final String KEY_PLAY_BEEP = "preferences_play_beep";
+ public static final String KEY_VIBRATE = "preferences_vibrate";
+ public static final String KEY_COPY_TO_CLIPBOARD = "preferences_copy_to_clipboard";
+ public static final String KEY_FRONT_LIGHT_MODE = "preferences_front_light_mode";
+ public static final String KEY_BULK_MODE = "preferences_bulk_mode";
+ public static final String KEY_REMEMBER_DUPLICATES = "preferences_remember_duplicates";
+ public static final String KEY_SUPPLEMENTAL = "preferences_supplemental";
+ public static final String KEY_AUTO_FOCUS = "preferences_auto_focus";
+ public static final String KEY_INVERT_SCAN = "preferences_invert_scan";
+ public static final String KEY_SEARCH_COUNTRY = "preferences_search_country";
+ public static final String KEY_DISABLE_AUTO_ORIENTATION = "preferences_orientation";
+
+ public static final String KEY_DISABLE_CONTINUOUS_FOCUS = "preferences_disable_continuous_focus";
+ public static final String KEY_DISABLE_EXPOSURE = "preferences_disable_exposure";
+ public static final String KEY_DISABLE_METERING = "preferences_disable_metering";
+ public static final String KEY_DISABLE_BARCODE_SCENE_MODE = "preferences_disable_barcode_scene_mode";
+ public static final String KEY_AUTO_OPEN_WEB = "preferences_auto_open_web";
+
+}
diff --git a/zxinglibrary/src/main/java/com/yzq/zxinglibrary/camera/AutoFocusManager.java b/zxinglibrary/src/main/java/com/yzq/zxinglibrary/camera/AutoFocusManager.java
new file mode 100644
index 0000000..c9fb2ba
--- /dev/null
+++ b/zxinglibrary/src/main/java/com/yzq/zxinglibrary/camera/AutoFocusManager.java
@@ -0,0 +1,141 @@
+/*
+ * Copyright (C) 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.yzq.zxinglibrary.camera;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.hardware.Camera;
+import android.os.AsyncTask;
+import android.preference.PreferenceManager;
+import android.util.Log;
+
+
+import com.yzq.zxinglibrary.android.PreferencesActivity;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.concurrent.RejectedExecutionException;
+
+
+/**
+ * 自动聚焦
+ * @author qichunjie
+ *
+ */
+final class AutoFocusManager implements Camera.AutoFocusCallback {
+
+ private static final String TAG = AutoFocusManager.class.getSimpleName();
+
+ private static final long AUTO_FOCUS_INTERVAL_MS = 2000L;
+ private static final Collection FOCUS_MODES_CALLING_AF;
+ static {
+ FOCUS_MODES_CALLING_AF = new ArrayList(2);
+ FOCUS_MODES_CALLING_AF.add(Camera.Parameters.FOCUS_MODE_AUTO);
+ FOCUS_MODES_CALLING_AF.add(Camera.Parameters.FOCUS_MODE_MACRO);
+ }
+
+ private boolean stopped;
+ private boolean focusing;
+ private final boolean useAutoFocus;
+ private final Camera camera;
+ private AsyncTask outstandingTask;
+
+ AutoFocusManager(Context context, Camera camera) {
+ this.camera = camera;
+ SharedPreferences sharedPrefs = PreferenceManager.getDefaultSharedPreferences(context);
+ String currentFocusMode = camera.getParameters().getFocusMode();
+ useAutoFocus =
+ sharedPrefs.getBoolean(PreferencesActivity.KEY_AUTO_FOCUS, true) &&
+ FOCUS_MODES_CALLING_AF.contains(currentFocusMode);
+ Log.i(TAG, "Current focus mode '" + currentFocusMode + "'; use auto focus? " + useAutoFocus);
+ start();
+ }
+
+ @Override
+ public synchronized void onAutoFocus(boolean success, Camera theCamera) {
+ focusing = false;
+ autoFocusAgainLater();
+ }
+
+ @SuppressLint("NewApi")
+private synchronized void autoFocusAgainLater() {
+ if (!stopped && outstandingTask == null) {
+ AutoFocusTask newTask = new AutoFocusTask();
+ try {
+ newTask.execute();
+ outstandingTask = newTask;
+ } catch (RejectedExecutionException ree) {
+ Log.w(TAG, "Could not request auto focus", ree);
+ }
+ }
+ }
+
+ synchronized void start() {
+ if (useAutoFocus) {
+ outstandingTask = null;
+ if (!stopped && !focusing) {
+ try {
+ camera.autoFocus(this);
+ focusing = true;
+ } catch (RuntimeException re) {
+ // Have heard RuntimeException reported in Android 4.0.x+; continue?
+ Log.w(TAG, "Unexpected exception while focusing", re);
+ // Try again later to keep cycle going
+ autoFocusAgainLater();
+ }
+ }
+ }
+ }
+
+ private synchronized void cancelOutstandingTask() {
+ if (outstandingTask != null) {
+ if (outstandingTask.getStatus() != AsyncTask.Status.FINISHED) {
+ outstandingTask.cancel(true);
+ }
+ outstandingTask = null;
+ }
+ }
+
+ synchronized void stop() {
+ stopped = true;
+ if (useAutoFocus) {
+ cancelOutstandingTask();
+ // Doesn't hurt to call this even if not focusing
+ try {
+ camera.cancelAutoFocus();
+ } catch (RuntimeException re) {
+ // Have heard RuntimeException reported in Android 4.0.x+; continue?
+ Log.w(TAG, "Unexpected exception while cancelling focusing", re);
+ }
+ }
+ }
+
+ private final class AutoFocusTask extends AsyncTask {
+ @Override
+ protected Object doInBackground(Object... voids) {
+ try {
+ Thread.sleep(AUTO_FOCUS_INTERVAL_MS);
+ } catch (InterruptedException e) {
+ // continue
+ }
+ start();
+ return null;
+ }
+ }
+
+}
diff --git a/zxinglibrary/src/main/java/com/yzq/zxinglibrary/camera/CameraConfigurationManager.java b/zxinglibrary/src/main/java/com/yzq/zxinglibrary/camera/CameraConfigurationManager.java
new file mode 100644
index 0000000..e95c206
--- /dev/null
+++ b/zxinglibrary/src/main/java/com/yzq/zxinglibrary/camera/CameraConfigurationManager.java
@@ -0,0 +1,145 @@
+/*
+ * Copyright (C) 2010 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.yzq.zxinglibrary.camera;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.graphics.Point;
+import android.hardware.Camera;
+import android.preference.PreferenceManager;
+import android.util.Log;
+import android.view.Display;
+import android.view.WindowManager;
+
+import com.yzq.zxinglibrary.android.PreferencesActivity;
+
+import java.lang.reflect.Method;
+
+/**
+ * Camera参数配置
+ */
+final class CameraConfigurationManager {
+
+ private static final String TAG = "CameraConfiguration";
+
+ private final Context context;
+ private Point screenResolution;
+ private Point cameraResolution;
+
+ CameraConfigurationManager(Context context) {
+ this.context = context;
+ }
+
+ /**
+ * Reads, one time, values from the camera that are needed by the app.
+ */
+ @SuppressLint("NewApi")
+ void initFromCameraParameters(Camera camera) {
+ Camera.Parameters parameters = camera.getParameters();
+ WindowManager manager = (WindowManager) context
+ .getSystemService(Context.WINDOW_SERVICE);
+ Display display = manager.getDefaultDisplay();
+ Point theScreenResolution = new Point(display.getWidth(),
+ display.getHeight());
+ screenResolution = theScreenResolution;
+ Log.i(TAG, "Screen resolution: " + screenResolution);
+
+ /************** 竖屏更改4 ******************/
+ Point screenResolutionForCamera = new Point();
+ screenResolutionForCamera.x = screenResolution.x;
+ screenResolutionForCamera.y = screenResolution.y;
+
+ // preview size is always something like 480*320, other 320*480
+ if (screenResolution.x < screenResolution.y) {
+ screenResolutionForCamera.x = screenResolution.y;
+ screenResolutionForCamera.y = screenResolution.x;
+ }
+
+ cameraResolution = CameraConfigurationUtils.findBestPreviewSizeValue(
+ parameters, screenResolutionForCamera);
+ Log.i(TAG, "Camera resolution: " + cameraResolution);
+
+ }
+
+ void setDesiredCameraParameters(Camera camera, boolean safeMode) {
+ Camera.Parameters parameters = camera.getParameters();
+
+ if (parameters == null) {
+ Log.w(TAG,
+ "Device error: no camera parameters are available. Proceeding without configuration.");
+ return;
+ }
+
+ Log.i(TAG, "Initial camera parameters: " + parameters.flatten());
+
+ if (safeMode) {
+ Log.w(TAG,
+ "In camera config safe mode -- most settings will not be honored");
+ }
+
+ SharedPreferences prefs = PreferenceManager
+ .getDefaultSharedPreferences(context);
+
+ CameraConfigurationUtils.setFocus(parameters, prefs.getBoolean(
+ PreferencesActivity.KEY_AUTO_FOCUS, true), prefs.getBoolean(
+ PreferencesActivity.KEY_DISABLE_CONTINUOUS_FOCUS, true),
+ safeMode);
+
+ parameters.setPreviewSize(cameraResolution.x, cameraResolution.y);
+ /****************** 竖屏更改2 *********************/
+ setDisplayOrientation(camera, 90);
+
+ Log.i(TAG, "Final camera parameters: " + parameters.flatten());
+
+ camera.setParameters(parameters);
+
+ Camera.Parameters afterParameters = camera.getParameters();
+ Camera.Size afterSize = afterParameters.getPreviewSize();
+ if (afterSize != null
+ && (cameraResolution.x != afterSize.width || cameraResolution.y != afterSize.height)) {
+ Log.w(TAG, "Camera said it supported preview size "
+ + cameraResolution.x + 'x' + cameraResolution.y
+ + ", but after setting it, preview size is "
+ + afterSize.width + 'x' + afterSize.height);
+ cameraResolution.x = afterSize.width;
+ cameraResolution.y = afterSize.height;
+ }
+ }
+
+ void setDisplayOrientation(Camera camera, int angle) {
+
+ Method method;
+ try {
+ method = camera.getClass().getMethod("setDisplayOrientation",
+ new Class[] { int.class });
+ if (method != null)
+ method.invoke(camera, new Object[] { angle });
+ } catch (Exception e1) {
+ e1.printStackTrace();
+ }
+ }
+
+ Point getCameraResolution() {
+ return cameraResolution;
+ }
+
+ Point getScreenResolution() {
+ return screenResolution;
+ }
+
+}
diff --git a/zxinglibrary/src/main/java/com/yzq/zxinglibrary/camera/CameraConfigurationUtils.java b/zxinglibrary/src/main/java/com/yzq/zxinglibrary/camera/CameraConfigurationUtils.java
new file mode 100644
index 0000000..6d10ee8
--- /dev/null
+++ b/zxinglibrary/src/main/java/com/yzq/zxinglibrary/camera/CameraConfigurationUtils.java
@@ -0,0 +1,484 @@
+/*
+ * Copyright (C) 2014 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.yzq.zxinglibrary.camera;
+
+import android.annotation.SuppressLint;
+import android.graphics.Point;
+import android.hardware.Camera;
+import android.os.Build;
+import android.util.Log;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.List;
+import java.util.regex.Pattern;
+
+/**
+ * Utility methods for configuring the Android camera.
+ *
+ * @author Sean Owen
+ */
+public final class CameraConfigurationUtils {
+
+ private static final String TAG = "CameraConfiguration";
+
+ private static final Pattern SEMICOLON = Pattern.compile(";");
+
+ private static final int MIN_PREVIEW_PIXELS = 480 * 320; // normal screen
+ private static final float MAX_EXPOSURE_COMPENSATION = 1.5f;
+ private static final float MIN_EXPOSURE_COMPENSATION = 0.0f;
+ private static final double MAX_ASPECT_DISTORTION = 0.15;
+ private static final int MIN_FPS = 10;
+ private static final int MAX_FPS = 20;
+ private static final int AREA_PER_1000 = 400;
+
+ private CameraConfigurationUtils() {
+ }
+
+ public static void setFocus(Camera.Parameters parameters,
+ boolean autoFocus, boolean disableContinuous, boolean safeMode) {
+ List supportedFocusModes = parameters.getSupportedFocusModes();
+ String focusMode = null;
+ if (autoFocus) {
+ if (safeMode || disableContinuous) {
+ focusMode = findSettableValue("focus mode",
+ supportedFocusModes, Camera.Parameters.FOCUS_MODE_AUTO);
+ } else {
+ focusMode = findSettableValue("focus mode",
+ supportedFocusModes,
+ // Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE,
+ //低于4.0版本不支持，暂时注释掉
+ Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO,
+ Camera.Parameters.FOCUS_MODE_AUTO);
+ }
+ }
+ // Maybe selected auto-focus but not available, so fall through here:
+ if (!safeMode && focusMode == null) {
+ focusMode = findSettableValue("focus mode", supportedFocusModes,
+ Camera.Parameters.FOCUS_MODE_MACRO,
+ Camera.Parameters.FOCUS_MODE_EDOF);
+ }
+ if (focusMode != null) {
+ if (focusMode.equals(parameters.getFocusMode())) {
+ Log.i(TAG, "Focus mode already set to " + focusMode);
+ } else {
+ parameters.setFocusMode(focusMode);
+ }
+ }
+ }
+
+ public static void setTorch(Camera.Parameters parameters, boolean on) {
+ List supportedFlashModes = parameters.getSupportedFlashModes();
+ String flashMode;
+ if (on) {
+ flashMode = findSettableValue("flash mode", supportedFlashModes,
+ Camera.Parameters.FLASH_MODE_TORCH,
+ Camera.Parameters.FLASH_MODE_ON);
+ } else {
+ flashMode = findSettableValue("flash mode", supportedFlashModes,
+ Camera.Parameters.FLASH_MODE_OFF);
+ }
+ if (flashMode != null) {
+ if (flashMode.equals(parameters.getFlashMode())) {
+ Log.i(TAG, "Flash mode already set to " + flashMode);
+ } else {
+ Log.i(TAG, "Setting flash mode to " + flashMode);
+ parameters.setFlashMode(flashMode);
+ }
+ }
+ }
+
+ public static void setBestExposure(Camera.Parameters parameters,
+ boolean lightOn) {
+ int minExposure = parameters.getMinExposureCompensation();
+ int maxExposure = parameters.getMaxExposureCompensation();
+ float step = parameters.getExposureCompensationStep();
+ if ((minExposure != 0 || maxExposure != 0) && step > 0.0f) {
+ // Set low when light is on
+ float targetCompensation = lightOn ? MIN_EXPOSURE_COMPENSATION
+ : MAX_EXPOSURE_COMPENSATION;
+ int compensationSteps = Math.round(targetCompensation / step);
+ float actualCompensation = step * compensationSteps;
+ // Clamp value:
+ compensationSteps = Math.max(
+ Math.min(compensationSteps, maxExposure), minExposure);
+ if (parameters.getExposureCompensation() == compensationSteps) {
+ Log.i(TAG, "Exposure compensation already set to "
+ + compensationSteps + " / " + actualCompensation);
+ } else {
+ Log.i(TAG, "Setting exposure compensation to "
+ + compensationSteps + " / " + actualCompensation);
+ parameters.setExposureCompensation(compensationSteps);
+ }
+ } else {
+ Log.i(TAG, "Camera does not support exposure compensation");
+ }
+ }
+
+ public static void setBestPreviewFPS(Camera.Parameters parameters) {
+ setBestPreviewFPS(parameters, MIN_FPS, MAX_FPS);
+ }
+
+ @SuppressLint("NewApi")
+ public static void setBestPreviewFPS(Camera.Parameters parameters,
+ int minFPS, int maxFPS) {
+ List supportedPreviewFpsRanges = parameters
+ .getSupportedPreviewFpsRange();
+ Log.i(TAG, "Supported FPS ranges: "
+ + toString(supportedPreviewFpsRanges));
+ if (supportedPreviewFpsRanges != null
+ && !supportedPreviewFpsRanges.isEmpty()) {
+ int[] suitableFPSRange = null;
+ for (int[] fpsRange : supportedPreviewFpsRanges) {
+ int thisMin = fpsRange[Camera.Parameters.PREVIEW_FPS_MIN_INDEX];
+ int thisMax = fpsRange[Camera.Parameters.PREVIEW_FPS_MAX_INDEX];
+ if (thisMin >= minFPS * 1000 && thisMax <= maxFPS * 1000) {
+ suitableFPSRange = fpsRange;
+ break;
+ }
+ }
+ if (suitableFPSRange == null) {
+ Log.i(TAG, "No suitable FPS range?");
+ } else {
+ int[] currentFpsRange = new int[2];
+ parameters.getPreviewFpsRange(currentFpsRange);
+ if (Arrays.equals(currentFpsRange, suitableFPSRange)) {
+ Log.i(TAG,
+ "FPS range already set to "
+ + Arrays.toString(suitableFPSRange));
+ } else {
+ Log.i(TAG,
+ "Setting FPS range to "
+ + Arrays.toString(suitableFPSRange));
+ parameters
+ .setPreviewFpsRange(
+ suitableFPSRange[Camera.Parameters.PREVIEW_FPS_MIN_INDEX],
+ suitableFPSRange[Camera.Parameters.PREVIEW_FPS_MAX_INDEX]);
+ }
+ }
+ }
+ }
+
+// public static void setFocusArea(Camera.Parameters parameters) {
+// if (parameters.getMaxNumFocusAreas() > 0) {
+// Log.i(TAG,
+// "Old focus areas: " + toString(parameters.getFocusAreas()));
+// List middleArea = buildMiddleArea(AREA_PER_1000);
+// Log.i(TAG, "Setting focus area to : " + toString(middleArea));
+// parameters.setFocusAreas(middleArea);
+// } else {
+// Log.i(TAG, "Device does not support focus areas");
+// }
+// }
+//
+// public static void setMetering(Camera.Parameters parameters) {
+// if (parameters.getMaxNumMeteringAreas() > 0) {
+// Log.i(TAG, "Old metering areas: " + parameters.getMeteringAreas());
+// List middleArea = buildMiddleArea(AREA_PER_1000);
+// Log.i(TAG, "Setting metering area to : " + toString(middleArea));
+// parameters.setMeteringAreas(middleArea);
+// } else {
+// Log.i(TAG, "Device does not support metering areas");
+// }
+// }
+//
+// private static List buildMiddleArea(int areaPer1000) {
+// return Collections.singletonList(new Camera.Area(new Rect(-areaPer1000,
+// -areaPer1000, areaPer1000, areaPer1000), 1));
+// }
+//
+// public static void setVideoStabilization(Camera.Parameters parameters) {
+// if (parameters.isVideoStabilizationSupported()) {
+// if (parameters.getVideoStabilization()) {
+// Log.i(TAG, "Video stabilization already enabled");
+// } else {
+// Log.i(TAG, "Enabling video stabilization...");
+// parameters.setVideoStabilization(true);
+// }
+// } else {
+// Log.i(TAG, "This device does not support video stabilization");
+// }
+// }
+
+ public static void setBarcodeSceneMode(Camera.Parameters parameters) {
+ if (Camera.Parameters.SCENE_MODE_BARCODE.equals(parameters
+ .getSceneMode())) {
+ Log.i(TAG, "Barcode scene mode already set");
+ return;
+ }
+ String sceneMode = findSettableValue("scene mode",
+ parameters.getSupportedSceneModes(),
+ Camera.Parameters.SCENE_MODE_BARCODE);
+ if (sceneMode != null) {
+ parameters.setSceneMode(sceneMode);
+ }
+ }
+
+ public static void setZoom(Camera.Parameters parameters,
+ double targetZoomRatio) {
+ if (parameters.isZoomSupported()) {
+ Integer zoom = indexOfClosestZoom(parameters, targetZoomRatio);
+ if (zoom == null) {
+ return;
+ }
+ if (parameters.getZoom() == zoom) {
+ Log.i(TAG, "Zoom is already set to " + zoom);
+ } else {
+ Log.i(TAG, "Setting zoom to " + zoom);
+ parameters.setZoom(zoom);
+ }
+ } else {
+ Log.i(TAG, "Zoom is not supported");
+ }
+ }
+
+ private static Integer indexOfClosestZoom(Camera.Parameters parameters,
+ double targetZoomRatio) {
+ List ratios = parameters.getZoomRatios();
+ Log.i(TAG, "Zoom ratios: " + ratios);
+ int maxZoom = parameters.getMaxZoom();
+ if (ratios == null || ratios.isEmpty() || ratios.size() != maxZoom + 1) {
+ Log.w(TAG, "Invalid zoom ratios!");
+ return null;
+ }
+ double target100 = 100.0 * targetZoomRatio;
+ double smallestDiff = Double.POSITIVE_INFINITY;
+ int closestIndex = 0;
+ for (int i = 0; i < ratios.size(); i++) {
+ double diff = Math.abs(ratios.get(i) - target100);
+ if (diff < smallestDiff) {
+ smallestDiff = diff;
+ closestIndex = i;
+ }
+ }
+ Log.i(TAG, "Chose zoom ratio of " + (ratios.get(closestIndex) / 100.0));
+ return closestIndex;
+ }
+
+ public static void setInvertColor(Camera.Parameters parameters) {
+ if (Camera.Parameters.EFFECT_NEGATIVE.equals(parameters
+ .getColorEffect())) {
+ Log.i(TAG, "Negative effect already set");
+ return;
+ }
+ String colorMode = findSettableValue("color effect",
+ parameters.getSupportedColorEffects(),
+ Camera.Parameters.EFFECT_NEGATIVE);
+ if (colorMode != null) {
+ parameters.setColorEffect(colorMode);
+ }
+ }
+
+ public static Point findBestPreviewSizeValue(Camera.Parameters parameters,
+ Point screenResolution) {
+
+ List rawSupportedSizes = parameters
+ .getSupportedPreviewSizes();
+ if (rawSupportedSizes == null) {
+ Log.w(TAG,
+ "Device returned no supported preview sizes; using default");
+ Camera.Size defaultSize = parameters.getPreviewSize();
+ if (defaultSize == null) {
+ throw new IllegalStateException(
+ "Parameters contained no preview size!");
+ }
+ return new Point(defaultSize.width, defaultSize.height);
+ }
+
+ // Sort by size, descending
+ List supportedPreviewSizes = new ArrayList(
+ rawSupportedSizes);
+ Collections.sort(supportedPreviewSizes, new Comparator() {
+ @Override
+ public int compare(Camera.Size a, Camera.Size b) {
+ int aPixels = a.height * a.width;
+ int bPixels = b.height * b.width;
+ if (bPixels < aPixels) {
+ return -1;
+ }
+ if (bPixels > aPixels) {
+ return 1;
+ }
+ return 0;
+ }
+ });
+
+ if (Log.isLoggable(TAG, Log.INFO)) {
+ StringBuilder previewSizesString = new StringBuilder();
+ for (Camera.Size supportedPreviewSize : supportedPreviewSizes) {
+ previewSizesString.append(supportedPreviewSize.width)
+ .append('x').append(supportedPreviewSize.height)
+ .append(' ');
+ }
+ Log.i(TAG, "Supported preview sizes: " + previewSizesString);
+ }
+
+ double screenAspectRatio = (double) screenResolution.x
+ / (double) screenResolution.y;
+
+ // Remove sizes that are unsuitable
+ Iterator it = supportedPreviewSizes.iterator();
+ while (it.hasNext()) {
+ Camera.Size supportedPreviewSize = it.next();
+ int realWidth = supportedPreviewSize.width;
+ int realHeight = supportedPreviewSize.height;
+ if (realWidth * realHeight < MIN_PREVIEW_PIXELS) {
+ it.remove();
+ continue;
+ }
+
+ boolean isCandidatePortrait = realWidth < realHeight;
+ int maybeFlippedWidth = isCandidatePortrait ? realHeight
+ : realWidth;
+ int maybeFlippedHeight = isCandidatePortrait ? realWidth
+ : realHeight;
+ double aspectRatio = (double) maybeFlippedWidth
+ / (double) maybeFlippedHeight;
+ double distortion = Math.abs(aspectRatio - screenAspectRatio);
+ if (distortion > MAX_ASPECT_DISTORTION) {
+ it.remove();
+ continue;
+ }
+
+ if (maybeFlippedWidth == screenResolution.x
+ && maybeFlippedHeight == screenResolution.y) {
+ Point exactPoint = new Point(realWidth, realHeight);
+ Log.i(TAG, "Found preview size exactly matching screen size: "
+ + exactPoint);
+ return exactPoint;
+ }
+ }
+
+ // If no exact match, use largest preview size. This was not a great
+ // idea on older devices because
+ // of the additional computation needed. We're likely to get here on
+ // newer Android 4+ devices, where
+ // the CPU is much more powerful.
+ if (!supportedPreviewSizes.isEmpty()) {
+ Camera.Size largestPreview = supportedPreviewSizes.get(0);
+ Point largestSize = new Point(largestPreview.width,
+ largestPreview.height);
+ Log.i(TAG, "Using largest suitable preview size: " + largestSize);
+ return largestSize;
+ }
+
+ // If there is nothing at all suitable, return current preview size
+ Camera.Size defaultPreview = parameters.getPreviewSize();
+ if (defaultPreview == null) {
+ throw new IllegalStateException(
+ "Parameters contained no preview size!");
+ }
+ Point defaultSize = new Point(defaultPreview.width,
+ defaultPreview.height);
+ Log.i(TAG, "No suitable preview sizes, using default: " + defaultSize);
+ return defaultSize;
+ }
+
+ private static String findSettableValue(String name,
+ Collection supportedValues, String... desiredValues) {
+ Log.i(TAG,
+ "Requesting " + name + " value from among: "
+ + Arrays.toString(desiredValues));
+ Log.i(TAG, "Supported " + name + " values: " + supportedValues);
+ if (supportedValues != null) {
+ for (String desiredValue : desiredValues) {
+ if (supportedValues.contains(desiredValue)) {
+ Log.i(TAG, "Can set " + name + " to: " + desiredValue);
+ return desiredValue;
+ }
+ }
+ }
+ Log.i(TAG, "No supported values match");
+ return null;
+ }
+
+ private static String toString(Collection arrays) {
+ if (arrays == null || arrays.isEmpty()) {
+ return "[]";
+ }
+ StringBuilder buffer = new StringBuilder();
+ buffer.append('[');
+ Iterator it = arrays.iterator();
+ while (it.hasNext()) {
+ buffer.append(Arrays.toString(it.next()));
+ if (it.hasNext()) {
+ buffer.append(", ");
+ }
+ }
+ buffer.append(']');
+ return buffer.toString();
+ }
+
+// private static String toString(Iterable areas) {
+// if (areas == null) {
+// return null;
+// }
+// StringBuilder result = new StringBuilder();
+// for (Camera.Area area : areas) {
+// result.append(area.rect).append(':').append(area.weight)
+// .append(' ');
+// }
+// return result.toString();
+// }
+
+ public static String collectStats(Camera.Parameters parameters) {
+ return collectStats(parameters.flatten());
+ }
+
+ public static String collectStats(CharSequence flattenedParams) {
+ StringBuilder result = new StringBuilder(1000);
+
+ result.append("BOARD=").append(Build.BOARD).append('\n');
+ result.append("BRAND=").append(Build.BRAND).append('\n');
+ result.append("CPU_ABI=").append(Build.CPU_ABI).append('\n');
+ result.append("DEVICE=").append(Build.DEVICE).append('\n');
+ result.append("DISPLAY=").append(Build.DISPLAY).append('\n');
+ result.append("FINGERPRINT=").append(Build.FINGERPRINT).append('\n');
+ result.append("HOST=").append(Build.HOST).append('\n');
+ result.append("ID=").append(Build.ID).append('\n');
+ result.append("MANUFACTURER=").append(Build.MANUFACTURER).append('\n');
+ result.append("MODEL=").append(Build.MODEL).append('\n');
+ result.append("PRODUCT=").append(Build.PRODUCT).append('\n');
+ result.append("TAGS=").append(Build.TAGS).append('\n');
+ result.append("TIME=").append(Build.TIME).append('\n');
+ result.append("TYPE=").append(Build.TYPE).append('\n');
+ result.append("USER=").append(Build.USER).append('\n');
+ result.append("VERSION.CODENAME=").append(Build.VERSION.CODENAME)
+ .append('\n');
+ result.append("VERSION.INCREMENTAL=").append(Build.VERSION.INCREMENTAL)
+ .append('\n');
+ result.append("VERSION.RELEASE=").append(Build.VERSION.RELEASE)
+ .append('\n');
+ result.append("VERSION.SDK_INT=").append(Build.VERSION.SDK_INT)
+ .append('\n');
+
+ if (flattenedParams != null) {
+ String[] params = SEMICOLON.split(flattenedParams);
+ Arrays.sort(params);
+ for (String param : params) {
+ result.append(param).append('\n');
+ }
+ }
+
+ return result.toString();
+ }
+
+}
diff --git a/zxinglibrary/src/main/java/com/yzq/zxinglibrary/camera/CameraManager.java b/zxinglibrary/src/main/java/com/yzq/zxinglibrary/camera/CameraManager.java
new file mode 100644
index 0000000..bdfd471
--- /dev/null
+++ b/zxinglibrary/src/main/java/com/yzq/zxinglibrary/camera/CameraManager.java
@@ -0,0 +1,337 @@
+/*
+ * Copyright (C) 2008 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.yzq.zxinglibrary.camera;
+
+import android.content.Context;
+import android.graphics.Point;
+import android.graphics.Rect;
+import android.hardware.Camera;
+import android.os.Handler;
+import android.util.Log;
+import android.view.SurfaceHolder;
+
+import com.google.zxing.PlanarYUVLuminanceSource;
+
+import java.io.IOException;
+
+/**
+ * This object wraps the Camera service object and expects to be the only one
+ * talking to it. The implementation encapsulates the steps needed to take
+ * preview-sized images, which are used for both preview and decoding.
+ *
+ * @author dswitkin@google.com (Daniel Switkin)
+ */
+public final class CameraManager {
+
+ private static final String TAG = CameraManager.class.getSimpleName();
+
+ private static final int MIN_FRAME_WIDTH= 240;//取景框的最小宽度
+ private static final int MIN_FRAME_HEIGHT = 240;//取景框的最小高度
+ private static final int MAX_FRAME_WIDTH = 675; // 取景框的最大宽度
+ private static final int MAX_FRAME_HEIGHT = 675; // 取景框的最大高度
+
+ private final Context context;
+ private final CameraConfigurationManager configManager;
+ private Camera camera;
+ private AutoFocusManager autoFocusManager;
+ private Rect framingRect;
+ private Rect framingRectInPreview;
+ private boolean initialized;
+ private boolean previewing;
+ private int requestedCameraId = -1;
+ private int requestedFramingRectWidth;
+ private int requestedFramingRectHeight;
+ /**
+ * Preview frames are delivered here, which we pass on to the registered
+ * handler. Make sure to clear the handler so it will only receive one
+ * message.
+ */
+ private final PreviewCallback previewCallback;
+
+ public CameraManager(Context context) {
+ this.context = context;
+ this.configManager = new CameraConfigurationManager(context);
+ previewCallback = new PreviewCallback(configManager);
+ }
+
+ /**
+ * Opens the camera driver and initializes the hardware parameters.
+ *
+ * @param holder The surface object which the camera will draw preview frames
+ * into.
+ * @throws IOException Indicates the camera driver failed to open.
+ */
+ public synchronized void openDriver(SurfaceHolder holder)
+ throws IOException {
+ Camera theCamera = camera;
+ if (theCamera == null) {
+
+ if (requestedCameraId >= 0) {
+ theCamera = OpenCameraInterface.open(requestedCameraId);
+ } else {
+ theCamera = OpenCameraInterface.open();
+ }
+
+ if (theCamera == null) {
+ throw new IOException();
+ }
+ camera = theCamera;
+ }
+ theCamera.setPreviewDisplay(holder);
+
+ if (!initialized) {
+ initialized = true;
+ configManager.initFromCameraParameters(theCamera);
+ if (requestedFramingRectWidth > 0 && requestedFramingRectHeight > 0) {
+ setManualFramingRect(requestedFramingRectWidth,
+ requestedFramingRectHeight);
+ requestedFramingRectWidth = 0;
+ requestedFramingRectHeight = 0;
+ }
+ }
+
+ Camera.Parameters parameters = theCamera.getParameters();
+ String parametersFlattened = parameters == null ? null : parameters
+ .flatten(); // Save these, temporarily
+ try {
+ configManager.setDesiredCameraParameters(theCamera, false);
+ } catch (RuntimeException re) {
+ // Driver failed
+ Log.w(TAG,
+ "Camera rejected parameters. Setting only minimal safe-mode parameters");
+ Log.i(TAG, "Resetting to saved camera params: "
+ + parametersFlattened);
+ // Reset:
+ if (parametersFlattened != null) {
+ parameters = theCamera.getParameters();
+ parameters.unflatten(parametersFlattened);
+ try {
+ theCamera.setParameters(parameters);
+ configManager.setDesiredCameraParameters(theCamera, true);
+ } catch (RuntimeException re2) {
+ // Well, darn. Give up
+ Log.w(TAG,
+ "Camera rejected even safe-mode parameters! No configuration");
+ }
+ }
+ }
+
+ }
+
+ public synchronized boolean isOpen() {
+ return camera != null;
+ }
+
+ /**
+ * Closes the camera driver if still in use.
+ */
+ public synchronized void closeDriver() {
+ if (camera != null) {
+ camera.release();
+ camera = null;
+ // Make sure to clear these each time we close the camera, so that
+ // any scanning rect
+ // requested by intent is forgotten.
+ framingRect = null;
+ framingRectInPreview = null;
+ }
+ }
+
+ /**
+ * Asks the camera hardware to begin drawing preview frames to the screen.
+ */
+ public synchronized void startPreview() {
+ Camera theCamera = camera;
+ if (theCamera != null && !previewing) {
+ theCamera.startPreview();
+ previewing = true;
+ autoFocusManager = new AutoFocusManager(context, camera);
+ }
+ }
+
+ /**
+ * Tells the camera to stop drawing preview frames.
+ */
+ public synchronized void stopPreview() {
+ if (autoFocusManager != null) {
+ autoFocusManager.stop();
+ autoFocusManager = null;
+ }
+ if (camera != null && previewing) {
+ camera.stopPreview();
+ previewCallback.setHandler(null, 0);
+ previewing = false;
+ }
+ }
+
+ /**
+ * A single preview frame will be returned to the handler supplied. The data
+ * will arrive as byte[] in the message.obj field, with width and height
+ * encoded as message.arg1 and message.arg2, respectively.
+ *
+ * @param handler The handler to send the message to.
+ * @param message The what field of the message to be sent.
+ */
+ public synchronized void requestPreviewFrame(Handler handler, int message) {
+ Camera theCamera = camera;
+ if (theCamera != null && previewing) {
+ previewCallback.setHandler(handler, message);
+ theCamera.setOneShotPreviewCallback(previewCallback);
+ }
+ }
+
+ /**
+ * Calculates the framing rect which the UI should draw to show the user
+ * where to place the barcode. This target helps with alignment as well as
+ * forces the user to hold the device far enough away to ensure the image
+ * will be in focus. 计算这个条形码的扫描框；便于声明的同时，也强制用户通过改变距离来扫描到整个条形码
+ *
+ * @return The rectangle to draw on screen in window coordinates.
+ */
+ public synchronized Rect getFramingRect() {
+ if (framingRect == null) {
+ if (camera == null) {
+ return null;
+ }
+ Point screenResolution = configManager.getScreenResolution();
+ if (screenResolution == null) {
+ // Called early, before init even finished
+ return null;
+ }
+
+ int width = findDesiredDimensionInRange(screenResolution.x,
+ MIN_FRAME_WIDTH, MAX_FRAME_WIDTH);
+ int height = findDesiredDimensionInRange(screenResolution.y,
+ MIN_FRAME_HEIGHT, MAX_FRAME_HEIGHT);
+
+// int width = findDesiredDimensionInRange(screenResolution.x,
+// MIN_FRAME_WIDTH, MAX_FRAME_WIDTH)*4/5;
+// int height = findDesiredDimensionInRange(screenResolution.y,
+// MIN_FRAME_HEIGHT, MAX_FRAME_HEIGHT)*4/5;
+
+ int leftOffset = (screenResolution.x - width) / 2;
+ int topOffset = (screenResolution.y - height) / 2;
+ framingRect = new Rect(leftOffset, topOffset, leftOffset + width,
+ topOffset + height);
+ Log.d(TAG, "Calculated framing rect: " + framingRect);
+ }
+ return framingRect;
+ }
+
+ private static int findDesiredDimensionInRange(int resolution, int hardMin,
+ int hardMax) {
+ int dim = 5 * resolution / 8; // Target 5/8 of each dimension
+ if (dim < hardMin) {
+ return hardMin;
+ }
+ if (dim > hardMax) {
+ return hardMax;
+ }
+ return dim;
+ }
+
+ /**
+ * Like {@link #getFramingRect} but coordinates are in terms of the preview
+ * frame, not UI / screen.
+ *
+ * @return {@link Rect} expressing barcode scan area in terms of the preview
+ * size
+ */
+ public synchronized Rect getFramingRectInPreview() {
+ if (framingRectInPreview == null) {
+ Rect framingRect = getFramingRect();
+ if (framingRect == null) {
+ return null;
+ }
+ Rect rect = new Rect(framingRect);
+ Point cameraResolution = configManager.getCameraResolution();
+ Point screenResolution = configManager.getScreenResolution();
+ if (cameraResolution == null || screenResolution == null) {
+ // Called early, before init even finished
+ return null;
+ }
+
+ /******************** 竖屏更改1(cameraResolution.x/y互换) ************************/
+ rect.left = rect.left * cameraResolution.y / screenResolution.x;
+ rect.right = rect.right * cameraResolution.y / screenResolution.x;
+ rect.top = rect.top * cameraResolution.x / screenResolution.y;
+ rect.bottom = rect.bottom * cameraResolution.x / screenResolution.y;
+ framingRectInPreview = rect;
+ }
+ return framingRectInPreview;
+ }
+
+ /**
+ * Allows third party apps to specify the camera ID, rather than determine
+ * it automatically based on available cameras and their orientation.
+ *
+ * @param cameraId camera ID of the camera to use. A negative value means
+ * "no preference".
+ */
+ public synchronized void setManualCameraId(int cameraId) {
+ requestedCameraId = cameraId;
+ }
+
+ /**
+ * Allows third party apps to specify the scanning rectangle dimensions,
+ * rather than determine them automatically based on screen resolution.
+ *
+ * @param width The width in pixels to scan.
+ * @param height The height in pixels to scan.
+ */
+ public synchronized void setManualFramingRect(int width, int height) {
+ if (initialized) {
+ Point screenResolution = configManager.getScreenResolution();
+ if (width > screenResolution.x) {
+ width = screenResolution.x;
+ }
+ if (height > screenResolution.y) {
+ height = screenResolution.y;
+ }
+ int leftOffset = (screenResolution.x - width) / 2;
+ int topOffset = (screenResolution.y - height) / 2;
+ framingRect = new Rect(leftOffset, topOffset, leftOffset + width,
+ topOffset + height);
+ Log.d(TAG, "Calculated manual framing rect: " + framingRect);
+ framingRectInPreview = null;
+ } else {
+ requestedFramingRectWidth = width;
+ requestedFramingRectHeight = height;
+ }
+ }
+
+ /**
+ * A factory method to build the appropriate LuminanceSource object based on
+ * the format of the preview buffers, as described by Camera.Parameters.
+ *
+ * @param data A preview frame.
+ * @param width The width of the image.
+ * @param height The height of the image.
+ * @return A PlanarYUVLuminanceSource instance.
+ */
+ public PlanarYUVLuminanceSource buildLuminanceSource(byte[] data,
+ int width, int height) {
+ Rect rect = getFramingRectInPreview();
+ if (rect == null) {
+ return null;
+ }
+ // Go ahead and assume it's YUV rather than die.
+ return new PlanarYUVLuminanceSource(data, width, height, rect.left,
+ rect.top, rect.width(), rect.height(), false);
+ }
+
+}
diff --git a/zxinglibrary/src/main/java/com/yzq/zxinglibrary/camera/OpenCameraInterface.java b/zxinglibrary/src/main/java/com/yzq/zxinglibrary/camera/OpenCameraInterface.java
new file mode 100644
index 0000000..817837b
--- /dev/null
+++ b/zxinglibrary/src/main/java/com/yzq/zxinglibrary/camera/OpenCameraInterface.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.yzq.zxinglibrary.camera;
+
+import android.annotation.SuppressLint;
+import android.hardware.Camera;
+import android.util.Log;
+
+public final class OpenCameraInterface {
+
+ private static final String TAG = OpenCameraInterface.class.getName();
+
+ private OpenCameraInterface() {
+ }
+
+
+ /**
+ * Opens the requested camera with {@link Camera#open(int)}, if one exists.
+ *
+ * @param cameraId camera ID of the camera to use. A negative value means "no preference"
+ * @return handle to {@link Camera} that was opened
+ */
+ @SuppressLint("NewApi")
+public static Camera open(int cameraId) {
+
+ int numCameras = Camera.getNumberOfCameras();
+ if (numCameras == 0) {
+ Log.w(TAG, "No cameras!");
+ return null;
+ }
+
+ boolean explicitRequest = cameraId >= 0;
+
+ if (!explicitRequest) {
+ // Select a camera if no explicit camera requested
+ int index = 0;
+ while (index < numCameras) {
+ Camera.CameraInfo cameraInfo = new Camera.CameraInfo();
+ Camera.getCameraInfo(index, cameraInfo);
+ if (cameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_BACK) {
+ break;
+ }
+ index++;
+ }
+
+ cameraId = index;
+ }
+
+ Camera camera;
+ if (cameraId < numCameras) {
+ Log.i(TAG, "Opening camera #" + cameraId);
+ camera = Camera.open(cameraId);
+ } else {
+ if (explicitRequest) {
+ Log.w(TAG, "Requested camera does not exist: " + cameraId);
+ camera = null;
+ } else {
+ Log.i(TAG, "No camera facing back; returning camera #0");
+ camera = Camera.open(0);
+ }
+ }
+
+ return camera;
+ }
+
+
+ /**
+ * Opens a rear-facing camera with {@link Camera#open(int)}, if one exists, or opens camera 0.
+ *
+ * @return handle to {@link Camera} that was opened
+ */
+ public static Camera open() {
+ return open(-1);
+ }
+
+}
diff --git a/zxinglibrary/src/main/java/com/yzq/zxinglibrary/camera/PreviewCallback.java b/zxinglibrary/src/main/java/com/yzq/zxinglibrary/camera/PreviewCallback.java
new file mode 100644
index 0000000..4304dde
--- /dev/null
+++ b/zxinglibrary/src/main/java/com/yzq/zxinglibrary/camera/PreviewCallback.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2010 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.yzq.zxinglibrary.camera;
+
+import android.graphics.Point;
+import android.hardware.Camera;
+import android.os.Handler;
+import android.os.Message;
+import android.util.Log;
+
+final class PreviewCallback implements Camera.PreviewCallback {
+
+ private static final String TAG = PreviewCallback.class.getSimpleName();
+
+ private final CameraConfigurationManager configManager;
+ private Handler previewHandler;
+ private int previewMessage;
+
+ PreviewCallback(CameraConfigurationManager configManager) {
+ this.configManager = configManager;
+ }
+
+ void setHandler(Handler previewHandler, int previewMessage) {
+ this.previewHandler = previewHandler;
+ this.previewMessage = previewMessage;
+ }
+
+ @Override
+ public void onPreviewFrame(byte[] data, Camera camera) {
+ Point cameraResolution = configManager.getCameraResolution();
+ Handler thePreviewHandler = previewHandler;
+ if (cameraResolution != null && thePreviewHandler != null) {
+ Message message = thePreviewHandler.obtainMessage(previewMessage, cameraResolution.x,
+ cameraResolution.y, data);
+ message.sendToTarget();
+ previewHandler = null;
+ } else {
+ Log.d(TAG, "Got preview callback, but no handler or resolution available");
+ }
+ }
+
+}
diff --git a/zxinglibrary/src/main/java/com/yzq/zxinglibrary/decode/DecodeFormatManager.java b/zxinglibrary/src/main/java/com/yzq/zxinglibrary/decode/DecodeFormatManager.java
new file mode 100644
index 0000000..23490fb
--- /dev/null
+++ b/zxinglibrary/src/main/java/com/yzq/zxinglibrary/decode/DecodeFormatManager.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2010 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.yzq.zxinglibrary.decode;
+
+import android.content.Intent;
+import android.net.Uri;
+
+import com.google.zxing.BarcodeFormat;
+import com.yzq.zxinglibrary.android.Intents;
+
+
+import java.util.Arrays;
+import java.util.EnumSet;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.regex.Pattern;
+
+public final class DecodeFormatManager {
+
+ private static final Pattern COMMA_PATTERN = Pattern.compile(",");
+
+ public static final Set PRODUCT_FORMATS;
+ static final Set INDUSTRIAL_FORMATS;
+ private static final Set ONE_D_FORMATS;
+ static final Set QR_CODE_FORMATS = EnumSet.of(BarcodeFormat.QR_CODE);
+ static final Set DATA_MATRIX_FORMATS = EnumSet.of(BarcodeFormat.DATA_MATRIX);
+ static final Set AZTEC_FORMATS = EnumSet.of(BarcodeFormat.AZTEC);
+ static final Set PDF417_FORMATS = EnumSet.of(BarcodeFormat.PDF_417);
+ static {
+ PRODUCT_FORMATS = EnumSet.of(BarcodeFormat.UPC_A,
+ BarcodeFormat.UPC_E,
+ BarcodeFormat.EAN_13,
+ BarcodeFormat.EAN_8,
+ BarcodeFormat.RSS_14,
+ BarcodeFormat.RSS_EXPANDED);
+ INDUSTRIAL_FORMATS = EnumSet.of(BarcodeFormat.CODE_39,
+ BarcodeFormat.CODE_93,
+ BarcodeFormat.CODE_128,
+ BarcodeFormat.ITF,
+ BarcodeFormat.CODABAR);
+ ONE_D_FORMATS = EnumSet.copyOf(PRODUCT_FORMATS);
+ ONE_D_FORMATS.addAll(INDUSTRIAL_FORMATS);
+ }
+ private static final Map> FORMATS_FOR_MODE;
+ static {
+ FORMATS_FOR_MODE = new HashMap>();
+ FORMATS_FOR_MODE.put(Intents.Scan.ONE_D_MODE, ONE_D_FORMATS);
+ FORMATS_FOR_MODE.put(Intents.Scan.PRODUCT_MODE, PRODUCT_FORMATS);
+ FORMATS_FOR_MODE.put(Intents.Scan.QR_CODE_MODE, QR_CODE_FORMATS);
+ FORMATS_FOR_MODE.put(Intents.Scan.DATA_MATRIX_MODE, DATA_MATRIX_FORMATS);
+ FORMATS_FOR_MODE.put(Intents.Scan.AZTEC_MODE, AZTEC_FORMATS);
+ FORMATS_FOR_MODE.put(Intents.Scan.PDF417_MODE, PDF417_FORMATS);
+ }
+
+ private DecodeFormatManager() {}
+
+ public static Set parseDecodeFormats(Intent intent) {
+ Iterable scanFormats = null;
+ CharSequence scanFormatsString = intent.getStringExtra(Intents.Scan.FORMATS);
+ if (scanFormatsString != null) {
+ scanFormats = Arrays.asList(COMMA_PATTERN.split(scanFormatsString));
+ }
+ return parseDecodeFormats(scanFormats, intent.getStringExtra(Intents.Scan.MODE));
+ }
+
+ public static Set parseDecodeFormats(Uri inputUri) {
+ List formats = inputUri.getQueryParameters(Intents.Scan.FORMATS);
+ if (formats != null && formats.size() == 1 && formats.get(0) != null){
+ formats = Arrays.asList(COMMA_PATTERN.split(formats.get(0)));
+ }
+ return parseDecodeFormats(formats, inputUri.getQueryParameter(Intents.Scan.MODE));
+ }
+
+ private static Set parseDecodeFormats(Iterable scanFormats, String decodeMode) {
+ if (scanFormats != null) {
+ Set formats = EnumSet.noneOf(BarcodeFormat.class);
+ try {
+ for (String format : scanFormats) {
+ formats.add(BarcodeFormat.valueOf(format));
+ }
+ return formats;
+ } catch (IllegalArgumentException iae) {
+ // ignore it then
+ }
+ }
+ if (decodeMode != null) {
+ return FORMATS_FOR_MODE.get(decodeMode);
+ }
+ return null;
+ }
+
+}
diff --git a/zxinglibrary/src/main/java/com/yzq/zxinglibrary/decode/DecodeHandler.java b/zxinglibrary/src/main/java/com/yzq/zxinglibrary/decode/DecodeHandler.java
new file mode 100644
index 0000000..e605ba2
--- /dev/null
+++ b/zxinglibrary/src/main/java/com/yzq/zxinglibrary/decode/DecodeHandler.java
@@ -0,0 +1,143 @@
+/*
+ * Copyright (C) 2010 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.yzq.zxinglibrary.decode;
+
+import android.graphics.Bitmap;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.Message;
+import android.util.Log;
+
+import com.google.zxing.BinaryBitmap;
+import com.google.zxing.DecodeHintType;
+import com.google.zxing.MultiFormatReader;
+import com.google.zxing.PlanarYUVLuminanceSource;
+import com.google.zxing.ReaderException;
+import com.google.zxing.Result;
+import com.google.zxing.common.HybridBinarizer;
+import com.yzq.zxinglibrary.Consants;
+import com.yzq.zxinglibrary.android.CaptureActivity;
+
+
+import java.io.ByteArrayOutputStream;
+import java.util.Map;
+
+public final class DecodeHandler extends Handler {
+
+ private static final String TAG = DecodeHandler.class.getSimpleName();
+
+ private final CaptureActivity activity;
+ private final MultiFormatReader multiFormatReader;
+ private boolean running = true;
+
+ DecodeHandler(CaptureActivity activity, Map hints) {
+ multiFormatReader = new MultiFormatReader();
+ multiFormatReader.setHints(hints);
+ this.activity = activity;
+ }
+
+ @Override
+ public void handleMessage(Message message) {
+ if (!running) {
+ return;
+ }
+ switch (message.what) {
+ case Consants.DECODE:
+ decode((byte[]) message.obj, message.arg1, message.arg2);
+ break;
+ case Consants.QUIT:
+ running = false;
+ Looper.myLooper().quit();
+ break;
+ }
+ }
+
+ /**
+ * Decode the data within the viewfinder rectangle, and time how long it
+ * took. For efficiency, reuse the same reader objects from one decode to
+ * the next.
+ *
+ * @param data The YUV preview frame.
+ * @param width The width of the preview frame.
+ * @param height The height of the preview frame.
+ */
+ private void decode(byte[] data, int width, int height) {
+ long start = System.currentTimeMillis();
+ Result rawResult = null;
+
+ /***************竖屏更改3**********************/
+ byte[] rotatedData = new byte[data.length];
+ for (int y = 0; y < height; y++) {
+ for (int x = 0; x < width; x++)
+ rotatedData[x * height + height - y - 1] = data[x + y * width];
+ }
+ int tmp = width; // Here we are swapping, that's the difference to #11
+ width = height;
+ height = tmp;
+ data = rotatedData;
+ /*************************************/
+
+ PlanarYUVLuminanceSource source = activity.getCameraManager()
+ .buildLuminanceSource(data, width, height);
+ if (source != null) {
+ BinaryBitmap bitmap = new BinaryBitmap(new HybridBinarizer(source));
+ try {
+ rawResult = multiFormatReader.decodeWithState(bitmap);
+ } catch (ReaderException re) {
+ // continue
+ } finally {
+ multiFormatReader.reset();
+ }
+ }
+
+ Handler handler = activity.getHandler();
+ if (rawResult != null) {
+ // Don't log the barcode contents for security.
+ long end = System.currentTimeMillis();
+ Log.d(TAG, "Found barcode in " + (end - start) + " ms");
+ if (handler != null) {
+ Message message = Message.obtain(handler,
+ Consants.DECODE_SUCCEEDED, rawResult);
+ Bundle bundle = new Bundle();
+ bundleThumbnail(source, bundle);
+ message.setData(bundle);
+ message.sendToTarget();
+ }
+ } else {
+ if (handler != null) {
+ Message message = Message.obtain(handler, Consants.DECODE_FAILED);
+ message.sendToTarget();
+ }
+ }
+ }
+
+ private static void bundleThumbnail(PlanarYUVLuminanceSource source,
+ Bundle bundle) {
+ int[] pixels = source.renderThumbnail();
+ int width = source.getThumbnailWidth();
+ int height = source.getThumbnailHeight();
+ Bitmap bitmap = Bitmap.createBitmap(pixels, 0, width, width, height,
+ Bitmap.Config.ARGB_8888);
+ ByteArrayOutputStream out = new ByteArrayOutputStream();
+ bitmap.compress(Bitmap.CompressFormat.JPEG, 50, out);
+ bundle.putByteArray(DecodeThread.BARCODE_BITMAP, out.toByteArray());
+ bundle.putFloat(DecodeThread.BARCODE_SCALED_FACTOR, (float) width
+ / source.getWidth());
+ }
+
+}
diff --git a/zxinglibrary/src/main/java/com/yzq/zxinglibrary/decode/DecodeThread.java b/zxinglibrary/src/main/java/com/yzq/zxinglibrary/decode/DecodeThread.java
new file mode 100644
index 0000000..c9f60d2
--- /dev/null
+++ b/zxinglibrary/src/main/java/com/yzq/zxinglibrary/decode/DecodeThread.java
@@ -0,0 +1,115 @@
+/*
+ * Copyright (C) 2008 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.yzq.zxinglibrary.decode;
+
+import android.content.SharedPreferences;
+import android.os.Handler;
+import android.os.Looper;
+import android.preference.PreferenceManager;
+import android.util.Log;
+
+import com.google.zxing.BarcodeFormat;
+import com.google.zxing.DecodeHintType;
+import com.google.zxing.ResultPointCallback;
+import com.yzq.zxinglibrary.android.CaptureActivity;
+import com.yzq.zxinglibrary.android.PreferencesActivity;
+
+import java.util.Collection;
+import java.util.EnumMap;
+import java.util.EnumSet;
+import java.util.Map;
+import java.util.concurrent.CountDownLatch;
+
+/**
+ * This thread does all the heavy lifting of decoding the images.
+ *
+ * @author dswitkin@google.com (Daniel Switkin)
+ */
+public final class DecodeThread extends Thread {
+
+ public static final String BARCODE_BITMAP = "barcode_bitmap";
+ public static final String BARCODE_SCALED_FACTOR = "barcode_scaled_factor";
+
+ private final CaptureActivity activity;
+ private final Map hints;
+ private Handler handler;
+ private final CountDownLatch handlerInitLatch;
+
+ public DecodeThread(CaptureActivity activity,
+ Collection decodeFormats,
+ Map baseHints,
+ String characterSet,
+ ResultPointCallback resultPointCallback) {
+
+ this.activity = activity;
+ handlerInitLatch = new CountDownLatch(1);
+
+ hints = new EnumMap(DecodeHintType.class);
+ if (baseHints != null) {
+ hints.putAll(baseHints);
+ }
+
+ // The prefs can't change while the thread is running, so pick them up once here.
+ if (decodeFormats == null || decodeFormats.isEmpty()) {
+ SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(activity);
+ decodeFormats = EnumSet.noneOf(BarcodeFormat.class);
+ if (prefs.getBoolean(PreferencesActivity.KEY_DECODE_1D_PRODUCT, true)) {
+ decodeFormats.addAll(DecodeFormatManager.PRODUCT_FORMATS);
+ }
+ if (prefs.getBoolean(PreferencesActivity.KEY_DECODE_1D_INDUSTRIAL, true)) {
+ decodeFormats.addAll(DecodeFormatManager.INDUSTRIAL_FORMATS);
+ }
+ if (prefs.getBoolean(PreferencesActivity.KEY_DECODE_QR, true)) {
+ decodeFormats.addAll(DecodeFormatManager.QR_CODE_FORMATS);
+ }
+ if (prefs.getBoolean(PreferencesActivity.KEY_DECODE_DATA_MATRIX, true)) {
+ decodeFormats.addAll(DecodeFormatManager.DATA_MATRIX_FORMATS);
+ }
+ if (prefs.getBoolean(PreferencesActivity.KEY_DECODE_AZTEC, false)) {
+ decodeFormats.addAll(DecodeFormatManager.AZTEC_FORMATS);
+ }
+ if (prefs.getBoolean(PreferencesActivity.KEY_DECODE_PDF417, false)) {
+ decodeFormats.addAll(DecodeFormatManager.PDF417_FORMATS);
+ }
+ }
+ hints.put(DecodeHintType.POSSIBLE_FORMATS, decodeFormats);
+
+ if (characterSet != null) {
+ hints.put(DecodeHintType.CHARACTER_SET, characterSet);
+ }
+ hints.put(DecodeHintType.NEED_RESULT_POINT_CALLBACK, resultPointCallback);
+ Log.i("DecodeThread", "Hints: " + hints);
+ }
+
+ public Handler getHandler() {
+ try {
+ handlerInitLatch.await();
+ } catch (InterruptedException ie) {
+ // continue?
+ }
+ return handler;
+ }
+
+ @Override
+ public void run() {
+ Looper.prepare();
+ handler = new DecodeHandler(activity, hints);
+ handlerInitLatch.countDown();
+ Looper.loop();
+ }
+
+}
diff --git a/zxinglibrary/src/main/java/com/yzq/zxinglibrary/encode/CodeCreator.java b/zxinglibrary/src/main/java/com/yzq/zxinglibrary/encode/CodeCreator.java
new file mode 100644
index 0000000..b4a266b
--- /dev/null
+++ b/zxinglibrary/src/main/java/com/yzq/zxinglibrary/encode/CodeCreator.java
@@ -0,0 +1,50 @@
+package com.yzq.zxinglibrary.encode;
+
+import android.graphics.Bitmap;
+
+import com.google.zxing.BarcodeFormat;
+import com.google.zxing.MultiFormatWriter;
+import com.google.zxing.WriterException;
+import com.google.zxing.common.BitMatrix;
+
+public class CodeCreator {
+
+ /**
+ * 生成QRCode（二维码）
+ *
+ * @param str
+ * @return
+ * @throws WriterException
+ */
+ public static Bitmap createQRCode(String url) throws WriterException {
+
+ if (url == null || url.equals("")) {
+ return null;
+ }
+
+ // 生成二维矩阵,编码时指定大小,不要生成了图片以后再进行缩放,这样会模糊导致识别失败
+ BitMatrix matrix = new MultiFormatWriter().encode(url,
+ BarcodeFormat.QR_CODE, 300, 300);
+
+ int width = matrix.getWidth();
+ int height = matrix.getHeight();
+
+ // 二维矩阵转为一维像素数组,也就是一直横着排了
+ int[] pixels = new int[width * height];
+
+ for (int y = 0; y < height; y++) {
+ for (int x = 0; x < width; x++) {
+ if (matrix.get(x, y)) {
+ pixels[y * width + x] = 0xff000000;
+ }
+
+ }
+ }
+
+ Bitmap bitmap = Bitmap.createBitmap(width, height,
+ Bitmap.Config.ARGB_8888);
+ bitmap.setPixels(pixels, 0, width, 0, 0, width, height);
+ return bitmap;
+ }
+
+}
diff --git a/zxinglibrary/src/main/java/com/yzq/zxinglibrary/view/ViewfinderResultPointCallback.java b/zxinglibrary/src/main/java/com/yzq/zxinglibrary/view/ViewfinderResultPointCallback.java
new file mode 100644
index 0000000..079ddf2
--- /dev/null
+++ b/zxinglibrary/src/main/java/com/yzq/zxinglibrary/view/ViewfinderResultPointCallback.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2009 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.yzq.zxinglibrary.view;
+
+import com.google.zxing.ResultPoint;
+import com.google.zxing.ResultPointCallback;
+
+public final class ViewfinderResultPointCallback implements ResultPointCallback {
+
+ private final ViewfinderView viewfinderView;
+
+ public ViewfinderResultPointCallback(ViewfinderView viewfinderView) {
+ this.viewfinderView = viewfinderView;
+ }
+
+ @Override
+ public void foundPossibleResultPoint(ResultPoint point) {
+ viewfinderView.addPossibleResultPoint(point);
+ }
+
+}
diff --git a/zxinglibrary/src/main/java/com/yzq/zxinglibrary/view/ViewfinderView.java b/zxinglibrary/src/main/java/com/yzq/zxinglibrary/view/ViewfinderView.java
new file mode 100644
index 0000000..52bbf3f
--- /dev/null
+++ b/zxinglibrary/src/main/java/com/yzq/zxinglibrary/view/ViewfinderView.java
@@ -0,0 +1,314 @@
+/*
+ * Copyright (C) 2008 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.yzq.zxinglibrary.view;
+
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.content.res.Resources;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Paint;
+import android.graphics.Rect;
+import android.util.AttributeSet;
+import android.view.View;
+
+import com.google.zxing.ResultPoint;
+import com.yzq.zxinglibrary.R;
+import com.yzq.zxinglibrary.camera.CameraManager;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * This view is overlaid on top of the camera preview. It adds the viewfinder
+ * rectangle and partial transparency outside it, as well as the laser scanner
+ * animation and result points. 这是一个位于相机顶部的预览view,它增加了一个外部部分透明的取景框，以及激光扫描动画和结果组件
+ *
+ * @author dswitkin@google.com (Daniel Switkin)
+ */
+public final class ViewfinderView extends View {
+
+ private static final int[] SCANNER_ALPHA = {0, 64, 128, 192, 255, 192,
+ 128, 64};
+ private static final long ANIMATION_DELAY = 80L;
+ private static final int CURRENT_POINT_OPACITY = 0xA0;
+ private static final int MAX_RESULT_POINTS = 20;
+ private static final int POINT_SIZE = 6;
+
+ private CameraManager cameraManager;
+ private final Paint paint;
+ private Bitmap resultBitmap;
+ private final int maskColor; // 取景框外的背景颜色
+ private final int resultColor;// result Bitmap的颜色
+ private final int laserColor; // 红色扫描线的颜色
+ private final int resultPointColor; // 特征点的颜色
+ private final int statusColor; // 提示文字颜色
+ private int scannerAlpha;
+ private List possibleResultPoints;
+ private List lastPossibleResultPoints;
+ // 扫描线移动的y
+ private int scanLineTop;
+ // 扫描线移动速度
+ private final int SCAN_VELOCITY = 10;
+ // 扫描线
+ Bitmap scanLight;
+
+ public ViewfinderView(Context context, AttributeSet attrs) {
+ super(context, attrs);
+
+ // Initialize these once for performance rather than calling them every
+ // time in onDraw().
+ paint = new Paint(Paint.ANTI_ALIAS_FLAG);
+ Resources resources = getResources();
+ maskColor = resources.getColor(R.color.viewfinder_mask);
+ resultColor = resources.getColor(R.color.result_view);
+ laserColor = resources.getColor(R.color.viewfinder_laser);
+ resultPointColor = resources.getColor(R.color.possible_result_points);
+ statusColor = resources.getColor(R.color.status_text);
+ scannerAlpha = 0;
+ possibleResultPoints = new ArrayList(5);
+ lastPossibleResultPoints = null;
+ scanLight = BitmapFactory.decodeResource(resources,
+ R.drawable.scan_light);
+ }
+
+ public void setCameraManager(CameraManager cameraManager) {
+ this.cameraManager = cameraManager;
+ }
+
+ @SuppressLint("DrawAllocation")
+ @Override
+ public void onDraw(Canvas canvas) {
+ if (cameraManager == null) {
+ return; // not ready yet, early draw before done configuring
+ }
+
+ // frame为取景框
+ Rect frame = cameraManager.getFramingRect();
+ Rect previewFrame = cameraManager.getFramingRectInPreview();
+ if (frame == null || previewFrame == null) {
+ return;
+ }
+ int width = canvas.getWidth();
+ int height = canvas.getHeight();
+
+
+
+ // Draw the exterior (i.e. outside the framing rect) darkened
+ // 绘制取景框外的暗灰色的表面，分四个矩形绘制
+ paint.setColor(resultBitmap != null ? resultColor : maskColor);
+ canvas.drawRect(0, 0, width, frame.top, paint);// Rect_1
+ canvas.drawRect(0, frame.top, frame.left, frame.bottom + 1, paint); // Rect_2
+ canvas.drawRect(frame.right + 1, frame.top, width, frame.bottom + 1,
+ paint); // Rect_3
+ canvas.drawRect(0, frame.bottom + 1, width, height, paint); // Rect_4
+
+ if (resultBitmap != null) {
+ // Draw the opaque result bitmap over the scanning rectangle
+ // 如果有二维码结果的Bitmap，在扫取景框内绘制不透明的result Bitmap
+ paint.setAlpha(CURRENT_POINT_OPACITY);
+ canvas.drawBitmap(resultBitmap, null, frame, paint);
+ } else {
+ // Draw a red "laser scanner" line through the middle to show
+ // decoding is active
+ drawFrameBounds(canvas, frame);
+ drawStatusText(canvas, frame, width);
+
+ // 绘制扫描线
+ // paint.setColor(laserColor);
+ // paint.setAlpha(SCANNER_ALPHA[scannerAlpha]);
+ // scannerAlpha = (scannerAlpha + 1) % SCANNER_ALPHA.length;
+ // int middle = frame.height() / 2 + frame.top;
+ // canvas.drawRect(frame.left + 2, middle - 1, frame.right - 1,
+ // middle + 2, paint);
+
+ drawScanLight(canvas, frame);
+
+ float scaleX = frame.width() / (float) previewFrame.width();
+ float scaleY = frame.height() / (float) previewFrame.height();
+
+ // 绘制扫描线周围的特征点
+ List currentPossible = possibleResultPoints;
+ List currentLast = lastPossibleResultPoints;
+ int frameLeft = frame.left;
+ int frameTop = frame.top;
+ if (currentPossible.isEmpty()) {
+ lastPossibleResultPoints = null;
+ } else {
+ possibleResultPoints = new ArrayList(5);
+ lastPossibleResultPoints = currentPossible;
+ paint.setAlpha(CURRENT_POINT_OPACITY);
+ paint.setColor(resultPointColor);
+ synchronized (currentPossible) {
+ for (ResultPoint point : currentPossible) {
+ canvas.drawCircle(frameLeft
+ + (int) (point.getX() * scaleX), frameTop
+ + (int) (point.getY() * scaleY), POINT_SIZE,
+ paint);
+ }
+ }
+ }
+ if (currentLast != null) {
+ paint.setAlpha(CURRENT_POINT_OPACITY / 2);
+ paint.setColor(resultPointColor);
+ synchronized (currentLast) {
+ float radius = POINT_SIZE / 2.0f;
+ for (ResultPoint point : currentLast) {
+ canvas.drawCircle(frameLeft
+ + (int) (point.getX() * scaleX), frameTop
+ + (int) (point.getY() * scaleY), radius, paint);
+ }
+ }
+ }
+
+ // Request another update at the animation interval, but only
+ // repaint the laser line,
+ // not the entire viewfinder mask.
+ postInvalidateDelayed(ANIMATION_DELAY, frame.left - POINT_SIZE,
+ frame.top - POINT_SIZE, frame.right + POINT_SIZE,
+ frame.bottom + POINT_SIZE);
+ }
+ }
+
+ /**
+ * 绘制取景框边框
+ *
+ * @param canvas
+ * @param frame
+ */
+ private void drawFrameBounds(Canvas canvas, Rect frame) {
+
+ paint.setColor(Color.WHITE);
+ paint.setStrokeWidth(2);
+ paint.setStyle(Paint.Style.STROKE);
+
+ canvas.drawRect(frame, paint);
+
+ paint.setColor(Color.BLUE);
+ paint.setStyle(Paint.Style.FILL);
+
+ int corWidth = 15;
+ int corLength = 45;
+
+ // 左上角
+ canvas.drawRect(frame.left - corWidth, frame.top, frame.left, frame.top
+ + corLength, paint);
+ canvas.drawRect(frame.left - corWidth, frame.top - corWidth, frame.left
+ + corLength, frame.top, paint);
+ // 右上角
+ canvas.drawRect(frame.right, frame.top, frame.right + corWidth,
+ frame.top + corLength, paint);
+ canvas.drawRect(frame.right - corLength, frame.top - corWidth,
+ frame.right + corWidth, frame.top, paint);
+ // 左下角
+ canvas.drawRect(frame.left - corWidth, frame.bottom - corLength,
+ frame.left, frame.bottom, paint);
+ canvas.drawRect(frame.left - corWidth, frame.bottom, frame.left
+ + corLength, frame.bottom + corWidth, paint);
+ // 右下角
+ canvas.drawRect(frame.right, frame.bottom - corLength, frame.right
+ + corWidth, frame.bottom, paint);
+ canvas.drawRect(frame.right - corLength, frame.bottom, frame.right
+ + corWidth, frame.bottom + corWidth, paint);
+ }
+
+ /**
+ * 绘制提示文字
+ *
+ * @param canvas
+ * @param frame
+ * @param width
+ */
+ private void drawStatusText(Canvas canvas, Rect frame, int width) {
+
+ String statusText1 = getResources().getString(
+ R.string.viewfinderview_status_text1);
+ String statusText2 = getResources().getString(
+ R.string.viewfinderview_status_text2);
+ int statusTextSize = 45;
+ int statusPaddingTop = 180;
+
+ paint.setColor(statusColor);
+ paint.setTextSize(statusTextSize);
+
+ int textWidth1 = (int) paint.measureText(statusText1);
+ canvas.drawText(statusText1, (width - textWidth1) / 2, frame.top
+ - statusPaddingTop, paint);
+
+ int textWidth2 = (int) paint.measureText(statusText2);
+ canvas.drawText(statusText2, (width - textWidth2) / 2, frame.top
+ - statusPaddingTop + 60, paint);
+ }
+
+ /**
+ * 绘制移动扫描线
+ *
+ * @param canvas
+ * @param frame
+ */
+ private void drawScanLight(Canvas canvas, Rect frame) {
+
+ if (scanLineTop == 0) {
+ scanLineTop = frame.top;
+ }
+
+ if (scanLineTop >= frame.bottom) {
+ scanLineTop = frame.top;
+ } else {
+ scanLineTop += SCAN_VELOCITY;
+ }
+ Rect scanRect = new Rect(frame.left, scanLineTop, frame.right,
+ scanLineTop + 30);
+ canvas.drawBitmap(scanLight, null, scanRect, paint);
+ }
+
+ public void drawViewfinder() {
+ Bitmap resultBitmap = this.resultBitmap;
+ this.resultBitmap = null;
+ if (resultBitmap != null) {
+ resultBitmap.recycle();
+ }
+ invalidate();
+ }
+
+ /**
+ * Draw a bitmap with the result points highlighted instead of the live
+ * scanning display.
+ *
+ * @param barcode An image of the decoded barcode.
+ */
+ public void drawResultBitmap(Bitmap barcode) {
+ resultBitmap = barcode;
+ invalidate();
+ }
+
+ public void addPossibleResultPoint(ResultPoint point) {
+ List points = possibleResultPoints;
+ synchronized (points) {
+ points.add(point);
+ int size = points.size();
+ if (size > MAX_RESULT_POINTS) {
+ // trim it
+ points.subList(0, size - MAX_RESULT_POINTS / 2).clear();
+ }
+ }
+ }
+
+}
diff --git a/zxinglibrary/src/main/res/drawable/btn_back_normal.png b/zxinglibrary/src/main/res/drawable/btn_back_normal.png
new file mode 100644
index 0000000..6eb4ac6
Binary files /dev/null and b/zxinglibrary/src/main/res/drawable/btn_back_normal.png differ
diff --git a/zxinglibrary/src/main/res/drawable/btn_back_press.png b/zxinglibrary/src/main/res/drawable/btn_back_press.png
new file mode 100644
index 0000000..ac4d201
Binary files /dev/null and b/zxinglibrary/src/main/res/drawable/btn_back_press.png differ
diff --git a/zxinglibrary/src/main/res/drawable/scan_light.png b/zxinglibrary/src/main/res/drawable/scan_light.png
new file mode 100644
index 0000000..0ed22ab
Binary files /dev/null and b/zxinglibrary/src/main/res/drawable/scan_light.png differ
diff --git a/zxinglibrary/src/main/res/drawable/selector_capture_back.xml b/zxinglibrary/src/main/res/drawable/selector_capture_back.xml
new file mode 100644
index 0000000..9922d95
--- /dev/null
+++ b/zxinglibrary/src/main/res/drawable/selector_capture_back.xml
@@ -0,0 +1,7 @@
+
+
+
+ -
+
+
+
+
+
+
+
+
+
+
+ -
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/zxinglibrary/src/main/res/drawable/shape_main_button.xml b/zxinglibrary/src/main/res/drawable/shape_main_button.xml
new file mode 100644
index 0000000..de75f6a
--- /dev/null
+++ b/zxinglibrary/src/main/res/drawable/shape_main_button.xml
@@ -0,0 +1,23 @@
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/zxinglibrary/src/main/res/drawable/shape_main_edit.xml b/zxinglibrary/src/main/res/drawable/shape_main_edit.xml
new file mode 100644
index 0000000..cb7fbc7
--- /dev/null
+++ b/zxinglibrary/src/main/res/drawable/shape_main_edit.xml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
diff --git a/zxinglibrary/src/main/res/drawable/shape_main_imageview.xml b/zxinglibrary/src/main/res/drawable/shape_main_imageview.xml
new file mode 100644
index 0000000..e5ffde7
--- /dev/null
+++ b/zxinglibrary/src/main/res/drawable/shape_main_imageview.xml
@@ -0,0 +1,10 @@
+
+
+
+
+
+
+
diff --git a/zxinglibrary/src/main/res/drawable/shape_main_title.xml b/zxinglibrary/src/main/res/drawable/shape_main_title.xml
new file mode 100644
index 0000000..9db0851
--- /dev/null
+++ b/zxinglibrary/src/main/res/drawable/shape_main_title.xml
@@ -0,0 +1,11 @@
+
+
+
+
+
+
+
diff --git a/zxinglibrary/src/main/res/layout/capture.xml b/zxinglibrary/src/main/res/layout/capture.xml
new file mode 100644
index 0000000..cad7234
--- /dev/null
+++ b/zxinglibrary/src/main/res/layout/capture.xml
@@ -0,0 +1,40 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/zxinglibrary/src/main/res/raw/beep.ogg b/zxinglibrary/src/main/res/raw/beep.ogg
new file mode 100644
index 0000000..1419947
Binary files /dev/null and b/zxinglibrary/src/main/res/raw/beep.ogg differ
diff --git a/zxinglibrary/src/main/res/values/colors.xml b/zxinglibrary/src/main/res/values/colors.xml
new file mode 100644
index 0000000..9425dd2
--- /dev/null
+++ b/zxinglibrary/src/main/res/values/colors.xml
@@ -0,0 +1,17 @@
+
+
+
+
+
+ #ff000000
+ #ffffffff
+ #c0ffbd21
+ #ffc0c0c0
+ #c099cc00
+ #ffffffff
+ #b0000000
+ #ffffffff
+ #00000000
+ #ffcc0000
+ #60000000
+
diff --git a/zxinglibrary/src/main/res/values/strings.xml b/zxinglibrary/src/main/res/values/strings.xml
new file mode 100644
index 0000000..d5600c8
--- /dev/null
+++ b/zxinglibrary/src/main/res/values/strings.xml
@@ -0,0 +1,10 @@
+
+ Zxing Library
+
+ Sorry, the Android camera encountered a problem. You may need to restart the device.
+ OK
+ 将二维码/条码放入取景框内
+ 即可自动扫描
+
+
+
diff --git a/zxinglibrary/src/test/java/com/yzq/zxinglibrary/ExampleUnitTest.java b/zxinglibrary/src/test/java/com/yzq/zxinglibrary/ExampleUnitTest.java
new file mode 100644
index 0000000..c22bbeb
--- /dev/null
+++ b/zxinglibrary/src/test/java/com/yzq/zxinglibrary/ExampleUnitTest.java
@@ -0,0 +1,17 @@
+package com.yzq.zxinglibrary;
+
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+/**
+ * Example local unit test, which will execute on the development machine (host).
+ *
+ * @see Testing documentation
+ */
+public class ExampleUnitTest {
+ @Test
+ public void addition_isCorrect() throws Exception {
+ assertEquals(4, 2 + 2);
+ }
+}
\ No newline at end of file