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

最新推荐文章于 2025-02-19 16:09:30 发布
最新推荐文章于 2025-02-19 16:09:30 发布
阅读量1.1w 收藏 7
点赞数
分类专栏： Android

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

参考地址：

http://blog.youkuaiyun.com/cfwdl/article/details/5746708

http://mjbb.iteye.com/blog/1018006

http://blog.youkuaiyun.com/hellogv/article/details/5962494


1、上传文件功能网上很多讲的，只要细心点，按照格式来写发送的数据，都是没有问题的。

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

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

修改内容：

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

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

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

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

             5、今天又做修改，之前写的压缩图片方法的竟然会变形(没有测试大的图片)，修改后不会变形了。

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


附上流程图：


 
拍照功能： 【预览尺寸有知道的朋友留言告知。】
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.android.com/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.android.com/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.     int maxWidth = 640,maxHeight=480;  //设置新图片的大小  
  8.            String fileName = picPath.substring(picPath.lastIndexOf("/"));  
  9.       
  10.     BitmapFactory.Options options = new BitmapFactory.Options();    
  11.     options.inJustDecodeBounds = true;    
  12.     Bitmap image = BitmapFactory.decodeFile(picPath, options);    
  13.     double ratio = 1D;    
  14.     if (maxWidth > 0 && maxHeight <= 0) {    
  15.         // 限定宽度，高度不做限制    
  16.         ratio = Math.ceil(options.outWidth / maxWidth);    
  17.     } else if (maxHeight > 0 && maxWidth <= 0) {    
  18.         // 限定高度，不限制宽度    
  19.         ratio = Math.ceil(options.outHeight / maxHeight);    
  20.     } else if (maxWidth > 0 && maxHeight > 0) {    
  21.         // 高度和宽度都做了限制，这时候我们计算在这个限制内能容纳的最大的图片尺寸，不会使图片变形    
  22.         double _widthRatio = Math.ceil(options.outWidth / maxWidth);    
  23.         double _heightRatio = (double) Math.ceil(options.outHeight / maxHeight);    
  24.         ratio = _widthRatio > _heightRatio ? _widthRatio : _heightRatio;    
  25.     }    
  26.     if (ratio > 1)  
  27.         options.inSampleSize = (int) ratio;  
  28.     options.inJustDecodeBounds = false;    
  29.     options.inPreferredConfig = Bitmap.Config.RGB_565;    
  30.     image = BitmapFactory.decodeFile(picPath, options);    
  31.          //保存入sdCard    
  32.          File file = new File(Const.thumbnailPath+fileName);    
  33.          try {    
  34.            FileOutputStream out = new FileOutputStream(file);    
  35.            if(image.compress(Bitmap.CompressFormat.JPEG, 100, out)){    
  36.                out.flush();    
  37.                out.close();    
  38.            }  
  39.        } catch (Exception e) {   
  40.            e.printStackTrace();  
  41.            return new File(picPath);  
  42.        }finally{  
  43.         if(image!=null && !image.isRecycled()){  
  44.             image.recycle();  
  45.         }  
  46.        }  
  47.     return file;  
  48. }  
 

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

做完这个拍照后，感觉功能太简单，比如：设置图片大小，白天夜晚照相等等一些系统照相机带的功能都没有，因此用在项目中感觉不炫。 然后就用了简单点的，直接调用系统照相机了。本来想着简单呢，后来也遇到点问题。
    (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.   }  
Android图片上传实现预览效果
09-02
主要介绍了Android图片上传实现预览效果的相关资料,需要的朋友可以参考下
android 拍照上传及本地上传
pi9nc的专栏
06-28 1244
android 拍照上传及本地上传 分类： android学习2012-06-18 09:28 2677人阅读 评论(35) 收藏 举报 androidstringpathfilenullexception ps:有很长一段时间没有上博客了。将源码贴出。 http://pan.baidu.com/share/link?shareid=188849&uk=1562
Android 利用Camera2实现相机预览、拍照、保存图片
最新发布
m0_54198552的博客
02-19 522
3、MainActivity的详细代码，包括设置分辨率、横竖屏旋转适配（此适配方案需根据不同设备调整），每五帧自动保存一张图片到相册（此需求需要增加保存图片的权限），如需点击按钮拍照，可根据自动拍照的逻辑进行一些修改。2、在AndroidManifest.xml中增加权限。
技术干货 | “选图预览并上传”的场景如何解？全网最全方案汇总来了
移动开发平台 mPaaS 的博客
01-08 256
你真的知道如何“上传”一张照片吗？
Android拍照上传
殇神马的博客
07-05 1013
在Android应用中，用户模块一般会有头像上传的功能，即用户可以调用摄像头拍照或者从本地图库中选择图片上传，用户打开应用登陆后即可显示上传的头像。 要想实现Android拍照+选择本地图片上传的功能，主要需要掌握以下几点： 调用系统照相机拍照 打开本地图库选择本地图片 将图片上传到服务器 （1）调用系统照相机拍照//调用系统照相机拍照 Intent intent = new Intent(Med
android拍照上传
weixin_qwaszx_520的博客
05-23 816
implementation 'com.jph.takephoto:takephoto_library:4.0.3'
Android拍照上传功能的实现与完善指南
为了使用Android拍照上传代码样例，开发者需要配置Android开发环境，通常包括安装Android Studio、配置Android SDK、创建新的Android项目等步骤。代码样例是初学者快速上手和学习的良好素材。初学者可以通过阅读样例...
Android应用源码开发：图片拍照上传功能实现
综上所述，本资源是一个综合性的Android应用开发案例，它不仅提供了一个具体的功能实现——图片拍照上传，而且涵盖了Android开发的多个关键知识点和技能点，非常适合于想要深入学习Android开发的学生或开发者使用。...
Android用户头像编辑：拍照或选择图片功能实现
在Android开发过程中，实现从内存读取或者拍照来改变头像的功能是用户界面交互中一项常见的需求。为了实现这一功能，开发者需要具备处理图像上传、选择相册图片、调用相机拍照以及对图像进行编辑处理等相关技能。 #...
拍照上传源码.rar
12-16
综合以上分析，这个“拍照上传源码.rar”压缩包提供了从调用设备摄像头、处理图像到将照片上传至服务器的完整流程。对于开发者来说，这是一个非常实用的资源，可以节约时间并避免重复造轮子。不过，使用时需注意版权...
camera2 API打造安卓拍照上传录像监控录屏APP源码解析
标题中提到的“安卓拍照上传录像监控录屏相关”是一个涵盖了安卓平台上进行图像和视频捕获、上传以及实时监控和录屏的综合技术领域。而“lcamera使用了camera2 API的拍照APP源码.rar”则指向一个特定的安卓应用源...
android 拍照并上传图片
01-02
android调用摄像机拍照并通过httpservlet将图片上传至Pc端的服务器，此代码可以改造成上传文件的程序
Android图片上传，可以选择多张图片，缩放预览，拍照上传等
08-23
Android图片上传，可以选择多张图片，缩放预览，拍照上传等
Android 拍照上传功能控件
04-10
Android 拍照上传功能控件 兼容2.3以上
Android拍照，上传，预览综合
baobaoupup
04-16 107
第一步 view source print? 1 try { 2 　　 Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE); 3 　　 startActivityForResult(intent, 0); 4 ...
Android拍照功能与上传实现
DevPulse的博客
09-23 272
用户可以点击拍照按钮进行拍照操作，拍摄的照片会保存在设备的存储器中，并通过uploadPhoto方法将照片上传至服务器。在布局文件中，创建一个相机预览的SurfaceView和一个拍照按钮。在Android应用开发中，实现拍照并上传功能是一个常见的需求。本文将详细介绍如何在Android应用中实现这一功能，并提供相应的源代码。在Activity或Fragment中，我们还需要处理相机权限请求的结果。注意：在实际开发中，需要根据具体需求进行适当的错误处理和用户提示，例如处理权限被拒绝的情况、显示拍照结果等。
Android-拍照上传图片
Word_Nihao的博客
11-22 988
Android手机拍照获取图片资源的处理，Android 7之后发生了一些变化，以下是个人将拍照上传流程进行整理 第一步：配置mainfest, 添加provider(在application标签内) &lt;provider android:name="android.support.v4.content.FileProvider" android:authorities=...
Android 图片拍照上传、本地上传
mac090705的专栏
10-15 784
1.拍照，并获得拍摄的照片 指定一个照片的存储路径，方便在onActivityResutl中使用
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值