package com.bluedatax.w65.view;
 
import android.content.Intent;
 
import android.graphics.Bitmap;
 
import android.graphics.BitmapFactory;
 
import android.graphics.Canvas;
 
import android.graphics.Paint;
 
import android.graphics.PorterDuff;
 
import android.graphics.PorterDuffXfermode;
 
import android.graphics.RectF;
 
import android.media.ThumbnailUtils;
 
import android.net.Uri;
 
import android.os.Bundle;
 
import android.os.Environment;
 
import android.provider.MediaStore;
 
import android.view.View;
 
import android.widget.ImageView;
 
import android.widget.RelativeLayout;
 
import android.widget.TextView;
 
import android.widget.Toast;
 
import com.bluedatax.w65.BaseActivity;
 
import com.bluedatax.w65.R;
 
import java.io.BufferedOutputStream;
 
import java.io.File;
 
import java.io.FileNotFoundException;
 
import java.io.FileOutputStream;
 
import java.io.IOException;
 
/** * 设置头像 * Created by bdx108 on 15/11/25. */
 
public class SetIcon extends BaseActivity implements View.OnClickListener {
 
private TextView mTextViewLeft;//标题左边内容
 
private TextView mTextViewMiddle;//标题中间内容
 
private RelativeLayout mLayoutTakePhoto;//拍照按钮
 
private RelativeLayout mLayoutPhoto;//调用系统相册按钮
 
private ImageView mImageViewImage;//显示头像的imageview
 
private static final int PICTURE_FROM_CAMERA=101;
 
private static final int PICTURE_FROM_GALLERY=102;
 
private File file;
 
private Uri uri;
 
@Override
 
protected void onCreate(Bundle savedInstanceState) {
 
super.onCreate(savedInstanceState);
 
setContentView(R.layout.activity_seticon);
 
initWidget();
 
String path=Environment.getExternalStorageDirectory()+"/w65/icon_bitmap/"+ "myicon.jpg";
 
if (path!=null){
 
mImageViewImage.setImageBitmap(new Setting().getDiskBitmap(path));
 
}else {
 
Toast.makeText(getApplicationContext(), "zanshi没有照片", Toast.LENGTH_LONG).show();
 
}
 
}
 
private void initWidget() {
 
mTextViewLeft= (TextView) findViewById(R.id.textview_title_left);
 
mTextViewMiddle= (TextView) findViewById(R.id.textview_title_middle);
 
mImageViewImage= (ImageView) findViewById(R.id.circleimage_seticon);
 
mImageViewImage.setOnClickListener(this);
 
mLayoutTakePhoto= (RelativeLayout) findViewById(R.id.layout_takephoto);
 
mLayoutTakePhoto.setOnClickListener(this);
 
mLayoutPhoto = (RelativeLayout) findViewById(R.id.layout_photo);
 
mLayoutPhoto.setOnClickListener(this);
 
mTextViewLeft.setText("账户");
 
mTextViewMiddle.setText("设置头像");
 
}
 
@Override
 
public void onClick(View v) {
 
switch (v.getId()){
 
case R.id.layout_takephoto:
 
startCamera();
 
break;
 
case R.id.layout_photo:
 
Intent intent = new Intent();
 
//设置启动相册的Action
 
intent.setAction(Intent.ACTION_GET_CONTENT);
 
//设置类型
 
intent.setType("image/*");
 
//启动相册，这里使用有返回结果的启动
 
startActivityForResult(intent, PICTURE_FROM_GALLERY);
 
break;
 
case R.id.circleimage_seticon:
 
Intent intent1=new Intent(SetIcon.this,ImageLarge.class);
 
startActivity(intent1);
 
break;
 
default:
 
break;
 
}
 
}
 
/** * 调用系统相机拍照 */
 
private void startCamera() {
 
Intent intent = new Intent();
 
//启动相机的Action
 
intent.setAction(MediaStore.ACTION_IMAGE_CAPTURE);
 
//文件的保存位置
 
file = new File(Environment.getExternalStorageDirectory(),
 
System.currentTimeMillis() + ".jpg");
 
if (!file.exists()) {
 
try {
 
file.createNewFile();
 
} catch (IOException e) {
 
e.printStackTrace();
 
}
 
}
 
//设置图片拍摄后保存的位置
 
intent.putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(file));
 
//启动相机，这里使用有返回结果的启动
 
startActivityForResult(intent, PICTURE_FROM_CAMERA);
 
}
 
@Override
 
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
 
super.onActivityResult(requestCode, resultCode, data);
 
if (resultCode == RESULT_OK) {
 
switch (requestCode) {
 
case PICTURE_FROM_CAMERA:
 
Bitmap bp = getCameraBitmap();
 
try {
 
saveFile(bp);
 
} catch (IOException e) {
 
e.printStackTrace();
 
}
 
mImageViewImage.setImageBitmap(bp);
 
break;
 
case PICTURE_FROM_GALLERY:
 
Bitmap bit = getPhotoBitmap(data);
 
try {
 
saveFile(bit);
 
} catch (IOException e) {
 
e.printStackTrace();
 
}
 
mImageViewImage.setImageBitmap(bit);
 
break;
 
}
 
}
 
}
 
public Bitmap getPhotoBitmap(Intent data) {
 
Bitmap bitmap=null;
 
Bitmap bit=null;
 
try {
 
uri=data.getData();
 
bitmap= BitmapFactory.decodeStream(getContentResolver().openInputStream(uri));
 
bitmap= ThumbnailUtils.extractThumbnail(bitmap, 300, 300);
 
bit=toRoundBitmap(bitmap);
 
} catch (FileNotFoundException e) {
 
e.printStackTrace();
 
}
 
//return bit;
 
return bitmap;
 
}
 
/** * 得到相机拍照后的照片的bitmap *@return */
 
public Bitmap getCameraBitmap() {
 
Bitmap bitmap=null;
 
try {
 
bitmap= BitmapFactory.decodeStream(getContentResolver().openInputStream(Uri.fromFile(file)));
 
bitmap= ThumbnailUtils.extractThumbnail(bitmap, 300, 300);
 
} catch (FileNotFoundException e) {
 
e.printStackTrace();
 
}
 
//Bitmap pic = getBitmap();//另一种显示图片的方法
 
//toRoundBitmap(pic);
 
//返回一个圆形的bitmap
 
//return toRoundBitmap(bitmap);
 
return bitmap;
 
}
 
// private Bitmap getBitmap() {
 
// BitmapFactory.Options op = new BitmapFactory.Options();
 
// op.inSampleSize = 10; //这个数字越大,图片大小越小.
 
// Bitmap pic= BitmapFactory.decodeFile(file.getAbsolutePath(), op);
 
// //这个ImageView是拍照完成后显示图片
 
// FileOutputStream b = null;
 
// try {
 
// b = new FileOutputStream(file.getAbsolutePath());
 
// } catch (FileNotFoundException e) {
 
// e.printStackTrace();
 
// }
 
// if(pic != null){
 
// pic.compress(Bitmap.CompressFormat.JPEG, 100, b);
 
// }
 
// return pic;
 
// }
 
/** * 将一个bitmap转化为圆形输出 *@param bitmap *@return */
 
public Bitmap toRoundBitmap(Bitmap bitmap){
 
int width=bitmap.getWidth();
 
int height=bitmap.getHeight();
 
int r=0;
 
if (width
 
r=width;
 
}else {
 
r=height;
 
}
 
Bitmap backgroundBitmap=Bitmap.createBitmap(width,height, Bitmap.Config.ARGB_8888);
 
Canvas canvas=new Canvas(backgroundBitmap);
 
Paint paint=new Paint();
 
paint.setAntiAlias(true);
 
RectF rectF=new RectF(0,0,r,r);
 
canvas.drawRoundRect(rectF,r/2,r/2,paint);
 
paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
 
canvas.drawBitmap(bitmap,null,rectF,paint);
 
return backgroundBitmap;
 
}
 
/** * 保存文件 *@param bm *@throws IOException */
 
public File saveFile(Bitmap bm) throws IOException {
 
String path = Environment.getExternalStorageDirectory().toString()+"/w65/icon_bitmap/";
 
File dirFile = new File(path);
 
if(!dirFile.exists()){
 
dirFile.mkdirs();
 
}
 
File myIconFile= new File(path + "myicon.jpg");
 
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(myIconFile));
 
bm.compress(Bitmap.CompressFormat.JPEG, 80, bos);
 
bos.flush();
 
bos.close();
 
return myIconFile;
 
}
 
}

 
 
该文章讲述了Android原生态开发过程中设置用户原型头像的实现过程。主要使用到技术有：Android原生态开发、CircleImageView圆形图片视图、Crop裁剪工具等。
 
 
1.业务介绍
 
业务具体流程可以分为一下几个过程：
 1.用户点击进行圆形头像设置，可以选择拍照设置和从本地选择图片进行设置两种设计方案。（一下以拍照设置为例进行说明）
 2.调用手机相机进行拍照
 3.获取拍照照片后调用Crop工具进行照片裁剪。
 4.将照片资源添加到CircleImageView视图中。
 下面将对整个过程进行详细讲解。
 
2.详细过程说明
 
选择照片来源
 
头像来源可以时本地也可以时拍照，系统可以为用户提供两种选择途径。该功能的实现方式可以采用Dialog实现。具体可见：一个好看的Dialog样式实现，仿IOS。
 
获取照片资源
 
上述已经说明，获取照片的途径有两种，如果进行拍照设置，那么系统应该调用手机相机进行拍照，如果选择本地照片，那么系统应该打开手机本地图库。该过程的具体代码如下：
 
    /**
     * 从本地相册选取图片作为头像
     * 将为用户打开本地图库
     */
    public void choseHeadImageFromGallery() {
        Intent intentFromGallery = new Intent();
        // 设置文件类型
        intentFromGallery.setType("image/*");
        intentFromGallery.setAction(Intent.ACTION_GET_CONTENT);
        activity.startActivityForResult(intentFromGallery, CODE_GALLERY_REQUEST);
    }
    /**
     * 启动手机相机拍摄照片作为头像
     * 将调用本地相机
     * 注意：该过程中首先判断了系统是否有存储卡，如果有的情况下将为Intent设置一个Uri对象，该对象可以理解为资源标识符。
     * Uri资源标识符将标识一个资源的存在，可以通过它获取一个资源信息。
     * 当为Intent设置 MediaStore.EXTRA_OUTPUT 输出位置时onActivityResult方法的intent.getData()方法将获取的时一个null
     * 否则获取是Bitmap对象
     */
    public void choseHeadImageFromCameraCapture() {
        Intent intentFromCapture = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
        // 判断存储卡是否可用，存储照片文件
        if (hasSdcard()) {
            uri = getUriForFile(activity,"head");
            intentFromCapture.putExtra(MediaStore.EXTRA_OUTPUT,uri);
        }
        activity.startActivityForResult(intentFromCapture, CODE_CAMERA_REQUEST);
    }
 
上述过程中使用了hasSdcard()方法和getUriForFile(activity,“head”)方法，这两个方法的实现过程如下：
 
    /**
     * 检查设备是否存在SDCard的工具方法
     */
    public boolean hasSdcard() {
        String state = Environment.getExternalStorageState();
        if (state.equals(Environment.MEDIA_MOUNTED)) {
            // 有存储的SDCard
            return true;
        } else {
            return false;
        }
    }
    /** 获取uri资源 **/
    public static Uri getUriForFile(Context context,String path){
        // 生成文件
        makeRootDirectory(basePath + DataTool.sdf_ymd.format(new Date()));
        // 生成文件
        File file = new File(basePath +DataTool.sdf_ymd.format(new Date()) , path + ".jpg");
        PicTool.file = file.getAbsolutePath();
        return getUriForFile(context,file);
    };
	/** 生成文件夹 **/
	public static boolean makeRootDirectory(String filePath) {
		File file = null;
		try {
			file = new File(filePath);
			if (!file.exists()) {
				file.mkdirs();
			}else{
				file.delete();
				file.mkdirs();
			}
			return true;
		} catch (Exception e) {
			Log.i("error:", e+"");
			return false;
		}
	}
    /**
     * 生成URL
     * @param context
     * @param file
     * @return
     */
    public static Uri getUriForFile(Context context, File file) {
        if (context == null || file == null) {
            throw new NullPointerException();
        }
        Uri uri;
        if (Build.VERSION.SDK_INT >= 24) {
            uri = FileProvider.getUriForFile(context.getApplicationContext(), "包名.fileprovider", file);
        } else {
            uri = Uri.fromFile(file);
        }
        return uri;
    }
 
由以上代码可以看出，在生成Uri对象的过程中使用到了FileProvider，这是由于在Android7.0以后使用FileProvider在应用中共享文件资源。在使用FileProvider过程中需要进行配置。配置过程如下：
 1.首先在res文件夹下床架xml文件夹，并创建file_path.xml文件。在该文件中做出一下配置：
 
<?xml version="1.0" encoding="utf-8"?>
<paths xmlns:android="http://schemas.android.com/apk/res/android">
    <external-path
        name="external"
        path="." />
    <external-files-path
        name="external_files"
        path="." />
    <cache-path
        name="cache"
        path="." />
    <external-cache-path
        name="external_cache"
        path="." />
    <files-path
        name="files"
        path="." />
</paths>
 
2.在AndroidManifest.xml文件中进行配置刚才的xml信息。
 
        <provider
            android:name="androidx.core.content.FileProvider"
            android:authorities="包名.fileprovider"
            android:exported="false"
            android:grantUriPermissions="true">
            <meta-data
                android:name="android.support.FILE_PROVIDER_PATHS"
                android:resource="@xml/file_path" />
        </provider>
 
以上两个操作可以完成FileProvider使用设置，该过程实际上标识了该应用可获取文件资源的范围。
 
拍照后的操作
 
拍照后的结果是由onActivityResult来接受处理的，在前面代码中
 
 Intent intentFromCapture = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
        // 判断存储卡是否可用，存储照片文件
        if (hasSdcard()) {
            uri = getUriForFile(activity,"head");
            intentFromCapture.putExtra(MediaStore.EXTRA_OUTPUT,uri);
        }
        activity.startActivityForResult(intentFromCapture, CODE_CAMERA_REQUEST);
 
我们可以看出给Intent对象传入的uri并不是个局部对象，这是由于当intent对象携带uri时，onActivityResult方法的intent对象并不能再次接受到Uri信息。因此需要将Uri对象作为全局变量存储。当调用onActivityResult方法处理照片资源时其实是处理全局的Uri对象。onAcitivityResult方法的具体操作输入：
 
    public void deal(int requestCode, int resultCode,
                     Intent intent){
        switch (requestCode) {
            case CODE_GALLERY_REQUEST: // 从本地获取
                if (PicTool.hasSdcard()) {
                    Crop.of(intent.getData(), resultUri).asSquare().start(activity);
                } else {
                    Toast.makeText(activity, "没有SDCard!", Toast.LENGTH_LONG)
                            .show();
                }
                break;
            case CODE_CAMERA_REQUEST: // 拍照成功后调用
                if (PicTool.hasSdcard()) {
                    Uri resultUri =  PicTool.getUriForFile(activity,"headPic");
                    Crop.of(uri, resultUri).asSquare().start(activity);
                } else {
                    Toast.makeText(activity, "没有SDCard!", Toast.LENGTH_LONG)
                            .show();
                }
                break;
            case Crop.REQUEST_CROP://使用Crop裁剪之后调用
            {
                if(resultCode == Crop.RESULT_ERROR) {
                    Toast.makeText(activity,"裁剪失败",Toast.LENGTH_SHORT).show();
                }else{
                    //裁剪成功后调用  如果setImageURL设置的url是同一个值的话  则无法改变前端显示
                    Uri result = Crop.getOutput(intent);
                    view.setImageURI(null);
                    view.setImageURI(result);
                }
                break;
            }
        }
    }
 
调用裁剪
 
在该过程中，调用裁剪使用了Crop工具。使用该工具需要做出一下引入：
 
    //圆形头像
    implementation 'de.hdodenhof:circleimageview:3.1.0'
    //裁剪照片
    compile 'com.soundcloud.android:android-crop:1.0.1@aar'
    compile 'com.github.bumptech.glide:glide:3.7.0'
 
Crop的实际使用过程相对比较简单，可以分为两个过程，如下：
 1.在AndroidManifest.xml文件中进行配置
 
<activity android:name="com.soundcloud.android.crop.CropImageActivity" />
 
实际上就是声明了一个acitivity，这是因为在进行裁剪的过程中实际上实在Crop实现的Acitivity上进行的，该Activity已经在crop包中实现了，因此需要在AndroidManifest.xml文件中文件中进行说明。
 2.代码中调用
 
/**
* 在该方法中需要三个参数：uri、resultUri和activity
* uri是需要裁剪的照片资源标识符
* resultUri是存储裁剪后的照片的资源标识符
* activity是调用裁剪的主体
**/
Crop.of(uri, resultUri).asSquare().start(activity);
 
当裁剪操作接受后，其实还是由onResultActivity进行接受处理，处理过程：
 
            case Crop.REQUEST_CROP://使用Crop裁剪之后调用
            {
                if(resultCode == Crop.RESULT_ERROR) {
                    Toast.makeText(activity,"裁剪失败",Toast.LENGTH_SHORT).show();
                }else{
                    //裁剪成功后调用  如果setImageURL设置的url是同一个值的话  则无法改变前端显示
                    Uri result = Crop.getOutput(intent);
                    view.setImageURI(null);
                    view.setImageURI(result);
                }
                break;
            }
 
注意：在该过程中，对view进行设置图片资源，首先执行了view.setImageURI(null);方法。这是由于setImageURI方法做了优化处理，它首先判断Uri指向的是否是同一个资源（路径以及文件名是否相同），如果是同一个资源的话，该方便并不会对view再进行Uri设置。
 
以上整个过程就完成了，下面进行简单梳理一下：
 1.调用dialog显示
 2.调用相机或者本地图库（如果调用相机的过程中该Intent设置了Uri，则onResultActivity方法的Intent对象的getData方法将接受不到信息）
 3.图片资源信息获取成功后通过Crop进行裁剪
 4.裁剪后的信息依旧交由onResultActivity方法进行处理
 
3.具体实现过程
 
1.jar包的引入：
 
    //圆形头像
    implementation 'de.hdodenhof:circleimageview:3.1.0'
    //裁剪照片
    compile 'com.soundcloud.android:android-crop:1.0.1@aar'
    compile 'com.github.bumptech.glide:glide:3.7.0'
 
2.在xml视图文件中配置圆形图片信息
 
    <de.hdodenhof.circleimageview.CircleImageView
        android:id="@+id/register_user_head_pic"
        android:layout_width="150dp"
        android:layout_height="120dp"
        android:layout_marginTop="50dp"
        app:civ_border_color="@color/gray"
        app:civ_border_width="1dp"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@id/toolbar" />
 
3.配置file_path方法：
 
 
<?xml version="1.0" encoding="utf-8"?>
<paths xmlns:android="http://schemas.android.com/apk/res/android">
    <external-path
        name="external"
        path="." />
    <external-files-path
        name="external_files"
        path="." />
    <cache-path
        name="cache"
        path="." />
    <external-cache-path
        name="external_cache"
        path="." />
    <files-path
        name="files"
        path="." />
</paths>
 
AndroidManifest.xml文件
 
        <provider
            android:name="androidx.core.content.FileProvider"
            android:authorities="com.baiyang.instant_messaging_based_on_android.fileprovider"
            android:exported="false"
            android:grantUriPermissions="true">
            <meta-data
                android:name="android.support.FILE_PROVIDER_PATHS"
                android:resource="@xml/file_path" />
        </provider>
 
provider是和activity标签同级的。此外还需要声明Crop的activity资源：
 
        <activity android:name="com.soundcloud.android.crop.CropImageActivity" />
 
4.工具类，下面给将直接给出整个过程中的工具类：
 
import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.net.Uri;
import android.os.Build;
import android.os.Environment;
import android.provider.MediaStore;
import android.util.Log;
import android.widget.Toast;

import androidx.core.content.FileProvider;

import com.soundcloud.android.crop.Crop;

import java.io.File;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;

import de.hdodenhof.circleimageview.CircleImageView;

/**
 *  圆形头像工具类
 */
public class CircleImageTool {
    // 圆形视图
    private CircleImageView view;
    // 调用主体
    private Activity activity;

    private String fileprovider;

    /**
     * 构造函数
     * @param activity -- 进行头像蛇者的activity
     * @param view -- 圆形视图对象
     * @param fileprovider -- AndroidManifest.xml文件中provider资源的所有者：android:authorities
     */
    public CircleImageTool(Activity activity,CircleImageView view,String fileprovider){
        this.activity = activity;
        this.view = view;
        this.fileprovider = fileprovider;
    }

    /* 请求识别码 */
    private static final int CODE_GALLERY_REQUEST = 0xa0; // 本地照片
    private static final int CODE_CAMERA_REQUEST = 0xa1; // 拍照
    // 图片资源标识符
    private Uri uri;

    /**
     * 从本地相册选取图片作为头像
     * 将为用户打开本地图库
     *
     * 当用户点击从本地获取时直接调用该方法
     */
    public void choseHeadImageFromGallery() {
        Intent intentFromGallery = new Intent();
        // 设置文件类型
        intentFromGallery.setType("image/*");
        intentFromGallery.setAction(Intent.ACTION_GET_CONTENT);
        activity.startActivityForResult(intentFromGallery, CODE_GALLERY_REQUEST);
    }
    /**
     * 启动手机相机拍摄照片作为头像
     * 将调用本地相机
     * 注意：该过程中首先判断了系统是否有存储卡，如果有的情况下将为Intent设置一个Uri对象，该对象可以理解为资源标识符。
     * Uri资源标识符将标识一个资源的存在，可以通过它获取一个资源信息。
     * 当为Intent设置 MediaStore.EXTRA_OUTPUT 输出位置时onActivityResult方法的intent.getData()方法将获取的时一个null
     * 否则获取是Bitmap对象
     *
     * 当用户点击拍照时直接调用该方法
     */
    public void choseHeadImageFromCameraCapture() {
        Intent intentFromCapture = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
        // 判断存储卡是否可用，存储照片文件
        if (hasSdcard()) {
            uri = getUriForFile(activity,"head");
            intentFromCapture.putExtra(MediaStore.EXTRA_OUTPUT,uri);
        }
        activity.startActivityForResult(intentFromCapture, CODE_CAMERA_REQUEST);
    }

    /**
     * 接受到返回结果时调用
     * @param requestCode
     * @param resultCode
     * @param intent
     */
    public void deal(int requestCode, int resultCode,
                     Intent intent){
        switch (requestCode) {
            case CODE_GALLERY_REQUEST: // 从本地获取
                if (PicTool.hasSdcard()) {
                    Uri resultUri = getUriForFile(activity,"headPic");
                    // 从本地获取  intent.getData()方法返回选中图片资源
                    Crop.of(intent.getData(), resultUri).asSquare().start(activity);
                } else {
                    Toast.makeText(activity, "没有SDCard!", Toast.LENGTH_LONG)
                            .show();
                }
                break;
            case CODE_CAMERA_REQUEST: // 拍照成功后调用
                if (hasSdcard()) {
                    Uri resultUri =  getUriForFile(activity,"headPic");
                    Crop.of(uri, resultUri).asSquare().start(activity);
                } else {
                    Toast.makeText(activity, "没有SDCard!", Toast.LENGTH_LONG)
                            .show();
                }
                break;
            case Crop.REQUEST_CROP://使用Crop裁剪之后调用
            {
                if(resultCode == Crop.RESULT_ERROR) {
                    Toast.makeText(activity,"裁剪失败",Toast.LENGTH_SHORT).show();
                }else{
                    //裁剪成功后调用  如果setImageURL设置的url是同一个值的话  则无法改变前端显示
                    Uri result = Crop.getOutput(intent);
                    view.setImageURI(null);
                    view.setImageURI(result);
                }
                break;
            }
        }
    }


    /**
     * 检查设备是否存在SDCard的工具方法
     */
    private boolean hasSdcard() {
        String state = Environment.getExternalStorageState();
        if (state.equals(Environment.MEDIA_MOUNTED)) {
            // 有存储的SDCard
            return true;
        } else {
            return false;
        }
    }

    private static final SimpleDateFormat sdf_ymd = new SimpleDateFormat("yyyy-MM-dd", Locale.CANADA);

    private Uri getUriForFile(Context context,String path){
        // 文件管理下：/Android/Data/包名/file/日期/
        String basePath = activity.getExternalFilesDir("").getAbsolutePath()+ File.separator  + sdf_ymd.format(new Date());
        // 生成文件
        makeRootDirectory(basePath);
        // 生成文件
        File file = new File(basePath , path + ".jpg");
        return getUriForFile(context,file);
    };

    // 生成文件夹
    private boolean makeRootDirectory(String filePath) {
        File file = null;
        try {
            file = new File(filePath);
            if (file.exists()) {
                file.delete();
            }
            file.mkdirs();
            return true;
        } catch (Exception e) {
            Log.i("error:", e+"");
            return false;
        }
    }
    /**
     * 生成URL
     * @param context
     * @param file
     * @return
     */
    private Uri getUriForFile(Context context, File file) {
        if (context == null || file == null) {
            throw new NullPointerException();
        }
        Uri uri;
        if (Build.VERSION.SDK_INT >= 24) {
            uri = FileProvider.getUriForFile(context.getApplicationContext(), fileprovider, file);
        } else {
            uri = Uri.fromFile(file);
        }
        return uri;
    }

}

使用PictureSelector、CircleImageView等库结合极光IM服务，实现头像的设置和获取（仅图库选取照片）
 
PictureSelector的引入和使用可参考  https://github.com/frank5552012/PictureSelector
 
极光文档头像：
 
 
1.用到的依赖
 
implementation ('com.github.LuckSiege.PictureSelector:picture_library:v2.5.9')//图库选择
implementation ('de.hdodenhof:circleimageview:2.1.0')//放圆形头像的控件
implementation 'com.android.support:support-v4:29.4.1'//解决了报错问题，Failed resolution of: Landroidx/localbroadcastmanager/content/LocalBroadcastManager
implementation 'com.github.bumptech.glide:glide:4.11.0'
 
2.放头像的控件 CircleImageView，圆形遮罩，将图片显示成圆形。
 
<de.hdodenhof.circleimageview.CircleImageView
                android:id="@+id/imageView_profile"
                android:layout_width="80dp"
                android:layout_height="80dp"
                android:src="@drawable/icon_boy" />
 
3.对图片设置点击事件
 
private Integer Pic_OK=1;


circleImageView.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                //选图片
                PictureSelector.create(MineFragment.this)
                        .openGallery(PictureMimeType.ofImage())
                        .loadImageEngine(GlideEngine.createGlideEngine())// 外部传入图片加载引擎，必传项
                        .maxSelectNum(1)
                        .minSelectNum(1)
                        .selectionMode(PictureConfig.SINGLE)
                        .previewImage(true)
                        .compress(true)
                        .minimumCompressSize(100)// 小于100kb的图片不压缩
                        .forResult(Pic_OK);//结果回调onActivityResult code
            }
        });
 
3.这里用到了GlideEngine.java 图片加载引擎，省略的话图片会显示不出来，所以新建一个，代码如下：
 
public class GlideEngine implements ImageEngine {

    /**
     * 加载图片
     *
     * @param context
     * @param url
     * @param imageView
     */
    @Override
    public void loadImage(@NonNull Context context, @NonNull String url, @NonNull ImageView imageView) {
        Glide.with(context)
                .load(url)
                .into(imageView);
    }

    /**
     * 加载网络图片适配长图方案
     * # 注意：此方法只有加载网络图片才会回调
     *
     * @param context
     * @param url
     * @param imageView
     * @param longImageView
     * @param callback      网络图片加载回调监听 {link after version 2.5.1 Please use the #OnImageCompleteCallback#}
     */
    @Override
    public void loadImage(@NonNull Context context, @NonNull String url,
                          @NonNull ImageView imageView,
                          SubsamplingScaleImageView longImageView, OnImageCompleteCallback callback) {
        Glide.with(context)
                .asBitmap()
                .load(url)
                .into(new ImageViewTarget<Bitmap>(imageView) {
                    @Override
                    public void onLoadStarted(@Nullable Drawable placeholder) {
                        super.onLoadStarted(placeholder);
                        if (callback != null) {
                            callback.onShowLoading();
                        }
                    }

                    @Override
                    public void onLoadFailed(@Nullable Drawable errorDrawable) {
                        super.onLoadFailed(errorDrawable);
                        if (callback != null) {
                            callback.onHideLoading();
                        }
                    }

                    @Override
                    protected void setResource(@Nullable Bitmap resource) {
                        if (callback != null) {
                            callback.onHideLoading();
                        }
                        if (resource != null) {
                            boolean eqLongImage = MediaUtils.isLongImg(resource.getWidth(),
                                    resource.getHeight());
                            longImageView.setVisibility(eqLongImage ? View.VISIBLE : View.GONE);
                            imageView.setVisibility(eqLongImage ? View.GONE : View.VISIBLE);
                            if (eqLongImage) {
                                // 加载长图
                                longImageView.setQuickScaleEnabled(true);
                                longImageView.setZoomEnabled(true);
                                longImageView.setPanEnabled(true);
                                longImageView.setDoubleTapZoomDuration(100);
                                longImageView.setMinimumScaleType(SubsamplingScaleImageView.SCALE_TYPE_CENTER_CROP);
                                longImageView.setDoubleTapZoomDpi(SubsamplingScaleImageView.ZOOM_FOCUS_CENTER);
                                longImageView.setImage(ImageSource.bitmap(resource),
                                        new ImageViewState(0, new PointF(0, 0), 0));
                            } else {
                                // 普通图片
                                imageView.setImageBitmap(resource);
                            }
                        }
                    }
                });
    }

    /**
     * 加载网络图片适配长图方案
     * # 注意：此方法只有加载网络图片才会回调
     *
     * @param context
     * @param url
     * @param imageView
     * @param longImageView
     * @ 已废弃
     */
    @Override
    public void loadImage(@NonNull Context context, @NonNull String url,
                          @NonNull ImageView imageView,
                          SubsamplingScaleImageView longImageView) {
        Glide.with(context)
                .asBitmap()
                .load(url)
                .into(new ImageViewTarget<Bitmap>(imageView) {
                    @Override
                    protected void setResource(@Nullable Bitmap resource) {
                        if (resource != null) {
                            boolean eqLongImage = MediaUtils.isLongImg(resource.getWidth(),
                                    resource.getHeight());
                            longImageView.setVisibility(eqLongImage ? View.VISIBLE : View.GONE);
                            imageView.setVisibility(eqLongImage ? View.GONE : View.VISIBLE);
                            if (eqLongImage) {
                                // 加载长图
                                longImageView.setQuickScaleEnabled(true);
                                longImageView.setZoomEnabled(true);
                                longImageView.setPanEnabled(true);
                                longImageView.setDoubleTapZoomDuration(100);
                                longImageView.setMinimumScaleType(SubsamplingScaleImageView.SCALE_TYPE_CENTER_CROP);
                                longImageView.setDoubleTapZoomDpi(SubsamplingScaleImageView.ZOOM_FOCUS_CENTER);
                                longImageView.setImage(ImageSource.bitmap(resource),
                                        new ImageViewState(0, new PointF(0, 0), 0));
                            } else {
                                // 普通图片
                                imageView.setImageBitmap(resource);
                            }
                        }
                    }
                });
    }

    /**
     * 加载相册目录
     *
     * @param context   上下文
     * @param url       图片路径
     * @param imageView 承载图片ImageView
     */
    @Override
    public void loadFolderImage(@NonNull Context context, @NonNull String url, @NonNull ImageView imageView) {
        Glide.with(context)
                .asBitmap()
                .load(url)
                .override(180, 180)
                .centerCrop()
                .sizeMultiplier(0.5f)
                .apply(new RequestOptions().placeholder(R.drawable.picture_image_placeholder))
                .into(new BitmapImageViewTarget(imageView) {
                    @Override
                    protected void setResource(Bitmap resource) {
                        RoundedBitmapDrawable circularBitmapDrawable =
                                RoundedBitmapDrawableFactory.
                                        create(context.getResources(), resource);
                        circularBitmapDrawable.setCornerRadius(8);
                        imageView.setImageDrawable(circularBitmapDrawable);
                    }
                });
    }


    /**
     * 加载gif
     *
     * @param context   上下文
     * @param url       图片路径
     * @param imageView 承载图片ImageView
     */
    @Override
    public void loadAsGifImage(@NonNull Context context, @NonNull String url,
                               @NonNull ImageView imageView) {
        Glide.with(context)
                .asGif()
                .load(url)
                .into(imageView);
    }

    /**
     * 加载图片列表图片
     *
     * @param context   上下文
     * @param url       图片路径
     * @param imageView 承载图片ImageView
     */
    @Override
    public void loadGridImage(@NonNull Context context, @NonNull String url, @NonNull ImageView imageView) {
        Glide.with(context)
                .load(url)
                .override(200, 200)
                .centerCrop()
                .apply(new RequestOptions().placeholder(R.drawable.picture_image_placeholder))
                .into(imageView);
    }


    private GlideEngine() {
    }

    private static GlideEngine instance;

    public static GlideEngine createGlideEngine() {
        if (null == instance) {
            synchronized (GlideEngine.class) {
                if (null == instance) {
                    instance = new GlideEngine();
                }
            }
        }
        return instance;
    }
}
 
4.回调结果，当请求码为Pic_OK时会执行逻辑代码，将图片的具体地址上传到极光服务器，同时进行头像获取和UI更新
 
private List<LocalMedia> selectList = new ArrayList<>();

@Override
    public void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {//回调结果
        super.onActivityResult(requestCode, resultCode, data);
        //当请求码是图库时
        if(requestCode==Pic_OK){
            selectList = PictureSelector.obtainMultipleResult(data);
            if (selectList != null && selectList.size() == 1 && selectList.get(0) != null){
                Log.i(TAG, "onActivityResult: "+selectList.get(0).getCompressPath());
                JMessageClient.updateUserAvatar(new File(selectList.get(0).getCompressPath()), new BasicCallback() {
                    @Override
                    public void gotResult(int i, String s) {
                        if (i==0){
                            ToastUtil.showToast(getActivity(),"更新头像成功！");
                            Log.i(TAG, "头像gotResult: "+i);
                            UserInfo myInfo = JMessageClient.getMyInfo();
                            Log.i(TAG, "个人信息gotResult: "+myInfo.toString());
                            myInfo.getAvatarBitmap(new GetAvatarBitmapCallback() {
                                @Override
                                public void gotResult(int i, String s, Bitmap bitmap) {
                                    if (i==0){
                                        circleImageView.setImageBitmap(bitmap);
                                        Log.i(TAG, "头像gotResult: UI更新成功");
                                    }
                                }
                            });
                            //包括裁剪和压缩后的缓存，要在上传成功后调用，type 指的是图片or视频缓存取决于你设置的ofImage或ofVideo 注意：需要系统sd卡权限
                            PictureFileUtils.deleteCacheDirFile(getContext(),PictureMimeType.ofImage());
                            // 清除所有缓存 例如：压缩、裁剪、视频、音频所生成的临时文件
                            PictureFileUtils.deleteAllCacheDirFile(getContext());
                        }else {
                            ToastUtil.showToast(getActivity(),"更新头像失败！");
                            Log.i(TAG, "头像gotResult: "+i);
                        }
                    }
                });
            }
            ToastUtil.showToast(getActivity(),"选择图片成功！");
        }
    }
 
5.在oncreate中初始化头像，就可以跳转此页面显示头像
 
//初始化显示用户头像
    private void initAvatar() {
        UserInfo myInfo = JMessageClient.getMyInfo();
        Log.i(TAG, "个人信息gotResult: "+myInfo.toString());
        myInfo.getAvatarBitmap(new GetAvatarBitmapCallback() {
            @Override
            public void gotResult(int i, String s, Bitmap bitmap) {
                if (i==0){
                    circleImageView.setImageBitmap(bitmap);
                    Log.i(TAG, "头像gotResult: UI更新成功");
                }
            }
        });
    }
 
 

 
先上代码：
 
package com.xiaogang.imageheader;
 
import java.io.File;
 
import android.net.Uri;
 
import android.os.Bundle;
 
import android.os.Environment;
 
import android.provider.MediaStore;
 
import android.app.Activity;
 
import android.content.Intent;
 
import android.graphics.Bitmap;
 
import android.graphics.drawable.BitmapDrawable;
 
import android.graphics.drawable.Drawable;
 
import android.view.View;
 
import android.view.View.OnClickListener;
 
import android.widget.Button;
 
import android.widget.ImageView;
 
import android.widget.Toast;
 
public class MainActivity extends Activity implements OnClickListener {
 
private static final int IMAGE_REQUEST_CODE = 0;
 
private static final int CAMERA_REQUEST_CODE = 1;
 
private static final int RESIZE_REQUEST_CODE = 2;
 
private static final String IMAGE_FILE_NAME = "header.jpg";
 
private ImageView mImageHeader;
 
@Override
 
protected void onCreate(Bundle savedInstanceState) {
 
super.onCreate(savedInstanceState);
 
setContentView(R.layout.activity_main);
 
setupViews();
 
}
 
private void setupViews() {
 
mImageHeader = (ImageView) findViewById(R.id.image_header);
 
final Button selectBtn1 = (Button) findViewById(R.id.btn_selectimage);
 
final Button selectBtn2 = (Button) findViewById(R.id.btn_takephoto);
 
selectBtn1.setOnClickListener(this);
 
selectBtn2.setOnClickListener(this);
 
}
 
@Override
 
public void onClick(View v) {
 
switch (v.getId()) {
 
case R.id.btn_selectimage:
 
Intent galleryIntent = new Intent(Intent.ACTION_GET_CONTENT);
 
galleryIntent.addCategory(Intent.CATEGORY_OPENABLE);
 
galleryIntent.setType("image/*");
 
startActivityForResult(galleryIntent, IMAGE_REQUEST_CODE);
 
break;
 
case R.id.btn_takephoto:
 
if (isSdcardExisting()) {
 
Intent cameraIntent = new Intent(
 
"android.media.action.IMAGE_CAPTURE");
 
cameraIntent.putExtra(MediaStore.EXTRA_OUTPUT, getImageUri());
 
cameraIntent.putExtra(MediaStore.EXTRA_VIDEO_QUALITY, 0);
 
startActivityForResult(cameraIntent, CAMERA_REQUEST_CODE);
 
} else {
 
Toast.makeText(v.getContext(), "请插入sd卡", Toast.LENGTH_LONG)
 
.show();
 
}
 
break;
 
}
 
}
 
@Override
 
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
 
if (resultCode != RESULT_OK) {
 
return;
 
} else {
 
switch (requestCode) {
 
case IMAGE_REQUEST_CODE:
 
resizeImage(data.getData());
 
break;
 
case CAMERA_REQUEST_CODE:
 
if (isSdcardExisting()) {
 
resizeImage(getImageUri());
 
} else {
 
Toast.makeText(MainActivity.this, "未找到存储卡，无法存储照片！",
 
Toast.LENGTH_LONG).show();
 
}
 
break;
 
case RESIZE_REQUEST_CODE:
 
if (data != null) {
 
showResizeImage(data);
 
}
 
break;
 
}
 
}
 
super.onActivityResult(requestCode, resultCode, data);
 
}
 
private boolean isSdcardExisting() {
 
final String state = Environment.getExternalStorageState();
 
if (state.equals(Environment.MEDIA_MOUNTED)) {
 
return true;
 
} else {
 
return false;
 
}
 
}
 
public void resizeImage(Uri uri) {
 
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", 150);
 
intent.putExtra("outputY", 150);
 
intent.putExtra("return-data", true);
 
startActivityForResult(intent, RESIZE_REQUEST_CODE);
 
}
 
private void showResizeImage(Intent data) {
 
Bundle extras = data.getExtras();
 
if (extras != null) {
 
Bitmap photo = extras.getParcelable("data");
 
Drawable drawable = new BitmapDrawable(photo);
 
mImageHeader.setImageDrawable(drawable);
 
}
 
}
 
private Uri getImageUri() {
 
return Uri.fromFile(new File(Environment.getExternalStorageDirectory(),
 
IMAGE_FILE_NAME));
 
}
 
}