• Android拍照、相册选取、裁剪图片


    来自:http://blog.csdn.net/ryantang03/article/details/8656278

    package com.example.listactivity;
    
    
    
    import java.io.ByteArrayOutputStream;
    import java.io.File;
    
    import com.example.model.ImageTools;
    
    import android.app.Activity;
    import android.app.AlertDialog;
    import android.content.Context;
    import android.content.DialogInterface;
    import android.content.Intent;
    import android.content.SharedPreferences;
    import android.content.SharedPreferences.Editor;
    import android.graphics.Bitmap;
    import android.graphics.BitmapFactory;
    import android.net.Uri;
    import android.os.Bundle;
    import android.os.Environment;
    import android.provider.MediaStore;
    import android.provider.MediaStore.Images.Media;
    import android.util.Log;
    import android.view.View;
    import android.view.View.OnClickListener;
    import android.widget.ImageView;
    
    public class Paizhao extends Activity {
        
        private ImageView paizhao;
        private static final int SCALE = 5;//照片缩小比例
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            // TODO Auto-generated method stub
            super.onCreate(savedInstanceState);
            setContentView(R.layout.paizhao);
            paizhao = (ImageView)this.findViewById(R.id.paizhao);
            paizhao.setOnClickListener(new TanDialog());
        }
        
        class TanDialog implements OnClickListener{
    
            @Override
            public void onClick(View v) {
                showPicturePicker(Paizhao.this);
            }
    
            
        }
    
        private void showPicturePicker(Context context) {
            
            AlertDialog.Builder dialog = new AlertDialog.Builder(context);
            dialog.setTitle("图片来源");
            dialog.setNegativeButton("取消", null);
            dialog.setItems(new String[]{"拍照","相册"},new DialogInterface.OnClickListener() {
                
                @Override
                public void onClick(DialogInterface dialog, int which) {
                    int REQUEST_CODE;
                    switch(which){
                    
                    //拍照
                    case 0:
                        REQUEST_CODE =0;
                        //启动相机                    
                        Intent openCameraIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
                        SharedPreferences share = getSharedPreferences("temp", Context.MODE_WORLD_WRITEABLE);
                        ImageTools.deletePhotoAtPathAndName(Environment.getExternalStorageDirectory().getAbsolutePath(), share.getString("tempName", ""));
                        
                        String filename = String.valueOf(System.currentTimeMillis())+".jpg";
                        Editor editor = share.edit();
                        editor.putString("tempName", filename);
                        editor.commit();
                        
                        Uri imguri = Uri.fromFile(new File(Environment.getExternalStorageDirectory(),filename));
                        //开启
                        openCameraIntent.putExtra(MediaStore.EXTRA_OUTPUT, imguri);
                        startActivityForResult(openCameraIntent, REQUEST_CODE);
                        break;
                        
                        //相册
                    case 1:
                        Intent openAlbumIntent = new Intent(Intent.ACTION_GET_CONTENT);
                        openAlbumIntent.setDataAndType(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, "image/*");
                        startActivityForResult(openAlbumIntent, 0);
                        break;
                    }
                    
                }
            } );
            dialog.create().show();
            
        }
        
        @Override
        //照相以后返回的照片
        protected void onActivityResult(int requestCode, int resultCode, Intent data) {
            super.onActivityResult(requestCode, resultCode, data);
            if(resultCode == RESULT_OK){
                
                switch (requestCode) {
                //拍照
                case 0:
                    Uri uri = null;
                    if(data != null){
                        uri = data.getData();
                        Log.e("----?", "data");
                    }else{
                        Log.e("----?", "file");
                        String fileName = getSharedPreferences("temp",Context.MODE_WORLD_WRITEABLE).getString("tempName", "");
                        uri = Uri.fromFile(new File(Environment.getExternalStorageDirectory(),fileName));
                    }
                    //剪裁
                    cropImage(uri, 500, 500, 1);
                    break;
                case 1:
                    Bitmap photo = null;
                    Uri photoUri = data.getData();
                    if (photoUri != null) {
                        photo = BitmapFactory.decodeFile(photoUri.getPath());
                    }
                    if (photo == null) {
                        Bundle extra = data.getExtras();
                        if (extra != null) {
                            photo = (Bitmap)extra.get("data");  
                            ByteArrayOutputStream stream = new ByteArrayOutputStream();  
                            photo.compress(Bitmap.CompressFormat.JPEG, 100, stream);
                        }  
                    }
                    paizhao.setImageBitmap(photo);
                    break;
                }
            }
        }
        
        //截取图片
        public void cropImage(Uri uri, int outputX, int outputY, int requestCode){
            Intent intent = new Intent("com.android.camera.action.CROP");  
            intent.setDataAndType(uri, "image/*");  
            intent.putExtra("crop", "true");  
            intent.putExtra("aspectX", 1);  
            intent.putExtra("aspectY", 1);  
            intent.putExtra("outputX", outputX);   
            intent.putExtra("outputY", outputY); 
            intent.putExtra("outputFormat", "JPEG");
            intent.putExtra("noFaceDetection", true);
            intent.putExtra("return-data", true);  
            startActivityForResult(intent, requestCode);
        }
        
    }

    ImageTools 类

    package com.example.model;
    
    import java.io.ByteArrayInputStream;
    import java.io.ByteArrayOutputStream;
    import java.io.File;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    
    import android.graphics.Bitmap;
    import android.graphics.Bitmap.Config;
    import android.graphics.BitmapFactory;
    import android.graphics.Canvas;
    import android.graphics.LinearGradient;
    import android.graphics.Matrix;
    import android.graphics.Paint;
    import android.graphics.PixelFormat;
    import android.graphics.PorterDuff.Mode;
    import android.graphics.PorterDuffXfermode;
    import android.graphics.Rect;
    import android.graphics.RectF;
    import android.graphics.Shader.TileMode;
    import android.graphics.drawable.BitmapDrawable;
    import android.graphics.drawable.Drawable;
    
    /**
     * Tools for handler picture
     * 
     * @author Ryan.Tang
     * 
     */
    public final class ImageTools {
    
        /**
         * Transfer drawable to bitmap
         * 
         * @param drawable
         * @return
         */
        public static Bitmap drawableToBitmap(Drawable drawable) {
            int w = drawable.getIntrinsicWidth();
            int h = drawable.getIntrinsicHeight();
    
            Bitmap.Config config = drawable.getOpacity() != PixelFormat.OPAQUE ? Bitmap.Config.ARGB_8888
                    : Bitmap.Config.RGB_565;
            Bitmap bitmap = Bitmap.createBitmap(w, h, config);
            Canvas canvas = new Canvas(bitmap);
            drawable.setBounds(0, 0, w, h);
            drawable.draw(canvas);
            return bitmap;
        }
    
        /**
         * Bitmap to drawable
         * 
         * @param bitmap
         * @return
         */
        public static Drawable bitmapToDrawable(Bitmap bitmap) {
            return new BitmapDrawable(bitmap);
        }
    
        /**
         * Input stream to bitmap
         * 
         * @param inputStream
         * @return
         * @throws Exception
         */
        public static Bitmap inputStreamToBitmap(InputStream inputStream)
                throws Exception {
            return BitmapFactory.decodeStream(inputStream);
        }
    
        /**
         * Byte transfer to bitmap
         * 
         * @param byteArray
         * @return
         */
        public static Bitmap byteToBitmap(byte[] byteArray) {
            if (byteArray.length != 0) {
                return BitmapFactory
                        .decodeByteArray(byteArray, 0, byteArray.length);
            } else {
                return null;
            }
        }
    
        /**
         * Byte transfer to drawable
         * 
         * @param byteArray
         * @return
         */
        public static Drawable byteToDrawable(byte[] byteArray) {
            ByteArrayInputStream ins = null;
            if (byteArray != null) {
                ins = new ByteArrayInputStream(byteArray);
            }
            return Drawable.createFromStream(ins, null);
        }
    
        /**
         * Bitmap transfer to bytes
         * 
         * @param byteArray
         * @return
         */
        public static byte[] bitmapToBytes(Bitmap bm) {
            byte[] bytes = null;
            if (bm != null) {
                ByteArrayOutputStream baos = new ByteArrayOutputStream();
                bm.compress(Bitmap.CompressFormat.PNG, 100, baos);
                bytes = baos.toByteArray();
            }
            return bytes;
        }
    
        /**
         * Drawable transfer to bytes
         * 
         * @param drawable
         * @return
         */
        public static byte[] drawableToBytes(Drawable drawable) {
            BitmapDrawable bitmapDrawable = (BitmapDrawable) drawable;
            Bitmap bitmap = bitmapDrawable.getBitmap();
            byte[] bytes = bitmapToBytes(bitmap);
            ;
            return bytes;
        }
    
        /**
         * Base64 to byte[]
    //     */
    //    public static byte[] base64ToBytes(String base64) throws IOException {
    //        byte[] bytes = Base64.decode(base64);
    //        return bytes;
    //    }
    //
    //    /**
    //     * Byte[] to base64
    //     */
    //    public static String bytesTobase64(byte[] bytes) {
    //        String base64 = Base64.encode(bytes);
    //        return base64;
    //    }
    
        /**
         * Create reflection images
         * 
         * @param bitmap
         * @return
         */
        public static Bitmap createReflectionImageWithOrigin(Bitmap bitmap) {
            final int reflectionGap = 4;
            int w = bitmap.getWidth();
            int h = bitmap.getHeight();
    
            Matrix matrix = new Matrix();
            matrix.preScale(1, -1);
    
            Bitmap reflectionImage = Bitmap.createBitmap(bitmap, 0, h / 2, w,
                    h / 2, matrix, false);
    
            Bitmap bitmapWithReflection = Bitmap.createBitmap(w, (h + h / 2),
                    Config.ARGB_8888);
    
            Canvas canvas = new Canvas(bitmapWithReflection);
            canvas.drawBitmap(bitmap, 0, 0, null);
            Paint deafalutPaint = new Paint();
            canvas.drawRect(0, h, w, h + reflectionGap, deafalutPaint);
    
            canvas.drawBitmap(reflectionImage, 0, h + reflectionGap, null);
    
            Paint paint = new Paint();
            LinearGradient shader = new LinearGradient(0, bitmap.getHeight(), 0,
                    bitmapWithReflection.getHeight() + reflectionGap, 0x70ffffff,
                    0x00ffffff, TileMode.CLAMP);
            paint.setShader(shader);
            // Set the Transfer mode to be porter duff and destination in
            paint.setXfermode(new PorterDuffXfermode(Mode.DST_IN));
            // Draw a rectangle using the paint with our linear gradient
            canvas.drawRect(0, h, w, bitmapWithReflection.getHeight()
                    + reflectionGap, paint);
    
            return bitmapWithReflection;
        }
    
        /**
         * Get rounded corner images
         * 
         * @param bitmap
         * @param roundPx
         *            5 10
         * @return
         */
        public static Bitmap getRoundedCornerBitmap(Bitmap bitmap, float roundPx) {
            int w = bitmap.getWidth();
            int h = bitmap.getHeight();
            Bitmap output = Bitmap.createBitmap(w, h, Config.ARGB_8888);
            Canvas canvas = new Canvas(output);
            final int color = 0xff424242;
            final Paint paint = new Paint();
            final Rect rect = new Rect(0, 0, w, h);
            final RectF rectF = new RectF(rect);
            paint.setAntiAlias(true);
            canvas.drawARGB(0, 0, 0, 0);
            paint.setColor(color);
            canvas.drawRoundRect(rectF, roundPx, roundPx, paint);
            paint.setXfermode(new PorterDuffXfermode(Mode.SRC_IN));
            canvas.drawBitmap(bitmap, rect, rect, paint);
    
            return output;
        }
    
        /**
         * Resize the bitmap
         * 
         * @param bitmap
         * @param width
         * @param height
         * @return
         */
        public static Bitmap zoomBitmap(Bitmap bitmap, int width, int height) {
            int w = bitmap.getWidth();
            int h = bitmap.getHeight();
            Matrix matrix = new Matrix();
            float scaleWidth = ((float) width / w);
            float scaleHeight = ((float) height / h);
            matrix.postScale(scaleWidth, scaleHeight);
            Bitmap newbmp = Bitmap.createBitmap(bitmap, 0, 0, w, h, matrix, true);
            return newbmp;
        }
    
        /**
         * Resize the drawable
         * @param drawable
         * @param w
         * @param h
         * @return
         */
        public static Drawable zoomDrawable(Drawable drawable, int w, int h) {
            int width = drawable.getIntrinsicWidth();
            int height = drawable.getIntrinsicHeight();
            Bitmap oldbmp = drawableToBitmap(drawable);
            Matrix matrix = new Matrix();
            float sx = ((float) w / width);
            float sy = ((float) h / height);
            matrix.postScale(sx, sy);
            Bitmap newbmp = Bitmap.createBitmap(oldbmp, 0, 0, width, height,
                    matrix, true);
            return new BitmapDrawable(newbmp);
        }
        
        /**
         * Get images from SD card by path and the name of image
         * @param photoName
         * @return
         */
        public static Bitmap getPhotoFromSDCard(String path,String photoName){
            Bitmap photoBitmap = BitmapFactory.decodeFile(path + "/" +photoName +".png");
            if (photoBitmap == null) {
                return null;
            }else {
                return photoBitmap;
            }
        }
        
        /**
         * Check the SD card 
         * @return
         */
        public static boolean checkSDCardAvailable(){
            return android.os.Environment.getExternalStorageState().equals(android.os.Environment.MEDIA_MOUNTED);
        }
        
        /**
         * Get image from SD card by path and the name of image
         * @param fileName
         * @return
         */
        public static boolean findPhotoFromSDCard(String path,String photoName){
            boolean flag = false;
            
            if (checkSDCardAvailable()) {
                File dir = new File(path);
                if (dir.exists()) {
                    File folders = new File(path);
                    File photoFile[] = folders.listFiles();
                    for (int i = 0; i < photoFile.length; i++) {
                        String fileName = photoFile[i].getName().split("\.")[0];
                        if (fileName.equals(photoName)) {
                            flag = true;
                        }
                    }
                }else {
                    flag = false;
                }
    //            File file = new File(path + "/" + photoName  + ".jpg" );
    //            if (file.exists()) {
    //                flag = true;
    //            }else {
    //                flag = false;
    //            }
                
            }else {
                flag = false;
            }
            return flag;
        }
        
        /**
         * Save image to the SD card 
         * @param photoBitmap
         * @param photoName
         * @param path
         */
        public static void savePhotoToSDCard(Bitmap photoBitmap,String path,String photoName){
            if (checkSDCardAvailable()) {
                File dir = new File(path);
                if (!dir.exists()){
                    dir.mkdirs();
                }
                
                File photoFile = new File(path , photoName + ".png");
                FileOutputStream fileOutputStream = null;
                try {
                    fileOutputStream = new FileOutputStream(photoFile);
                    if (photoBitmap != null) {
                        if (photoBitmap.compress(Bitmap.CompressFormat.PNG, 100, fileOutputStream)) {
                            fileOutputStream.flush();
    //                        fileOutputStream.close();
                        }
                    }
                } catch (FileNotFoundException e) {
                    photoFile.delete();
                    e.printStackTrace();
                } catch (IOException e) {
                    photoFile.delete();
                    e.printStackTrace();
                } finally{
                    try {
                        fileOutputStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            } 
        }
        
        /**
         * Delete the image from SD card
         * @param context
         * @param path
         * file:///sdcard/temp.jpg
         */
        public static void deleteAllPhoto(String path){
            if (checkSDCardAvailable()) {
                File folder = new File(path);
                File[] files = folder.listFiles();
                for (int i = 0; i < files.length; i++) {
                    files[i].delete();
                }
            }
        }
        
        public static void deletePhotoAtPathAndName(String path,String fileName){
            if (checkSDCardAvailable()) {
                File folder = new File(path);
                File[] files = folder.listFiles();
                for (int i = 0; i < files.length; i++) {
                    System.out.println(files[i].getName());
                    if (files[i].getName().equals(fileName)) {
                        files[i].delete();
                    }
                }
            }
        }
    
    }

    AndroidManifest

           <uses-feature android:name="android.hardware.camera" />
        <uses-feature android:name="android.hardware.camera.autofocus" />
        <uses-permission android:name="android.permission.CAMERA" />
        <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />

  • 相关阅读:
    iscroll4实现轮播图效果
    用css样式围剿等高列问题(转载)
    一些小bug
    前端代码规范
    !DOCTYPE html文档类型声明简写 HTML5 DOCTYPE缩写
    JS判断鼠标向上滚动还是向下滚动
    css Cursor:url()自定义鼠标指针样式为图片
    线段树-矩形面积求并
    值域线段树 bzoj 4627
    简单数位DP
  • 原文地址:https://www.cnblogs.com/lihaolihao/p/3732477.html
Copyright © 2020-2023  润新知