精华内容
下载资源
问答
  • Android 拍照上传图片

    2015-11-21 13:58:13
    Android 拍照上传图片,有弹出框,可以选择从拍照还是本地相册中选择图片。选择图片并进行图片上传。
  • android 拍照上传照片(新)源码

    千次下载 热门讨论 2012-12-12 20:15:37
    android 拍照上传照片(新)源码,需要的可以下载下去看看。
  • 本篇文章主要介绍了Android设置拍照或者上传本地图片示例,可以拍照或者上传本地文件,有需要的可以了解一下。
  • android 拍照上传图片

    2016-04-26 16:10:20
    android 拍照上传、裁剪、图片
  • 1.Android手机客户端,拍照(或选择图片),然后上传到服务器。 2.服务器端接收手机端上传上来的图片。 二、实现步骤: 1.按惯例,先放效果图: 项目结构: 2.activity_main.xml <?xml version=1.0 encoding=utf...
  • 压缩文件包含了android端和web端,web端使用myeclipse8.5开发的,...具体实现了手机选择相册图片或者拍照能预览图片并将图片上传到服务器。发布到手机上测试可能需要手动在手机权限管理中打开摄像头和文件读写的权限。
  • 仿照微信,朋友圈分享图片功能 。可以进行图片的多张选择,拍照添加图片,以及进行图片的预览,预览时可以进行缩放,并且可以删除选中状态的图片 。很不错的源码,大家有需要可以下载看看 。
  • 最近要搞一个项目,需要上传相册和拍照图片,不负所望,终于完成了! 不过需要说明一下,其实网上很多教程拍照图片,都是缩略图不是很清晰,所以需要在调用照相机的时候,事先生成一个地址,用于标识拍照图片...
  • android拍照上传

    2015-04-16 14:49:40
    实现拍照上传功能,可做扩展 /* 上传文件至Server的方法 */ Index_Activity.java
  • 主要介绍了解决android有的手机拍照上传图片被旋转的问题的相关资料,需要的朋友可以参考下
  • 最近要搞一个项目,需要上传相册和拍照图片,不负所望,终于完成了! 不过需要说明一下,其实网上很多教程拍照图片,都是缩略图不是很清晰,所以需要在调用照相机的时候,事先生成一个地址,用于标识拍照图片...
  • Android拍照功能和照片包含参数一起上传服务器,网上很多教程拍照的图片,都是缩略图不是很清晰,所以需要在调用照相机的时候,事先生成一个地址,用于标识拍照的图片URI
  • 调用Android系统自带拍照功能对发票进行拍照存储; 使用DES算法加密照片; 基于Socket的上传发票照片及相关信息至服务器并解密;  将发票基本信息存至SqlServer数据库
  • Android拍照上传至服务器端,连同服务器端代码一并给出,小伙伴们,如果有好的意见可以发送到我的邮箱whsgzcy@foxmail.com
  • android 拍照上传照片

    2016-02-29 10:00:11
    android ,Activity S需要拍照上传照片,但是点用相机后,S会刷新界面,怎么破? Activity S的属性是: android:name="com.example.activity.S" android:screenOrientation="portrait" android:...
  • Android设置拍照或者上传本地图片,很好的例子已经测试过完全可以使用
  • Android仿微信图片上传,可以选择多张图片,缩放预览,拍照上传等 - 享受技术带来的快乐! - 博客频道 - CSDN.NET_files
  • 一、 实现拍照、选择图片并裁剪图片效果 按照之前博客的风格,首先看下实现效果。   二、 uCrop项目应用 想起之前看到的Yalantis/uCrop效果比较绚,但是研究源码之后发现在定制界面方面还是有一点的限制,于是在...
  • android 拍照上传(最新)

    2016-03-14 16:59:29
    android 拍照上传 图片剪切 注释详细 非常适合新手
  • android 拍照上传web端

    2016-03-14 16:51:16
    android 拍照上传web端
  • Android开发——通过HTTP协议,客户端发送图片到服务器,服务器接收图片,仅供参考。
  • Android手机客户端,拍照(或从相册中选择图片),然后上传到服务器。 服务器端接收到手机端上传上来的图片并处理后返回 把从服务器获取到的图片展示在页面上 三. 实现步骤 第一步现在清单文件中把需要的权限写上 ...

    作为新手小白,为了实现这个拍照和相册选取图片并上传功能,确实花费了很多时间,因为实现不容易,所以记录下来,一和大家分享,二为之后学习做个备忘。

    一.实现效果

    在这里插入图片描述

    二. 整体思路

    1. Android手机客户端,拍照(或从相册中选择图片),然后上传到服务器。
    2. 服务器端接收到手机端上传上来的图片并处理后返回
    3. 把从服务器获取到的图片展示在页面上

    三. 实现步骤

    1. 第一步现在清单文件中把需要的权限写上
     <!--  相机-->
       <uses-permission android:name="android.permission.CAMERA" />
        <!-- 存储权限-->
        <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
    
    1. 创建popupWindow弹窗,给出图片选择方式
    2. 通过点击拍摄或相册按钮进行图片拍摄和选择上传,在此处的话,会来个权限的检查和申请
      (相机拍照要有拍照权限和读内存卡权限,相册选择只需读内存卡权限)
    3. 对拍照、相册选择图片的返回结果进行处理 (这里重点是数据类型转换的问题)
      就不多说,先上代码
    public class MyEvaluation<OkHttpClient, FormBody> extends AppCompatActivity implements View.OnClickListener {
       /***
       **控件定义省略。。
       **/
       
        private MyEvalImageAdapter myEvalImageAdapter;
    //    private List<String> imageList=null;
        private List<Map<String,Object>> imageList = null;
        private List<ImageViewInfo> mImgList=null;
    
        private final int TAKE_PHOTO_PERMISSION_REQUEST_CODE = 0;  //拍照的权限处理返回码
        private final int WRITE_SDCARD_PERMISSION_REQUEST_CODE = 1; // 读储存卡内容的权限处理返回码
        private final int REQUEST_CODE_FROM_PHOTO = 2; //相册选取返回的requestCode
        private final int REQUEST_CODE_FROM_CAMERA = 1;//拍照返回的requestCode
        private String imgString = ""; //要上传的图片路径
        private String mFilePath="";  拍照得到的原图保存的图片路径
    
        String[] permissions = new String[]{
                Manifest.permission.CAMERA,
                Manifest.permission.WRITE_EXTERNAL_STORAGE
        };
        AlertDialog alertDialog;
       
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            initView();
        }
        /**
         * todo 初始化控件 initView
         */
        private void initView() {
        /**省略**/
        }
    
    
      //使用相机拍摄功能的权限检查并设置
        private void checkPermission() {
            List<String> permissionList = new ArrayList<>();
            for (int i = 0; i < permissions.length; i++) {
                if (ContextCompat.checkSelfPermission(this, permissions[i]) != PackageManager.PERMISSION_GRANTED) {
                    permissionList.add(permissions[i]);
                }
            }
            if (permissionList.size() <= 0) {
                //说明权限都已经通过,可以做你想做的事情去(调起相机拍摄)
                openCamera();
            } else {
                //对存在的未允许的权限进行申请
                ActivityCompat.requestPermissions(this, permissions, TAKE_PHOTO_PERMISSION_REQUEST_CODE);
            }
        }
    
    
        /**
         * todo 对用户权限授予结果处理
         * @param requestCode 权限要求码,即我们申请权限时传入的常量 如: TAKE_PHOTO_PERMISSION_REQUEST_CODE
         * @param permissions  保存权限名称的 String 数组,可以同时申请一个以上的权限
         * @param grantResults 每一个申请的权限的用户处理结果数组(是否授权)
         */
        @Override
        public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
            super.onRequestPermissionsResult(requestCode, permissions, grantResults);
            switch (requestCode){
                case TAKE_PHOTO_PERMISSION_REQUEST_CODE:
                    boolean haspermission = false;
                    for(int i=0;i<grantResults.length;i++){
                        if (grantResults[i] == -1){
                            haspermission = true;
                        }
                    }
                    if(haspermission){
                        //跳转到系统设置权限页面,或者直接关闭页面,不让他继续访问
                        permissionDialog();
                    }else{
                     //全部权限通过,可以进行下一步操作(调起相机拍摄)
                     openCamera();
                    }
                    break;
                case WRITE_SDCARD_PERMISSION_REQUEST_CODE:
                    if(grantResults.length>0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                    }else{
                        ToolUtils.midToast(this,"读内存卡内容权限被拒绝",1000);
                    }
                    break;
            }
        }
    
        //手动打开设置应用权限
        private void permissionDialog() {
            if (alertDialog == null) {
                alertDialog = new AlertDialog.Builder(this)
                        .setTitle("提示信息")
                        .setMessage("当前应用缺少必要权限,该拍摄功能暂时无法使用。如若需要,请单击【设置】按钮前往设置中心进行权限授权。")
                        .setPositiveButton("设置", new DialogInterface.OnClickListener() {
                            @Override
                            public void onClick(DialogInterface dialog, int which) {
                                cancelPermissionDialog();
                                Uri packageURI = Uri.parse("package:" + getPackageName());
                                Intent intent = new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS, packageURI);
                                startActivity(intent);
                            }
                        })
                        .setNegativeButton("取消", new DialogInterface.OnClickListener() {
                            @Override
                            public void onClick(DialogInterface dialog, int which) {
                                cancelPermissionDialog();
                            }
                        })
                        .create();
            }
            alertDialog.show();
        }
        //用户取消授权,关闭对话款
        private void cancelPermissionDialog() {
            alertDialog.cancel();
        }
    
    
        /**
         * todo 点击事件
         * @param v
         */
        @Override
        public void onClick(View v) {
            switch (v.getId()) {
                case R.id.uploadImg:  //打开弹窗(上传图片方式选择)
                    createPopupWindow(v);
                    break;
                //拍照上传
                case R.id.camera_btn:
                    popupWindow.dismiss();
                    //6.0才用动态权限
                    if (Build.VERSION.SDK_INT >= 23) {
                        checkPermission();
                    }
                    break;
    
                //从相册中选择
                case R.id.pic_btn:
                    popupWindow.dismiss();
                    //6.0才用动态权限
                    if (Build.VERSION.SDK_INT >= 23) {
                        if(ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE)
                                != PackageManager.PERMISSION_GRANTED) {
                            // 申请读写内存卡内容的权限
                            ActivityCompat.requestPermissions(this,
                                    new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE}, WRITE_SDCARD_PERMISSION_REQUEST_CODE);
                        }else{
                            intent = new Intent(Intent.ACTION_PICK,MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
                            startActivityForResult(intent, REQUEST_CODE_FROM_PHOTO);
                        }
                    }
    
                    break;
                case R.id.cancel_btn: //点击取消按钮,关闭弹窗
                    popupWindow.dismiss();
                    break;
                case R.id.eval_commit_btn:
                    submitComment();  //提交
                    break;
            }
        }
    
        //打开相机拍照
        private void openCamera() {
            // 获取SD卡路径
            mFilePath = Environment.getExternalStorageDirectory().getPath();
            // 保存图片的文件名
            mFilePath = mFilePath + "/" + "IMG"+ Calendar.getInstance().getTime() +".png";
            //android7.0以上版本
            if(Build.VERSION.SDK_INT>=Build.VERSION_CODES.N){
                takePhotoBiggerThan7((new File(mFilePath)).getAbsolutePath());
            }else{
                Intent openCameraIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
                Uri mUri = Uri.fromFile(new File(mFilePath));
    
                openCameraIntent.putExtra(MediaStore.EXTRA_OUTPUT,mUri);
                startActivityForResult(openCameraIntent,REQUEST_CODE_FROM_CAMERA);
            }
    //        intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
    //        startActivityForResult(intent, REQUEST_CODE_FROM_CAMERA);
        }
    
        private void takePhotoBiggerThan7(String absolutePath) {
            Uri mCameraTempUri;
            try {
                ContentValues values = new ContentValues(1);
                values.put(MediaStore.Images.Media.MIME_TYPE, "image/jpg");
                values.put(MediaStore.Images.Media.DATA, absolutePath);
                mCameraTempUri = getContentResolver().insert(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, values);
                Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
                intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION
                        | Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
                if (mCameraTempUri != null) {
                    intent.putExtra(MediaStore.EXTRA_OUTPUT, mCameraTempUri);
                    intent.putExtra(MediaStore.EXTRA_VIDEO_QUALITY, 1);
                }
                startActivityForResult(intent, REQUEST_CODE_FROM_CAMERA);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
       
        /**
         * todo 对拍照、相册选择图片的返回结果进行处理
         * @param requestCode 返回码,用于确定是哪个 Activity 返回的数据
         * @param resultCode 返回结果,一般如果操作成功返回的是 RESULT_OK
         * @param data 返回对应 activity 返回的数据
         */
        @Override
        protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
            super.onActivityResult(requestCode, resultCode, data);
            switch (requestCode){
                // 表示 调用照相机拍照返回
                case REQUEST_CODE_FROM_CAMERA:
                    if(resultCode == RESULT_OK){
                        try {
                            // 获取输入流
                            FileInputStream is = new FileInputStream(mFilePath);
                            // 把流解析成bitmap,此时就得到了清晰的原图
                            Bitmap imageBitmap = BitmapFactory.decodeStream(is);
                            Bitmap newImageBitmap = scaleBitmap(imageBitmap,(float)0.5); //压缩图片
                            Uri imageUri = Uri.parse(MediaStore.Images.Media.insertImage(getContentResolver(),newImageBitmap, "IMG"+ Calendar.getInstance().getTime(),null));
                            imgString = UriToFile(imageUri);
                            upLoadImg(); //调用接口把图片上传到服务器
                        } catch (FileNotFoundException e) {
                            e.printStackTrace();
                        }
                    }
                    break;
                    //从相册中选择图片返回
                case REQUEST_CODE_FROM_PHOTO:
                    if(resultCode == RESULT_OK){
                        try {
                            Uri uri = data.getData();
                            Bitmap imageBitmap = MediaStore.Images.Media.getBitmap(this.getContentResolver(),uri);
                            Bitmap newImageBitmap = scaleBitmap(imageBitmap,(float)0.5); //压缩图片
                            Uri newUri = Uri.parse(MediaStore.Images.Media.insertImage(getContentResolver(),newImageBitmap,"IMG"+ Calendar.getInstance().getTime(),null));
                            imgString = UriToFile(newUri);
                            upLoadImg();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                    break;
            }
        }
    
    
        /**
         * todo  uri 转 file
         * @param uri
         * @return
         */
        public String UriToFile(Uri uri) {
            String[] filePc = {MediaStore.Images.Media.DATA};
            Cursor cursor = getContentResolver().query(uri, filePc, null, null, null);
            cursor.moveToFirst();
            Log.i(TAG, "UriToFile: 22"+cursor);
            int col = cursor.getColumnIndex(filePc[0]);
            String pic = cursor.getString(col);
            cursor.close();
            return pic;
        }
    
        /**
         * todo 压缩图片
         * @param origin
         * @param ratio
         * @return
         */
        public Bitmap scaleBitmap(Bitmap origin, float ratio) {
            if (origin == null) {
                return null;
            }
            int width = origin.getWidth();
            int height = origin.getHeight();
            Matrix matrix = new Matrix();
            matrix.preScale(ratio, ratio);
            Bitmap newBM = Bitmap.createBitmap(origin, 0, 0, width, height, matrix, false);
            return newBM;
        }
    
        /**
         * todo 创建弹窗(用于上传图片方式选择)
         * author wang
         * @param view
         */
        private void createPopupWindow(View view) {
            if(popupView==null){
                popupView = getLayoutInflater().inflate(R.layout.popup_unload_image,null);
            }
            popupWindow = new PopupWindow(popupView, ViewGroup.LayoutParams.MATCH_PARENT,ViewGroup.LayoutParams.WRAP_CONTENT,true);
    //        popupWindow.showAsDropDown(view, view.getWidth(),view.getHeight());
            popupWindow.showAtLocation(findViewById(R.id.layout_parent), Gravity.BOTTOM,0,0);  //底部显示弹窗
            popupWindow.setBackgroundDrawable(getResources().getDrawable(R.color.white));
    
            setAlpha(0.3f);
            //把背景还原
            popupWindow.setOnDismissListener(new PopupWindow.OnDismissListener() {
                @Override
                public void onDismiss() {
                    setAlpha(1.0f);
                }
            });
    
            initPopupView();
        }
    
        /**
         * todo 初始化弹窗的控件
         */
        private void initPopupView() {
            Button camera_btn = popupView.findViewById(R.id.camera_btn);
            Button pic_btn = popupView.findViewById(R.id.pic_btn);
            Button cancel_btn = popupView.findViewById(R.id.cancel_btn);
            camera_btn.setOnClickListener(this);
            pic_btn.setOnClickListener(this);
            cancel_btn.setOnClickListener(this);
        }
    
        /**
         * todo 自定义方法,遮罩层
         * @param f
         */
        private void setAlpha(float f) {
            WindowManager.LayoutParams lp =getWindow().getAttributes();
            lp.alpha = f;
            getWindow().setAttributes(lp);
        }
    
        /**
         * todo handler
         */
        @SuppressLint("HandlerLeak")
        Handler handler = new Handler(){
            @Override
            public void handleMessage(@NonNull Message msg) {
                super.handleMessage(msg);
                switch (msg.what){
                    case 1:
                        try{
                            JSONObject resObj = (JSONObject) msg.obj;
                            if(resObj !=null && resObj.getInt("status")==1000){
                                String imgUrl = Helper.fixImgUrl(resObj.getString("data"));
                                Map<String,Object> imageMap = new HashMap<>();
                                imageMap.put("url",imgUrl);
                                imageList.add(imageMap);
                                Log.i(TAG, "handleMessage:ist "+imageList);
                                myEvalImageAdapter.setData(imageList);
                            }
                        }catch (JSONException je){
                            je.printStackTrace();
                        }
                        break;
                    case 2:
                        break;
    
                }
            }
        };
    
        /**
         * todo 上传图片(api)
         */
        private void upLoadImg() {
            try{
                new Thread(){
                    @Override
                    public void run() {
                        super.run();
                            JSONObject retObj = Helper.imgUpload(imgString,userToken);
    
                            msg = handler.obtainMessage();
                            msg.what=1;
                            msg.obj = retObj;
                            handler.sendMessage(msg);
                    }
                }.start();
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    
        /**
         * todo 创建适配器
         */
        private void createAdapter(){
            GridLayoutManager gridManager = new GridLayoutManager(MyEvaluation.this,3);
            eval_image_rv.setLayoutManager(gridManager);
            myEvalImageAdapter = new MyEvalImageAdapter(getApplicationContext());
            eval_image_rv.setAdapter(myEvalImageAdapter);
            itemClick();
        }
        /**
         * todo 点击图片进行放大预览
         */
        private void itemClick() { 
        /**省略**/
        }
    
        /**
         * todo 点击提交评价
         */
        private void submitComment(){
         /**省略**/
         } 
      }
    
    

    上面给出的代码 基本是用到的,大家也去试试,如果不出意外,是可以运行的了

    四. 重点

    不过接下来我要提下的就是大家调用相机拍照获取的图片不清晰的问题,当然我上面写出的代码,获取到的图片是清晰,但还是要说下:

       //打开相机拍照
        private void openCamera() {
           intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
           startActivityForResult(intent, REQUEST_CODE_FROM_CAMERA);
        }
    

    对返回结果进行处理

      protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
            super.onActivityResult(requestCode, resultCode, data);
            switch (requestCode){
                // 表示 调用照相机拍照
                case REQUEST_CODE_FROM_CAMERA:
                    if(resultCode == RESULT_OK){
                        Bundle bundleData = data.getExtras();
                        Bitmap imageBitmap = (Bitmap) bundleData.get("data");
                        Log.i(TAG, "onActivityResult: ff"+imageBitmap);
                        Bitmap newImageBitmap = scaleBitmap(imageBitmap,(float)0.5); //压缩图片
                        Uri imageUri = Uri.parse(MediaStore.Images.Media.insertImage(getContentResolver(),newImageBitmap, "IMG"+ Calendar.getInstance().getTime(),null));
                        imgString = UriToFile(imageUri);
                        upLoadImg();
                    }
                    break;
    

    对于上面这种方法是不是很熟悉,因为我一开始来就是这样子写的,图片是可以获取到了,但是我这边的需求是要点击可预览大图,一看大图,被吓到了,根本看不清楚大图中的具体内容。
    然后我就又去查了一下,原来调用系统相机去获取data时获取到的只是缩略图,如果想要查看大图,需要将拍照得到的原图则保存到手机中,然后再去读取。

    
        //打开相机拍照
        private void openCamera() {
            // 获取SD卡路径
            mFilePath = Environment.getExternalStorageDirectory().getPath();
            // 保存图片的文件名
            mFilePath = mFilePath + "/" + "IMG"+ Calendar.getInstance().getTime() +".png";
            //android7.0以上版本
            if(Build.VERSION.SDK_INT>=Build.VERSION_CODES.N){
                takePhotoBiggerThan7((new File(mFilePath)).getAbsolutePath());
            }else{
                Intent openCameraIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
                Uri mUri = Uri.fromFile(new File(mFilePath));
    
                openCameraIntent.putExtra(MediaStore.EXTRA_OUTPUT,mUri);
                startActivityForResult(openCameraIntent,REQUEST_CODE_FROM_CAMERA);
            }
        }
    
        private void takePhotoBiggerThan7(String absolutePath) {
            Uri mCameraTempUri;
            try {
                ContentValues values = new ContentValues(1);
                values.put(MediaStore.Images.Media.MIME_TYPE, "image/jpg");
                values.put(MediaStore.Images.Media.DATA, absolutePath);
                mCameraTempUri = getContentResolver().insert(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, values);
                Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
                intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION
                        | Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
                if (mCameraTempUri != null) {
                    intent.putExtra(MediaStore.EXTRA_OUTPUT, mCameraTempUri);
                    intent.putExtra(MediaStore.EXTRA_VIDEO_QUALITY, 1);
                }
                startActivityForResult(intent, REQUEST_CODE_FROM_CAMERA);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
      protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
            super.onActivityResult(requestCode, resultCode, data);
            switch (requestCode){
                // 表示 调用照相机拍照
                case REQUEST_CODE_FROM_CAMERA:
                    if(resultCode == RESULT_OK){
                          try {
                            // 获取输入流
                            FileInputStream is = new FileInputStream(mFilePath);
                            // 把流解析成bitmap,此时就得到了清晰的原图
                            Bitmap imageBitmap = BitmapFactory.decodeStream(is);
                            Bitmap newImageBitmap = scaleBitmap(imageBitmap,(float)0.5); //压缩图片
                            Uri imageUri = Uri.parse(MediaStore.Images.Media.insertImage(getContentResolver(),newImageBitmap, "IMG"+ Calendar.getInstance().getTime(),null));
                            imgString = UriToFile(imageUri);
                            upLoadImg(); //调用接口把图片上传到服务器
                        } catch (FileNotFoundException e) {
                            e.printStackTrace();
                        }
                    break;
    

    这样子就可以获取到清晰的图片啦

    注意:
    在Uri imageUri = Uri.parse(MediaStore.Images.Media.insertImage(getContentResolver(),newImageBitmap, “IMG”+ Calendar.getInstance().getTime(),null))中使用MediaStore.Images.Media.insertImage方法会使相册中生成两张一模一样的图,所以有必要的话在用完后把它給删除
    this.getContentResolver().delete(uri, null, null);

    五. 出错排查

    以下问题是我在开发过程中遇到的,然后我自己的一个解决方案,供大家参考下,具体如何还得根据自己的情况来

    1. 问题一
      在这里插入图片描述
      解决方法:在清单文件中添加 android:requestLegacyExternalStorage="true"就可以了
      在这里插入图片描述

    2. 问题二
      在这里插入图片描述
      出错原因:
      在这里插入图片描述
      解决方案:
      在这里插入图片描述

    展开全文
  • Android实现拍照相册图片上传功能

    万次阅读 多人点赞 2018-06-12 10:39:56
    更改头像功能不像修改信息一样直接提交参数就可以,需要上传图片文件 我就直接贴代码了首先给出布局文件 &lt;ImageView android:id="@+id/iv" android:layout_width="50dp" android:...

    更改头像功能不像修改信息一样直接提交参数就可以,需要上传图片文件
    我就直接贴代码了首先给出布局文件

      <ImageView
            android:id="@+id/iv"
            android:layout_width="50dp"
            android:layout_height="50dp"
            android:src="@mipmap/ic_launcher" />
    
        <Button
            android:id="@+id/btn1"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="拍照" />
    
        <Button
            android:id="@+id/btn2"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="摄像" />
        <TextView
            android:id="@+id/tv"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content" />

    然后就是上传的代码了

    public class MainActivity extends AppCompatActivity implements View.OnClickListener {
        private Button btn1, btn2;
        private ImageView headIv;
        private TextView textView;
        private static final String TAG = "MainActivity";
        private final int IMAGE_RESULT_CODE = 2;
        private final int PICK = 1;
        private String url = "";//此处为上传图片地址,我就不写了
        private String imgString = "";
        private Intent intent;
        private Handler mHandler = new Handler(Looper.getMainLooper());
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            btn1 = findViewById(R.id.btn1);
            btn2 = findViewById(R.id.btn2);
            textView = findViewById(R.id.tv);
            headIv = findViewById(R.id.iv);
            btn1.setOnClickListener(this);
            btn2.setOnClickListener(this);
        }
    
        @Override
        public void onClick(View v) {
            switch (v.getId()) {
                case R.id.btn1:
                    intent = new Intent(android.provider.MediaStore.ACTION_IMAGE_CAPTURE);
                    startActivityForResult(intent, PICK);
                    break;
                case R.id.btn2:
                    intent = new Intent(Intent.ACTION_PICK, android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
                    startActivityForResult(intent, IMAGE_RESULT_CODE);
                    break;
            }
        }
    
        @Override
        protected void onActivityResult(int requestCode, int resultCode, Intent data) {
            super.onActivityResult(requestCode, resultCode, data);
            switch (requestCode) {
                // 表示 调用照相机拍照
                case PICK:
                    if (resultCode == RESULT_OK) {
                        Bundle bundle = data.getExtras();
                        Bitmap bitmap = (Bitmap) bundle.get("data");
                        imgString = bitmapToBase64(bitmap);
                        uploadImg();
                    }
                    break;
                // 选择图片库的图片
                case IMAGE_RESULT_CODE:
                    if (resultCode == RESULT_OK) {
                        Uri uri = data.getData();
                        Bitmap bitmap2 = PhotoUtils.getBitmapFromUri(uri, this);
                        imgString = bitmapToBase64(bitmap2);
                        uploadImg();
                    }
                    break;
            }
        }
    //上传图片文件的操作
        public void uploadImg() {
            OkHttpClient okHttpClient = new OkHttpClient.Builder().build();
            //上传图片参数需要与服务端沟通,我就不多做解释了,我添加的都是我们服务端需要的
            //你们根据情况自行更改
            //另外网络请求我就不多做解释了
            FormBody body = new FormBody.Builder().add("dir", "c/image")
                    .add("data", imgString)
                    .add("file", "headicon")
                    .add("ext", "jpg").build();
            Request request = new Request.Builder().url(url).post(body).build();
            okHttpClient.newCall(request).enqueue(new Callback() {
                @Override
                public void onFailure(Call call, IOException e) {
    
                }
    
                @Override
                public void onResponse(Call call, Response response) throws IOException {
                    final String data = response.body().string();
                    Gson gson = new Gson();
                    final Beans bean = gson.fromJson(data, Beans.class);
                    Log.d(TAG, "onResponse: " + data);
                    mHandler.post(new Runnable() {
                        @Override
                        public void run() {    
                         //加载图片用的Gilde框架,也可以自己自由选择,
                         //""里面取决于服务端的返回值是否需要自行添加地址          
                          Glide.with(MainActivity.this).load(""+bean.getData().getUrl()).into(headIv);
                        }
                    });
                }
            });
        }
    
    //如上参需要64位编码可调用此方法,不需要可以忽略
        public static String bitmapToBase64(Bitmap bitmap) {
    
            String result = null;
            ByteArrayOutputStream baos = null;
            try {
                if (bitmap != null) {
                    baos = new ByteArrayOutputStream();
                    bitmap.compress(Bitmap.CompressFormat.JPEG, 100, baos);
    
                    baos.flush();
                    baos.close();
    
                    byte[] bitmapBytes = baos.toByteArray();
                    result = Base64.encodeToString(bitmapBytes, Base64.DEFAULT);
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    if (baos != null) {
                        baos.flush();
                        baos.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return result;
        }
    }

    我尽量把说明都写在了注释里,就不在这里多说了
    最后把照片工具类贴出来,因为MainActivity有调用
    我不写出来可能有的小伙伴因为这一个报错就不知如何处理
    实体类我就不写了,因为真的太简单了

    public class PhotoUtils {
        private static final String TAG = "PhotoUtils";
    
        /**
         * @param activity    当前activity
         * @param imageUri    拍照后照片存储路径
         * @param requestCode 调用系统相机请求码
         */
        public static void takePicture(Activity activity, Uri imageUri, int requestCode) {
            //调用系统相机
            Intent intentCamera = new Intent();
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
                intentCamera.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION); //添加这一句表示对目标应用临时授权该Uri所代表的文件
            }
            intentCamera.setAction(MediaStore.ACTION_IMAGE_CAPTURE);
            //将拍照结果保存至photo_file的Uri中,不保留在相册中
            intentCamera.putExtra(MediaStore.EXTRA_OUTPUT, imageUri);
            activity.startActivityForResult(intentCamera, requestCode);
        }
    
        /**
         * @param activity    当前activity
         * @param requestCode 打开相册的请求码
         */
        public static void openPic(Activity activity, int requestCode) {
            Intent photoPickerIntent = new Intent(Intent.ACTION_GET_CONTENT);
            photoPickerIntent.setType("image/*");
            activity.startActivityForResult(photoPickerIntent, requestCode);
        }
    
        /**
         * @param activity    当前activity
         * @param orgUri      剪裁原图的Uri
         * @param desUri      剪裁后的图片的Uri
         * @param aspectX     X方向的比例
         * @param aspectY     Y方向的比例
         * @param width       剪裁图片的宽度
         * @param height      剪裁图片高度
         * @param requestCode 剪裁图片的请求码
         */
        public static void cropImageUri(Activity activity, Uri orgUri, Uri desUri, int aspectX, int aspectY, int width, int height, int requestCode) {
            Intent intent = new Intent("com.android.camera.action.CROP");
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
                intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
            }
            intent.setDataAndType(orgUri, "image/*");
            intent.putExtra("crop", "true");
            intent.putExtra("aspectX", aspectX);
            intent.putExtra("aspectY", aspectY);
            intent.putExtra("outputX", width);
            intent.putExtra("outputY", height);
            intent.putExtra("scale", true);
            //将剪切的图片保存到目标Uri中
            intent.putExtra(MediaStore.EXTRA_OUTPUT, desUri);
            intent.putExtra("return-data", false);
            intent.putExtra("outputFormat", Bitmap.CompressFormat.JPEG.toString());
            intent.putExtra("noFaceDetection", true);
            activity.startActivityForResult(intent, requestCode);
        }
    
        /**
         * 读取uri所在的图片
         *
         * @param uri      图片对应的Uri
         * @param mContext 上下文对象
         * @return 获取图像的Bitmap
         */
        public static Bitmap getBitmapFromUri(Uri uri, Context mContext) {
            try {
                Bitmap bitmap = MediaStore.Images.Media.getBitmap(mContext.getContentResolver(), uri);
                return bitmap;
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }
    
        /**
         * @param context 上下文对象
         * @param uri     当前相册照片的Uri
         * @return 解析后的Uri对应的String
         */
        @SuppressLint("NewApi")
        public static String getPath(final Context context, final Uri uri) {
    
            final boolean isKitKat = Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT;
            String pathHead = "file:///";
            // DocumentProvider
            if (isKitKat && DocumentsContract.isDocumentUri(context, uri)) {
                // ExternalStorageProvider
                if (isExternalStorageDocument(uri)) {
                    final String docId = DocumentsContract.getDocumentId(uri);
                    final String[] split = docId.split(":");
                    final String type = split[0];
                    if ("primary".equalsIgnoreCase(type)) {
                        return pathHead + Environment.getExternalStorageDirectory() + "/" + split[1];
                    }
                }
                // DownloadsProvider
                else if (isDownloadsDocument(uri)) {
    
                    final String id = DocumentsContract.getDocumentId(uri);
    
                    final Uri contentUri = ContentUris.withAppendedId(Uri.parse("content://downloads/public_downloads"), Long.valueOf(id));
    
                    return pathHead + getDataColumn(context, contentUri, null, null);
                }
                // MediaProvider
                else if (isMediaDocument(uri)) {
                    final String docId = DocumentsContract.getDocumentId(uri);
                    final String[] split = docId.split(":");
                    final String type = split[0];
    
                    Uri contentUri = null;
                    if ("image".equals(type)) {
                        contentUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
                    } else if ("video".equals(type)) {
                        contentUri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
                    } else if ("audio".equals(type)) {
                        contentUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
                    }
    
                    final String selection = "_id=?";
                    final String[] selectionArgs = new String[]{split[1]};
    
                    return pathHead + getDataColumn(context, contentUri, selection, selectionArgs);
                }
            }
            // MediaStore (and general)
            else if ("content".equalsIgnoreCase(uri.getScheme())) {
                return pathHead + getDataColumn(context, uri, null, null);
            }
            // File
            else if ("file".equalsIgnoreCase(uri.getScheme())) {
                return pathHead + uri.getPath();
            }
            return null;
        }
    
        /**
         * Get the value of the data column for this Uri. This is useful for
         * MediaStore Uris, and other file-based ContentProviders.
         *
         * @param context       The context.
         * @param uri           The Uri to query.
         * @param selection     (Optional) Filter used in the query.
         * @param selectionArgs (Optional) Selection arguments used in the query.
         * @return The value of the _data column, which is typically a file path.
         */
        private static String getDataColumn(Context context, Uri uri, String selection, String[] selectionArgs) {
    
            Cursor cursor = null;
            final String column = "_data";
            final String[] projection = {column};
            try {
                cursor = context.getContentResolver().query(uri, projection, selection, selectionArgs, null);
                if (cursor != null && cursor.moveToFirst()) {
                    final int column_index = cursor.getColumnIndexOrThrow(column);
                    return cursor.getString(column_index);
                }
            } finally {
                if (cursor != null)
                    cursor.close();
            }
            return null;
        }
    
        /**
         * @param uri The Uri to check.
         * @return Whether the Uri authority is ExternalStorageProvider.
         */
        private static boolean isExternalStorageDocument(Uri uri) {
            return "com.android.externalstorage.documents".equals(uri.getAuthority());
        }
    
        /**
         * @param uri The Uri to check.
         * @return Whether the Uri authority is DownloadsProvider.
         */
        private static boolean isDownloadsDocument(Uri uri) {
            return "com.android.providers.downloads.documents".equals(uri.getAuthority());
        }
    
        /**
         * @param uri The Uri to check.
         * @return Whether the Uri authority is MediaProvider.
         */
        private static boolean isMediaDocument(Uri uri) {
            return "com.android.providers.media.documents".equals(uri.getAuthority());
        }
    }
    展开全文
  • android拍照后将照片上传至web服务器,服务器端使用servlet+tomcat实现,拍照时实现自动对焦,并且可以调整相机焦距
  • 怎么把拍照好的图片数据放到gallery中显示又要保存到sdcard上,请看下面的实例

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,422
精华内容 3,368
关键字:

android拍照上传图片