View difference between Paste ID: vDrLKasd and J475cdQ6

-package com.blutechnologies.scancard;
+
 public class CameraActivity extends FragmentActivity implements SensorEventListener,ShutterButton.ShutterButtonListener,View.OnClickListener,KeyEvent.Callback
-import java.io.File;
+
-import java.io.FileNotFoundException;
+
-import java.io.FileOutputStream;
+
-import java.io.IOException;
+
 	long sSensorCallTime;
-import android.annotation.TargetApi;
+
-import android.app.Activity;
+
-import android.content.Context;
+
-import android.content.Intent;
+
-import android.graphics.Bitmap;
+
-import android.graphics.BitmapFactory;
+
-import android.graphics.Matrix;
+
-import android.hardware.Camera;
+
-import android.hardware.Camera.AutoFocusCallback;
+
-import android.hardware.Camera.CameraInfo;
+
-import android.hardware.Camera.Parameters;
+
-import android.hardware.Camera.PictureCallback;
+
-import android.hardware.Sensor;
+
-import android.hardware.SensorEvent;
+
-import android.hardware.SensorEventListener;
+
-import android.hardware.SensorManager;
+
-import android.media.ExifInterface;
+
-import android.os.Build;
+
-import android.os.Bundle;
+
-import android.os.Debug;
+
-import android.os.Environment;
+
-import android.os.Handler;
+
-import android.os.Message;
+
-import android.support.v4.app.FragmentActivity;
+
-import android.util.Log;
+
-import android.view.KeyEvent;
+
-import android.view.OrientationEventListener;
+
-import android.view.Surface;
+
-import android.view.View;
+
-import android.view.Window;
+
-import android.view.WindowManager;
+
-import android.widget.FrameLayout;
+
 		if(sFocusTime!=0 &&sClickTime==0)
 		{
 			sSensorCallTime=System.currentTimeMillis();
 			Log.d(TAG,"Sensor call time"+sSensorCallTime);
 		}
 		if(!isClicked){
 			float x=event.values[0];
 			float y=event.values[1];
 			float z=event.values[2];
 			if(mLastX==0)
 				mLastX=x;
 			if(mLastY==0)
 				mLastY=y;
 			if(mLastZ==0)
 				mLastZ=z;
 
 			float deltaX=x-mLastX;
 			float deltaY=y-mLastY;
 			float deltaZ=z-mLastZ;
 			if(deltaX>2.5 || deltaY>2.5 || deltaZ>2.5)
 			{
 				if(mFocusState!=FOCUSING && mFocusState!=FOCUSING_SNAP_ON_FINISH)
 				{
 					mFocusState=FOCUS_NOT_STARTED;
 					Log.d(TAG, "Focus called from accelerometer");
 					doFocus(true);
 				}
 			}
 				mLastX=x;
 				mLastY=y;
 				mLastZ=z;
 		}
 	}
-	private static final int FIRST_TIME_INIT = 1;
+
-    private static final int CLEAR_SCREEN_DELAY = 2;
+
-
+
-
+
-    private MyOrientationEventListener mOrientationListener;
+
-    // The device orientation in degrees. Default is unknown.
+
-    private int mOrientation = OrientationEventListener.ORIENTATION_UNKNOWN;
+
-    // The orientation compensation for icons and thumbnails.
+
-    private int mOrientationCompensation = 0;
+
-
+
-    private boolean mPreviewing;
+
-    private boolean mPausing;
+
-    private boolean mFirstTimeInitialized;
+
-
+
 		btn_capture.setClickable(true);
 	}
 
 	@Override
 	public void onResume()
 	{
 		super.onResume();
 		initializeCamera();
 		sensorManager.registerListener(this, sensor,SensorManager.SENSOR_DELAY_UI);
 	}
 
 	private void initializeCamera()
 	{
 		mCamera=null;
 		Camera.CameraInfo info=new Camera.CameraInfo();
 		int cameraCount=Camera.getNumberOfCameras();
 		for(int cameraIndex=0;cameraIndex<cameraCount;cameraIndex++)
 		{
 			try
 			{
 				Camera.getCameraInfo(cameraIndex, info);
 				if(cameraIndex==info.CAMERA_FACING_BACK)
 				{
 					mCamera=Camera.open(cameraIndex);
 				}
 				mPreview=new CameraPreview(this,mCamera);
 				container.addView(mPreview);
 				isPreviewShowing=true;
 			}
 			catch(Exception ex)
 			{
 				Log.d(TAG, "Could not open camera");
 			}
 		}
 
 
 	}
 
 	private void autoFocus()
 	{
 		//Confused about the condition:
 		if(mFocusState==FOCUS_NOT_STARTED && isPreviewShowing && mCameraStatus!=SNAPSHOT_IN_PROGRESS)
 		{
 			mFocusState=FOCUSING;
 			mCamera.autoFocus(autoFocusCallback);
 		}
 	}
 
 	private void cancelAutoFocus()
 	{
 		//Confused about the condition
 		if(mCameraStatus==CAMERA_IDLE && (mFocusState==FOCUSING||mFocusState==FOCUS_SUCCESS||mFocusState==FOCUS_FAIL))
 		{
 			mCamera.cancelAutoFocus();
 		}
 		mFocusState=FOCUS_NOT_STARTED;
 	}
 
 	private void doSnap()
 	{
 		String mFocusMode=mCamera.getParameters().getFocusMode();
 		if(mFocusMode.equals(Parameters.FOCUS_MODE_INFINITY)||mFocusMode.equals(Parameters.FOCUS_MODE_EDOF)||mFocusMode.equals(mFocusMode.equals(Parameters.FOCUS_MODE_FIXED))||mFocusState==FOCUS_SUCCESS||mFocusState==FOCUS_FAIL||mFocusState==FOCUS_NOT_STARTED)
-		if(mFirstTimeInitialized)
+
-			initializeSecondTime();
+
 			//If the focus was not started,it will go through the focus states if the user holds on to the ShutterButton until the Camera focuses...
-			initializeFirstTime();
+
 			mCameraStatus=SNAPSHOT_IN_PROGRESS;
 			mCamera.takePicture(null, null, pictureCallback);
 		}
 		else if(mFocusState==FOCUSING)
 			mFocusState=FOCUSING_SNAP_ON_FINISH;
 
 	}
-		try
+
 	private void doFocus(boolean pressed)
-			mCamera=Camera.open();
+
 		//Pressed is set to true,if ShutterButton is half-pressed
-		catch(Exception ex)
+
 			autoFocus();
-			Log.d(TAG, "Could not open camera");
+
 			cancelAutoFocus();
-		mPreview=new CameraPreview(this,mCamera);
+
-		container.addView(mPreview);
+
-		isPreviewShowing=true;
+
 	public void onPause()
 	{
 		super.onPause();
 		sensorManager.unregisterListener(this);
 		isPreviewShowing=false;
 		killCamera();
 		container.removeAllViews();
 	}
 
 	@Override
 	public void onDestroy()
 	{
 		super.onDestroy();
 	}
 
 
 	private void killCamera()
 	{
 		if(mCamera!=null)
 		{
 			mCamera.cancelAutoFocus();
 			mCamera.release();
 			mCamera=null;
 		}
-		int rotation=0;
+
-		 if (mOrientation != OrientationEventListener.ORIENTATION_UNKNOWN) {
+
-             CameraInfo info = new CameraInfo();
+
-             Camera.getCameraInfo(CameraInfo.CAMERA_FACING_BACK, info);
+
-             if (info.facing == CameraInfo.CAMERA_FACING_FRONT) {
+
-                 rotation = (info.orientation - mOrientation + 360) % 360;
+
-             } else {  // back-facing camera
+
-                 rotation = (info.orientation + mOrientation) % 360;
+
-             }
+
-         }
+
-         Camera.Parameters params=mCamera.getParameters();
+
-         params.setRotation(rotation);
+
-         mCamera.setParameters(params);
+
 				else
 					mFocusState=FOCUS_FAIL;
 				doSnap();
 			}
 
 			else if(mFocusState==FOCUSING)
 			{
 				if(success)
 					mFocusState=FOCUS_SUCCESS;
 				else
 					mFocusState=FOCUS_FAIL;
 			}
 
 			else if(mFocusState==FOCUS_NOT_STARTED)
 			{
 				Log.d(TAG,"Focus not started,doing nothing");
 			}
 		}
 
 	};
 
 	PictureCallback pictureCallback=new PictureCallback()
 	{
 
 		@Override
 		public void onPictureTaken(final byte[] data, Camera camera) {
-		mOrientationListener.disable();
+
 			Log.d(TAG,"In picture callback");
 			mCameraStatus=CAMERA_IDLE;
 			String path=Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES).getAbsolutePath();
 			File dir=new File(path);
 			if(!dir.exists())
 				dir.mkdirs();
 			String fileName="IMG_"+System.currentTimeMillis()+".jpg";
 			pathName=path+File.separator+fileName;
 			new Thread()
 			{
 				public void run()
 				{
 					try {
 						FileOutputStream fos=new FileOutputStream(pathName);
-			mCamera.setPreviewCallback(null);
+
-			mCamera.stopPreview();
+
 					} catch (FileNotFoundException e) {
 						Log.e(TAG, "The output file could not be found",e);
 					} catch (IOException e) {
 						Log.e(TAG, "There was an exception writing from byte[] to file",e);
 					}
 
 					try {
 						ExifInterface exif=new ExifInterface(pathName.toString());
 						int exifOrientation=exif.getAttributeInt(ExifInterface.TAG_ORIENTATION,ExifInterface.ORIENTATION_NORMAL);
 						Log.d(TAG,"Orient:"+exifOrientation);
 						int rotate=0;
 						switch(exifOrientation)
 						{
 							case ExifInterface.ORIENTATION_ROTATE_90:
 								rotate=90;
 								break;
 							case ExifInterface.ORIENTATION_ROTATE_180:
 								rotate=180;
 								break;
 							case ExifInterface.ORIENTATION_ROTATE_270:
 								rotate=270;
 								break;
 						}
 						Log.d(TAG,"Rotation:"+rotate);
 						if(rotate!=0)
 						{
 							Bitmap bitmap=BitmapFactory.decodeFile(pathName);
 							int w=bitmap.getWidth();
 							int h=bitmap.getHeight();
 							Matrix mtx=new Matrix();
 							mtx.preRotate(rotate);
 							bitmap=Bitmap.createBitmap(bitmap, 0, 0,w,h,mtx,false);
 							bitmap = bitmap.copy(Bitmap.Config.ARGB_8888, true);
 							FileOutputStream fos;
 							try {
 								fos = new FileOutputStream(pathName);
 								bitmap.compress(Bitmap.CompressFormat.JPEG, 100, fos);
 							} catch (FileNotFoundException e) {
 								Log.e(TAG, "Error saving rotated bitmap to file,e");
 							}
 						}
 					}
 					catch(IOException e) {
 						Log.e(TAG,"Rotate or coversion failed:"+e.toString());
 						}
 				}
 			}.start();
 			Intent intent=new Intent(getBaseContext(),ImagePreviewActivity.class);
 			intent.putExtra("pathName", pathName);
 			isPreviewShowing=false;
 			startActivity(intent);
 		}
 	};
 	@Override
 	public void onShutterButtonFocus(ShutterButton shutterButton,
 			boolean pressed) {
 		// TODO Auto-generated method stub
 		sFocusTime=System.currentTimeMillis();
 		Log.d(TAG, "Shutter button focus called "+sFocusTime);
 		switch(shutterButton.getId())
 		{
 			case R.id.btn_capture:
 			{
 				isClicked=pressed;
 				doFocus(pressed);
 				break;
 			}
 		}
 
 	}
 
 	@Override
 	public void onShutterButtonClick(ShutterButton shutterButton) {
 		// TODO Auto-generated method stub
 		Log.d(TAG, "Shutter button click called");
 		sClickTime=System.currentTimeMillis();
 		Log.d(TAG,"ShutterButtonClick time: "+sClickTime);
 		Log.d(TAG,"Time taken to go to click"+((float)(sClickTime-sFocusTime)/1000));
 		switch(shutterButton.getId())
 		{
 			case R.id.btn_capture:
 				doSnap();
 				isClicked=false;
 				break;
 		}
 
 	}
 
 	@Override
 	public void onClick(View v) {
 		// TODO Auto-generated method stub
 		//This assumes that the clicks the screen only if the focus has not been set...
 		//This feature is useful in phones where accelerometer delay is unacceptable
 		doFocus(true);
 	}
 
 	@Override
 	public boolean onKeyDown(int keyCode,KeyEvent event)
 	{
 		switch(keyCode)
 		{
 			case KeyEvent.KEYCODE_BACK:
 				startActivity(new Intent(this,MainActivity.class));
 		}
 		return false;
 	}
 
 
 }