码迷，mamicode.com
首页 > 移动开发 > 详细

android选择图片或拍照图片上传到服务器(包括上传参数)

时间：2015-05-29 00:47:30      阅读：256      评论：0      收藏：0      [点我收藏+]

标签：

最近要搞一个项目，需要上传相册和拍照的图片，不负所望，终于完成了！  不过需要说明一下，其实网上很多教程拍照的图片，都是缩略图不是很清晰，所以需要在调用照相机的时候，事先生成一个地址，用于标识拍照的图片URI

具体上传代码：

1.选择图片和上传界面，包括上传完成和异常的回调监听

[java] view plaincopy
 
  1. package com.spring.sky.image.upload;  
  2.   
  3.   
  4. import java.util.HashMap;  
  5. import java.util.Map;  
  6.   
  7. import android.app.Activity;  
  8. import android.app.ProgressDialog;  
  9. import android.content.Intent;  
  10. import android.graphics.Bitmap;  
  11. import android.graphics.BitmapFactory;  
  12. import android.os.Bundle;  
  13. import android.os.Handler;  
  14. import android.os.Message;  
  15. import android.util.Log;  
  16. import android.view.View;  
  17. import android.view.View.OnClickListener;  
  18. import android.widget.Button;  
  19. import android.widget.ImageView;  
  20. import android.widget.ProgressBar;  
  21. import android.widget.TextView;  
  22. import android.widget.Toast;  
  23.   
  24. import com.spring.sky.image.upload.network.UploadUtil;  
  25. import com.spring.sky.image.upload.network.UploadUtil.OnUploadProcessListener;  
  26. /** 
  27.  * @author spring sky<br> 
  28.  * Email :vipa1888@163.com<br> 
  29.  * QQ: 840950105<br> 
  30.  * 说明：主要用于选择文件和上传文件操作 
  31.  */  
  32. public class MainActivity extends Activity implements OnClickListener,OnUploadProcessListener{  
  33.     private static final String TAG = "uploadImage";  
  34.       
  35.     /** 
  36.      * 去上传文件 
  37.      */  
  38.     protected static final int TO_UPLOAD_FILE = 1;    
  39.     /** 
  40.      * 上传文件响应 
  41.      */  
  42.     protected static final int UPLOAD_FILE_DONE = 2;  //  
  43.     /** 
  44.      * 选择文件 
  45.      */  
  46.     public static final int TO_SELECT_PHOTO = 3;  
  47.     /** 
  48.      * 上传初始化 
  49.      */  
  50.     private static final int UPLOAD_INIT_PROCESS = 4;  
  51.     /** 
  52.      * 上传中 
  53.      */  
  54.     private static final int UPLOAD_IN_PROCESS = 5;  
  55.     /*** 
  56.      * 这里的这个URL是我服务器的javaEE环境URL 
  57.      */  
  58.     private static String requestURL = "http://192.168.10.160:8080/fileUpload/p/file!upload";  
  59.     private Button selectButton,uploadButton;  
  60.     private ImageView imageView;  
  61.     private TextView uploadImageResult;  
  62.     private ProgressBar progressBar;  
  63.       
  64.     private String picPath = null;  
  65.     private ProgressDialog progressDialog;  
  66.       
  67.     /** Called when the activity is first created. */  
  68.     @Override  
  69.     public void onCreate(Bundle savedInstanceState) {  
  70.         super.onCreate(savedInstanceState);  
  71.         setContentView(R.layout.main);  
  72.         initView();  
  73.     }  
  74.       
  75.     /** 
  76.      * 初始化数据 
  77.      */  
  78.     private void initView() {  
  79.         selectButton = (Button) this.findViewById(R.id.selectImage);  
  80.         uploadButton = (Button) this.findViewById(R.id.uploadImage);  
  81.         selectButton.setOnClickListener(this);  
  82.         uploadButton.setOnClickListener(this);  
  83.         imageView = (ImageView) this.findViewById(R.id.imageView);  
  84.         uploadImageResult = (TextView) findViewById(R.id.uploadImageResult);  
  85.         progressDialog = new ProgressDialog(this);  
  86.         progressBar = (ProgressBar) findViewById(R.id.progressBar1);  
  87.     }  
  88.   
  89.     @Override  
  90.     public void onClick(View v) {  
  91.         switch (v.getId()) {  
  92.         case R.id.selectImage:  
  93.             Intent intent = new Intent(this,SelectPicActivity.class);  
  94.             startActivityForResult(intent, TO_SELECT_PHOTO);  
  95.             break;  
  96.         case R.id.uploadImage:  
  97.             if(picPath!=null)  
  98.             {  
  99.                 handler.sendEmptyMessage(TO_UPLOAD_FILE);  
  100.             }else{  
  101.                 Toast.makeText(this, "上传的文件路径出错", Toast.LENGTH_LONG).show();  
  102.             }  
  103.             break;  
  104.         default:  
  105.             break;  
  106.         }  
  107.     }  
  108.   
  109.     @Override  
  110.     protected void onActivityResult(int requestCode, int resultCode, Intent data) {  
  111.         if(resultCode==Activity.RESULT_OK && requestCode == TO_SELECT_PHOTO)  
  112.         {  
  113.             picPath = data.getStringExtra(SelectPicActivity.KEY_PHOTO_PATH);  
  114.             Log.i(TAG, "最终选择的图片="+picPath);  
  115.             Bitmap bm = BitmapFactory.decodeFile(picPath);  
  116.             imageView.setImageBitmap(bm);  
  117.         }  
  118.         super.onActivityResult(requestCode, resultCode, data);  
  119.     }  
  120.       
  121.   
  122.     /** 
  123.      * 上传服务器响应回调 
  124.      */  
  125.     @Override  
  126.     public void onUploadDone(int responseCode, String message) {  
  127.         progressDialog.dismiss();  
  128.         Message msg = Message.obtain();  
  129.         msg.what = UPLOAD_FILE_DONE;  
  130.         msg.arg1 = responseCode;  
  131.         msg.obj = message;  
  132.         handler.sendMessage(msg);  
  133.     }  
  134.       
  135.     private void toUploadFile()  
  136.     {  
  137.         uploadImageResult.setText("正在上传中...");  
  138.         progressDialog.setMessage("正在上传文件...");  
  139.         progressDialog.show();  
  140.         String fileKey = "pic";  
  141.         UploadUtil uploadUtil = UploadUtil.getInstance();;  
  142.         uploadUtil.setOnUploadProcessListener(this);  //设置监听器监听上传状态  
  143.           
  144.         Map<String, String> params = new HashMap<String, String>();  
  145.         params.put("orderId", "11111");  
  146.         uploadUtil.uploadFile( picPath,fileKey, requestURL,params);  
  147.     }  
  148.       
  149.     private Handler handler = new Handler(){  
  150.         @Override  
  151.         public void handleMessage(Message msg) {  
  152.             switch (msg.what) {  
  153.             case TO_UPLOAD_FILE:  
  154.                 toUploadFile();  
  155.                 break;  
  156.               
  157.             case UPLOAD_INIT_PROCESS:  
  158.                 progressBar.setMax(msg.arg1);  
  159.                 break;  
  160.             case UPLOAD_IN_PROCESS:  
  161.                 progressBar.setProgress(msg.arg1);  
  162.                 break;  
  163.             case UPLOAD_FILE_DONE:  
  164.                 String result = "响应码："+msg.arg1+"\n响应信息："+msg.obj+"\n耗时："+UploadUtil.getRequestTime()+"秒";  
  165.                 uploadImageResult.setText(result);  
  166.                 break;  
  167.             default:  
  168.                 break;  
  169.             }  
  170.             super.handleMessage(msg);  
  171.         }  
  172.           
  173.     };  
  174.   
  175.     @Override  
  176.     public void onUploadProcess(int uploadSize) {  
  177.         Message msg = Message.obtain();  
  178.         msg.what = UPLOAD_IN_PROCESS;  
  179.         msg.arg1 = uploadSize;  
  180.         handler.sendMessage(msg );  
  181.     }  
  182.   
  183.     @Override  
  184.     public void initUpload(int fileSize) {  
  185.         Message msg = Message.obtain();  
  186.         msg.what = UPLOAD_INIT_PROCESS;  
  187.         msg.arg1 = fileSize;  
  188.         handler.sendMessage(msg );  
  189.     }  
  190.       
  191. }  


2.选择图片界面，主要涉及两种方式：选择图片和及时拍照图片

[java] view plaincopy
 
  1. package com.spring.sky.image.upload;  
  2.   
  3. import android.app.Activity;  
  4. import android.content.ContentValues;  
  5. import android.content.Intent;  
  6. import android.database.Cursor;  
  7. import android.net.Uri;  
  8. import android.os.Bundle;  
  9. import android.os.Environment;  
  10. import android.provider.MediaStore;  
  11. import android.util.Log;  
  12. import android.view.MotionEvent;  
  13. import android.view.View;  
  14. import android.view.View.OnClickListener;  
  15. import android.widget.Button;  
  16. import android.widget.LinearLayout;  
  17. import android.widget.Toast;  
  18.   
  19. /** 
  20.  * @author spring sky<br> 
  21.  * Email :vipa1888@163.com<br> 
  22.  * QQ: 840950105<br> 
  23.  * @version 创建时间：2012-11-22 上午9:20:03 
  24.  * 说明：主要用于选择文件操作 
  25.  */  
  26.   
  27. public class SelectPicActivity extends Activity implements OnClickListener{  
  28.   
  29.     /*** 
  30.      * 使用照相机拍照获取图片 
  31.      */  
  32.     public static final int SELECT_PIC_BY_TACK_PHOTO = 1;  
  33.     /*** 
  34.      * 使用相册中的图片 
  35.      */  
  36.     public static final int SELECT_PIC_BY_PICK_PHOTO = 2;  
  37.       
  38.     /*** 
  39.      * 从Intent获取图片路径的KEY 
  40.      */  
  41.     public static final String KEY_PHOTO_PATH = "photo_path";  
  42.       
  43.     private static final String TAG = "SelectPicActivity";  
  44.       
  45.     private LinearLayout dialogLayout;  
  46.     private Button takePhotoBtn,pickPhotoBtn,cancelBtn;  
  47.   
  48.     /**获取到的图片路径*/  
  49.     private String picPath;  
  50.       
  51.     private Intent lastIntent ;  
  52.       
  53.     private Uri photoUri;  
  54.     @Override  
  55.     protected void onCreate(Bundle savedInstanceState) {  
  56.         super.onCreate(savedInstanceState);  
  57.         setContentView(R.layout.select_pic_layout);  
  58.         initView();  
  59.     }  
  60.     /** 
  61.      * 初始化加载View 
  62.      */  
  63.     private void initView() {  
  64.         dialogLayout = (LinearLayout) findViewById(R.id.dialog_layout);  
  65.         dialogLayout.setOnClickListener(this);  
  66.         takePhotoBtn = (Button) findViewById(R.id.btn_take_photo);  
  67.         takePhotoBtn.setOnClickListener(this);  
  68.         pickPhotoBtn = (Button) findViewById(R.id.btn_pick_photo);  
  69.         pickPhotoBtn.setOnClickListener(this);  
  70.         cancelBtn = (Button) findViewById(R.id.btn_cancel);  
  71.         cancelBtn.setOnClickListener(this);  
  72.           
  73.         lastIntent = getIntent();  
  74.     }  
  75.   
  76.     @Override  
  77.     public void onClick(View v) {  
  78.         switch (v.getId()) {  
  79.         case R.id.dialog_layout:  
  80.             finish();  
  81.             break;  
  82.         case R.id.btn_take_photo:  
  83.             takePhoto();  
  84.             break;  
  85.         case R.id.btn_pick_photo:  
  86.             pickPhoto();  
  87.             break;  
  88.         default:  
  89.             finish();  
  90.             break;  
  91.         }  
  92.     }  
  93.   
  94.     /** 
  95.      * 拍照获取图片 
  96.      */  
  97.     private void takePhoto() {  
  98.         //执行拍照前，应该先判断SD卡是否存在  
  99.         String SDState = Environment.getExternalStorageState();  
  100.         if(SDState.equals(Environment.MEDIA_MOUNTED))  
  101.         {  
  102.               
  103.             Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);//"android.media.action.IMAGE_CAPTURE"  
  104.             /*** 
  105.              * 需要说明一下，以下操作使用照相机拍照，拍照后的图片会存放在相册中的 
  106.              * 这里使用的这种方式有一个好处就是获取的图片是拍照后的原图 
  107.              * 如果不实用ContentValues存放照片路径的话，拍照后获取的图片为缩略图不清晰 
  108.              */  
  109.             ContentValues values = new ContentValues();    
  110.             photoUri = this.getContentResolver().insert(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, values);    
  111.             intent.putExtra(android.provider.MediaStore.EXTRA_OUTPUT, photoUri);  
  112.             /**-----------------*/  
  113.             startActivityForResult(intent, SELECT_PIC_BY_TACK_PHOTO);  
  114.         }else{  
  115.             Toast.makeText(this,"内存卡不存在", Toast.LENGTH_LONG).show();  
  116.         }  
  117.     }  
  118.   
  119.     /*** 
  120.      * 从相册中取图片 
  121.      */  
  122.     private void pickPhoto() {  
  123.         Intent intent = new Intent();  
  124.         intent.setType("image/*");  
  125.         intent.setAction(Intent.ACTION_GET_CONTENT);  
  126.         startActivityForResult(intent, SELECT_PIC_BY_PICK_PHOTO);  
  127.     }  
  128.       
  129.     @Override  
  130.     public boolean onTouchEvent(MotionEvent event) {  
  131.         finish();  
  132.         return super.onTouchEvent(event);  
  133.     }  
  134.       
  135.       
  136.     @Override  
  137.     protected void onActivityResult(int requestCode, int resultCode, Intent data) {  
  138.         if(resultCode == Activity.RESULT_OK)  
  139.         {  
  140.             doPhoto(requestCode,data);  
  141.         }  
  142.         super.onActivityResult(requestCode, resultCode, data);  
  143.     }  
  144.       
  145.     /**  
  146.      * 选择图片后，获取图片的路径  
  147.      * @param requestCode  
  148.      * @param data  
  149.      */  
  150.     private void doPhoto(int requestCode,Intent data)  
  151.     {  
  152.         if(requestCode == SELECT_PIC_BY_PICK_PHOTO )  //从相册取图片，有些手机有异常情况，请注意  
  153.         {  
  154.             if(data == null)  
  155.             {  
  156.                 Toast.makeText(this, "选择图片文件出错", Toast.LENGTH_LONG).show();  
  157.                 return;  
  158.             }  
  159.             photoUri = data.getData();  
  160.             if(photoUri == null )  
  161.             {  
  162.                 Toast.makeText(this, "选择图片文件出错", Toast.LENGTH_LONG).show();  
  163.                 return;  
  164.             }  
  165.         }  
  166.         String[] pojo = {MediaStore.Images.Media.DATA};  
  167.         Cursor cursor = managedQuery(photoUri, pojo, null, null,null);     
  168.         if(cursor != null )  
  169.         {  
  170.             int columnIndex = cursor.getColumnIndexOrThrow(pojo[0]);  
  171.             cursor.moveToFirst();  
  172.             picPath = cursor.getString(columnIndex);  
  173.             cursor.close();  
  174.         }  
  175.         Log.i(TAG, "imagePath = "+picPath);  
  176.         if(picPath != null && ( picPath.endsWith(".png") || picPath.endsWith(".PNG") ||picPath.endsWith(".jpg") ||picPath.endsWith(".JPG")  ))  
  177.         {  
  178.             lastIntent.putExtra(KEY_PHOTO_PATH, picPath);  
  179.             setResult(Activity.RESULT_OK, lastIntent);  
  180.             finish();  
  181.         }else{  
  182.             Toast.makeText(this, "选择图片文件不正确", Toast.LENGTH_LONG).show();  
  183.         }  
  184.     }  
  185. }  


3. 上传工具类，主要实现了图片的上传，上传过程的初始化监听和上传完成的监听，还有上传耗时的计算

[java] view plaincopy
 
  1. package com.spring.sky.image.upload.network;  
  2.   
  3. import java.io.DataOutputStream;  
  4. import java.io.File;  
  5. import java.io.FileInputStream;  
  6. import java.io.IOException;  
  7. import java.io.InputStream;  
  8. import java.net.HttpURLConnection;  
  9. import java.net.MalformedURLException;  
  10. import java.net.URL;  
  11. import java.util.Iterator;  
  12. import java.util.Map;  
  13. import java.util.UUID;  
  14.   
  15. import android.util.Log;  
  16.   
  17. /** 
  18.  *  
  19.  * 上传工具类 
  20.  * @author spring sky<br> 
  21.  * Email :vipa1888@163.com<br> 
  22.  * QQ: 840950105<br> 
  23.  * 支持上传文件和参数 
  24.  */  
  25. public class UploadUtil {  
  26.     private static UploadUtil uploadUtil;  
  27.     private static final String BOUNDARY =  UUID.randomUUID().toString(); // 边界标识 随机生成  
  28.     private static final String PREFIX = "--";  
  29.     private static final String LINE_END = "\r\n";  
  30.     private static final String CONTENT_TYPE = "multipart/form-data"; // 内容类型  
  31.     private UploadUtil() {  
  32.   
  33.     }  
  34.   
  35.     /** 
  36.      * 单例模式获取上传工具类 
  37.      * @return 
  38.      */  
  39.     public static UploadUtil getInstance() {  
  40.         if (null == uploadUtil) {  
  41.             uploadUtil = new UploadUtil();  
  42.         }  
  43.         return uploadUtil;  
  44.     }  
  45.   
  46.     private static final String TAG = "UploadUtil";  
  47.     private int readTimeOut = 10 * 1000; // 读取超时  
  48.     private int connectTimeout = 10 * 1000; // 超时时间  
  49.     /*** 
  50.      * 请求使用多长时间 
  51.      */  
  52.     private static int requestTime = 0;  
  53.       
  54.     private static final String CHARSET = "utf-8"; // 设置编码  
  55.   
  56.     /*** 
  57.      * 上传成功 
  58.      */  
  59.     public static final int UPLOAD_SUCCESS_CODE = 1;  
  60.     /** 
  61.      * 文件不存在 
  62.      */  
  63.     public static final int UPLOAD_FILE_NOT_EXISTS_CODE = 2;  
  64.     /** 
  65.      * 服务器出错 
  66.      */  
  67.     public static final int UPLOAD_SERVER_ERROR_CODE = 3;  
  68.     protected static final int WHAT_TO_UPLOAD = 1;  
  69.     protected static final int WHAT_UPLOAD_DONE = 2;  
  70.       
  71.     /** 
  72.      * android上传文件到服务器 
  73.      *  
  74.      * @param filePath 
  75.      *            需要上传的文件的路径 
  76.      * @param fileKey 
  77.      *            在网页上<input type=file name=xxx/> xxx就是这里的fileKey 
  78.      * @param RequestURL 
  79.      *            请求的URL 
  80.      */  
  81.     public void uploadFile(String filePath, String fileKey, String RequestURL,  
  82.             Map<String, String> param) {  
  83.         if (filePath == null) {  
  84.             sendMessage(UPLOAD_FILE_NOT_EXISTS_CODE,"文件不存在");  
  85.             return;  
  86.         }  
  87.         try {  
  88.             File file = new File(filePath);  
  89.             uploadFile(file, fileKey, RequestURL, param);  
  90.         } catch (Exception e) {  
  91.             sendMessage(UPLOAD_FILE_NOT_EXISTS_CODE,"文件不存在");  
  92.             e.printStackTrace();  
  93.             return;  
  94.         }  
  95.     }  
  96.   
  97.     /** 
  98.      * android上传文件到服务器 
  99.      *  
  100.      * @param file 
  101.      *            需要上传的文件 
  102.      * @param fileKey 
  103.      *            在网页上<input type=file name=xxx/> xxx就是这里的fileKey 
  104.      * @param RequestURL 
  105.      *            请求的URL 
  106.      */  
  107.     public void uploadFile(final File file, final String fileKey,  
  108.             final String RequestURL, final Map<String, String> param) {  
  109.         if (file == null || (!file.exists())) {  
  110.             sendMessage(UPLOAD_FILE_NOT_EXISTS_CODE,"文件不存在");  
  111.             return;  
  112.         }  
  113.   
  114.         Log.i(TAG, "请求的URL=" + RequestURL);  
  115.         Log.i(TAG, "请求的fileName=" + file.getName());  
  116.         Log.i(TAG, "请求的fileKey=" + fileKey);  
  117.         new Thread(new Runnable() {  //开启线程上传文件  
  118.             @Override  
  119.             public void run() {  
  120.                 toUploadFile(file, fileKey, RequestURL, param);  
  121.             }  
  122.         }).start();  
  123.           
  124.     }  
  125.   
  126.     private void toUploadFile(File file, String fileKey, String RequestURL,  
  127.             Map<String, String> param) {  
  128.         String result = null;  
  129.         requestTime= 0;  
  130.           
  131.         long requestTime = System.currentTimeMillis();  
  132.         long responseTime = 0;  
  133.   
  134.         try {  
  135.             URL url = new URL(RequestURL);  
  136.             HttpURLConnection conn = (HttpURLConnection) url.openConnection();  
  137.             conn.setReadTimeout(readTimeOut);  
  138.             conn.setConnectTimeout(connectTimeout);  
  139.             conn.setDoInput(true); // 允许输入流  
  140.             conn.setDoOutput(true); // 允许输出流  
  141.             conn.setUseCaches(false); // 不允许使用缓存  
  142.             conn.setRequestMethod("POST"); // 请求方式  
  143.             conn.setRequestProperty("Charset", CHARSET); // 设置编码  
  144.             conn.setRequestProperty("connection", "keep-alive");  
  145.             conn.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1)");  
  146.             conn.setRequestProperty("Content-Type", CONTENT_TYPE + ";boundary=" + BOUNDARY);  
  147. //          conn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");  
  148.               
  149.             /** 
  150.              * 当文件不为空，把文件包装并且上传 
  151.              */  
  152.             DataOutputStream dos = new DataOutputStream(conn.getOutputStream());  
  153.             StringBuffer sb = null;  
  154.             String params = "";  
  155.               
  156.             /*** 
  157.              * 以下是用于上传参数 
  158.              */  
  159.             if (param != null && param.size() > 0) {  
  160.                 Iterator<String> it = param.keySet().iterator();  
  161.                 while (it.hasNext()) {  
  162.                     sb = null;  
  163.                     sb = new StringBuffer();  
  164.                     String key = it.next();  
  165.                     String value = param.get(key);  
  166.                     sb.append(PREFIX).append(BOUNDARY).append(LINE_END);  
  167.                     sb.append("Content-Disposition: form-data; name=\"").append(key).append("\"").append(LINE_END).append(LINE_END);  
  168.                     sb.append(value).append(LINE_END);  
  169.                     params = sb.toString();  
  170.                     Log.i(TAG, key+"="+params+"##");  
  171.                     dos.write(params.getBytes());  
  172. //                  dos.flush();  
  173.                 }  
  174.             }  
  175.               
  176.             sb = null;  
  177.             params = null;  
  178.             sb = new StringBuffer();  
  179.             /** 
  180.              * 这里重点注意： name里面的值为服务器端需要key 只有这个key 才可以得到对应的文件 
  181.              * filename是文件的名字，包含后缀名的 比如:abc.png 
  182.              */  
  183.             sb.append(PREFIX).append(BOUNDARY).append(LINE_END);  
  184.             sb.append("Content-Disposition:form-data; name=\"" + fileKey  
  185.                     + "\"; filename=\"" + file.getName() + "\"" + LINE_END);  
  186.             sb.append("Content-Type:image/pjpeg" + LINE_END); // 这里配置的Content-type很重要的 ，用于服务器端辨别文件的类型的  
  187.             sb.append(LINE_END);  
  188.             params = sb.toString();  
  189.             sb = null;  
  190.               
  191.             Log.i(TAG, file.getName()+"=" + params+"##");  
  192.             dos.write(params.getBytes());  
  193.             /**上传文件*/  
  194.             InputStream is = new FileInputStream(file);  
  195.             onUploadProcessListener.initUpload((int)file.length());  
  196.             byte[] bytes = new byte[1024];  
  197.             int len = 0;  
  198.             int curLen = 0;  
  199.             while ((len = is.read(bytes)) != -1) {  
  200.                 curLen += len;  
  201.                 dos.write(bytes, 0, len);  
  202.                 onUploadProcessListener.onUploadProcess(curLen);  
  203.             }  
  204.             is.close();  
  205.               
  206.             dos.write(LINE_END.getBytes());  
  207.             byte[] end_data = (PREFIX + BOUNDARY + PREFIX + LINE_END).getBytes();  
  208.             dos.write(end_data);  
  209.             dos.flush();  
  210. //            
  211. //          dos.write(tempOutputStream.toByteArray());  
  212.             /** 
  213.              * 获取响应码 200=成功 当响应成功，获取响应的流 
  214.              */  
  215.             int res = conn.getResponseCode();  
  216.             responseTime = System.currentTimeMillis();  
  217.             this.requestTime = (int) ((responseTime-requestTime)/1000);  
  218.             Log.e(TAG, "response code:" + res);  
  219.             if (res == 200) {  
  220.                 Log.e(TAG, "request success");  
  221.                 InputStream input = conn.getInputStream();  
  222.                 StringBuffer sb1 = new StringBuffer();  
  223.                 int ss;  
  224.                 while ((ss = input.read()) != -1) {  
  225.                     sb1.append((char) ss);  
  226.                 }  
  227.                 result = sb1.toString();  
  228.                 Log.e(TAG, "result : " + result);  
  229.                 sendMessage(UPLOAD_SUCCESS_CODE, "上传结果："  
  230.                         + result);  
  231.                 return;  
  232.             } else {  
  233.                 Log.e(TAG, "request error");  
  234.                 sendMessage(UPLOAD_SERVER_ERROR_CODE,"上传失败：code=" + res);  
  235.                 return;  
  236.             }  
  237.         } catch (MalformedURLException e) {  
  238.             sendMessage(UPLOAD_SERVER_ERROR_CODE,"上传失败：error=" + e.getMessage());  
  239.             e.printStackTrace();  
  240.             return;  
  241.         } catch (IOException e) {  
  242.             sendMessage(UPLOAD_SERVER_ERROR_CODE,"上传失败：error=" + e.getMessage());  
  243.             e.printStackTrace();  
  244.             return;  
  245.         }  
  246.     }  
  247.   
  248.     /** 
  249.      * 发送上传结果 
  250.      * @param responseCode 
  251.      * @param responseMessage 
  252.      */  
  253.     private void sendMessage(int responseCode,String responseMessage)  
  254.     {  
  255.         onUploadProcessListener.onUploadDone(responseCode, responseMessage);  
  256.     }  
  257.       
  258.     /** 
  259.      * 下面是一个自定义的回调函数，用到回调上传文件是否完成 
  260.      *  
  261.      * @author shimingzheng 
  262.      *  
  263.      */  
  264.     public static interface OnUploadProcessListener {  
  265.         /** 
  266.          * 上传响应 
  267.          * @param responseCode 
  268.          * @param message 
  269.          */  
  270.         void onUploadDone(int responseCode, String message);  
  271.         /** 
  272.          * 上传中 
  273.          * @param uploadSize 
  274.          */  
  275.         void onUploadProcess(int uploadSize);  
  276.         /** 
  277.          * 准备上传 
  278.          * @param fileSize 
  279.          */  
  280.         void initUpload(int fileSize);  
  281.     }  
  282.     private OnUploadProcessListener onUploadProcessListener;  
  283.       
  284.       
  285.   
  286.     public void setOnUploadProcessListener(  
  287.             OnUploadProcessListener onUploadProcessListener) {  
  288.         this.onUploadProcessListener = onUploadProcessListener;  
  289.     }  
  290.   
  291.     public int getReadTimeOut() {  
  292.         return readTimeOut;  
  293.     }  
  294.   
  295.     public void setReadTimeOut(int readTimeOut) {  
  296.         this.readTimeOut = readTimeOut;  
  297.     }  
  298.   
  299.     public int getConnectTimeout() {  
  300.         return connectTimeout;  
  301.     }  
  302.   
  303.     public void setConnectTimeout(int connectTimeout) {  
  304.         this.connectTimeout = connectTimeout;  
  305.     }  
  306.     /** 
  307.      * 获取上传使用的时间 
  308.      * @return 
  309.      */  
  310.     public static int getRequestTime() {  
  311.         return requestTime;  
  312.     }  
  313.       
  314.     public static interface uploadProcessListener{  
  315.           
  316.     }  
  317.       
  318.       
  319.       
  320.       
  321. }  


本文章欢迎转载，但是请保留原连接地址：http://blog.csdn.net/vipa1888/article/details/8213898

以上代码，我就不详细讲解原理，相关难点注释已经写得很清楚了！分享出来，和大家一起学习！

android选择图片或拍照图片上传到服务器(包括上传参数)

标签：

原文地址：http://www.cnblogs.com/lingyi1111/p/4537345.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！