logo
搜索
我的图书馆

发文章

发文工具

其他工具

留言交流
搜索
分享

Android拍照，上传，预览综合【修改】

 旭龙 2012-10-09

转载自 http://aokunsang./blog/1295813


最近需要做手机拍照【两种方式：调用系统相机(博客最后);自己写照相机布局】，预览，上传功能。特地研究了下android的手机拍照。

参考地址：

http://blog.csdn.net/cfwdl/article/details/5746708

http://mjbb./blog/1018006

http://blog.csdn.net/hellogv/article/details/5962494


1、上传文件功能网上很多讲的，只要细心点，按照格式来写发送的数据，都是没有问题的。如果遇到问题，欢迎留言讨论、

2、预览使用Gallery和ImageSwitcher就行，我做的很简单(参考代码)。

----------------------------------------------------------------------------------------------------------------------

修改内容：

          1、照相功能使用系统自带照相机(自己写的照相机属性设置根据不同照相机会有问题，所以舍弃)

          2、预览功能不再使用Gallery+ImageSwitcher;实用性不强，并且显示慢且卡。改用异步加载

          3、上传图片时，对图片进行压缩，增加上传速度。

          4、长按gridView进入编辑模式，批量删除图片。参考http://aokunsang./blog/1668902

  以此，希望能做到最好的用户体验。


附上流程图：


 
拍照功能：【预览尺寸有知道的朋友留言告知。】
Java代码  收藏代码
  1. * 拍照  
  2. * @author Administrator  
  3. */  
  4. ublic class TakePhotoAct extends Activity implements SurfaceHolder.Callback{  
  5.   
  6. private static String imgPath = Environment.getExternalStorageDirectory().getPath() + "/"+Const.imageDir;  
  7.   
  8. private SurfaceView surfaceView;   //相机画布  
  9. private SurfaceHolder surfaceHolder;   
  10. private Button takePicView,exitView;  
  11.   
  12. private Camera mCamera;    //照相机  
  13.   
  14. @Override  
  15.    public void onCreate(Bundle savedInstanceState) {  
  16.       
  17.        super.onCreate(savedInstanceState);  
  18.        setContentView(R.layout.main);  
  19. /这里我在AndroidManifest.xml的activity中添加了android:theme="@android:style/Theme.NoTitleBar.Fullscreen"  
  20.   
  21.        /** 
  22.         * 隐藏状态栏和标题栏 
  23.          
  24.        this.getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN); 
  25.        requestWindowFeature(Window.FEATURE_NO_TITLE); 
  26.        */  
  27.        //setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);  //横屏  
  28.        /** 
  29.         * 获取Button并且设置事件监听 
  30.         */  
  31.        takePicView = (Button)this.findViewById(R.id.takepic);  
  32.        takePicView.setOnClickListener(TakePicListener);  
  33.        exitView = (Button)this.findViewById(R.id.exit);  
  34.        exitView.setOnClickListener(new OnClickListener() {  
  35.         @Override  
  36.         public void onClick(View v) {  
  37.             finish();  
  38.         }  
  39.     });  
  40.        surfaceView = (SurfaceView)this.findViewById(R.id.surface_camera);  
  41.        surfaceHolder = surfaceView.getHolder();  
  42.        surfaceHolder.addCallback(this);  
  43.        surfaceHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);  
  44.          
  45.        checkSoftStage();  //首先检测SD卡是否存在  
  46.    }  
  47.   
  48. /** 
  49.  * 检测手机是否存在SD卡,网络连接是否打开 
  50.  */  
  51. private void checkSoftStage(){  
  52.     if(Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)){  //判断是否存在SD卡  
  53. /           String rootPath = Environment.getExternalStorageDirectory().getPath();  //获取SD卡的根目录  
  54.         File file = new File(imgPath);  
  55.         if(!file.exists()){  
  56.             file.mkdir();  
  57.         }  
  58.     }else{  
  59.         new AlertDialog.Builder(this).setMessage("检测到手机没有存储卡！请插入手机存储卡再开启本应用。")  
  60.             .setPositiveButton("确定", new DialogInterface.OnClickListener() {  
  61.                 @Override  
  62.                 public void onClick(DialogInterface dialog, int which) {  
  63.                     finish();  
  64.                 }  
  65.             }).show();  
  66.     }  
  67. }  
  68.   
  69. /** 
  70.  * 点击拍照按钮,启动拍照 
  71.  */  
  72. private final OnClickListener TakePicListener = new OnClickListener(){  
  73.     @Override  
  74.     public void onClick(View v) {  
  75.         mCamera.autoFocus(new AutoFoucus());  //自动对焦  
  76.     }  
  77. };  
  78.   
  79. /** 
  80.  * 自动对焦后拍照 
  81.  * @author aokunsang 
  82.  * @Date 2011-12-5 
  83.  */  
  84. private final class AutoFoucus implements AutoFocusCallback{  
  85.     @Override  
  86.     public void onAutoFocus(boolean success, Camera camera) {  
  87.         if(success && mCamera!=null){  
  88.             mCamera.takePicture(mShutterCallback, null, mPictureCallback);  
  89.         }  
  90.     }  
  91. }  
  92. /** 
  93.  * 重点对象、 此处实例化了一个本界面的PictureCallback 
  94.  * 当用户拍完一张照片的时候触发，这时候对图片处理并保存操作。 
  95.  *  
  96.  */  
  97. private final PictureCallback mPictureCallback = new PictureCallback() {  
  98.     @Override  
  99.     public void onPictureTaken(byte[] data, Camera camera) {  
  100.         try {  
  101.             String fileName = System.currentTimeMillis()+".jpg";  
  102.             File file = new File(imgPath,fileName);  
  103.             Bitmap bm = BitmapFactory.decodeByteArray(data, 0, data.length);  
  104.             BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(file));  
  105.             bm.compress(Bitmap.CompressFormat.JPEG, 60, bos);  
  106.             bos.flush();  
  107.             bos.close();  
  108.               
  109.             Intent intent = new Intent(TakePhotoAct.this,PictureViewAct.class);  
  110.             intent.putExtra("imagePath", file.getPath());  
  111.             startActivity(intent);  
  112.         } catch (Exception e) {  
  113.             e.printStackTrace();  
  114.         }  
  115.     }  
  116. };  
  117. /**  
  118. * 在相机快门关闭时候的回调接口，通过这个接口来通知用户快门关闭的事件，  
  119. * 普通相机在快门关闭的时候都会发出响声，根据需要可以在该回调接口中定义各种动作， 例如：使设备震动  
  120. */    
  121. private final ShutterCallback mShutterCallback = new ShutterCallback() {    
  122.     public void onShutter() {    
  123.         Log.d("ShutterCallback", "...onShutter...");    
  124.     }    
  125. };  
  126.   
  127. @Override  
  128. /** 
  129.  * 初始化相机参数，比如相机的参数: 像素, 大小,格式 
  130.  */  
  131. public void surfaceChanged(SurfaceHolder holder, int format, int width,  
  132.         int height) {  
  133.     Camera.Parameters param = mCamera.getParameters();  
  134.     /** 
  135.      * 设置拍照图片格式 
  136.      */  
  137.     param.setPictureFormat(PixelFormat.JPEG);  
  138.     /** 
  139.      * 设置预览尺寸【这里需要注意：预览尺寸有些数字正确，有些会报错，不清楚为啥】 
  140.      */  
  141.     //param.setPreviewSize(320, 240);  
  142.     /** 
  143.      * 设置图片大小 
  144.      */  
  145.     param.setPictureSize(Const.width, Const.height);  
  146.     mCamera.setParameters(param);  
  147.     /** 
  148.      * 开始预览 
  149.      */  
  150.     mCamera.startPreview();  
  151. }  
  152. @Override  
  153. /** 
  154.  * 打开相机,设置预览 
  155.  */  
  156. public void surfaceCreated(SurfaceHolder holder) {  
  157.     try {  
  158.         mCamera = Camera.open();  //打开摄像头  
  159.         mCamera.setPreviewDisplay(holder);  
  160.     } catch (IOException e) {  
  161.         mCamera.release();  
  162.         mCamera = null;  
  163.     }  
  164. }  
  165.   
  166. @Override  
  167. /** 
  168.  * 预览界面被关闭时，或者停止相机拍摄;释放相机资源 
  169.  */  
  170. public void surfaceDestroyed(SurfaceHolder holder) {  
  171.     mCamera.stopPreview();  
  172.     if(mCamera!=null) mCamera.release();  
  173.     mCamera = null;  
  174. }  
  175.   
  176. @Override  
  177. public boolean onKeyDown(int keyCode, KeyEvent event) {  
  178.     if(keyCode == KeyEvent.KEYCODE_CAMERA){   //按下相机实体按键，启动本程序照相功能  
  179.         mCamera.autoFocus(new AutoFoucus());  //自动对焦  
  180.         return true;  
  181.     }else{  
  182.         return false;  
  183.     }  
  184. }  
  xml：
Xml代码  收藏代码
  1. <?xml version="1.0" encoding="utf-8"?>  
  2. <LinearLayout xmlns:android="http://schemas./apk/res/android"  
  3.     android:orientation="vertical"  
  4.     android:layout_width="fill_parent"  
  5.     android:layout_height="fill_parent"  
  6.     >  
  7.     <SurfaceView   
  8.         android:id="@+id/surface_camera"  
  9.         android:layout_width="fill_parent"  
  10.         android:layout_height="fill_parent"  
  11.         android:layout_weight="1"  
  12.     />  
  13. <LinearLayout   
  14.     android:orientation="horizontal"  
  15.     android:layout_width="fill_parent"  
  16.     android:layout_height="wrap_content">  
  17.       
  18.     <Button   
  19.         android:text="拍照"  
  20.         android:layout_width="wrap_content"  
  21.         android:layout_height="wrap_content"  
  22.         android:id="@+id/takepic"  
  23.     />  
  24.     <Button   
  25.         android:text="退出"  
  26.         android:layout_width="wrap_content"  
  27.         android:layout_height="wrap_content"  
  28.         android:id="@+id/exit"  
  29.     />  
  30. </LinearLayout>  
  31. </LinearLayout>  
 预览功能：
 /**
Java代码  收藏代码
  1.  * 图片预览  
  2.  * @author： aokunsang  
  3.  * @date： 2012-8-1  
  4.  */  
  5. public class PictureScanAct extends Activity {  
  6.   
  7.     private GridView gridView;  
  8.     private ImageAdapter imgAdapter;  
  9.     private List<String> fileNameList = new ArrayList<String>();  
  10.       
  11.     @Override  
  12.     protected void onCreate(Bundle savedInstanceState) {  
  13.           
  14.         super.onCreate(savedInstanceState);  
  15.         setContentView(R.layout.picturescan);  
  16.           
  17.         gridView = (GridView)findViewById(R.id.picture_grid);  
  18.         imgAdapter = new ImageAdapter(this);  
  19.         gridView.setAdapter(imgAdapter);  
  20.         gridView.setOnItemClickListener(new AdapterView.OnItemClickListener() {  
  21.             @Override  
  22.             public void onItemClick(AdapterView<?> parent, View view,  
  23.                     int position, long id) {  
  24.                 String fileName = fileNameList.get(position);  
  25.                 startActivity(new Intent(PictureScanAct.this, PictureViewAct.class).putExtra("flag","upload").putExtra("imagePath",fileName));  
  26.             }  
  27.         });  
  28.         //setProgressBarIndeterminateVisibility(true);  
  29.         Toast.makeText(this, "加载图片中....", Toast.LENGTH_LONG).show();  
  30.         new AsyncLoadedImage().execute();  
  31.     }  
  32.     /** 
  33.      * 向适配器添加图片 
  34.      * @param bitmap 
  35.      */  
  36.     private void addImage(Bitmap... loadImages){  
  37.         for(Bitmap loadImage:loadImages){  
  38.             imgAdapter.addPhoto(loadImage);  
  39.         }  
  40.     }  
  41.     /** 
  42.      * 释放内存 
  43.      */  
  44.     protected void onDestroy() {  
  45.         super.onDestroy();  
  46.         final GridView grid = gridView;  
  47.         final int count = grid.getChildCount();  
  48.         ImageView v = null;  
  49.         for (int i = 0; i < count; i++) {  
  50.             v = (ImageView) grid.getChildAt(i);  
  51.             ((BitmapDrawable) v.getDrawable()).setCallback(null);  
  52.         }  
  53.     }  
  54.     /** 
  55.      * 异步加载图片展示 
  56.      * @author： aokunsang 
  57.      * @date： 2012-8-1 
  58.      */  
  59.      class AsyncLoadedImage extends AsyncTask<Object, Bitmap, Boolean> {  
  60.   
  61.         @Override  
  62.         protected Boolean doInBackground(Object... params) {  
  63.             File fileDir = new File(Const.imgPath);  
  64.             File[] files = fileDir.listFiles();  
  65.             boolean result = false;  
  66.             if(files!=null){  
  67.                 for(File file:files){  
  68.                     String fileName = file.getName();  
  69.                     if (fileName.lastIndexOf(".") > 0    
  70.                             && fileName.substring(fileName.lastIndexOf(".") + 1,    
  71.                             fileName.length()).equals("jpg")){  
  72.                         Bitmap bitmap;  
  73.                         Bitmap newBitmap;  
  74.                          try {  
  75.                             BitmapFactory.Options options = new BitmapFactory.Options();  
  76.                             options.inSampleSize = 10;  
  77.                             bitmap = BitmapFactory.decodeFile(file.getPath(), options);  
  78.                             newBitmap = ThumbnailUtils.extractThumbnail(bitmap, 100, 100);  
  79.                             bitmap.recycle();  
  80.                             if (newBitmap != null) {  
  81.                                 fileNameList.add(file.getPath());  
  82.                                 publishProgress(newBitmap);  
  83.                                 result = true;  
  84.                             }  
  85.                         } catch (Exception e) {  
  86.                             e.printStackTrace();  
  87.                         }  
  88.                     }  
  89.                 }  
  90.             }  
  91.             return result;  
  92.         }  
  93.         @Override  
  94.         public void onProgressUpdate(Bitmap... value) {  
  95.             addImage(value);  
  96.         }  
  97.         @Override  
  98.         protected void onPostExecute(Boolean result) {  
  99.             if(!result){  
  100.                 showDialog(1);  
  101.             }  
  102.         }  
  103.      }  
  104.      @Override  
  105.     protected Dialog onCreateDialog(int id) {  
  106.          AlertDialog dialog = new AlertDialog.Builder(PictureScanAct.this).setTitle("温馨提示").setMessage("暂时还没有照片,请先采集照片！")  
  107.             .setPositiveButton("确定", new DialogInterface.OnClickListener(){  
  108.                 @Override  
  109.                 public void onClick(DialogInterface dialog, int which) {  
  110.                     startActivity(new Intent(PictureScanAct.this,TakePhotoAct.class));  
  111.                 }  
  112.             }).setNegativeButton("取消", new DialogInterface.OnClickListener() {  
  113.                 @Override  
  114.                 public void onClick(DialogInterface dialog, int which) {  
  115.                     finish();  
  116.                 }  
  117.             }).show();  
  118.          return dialog;  
  119.     }  
  120. }  
 
   GridView适配器：
     public class ImageAdapter extends BaseAdapter {
Java代码  收藏代码
  1. private List<Bitmap> picList = new ArrayList<Bitmap>();  
  2. private Context mContext;  
  3. public ImageAdapter(Context mContext){  
  4.     this.mContext = mContext;  
  5. }  
  6.   
  7. @Override  
  8. public int getCount() {  
  9.     return picList.size();  
  10. }  
  11.   
  12. /* (non-Javadoc) 
  13.  * @see android.widget.Adapter#getItem(int) 
  14.  */  
  15. @Override  
  16. public Object getItem(int position) {  
  17.     // TODO Auto-generated method stub  
  18.     return picList.get(position);  
  19. }  
  20. /** 
  21.  * 添加图片 
  22.  * @param bitmap 
  23.  */  
  24. public void addPhoto(Bitmap loadImage){  
  25.     picList.add(loadImage);  
  26.     notifyDataSetChanged();  
  27. }  
  28.   
  29. /* (non-Javadoc) 
  30.  * @see android.widget.Adapter#getItemId(int) 
  31.  */  
  32. @Override  
  33. public long getItemId(int position) {  
  34.     // TODO Auto-generated method stub  
  35.     return position;  
  36. }  
  37.   
  38. @Override  
  39. public View getView(int position, View convertView, ViewGroup parent) {  
  40.     ImageView imageView = null;  
  41.     if(convertView == null){  
  42.         imageView = new ImageView(mContext);  
  43.         imageView.setLayoutParams(new GridView.LayoutParams(110, 110));    
  44.         imageView.setScaleType(ImageView.ScaleType.CENTER_CROP);    
  45.         imageView.setPadding(5,5,5,5);  
  46.     }else{  
  47.         imageView = (ImageView)convertView;  
  48.     }  
  49.     imageView.setImageBitmap(picList.get(position));  
  50.     return imageView;  
  51. }  
 
   图片预览界面：
  
     <?xml version="1.0" encoding="utf-8"?>
Xml代码  收藏代码
  1. <GridView xmlns:android="http://schemas./apk/res/android"  
  2.     android:id="@+id/picture_grid"  
  3.     android:layout_width="match_parent"  
  4.     android:layout_height="match_parent"   
  5.     android:numColumns="4"  
  6.     android:verticalSpacing="5dip"  
  7.     android:horizontalSpacing="5dip"  
  8.     android:stretchMode="columnWidth"  
  9.     android:columnWidth="120dip"  
  10.     android:gravity="center"      
  11.     >  
  12. </GridView>  
 
   
   预览图片：
   



   

   上传工具类：
Java代码  收藏代码
  1. import java.io.BufferedReader;  
  2. import java.io.DataOutputStream;  
  3. import java.io.FileInputStream;  
  4. import java.io.InputStream;  
  5. import java.io.InputStreamReader;  
  6. import java.net.HttpURLConnection;  
  7. import java.net.URL;  
  8. import java.util.Map;  
  9. import java.util.Map.Entry;  
  10.   
  11. import android.util.Log;  
  12.   
  13. import com.peacemap.photo.po.FileInfo;  
  14.   
  15. /** 
  16.  * POST上传文件 
  17.  * @author aokunsang 
  18.  * @Date 2011-12-6 
  19.  */  
  20. public class PostFile {  
  21.   
  22.     private static PostFile postFile = new PostFile();  
  23.       
  24.     private final static String LINEND = "\r\n";  
  25.     private final static String BOUNDARY = "---------------------------7da2137580612"; //数据分隔线  
  26.     private final static String PREFIX = "--";  
  27.     private final static String MUTIPART_FORMDATA = "multipart/form-data";  
  28.     private final static String CHARSET = "utf-8";  
  29.     private final static String CONTENTTYPE = "application/octet-stream";  
  30.       
  31.     private PostFile(){}  
  32.     public static PostFile getInstance(){  
  33.         return postFile;  
  34.     }  
  35.       
  36.     /** 
  37.      * HTTP上传文件 
  38.      * @param actionUrl  请求服务器的路径 
  39.      * @param params     传递的表单内容 
  40.      * @param files      多个文件信息 
  41.      * @return 
  42.      */  
  43.     public String post(String actionUrl,Map<String,String> params,FileInfo[] files){  
  44.         try {  
  45.             URL url = new URL(actionUrl);  
  46.             HttpURLConnection urlConn = (HttpURLConnection)url.openConnection();  
  47.             urlConn.setDoOutput(true);   //允许输出  
  48.             urlConn.setDoInput(true);   //允许输入  
  49.             urlConn.setUseCaches(false);  
  50.             urlConn.setRequestMethod("POST");  
  51.             urlConn.setRequestProperty("connection", "Keep-Alive");  
  52.             urlConn.setRequestProperty("Charset", CHARSET);  
  53.             urlConn.setRequestProperty("Content-Type", MUTIPART_FORMDATA+";boundary="+BOUNDARY);  
  54.               
  55.             DataOutputStream dos = new DataOutputStream(urlConn.getOutputStream());  
  56.             //构建表单数据  
  57.             String entryText = bulidFormText(params);  
  58.             Log.i("-------描述信息---------------", entryText);  
  59.             dos.write(entryText.getBytes());  
  60.               
  61.             StringBuffer sb = new StringBuffer("");  
  62.       
  63.             for(FileInfo file : files){  
  64.                 sb.append(PREFIX).append(BOUNDARY).append(LINEND);  
  65.                 sb.append("Content-Disposition: form-data; name=\""+file.getFileTextName()+"\"; filename=\""+file.getFile().getAbsolutePath()+"\""+LINEND);  
  66.                 sb.append("Content-Type:"+CONTENTTYPE+";charset="+CHARSET+LINEND);  
  67.                 sb.append(LINEND);  
  68.                 dos.write(sb.toString().getBytes());  
  69.                   
  70.                 InputStream is = new FileInputStream(file.getFile());  
  71.                 byte[] buffer = new byte[1024];  
  72.                 int len = 0;  
  73.                 while ((len = is.read(buffer)) != -1) {  
  74.                     dos.write(buffer, 0, len);  
  75.                 }  
  76.                 is.close();  
  77.                 dos.write(LINEND.getBytes());  
  78.             }  
  79.             //请求的结束标志  
  80.             byte[] end_data = (PREFIX + BOUNDARY + PREFIX + LINEND).getBytes();  
  81.             dos.write(end_data);  
  82.             dos.flush();  
  83.     //-----------------------------------  发送请求数据结束  ----------------------------  
  84.               
  85.     //----------------------------------   接收返回信息 ------------------------  
  86.               
  87.             int code = urlConn.getResponseCode();  
  88.             if(code!=200){  
  89.                 urlConn.disconnect();  
  90.                 return "";  
  91.             }else{  
  92.                 BufferedReader br = new BufferedReader(new InputStreamReader(urlConn.getInputStream()));  
  93.                 String result = "";  
  94.                 String line = null;  
  95.                 while((line = br.readLine())!=null){  
  96.                     result += line;  
  97.                 }  
  98.                 br.close();  
  99.                 urlConn.disconnect();  
  100.                 return result;  
  101.             }  
  102.         } catch (Exception e) {  
  103.             Log.e("--------上传图片错误--------", e.getMessage());  
  104.             return null;  
  105.         }  
  106.     }  
  107.       
  108.     /** 
  109.      * HTTP上传单个文件 
  110.      * @param actionUrl  请求服务器的路径 
  111.      * @param params     传递的表单内容 
  112.      * @param files      单个文件信息 
  113.      * @return 
  114.      */  
  115.     public String post(String actionUrl,Map<String,String> params,FileInfo fileInfo){  
  116.         return post(actionUrl, params, new FileInfo[]{fileInfo});  
  117.     }  
  118.       
  119.     /** 
  120.      * 封装表单文本数据 
  121.      * @param paramText 
  122.      * @return 
  123.      */  
  124.     private String bulidFormText(Map<String,String> paramText){  
  125.         if(paramText==null || paramText.isEmpty()) return "";  
  126.         StringBuffer sb = new StringBuffer("");  
  127.         for(Entry<String,String> entry : paramText.entrySet()){   
  128.             sb.append(PREFIX).append(BOUNDARY).append(LINEND);  
  129.             sb.append("Content-Disposition:form-data;name=\""  
  130.                     + entry.getKey() + "\"" + LINEND);  
  131. //          sb.append("Content-Type:text/plain;charset=" + CHARSET + LINEND);  
  132.             sb.append(LINEND);  
  133.             sb.append(entry.getValue());  
  134.             sb.append(LINEND);  
  135.         }  
  136.         return sb.toString();  
  137.     }  
  138.     /** 
  139.      * 封装文件文本数据 
  140.      * @param files 
  141.      * @return 
  142.      */  
  143.     private String buildFromFile(FileInfo[] files){  
  144.         StringBuffer sb = new StringBuffer();  
  145.         for(FileInfo file : files){  
  146.             sb.append(PREFIX).append(BOUNDARY).append(LINEND);  
  147.             sb.append("Content-Disposition: form-data; name=\""+file.getFileTextName()+"\"; filename=\""+file.getFile().getAbsolutePath()+"\""+LINEND);  
  148.             sb.append("Content-Type:"+CONTENTTYPE+";charset="+CHARSET+LINEND);  
  149.             sb.append(LINEND);  
  150.         }  
  151.         return sb.toString();  
  152.     }  
  153. }  
    上传图片时对图片进行压缩处理(压缩处理程序)：
   /**
Java代码  收藏代码
  1.      * 压缩图片上传  
  2.      * @param picPath  
  3.      * @return  
  4.      */  
  5.     private synchronized File compressPicture(String picPath){  
  6.           
  7.            String fileName = picPath.substring(picPath.lastIndexOf("/"));  
  8.           
  9.             Bitmap bitmap = BitmapFactory.decodeFile(picPath);  
  10.             //获取这个图片的宽和高     
  11.             int width = bitmap.getWidth();     
  12.             int height = bitmap.getHeight();     
  13.         
  14.             //设置上传时候，图片的宽度和高度     
  15.             int newWidth = 640;     
  16.             int newHeight = 480;     
  17.         
  18.             //计算缩放率，新尺寸除原始尺寸     
  19.             float scaleWidth = ((float) newWidth) / width;     
  20.             float scaleHeight = ((float) newHeight) / height;     
  21.         
  22.             // 创建操作图片用的matrix对象     
  23.             Matrix matrix = new Matrix();     
  24.             // 缩放图片动作     
  25.             matrix.postScale(scaleWidth, scaleHeight);     
  26.             //旋转图片 动作     
  27.             //matrix.postRotate(45);     
  28.         
  29.             // 创建新的图片     
  30.             Bitmap resizedBitmap = Bitmap.createBitmap(bitmap, 0, 0,     
  31.                               width, height, matrix, true);     
  32.              
  33.            //保存入sdCard    
  34.            File file = new File(Const.thumbnailPath+fileName);    
  35.            try {    
  36.             FileOutputStream out = new FileOutputStream(file);    
  37.             if(resizedBitmap.compress(Bitmap.CompressFormat.JPEG, 100, out)){    
  38.                 out.flush();    
  39.                 out.close();    
  40.             }  
  41.         } catch (Exception e) {   
  42.             e.printStackTrace();  
  43.             return new File(picPath);  
  44.         }finally{  
  45.             if(bitmap!=null && !bitmap.isRecycled()){  
  46.                 bitmap.recycle();  
  47.             }  
  48.             if(resizedBitmap!=null && !resizedBitmap.isRecycled()){  
  49.                 resizedBitmap.recycle();  
  50.             }  
  51.         }  
  52.         return file;  
  53.     }   
  54. }  
 

-------------------------------------我是个华丽的分割线，哇哈哈-----------------------------------------------

做完这个拍照后，感觉功能太简单，比如：设置图片大小，白天夜晚照相等等一些系统照相机带的功能都没有，因此用在项目中感觉不炫。 然后就用了简单点的，直接调用系统照相机了。本来想着简单呢，后来也遇到点问题。
    (1)根据Camera Activity返回的时候，会带一个名为data的Bitmap对象，照片的缩略图（这个地方可以做各种修改，我没用到不说了），上代码：
Java代码  收藏代码
  1.  @Override    
  2.    public void onCreate(Bundle savedInstanceState) {  
  3.        super.onCreate(savedInstanceState);  
  4.        checkSoftStage();  
  5.          
  6.        try {  
  7.            Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);  
  8.            startActivityForResult(intent, TAKE_PICTURE);   
  9.        } catch (Exception e) {  
  10.            e.printStackTrace();  
  11.        }  
  12. }  
  13.  /** 
  14.      * 检测手机是否存在SD卡,网络连接是否打开 
  15.      */  
  16.     private void checkSoftStage(){  
  17.         if(Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)){  //判断是否存在SD卡  
  18.             File file = new File(imgPath);  
  19.             if(!file.exists()){  
  20.                 file.mkdir();  
  21.             }  
  22.         }else{  
  23.             new AlertDialog.Builder(this).setMessage("检测到手机没有存储卡！请插入手机存储卡再开启本应用。")  
  24.                 .setPositiveButton("确定", new DialogInterface.OnClickListener() {  
  25.                     @Override  
  26.                     public void onClick(DialogInterface dialog, int which) {  
  27.                         finish();  
  28.                     }  
  29.                 }).show();  
  30.         }  
  31.     }  
  32.  protected void onActivityResult(int requestCode, int resultCode, Intent data)  {           
  33.             if (resultCode == TAKE_PICTURE)      {            
  34.                 //  拍照Activity保存图像数据的key是data，返回的数据类型是Bitmap对象            
  35.                 Bitmap cameraBitmap = (Bitmap) data.getExtras().get("/sdcard/rtest.jpg");           
  36.                 //  在ImageView组件中显示拍摄的照片           
  37.                 image.setImageBitmap(cameraBitmap);   
  38.   
  39.                 // 做自己的业务操作。。。。  
  40.                 }        
  41.       super.onActivityResult(requestCode, resultCode, data);    
  42.                 }   
 
   (2)以上代码在我的小米手机上测试时，出现问题了。 返回的name为data的Bitmap对象是个Null,我发现小米照完相片之后，他会先跳到一个预览的界面(系统自带的页面)，所以得不到Bitmap对象了。
因此我就先保存照片以及其路径，然后在onActivityResult中获取图片，做业务操作，代码如下：
Java代码  收藏代码
  1.   public void onCreate(Bundle savedInstanceState) {  
  2.    super.onCreate(savedInstanceState);  
  3.    checkSoftStage();  
  4.      
  5.    try {  
  6.        Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);  
  7.        startActivityForResult(intent, TAKE_PICTURE);   
  8.    } catch (Exception e) {  
  9.        e.printStackTrace();  
  10.    }  
  11.      
  12.    try {  
  13.        Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);  
  14.        String fileName = System.currentTimeMillis()+".jpg";  
  15.        newImgPath = imgPath + "/" + fileName;  
  16.        Uri uri = Uri.fromFile(new File(imgPath,fileName));  
  17.        intent.putExtra(MediaStore.EXTRA_OUTPUT, uri);  
  18.        startActivityForResult(intent, TAKE_PICTURE);   
  19.       } catch (Exception e) {  
  20.           e.printStackTrace();  
  21.       }   
  22.   }  
  23. @Override   
  24.   protected void onActivityResult(int requestCode,   
  25.    int resultCode, Intent data) {   
  26.        Log.i("--------图片路径---------", "------"+newImgPath+"---------");  
  27.       //.....做一些业务操作  
  28.     } catch (Exception e) {  
  29.         e.printStackTrace();  
  30.     }  
  31.     super.onActivityResult(requestCode, resultCode, data);  
  32.   }  
 

    本站是提供个人知识管理的网络存储空间，所有内容均由用户发布，不代表本站观点。请注意甄别内容中的联系方式、诱导购买等信息，谨防诈骗。如发现有害或侵权内容，请点击一键举报。
    转藏 分享 献花（0）

    来自： 旭龙 > 《android》

    举报/认领

    0条评论

    发表

    请遵守用户 评论公约

    类似文章 更多