[Unity+Android]横版扫描二维码

package="com.example.qr_codescan"

   android:versionCode="1"

   android:versionName="1.0" >  

       android:minSdkVersion="8"

       android:targetSdkVersion="16" />  

       android:allowBackup="true"

       android:icon="@drawable/ic_launcher"

       android:label="@string/app_name"

       android:theme="@android:style/Theme.NoTitleBar" >  

           android:name="com.example.qr_codescan.MainActivity"

           android:screenOrientation="landscape"

           android:label="@string/app_name" >  

           android:name=".MipcaActivityCapture"

           android:configChanges="orientation|keyboardHidden"

           android:screenOrientation="landscape"

           android:windowSoftInputMode="stateAlwaysHidden" >  

package com.example.qr_codescan;  

import android.app.Activity;  

import android.content.Intent;  

import android.graphics.Bitmap;  

import android.os.Bundle;  

import android.view.View;  

import android.view.View.OnClickListener;  

import android.widget.Button;  

import android.widget.ImageView;  

import android.widget.TextView;  

import com.unity3d.player.UnityPlayer;  

import com.unity3d.player.UnityPlayerActivity;  

publicclass MainActivityextends UnityPlayerActivity {  

privatefinalstaticint SCANNIN_GREQUEST_CODE =1;  

/**

    * 显示扫描结果

    */

//  private TextView mTextView ;

/**

    * 显示扫描拍的图片

    */

//  private ImageView mImageView;

@Override

protectedvoid onCreate(Bundle savedInstanceState) {  

super.onCreate(savedInstanceState);  

//      setContentView(R.layout.activity_main);

//      

//      mTextView = (TextView) findViewById(R.id.result);

//      mImageView = (ImageView) findViewById(R.id.qrcode_bitmap);

//      

//      //点击按钮跳转到二维码扫描界面，这里用的是startActivityForResult跳转

//      //扫描完了之后调到该界面

//      Button mButton = (Button) findViewById(R.id.button1);

//      mButton.setOnClickListener(new OnClickListener() {

//          

//          @Override

//          public void onClick(View v) {

//              Intent intent = new Intent();

//              intent.setClass(MainActivity.this, MipcaActivityCapture.class);

//              intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);

//              startActivityForResult(intent, SCANNIN_GREQUEST_CODE);

//          }

//      });

   }  

publicvoid Show()  

   {  

       Intent intent = new Intent();  

       intent.setClass(MainActivity.this, MipcaActivityCapture.class);  

       intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);  

       startActivityForResult(intent, SCANNIN_GREQUEST_CODE);  

   }  

@Override

protectedvoid onActivityResult(int requestCode,int resultCode, Intent data) {  

super.onActivityResult(requestCode, resultCode, data);  

switch (requestCode) {  

case SCANNIN_GREQUEST_CODE:  

if(resultCode == RESULT_OK){  

               Bundle bundle = data.getExtras();  

//显示扫描到的内容

//              mTextView.setText(bundle.getString("result"));

//显示

//              mImageView.setImageBitmap((Bitmap) data.getParcelableExtra("bitmap"));

               UnityPlayer.UnitySendMessage("GameObject","GetString",bundle.getString("result"));  

           }  

break;  

       }  

   }    

}  

/*

* 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.mining.app.zxing.camera;  

import android.content.Context;  

import android.graphics.Point;  

import android.hardware.Camera;  

import android.os.Build;  

import android.util.Log;  

import android.view.Display;  

import android.view.WindowManager;  

import java.lang.reflect.Method;  

import java.util.regex.Pattern;  

finalclass CameraConfigurationManager {  

privatestaticfinal String TAG = CameraConfigurationManager.class.getSimpleName();  

privatestaticfinalint TEN_DESIRED_ZOOM =27;  

privatestaticfinalint DESIRED_SHARPNESS =30;  

privatestaticfinal Pattern COMMA_PATTERN = Pattern.compile(",");  

privatefinal Context context;  

private Point screenResolution;  

private Point cameraResolution;  

privateint previewFormat;  

private String previewFormatString;  

 CameraConfigurationManager(Context context) {  

this.context = context;  

 }  

/**

  * Reads, one time, values from the camera that are needed by the app.

  */

void initFromCameraParameters(Camera camera) {  

   Camera.Parameters parameters = camera.getParameters();  

   previewFormat = parameters.getPreviewFormat();  

   previewFormatString = parameters.get("preview-format");  

   Log.d(TAG, "Default preview format: " + previewFormat +'/' + previewFormatString);  

   WindowManager manager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);  

   Display display = manager.getDefaultDisplay();  

   screenResolution = new Point(display.getWidth(), display.getHeight());  

   Log.d(TAG, "Screen resolution: " + screenResolution);  

   cameraResolution = getCameraResolution(parameters, screenResolution);  

   Log.d(TAG, "Camera resolution: " + screenResolution);  

 }  

/**

  * Sets the camera up to take preview p_w_picpaths which are used for both preview and decoding.

  * We detect the preview format here so that buildLuminanceSource() can build an appropriate

  * LuminanceSource subclass. In the future we may want to force YUV420SP as it's the smallest,

  * and the planar Y can be used for barcode scanning without a copy in some cases.

  */

void setDesiredCameraParameters(Camera camera) {  

   Camera.Parameters parameters = camera.getParameters();  

   Log.d(TAG, "Setting preview size: " + cameraResolution);  

   parameters.setPreviewSize(cameraResolution.x, cameraResolution.y);  

   setFlash(parameters);  

   setZoom(parameters);  

//setSharpness(parameters);

//modify here

//    camera.setDisplayOrientation(90);

//兼容2.1

//setDisplayOrientation(camera, 90);

   camera.setParameters(parameters);  

 }  

 Point getCameraResolution() {  

return cameraResolution;  

 }  

 Point getScreenResolution() {  

return screenResolution;  

 }  

int getPreviewFormat() {  

return previewFormat;  

 }  

 String getPreviewFormatString() {  

return previewFormatString;  

 }  

privatestatic Point getCameraResolution(Camera.Parameters parameters, Point screenResolution) {  

   String previewSizeValueString = parameters.get("preview-size-values");  

// saw this on Xperia

if (previewSizeValueString ==null) {  

     previewSizeValueString = parameters.get("preview-size-value");  

   }  

   Point cameraResolution = null;  

if (previewSizeValueString !=null) {  

     Log.d(TAG, "preview-size-values parameter: " + previewSizeValueString);  

     cameraResolution = findBestPreviewSizeValue(previewSizeValueString, screenResolution);  

   }  

if (cameraResolution ==null) {  

// Ensure that the camera resolution is a multiple of 8, as the screen may not be.

     cameraResolution = new Point(  

         (screenResolution.x >> 3) <<3,  

         (screenResolution.y >> 3) <<3);  

   }  

return cameraResolution;  

 }  

privatestatic Point findBestPreviewSizeValue(CharSequence previewSizeValueString, Point screenResolution) {  

int bestX =0;  

int bestY =0;  

int diff = Integer.MAX_VALUE;  

for (String previewSize : COMMA_PATTERN.split(previewSizeValueString)) {  

     previewSize = previewSize.trim();  

int dimPosition = previewSize.indexOf('x');  

if (dimPosition <0) {  

       Log.w(TAG, "Bad preview-size: " + previewSize);  

continue;  

     }  

int newX;  

int newY;  

try {  

       newX = Integer.parseInt(previewSize.substring(0, dimPosition));  

       newY = Integer.parseInt(previewSize.substring(dimPosition + 1));  

     } catch (NumberFormatException nfe) {  

       Log.w(TAG, "Bad preview-size: " + previewSize);  

continue;  

     }  

int newDiff = Math.abs(newX - screenResolution.x) + Math.abs(newY - screenResolution.y);  

if (newDiff ==0) {  

       bestX = newX;  

       bestY = newY;  

break;  

     } elseif (newDiff < diff) {  

       bestX = newX;  

       bestY = newY;  

       diff = newDiff;  

     }  

   }  

if (bestX >0 && bestY >0) {  

returnnew Point(bestX, bestY);  

   }  

returnnull;  

 }  

privatestaticint findBestMotZoomValue(CharSequence stringValues,int tenDesiredZoom) {  

int tenBestValue =0;  

for (String stringValue : COMMA_PATTERN.split(stringValues)) {  

     stringValue = stringValue.trim();  

double value;  

try {  

       value = Double.parseDouble(stringValue);  

     } catch (NumberFormatException nfe) {  

return tenDesiredZoom;  

     }  

int tenValue = (int) (10.0 * value);  

if (Math.abs(tenDesiredZoom - value) < Math.abs(tenDesiredZoom - tenBestValue)) {  

       tenBestValue = tenValue;  

     }  

   }  

return tenBestValue;  

 }  

privatevoid setFlash(Camera.Parameters parameters) {  

// FIXME: This is a hack to turn the flash off on the Samsung Galaxy.

// And this is a hack-hack to work around a different value on the Behold II

// Restrict Behold II check to Cupcake, per Samsung's advice

//if (Build.MODEL.contains("Behold II") &&

//    CameraManager.SDK_INT == Build.VERSION_CODES.CUPCAKE) {

if (Build.MODEL.contains("Behold II") && CameraManager.SDK_INT ==3) {// 3 = Cupcake

     parameters.set("flash-value",1);  

   } else {  

     parameters.set("flash-value",2);  

   }  

// This is the standard setting to turn the flash off that all devices should honor.

   parameters.set("flash-mode","off");  

 }  

privatevoid setZoom(Camera.Parameters parameters) {  

   String zoomSupportedString = parameters.get("zoom-supported");  

if (zoomSupportedString !=null && !Boolean.parseBoolean(zoomSupportedString)) {  

return;  

   }  

int tenDesiredZoom = TEN_DESIRED_ZOOM;  

   String maxZoomString = parameters.get("max-zoom");  

if (maxZoomString !=null) {  

try {  

int tenMaxZoom = (int) (10.0 * Double.parseDouble(maxZoomString));  

if (tenDesiredZoom > tenMaxZoom) {  

         tenDesiredZoom = tenMaxZoom;  

       }  

     } catch (NumberFormatException nfe) {  

       Log.w(TAG, "Bad max-zoom: " + maxZoomString);  

     }  

   }  

   String takingPictureZoomMaxString = parameters.get("taking-picture-zoom-max");  

if (takingPictureZoomMaxString !=null) {  

try {  

int tenMaxZoom = Integer.parseInt(takingPictureZoomMaxString);  

if (tenDesiredZoom > tenMaxZoom) {  

         tenDesiredZoom = tenMaxZoom;  

       }  

     } catch (NumberFormatException nfe) {  

       Log.w(TAG, "Bad taking-picture-zoom-max: " + takingPictureZoomMaxString);  

     }  

   }  

   String motZoomValuesString = parameters.get("mot-zoom-values");  

if (motZoomValuesString !=null) {  

     tenDesiredZoom = findBestMotZoomValue(motZoomValuesString, tenDesiredZoom);  

   }  

   String motZoomStepString = parameters.get("mot-zoom-step");  

if (motZoomStepString !=null) {  

try {  

double motZoomStep = Double.parseDouble(motZoomStepString.trim());  

int tenZoomStep = (int) (10.0 * motZoomStep);  

if (tenZoomStep >1) {  

         tenDesiredZoom -= tenDesiredZoom % tenZoomStep;  

       }  

     } catch (NumberFormatException nfe) {  

// continue

     }  

   }  

// Set zoom. This helps encourage the user to pull back.

// Some devices like the Behold have a zoom parameter

if (maxZoomString !=null || motZoomValuesString !=null) {  

     parameters.set("zoom", String.valueOf(tenDesiredZoom /10.0));  

   }  

// Most devices, like the Hero, appear to expose this zoom parameter.

// It takes on values like "27" which appears to mean 2.7x zoom

if (takingPictureZoomMaxString !=null) {  

     parameters.set("taking-picture-zoom", tenDesiredZoom);  

   }  

 }  

publicstaticint getDesiredSharpness() {  

return DESIRED_SHARPNESS;  

   }  

/**

    * compatible  1.6

    * @param camera

    * @param angle

    */

protectedvoid setDisplayOrientation(Camera camera,int angle){    

       Method downPolymorphic;    

try

       {    

           downPolymorphic = camera.getClass().getMethod("setDisplayOrientation",new Class[] {int.class });    

if (downPolymorphic !=null)    

               downPolymorphic.invoke(camera, new Object[] { angle });    

       }    

catch (Exception e1)    

       {    

       }    

  }    

}