安卓端拍照上传服务器+保存到本地电脑

作者: 墨色尘埃 | 来源:发表于2017-11-21 15:57 被阅读0次

安卓端拍照上传服务器+保存到本地电脑
前端上传图片
文件上传、表单写法、$_FILES 变量、对多文件信息的遍历读取
【mac系统】springboot静态资源路径配置，保存安卓端上
安装设备Mac值获取
SpingBoot上传文字与文件
手机访问mac，window本地服务器
H5随笔
安卓开发01——上传圆角头像到服务器
关于安卓保存图片到本地后，系统相册不显示问题

项目地址：https://github.com/jihymood/TakePicture
这篇文章讲的很好：Retrofit2文件上传
使用retrofit2+rxjava2
PointApi

public interface PointApi {

    @Multipart
    @POST("New_work_order/uploadFile")
    Observable<ResponseObj<Boolean>> uploadFile(@PartMap Map<String, InputStream> map);

    @Multipart
    @POST("New_work_order/uploadFile")
    Observable<ResponseObj<Boolean>> uploadFile2(@PartMap Map<String, RequestBody> files);

}

MainActivity，主要看onActivityResult方法中的，map里的key必须是file.getName() + ""; filename="" + file.getName()，这样才能在后台的方法中接收到，具体是为什么有待研究

package com.cc.csdndemo1;

import android.content.Intent;
import android.graphics.Bitmap;
import android.os.Bundle;
import android.os.Environment;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.ImageView;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

import butterknife.BindView;
import butterknife.ButterKnife;
import butterknife.OnClick;
import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.functions.Consumer;
import io.reactivex.schedulers.Schedulers;
import okhttp3.MediaType;
import okhttp3.RequestBody;

public class MainActivity extends AppCompatActivity {


    @BindView(R.id.takephotoTV)
    Button takephotoTV;
    @BindView(R.id.savephotoTV)
    Button savephotoTV;
    @BindView(R.id.imageIV)
    ImageView imageIV;

    private final int CAMERA_REQUEST = 8888;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        ButterKnife.bind(this);
    }


    @OnClick({R.id.takephotoTV, R.id.savephotoTV})
    public void onViewClicked(View view) {
        switch (view.getId()) {
            case R.id.takephotoTV:
                Intent cameraIntent = new Intent(android.provider.MediaStore.ACTION_IMAGE_CAPTURE);
                startActivityForResult(cameraIntent, CAMERA_REQUEST);
                break;
            case R.id.savephotoTV:
                getFile();
                break;
        }
    }


    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        Bitmap bitmap = null;
        if (requestCode == CAMERA_REQUEST && resultCode == RESULT_OK) {
            bitmap = (Bitmap) data.getExtras().get("data");
            imageIV.setImageBitmap(bitmap);
        }

        /**
         * Map<String, InputStream>
         * 方法一
         */
        File file = compressImage(bitmap);
        Map<String, InputStream> files = new HashMap<>();
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        bitmap.compress(Bitmap.CompressFormat.PNG, 100, baos);
        InputStream inputStream = new ByteArrayInputStream(baos.toByteArray());
        files.put(file.getName() + "\"; filename=\"" + file.getName(), inputStream);

        /**
         * Map<String, RequestBody>
         * 方法二：map里的key必须是file.getName() + "\"; filename=\"" + file.getName()这样
         * 这样才能在后台的方法中接收到，具体是为什么有待研究
         */
        Map<String, RequestBody> map = new HashMap<>();
        File file1 = compressImage(bitmap);
        String ext = file1.getName().substring(file1.getName().lastIndexOf(".") + 1);
        RequestBody requestBody = RequestBody.create(MediaType.parse("image/" + ext), file1);
        map.put(file1.getName() + "\"; filename=\"" + file1.getName(), requestBody);


        ApiManager.getInstance()
                .pointApiService()
//                .uploadPicture1(files)
//                .uploadPicture2(map)
                .uploadPicture(map)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new io.reactivex.functions.Consumer<ResponseObj<Boolean>>() {
                    @Override
                    public void accept(ResponseObj<Boolean> booleanResponseObj) throws Exception {
                        Log.e("MainActivity", "booleanResponseObj:" + booleanResponseObj.data.toString());
                    }
                }, new io.reactivex.functions.Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Log.e("MainActivity", "throwable:" + throwable);
                    }
                });

    }


    /**
     * 压缩图片（质量压缩）
     *
     * @param bitmap
     */
    public File compressImage(Bitmap bitmap) {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        bitmap.compress(Bitmap.CompressFormat.JPEG, 100, baos);//质量压缩方法，这里100表示不压缩，把压缩后的数据存放到baos中
        int options = 100;

        //循环判断如果压缩后图片是否大于500kb,大于继续压缩;不进行压缩的话调过这段代码
//        while (baos.toByteArray().length / 1024 > 500) {
//            baos.reset();//重置baos即清空baos
//            options -= 10;//每次都减少10
//            bitmap.compress(Bitmap.CompressFormat.JPEG, options, baos);//这里压缩options%，把压缩后的数据存放到baos中
//            long length = baos.toByteArray().length;
//        }

        SimpleDateFormat format = new SimpleDateFormat("yyyyMMddHHmmss");
        Date date = new Date(System.currentTimeMillis());
        String filename = format.format(date);
        File file = new File(Environment.getExternalStorageDirectory(), filename + ".png");
        try {
            FileOutputStream fos = new FileOutputStream(file);
            try {
                fos.write(baos.toByteArray());
                fos.flush();
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        return file;
    }


    /**
     * 选择手机指定目录文件上传到电脑
     */
    public void getFile() {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        File file = null;
        String name = "拍照姿势大全，50条顶级秘籍.txt";
        String path = Environment.getExternalStorageDirectory().getPath() + "/" + name;
        try {
            file = new File(path);
            fis = new FileInputStream(file);
            Log.e("MainActivity", String.valueOf(fis.available()));

            /**
             * 方法一：如果使用InputStream传的话，会丢失大部分数据
             * 测试中，一个2946kb的文件传到后台只有2kb了
             */
            Map<String, InputStream> files = new HashMap<>();
            files.put(name + "\"; filename=\"" + name, fis);

            /**
             * 方法二：使用RequestBody传的话，不会丢失数据，可以正常写到后台
             */
            Map<String, RequestBody> map = new HashMap<>();
            String ext = file.getName().substring(file.getName().lastIndexOf(".") + 1);
            RequestBody requestBody = RequestBody.create(MediaType.parse("image/" + ext), file);
            map.put(file.getName() + "\"; filename=\"" + file.getName(), requestBody);

            ApiManager.getInstance()
                    .pointApiService()
//                    .uploadFile(files)
                    .uploadFile1(map)
                    .subscribeOn(Schedulers.io())
                    .observeOn(AndroidSchedulers.mainThread())
                    .subscribe(new Consumer<ResponseObj<Boolean>>() {
                        @Override
                        public void accept(ResponseObj<Boolean> booleanResponseObj) throws Exception {
                            Log.e("MainActivity", booleanResponseObj.data.toString());
                        }
                    }, new Consumer<Throwable>() {
                        @Override
                        public void accept(Throwable throwable) throws Exception {
                            Log.e("MainActivity", throwable.getMessage());
                        }
                    });


        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

}

后台部分：使用Intellij IDEA+SpringBoot开发
在control 层

package com.jspptd.postal.collectserver.restcontrol;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Date;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.UUID;

import javax.servlet.http.HttpServletRequest;


/**
 * Created by LOG on 2017/7/5.
 */
@RestController
@RequestMapping("/takePicture")
public class CollectController {

    private Logger log = LoggerFactory.getLogger(CollectController.class);

    @Value("${destDirName}")
    protected String destDirName;

    /**
     * 文件上传
     */
    @RequestMapping(value = "/uploadPicture", method = RequestMethod.POST)
    ResponseObj<Boolean> uploadPicture(HttpServletRequest request) {
        log.info("进入文件上传逻辑");
        if (request instanceof MultipartHttpServletRequest) {
            try {
                MultipartHttpServletRequest mulRequest = (MultipartHttpServletRequest) request;
                Set<Map.Entry<String, MultipartFile>> set = mulRequest.getFileMap().entrySet();
                Map<String, InputStream> listFile = new LinkedHashMap<>();
                log.info("个数" + Integer.toString(set.size()));
                for (Map.Entry<String, MultipartFile> each : set) {
                    String fileName = each.getKey();
                    MultipartFile file = each.getValue();
                    //这里需要上传FTP
                    try {
                        listFile.put(fileName, file.getInputStream());
                    } catch (Exception ex) {
                        return new ResponseObj<>(false, new Error("文件存储失败"));
                    }
                }

                String formjson = mulRequest.getParameter("content");
                ObjectMapper mapper = new ObjectMapper();
                mapper.setVisibility(PropertyAccessor.FIELD, JsonAutoDetect.Visibility.ANY);
                mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

//                boolean result = iInstallWorkOrder.upLoadFile(listFile);
                boolean result = true;

                return new ResponseObj<>(result);
            } catch (Exception ex) {
                return new ResponseObj<>(false, new Error(ex.getMessage()));
            }

        } else {
            return new ResponseObj<>(false, new Error("文件上传：数据格式不正确"));
        }
    }


    /**
     * 接收到安卓端传过来的map，将图片保存到本地电脑
     */
    @RequestMapping(value = "/picture", method = RequestMethod.POST)
    public ResponseObj<Boolean> reportCompany(HttpServletRequest request) {
        log.info("进入文件上传逻辑");
        if (request instanceof MultipartHttpServletRequest) {
            MultipartHttpServletRequest mulRequest = (MultipartHttpServletRequest) request;
            Set<Map.Entry<String, MultipartFile>> set = mulRequest.getFileMap().entrySet();

            String photoId = UUID.randomUUID().toString();
            for (Map.Entry<String, MultipartFile> each : set) {
                String fileName = each.getKey();
                String name = each.getValue().getOriginalFilename();
                String suffixal = getSuffixal(name);
                try {
                    writeToLocal(fileName, each.getValue().getInputStream());
                } catch (IOException e) {
                    e.printStackTrace();
                    return new ResponseObj(false, new Error("文件保存失败"));
                }
            }
        }
        return new ResponseObj<>(true, null);
    }

    /**
     * 接收到安卓端传过来的map，将图片保存到本地电脑
     */
    @RequestMapping(value = "/uploadFile", method = RequestMethod.POST)
    public ResponseObj<Boolean> uploadFile(HttpServletRequest request) {
        log.info("进入文件上传逻辑");
        if (request instanceof MultipartHttpServletRequest) {
            MultipartHttpServletRequest mulRequest = (MultipartHttpServletRequest) request;
            Set<Map.Entry<String, MultipartFile>> set = mulRequest.getFileMap().entrySet();

            String photoId = UUID.randomUUID().toString();
            for (Map.Entry<String, MultipartFile> each : set) {
                String fileName = each.getKey();
                String name = each.getValue().getOriginalFilename();
                String suffixal = getSuffixal(name);
                try {
                    writeToLocal(fileName, each.getValue().getInputStream());
                } catch (IOException e) {
                    e.printStackTrace();
                    return new ResponseObj(false, new Error("文件保存失败"));
                }
            }
        }
        return new ResponseObj<>(true, null);
    }


    /**
     * 将InputStream写入本地文件
     * 输入流
     *
     * @throws IOException
     */

    private void writeToLocal(String fileName, InputStream input) throws IOException {
        createDir(destDirName);
        String dirFile = destDirName + fileName;
        int len;
        byte[] bytes = new byte[1024];
        FileOutputStream fos = new FileOutputStream(dirFile);
        while ((len = input.read(bytes)) != -1) {
            fos.write(bytes, 0, len);
            fos.flush();
        }
        fos.close();
        input.close();
        System.out.print("创建成功");
    }

    /**
     * 创建文件夹
     *
     * @param destDirName
     * @return
     */
    public boolean createDir(String destDirName) {
        File dir = new File(destDirName);
        if (dir.exists()) {
            return false;
        }
        if (!destDirName.endsWith(File.separator)) {
            destDirName = destDirName + File.separator;
        }
        //创建目录
        if (dir.mkdirs()) {

            return true;
        } else {

            return false;
        }
    }

    /**
     * 截取图片后缀名
     */
    public String getSuffixal(String name) {
        String str = name.substring(name.length() - 4, name.length());
        return str;
    }

    /**
     * 获取当前时间
     */
    public long getNowTime() {
        return new Date().getTime();
    }

    /**
     * 判断String是否为空
     *
     * @param string
     * @return
     */
    public boolean isEmpty(String string) {
        return null == string || "".equals(string);
    }

}

微信图片_20171121150931.png

多图片上传抓包_副本.png

安卓端拍照上传服务器+保存到本地电脑
项目地址：https://github.com/jihymood/TakePicture这篇文章讲的很好：Retr...
前端上传图片
之前总结过一篇图片上传的文章，见客户端拍照上传服务器+保存到本地电脑。 list中包含了要上传的内容，当commi...
文件上传、表单写法、$_FILES 变量、对多文件信息的遍历读取
原理文件上传：文件从用户本地电脑通过传输方式（web表单）保存到服务器所在电脑指定的目录下。 1、增加文件上传表...
【mac系统】springboot静态资源路径配置，保存安卓端上
先说整体思路：安卓上传图片：在安卓端选取相册图片或拍照后，使用base64对图片进行编码，用String类型传给...
安装设备Mac值获取
可根据ip或者本地文件获取，但待测试。安卓端，与ios端的服务器超时重传时间不一致，安卓端不太统一，需要在超时后排重。
SpingBoot上传文字与文件
接收安卓端通过retrofit上传的文字及图片，安卓代码见这里直接上代码。设置文件上传的大小
手机访问mac，window本地服务器
我们在做安卓或者ios开发时，开发阶段会用手机访问本地服务器，而本地服务器开发阶段也是部署在后台开发的电脑上。ma...
H5随笔
H5兼容VIdeo H5让兼容安卓和IOS调用相机移动端debug input file 拍照上传IOS图片旋转...
安卓开发01——上传圆角头像到服务器
安卓上传圆角头像到服务器功能功能逻辑流程第一步选择照片/拍照(选择照片和拍照分别需要文件读取和相机权限)第二...
关于安卓保存图片到本地后，系统相册不显示问题
问题：对于安卓保存到本地后，系统相册不显示。原因：虽然文件已经保存到本地，但是图库的数据记录并没有该图片，所以需...