tauplatform 1.0.2 → 1.0.3

data/lib/commonAPI/mediacapture/ext/platform/android/src/com/rho/camera/CameraRhoListener.java

@@ -3,6 +3,7 @@ package com.rho.camera;
 import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.FileInputStream;
+import java.io.OutputStream;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.IOException;
@@ -37,7 +38,7 @@ import com.rhomobile.rhodes.util.Utils;
 import com.rhomobile.rhodes.file.RhoFileApi;
 
 public class CameraRhoListener extends AbstractRhoListener implements
-		IRhoListener {
+IRhoListener {
 
 	private static final String TAG = CameraRhoListener.class.getSimpleName();
 
@@ -51,11 +52,24 @@ public class CameraRhoListener extends AbstractRhoListener implements
 	private String imgPath = null;
 	private Bitmap mBitmap = null;
 	private String rename = null;
-	
+
 	static CameraRhoListener getInstance() {
 		return sInstance;
 	}
 
+
+	private void cleanState() {
+		mActualPropertyMap = null;
+		picChoosen_imagewidth = 0;
+		picChoosen_imageheight = 0;
+		curUri = null;
+		storedUri = null;
+		resultMap=new HashMap<String,Object>();
+		imgPath = null;
+		mBitmap = null;
+		rename = null;
+	}
+
 	@Override
 	public void onCreateApplication(IRhoExtManager extManager) {
 		sInstance = this;
@@ -76,26 +90,36 @@ public class CameraRhoListener extends AbstractRhoListener implements
 		Uri captureUri = null;
 		String targetPath = " ";
 		ByteArrayOutputStream stream = null;
+		Logger.T(TAG, "CameraRhoListener.onActivityResult() START");
+		Logger.T(TAG, "ActualProperties: ["+getActualPropertyMap()+"]");
+		Logger.T(TAG, "Properties: ["+propertyMap+"]");
+
 		try {
 			if (resultCode == Activity.RESULT_OK)
 			{
+				Logger.T(TAG, "resultCode == Activity.RESULT_OK");
 				getActualPropertyMap().put("default_camera_key_path", "");
 				SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMdd_hhmmss");
 				rename = "IMG_"+ dateFormat.format(new Date(System.currentTimeMillis()))+".jpg";
 				if(propertyMap.containsKey("fileName")){
 					rename = propertyMap.get("fileName")+ ".jpg";
 				}
-				String curPath = null;		
-				String strCaptureUri = getActualPropertyMap().get("captureUri");		
+
+				BitmapFactory.Options options_only_size = new BitmapFactory.Options();
+				options_only_size.inJustDecodeBounds = true;
+
+				String curPath = null;
+				String strCaptureUri = getActualPropertyMap().get("captureUri");
 				if (strCaptureUri != null)
 				{
 					captureUri = Uri.parse(getActualPropertyMap().get("captureUri"));
 					getActualPropertyMap().put("default_camera_key_path", "");
-				}		
+				}
 				if (intent != null && intent.hasExtra(MediaStore.EXTRA_OUTPUT))
 				{
+					Logger.T(TAG, "intent != null && intent.hasExtra(MediaStore.EXTRA_OUTPUT)");
 					if(intent.hasExtra(MediaStore.EXTRA_OUTPUT)){
-						Logger.T(TAG, "Intent extras: "+ intent.getExtras().keySet());	
+						Logger.T(TAG, "Intent extras: "+ intent.getExtras().keySet());
 						curUri = (Uri) intent.getParcelableExtra(MediaStore.EXTRA_OUTPUT);
 						storedUri = curUri;
 					}
@@ -106,35 +130,46 @@ public class CameraRhoListener extends AbstractRhoListener implements
 					try {
 						System.gc();
 						if (getActualPropertyMap().get("DeviceGallery_Key") == null){
-							mBitmap = BitmapFactory.decodeFile(curUri.getPath());
+							BitmapFactory.decodeFile(curUri.getPath(), options_only_size);
+							if((getActualPropertyMap().get("outputFormat").equalsIgnoreCase("dataUri"))){
+								mBitmap = BitmapFactory.decodeFile(curUri.getPath());
+							}
+
 						}else{
 							imgPath = getFilePath(curUri);
-							mBitmap = BitmapFactory.decodeFile(imgPath);
+							BitmapFactory.decodeFile(imgPath, options_only_size);
+							if((getActualPropertyMap().get("outputFormat").equalsIgnoreCase("dataUri"))){
+								mBitmap = BitmapFactory.decodeFile(imgPath);
+							}
 							File f= new File(imgPath);
 							imgPath = copyImg(imgPath);
 							f.renameTo(new File(f.getParentFile(), rename));
 							String pathAfterRename = f.getParentFile().getAbsolutePath() +"/"+rename;
 							fixTheGalleryIssue(pathAfterRename);
-							// RhodesActivity.getContext().sendBroadcast(new Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE, 
-					  //              Uri.parse(curUri.getPath())));
+							// RhodesActivity.getContext().sendBroadcast(new Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE,
+							//			  Uri.parse(curUri.getPath())));
 							getActualPropertyMap().put("default_camera_key_path", "default_camera_key_path_value");
 						}
-						
+
 					} catch (OutOfMemoryError e1) {
 						e1.printStackTrace();
 					}
 					File file = null;
-					if (!getActualPropertyMap().containsKey("fileName") && getActualPropertyMap().get("ChoosePicture_Key") == null){ 
+					if (!getActualPropertyMap().containsKey("fileName") && getActualPropertyMap().get("ChoosePicture_Key") == null){
 						file= new File(curUri.getPath());
 						file.renameTo(new File(file.getParentFile(), rename));
 						String pathAfterRename = file.getParentFile().getAbsolutePath() +"/"+rename;
 						fixTheGalleryIssue(pathAfterRename);
-						// RhodesActivity.getContext().sendBroadcast(new Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE, 
-				  //              Uri.parse(curUri.getPath())));
+						// RhodesActivity.getContext().sendBroadcast(new Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE,
+						//			  Uri.parse(curUri.getPath())));
 					}
-					picChoosen_imagewidth = mBitmap.getWidth();
-					picChoosen_imageheight = mBitmap.getHeight();
-					if((getActualPropertyMap().get("outputFormat").equalsIgnoreCase("dataUri"))){				
+					//picChoosen_imagewidth = mBitmap.getWidth();
+					//picChoosen_imageheight = mBitmap.getHeight();
+					picChoosen_imagewidth = options_only_size.outWidth;
+					picChoosen_imageheight = options_only_size.outHeight;
+
+
+					if((getActualPropertyMap().get("outputFormat").equalsIgnoreCase("dataUri"))){
 						stream = new ByteArrayOutputStream();
 						mBitmap.compress(Bitmap.CompressFormat.JPEG, 100, stream);
 						byte[] byteArray = stream.toByteArray();
@@ -153,86 +188,226 @@ public class CameraRhoListener extends AbstractRhoListener implements
 							byteArray = stream.toByteArray();
 							dataBuilder.append(Base64.encodeToString(byteArray, false));
 						}
-						getActualPropertyMap().put("curUri", dataBuilder.toString());						
+						getActualPropertyMap().put("curUri", dataBuilder.toString());
 						curUri=Uri.parse(dataBuilder.toString());
+						mBitmap.recycle();
 					}
-					Logger.T(TAG, "Photo is captured: " + curUri);					
-					mBitmap.recycle();
+					Logger.T(TAG, "Photo is captured: " + curUri);
+					//mBitmap.recycle();
 				}else if (captureUri != null )
-				{			
-					
-				curUri = captureUri;
-					
-					
+				{
+					Logger.T(TAG, "captureUri != null");
+
+					curUri = captureUri;
+
 					if (getActualPropertyMap().get("dataURI") == null) {
-						imgPath = getFilePath(curUri);
+						Logger.T(TAG, "getActualPropertyMap().get(dataURI) == null");
+						boolean fromGallery = false;
+						try {
+							imgPath = getFilePath(curUri);
+						}
+						catch (Exception e) {
+							e.printStackTrace();
+						}
+						Logger.T(TAG, "curUri ["+curUri+"]");
+						Logger.T(TAG, "imgPath ["+imgPath+"]");
+						//Utils.platformLog("################", "intent.getData() ["+intent.getData()+"]");
+						if (imgPath == null) {
+							try {
+								imgPath = getFilePath(intent.getData());
+							}
+							catch (Exception e) {
+								e.printStackTrace();
+							}
+						}
+
+
+						if (fromGallery) {
+						}
+						else {
 							File f= new File(imgPath);
 							imgPath = copyImg(imgPath);
 							getActualPropertyMap().put("default_camera_key_path", "default_camera_key_path_value");
 							BitmapFactory.Options options = new BitmapFactory.Options();
 							options.inPreferredConfig = Bitmap.Config.ARGB_8888;
-							        try {
-							        	mBitmap = BitmapFactory.decodeStream(new FileInputStream(f), null, options);
-							        	if (!getActualPropertyMap().containsKey("fileName") && getActualPropertyMap().get("ChoosePicture_Key") == null){ 
-							        	f.renameTo(new File(f.getParentFile(), rename));
-							        	String pathAfterRename = f.getParentFile().getAbsolutePath() +"/"+rename;
-							        	fixTheGalleryIssue(pathAfterRename);
-										// RhodesActivity.getContext().sendBroadcast(new Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE, 
-								  //              Uri.parse(f.getAbsolutePath())));
-							        	}
-							        } catch (FileNotFoundException e) {
-							            e.printStackTrace();
-							        }
-							picChoosen_imagewidth = mBitmap.getWidth();
-							picChoosen_imageheight = mBitmap.getHeight();
-							mBitmap.recycle();
+							try {
+								BitmapFactory.decodeStream(new FileInputStream(f), null, options_only_size);
+								if (!getActualPropertyMap().containsKey("fileName") && getActualPropertyMap().get("ChoosePicture_Key") == null){
+									f.renameTo(new File(f.getParentFile(), rename));
+									String pathAfterRename = f.getParentFile().getAbsolutePath() +"/"+rename;
+									fixTheGalleryIssue(pathAfterRename);
+									// RhodesActivity.getContext().sendBroadcast(new Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE,
+									//			  Uri.parse(f.getAbsolutePath())));
+								}
+							} catch (FileNotFoundException e) {
+								e.printStackTrace();
+							}
+							picChoosen_imagewidth = options_only_size.outWidth;
+							picChoosen_imageheight = options_only_size.outHeight;
+							//mBitmap.recycle();
+						}
 					}
-					
+
 				}
 				else
 				{
+					Logger.T(TAG, "else(2)");
 					curUri = intent.getData();
 					Logger.T(TAG, "Check intent data: " + curUri);
 				}
-				
-				if (curUri.getScheme().equals("file")) 
-				{					
-						curPath = curUri.getPath();					
-						String dataDir=RhodesActivity.safeGetInstance().getApplicationInfo().dataDir;
-						dataDir=dataDir+curPath.substring(curPath.lastIndexOf("/") );
-						
-					    if(getActualPropertyMap().get("fileName")==null)
-					    	{
-					    		getActualPropertyMap().put("fileName",dataDir);
-					    	}
-					    if(getActualPropertyMap().get("fileName").contains(".jpg"))
-					    	targetPath = getActualPropertyMap().get("fileName");
-					    else
-					    	targetPath = getActualPropertyMap().get("fileName")+".jpg";
-						File curFile = new File(curPath);
-						
-						if (!curPath.equals(targetPath)) 
-						{
+
+				if (curUri == null) {
+					curUri = intent.getData();
+				}
+
+				if (curUri.getScheme().equals("file"))
+				{
+					Logger.T(TAG, "curUri.getScheme().equals(file)");
+					curPath = curUri.getPath();
+					Logger.T(TAG, "curPath["+curPath+"]");
+					String dataDir=RhodesActivity.safeGetInstance().getApplicationInfo().dataDir;
+					dataDir=dataDir+curPath.substring(curPath.lastIndexOf("/") );
+
+					if(getActualPropertyMap().get("fileName")==null)
+					{
+						getActualPropertyMap().put("fileName",dataDir);
+					}
+					if(getActualPropertyMap().get("fileName").contains(".jpg"))
+					targetPath = getActualPropertyMap().get("fileName");
+					else
+					targetPath = getActualPropertyMap().get("fileName")+".jpg";
+					File curFile = new File(curPath);
+
+					if (!curPath.equals(targetPath))
+					{
 						//	Utils.copy(curPath, targetPath);
 						//	curFile.delete();
-							Logger.T(TAG, "File copied to " + targetPath);							
-							curUri = Uri.fromFile(new File(targetPath));
+						Logger.T(TAG, "File copied to " + targetPath);
+						curUri = Uri.fromFile(new File(targetPath));
+					}
+					imgPath = copyImg(curPath);
+					curUri = Uri.parse(imgPath);
+					copyImgAsUserChoice(curPath);
+
+					Logger.T(TAG, "imgPath ["+imgPath+"]");
+					Logger.T(TAG, "curUri ["+curUri+"]");
+					Logger.T(TAG, "curPath ["+curPath+"]");
+					Logger.T(TAG, "targetPath["+targetPath+"]");
+				}
+
+				String useRealBitmapResize = getActualPropertyMap().get("useRealBitmapResize");
+				if ((useRealBitmapResize != null) && (Boolean.parseBoolean(useRealBitmapResize))) {
+					Logger.T(TAG, "$$$ real resize start $$$");
+					try {
+						// resize to preffered size
+
+						Logger.T(TAG, "imgPath ["+imgPath+"]");
+						Logger.T(TAG, "rename ["+rename+"]");
+						String bitmapPath = imgPath;
+
+
+						BitmapFactory.decodeFile(bitmapPath, options_only_size);
+						picChoosen_imagewidth = options_only_size.outWidth;
+						picChoosen_imageheight = options_only_size.outHeight;
+
+						int idesiredWidth = 0;
+						int idesiredHeight = 0;
+						if (getActualPropertyMap().get("desiredWidth") != null) {
+							idesiredWidth = Integer.valueOf(getActualPropertyMap().get("desiredWidth"));
+						}
+						if (getActualPropertyMap().get("desiredHeight") != null) {
+							idesiredHeight = Integer.valueOf(getActualPropertyMap().get("desiredHeight"));
 						}
-						imgPath = copyImg(curPath);
-						curUri = Uri.parse(imgPath);
-						copyImgAsUserChoice(curPath);
+						Logger.T(TAG, " FILE ["+bitmapPath+"]	 orig["+picChoosen_imagewidth+"x"+picChoosen_imageheight+"] scaleto ["+idesiredHeight+"x"+idesiredHeight+"]");
+						if ((idesiredHeight > 0) && (idesiredWidth > 0)) {
+							// process resize
+							Logger.T(TAG, "Do SCALE  orig["+picChoosen_imagewidth+"x"+picChoosen_imageheight+"] scaleto ["+idesiredHeight+"x"+idesiredHeight+"]");
+
+
+							float fcurWidth = picChoosen_imagewidth;
+							float fcurHeight = picChoosen_imageheight;
+
+							float desiredWidth = idesiredWidth;
+							float desiredHeight = idesiredHeight;
+
+							float kw = desiredWidth / fcurWidth;
+							float kh = desiredHeight / fcurHeight;
+
+							if (kw > 1.0) {
+								if (kh > kw) {
+									kw = kw/kh;
+									kh = 1.0f;
+								}
+								else {
+									kh = kh/kw;
+									kw = 1.0f;
+								}
+							}
+							else {
+								if (kh > 1.0) {
+									kw = kw/kh;
+									kh = 1.0f;
+								}
+							}
+
+							float k = kw;
+							if (kw > kh) {
+								k = kh;
+							}
+
+							int newWidth = (int)(picChoosen_imagewidth*k);
+							int newHeight = (int)(picChoosen_imageheight*k);
+
+							BitmapFactory.Options bmOptions = new BitmapFactory.Options();
+							bmOptions.inJustDecodeBounds = false;
+							bmOptions.inSampleSize = picChoosen_imagewidth / newWidth;
+
+							picChoosen_imagewidth = newWidth;
+							picChoosen_imageheight = newHeight;
+
+
+							Logger.T(TAG, "Load samle scale ["+bmOptions.inSampleSize+"]");
+
+							bmOptions.inPurgeable = true;
+
+							Bitmap bitmap = BitmapFactory.decodeFile(bitmapPath, bmOptions);
+
+							Bitmap scaledBitmap=Bitmap.createScaledBitmap(bitmap, newWidth, newHeight, true);
+							ByteArrayOutputStream bos=new ByteArrayOutputStream();
+							scaledBitmap.compress(Bitmap.CompressFormat.JPEG, 75, bos);
+							bitmap.recycle();
+							bitmap=null;
+							OutputStream out;
+							out = new FileOutputStream(bitmapPath+"_tmp");
+							bos.writeTo(out);
+							bos.flush();
+
+							File file= new File(bitmapPath+"_tmp");
+							File file_old = new File(bitmapPath);
+							file_old.delete();
+							file.renameTo(new File(bitmapPath));
+							fixTheGalleryIssue(bitmapPath);
+
+
+						}
+					} catch (Exception e) {
+						// TODO: handle exception
+						e.printStackTrace();
+					}
+					Logger.T(TAG, "$$$ resize finished $$$");
 				}
+
 				try{
 					DefaultCameraAsyncTask async = new DefaultCameraAsyncTask(mMethodResult, resultMap, intent, resultCode);
-					async.execute();					
+					async.execute();
 				}
 				catch(Exception ex)
 				{
-										
-				}	
-			} 
-			else if (resultCode == Activity.RESULT_CANCELED) 
-			{	
+					ex.printStackTrace();
+				}
+			}
+			else if (resultCode == Activity.RESULT_CANCELED)
+			{
 				getActualPropertyMap().put("default_camera_key_path", "");
 				DefaultCameraAsyncTask async = new DefaultCameraAsyncTask(mMethodResult, resultMap, intent,resultCode);
 				async.execute();
@@ -240,7 +415,7 @@ public class CameraRhoListener extends AbstractRhoListener implements
 				mMethodResult.setError("Unknown error");
 			}
 		} catch (Throwable err) {
-			Logger.E(TAG, err);	
+			Logger.E(TAG, err);
 			if (stream != null) {
 				try {
 					stream.reset();
@@ -251,28 +426,28 @@ public class CameraRhoListener extends AbstractRhoListener implements
 			}
 			mMethodResult.setError(err.getMessage());
 		}
-		
+
 	}
 
 
 
-	private void fixTheGalleryIssue(String absoluteRenamedPath ) 
+	private void fixTheGalleryIssue(String absoluteRenamedPath )
 	{
-			if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT)
-			{
-				 MediaScannerConnection.scanFile(RhodesActivity.getContext(), new String[] {absoluteRenamedPath }, null, new MediaScannerConnection.OnScanCompletedListener() {
+		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT)
+		{
+			MediaScannerConnection.scanFile(RhodesActivity.getContext(), new String[] {absoluteRenamedPath }, null, new MediaScannerConnection.OnScanCompletedListener() {
 
-						public void onScanCompleted(String path, Uri uri) 
-			              {
-			              }
-			            });
+				public void onScanCompleted(String path, Uri uri)
+				{
+				}
+			});
 
-			}
-			else
-			{ 
+		}
+		else
+		{
 			RhodesActivity.getContext().sendBroadcast(new Intent(Intent.ACTION_MEDIA_MOUNTED, Uri.parse("file://" + Environment.getExternalStorageDirectory())));
-			} 
-		
+		}
+
 
 	}
 
@@ -284,9 +459,9 @@ public class CameraRhoListener extends AbstractRhoListener implements
 	void releaseMethodResult() {
 		mMethodResult = null;
 		resultMap.clear();
-		mActualPropertyMap.clear();
-		getActualPropertyMap().put("DeviceGallery_Key", "");
-		getActualPropertyMap().put("ChoosePicture_Key", "");
+		//mActualPropertyMap.clear();
+		//getActualPropertyMap().put("DeviceGallery_Key", "");
+		//getActualPropertyMap().put("ChoosePicture_Key", "");
 	}
 
 	void setActualPropertyMap(Map<String, String> propertyMap) {
@@ -296,264 +471,335 @@ public class CameraRhoListener extends AbstractRhoListener implements
 	Map<String, String> getActualPropertyMap() {
 		return mActualPropertyMap;
 	}
-	
+
 	/**
-	 * AsyncTask class to handle keydispatchingtimedout or ANR caused 
-	 * when OK or Cancel button of default camera in clicked 
-	 * @param  IMethodResult  Object to set the hash map properties
-	 * @param  HashMap to set properties of captured image to map
-	 * @param  Intent 
-	 * @param  ResultCode to decide click is OK or Cancel
-	 */
+	* AsyncTask class to handle keydispatchingtimedout or ANR caused
+	* when OK or Cancel button of default camera in clicked
+	* @param  IMethodResult  Object to set the hash map properties
+	* @param  HashMap to set properties of captured image to map
+	* @param  Intent
+	* @param  ResultCode to decide click is OK or Cancel
+	*/
 	public class DefaultCameraAsyncTask extends AsyncTask<Void, Void, Void>{
 
 		IMethodResult inMethodRes;
 		HashMap<String, Object> inResultMap = new HashMap<String,Object>();
 		Intent intent = new Intent();
 		int resCode;
-		
+
 		public DefaultCameraAsyncTask(IMethodResult inMethodRes, HashMap<String, Object> inResultMap, Intent intent, int resCode){
-            this.inMethodRes = inMethodRes;
-            this.inResultMap = inResultMap;
-            this.intent = intent;
-            this.resCode = resCode;
-        }
-		
+			this.inMethodRes = inMethodRes;
+			this.inResultMap = inResultMap;
+			this.intent = intent;
+			this.resCode = resCode;
+		}
+
 		@Override
 		protected Void doInBackground(Void... params) {
 
 			if(resCode == -1){
 				if (intent != null && intent.hasExtra("error")) {
-						inResultMap.put("message", ""+intent.getStringExtra("error"));
-						if(intent.getStringExtra("error").contains("\\"))
-							inResultMap.put("message", "File path is invalid.");
-						inResultMap.put("status", "error");
-					}
-				else{
-				inResultMap.put("status","ok");
-				if(CameraSingletonObject.deprecated_choose_pic || CameraObject.deprecated_take_pic){
-					inResultMap.put("image_uri",  "db/db-files/"+ curUri.toString().substring(curUri.toString().lastIndexOf("/")+1, curUri.toString().length()));
-					inResultMap.put("image_format",   "jpg");			
+					inResultMap.put("message", ""+intent.getStringExtra("error"));
+					if(intent.getStringExtra("error").contains("\\"))
+					inResultMap.put("message", "File path is invalid.");
+					inResultMap.put("status", "error");
 				}
 				else{
-					if((getActualPropertyMap().get("default_camera_key_path") != null) && (getActualPropertyMap().get("default_camera_key_path") != "")){
-						inResultMap.put("imageUri",  imgPath);
-						inResultMap.put("imageFormat",   "jpg");
-					}else{
-						inResultMap.put("imageUri",  curUri.toString());
-						inResultMap.put("imageFormat",   "jpg");
-					}			
-				}
-				if(picChoosen_imagewidth > 0){
+					inResultMap.put("status","ok");
 					if(CameraSingletonObject.deprecated_choose_pic || CameraObject.deprecated_take_pic){
-						inResultMap.put("image_width",  "" + picChoosen_imagewidth);
-						inResultMap.put("image_height",  "" + picChoosen_imageheight);
+						inResultMap.put("image_uri",  "db/db-files/"+ curUri.toString().substring(curUri.toString().lastIndexOf("/")+1, curUri.toString().length()));
+						inResultMap.put("image_format",   "jpg");
 					}
 					else{
-						inResultMap.put("imageWidth",  "" + picChoosen_imagewidth);
-						inResultMap.put("imageHeight",  "" + picChoosen_imageheight);
+						if((getActualPropertyMap().get("default_camera_key_path") != null) && (getActualPropertyMap().get("default_camera_key_path") != "")){
+							inResultMap.put("imageUri",  imgPath);
+							inResultMap.put("imageFormat",   "jpg");
+						}else{
+							inResultMap.put("imageUri",  curUri.toString());
+							inResultMap.put("imageFormat",   "jpg");
+						}
 					}
-				}
-				else{
-					if(CameraSingletonObject.deprecated_choose_pic || CameraObject.deprecated_take_pic){
-						inResultMap.put("image_width",  "" + picChoosen_imagewidth);
-						inResultMap.put("image_height",  "" + picChoosen_imageheight);
+					if(picChoosen_imagewidth > 0){
+						if(CameraSingletonObject.deprecated_choose_pic || CameraObject.deprecated_take_pic){
+							inResultMap.put("image_width",  "" + picChoosen_imagewidth);
+							inResultMap.put("image_height",  "" + picChoosen_imageheight);
+						}
+						else{
+							inResultMap.put("imageWidth",  "" + picChoosen_imagewidth);
+							inResultMap.put("imageHeight",  "" + picChoosen_imageheight);
+						}
 					}
 					else{
-						inResultMap.put("imageWidth",  "" + intent.getExtras().get("IMAGE_WIDTH"));
-						inResultMap.put("imageHeight",  "" + intent.getExtras().get("IMAGE_HEIGHT"));
+						if(CameraSingletonObject.deprecated_choose_pic || CameraObject.deprecated_take_pic){
+							inResultMap.put("image_width",  "" + picChoosen_imagewidth);
+							inResultMap.put("image_height",  "" + picChoosen_imageheight);
+						}
+						else{
+							inResultMap.put("imageWidth",  "" + intent.getExtras().get("IMAGE_WIDTH"));
+							inResultMap.put("imageHeight",  "" + intent.getExtras().get("IMAGE_HEIGHT"));
+						}
 					}
 				}
-				}
-				
+
 			}else if(resCode == 0){
-				
+
 				inResultMap.put("message", "User canceled operation.");
 				if (intent != null && intent.hasExtra("error")) {
 					inResultMap.put("message", ""+intent.getStringExtra("error"));
 					if(intent.getStringExtra("error").contains("\\"))
-						inResultMap.put("message", "File path is invalid.");
+					inResultMap.put("message", "File path is invalid.");
 					inResultMap.put("status", "error");
 				} else {
 					inResultMap.put("status", "cancel");
 				}
 			}
 			return null;
-			
-		}	
-		
+
+		}
+
 		@Override
 		protected void onPostExecute(Void result) {
 			super.onPostExecute(result);
 			inMethodRes.set(inResultMap);
+			cleanState();
 			releaseMethodResult();
 		}
-		
+
 	}
-	
+
 	/*
-	 * method to convert uri to file path
-	 * 
-	 * @param Uri of file
-	 * @returns String path of file
-	 * 
-	 */
+	* method to convert uri to file path
+	*
+	* @param Uri of file
+	* @returns String path of file
+	*
+	*/
 	private String getFilePath(Uri uri){
-		String mImgPath = null;
-		Cursor imageCursor = RhodesActivity.getContext().getContentResolver().query(
-				uri, null, null, null, null);
-		if(imageCursor.moveToFirst()){
-			mImgPath = imageCursor.getString(imageCursor
-					.getColumnIndex(MediaColumns.DATA));
-			imageCursor.close();
-		
-		}
-		return mImgPath;
-	}
-	
-	/**
-	 * Copy image.
-	 * Function to copy image from sd card to application root path
-	 *  
-	 * @param photo
-	 *            the photo
-	 * @return the string
-	 */
-	public String copyImg(String imgPath){
-		
-		File oldFile = new File(imgPath);
-		
-		int lastIndex  = rename.lastIndexOf("/");
-		
-		String file_name= rename.substring(lastIndex+1, rename.length());
-		
-		File mediafile  =  new File(RhoFileApi.getDbFilesPath(), file_name);
-		
-		//File mediafile  =  new File(RhoFileApi.getDbFilesPath(), rename);
-		FileInputStream finput= null;
-		FileOutputStream fout = null;
+		String resultPath = null;
 		try {
-			finput = new FileInputStream(oldFile);
-			fout = new FileOutputStream(mediafile);
-			byte[] b = new byte[1024];
-			int read = 0;
-			while ((read = finput.read(b)) != -1) {
-				fout.write(b, 0, read);
+			String mImgPath = null;
+			Cursor imageCursor = RhodesActivity.getContext().getContentResolver().query(
+			uri, null, null, null, null);
+			if(imageCursor.moveToFirst()){
+				mImgPath = imageCursor.getString(imageCursor
+				.getColumnIndex(MediaColumns.DATA));
+				imageCursor.close();
 			}
-		} catch (FileNotFoundException e) {
+			resultPath = mImgPath;
+		}
+		catch (Exception e) {
 			e.printStackTrace();
-		} catch (IOException e) {
+		}
+		try {
+			if (resultPath == null) {
+
+				Uri selectedImage = uri;
+				String[] filePathColumn = { MediaStore.Images.Media.DATA };
+
+				Cursor cursor = RhodesActivity.getContext().getContentResolver().query(selectedImage,
+				filePathColumn, null, null, null);
+				cursor.moveToFirst();
+
+				int columnIndex = cursor.getColumnIndex(filePathColumn[0]);
+				resultPath = cursor.getString(columnIndex);
+				cursor.close();
+
+			}
+		}
+		catch (Exception e) {
 			e.printStackTrace();
-		} finally {
-			if(finput != null){
-				try {
-					finput.close();
-				} catch (IOException e) {
-					e.printStackTrace();
-				}
+		}
+		return resultPath;
+	}
+
+
+
+
+/**
+* Copy image.
+* Function to copy image from sd card to application root path
+*
+* @param photo
+*			the photo
+* @return the string
+*/
+public String copyImg(String imgPath){
+
+	File oldFile = new File(imgPath);
+
+	int lastIndex  = rename.lastIndexOf("/");
+
+	String file_name= rename.substring(lastIndex+1, rename.length());
+
+	File mediafile  =  new File(RhoFileApi.getDbFilesPath(), file_name);
+
+	//File mediafile  =  new File(RhoFileApi.getDbFilesPath(), rename);
+	FileInputStream finput= null;
+	FileOutputStream fout = null;
+	try {
+		finput = new FileInputStream(oldFile);
+		fout = new FileOutputStream(mediafile);
+		byte[] b = new byte[1024];
+		int read = 0;
+		while ((read = finput.read(b)) != -1) {
+			fout.write(b, 0, read);
+		}
+	} catch (FileNotFoundException e) {
+		e.printStackTrace();
+	} catch (IOException e) {
+		e.printStackTrace();
+	} finally {
+		if(finput != null){
+			try {
+				finput.close();
+			} catch (IOException e) {
+				e.printStackTrace();
 			}
-			
-			if(fout != null){
-				try {
-					fout.close();
-				} catch (IOException e) {
-					e.printStackTrace();
-				}
+		}
+
+		if(fout != null){
+			try {
+				fout.close();
+			} catch (IOException e) {
+				e.printStackTrace();
 			}
 		}
-		
-		return mediafile.getAbsolutePath();
 	}
-	
-	/**
-	 * copyImgAsUserChoice image.
-	 * Function to copy image from sd card to User specific path
-	 *  Provided in TestCam.html file.
-	 * @param photo
-	 *            the photo
-	 * 
-	 */
-	public void copyImgAsUserChoice(String imgPath){
+
+	return mediafile.getAbsolutePath();
+}
+
+
+public String copyImgToTarget(String srcPath, String dstPath) {
+
+	File oldFile = new File(srcPath);
+	File mediafile  =  new File(dstPath);
+
+	//File mediafile  =  new File(RhoFileApi.getDbFilesPath(), rename);
+	FileInputStream finput= null;
+	FileOutputStream fout = null;
+	try {
+		finput = new FileInputStream(oldFile);
+		fout = new FileOutputStream(mediafile);
+		byte[] b = new byte[1024];
+		int read = 0;
+		while ((read = finput.read(b)) != -1) {
+			fout.write(b, 0, read);
+		}
+	} catch (FileNotFoundException e) {
+		e.printStackTrace();
+	} catch (IOException e) {
+		e.printStackTrace();
+	} finally {
+		if(finput != null){
+			try {
+				finput.close();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+		}
+
+		if(fout != null){
+			try {
+				fout.close();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+		}
+	}
+
+	return mediafile.getAbsolutePath();
+}
+
+/**
+* copyImgAsUserChoice image.
+* Function to copy image from sd card to User specific path
+*  Provided in TestCam.html file.
+* @param photo
+*			the photo
+*
+*/
+public void copyImgAsUserChoice(String imgPath){
 	if(rename.contains("sdcard")){
-			
+
 		Boolean isSDPresent = android.os.Environment.getExternalStorageState().equals(android.os.Environment.MEDIA_MOUNTED);
-		
 
-			if(isSDPresent)
-			{
-	
-				File oldFile = new File(imgPath);
-				
-				int lastIndex = rename.lastIndexOf("/");
-				
-				String subfolderName = rename.replaceAll("/sdcard", "");
-				String folderName = subfolderName.substring(subfolderName.indexOf("/")+1,subfolderName.lastIndexOf("/"));
-				
-				String file_name= rename.substring(lastIndex+1, rename.length());
-				
-				File directory = new File(Environment.getExternalStorageDirectory()+File.separator + folderName);
-				boolean flag = directory.mkdirs();
-				
-				File mediafile  =  new File(directory +File.separator  + file_name);
-				
-				
-				FileInputStream finput= null;
-				FileOutputStream fout = null;
-				try {
-					finput = new FileInputStream(oldFile);
-					fout = new FileOutputStream(mediafile);
-					byte[] b = new byte[1024];
-					int read = 0;
-					while ((read = finput.read(b)) != -1) {
-						fout.write(b, 0, read);
-					}
-				} catch (FileNotFoundException e) {
-					e.printStackTrace();
-				} catch (IOException e) {
-					e.printStackTrace();
-				} finally {
-					if(finput != null){
-						try {
-							finput.close();
-							
-						} catch (IOException e) {
-							e.printStackTrace();
-						}
+
+		if(isSDPresent)
+		{
+
+			File oldFile = new File(imgPath);
+
+			int lastIndex = rename.lastIndexOf("/");
+
+			String subfolderName = rename.replaceAll("/sdcard", "");
+			String folderName = subfolderName.substring(subfolderName.indexOf("/")+1,subfolderName.lastIndexOf("/"));
+
+			String file_name= rename.substring(lastIndex+1, rename.length());
+
+			File directory = new File(Environment.getExternalStorageDirectory()+File.separator + folderName);
+			boolean flag = directory.mkdirs();
+
+			File mediafile  =  new File(directory +File.separator  + file_name);
+
+
+			FileInputStream finput= null;
+			FileOutputStream fout = null;
+			try {
+				finput = new FileInputStream(oldFile);
+				fout = new FileOutputStream(mediafile);
+				byte[] b = new byte[1024];
+				int read = 0;
+				while ((read = finput.read(b)) != -1) {
+					fout.write(b, 0, read);
+				}
+			} catch (FileNotFoundException e) {
+				e.printStackTrace();
+			} catch (IOException e) {
+				e.printStackTrace();
+			} finally {
+				if(finput != null){
+					try {
+						finput.close();
+
+					} catch (IOException e) {
+						e.printStackTrace();
 					}
-					
-					if(fout != null){
-						try {
-							fout.close();
-						} catch (IOException e) {
-							e.printStackTrace();
-						}
+				}
+
+				if(fout != null){
+					try {
+						fout.close();
+					} catch (IOException e) {
+						e.printStackTrace();
 					}
 				}
-				deleteImage();
 			}
-			
-			
+			deleteImage();
 		}
+
+
 	}
+}
 
 /**
- * deleteImage image.
- * Function for Deleting the Image from SD card.
- * And maintain a copy of same Image at user specific Path  
- * @param nothing
- * 
- */
+* deleteImage image.
+* Function for Deleting the Image from SD card.
+* And maintain a copy of same Image at user specific Path
+* @param nothing
+*
+*/
 public void deleteImage(){
 	String storageLocation = null;
 	storageLocation = Environment.getExternalStorageDirectory().toString();
-	
+
 	int lastIndex = rename.lastIndexOf("/");
 	String file_name= rename.substring(lastIndex+1, rename.length());
-	
+
 	File file = new File(storageLocation + "/Pictures/"+file_name);
-	  if(file.exists()){
-		  file.delete();
-	  }
-   }
-   
+	if(file.exists()){
+		file.delete();
+	}
+}
+
 }