图库模块：图片预览，网格模式全屏预览

韩亚云
1 parent cb7ee015
Showing 45 changed files with 4247 additions and 66 deletions
app/strike/src/main/AndroidManifest.xml
app/strike/src/main/java/com/cnlive/strike/imgutil/ImgActivity.java
app/strike/src/main/java/com/cnlive/strike/imgutil/SimplePrevActivity.java
app/strike/src/main/res/layout/activity_img.xml
app/strike/src/main/res/layout/activity_simple_prev.xml
core/database/src/main/java/com/cnlive/database/dao/DaoMaster.java
core/database/src/main/java/com/cnlive/database/dao/DaoSession.java
core/imageload/src/main/java/com/cnlive/core/gridview/AutoGridMode.java
core/imageload/src/main/java/com/cnlive/core/gridview/AutoGridView.java
core/imageload/src/main/java/com/cnlive/core/gridview/GridImgUtil.java
core/imageload/src/main/java/com/cnlive/core/gridview/adapter/BaseAutoGridAdapter.java
core/imageload/src/main/java/com/cnlive/core/gridview/adapter/BaseAutoGridHolder.java
core/imageload/src/main/java/com/cnlive/core/gridview/adapter/QuickAutoGridAdapter.java
core/imageload/src/main/java/com/cnlive/core/gridview/adapter/SimpleAutoGridAdapter.java
core/imageload/src/main/java/com/cnlive/core/gridview/model/SizeHelper.java
core/imageload/src/main/java/com/cnlive/core/gridview/model/SizeInfo.java
core/imageload/src/main/java/com/cnlive/core/gridview/model/SizeParam.java
core/imageload/src/main/java/com/cnlive/core/imagepreview/ImageDrawee.java
core/imageload/src/main/java/com/cnlive/core/imagepreview/ImagePreView.java
core/imageload/src/main/java/com/cnlive/core/imagepreview/ImageTransfer.java
@@ -17,7 +17,8 @@
         android:roundIcon="@mipmap/ic_launcher_round"
         android:supportsRtl="true"
         android:theme="@style/AppTheme">
-        <activity android:name="com.cnlive.strike.demo.activity.HappyChinaActivity"></activity>
+        <activity android:name="com.cnlive.strike.imgutil.SimplePrevActivity"></activity>
+        <activity android:name="com.cnlive.strike.demo.activity.HappyChinaActivity" />
         <provider
             android:name="androidx.core.content.FileProvider"
@@ -3,6 +3,7 @@ package com.cnlive.strike.imgutil;
 import androidx.appcompat.app.AppCompatActivity;
 import android.animation.ObjectAnimator;
+import android.content.Intent;
 import android.graphics.Bitmap;
 import android.os.Bundle;
 import android.os.Handler;
@@ -85,6 +86,8 @@ public class ImgActivity extends AppCompatActivity {
         iv_test9 =  findViewById(R.id.iv_test9);
         iv_test10 =  findViewById(R.id.iv_test10);
         iv_test11 =  findViewById(R.id.iv_test11);
+
+        findViewById(R.id.simpla_see).setOnClickListener(view -> startActivity(new Intent(this,SimplePrevActivity.class)));
     }
@@ -100,6 +103,7 @@ public class ImgActivity extends AppCompatActivity {
             }
         };
+
         ImageLoader.with(this)
                 .url(URL1)
                 .animate(animation)
@@ -125,7 +129,7 @@ public class ImgActivity extends AppCompatActivity {
         data.setShowImg(URL1);
         iv_test1.setOnClickListener(view -> PreviewImageViewActivity.startPreviewPictrue(this, view, data));
-//        ImageLoader.with(this)
+//        LoadImage.with(this)
 //                .url(URL1)
 //                .scale(ScaleMode.FIT_CENTER)
 //                .into(iv_test2);
@@ -168,7 +172,7 @@ public class ImgActivity extends AppCompatActivity {
                 .into(iv_test7);
             //加载本地图片
-//        ImageLoader.with(this)
+//        LoadImage.with(this)
 //                .file(new File(getFilesDir(), IMG_NAME_C))
 //                .placeHolder(R.mipmap.ic_launcher)
 //                .scale(ScaleMode.FIT_CENTER)
+package com.cnlive.strike.imgutil;
+
+
+import android.graphics.drawable.Drawable;
+import android.view.KeyEvent;
+import android.view.View;
+import android.widget.ImageView;
+
+import com.bumptech.glide.request.target.SimpleTarget;
+import com.bumptech.glide.request.transition.Transition;
+import com.cnlive.cloud.R;
+import com.cnlive.core.gridview.AutoGridView;
+import com.cnlive.core.gridview.GridImgUtil;
+import com.cnlive.core.gridview.adapter.BaseAutoGridHolder;
+import com.cnlive.core.gridview.adapter.SimpleAutoGridAdapter;
+import com.cnlive.core.imagepreview.ImagePreView;
+import com.cnlive.core.imagepreview.PhotoLoader;
+import com.cnlive.core.imagepreview.ViewerStatus;
+import com.cnlive.core.imagepreview.listener.OnBrowseStatusListener;
+import com.cnlive.core.libs.base.frame.activity.BaseActivity;
+import com.cnlive.core.libs.base.util.GlideUtil;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+public class SimplePrevActivity extends BaseActivity {
+
+    private ImagePreView preView;
+    private AutoGridView autoGridView;
+    List<String> list = new ArrayList<>();
+    private SimpleAutoGridAdapter adapter;
+
+
+    @Override
+    protected int getViewLayoutId() {
+        return R.layout.activity_simple_prev;
+    }
+
+
+    @Override
+    protected void initView() {
+        preView = findViewById(R.id.image_pre);
+        autoGridView = findViewById(R.id.grid_view);
+        list.add("https://b-ssl.duitang.com/uploads/item/201505/09/20150509221719_kyNrM.jpeg");
+        list.add("https://b-ssl.duitang.com/uploads/item/201709/26/20170926131419_8YhLA.jpeg");
+        list.add("https://b-ssl.duitang.com/uploads/item/201505/11/20150511122951_MAwVZ.jpeg");
+        list.add("https://b-ssl.duitang.com/uploads/item/201704/23/20170423205828_BhNSv.jpeg");
+        list.add("https://b-ssl.duitang.com/uploads/item/201706/30/20170630181644_j4mh5.jpeg");
+
+        preView.overlayStatusBar(false)
+                .imageData(list)
+                .imageLoader(new PhotoLoader());
+
+        adapter = new SimpleAutoGridAdapter<String, BaseAutoGridHolder>(list);
+        adapter.setImageLoader(new SimpleAutoGridAdapter.ImageLoader() {
+            @Override
+            public void onLoadImage(int position, Object item, ImageView imageView) {
+
+                GridImgUtil.loadImage(SimplePrevActivity.this, item, new SimpleTarget<Drawable>() {
+                    @Override
+                    public void onResourceReady(@NonNull Drawable resource, @Nullable Transition<? super Drawable> transition) {
+                        preView.getViewData().get(position).setImageWidth(resource.getIntrinsicWidth());
+                        preView.getViewData().get(position).setImageHeight(resource.getIntrinsicHeight());
+                        imageView.setImageDrawable(resource);
+                    }
+
+                    @Override
+                    public void onLoadFailed(@Nullable Drawable errorDrawable) {
+                        super.onLoadFailed(errorDrawable);
+                        imageView.setImageDrawable(errorDrawable);
+                    }
+                });
+            }
+        });
+        autoGridView.setOnItemClickListener(new AutoGridView.OnItemClickListener() {
+            @Override
+            public void onItemClick(int position, View view) {
+                preView.bindViewGroup(autoGridView);
+                preView.watch(position);
+            }
+        });
+
+        autoGridView.setAdapter(adapter);
+        preView.setOnBrowseStatusListener(new OnBrowseStatusListener() {
+            @Override
+            public void onBrowseStatus(int status) {
+                //可以根据状态去设置状态栏颜色
+                if(status == ViewerStatus.STATUS_BEGIN_OPEN){
+
+                }else if(status == ViewerStatus.STATUS_SILENCE){
+
+                }
+            }
+        });
+    }
+
+    @Override
+    public boolean onKeyDown(int keyCode, KeyEvent event) {
+        boolean b = preView.onKeyDown(keyCode, event);
+        if (b) {
+            return b;
+        }
+        return super.onKeyDown(keyCode, event);
+    }
+}
@@ -3,11 +3,19 @@
     android:layout_width="match_parent"
     android:layout_height="match_parent">
+
+
     <LinearLayout
         android:layout_width="match_parent"
         android:layout_height="match_parent"
         android:orientation="vertical">
+        <Button
+            android:id="@+id/simpla_see"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="简单预览" />
+
         <TextView
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
+<?xml version="1.0" encoding="utf-8"?>
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    tools:context="com.cnlive.strike.imgutil.SimplePrevActivity">
+
+    <com.cnlive.core.gridview.AutoGridView
+        android:id="@+id/grid_view"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"/>
+
+    <com.cnlive.core.imagepreview.ImagePreView
+        android:id="@+id/image_pre"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"/>
+</RelativeLayout>
@@ -29,9 +29,11 @@ public class DaoMaster extends AbstractDaoMaster {
         ContactListDao.createTable(db, ifNotExists);
         ContanctDaRenEntityDao.createTable(db, ifNotExists);
         ContanctGroupChatEntityDao.createTable(db, ifNotExists);
-        DBFriendCircleMessageDao.createTable(db, ifNotExists);
         DarenDetailMsgDao.createTable(db, ifNotExists);
         DarenListMsgDao.createTable(db, ifNotExists);
+        DBFriendCircleMessageDao.createTable(db, ifNotExists);
+        DBMomentDetailDao.createTable(db, ifNotExists);
+        DBMomentItemDao.createTable(db, ifNotExists);
         DownloadInfoDao.createTable(db, ifNotExists);
         ExceptionInfoDao.createTable(db, ifNotExists);
         HolidayThemeInfoDao.createTable(db, ifNotExists);
@@ -49,9 +51,6 @@ public class DaoMaster extends AbstractDaoMaster {
         SearchHistoryDao.createTable(db, ifNotExists);
         SysNumReadableDao.createTable(db, ifNotExists);
         WitnessDao.createTable(db, ifNotExists);
-        DBMomentDetailDao.createTable(db, ifNotExists);
-        DBMomentItemDao.createTable(db, ifNotExists);
-        TestInfoDao.createTable(db, ifNotExists);
     }
     /** Drops underlying database table using DAOs. */
@@ -64,9 +63,11 @@ public class DaoMaster extends AbstractDaoMaster {
         ContactListDao.dropTable(db, ifExists);
         ContanctDaRenEntityDao.dropTable(db, ifExists);
         ContanctGroupChatEntityDao.dropTable(db, ifExists);
-        DBFriendCircleMessageDao.dropTable(db, ifExists);
         DarenDetailMsgDao.dropTable(db, ifExists);
         DarenListMsgDao.dropTable(db, ifExists);
+        DBFriendCircleMessageDao.dropTable(db, ifExists);
+        DBMomentDetailDao.dropTable(db, ifExists);
+        DBMomentItemDao.dropTable(db, ifExists);
         DownloadInfoDao.dropTable(db, ifExists);
         ExceptionInfoDao.dropTable(db, ifExists);
         HolidayThemeInfoDao.dropTable(db, ifExists);
@@ -84,9 +85,6 @@ public class DaoMaster extends AbstractDaoMaster {
         SearchHistoryDao.dropTable(db, ifExists);
         SysNumReadableDao.dropTable(db, ifExists);
         WitnessDao.dropTable(db, ifExists);
-        DBMomentDetailDao.dropTable(db, ifExists);
-        DBMomentItemDao.dropTable(db, ifExists);
-        TestInfoDao.dropTable(db, ifExists);
     }
     /**
@@ -113,9 +111,11 @@ public class DaoMaster extends AbstractDaoMaster {
         registerDaoClass(ContactListDao.class);
         registerDaoClass(ContanctDaRenEntityDao.class);
         registerDaoClass(ContanctGroupChatEntityDao.class);
-        registerDaoClass(DBFriendCircleMessageDao.class);
         registerDaoClass(DarenDetailMsgDao.class);
         registerDaoClass(DarenListMsgDao.class);
+        registerDaoClass(DBFriendCircleMessageDao.class);
+        registerDaoClass(DBMomentDetailDao.class);
+        registerDaoClass(DBMomentItemDao.class);
         registerDaoClass(DownloadInfoDao.class);
         registerDaoClass(ExceptionInfoDao.class);
         registerDaoClass(HolidayThemeInfoDao.class);
@@ -133,9 +133,6 @@ public class DaoMaster extends AbstractDaoMaster {
         registerDaoClass(SearchHistoryDao.class);
         registerDaoClass(SysNumReadableDao.class);
         registerDaoClass(WitnessDao.class);
-        registerDaoClass(DBMomentDetailDao.class);
-        registerDaoClass(DBMomentItemDao.class);
-        registerDaoClass(TestInfoDao.class);
     }
     public DaoSession newSession() {
@@ -16,9 +16,11 @@ import com.cnlive.database.bean.ChatMedia;
 import com.cnlive.database.bean.ContactList;
 import com.cnlive.database.bean.ContanctDaRenEntity;
 import com.cnlive.database.bean.ContanctGroupChatEntity;
-import com.cnlive.database.bean.DBFriendCircleMessage;
 import com.cnlive.database.bean.DarenDetailMsg;
 import com.cnlive.database.bean.DarenListMsg;
+import com.cnlive.database.bean.DBFriendCircleMessage;
+import com.cnlive.database.bean.DBMomentDetail;
+import com.cnlive.database.bean.DBMomentItem;
 import com.cnlive.database.bean.DownloadInfo;
 import com.cnlive.database.bean.ExceptionInfo;
 import com.cnlive.database.bean.HolidayThemeInfo;
@@ -36,8 +38,37 @@ import com.cnlive.database.bean.SearchContent;
 import com.cnlive.database.bean.SearchHistory;
 import com.cnlive.database.bean.SysNumReadable;
 import com.cnlive.database.bean.Witness;
-import com.cnlive.database.bean.DBMomentDetail;
-import com.cnlive.database.bean.DBMomentItem;
+
+import com.cnlive.database.dao.AudioPlayHistoricalRecordDao;
+import com.cnlive.database.dao.AudioPlayLastInfoDao;
+import com.cnlive.database.dao.ChatFileMsgDao;
+import com.cnlive.database.dao.ChatImageAndVideoMsgDao;
+import com.cnlive.database.dao.ChatMediaDao;
+import com.cnlive.database.dao.ContactListDao;
+import com.cnlive.database.dao.ContanctDaRenEntityDao;
+import com.cnlive.database.dao.ContanctGroupChatEntityDao;
+import com.cnlive.database.dao.DarenDetailMsgDao;
+import com.cnlive.database.dao.DarenListMsgDao;
+import com.cnlive.database.dao.DBFriendCircleMessageDao;
+import com.cnlive.database.dao.DBMomentDetailDao;
+import com.cnlive.database.dao.DBMomentItemDao;
+import com.cnlive.database.dao.DownloadInfoDao;
+import com.cnlive.database.dao.ExceptionInfoDao;
+import com.cnlive.database.dao.HolidayThemeInfoDao;
+import com.cnlive.database.dao.IMConversationInfoDao;
+import com.cnlive.database.dao.IMGroupFaceMemberIdsDao;
+import com.cnlive.database.dao.IMGroupMembersDao;
+import com.cnlive.database.dao.IMGroupMembersListDao;
+import com.cnlive.database.dao.IMGroupMembersManagerListDao;
+import com.cnlive.database.dao.IMUserInfoDao;
+import com.cnlive.database.dao.LaunchAdInfoDao;
+import com.cnlive.database.dao.NewContactFriendEntityDao;
+import com.cnlive.database.dao.NewPhoneContactEntityDao;
+import com.cnlive.database.dao.NewsNumberDao;
+import com.cnlive.database.dao.SearchContentDao;
+import com.cnlive.database.dao.SearchHistoryDao;
+import com.cnlive.database.dao.SysNumReadableDao;
+import com.cnlive.database.dao.WitnessDao;
 // THIS CODE IS GENERATED BY greenDAO, DO NOT EDIT.
@@ -56,9 +87,11 @@ public class DaoSession extends AbstractDaoSession {
     private final DaoConfig contactListDaoConfig;
     private final DaoConfig contanctDaRenEntityDaoConfig;
     private final DaoConfig contanctGroupChatEntityDaoConfig;
-    private final DaoConfig dBFriendCircleMessageDaoConfig;
     private final DaoConfig darenDetailMsgDaoConfig;
     private final DaoConfig darenListMsgDaoConfig;
+    private final DaoConfig dBFriendCircleMessageDaoConfig;
+    private final DaoConfig dBMomentDetailDaoConfig;
+    private final DaoConfig dBMomentItemDaoConfig;
     private final DaoConfig downloadInfoDaoConfig;
     private final DaoConfig exceptionInfoDaoConfig;
     private final DaoConfig holidayThemeInfoDaoConfig;
@@ -76,9 +109,6 @@ public class DaoSession extends AbstractDaoSession {
     private final DaoConfig searchHistoryDaoConfig;
     private final DaoConfig sysNumReadableDaoConfig;
     private final DaoConfig witnessDaoConfig;
-    private final DaoConfig dBMomentDetailDaoConfig;
-    private final DaoConfig dBMomentItemDaoConfig;
-    private final DaoConfig testInfoDaoConfig;
     private final AudioPlayHistoricalRecordDao audioPlayHistoricalRecordDao;
     private final AudioPlayLastInfoDao audioPlayLastInfoDao;
@@ -88,9 +118,11 @@ public class DaoSession extends AbstractDaoSession {
     private final ContactListDao contactListDao;
     private final ContanctDaRenEntityDao contanctDaRenEntityDao;
     private final ContanctGroupChatEntityDao contanctGroupChatEntityDao;
-    private final DBFriendCircleMessageDao dBFriendCircleMessageDao;
     private final DarenDetailMsgDao darenDetailMsgDao;
     private final DarenListMsgDao darenListMsgDao;
+    private final DBFriendCircleMessageDao dBFriendCircleMessageDao;
+    private final DBMomentDetailDao dBMomentDetailDao;
+    private final DBMomentItemDao dBMomentItemDao;
     private final DownloadInfoDao downloadInfoDao;
     private final ExceptionInfoDao exceptionInfoDao;
     private final HolidayThemeInfoDao holidayThemeInfoDao;
@@ -108,9 +140,6 @@ public class DaoSession extends AbstractDaoSession {
     private final SearchHistoryDao searchHistoryDao;
     private final SysNumReadableDao sysNumReadableDao;
     private final WitnessDao witnessDao;
-    private final DBMomentDetailDao dBMomentDetailDao;
-    private final DBMomentItemDao dBMomentItemDao;
-    private final TestInfoDao testInfoDao;
     public DaoSession(Database db, IdentityScopeType type, Map<Class<? extends AbstractDao<?, ?>>, DaoConfig>
             daoConfigMap) {
@@ -140,15 +169,21 @@ public class DaoSession extends AbstractDaoSession {
         contanctGroupChatEntityDaoConfig = daoConfigMap.get(ContanctGroupChatEntityDao.class).clone();
         contanctGroupChatEntityDaoConfig.initIdentityScope(type);
-        dBFriendCircleMessageDaoConfig = daoConfigMap.get(DBFriendCircleMessageDao.class).clone();
-        dBFriendCircleMessageDaoConfig.initIdentityScope(type);
-
         darenDetailMsgDaoConfig = daoConfigMap.get(DarenDetailMsgDao.class).clone();
         darenDetailMsgDaoConfig.initIdentityScope(type);
         darenListMsgDaoConfig = daoConfigMap.get(DarenListMsgDao.class).clone();
         darenListMsgDaoConfig.initIdentityScope(type);
+        dBFriendCircleMessageDaoConfig = daoConfigMap.get(DBFriendCircleMessageDao.class).clone();
+        dBFriendCircleMessageDaoConfig.initIdentityScope(type);
+
+        dBMomentDetailDaoConfig = daoConfigMap.get(DBMomentDetailDao.class).clone();
+        dBMomentDetailDaoConfig.initIdentityScope(type);
+
+        dBMomentItemDaoConfig = daoConfigMap.get(DBMomentItemDao.class).clone();
+        dBMomentItemDaoConfig.initIdentityScope(type);
+
         downloadInfoDaoConfig = daoConfigMap.get(DownloadInfoDao.class).clone();
         downloadInfoDaoConfig.initIdentityScope(type);
@@ -200,15 +235,6 @@ public class DaoSession extends AbstractDaoSession {
         witnessDaoConfig = daoConfigMap.get(WitnessDao.class).clone();
         witnessDaoConfig.initIdentityScope(type);
-        dBMomentDetailDaoConfig = daoConfigMap.get(DBMomentDetailDao.class).clone();
-        dBMomentDetailDaoConfig.initIdentityScope(type);
-
-        dBMomentItemDaoConfig = daoConfigMap.get(DBMomentItemDao.class).clone();
-        dBMomentItemDaoConfig.initIdentityScope(type);
-
-        testInfoDaoConfig = daoConfigMap.get(TestInfoDao.class).clone();
-        testInfoDaoConfig.initIdentityScope(type);
-
         audioPlayHistoricalRecordDao = new AudioPlayHistoricalRecordDao(audioPlayHistoricalRecordDaoConfig, this);
         audioPlayLastInfoDao = new AudioPlayLastInfoDao(audioPlayLastInfoDaoConfig, this);
         chatFileMsgDao = new ChatFileMsgDao(chatFileMsgDaoConfig, this);
@@ -217,9 +243,11 @@ public class DaoSession extends AbstractDaoSession {
         contactListDao = new ContactListDao(contactListDaoConfig, this);
         contanctDaRenEntityDao = new ContanctDaRenEntityDao(contanctDaRenEntityDaoConfig, this);
         contanctGroupChatEntityDao = new ContanctGroupChatEntityDao(contanctGroupChatEntityDaoConfig, this);
-        dBFriendCircleMessageDao = new DBFriendCircleMessageDao(dBFriendCircleMessageDaoConfig, this);
         darenDetailMsgDao = new DarenDetailMsgDao(darenDetailMsgDaoConfig, this);
         darenListMsgDao = new DarenListMsgDao(darenListMsgDaoConfig, this);
+        dBFriendCircleMessageDao = new DBFriendCircleMessageDao(dBFriendCircleMessageDaoConfig, this);
+        dBMomentDetailDao = new DBMomentDetailDao(dBMomentDetailDaoConfig, this);
+        dBMomentItemDao = new DBMomentItemDao(dBMomentItemDaoConfig, this);
         downloadInfoDao = new DownloadInfoDao(downloadInfoDaoConfig, this);
         exceptionInfoDao = new ExceptionInfoDao(exceptionInfoDaoConfig, this);
         holidayThemeInfoDao = new HolidayThemeInfoDao(holidayThemeInfoDaoConfig, this);
@@ -237,9 +265,6 @@ public class DaoSession extends AbstractDaoSession {
         searchHistoryDao = new SearchHistoryDao(searchHistoryDaoConfig, this);
         sysNumReadableDao = new SysNumReadableDao(sysNumReadableDaoConfig, this);
         witnessDao = new WitnessDao(witnessDaoConfig, this);
-        dBMomentDetailDao = new DBMomentDetailDao(dBMomentDetailDaoConfig, this);
-        dBMomentItemDao = new DBMomentItemDao(dBMomentItemDaoConfig, this);
-        testInfoDao = new TestInfoDao(testInfoDaoConfig, this);
         registerDao(AudioPlayHistoricalRecord.class, audioPlayHistoricalRecordDao);
         registerDao(AudioPlayLastInfo.class, audioPlayLastInfoDao);
@@ -249,9 +274,11 @@ public class DaoSession extends AbstractDaoSession {
         registerDao(ContactList.class, contactListDao);
         registerDao(ContanctDaRenEntity.class, contanctDaRenEntityDao);
         registerDao(ContanctGroupChatEntity.class, contanctGroupChatEntityDao);
-        registerDao(DBFriendCircleMessage.class, dBFriendCircleMessageDao);
         registerDao(DarenDetailMsg.class, darenDetailMsgDao);
         registerDao(DarenListMsg.class, darenListMsgDao);
+        registerDao(DBFriendCircleMessage.class, dBFriendCircleMessageDao);
+        registerDao(DBMomentDetail.class, dBMomentDetailDao);
+        registerDao(DBMomentItem.class, dBMomentItemDao);
         registerDao(DownloadInfo.class, downloadInfoDao);
         registerDao(ExceptionInfo.class, exceptionInfoDao);
         registerDao(HolidayThemeInfo.class, holidayThemeInfoDao);
@@ -269,9 +296,6 @@ public class DaoSession extends AbstractDaoSession {
         registerDao(SearchHistory.class, searchHistoryDao);
         registerDao(SysNumReadable.class, sysNumReadableDao);
         registerDao(Witness.class, witnessDao);
-        registerDao(DBMomentDetail.class, dBMomentDetailDao);
-        registerDao(DBMomentItem.class, dBMomentItemDao);
-        registerDao(TestInfo.class, testInfoDao);
     }
     public void clear() {
@@ -283,9 +307,11 @@ public class DaoSession extends AbstractDaoSession {
         contactListDaoConfig.clearIdentityScope();
         contanctDaRenEntityDaoConfig.clearIdentityScope();
         contanctGroupChatEntityDaoConfig.clearIdentityScope();
-        dBFriendCircleMessageDaoConfig.clearIdentityScope();
         darenDetailMsgDaoConfig.clearIdentityScope();
         darenListMsgDaoConfig.clearIdentityScope();
+        dBFriendCircleMessageDaoConfig.clearIdentityScope();
+        dBMomentDetailDaoConfig.clearIdentityScope();
+        dBMomentItemDaoConfig.clearIdentityScope();
         downloadInfoDaoConfig.clearIdentityScope();
         exceptionInfoDaoConfig.clearIdentityScope();
         holidayThemeInfoDaoConfig.clearIdentityScope();
@@ -303,9 +329,6 @@ public class DaoSession extends AbstractDaoSession {
         searchHistoryDaoConfig.clearIdentityScope();
         sysNumReadableDaoConfig.clearIdentityScope();
         witnessDaoConfig.clearIdentityScope();
-        dBMomentDetailDaoConfig.clearIdentityScope();
-        dBMomentItemDaoConfig.clearIdentityScope();
-        testInfoDaoConfig.clearIdentityScope();
     }
     public AudioPlayHistoricalRecordDao getAudioPlayHistoricalRecordDao() {
@@ -340,10 +363,6 @@ public class DaoSession extends AbstractDaoSession {
         return contanctGroupChatEntityDao;
     }
-    public DBFriendCircleMessageDao getDBFriendCircleMessageDao() {
-        return dBFriendCircleMessageDao;
-    }
-
     public DarenDetailMsgDao getDarenDetailMsgDao() {
         return darenDetailMsgDao;
     }
@@ -352,6 +371,18 @@ public class DaoSession extends AbstractDaoSession {
         return darenListMsgDao;
     }
+    public DBFriendCircleMessageDao getDBFriendCircleMessageDao() {
+        return dBFriendCircleMessageDao;
+    }
+
+    public DBMomentDetailDao getDBMomentDetailDao() {
+        return dBMomentDetailDao;
+    }
+
+    public DBMomentItemDao getDBMomentItemDao() {
+        return dBMomentItemDao;
+    }
+
     public DownloadInfoDao getDownloadInfoDao() {
         return downloadInfoDao;
     }
@@ -420,16 +451,4 @@ public class DaoSession extends AbstractDaoSession {
         return witnessDao;
     }
-    public DBMomentDetailDao getDBMomentDetailDao() {
-        return dBMomentDetailDao;
-    }
-
-    public DBMomentItemDao getDBMomentItemDao() {
-        return dBMomentItemDao;
-    }
-
-    public TestInfoDao getTestInfoDao() {
-        return testInfoDao;
-    }
-
 }
+package com.cnlive.core.gridview;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+import androidx.annotation.IntDef;
+
+/**
+ * created by hanyayun
+ * on 2020/2/13
+ */
+@IntDef({AutoGridMode.GRID_NINE,
+        AutoGridMode.GRID_NORMAL})
+@Retention(RetentionPolicy.SOURCE)
+public @interface AutoGridMode {
+    // 网格图的两种模式中的九宫格模式
+    int GRID_NINE = 0;
+    // 网格图的两种模式中的普通模式
+    int GRID_NORMAL = 1;
+}
+package com.cnlive.core.gridview;
+
+import android.content.Context;
+import android.content.res.TypedArray;
+import android.database.DataSetObserver;
+import android.util.AttributeSet;
+import android.view.View;
+import android.view.ViewGroup;
+
+import com.cnlive.core.gridview.adapter.BaseAutoGridAdapter;
+import com.cnlive.core.gridview.model.SizeHelper;
+import com.cnlive.core.gridview.model.SizeInfo;
+import com.cnlive.core.gridview.model.SizeParam;
+import com.cnlive.core.imageload.R;
+
+import java.lang.ref.SoftReference;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+import androidx.annotation.FloatRange;
+
+/**
+ * created by hanyayun
+ * on 2020/2/13
+ */
+public class AutoGridView extends ViewGroup {
+
+    /**
+     * 默认值
+     */
+    // 无效的值
+    private static final int INVALID_VAL = -1;
+    // 默认网格图模式
+    private static final int DEF_MODE = AutoGridMode.GRID_NINE;
+    // 默认的 item 最大行数
+    private static final int DEF_ROW = 3;
+    // 默认的 item 最大列数
+    private static final int DEF_COLUMN = 3;
+    // 默认的 item 高度
+    public static final int DEF_ITEM_HEIGHT = INVALID_VAL;
+    // 默认的 item 横向间距
+    private static final int DEF_HORIZONTAL_SPACE = 10;
+    //  默认的 item 纵向间距
+    private static final int DEF_VERTICAL_SPACE = 10;
+    // 九宫格模式时，当只有一个 item 时，item 的宽与父容器可用总宽度（即去除左右 padding 后的 width ）的比
+    // 此处默认 DEF_SINGLE_WIDTH_PERCENT 为无效值，即 item 的宽度自适应
+    private static final float DEF_SINGLE_WIDTH_PERCENT = INVALID_VAL;
+    // 九宫格模式时，当只有一个 item 时，item 的高与父容器可用总宽度（即去除左右 padding 后的 width ）的比
+    private static final float DEF_SINGLE_HEIGHT_PERCENT = INVALID_VAL;
+
+    /**
+     * 变量
+     */
+    // 网格图的模式
+    private int mMode;
+    // item 的行数
+    private int mRow;
+    // item 的列数
+    private int mColumn;
+    // item 的高度
+    private float mItemHeight;
+    // item 之间的横向间距
+    private float mHorizontalSpace;
+    // item 之间的纵向间距
+    private float mVerticalSpace;
+    // 九宫格模式时，当只有一个 item 时，item 的宽与父容器可用总宽度（即去除左右 padding 后的 width ）的比
+    private float mNineSingleWidthPer;
+    // 九宫格模式时，当只有一个 item 时，item 的高与父容器可用总宽度（即去除左右 padding 后的 width ）的比
+    private float mNineSingleHeightPer;
+
+    // 网格数据计算辅助类
+    private SizeHelper mSizeHelper;
+    private SizeParam mSizeParam;
+    // SizeHelper 中计算结果后，返回的结果类
+    private SizeInfo mSizeInfo;
+    // 缓存 item 的 viewType
+    private ArrayList<String> mCacheTypeBin;
+    // 缓存器，存储 item，用于复用
+    private HashMap<String, List<SoftReference<View>>> mCacheBin;
+    private AdapterObserver mDataSetObserver;
+    private BaseAutoGridAdapter mAdapter;
+    private OnItemClickListener mItemClickListener;
+    private OnItemLongClickListener mItemLongClickListener;
+
+    public AutoGridView(Context context) {
+        super(context);
+        init(context, null);
+    }
+
+    public AutoGridView(Context context, AttributeSet attrs) {
+        super(context, attrs);
+        init(context, attrs);
+    }
+
+    public AutoGridView(Context context, AttributeSet attrs, int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
+        init(context, attrs);
+    }
+
+    private void init(Context context, AttributeSet attrs) {
+        initData();
+        if (attrs != null) {
+            TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.AutoGridView);
+            if (a != null) {
+                mMode = a.getInt(R.styleable.AutoGridView_agv_mode, DEF_MODE);
+                mRow = a.getInt(R.styleable.AutoGridView_agv_row, DEF_ROW);
+                mColumn = a.getInt(R.styleable.AutoGridView_agv_column, DEF_COLUMN);
+                mItemHeight = a.getDimension(R.styleable.AutoGridView_agv_item_height, DEF_ITEM_HEIGHT);
+                mHorizontalSpace = a.getDimension(R.styleable.AutoGridView_agv_horizontal_space, DEF_HORIZONTAL_SPACE);
+                mVerticalSpace = a.getDimension(R.styleable.AutoGridView_agv_vertical_space, DEF_VERTICAL_SPACE);
+                mNineSingleWidthPer = a.getFloat(R.styleable.AutoGridView_agv_nines_widthper, DEF_SINGLE_WIDTH_PERCENT);
+                mNineSingleHeightPer = a.getFloat(R.styleable.AutoGridView_agv_nines_heightper, DEF_SINGLE_HEIGHT_PERCENT);
+                a.recycle();
+            }
+        }
+    }
+
+    private void initData() {
+        mMode = DEF_MODE;
+        mRow = DEF_ROW;
+        mColumn = DEF_COLUMN;
+        mItemHeight = DEF_ITEM_HEIGHT;
+        mHorizontalSpace = DEF_HORIZONTAL_SPACE;
+        mVerticalSpace = DEF_VERTICAL_SPACE;
+        mNineSingleWidthPer = DEF_SINGLE_WIDTH_PERCENT;
+        mNineSingleHeightPer = DEF_SINGLE_HEIGHT_PERCENT;
+
+        mSizeHelper = new SizeHelper();
+    }
+
+    public void setAdapter(BaseAutoGridAdapter adapter) {
+        if (mAdapter != null && mDataSetObserver != null) {
+            // 删除已经存在的观察者
+            mAdapter.unregisterDataSetObserver(mDataSetObserver);
+        }
+        removeAllViews();
+        // 清空缓存器
+        if (mCacheTypeBin != null) {
+            mCacheTypeBin.clear();
+        }
+        if (mCacheBin != null) {
+            mCacheBin.clear();
+        }
+        // 重置 adapter
+        mAdapter = adapter;
+        if (mAdapter != null) {
+            mDataSetObserver = new AdapterObserver();
+            // 注册观察者
+            mAdapter.registerDataSetObserver(mDataSetObserver);
+            if (mAdapter.getItemCount() > 0) {
+                addItemViews();
+            }
+        }
+    }
+
+    /**
+     * 通知刷新
+     */
+    private void notifyChanged() {
+        if (mAdapter != null) {
+            int newSize = mAdapter.getItemCount();
+            if (newSize == 0) {
+                if (mCacheTypeBin != null) {
+                    mCacheTypeBin.clear();
+                }
+                if (mCacheBin != null) {
+                    mCacheBin.clear();
+                }
+            } else {
+                if (mCacheBin == null) mCacheBin = new HashMap<>();
+                for (int i = 0, len = mCacheTypeBin.size(); i < len; i++) {
+                    String key = mCacheTypeBin.get(i);
+                    List<SoftReference<View>> views = mCacheBin.get(key);
+                    views = (views != null ? views : new ArrayList<SoftReference<View>>());
+                    views.add(new SoftReference<View>(getChildAt(i)));
+                    mCacheBin.put(key, views);
+                }
+            }
+            removeAllViews();
+            if (mCacheTypeBin != null) {
+                mCacheTypeBin.clear();
+            }
+            for (int i = 0; i < newSize; i++) {
+                String key = mMode + "_" + mAdapter.getItemViewType(i);
+                mCacheTypeBin.add(key);
+                // 从缓存器中取出 key 类型的 view 列表
+                List<SoftReference<View>> views = mCacheBin.get(key);
+                /** 此处做简单的缓存复用处理 */
+                if (views != null && views.size() > 0) {
+                    boolean isAddItem = false;
+                    for (SoftReference<View> softReference : views) {
+                        if (softReference != null && softReference.get() != null) {
+                            View itemView = softReference.get();
+                            // 如果列表中的 item 还没有父容器，则复用该 item
+                            if (itemView.getParent() == null) {
+                                addItemClickListener(itemView, i);
+                                addItemLongClickListener(itemView, i);
+                                addView(mAdapter.getView(i, itemView, this), new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
+                                isAddItem = true;
+                                views.remove(itemView);
+                                mCacheBin.put(key, views);
+                                break;
+                            }
+                        }
+                    }
+                    // 如果从 views 中未找到匹配的 item ，则新建 item
+                    if (!isAddItem) {
+                        View itemView = mAdapter.getView(i, null, this);
+                        // 将新建的 item 存入列表中
+                        views.add(new SoftReference<View>(itemView));
+                        addItemClickListener(itemView, i);
+                        addItemLongClickListener(itemView, i);
+                        addView(itemView, new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
+                    }
+                }
+                // 如果没有 key 类型的 view 存在，则新建 item
+                else {
+                    View itemView = mAdapter.getView(i, null, this);
+                    views = (views != null ? views : new ArrayList<SoftReference<View>>());
+                    views.add(new SoftReference<View>(itemView));
+                    addItemClickListener(itemView, i);
+                    addItemLongClickListener(itemView, i);
+                    addView(itemView, new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
+                }
+            }
+            if (mCacheBin != null && mCacheBin.size() > 0) {
+                mCacheBin.clear();
+            }
+        }
+        requestLayout();
+        invalidate();
+    }
+
+    /**
+     * 添加 item
+     */
+    private void addItemViews() {
+        int totalCount = mAdapter.getItemCount();
+        int maxCount = mRow * mColumn;
+        int childCount = totalCount > maxCount ? maxCount : totalCount;
+        if (mCacheTypeBin == null) mCacheTypeBin = new ArrayList<>();
+        for (int i = 0; i < childCount; i++) {
+            View itemView = mAdapter.getView(i, null, this);
+            String key = mMode + "_" + mAdapter.getItemViewType(i);
+            mCacheTypeBin.add(key);
+            addItemClickListener(itemView, i);
+            addItemLongClickListener(itemView, i);
+            /** 一定要有 LayoutParams ，addView 的时候，item 在 xml 中的 width 和 height 设置的值，都是没效果的（变成 wrap_content ），
+             * 可能会出现控件的宽高显示偏差，所以必须设置此句）*/
+            addView(itemView, new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
+        }
+    }
+
+    /**
+     * 设置 item 的点击监听事件
+     *
+     * @param view
+     * @param position
+     */
+    private void addItemClickListener(View view, final int position) {
+        view.setOnClickListener(new OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                if (mItemClickListener != null) {
+                    mItemClickListener.onItemClick(position, v);
+                }
+            }
+        });
+    }
+
+    /**
+     * 设置 item 的长按监听事件
+     *
+     * @param view
+     * @param position
+     */
+    private void addItemLongClickListener(View view, final int position) {
+        view.setOnLongClickListener(new OnLongClickListener() {
+            @Override
+            public boolean onLongClick(View v) {
+                if (mItemLongClickListener != null) {
+                    return mItemLongClickListener.onItemLongClick(position, v);
+                }
+                return false;
+            }
+        });
+    }
+
+    @Override
+    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
+        int measureWidth = MeasureSpec.getSize(widthMeasureSpec);
+        int measureHeight = MeasureSpec.getSize(heightMeasureSpec);
+        int widthMode = MeasureSpec.getMode(widthMeasureSpec);
+        int heightMode = MeasureSpec.getMode(heightMeasureSpec);
+        if (mAdapter == null || getChildCount() == 0) {
+            setMeasuredDimension(measureWidth, heightMode == MeasureSpec.EXACTLY ? measureHeight : getPaddingTop() + getPaddingBottom());
+            return;
+        }
+        int maxWidth = measureWidth - getPaddingLeft() - getPaddingRight();
+        int childCount = getChildCount();
+        mSizeParam = new SizeParam();
+        mSizeParam.setMode(mMode)
+                .setRow(mRow)
+                .setColumn(mColumn)
+                .setMaxWidth(maxWidth)
+                .setItemCount(childCount)
+                .setItemHeight(mItemHeight)
+                .setHorizontalSpace(mHorizontalSpace)
+                .setVerticalSpace(mVerticalSpace)
+                .setSingleWidthPer(mNineSingleWidthPer)
+                .setSingleHeightPer(mNineSingleHeightPer);
+        if (mSizeHelper == null) {
+            mSizeHelper = new SizeHelper();
+        }
+        mSizeInfo = mSizeHelper.calculateSize(mSizeParam);
+        // 如果只有一个 child ，且当前模式为九宫格模式
+        if (childCount == 1 && mMode == AutoGridMode.GRID_NINE) {
+            View child = getChildAt(0);
+            int childWms, childHms;
+            // 宽度自适应
+            if (mNineSingleWidthPer == INVALID_VAL) {
+                // child 的宽度介于 0 到 父容器的最大宽度之间
+                childWms = MeasureSpec.makeMeasureSpec(maxWidth, MeasureSpec.AT_MOST);
+            } else {
+                childWms = MeasureSpec.makeMeasureSpec((int) mSizeInfo.getChildWidth(), MeasureSpec.EXACTLY);
+            }
+            // 高度自适应
+            if (mNineSingleHeightPer == INVALID_VAL) {
+                // child 可以获取它想要的高度
+                childHms = MeasureSpec.makeMeasureSpec((int) mSizeInfo.getChildHeight(), MeasureSpec.UNSPECIFIED);
+            } else {
+                childHms = MeasureSpec.makeMeasureSpec((int) mSizeInfo.getChildHeight(), MeasureSpec.EXACTLY);
+            }
+            child.measure(childWms, childHms);
+            int cw = child.getMeasuredWidth() == 0 ? maxWidth : child.getMeasuredWidth();
+            int ch = child.getMeasuredHeight() == 0 ? (int) (0.6 * maxWidth) : child.getMeasuredHeight();
+            mSizeInfo.setChildWidth(cw);
+            mSizeInfo.setChildHeight(ch);
+            mSizeInfo.setParentWidth(cw);
+            mSizeInfo.setParentHeight(ch);
+        } else {
+            for (int i = 0; i < getChildCount(); i++) {
+                View child = getChildAt(i);
+                if (child != null) {
+                    child.measure(MeasureSpec.makeMeasureSpec((int) mSizeInfo.getChildWidth(), MeasureSpec.EXACTLY),
+                            MeasureSpec.makeMeasureSpec((int) mSizeInfo.getChildHeight(), MeasureSpec.EXACTLY));
+                }
+            }
+        }
+
+        // 测量 AutoGridView 的大小
+        if (mSizeInfo != null) {
+            int widthMeasure = (int) (mSizeInfo.getParentWidth() + getPaddingLeft() + getPaddingRight());
+            int heightMeasure = (int) (mSizeInfo.getParentHeight() + getPaddingTop() + getPaddingBottom());
+            setMeasuredDimension(widthMode == MeasureSpec.EXACTLY ? measureWidth : widthMeasure, heightMode == MeasureSpec.EXACTLY ? measureHeight : heightMeasure);
+        } else {
+            setMeasuredDimension(measureWidth, heightMode == MeasureSpec.EXACTLY ? measureHeight : getPaddingTop() + getPaddingBottom());
+        }
+    }
+
+    @Override
+    protected void onLayout(boolean changed, int l, int t, int r, int b) {
+        if (mAdapter == null || getChildCount() == 0 || mSizeInfo == null) {
+            return;
+        }
+        // 遍历 child，设置每个 child 所在的位置
+        int childCount = getChildCount();
+        for (int i = 0; i < childCount; i++) {
+            int[] position = mSizeHelper.findPosition(mSizeInfo, i);
+            int left = (int) (getPaddingLeft() + position[1] * (mSizeInfo.getChildWidth() + mHorizontalSpace));
+            int top = (int) (getPaddingTop() + position[0] * (mSizeInfo.getChildHeight() + mVerticalSpace));
+            int right = (int) (left + mSizeInfo.getChildWidth());
+            int bottom = (int) (top + mSizeInfo.getChildHeight());
+            View child = getChildAt(i);
+            child.layout(left, top, right, bottom);
+        }
+    }
+
+    public interface OnItemClickListener {
+        void onItemClick(int position, View view);
+    }
+
+    public interface OnItemLongClickListener {
+        boolean onItemLongClick(int position, View view);
+    }
+
+    public void setOnItemClickListener(OnItemClickListener listener) {
+        this.mItemClickListener = listener;
+    }
+
+    public void setOnItemLongClickListener(OnItemLongClickListener listener) {
+        this.mItemLongClickListener = listener;
+    }
+
+    public void setMode(@AutoGridMode int mode) {
+        this.mMode = mode;
+    }
+
+    @AutoGridMode
+    public int getMode() {
+        return mMode;
+    }
+
+    public void setRow(int row) {
+        this.mRow = row;
+    }
+
+    public int getRow() {
+        return mRow;
+    }
+
+    public void setColumn(int column) {
+        this.mColumn = column;
+    }
+
+    public int getColumn() {
+        return mColumn;
+    }
+
+    public void setItemHeight(float itemHeight) {
+        this.mItemHeight = itemHeight;
+    }
+
+    public float getItemHeight() {
+        return mItemHeight;
+    }
+
+    public void setHorizontalSpace(float horizontalSpace) {
+        this.mHorizontalSpace = horizontalSpace;
+    }
+
+    public float getHorizontalSpace() {
+        return mHorizontalSpace;
+    }
+
+    public void setVerticalSpace(float verticalSpace) {
+        this.mVerticalSpace = verticalSpace;
+    }
+
+    public float getVerticalSpace() {
+        return mVerticalSpace;
+    }
+
+    public void setNineSingleWidthPercent(@FloatRange(from = 0f, to = 1f) float nineSingleWidthPercent) {
+        this.mNineSingleWidthPer = nineSingleWidthPercent;
+    }
+
+    public float getNineSingleWidthPercent() {
+        return mNineSingleWidthPer;
+    }
+
+    public void setNineSingleHeightPercent(@FloatRange(from = 0f, to = 1f) float nineSingleHeightPercent) {
+        this.mNineSingleHeightPer = nineSingleHeightPercent;
+    }
+
+    public float getNineSingleHeightPercent() {
+        return mNineSingleHeightPer;
+    }
+
+    private class AdapterObserver extends DataSetObserver {
+
+        @Override
+        public void onChanged() {
+            super.onChanged();
+            notifyChanged();
+        }
+
+        @Override
+        public void onInvalidated() {
+            super.onInvalidated();
+        }
+    }
+
+    @Override
+    protected void onDetachedFromWindow() {
+        if (mAdapter != null) {
+            if (mDataSetObserver != null) {
+                mAdapter.unregisterDataSetObserver(mDataSetObserver);
+            }
+            mAdapter = null;
+        }
+        if (mCacheTypeBin != null) {
+            mCacheTypeBin.clear();
+            mCacheTypeBin = null;
+        }
+        if (mCacheBin != null) {
+            mCacheBin.clear();
+            mCacheBin = null;
+        }
+        mItemClickListener = null;
+        mItemLongClickListener = null;
+        super.onDetachedFromWindow();
+    }
+}
+
+package com.cnlive.core.gridview;
+
+import android.content.Context;
+import android.graphics.drawable.Drawable;
+import android.widget.ImageView;
+
+import com.bumptech.glide.request.RequestListener;
+import com.bumptech.glide.request.target.SimpleTarget;
+import com.cnlive.core.imageload.R;
+import com.cnlive.core.libs.base.application.GlideApp;
+
+/**
+ * created by hanyayun
+ * on 2020/2/13
+ */
+public class GridImgUtil {
+    public static void loadImage(Context context, final Object src, final ImageView view) {
+        GlideApp.with(context)
+                .load(src)
+//                .placeholder(R.drawable.img_placeholder)
+//                .error(R.drawable.img_placeholder)
+                .into(view);
+    }
+
+    public static void loadImage(Context context, final Object src, final ImageView view, RequestListener<Drawable> listener) {
+        GlideApp.with(context)
+                .load(src)
+//                .placeholder(R.drawable.img_placeholder)
+//                .error(R.drawable.img_placeholder)
+                .listener(listener)
+                .into(view);
+    }
+
+    public static void loadImage(Context context, final Object src, final SimpleTarget<Drawable> target) {
+        GlideApp.with(context)
+                .load(src)
+                .thumbnail(0.1f)
+//                .placeholder(R.drawable.img_placeholder)
+//                .error(R.drawable.img_placeholder)
+                .into(target);
+    }
+}
+
+package com.cnlive.core.gridview.adapter;
+
+import android.database.DataSetObservable;
+import android.database.DataSetObserver;
+import android.view.View;
+import android.view.ViewGroup;
+
+/**
+ * created by hanyayun
+ * on 2020/2/13
+ */
+public abstract class BaseAutoGridAdapter<VH extends BaseAutoGridHolder>  {
+// 被观察者，用来注册观察者
+private final DataSetObservable mDataSetObservable = new DataSetObservable();
+
+/**
+ * 创建 ViewHolder
+ */
+public abstract VH onCreateViewHolder(ViewGroup parent, int viewType);
+
+/**
+ * 绑定 item 的 ViewHolder
+ */
+public abstract void onBindViewHolder(VH holder, int position);
+
+/**
+ * 获取 item 的数量
+ */
+public abstract int getItemCount();
+
+public int getItemViewType(int position) {
+        return 0;
+        }
+
+public View getView(int position, View convertView, ViewGroup parent) {
+        int viewType = getItemViewType(position);
+        VH holder = null;
+        if (convertView == null) {
+        holder = onCreateViewHolder(parent, viewType);
+        convertView = holder.getConvertView();
+        convertView.setTag(holder);
+        } else {
+        holder = (VH) convertView.getTag();
+        }
+        holder.setViewType(viewType);
+        onBindViewHolder(holder, position);
+        return convertView;
+        }
+
+
+/**
+ * 注册观察者
+ *
+ * @param observer
+ */
+public void registerDataSetObserver(DataSetObserver observer) {
+        mDataSetObservable.registerObserver(observer);
+        }
+
+/**
+ * 删除已经注册过的观察者
+ *
+ * @param observer
+ */
+public void unregisterDataSetObserver(DataSetObserver observer) {
+        mDataSetObservable.unregisterObserver(observer);
+        }
+
+/**
+ * 通知刷新
+ */
+public void notifyDataSetChanged() {
+        mDataSetObservable.notifyChanged();
+        }
+        }
+package com.cnlive.core.gridview.adapter;
+
+import android.view.View;
+import android.widget.ImageView;
+import android.widget.TextView;
+
+import androidx.annotation.IdRes;
+
+/**
+ * created by hanyayun
+ * on 2020/2/13
+ */
+public class BaseAutoGridHolder {
+    private View convertView;
+    private int mViewType;
+
+    public BaseAutoGridHolder(final View convertView) {
+        this.convertView = convertView;
+    }
+
+    public View getConvertView() {
+        return convertView;
+    }
+
+    public <T extends View> T findViewById(@IdRes int viewId) {
+        T view = (T) convertView.findViewById(viewId);
+        return view;
+    }
+
+    public ImageView getImageView(@IdRes int viewId) {
+        return findViewById(viewId);
+    }
+
+    public TextView getTextView(@IdRes int viewId) {
+        return findViewById(viewId);
+    }
+
+    public int getViewType() {
+        return mViewType;
+    }
+
+    public void setViewType(int viewType) {
+        this.mViewType = viewType;
+    }
+}
+package com.cnlive.core.gridview.adapter;
+
+import android.util.SparseIntArray;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.util.List;
+
+import androidx.annotation.LayoutRes;
+
+/**
+ * created by hanyayun
+ * on 2020/2/13
+ */
+public abstract class QuickAutoGridAdapter<T, VH extends BaseAutoGridHolder> extends BaseAutoGridAdapter<VH> {
+    private static final int LAYOUT_NOT_FOUND = -404;
+
+    private LayoutInflater mLayoutInflater;
+    private SparseIntArray mLayoutTypes;
+    protected List<T> mData;
+
+    public QuickAutoGridAdapter() {
+
+    }
+
+    public void setData(List<T> list) {
+        this.mData = list;
+    }
+
+    public List<T> getData() {
+        return mData;
+    }
+
+    public void updateData(List<T> list) {
+        mData = list;
+        notifyDataSetChanged();
+    }
+
+    protected void addItemType(int type, @LayoutRes int layoutId) {
+        if (mLayoutTypes == null) {
+            mLayoutTypes = new SparseIntArray();
+        }
+        mLayoutTypes.put(type, layoutId);
+    }
+
+    @Override
+    public int getItemViewType(int position) {
+        return onHandleViewType(position);
+    }
+
+    @Override
+    public VH onCreateViewHolder(ViewGroup parent, int viewType) {
+        if (mLayoutInflater == null) mLayoutInflater = LayoutInflater.from(parent.getContext());
+        View convertView = getItemView(getLayoutId(viewType), parent);
+        VH holder = createBaseViewHolder(convertView);
+        return holder;
+    }
+
+    @Override
+    public void onBindViewHolder(VH holder, int position) {
+        onHandleViewHolder(holder, position, mData.get(position));
+    }
+
+    @Override
+    public int getItemCount() {
+        return mData != null ? mData.size() : 0;
+    }
+
+    public abstract int onHandleViewType(int position);
+
+    public abstract void onHandleViewHolder(VH holder, int position, T item);
+
+    protected View getItemView(int layoutResId, ViewGroup parent) {
+        if (layoutResId != LAYOUT_NOT_FOUND) {
+            return mLayoutInflater.inflate(layoutResId, parent, false);
+        }
+        return null;
+    }
+
+    private int getLayoutId(int vieType) {
+        return mLayoutTypes.get(vieType, LAYOUT_NOT_FOUND);
+    }
+
+    protected VH createBaseViewHolder(View view) {
+        Class temp = getClass();
+        Class z = null;
+        while (z == null && null != temp) {
+            z = getInstancedGenericKClass(temp);
+            temp = temp.getSuperclass();
+        }
+        VH k;
+        // 泛型擦除会导致 z 为 null
+        if (z == null) {
+            k = (VH) new BaseAutoGridHolder(view);
+        } else {
+            k = createGenericKInstance(z, view);
+        }
+        return k != null ? k : (VH) new BaseAutoGridHolder(view);
+    }
+
+    @SuppressWarnings("unchecked")
+    private VH createGenericKInstance(Class z, View view) {
+        try {
+            Constructor constructor;
+            // inner and unstatic class
+            if (z.isMemberClass() && !Modifier.isStatic(z.getModifiers())) {
+                constructor = z.getDeclaredConstructor(getClass(), View.class);
+                constructor.setAccessible(true);
+                return (VH) constructor.newInstance(this, view);
+            } else {
+                constructor = z.getDeclaredConstructor(View.class);
+                constructor.setAccessible(true);
+                return (VH) constructor.newInstance(view);
+            }
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (InstantiationException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    private Class getInstancedGenericKClass(Class z) {
+        Type type = z.getGenericSuperclass();
+        if (type instanceof ParameterizedType) {
+            Type[] types = ((ParameterizedType) type).getActualTypeArguments();
+            for (Type temp : types) {
+                if (temp instanceof Class) {
+                    Class tempClass = (Class) temp;
+                    if (BaseAutoGridHolder.class.isAssignableFrom(tempClass)) {
+                        return tempClass;
+                    }
+                } else if (temp instanceof ParameterizedType) {
+                    Type rawType = ((ParameterizedType) temp).getRawType();
+                    if (rawType instanceof Class && BaseAutoGridHolder.class.isAssignableFrom((Class<?>) rawType)) {
+                        return (Class<?>) rawType;
+                    }
+                }
+            }
+        }
+        return null;
+    }
+}
+package com.cnlive.core.gridview.adapter;
+
+import android.widget.ImageView;
+
+import com.cnlive.core.gridview.AutoGridMode;
+import com.cnlive.core.imageload.R;
+
+import java.util.List;
+
+/**
+ * created by hanyayun
+ * on 2020/2/13
+ */
+public class SimpleAutoGridAdapter<T, VH extends BaseAutoGridHolder> extends QuickAutoGridAdapter<T, VH> {
+    // item 类型
+    private final int ITEM_TYPE_SINGLE = 0;
+    private final int ITEM_TYPE_NORMAL = 1;
+
+    private int mGridMode;
+    private ImageLoader mImageLoader;
+
+    public SimpleAutoGridAdapter() {
+        init();
+    }
+
+    public SimpleAutoGridAdapter(List<T> list) {
+        setData(list);
+        init();
+    }
+
+    private void init() {
+        addItemType(ITEM_TYPE_SINGLE, R.layout.auto_grid_item_simple_pic_single);
+        addItemType(ITEM_TYPE_NORMAL, R.layout.auto_grid_item_simple_pic);
+        mGridMode = AutoGridMode.GRID_NINE;
+    }
+
+    public void setMode(@AutoGridMode int mode) {
+        this.mGridMode = mode;
+    }
+
+    public void setImageLoader(ImageLoader loader) {
+        this.mImageLoader = loader;
+    }
+
+    @Override
+    public int onHandleViewType(int position) {
+        int viewType;
+        if (mGridMode == AutoGridMode.GRID_NINE) {
+            if (getItemCount() == 1) {
+                viewType = ITEM_TYPE_SINGLE;
+            } else {
+                viewType = ITEM_TYPE_NORMAL;
+            }
+        } else {
+            viewType = ITEM_TYPE_NORMAL;
+        }
+        return viewType;
+    }
+
+    @Override
+    public void onHandleViewHolder(VH holder, int position, T item) {
+        if (mImageLoader != null) {
+            mImageLoader.onLoadImage(position, item, holder.getImageView(R.id.iv_auto_grid_item_simple_pic));
+        }
+    }
+
+    public interface ImageLoader<T> {
+        /**
+         * 加载图片
+         */
+        void onLoadImage(int position, T item, ImageView imageView);
+    }
+}
+package com.cnlive.core.gridview.model;
+
+import com.cnlive.core.gridview.AutoGridMode;
+import com.cnlive.core.gridview.AutoGridView;
+
+/**
+ * 网格数据计算辅助类
+ * created by hanyayun
+ * on 2020/2/13
+ */
+public class SizeHelper {
+    /**
+     * 计算 item 和 parent 的宽高
+     *
+     * @param param
+     * @return
+     */
+    public SizeInfo calculateSize(SizeParam param) {
+        if (param != null) {
+            float childWidth, childHeight;
+            float parentWidth, parentHeight;
+            int childRow, childColumn;
+
+            int parentRow = param.getRow();
+            int parentColumn = param.getColumn();
+            float parentMaxWidth = param.getMaxWidth();
+            int totalCount = param.getItemCount();
+            float totalHorizontalSpace = (parentColumn - 1) * param.getHorizontalSpace();
+            childWidth = (parentMaxWidth - totalHorizontalSpace) / parentColumn;
+            childHeight = param.getItemHeight() != AutoGridView.DEF_ITEM_HEIGHT ? param.getItemHeight() : childWidth;
+            // 判断当前网格是九宫格模式还是普通模式
+            // 当前模式为九宫格模式时
+            if (param.getMode() == AutoGridMode.GRID_NINE) {
+                // 只有一个 item 时
+                if (totalCount == 1) {
+                    float widthPer = param.getSingleWidthPer();
+                    float heightPer = param.getSingleHeightPer();
+                    childRow = 1;
+                    childColumn = 1;
+                    if (widthPer <= 0) {
+                        childWidth = 0;
+                    } else {
+                        if (widthPer > 1) {
+                            widthPer = 1;
+                        }
+                        childWidth = widthPer * parentMaxWidth;
+                    }
+                    if (heightPer <= 0) {
+                        childHeight = 0;
+                    } else {
+                        childHeight = heightPer * parentMaxWidth;
+                    }
+                    parentWidth = childWidth;
+                    parentHeight = childHeight;
+                    return new SizeInfo(childRow, childColumn, childWidth, childHeight, parentWidth, parentHeight);
+                } else {
+                    // 如果 item 的个数大于可以显示的最大个数
+                    if (parentRow * parentColumn < totalCount) {
+                        childRow = parentRow;
+                        childColumn = parentColumn;
+                    } else {
+                        // 判断 item 的个数是否可以开平方（即判断是否可以将 itemView 拼成正方形放置）
+                        int temp = (int) Math.sqrt(totalCount);
+                        if (temp * temp == totalCount) {
+                            // 如果 item 的个数不满一行，则不做正方形放置，否则做正方形放置
+                            if (totalCount <= parentColumn) {
+                                childRow = 1;
+                                childColumn = totalCount;
+                            } else {
+                                childRow = temp;
+                                childColumn = temp;
+                            }
+                        } else {
+                            childRow = totalCount / parentColumn + (totalCount % parentColumn == 0 ? 0 : 1);
+                            childColumn = param.getColumn();
+                        }
+                    }
+                }
+            }
+            // 当前模式为普通网格模式时
+            else {
+                if (parentRow * parentColumn < totalCount) {
+                    childRow = parentRow;
+                    childColumn = parentColumn;
+                } else {
+                    childRow = totalCount / parentColumn + (totalCount % parentColumn == 0 ? 0 : 1);
+                    childColumn = parentColumn;
+                }
+            }
+            parentWidth = childColumn * childWidth + (childColumn - 1) * param.getHorizontalSpace();
+            parentHeight = childRow * childHeight + (childRow - 1) * param.getVerticalSpace();
+            // 当只有一个 child 的时候，parent 的总宽度与 item 的宽度一致
+            if (totalCount == 1) {
+                parentWidth = childWidth;
+            }
+            return new SizeInfo(childRow, childColumn, childWidth, childHeight, parentWidth, parentHeight);
+        }
+        return null;
+    }
+
+    /**
+     * 找到 item 在网格中的位置
+     *
+     * @param bean
+     * @param index
+     * @return
+     */
+    public int[] findPosition(SizeInfo bean, int index) {
+        if (bean == null) {
+            return null;
+        }
+        int[] position = new int[2];
+        position[0] = index / bean.getChildColumn();
+        position[1] = index - position[0] * bean.getChildColumn();
+        return position;
+    }
+}
+package com.cnlive.core.gridview.model;
+
+/**
+ * created by hanyayun
+ * on 2020/2/13
+ */
+public class SizeInfo {
+    private int childRow;
+    private int childColumn;
+    private float childWidth;
+    private float childHeight;
+    private float parentWidth;
+    private float parentHeight;
+
+    public SizeInfo() {
+        super();
+    }
+
+    public SizeInfo(int childRow, int childColumn, float childWidth, float childHeight, float parentWidth, float parentHeight) {
+        this.childRow = childRow;
+        this.childColumn = childColumn;
+        this.childWidth = childWidth;
+        this.childHeight = childHeight;
+        this.parentWidth = parentWidth;
+        this.parentHeight = parentHeight;
+    }
+
+    public int getChildRow() {
+        return childRow;
+    }
+
+    public void setChildRow(int childRow) {
+        this.childRow = childRow;
+    }
+
+    public int getChildColumn() {
+        return childColumn;
+    }
+
+    public void setChildColumn(int childColumn) {
+        this.childColumn = childColumn;
+    }
+
+    public float getChildWidth() {
+        return childWidth;
+    }
+
+    public void setChildWidth(float childWidth) {
+        this.childWidth = childWidth;
+    }
+
+    public float getChildHeight() {
+        return childHeight;
+    }
+
+    public void setChildHeight(float childHeight) {
+        this.childHeight = childHeight;
+    }
+
+    public float getParentWidth() {
+        return parentWidth;
+    }
+
+    public void setParentWidth(float parentWidth) {
+        this.parentWidth = parentWidth;
+    }
+
+    public float getParentHeight() {
+        return parentHeight;
+    }
+
+    public void setParentHeight(float parentHeight) {
+        this.parentHeight = parentHeight;
+    }
+}
 \ No newline at end of file
+package com.cnlive.core.gridview.model;
+
+/**
+ * created by hanyayun
+ * on 2020/2/13
+ */
+public class SizeParam {
+    private int mode;
+    private int row;
+    private int column;
+    private int maxWidth;
+    private int itemCount;
+    private float itemWidth;
+    private float itemHeight;
+    private float horizontalSpace;
+    private float verticalSpace;
+    private float singleWidthPer;
+    private float singleHeightPer;
+
+    public SizeParam() {
+    }
+
+    public SizeParam(int mode, int row, int column, int maxWidth, int itemCount,
+                     float itemWidth, float itemHeight, float horizontalSpace, float verticalSpace,
+                     float singleWidthPer, float singleHeightPer) {
+        this.mode = mode;
+        this.row = row;
+        this.column = column;
+        this.maxWidth = maxWidth;
+        this.itemCount = itemCount;
+        this.itemWidth = itemWidth;
+        this.itemHeight = itemHeight;
+        this.horizontalSpace = horizontalSpace;
+        this.verticalSpace = verticalSpace;
+        this.singleWidthPer = singleWidthPer;
+        this.singleHeightPer = singleHeightPer;
+    }
+
+    public int getMode() {
+        return mode;
+    }
+
+    public SizeParam setMode(int mode) {
+        this.mode = mode;
+        return this;
+    }
+
+    public int getRow() {
+        return row;
+    }
+
+    public SizeParam setRow(int row) {
+        this.row = row;
+        return this;
+    }
+
+    public int getColumn() {
+        return column;
+    }
+
+    public SizeParam setColumn(int column) {
+        this.column = column;
+        return this;
+    }
+
+    public int getMaxWidth() {
+        return maxWidth;
+    }
+
+    public SizeParam setMaxWidth(int maxWidth) {
+        this.maxWidth = maxWidth;
+        return this;
+    }
+
+    public int getItemCount() {
+        return itemCount;
+    }
+
+    public SizeParam setItemCount(int itemCount) {
+        this.itemCount = itemCount;
+        return this;
+    }
+
+    public float getItemWidth() {
+        return itemWidth;
+    }
+
+    public SizeParam setItemWidth(float itemWidth) {
+        this.itemWidth = itemWidth;
+        return this;
+    }
+
+    public float getItemHeight() {
+        return itemHeight;
+    }
+
+    public SizeParam setItemHeight(float itemHeight) {
+        this.itemHeight = itemHeight;
+        return this;
+    }
+
+    public float getHorizontalSpace() {
+        return horizontalSpace;
+    }
+
+    public SizeParam setHorizontalSpace(float horizontalSpace) {
+        this.horizontalSpace = horizontalSpace;
+        return this;
+    }
+
+    public float getVerticalSpace() {
+        return verticalSpace;
+    }
+
+    public SizeParam setVerticalSpace(float verticalSpace) {
+        this.verticalSpace = verticalSpace;
+        return this;
+    }
+
+    public float getSingleWidthPer() {
+        return singleWidthPer;
+    }
+
+    public SizeParam setSingleWidthPer(float singleWidthPer) {
+        this.singleWidthPer = singleWidthPer;
+        return this;
+    }
+
+    public float getSingleHeightPer() {
+        return singleHeightPer;
+    }
+
+    public SizeParam setSingleHeightPer(float singleHeightPer) {
+        this.singleHeightPer = singleHeightPer;
+        return this;
+    }
+}
+package com.cnlive.core.imagepreview;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.drawable.Drawable;
+import android.util.Log;
+import android.widget.FrameLayout;
+import android.widget.ImageView;
+
+import com.cnlive.core.imagepreview.indexui.ProgressUI;
+
+import androidx.annotation.NonNull;
+import uk.co.senab.photoview.PhotoView;
+
+/**
+ * created by hanyayun
+ * on 2020/1/20
+ */
+public class ImageDrawee extends FrameLayout {
+    private PhotoView imageView;
+    private ProgressUI progressUI;
+
+    public ImageDrawee(@NonNull Context context) {
+        super(context);
+        init();
+    }
+
+    private void init() {
+        // 添加 imageView
+        imageView = new PhotoView(getContext());
+        addView(imageView);
+    }
+
+    public void setProgressUI(ProgressUI progressUI) {
+        this.progressUI = progressUI;
+        if (progressUI != null) {
+            progressUI.init(this);
+        }
+    }
+
+    /**
+     * 更新加载进度
+     */
+    public void handleProgress(float progress) {
+        if (progressUI != null && progressUI.getProgressView() != null) {
+            if (progress == 0) {
+                progressUI.start();
+            } else if (progress == 1f) {
+                progressUI.stop();
+            }
+            progressUI.handleProgress(progress);
+        }
+    }
+
+    public void hideProgressUI() {
+        if (progressUI != null && progressUI.getProgressView() != null
+                && progressUI.getProgressView().getVisibility() == VISIBLE) {
+            progressUI.stop();
+        }
+    }
+
+    /**
+     * 释放 imageView 占据的内存
+     * <p>
+     * Bitmap 的存储分为两部分，一部分是 Bitmap 的数据，一部分是 Bitmap 的引用。
+     * 在 Android2.3 时代，Bitmap 的引用是放在堆中的，而 Bitmap 的数据部分是放在栈中的，需要用户调用 recycle 方法手动进行内存回收；
+     * 在 Android2.3 之后，整个 Bitmap（包括数据和引用）都放在了堆中，整个 Bitmap 的回收就全部交给GC了，不用在手动调用 recycle 方法回收内存。
+     */
+    public void recycle() {
+//        Drawable drawable = imageView.getDrawable();
+//        if (drawable != null && drawable instanceof BitmapDrawable) {
+//            Bitmap bitmap = ((BitmapDrawable) drawable).getBitmap();
+//            if (bitmap != null && !bitmap.isRecycled()) {
+//                /**
+//                 * 当如果图片加载框架设置了缓存且 bitmap 已经被回收，
+//                 * 但是 canvas 在 draw 时，继续使用被回收的 bitmap，会抛出异常：
+//                 * a BitmapDrawable: Canvas: trying to use a recycled bitmap.
+//                 * 故此处不使用 bitmap.recycle() 方法（或者图片加载框架去除缓存设置）。
+//                 */
+//                bitmap.recycle();
+//                bitmap = null;
+//            }
+//        }
+        // 调用 setImageDrawable(null) 方法,然后 GC 会完成图片的回收
+        imageView.setImageDrawable(null);
+        // 手动调用 GC（但是 GC 并不一定是马上执行的，只能说是加速 GC 回收）
+//        System.gc();
+    }
+
+    public ImageView getImageView() {
+        return imageView;
+    }
+
+    public void setImage(Object obj) {
+        if (obj == null) {
+            return;
+        }
+        if (obj instanceof Drawable) {
+            imageView.setImageDrawable((Drawable) obj);
+        } else if (obj instanceof Bitmap) {
+            imageView.setImageBitmap((Bitmap) obj);
+        } else if (obj instanceof Integer) {
+            imageView.setImageResource((Integer) obj);
+        } else {
+            Log.e("ImageDrawee", "Unable to identify picture resources.");
+        }
+    }
+
+    public float getScale() {
+        return imageView.getScale();
+    }
+
+    public void setScale(float scale) {
+        imageView.setScale(scale);
+    }
+
+    public float getMaxScale() {
+        return imageView.getMaximumScale();
+    }
+
+    public void setMaxScale(float scale) {
+        this.imageView.setMaximumScale(scale);
+    }
+
+    public float getMinScale() {
+        return imageView.getMinimumScale();
+    }
+
+    public void setMinScale(float scale) {
+        imageView.setMinimumScale(scale);
+    }
+}
 \ No newline at end of file
+package com.cnlive.core.imagepreview;
+
+import android.content.Context;
+import android.content.res.TypedArray;
+import android.graphics.Color;
+import android.graphics.drawable.Drawable;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.view.KeyEvent;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.FrameLayout;
+
+import com.cnlive.core.imageload.R;
+import com.cnlive.core.imagepreview.dragger.DragHandler;
+import com.cnlive.core.imagepreview.dragger.DragMode;
+import com.cnlive.core.imagepreview.dragger.DragStatus;
+import com.cnlive.core.imagepreview.indexui.DefaultIndexUI;
+import com.cnlive.core.imagepreview.indexui.DefaultProgressUI;
+import com.cnlive.core.imagepreview.indexui.IndexUI;
+import com.cnlive.core.imagepreview.indexui.ProgressUI;
+import com.cnlive.core.imagepreview.listener.OnBrowseStatusListener;
+import com.cnlive.core.imagepreview.listener.OnDragStatusListener;
+import com.cnlive.core.imagepreview.listener.OnItemChangedListener;
+import com.cnlive.core.imagepreview.listener.OnItemClickListener;
+import com.cnlive.core.imagepreview.listener.OnItemLongPressListener;
+import com.cnlive.core.imagepreview.viewpager.ImagePagerAdapter;
+import com.cnlive.core.imagepreview.viewpager.ImageViewPager;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import androidx.annotation.IntRange;
+import androidx.annotation.NonNull;
+import androidx.viewpager.widget.ViewPager;
+
+/**
+ * created by hanyayun
+ * on 2020/1/21
+ */
+public class ImagePreView extends FrameLayout implements ViewPager.OnPageChangeListener {
+    private final String TAG = getClass().getSimpleName();
+
+    // 索引视图
+    private IndexUI indexUI;
+    // 加载进度视图
+    private ProgressUI progressUI;
+    private ImageViewPager viewPager;
+    private ImagePagerAdapter mAdapter;
+    private LoadImage mLoader;
+    private DragHandler mDragHandler;
+
+    // 是否执行进场动画
+    private boolean playEnterAnim = true;
+    // 是否执行退场动画
+    private boolean playExitAnim = true;
+    // 动画执行时间
+    private long mDuration = 300;
+    // 是否显示图片索引
+    private boolean showIndex = true;
+    // 是否可拖拽图片
+    private boolean draggable = true;
+    // 拖拽模式
+    private int mDragMode = DragMode.MODE_AGILE;
+
+    private List<ViewData> mSourceList;
+    // ImageViewer 是否会占据 StatusBar 的空间
+    private boolean overlayStatusBar = false;
+    private float mMaxScale;
+    private float mMinScale;
+
+    // 上一次的触摸点坐标
+    private float mLastX, mLastY;
+    // 是否正在进行拖拽
+    private boolean isDragging;
+    // 是否有动画正在执行
+    private boolean hasAnimRunning;
+    // 是否已经执行了进场动画
+    private boolean hasPlayEnterAnim = false;
+    // ImageViewer 的当前状态
+    private int mViewStatus = ViewerStatus.STATUS_SILENCE;
+    // 缓存 item，用于复用
+    private ArrayList<ImageDrawee> mViewBox = new ArrayList<ImageDrawee>();
+
+    private OnItemClickListener mItemClickListener;
+    private OnItemLongPressListener mItemLongPressListener;
+    private OnItemChangedListener mItemChangedListener;
+    private OnDragStatusListener mDragStatusListener;
+    private OnBrowseStatusListener mBrowseStatusListener;
+
+    public ImagePreView(@NonNull Context context) {
+        super(context);
+        init(context, null);
+    }
+
+    public ImagePreView(Context context, AttributeSet attrs) {
+        super(context, attrs);
+        init(context, attrs);
+    }
+
+    public ImagePreView(Context context, AttributeSet attrs, int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
+        init(context, attrs);
+    }
+
+    private void init(Context context, AttributeSet attrs) {
+        if (attrs != null) {
+            TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.ImagePreView);
+            if (a != null) {
+                playEnterAnim = a.getBoolean(R.styleable.ImagePreView_ivr_playEnterAnim, true);
+                playExitAnim = a.getBoolean(R.styleable.ImagePreView_ivr_playExitAnim, true);
+                mDuration = a.getInteger(R.styleable.ImagePreView_ivr_duration, 300);
+                showIndex = a.getBoolean(R.styleable.ImagePreView_ivr_showIndex, true);
+                draggable = a.getBoolean(R.styleable.ImagePreView_ivr_draggable, true);
+                mDragMode = a.getInteger(R.styleable.ImagePreView_ivr_dragMode, DragMode.MODE_AGILE);
+                a.recycle();
+            }
+        }
+        initView();
+    }
+
+    private void initView() {
+        if (getBackground() == null) {
+            setBackgroundColor(Color.BLACK);
+        }
+
+        // 添加 ViewPager
+        viewPager = new ImageViewPager(getContext());
+        viewPager.setOffscreenPageLimit(1);
+        viewPager.addOnPageChangeListener(this);
+        addView(viewPager, new FrameLayout.LayoutParams(
+                FrameLayout.LayoutParams.MATCH_PARENT,
+                FrameLayout.LayoutParams.MATCH_PARENT));
+
+        setVisibility(View.INVISIBLE);
+
+        progressUI = new DefaultProgressUI();
+    }
+
+
+    @Override
+    public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
+
+    }
+
+    @Override
+    public void onPageSelected(int position) {
+        if (showIndex && indexUI != null && mSourceList != null) {
+            indexUI.handleItemChanged(position, mSourceList.size());
+        }
+        if (mItemChangedListener != null) {
+            mItemChangedListener.onItemChanged(position, getCurrentItem());
+        }
+    }
+
+    @Override
+    public void onPageScrollStateChanged(int state) {
+
+    }
+
+    public ImagePreView imageData(@NonNull List list) {
+        if (mSourceList == null) {
+            mSourceList = new ArrayList<ViewData>();
+        } else {
+            mSourceList.clear();
+        }
+        for (int i = 0, len = list.size(); i < len; i++) {
+            ViewData vd = new ViewData(list.get(i));
+            mSourceList.add(vd);
+        }
+        return this;
+    }
+
+    public ImagePreView overlayStatusBar(boolean overlayStatusBar) {
+        this.overlayStatusBar = overlayStatusBar;
+        return this;
+    }
+
+    public ImagePreView bindViewGroup(@NonNull ViewGroup viewGroup) {
+        for (int i = 0, len = viewGroup.getChildCount(); i < len; i++) {
+            View child = viewGroup.getChildAt(i);
+            int[] location = new int[2];
+            // 获取 child 在屏幕中的坐标，其中 getLocationOnScreen() 方法获取的 y 轴坐标包含状态栏的高度
+            child.getLocationOnScreen(location);
+            mSourceList.get(i).setTargetX(location[0]);
+            mSourceList.get(i).setTargetY(overlayStatusBar ? location[1] : location[1] - Utils.getStatusBarHeight(getContext()));
+            mSourceList.get(i).setTargetWidth(child.getMeasuredWidth());
+            mSourceList.get(i).setTargetHeight(child.getMeasuredHeight());
+        }
+        return this;
+    }
+
+    public ImagePreView viewData(@NonNull List<ViewData> list) {
+        this.mSourceList = list;
+        return this;
+    }
+
+    public ImagePreView imageLoader(@NonNull LoadImage loader) {
+        this.mLoader = loader;
+        return this;
+    }
+
+    public ImagePreView playEnterAnim(boolean play) {
+        this.playEnterAnim = play;
+        return this;
+    }
+
+    public ImagePreView playExitAnim(boolean play) {
+        this.playExitAnim = play;
+        return this;
+    }
+
+    public ImagePreView duration(long duration) {
+        this.mDuration = duration;
+        return this;
+    }
+
+    public ImagePreView showIndex(boolean showIndex) {
+        this.showIndex = showIndex;
+        return this;
+    }
+
+    public ImagePreView loadIndexUI(@NonNull IndexUI indexUI) {
+        this.indexUI = indexUI;
+        return this;
+    }
+
+    public ImagePreView loadProgressUI(@NonNull ProgressUI progressUI) {
+        this.progressUI = progressUI;
+        return this;
+    }
+
+    public ImagePreView draggable(boolean draggable) {
+        this.draggable = draggable;
+        return this;
+    }
+
+    public ImagePreView dragMode(int mode) {
+        this.mDragMode = mode;
+        return this;
+    }
+
+    public ImagePreView setMaxScale(float scale) {
+        this.mMaxScale = scale;
+        return this;
+    }
+
+    public ImagePreView setMinScale(float scale) {
+        this.mMinScale = scale;
+        return this;
+    }
+
+    public ImagePreView setOnItemClickListener(OnItemClickListener listener) {
+        this.mItemClickListener = listener;
+        return this;
+    }
+
+    public ImagePreView setOnItemLongPressListener(OnItemLongPressListener listener) {
+        this.mItemLongPressListener = listener;
+        return this;
+    }
+
+    public ImagePreView setOnItemChangedListener(OnItemChangedListener listener) {
+        this.mItemChangedListener = listener;
+        return this;
+    }
+
+    public ImagePreView setOnDragStatusListener(OnDragStatusListener listener) {
+        this.mDragStatusListener = listener;
+        return this;
+    }
+
+    public ImagePreView setOnBrowseStatusListener(OnBrowseStatusListener listener) {
+        this.mBrowseStatusListener = listener;
+        return this;
+    }
+
+    /**
+     * 开启浏览
+     *
+     * @param startPosition 开始位置，即点击的 ImageView 的位置
+     */
+    public void watch(@IntRange(from = 0) int startPosition) {
+        watch(startPosition, 0, 0, null);
+    }
+
+    /**
+     * 开启浏览
+     *
+     * @param startPosition 开始位置，即点击的 ImageView 的位置
+     * @param callback      进场动画执行回调
+     */
+    public void watch(@IntRange(from = 0) int startPosition, ImageTransfer.OnTransCallback callback) {
+        watch(startPosition, 0, 0, callback);
+    }
+
+    /**
+     * 开启浏览
+     *
+     * @param startPosition    开始位置，即点击的 ImageView 的位置
+     * @param startImageWidth  被点击的 ImageView 加载的资源图片的实际宽度
+     * @param startImageHeight 被点击的 ImageView 加载的资源图片的实际高度
+     */
+    public void watch(@IntRange(from = 0) int startPosition, int startImageWidth, int startImageHeight) {
+        watch(startPosition, startImageWidth, startImageHeight, null);
+    }
+
+    /**
+     * 开启浏览
+     *
+     * @param startPosition    开始位置，即点击的 ImageView 的位置
+     * @param startImageWidth  被点击的 ImageView 加载的资源图片的实际宽度
+     * @param startImageHeight 被点击的 ImageView 加载的资源图片的实际高度
+     * @param callback         进场动画执行回调
+     */
+    public void watch(@IntRange(from = 0) final int startPosition, int startImageWidth, int startImageHeight, final ImageTransfer.OnTransCallback callback) {
+        if (mSourceList == null || startPosition >= mSourceList.size()) {
+            Log.e(TAG, "SourceList is null or StartPosition greater than or equal to the length of Sourcelist.");
+            return;
+        }
+        if (startImageWidth != 0 && startImageHeight != 0
+                && (mSourceList.get(startPosition).getImageWidth() == 0 ||
+                mSourceList.get(startPosition).getImageHeight() == 0)) {
+            mSourceList.get(startPosition).setImageWidth(startImageWidth);
+            mSourceList.get(startPosition).setImageHeight(startImageHeight);
+        }
+        viewPager.setScrollable(true);
+        mAdapter = new ImagePagerAdapter(mSourceList.size()) {
+            @NonNull
+            @Override
+            public Object instantiateItem(@NonNull ViewGroup container, int position) {
+                return ImagePreView.this.instantiateItem(container, position, startPosition, callback);
+            }
+        };
+        viewPager.setAdapter(mAdapter);
+        viewPager.setCurrentItem(startPosition);
+        setVisibility(VISIBLE);
+        if (!playEnterAnim) {
+            noteBrowseStatus(ViewerStatus.STATUS_WATCHING);
+            handleIndexUI(startPosition);
+        }
+    }
+
+    /**
+     * 取消浏览
+     */
+    public void cancel() {
+        cancel(null);
+    }
+
+    /**
+     * 取消浏览
+     *
+     * @param callback 退场动画执行回调
+     */
+    public void cancel(final ImageTransfer.OnTransCallback callback) {
+        if (indexUI != null) {
+            indexUI.hide();
+        }
+        if (playExitAnim) {
+            int position = getCurrentPosition();
+            new ImageTransfer(getWidth(), getHeight())
+                    .with(getCurrentItem().getImageView())
+                    .background(getBackground())
+                    .duration(mDuration)
+                    .loadExitData(mSourceList.get(position))
+                    .callback(new ImageTransfer.OnTransCallback() {
+                        @Override
+                        public void onStart() {
+                            noteBrowseStatus(ViewerStatus.STATUS_BEGIN_CLOSE);
+                            if (callback != null) {
+                                callback.onStart();
+                            }
+                        }
+
+                        @Override
+                        public void onRunning(float progress) {
+                            noteBrowseStatus(ViewerStatus.STATUS_CLOSING);
+                            if (callback != null) {
+                                callback.onRunning(progress);
+                            }
+                        }
+
+                        @Override
+                        public void onEnd() {
+                            noteBrowseStatus(ViewerStatus.STATUS_SILENCE);
+                            if (callback != null) {
+                                callback.onEnd();
+                            }
+                            shutComplete();
+                        }
+                    })
+                    .play();
+        } else {
+            noteBrowseStatus(ViewerStatus.STATUS_SILENCE);
+            shutComplete();
+        }
+    }
+
+    /**
+     * 实例化 item
+     */
+    private ImageDrawee instantiateItem(ViewGroup container, int position, final int startPosition, final ImageTransfer.OnTransCallback callback) {
+        ImageDrawee drawee = null;
+        if (mViewBox.size() > 0) {
+            for (ImageDrawee item : mViewBox) {
+                if (item.getParent() == null) {
+                    drawee = item;
+                    break;
+                }
+            }
+        }
+        if (drawee == null) {
+            drawee = new ImageDrawee(container.getContext());
+            drawee.setProgressUI(progressUI);
+            mViewBox.add(drawee);
+        }
+        container.addView(drawee);
+        configureItem(position, drawee);
+        if (playEnterAnim && !hasPlayEnterAnim && startPosition == position) {
+            hasPlayEnterAnim = true;
+            new ImageTransfer(getWidth(), getHeight())
+                    .with(drawee.getImageView())
+                    .loadEnterData(mSourceList.get(position))
+                    .background(getBackground())
+                    .duration(mDuration)
+                    .callback(new ImageTransfer.OnTransCallback() {
+                        @Override
+                        public void onStart() {
+                            noteBrowseStatus(ViewerStatus.STATUS_BEGIN_OPEN);
+                            if (callback != null) {
+                                callback.onStart();
+                            }
+                        }
+
+                        @Override
+                        public void onRunning(float progress) {
+                            noteBrowseStatus(ViewerStatus.STATUS_OPENING);
+                            if (callback != null) {
+                                callback.onRunning(progress);
+                            }
+                        }
+
+                        @Override
+                        public void onEnd() {
+                            handleIndexUI(startPosition);
+                            noteBrowseStatus(ViewerStatus.STATUS_WATCHING);
+                            if (callback != null) {
+                                callback.onEnd();
+                            }
+                        }
+                    })
+                    .play();
+        }
+        return drawee;
+    }
+
+    /**
+     * 配置 item
+     */
+    private void configureItem(final int position, final ImageDrawee drawee) {
+        drawee.setTag(position);
+        if (mMaxScale > 0) {
+            drawee.setMaxScale(mMaxScale);
+        }
+        if (mMinScale > 0) {
+            drawee.setMinScale(mMinScale);
+        }
+        mLoader.displayImage(mSourceList.get(position).getImageSrc(), drawee.getImageView(), new LoadImage.LoadCallback() {
+            @Override
+            public void onLoadStarted(Object placeholder) {
+                drawee.setImage(placeholder);
+            }
+
+            @Override
+            public void onLoading(float progress) {
+                drawee.handleProgress(progress);
+            }
+
+            @Override
+            public void onLoadSucceed(Object source) {
+                drawee.hideProgressUI();
+                drawee.setImage(source);
+                if (mSourceList.get(position).getImageWidth() == 0 ||
+                        mSourceList.get(position).getImageHeight() == 0) {
+                    Drawable drawable = drawee.getImageView().getDrawable();
+                    if (drawable != null) {
+                        mSourceList.get(position).setImageWidth(drawable.getIntrinsicWidth());
+                        mSourceList.get(position).setImageHeight(drawable.getIntrinsicHeight());
+                    }
+                }
+            }
+
+            @Override
+            public void onLoadFailed(Object error) {
+                drawee.hideProgressUI();
+                drawee.setImage(error);
+            }
+        });
+        // 单击事件
+        drawee.getImageView().setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                if (!hasAnimRunning && mItemClickListener != null) {
+                    final boolean result = mItemClickListener.onItemClick(position, drawee.getImageView());
+                    // 判断是否消费了单击事件，如果消费了，则单击事件的后续方法不执行
+                    if (result) {
+                        return;
+                    }
+                }
+                cancel();
+            }
+        });
+        // 长按事件
+        drawee.getImageView().setOnLongClickListener(new View.OnLongClickListener() {
+            @Override
+            public boolean onLongClick(View v) {
+                if (!hasAnimRunning && mItemLongPressListener != null) {
+                    return mItemLongPressListener.onItemLongPress(position, drawee.getImageView());
+                }
+                return false;
+            }
+        });
+    }
+
+    private void noteDragStatus(int status) {
+        switch (status) {
+            case DragStatus.STATUS_BEGIN_RESTORE:
+            case DragStatus.STATUS_BEGIN_EXIT:
+                hasAnimRunning = true;
+                break;
+            case DragStatus.STATUS_COMPLETE_RESTORE:
+            case DragStatus.STATUS_COMPLETE_EXIT:
+                hasAnimRunning = false;
+                break;
+        }
+        if (mDragStatusListener != null) {
+            mDragStatusListener.onDragStatusChanged(status);
+        }
+    }
+
+    private void noteBrowseStatus(int status) {
+        mViewStatus = status;
+        switch (status) {
+            case ViewerStatus.STATUS_BEGIN_OPEN:
+                hasAnimRunning = true;
+                break;
+            case ViewerStatus.STATUS_BEGIN_CLOSE:
+                viewPager.setScrollable(false);
+                hasAnimRunning = true;
+                break;
+            case ViewerStatus.STATUS_WATCHING:
+                hasAnimRunning = false;
+                break;
+            case ViewerStatus.STATUS_SILENCE:
+                viewPager.setScrollable(true);
+                hasAnimRunning = false;
+                break;
+        }
+        if (mBrowseStatusListener != null) {
+            mBrowseStatusListener.onBrowseStatus(mViewStatus);
+        }
+    }
+
+    /**
+     * 处理索引 UI
+     */
+    private void handleIndexUI(int startPosition) {
+        if (indexUI == null) {
+            indexUI = new DefaultIndexUI(overlayStatusBar);
+        }
+        if (showIndex) {
+            if (mSourceList.size() > 1) {
+                indexUI.setup(this, startPosition, mSourceList.size());
+            } else {
+                indexUI.hide();
+            }
+        } else {
+            indexUI.hide();
+        }
+    }
+
+    private void shutComplete() {
+        setVisibility(GONE);
+        reset();
+    }
+
+    private void reset() {
+        if (mViewBox.size() > 0) {
+            mViewBox.clear();
+        }
+        if (mDragHandler != null) {
+            mDragHandler.clear();
+            mDragHandler = null;
+        }
+        mAdapter = null;
+        hasAnimRunning = false;
+        hasPlayEnterAnim = false;
+    }
+
+    public List<ViewData> getViewData() {
+        return mSourceList;
+    }
+
+    public ImageDrawee getCurrentItem() {
+        if (mViewBox != null) {
+            for (ImageDrawee drawee : mViewBox) {
+                if ((int) drawee.getTag() == getCurrentPosition()) {
+                    return drawee;
+                }
+            }
+        }
+        return (ImageDrawee) viewPager.findViewWithTag(getCurrentPosition());
+    }
+
+    public int getCurrentPosition() {
+        return viewPager != null ? viewPager.getCurrentItem() : 0;
+    }
+
+    public int getViewStatus() {
+        return mViewStatus;
+    }
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    ////  拖拽相关
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+
+    @Override
+    public boolean onInterceptTouchEvent(MotionEvent ev) {
+        boolean isIntercept = super.onInterceptTouchEvent(ev);
+        if (!hasAnimRunning && draggable) {
+            // 是否拦截触摸事件？
+            // 若拦截，则 ImageViewer 自己处理触摸事件；
+            // 若不拦截，则 ImageView 处理触摸事件
+            int action = ev.getAction() & ev.getActionMasked();
+            if (action == MotionEvent.ACTION_DOWN) {
+                mLastX = ev.getX();
+                mLastY = ev.getY();
+            } else if (action == MotionEvent.ACTION_MOVE) {
+                /**
+                 * 拖拽触发条件：
+                 * 1.允许拖拽
+                 * 2.仅有一个触摸点
+                 * 3.图片的缩放等级 = 1f
+                 * 4.拖拽处理类不为空
+                 * 5.手势为上下滑动手势，左右滑动不触发
+                 */
+                if (ev.getPointerCount() == 1 && getCurrentItem().getScale() <= 1f) {
+                    float disX = ev.getX() - mLastX;
+                    float disY = ev.getY() - mLastY;
+                    // 上下滑动手势
+                    if (Math.abs(disX) < Math.abs(disY)) {
+                        if (mDragMode == DragMode.MODE_AGILE && disY < 0) {
+                            return isIntercept;
+                        }
+                        isDragging = true;
+                        if (mDragHandler == null) {
+                            mDragHandler = new DragHandler(getWidth(), getHeight());
+                        }
+                        mDragHandler.onReay(mDragMode, getBackground());
+                        noteDragStatus(DragStatus.STATUS_READY);
+                        isIntercept = true;
+                    }
+                }
+            }
+        }
+        return isIntercept;
+    }
+
+    @Override
+    public boolean onTouchEvent(MotionEvent event) {
+        int action = event.getAction() & event.getActionMasked();
+        if (action == MotionEvent.ACTION_MOVE) {
+            if (draggable && isDragging && mDragHandler != null) {
+                mDragHandler.onDrag(mLastX, mLastY, event, getCurrentItem().getImageView());
+                noteDragStatus(DragStatus.STATUS_DRAGGING);
+            }
+            mLastX = event.getX();
+            mLastY = event.getY();
+        } else if (action == MotionEvent.ACTION_UP) {
+            if (draggable && isDragging && mDragHandler != null) {
+                isDragging = false;
+                // 释放图片
+                mDragHandler.onUp(getCurrentItem().getImageView(),
+                        mSourceList.get(getCurrentPosition()), new ImageTransfer.OnTransCallback() {
+                            @Override
+                            public void onStart() {
+                                handleDragResultStatus("start");
+                            }
+
+                            @Override
+                            public void onRunning(float progress) {
+                                handleDragResultStatus("running");
+                            }
+
+                            @Override
+                            public void onEnd() {
+                                handleDragResultStatus("end");
+                            }
+                        });
+            }
+            mLastX = 0;
+            mLastY = 0;
+        }
+        return super.onTouchEvent(event);
+    }
+
+    private void handleDragResultStatus(String proceed) {
+        if (mDragHandler.getAction() == ImageTransfer.ACTION_DRAG_RESTORE) {
+            int status = proceed.equals("start") ? DragStatus.STATUS_BEGIN_RESTORE :
+                    (proceed.equals("running") ? DragStatus.STATUS_RESTORING :
+                            DragStatus.STATUS_COMPLETE_RESTORE);
+            if (status == DragStatus.STATUS_BEGIN_RESTORE) {
+                viewPager.setScrollable(false);
+                hasAnimRunning = true;
+            } else if (status == DragStatus.STATUS_COMPLETE_RESTORE) {
+                viewPager.setScrollable(true);
+                hasAnimRunning = false;
+            }
+            noteDragStatus(status);
+        } else if (mDragHandler.getAction() == ImageTransfer.ACTION_DRAG_EXIT_AGILE
+                || mDragHandler.getAction() == ImageTransfer.ACTION_DRAG_EXIT_SIMPLE) {
+            int status = proceed.equals("start") ? DragStatus.STATUS_BEGIN_EXIT :
+                    (proceed.equals("running") ? DragStatus.STATUS_EXITTING :
+                            DragStatus.STATUS_COMPLETE_EXIT);
+            if (status == DragStatus.STATUS_BEGIN_EXIT) {
+                viewPager.setScrollable(false);
+                hasAnimRunning = true;
+            } else if (status == DragStatus.STATUS_COMPLETE_EXIT) {
+                viewPager.setScrollable(true);
+                hasAnimRunning = false;
+            }
+            noteDragStatus(status);
+            if (proceed.equals("end")) {
+                noteBrowseStatus(ViewerStatus.STATUS_SILENCE);
+                shutComplete();
+            }
+        }
+    }
+
+    /**
+     * 如果本方法未执行，则是因为图片浏览器为获取到焦点，可在外部手动获取焦点
+     * 建议在外部手动调动本方法
+     *
+     * @param keyCode
+     * @param event
+     * @return
+     */
+    @Override
+    public boolean onKeyDown(int keyCode, KeyEvent event) {
+        if (keyCode == KeyEvent.KEYCODE_BACK) {
+            if (!hasAnimRunning) {
+                if (mViewStatus == ViewerStatus.STATUS_WATCHING) {
+                    cancel();
+                    // 消费返回键点击事件，不传递出去
+                    return true;
+                }
+            }
+        }
+        return super.onKeyDown(keyCode, event);
+    }
+
+    @Override
+    protected void onDetachedFromWindow() {
+        super.onDetachedFromWindow();
+        mSourceList = null;
+        mLoader = null;
+        reset();
+    }
+}
+package com.cnlive.core.imagepreview;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.ValueAnimator;
+import android.graphics.drawable.Drawable;
+import android.widget.FrameLayout;
+import android.widget.ImageView;
+
+import androidx.annotation.NonNull;
+
+/**
+ * 图片进退场动画处理类
+ * created by hanyayun
+ * on 2020/1/20
+ */
+public class ImageTransfer {
+    // 没有需要执行的动画
+    public static final int ACTION_IDEL = -1;
+    // 执行进场动画
+    public static final int ACTION_ENTER = 0;
+    // 执行退场动画
+    public static final int ACTION_EXIT = 1;
+    // 拖拽后，执行复原动画
+    public static final int ACTION_DRAG_RESTORE = 2;
+    // 在灵巧模式下，拖拽后，执行退场动画
+    public static final int ACTION_DRAG_EXIT_AGILE = 3;
+    // 在简单模式下，拖拽后，执行退场动画
+    public static final int ACTION_DRAG_EXIT_SIMPLE = 4;
+
+
+    private int interfaceWidth, interfaceHeight;
+    private int startWidth, startHeight;
+    private int endWidth, endHeight;
+    private float startX, startY;
+    private float endX, endY;
+    private long duration;
+    private Drawable background;
+    private int startAlpha, endAlpha;
+
+    private int animAction;
+    // 是否设置了图片的原始尺寸
+    private boolean hasSetImageOriginalSize;
+    private ImageView imageView;
+    private OnTransCallback mTransCallback;
+
+
+    public ImageTransfer(int interfaceWidth, int interfaceHeight) {
+        this.interfaceWidth = interfaceWidth;
+        this.interfaceHeight = interfaceHeight;
+    }
+
+    public ImageTransfer with(@NonNull ImageView target) {
+        this.imageView = target;
+        return this;
+    }
+
+    /**
+     * 加载进场动画数据
+     */
+    public ImageTransfer loadEnterData(@NonNull ViewData viewData) {
+        startX = viewData.getTargetX();
+        startY = viewData.getTargetY();
+        startWidth = viewData.getTargetWidth();
+        startHeight = viewData.getTargetHeight();
+        int imageWidth, imageHeight;
+        if (viewData.getImageWidth() == 0 || viewData.getImageHeight() == 0) {
+            imageWidth = interfaceWidth;
+            imageHeight = interfaceHeight;
+            hasSetImageOriginalSize = false;
+        } else {
+            imageWidth = viewData.getImageWidth();
+            imageHeight = viewData.getImageHeight();
+            hasSetImageOriginalSize = true;
+        }
+        float scale = Math.min(interfaceWidth * 1f / imageWidth, interfaceHeight * 1f / imageHeight);
+        endWidth = (int) (imageWidth * scale);
+        endHeight = (int) (imageHeight * scale);
+        endX = (interfaceWidth - endWidth) * 1f / 2;
+        endY = (interfaceHeight - endHeight) * 1f / 2;
+        startAlpha = 0;
+        endAlpha = 255;
+        animAction = ACTION_ENTER;
+        return this;
+    }
+
+    /**
+     * 加载退场动画数据
+     */
+    public ImageTransfer loadExitData(@NonNull ViewData viewData) {
+        endX = viewData.getTargetX();
+        endY = viewData.getTargetY();
+        endWidth = viewData.getTargetWidth();
+        endHeight = viewData.getTargetHeight();
+        int imageWidth, imageHeight;
+        if (viewData.getImageWidth() == 0 || viewData.getImageHeight() == 0) {
+            Drawable thumb = imageView.getDrawable();
+            if (thumb != null) {
+                imageWidth = thumb.getIntrinsicWidth();
+                imageHeight = thumb.getIntrinsicHeight();
+                hasSetImageOriginalSize = true;
+            } else {
+                imageWidth = interfaceWidth;
+                imageHeight = interfaceHeight;
+                hasSetImageOriginalSize = false;
+            }
+        } else {
+            imageWidth = viewData.getImageWidth();
+            imageHeight = viewData.getImageHeight();
+            hasSetImageOriginalSize = true;
+        }
+        float scale = Math.min(interfaceWidth * 1f / imageWidth, interfaceHeight * 1f / imageHeight);
+        startWidth = (int) (imageWidth * scale);
+        startHeight = (int) (imageHeight * scale);
+        startX = (interfaceWidth - startWidth) * 1f / 2;
+        startY = (interfaceHeight - startHeight) * 1f / 2;
+        startAlpha = background.getAlpha();
+        endAlpha = 0;
+        animAction = ACTION_EXIT;
+        return this;
+    }
+
+    /**
+     * 加载拖拽复原动画数据
+     */
+    public ImageTransfer loadDragRestoreData() {
+        startX = imageView.getTranslationX();
+        startY = imageView.getTranslationY();
+        startWidth = imageView.getWidth();
+        startHeight = imageView.getHeight();
+        endX = 0;
+        endY = 0;
+        endWidth = interfaceWidth;
+        endHeight = interfaceHeight;
+        startAlpha = background.getAlpha();
+        endAlpha = 255;
+        animAction = ACTION_DRAG_RESTORE;
+        return this;
+    }
+
+
+    /**
+     * 灵巧拖拽模式下，加载拖拽退场动画数据
+     */
+    public ImageTransfer loadDragExitDataInAgile(@NonNull ViewData viewData) {
+        int imageWidth, imageHeight;
+        if (viewData.getImageWidth() == 0 || viewData.getImageHeight() == 0) {
+            Drawable thumb = imageView.getDrawable();
+            if (thumb != null) {
+                imageWidth = thumb.getIntrinsicWidth();
+                imageHeight = thumb.getIntrinsicHeight();
+                hasSetImageOriginalSize = true;
+            } else {
+                imageWidth = interfaceWidth;
+                imageHeight = interfaceHeight;
+                hasSetImageOriginalSize = false;
+            }
+        } else {
+            imageWidth = viewData.getImageWidth();
+            imageHeight = viewData.getImageHeight();
+            hasSetImageOriginalSize = true;
+        }
+        float adjustScale = Math.min(interfaceWidth * 1f / imageWidth, interfaceHeight * 1f / imageHeight);
+        float dragScale = imageView.getWidth() * 1f / interfaceWidth;
+        startWidth = (int) (imageWidth * adjustScale * dragScale);
+        startHeight = (int) (imageHeight * adjustScale * dragScale);
+        startX = imageView.getTranslationX() + (imageView.getWidth() - startWidth) * 1f / 2;
+        startY = imageView.getTranslationY() + (imageView.getHeight() - startHeight) * 1f / 2;
+        // 图片是否已经滑出预览界面
+        if (
+            // imageView 已经从左边滑出预览界面
+                (startX + startWidth) <= 0
+                        // imageView 已经从右边滑出预览界面
+                        || startX >= interfaceWidth
+                        // imageView 已经从底部滑出图片预览界面
+                        || startY >= interfaceHeight) {
+            endX = startX;
+            endY = startY;
+            endWidth = startWidth;
+            endHeight = startHeight;
+        } else {
+            endX = viewData.getTargetX();
+            endY = viewData.getTargetY();
+            endWidth = viewData.getTargetWidth();
+            endHeight = viewData.getTargetHeight();
+        }
+        startAlpha = background.getAlpha();
+        endAlpha = 0;
+        animAction = ACTION_DRAG_EXIT_AGILE;
+        return this;
+    }
+
+    /**
+     * 简单拖拽模式下，加载拖拽退场动画数据
+     */
+    public ImageTransfer loadDragExitDataInSimple(@NonNull ViewData viewData) {
+        startX = endX = 0;
+        startY = imageView.getTranslationY();
+        startWidth = endWidth = imageView.getWidth();
+        startHeight = endHeight = imageView.getHeight();
+
+        // 计算 endY
+        int imageWidth, imageHeight;
+        if (viewData.getImageWidth() == 0 || viewData.getImageHeight() == 0) {
+            Drawable thumb = imageView.getDrawable();
+            if (thumb != null) {
+                imageWidth = thumb.getIntrinsicWidth();
+                imageHeight = thumb.getIntrinsicHeight();
+                hasSetImageOriginalSize = true;
+            } else {
+                imageWidth = interfaceWidth;
+                imageHeight = interfaceHeight;
+                hasSetImageOriginalSize = false;
+            }
+        } else {
+            imageWidth = viewData.getImageWidth();
+            imageHeight = viewData.getImageHeight();
+            hasSetImageOriginalSize = true;
+        }
+        float scale = Math.min(interfaceWidth * 1f / imageWidth, interfaceHeight * 1f / imageHeight);
+        // 图片的缩放等级为 1f 时，图片的高度
+        int adjustImageHeight = (int) (imageHeight * scale);
+        // 图片的缩放等级为 1f 且居中时时，在预览界面中的距离容器顶部的距离
+        float disOnYFromTop = (interfaceHeight - adjustImageHeight) / 2;
+        // 图片在预览界面中的当前 Y 轴坐标
+        float currentImageY = startY + disOnYFromTop;
+        // 图片是否已经滑出浏览界面
+        if (
+            // 图片已经从顶部滑出预览界面
+                (currentImageY + adjustImageHeight) <= 0
+                        // 图片已经从底部滑出预览界面
+                        || currentImageY >= interfaceHeight) {
+            endY = startY;
+        } else {
+            // 此处加 20 ,是为了减少误差，防止影响动画美观
+            endY = currentImageY > disOnYFromTop ?
+                    // 向下滑动
+                    startY + (interfaceHeight - currentImageY) + 20
+                    // 向上滑动
+                    : startY - (currentImageY + adjustImageHeight) - 20;
+        }
+
+        startAlpha = background.getAlpha();
+        endAlpha = 0;
+        animAction = ACTION_DRAG_EXIT_SIMPLE;
+        return this;
+    }
+
+    public ImageTransfer background(Drawable background) {
+        this.background = background;
+        return this;
+    }
+
+    public ImageTransfer duration(long duration) {
+        this.duration = duration;
+        return this;
+    }
+
+    public ImageTransfer callback(OnTransCallback callback) {
+        this.mTransCallback = callback;
+        return this;
+    }
+
+    public void play() {
+        ValueAnimator animator = ValueAnimator.ofFloat(0, 1f);
+        animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
+
+            @Override
+            public void onAnimationUpdate(ValueAnimator animation) {
+                final float progress = (float) animation.getAnimatedValue();
+                if (startX != endX) {
+                    imageView.setTranslationX(calculateByProgress(progress, startX, endX));
+                }
+                if (startY != endY) {
+                    imageView.setTranslationY(calculateByProgress(progress, startY, endY));
+                }
+                if (startWidth != endWidth || startHeight != endHeight) {
+                    imageView.getLayoutParams().width = (int) calculateByProgress(progress, startWidth, endWidth);
+                    imageView.getLayoutParams().height = (int) calculateByProgress(progress, startHeight, endHeight);
+                    imageView.requestLayout();
+                }
+                if (startAlpha != endAlpha) {
+                    background.setAlpha((int) calculateByProgress(progress, startAlpha, endAlpha));
+                }
+                if (mTransCallback != null) {
+                    mTransCallback.onRunning(progress);
+                }
+            }
+        });
+        animator.addListener(new AnimatorListenerAdapter() {
+            @Override
+            public void onAnimationStart(Animator animation) {
+                super.onAnimationStart(animation);
+                if (animAction == ACTION_ENTER
+                        || animAction == ACTION_EXIT
+                        || animAction == ACTION_DRAG_EXIT_AGILE) {
+                    if (hasSetImageOriginalSize) {
+                        imageView.setScaleType(ImageView.ScaleType.CENTER_CROP);
+                    }
+                }
+                if (mTransCallback != null) {
+                    mTransCallback.onStart();
+                }
+            }
+
+            @Override
+            public void onAnimationEnd(Animator animation) {
+                super.onAnimationEnd(animation);
+                if (animAction == ACTION_ENTER && hasSetImageOriginalSize) {
+                    imageView.setScaleType(ImageView.ScaleType.FIT_CENTER);
+                    imageView.setTranslationX(0);
+                    imageView.setTranslationY(0);
+                    imageView.getLayoutParams().width = FrameLayout.LayoutParams.MATCH_PARENT;
+                    imageView.getLayoutParams().height = FrameLayout.LayoutParams.MATCH_PARENT;
+                    imageView.requestLayout();
+                }
+                imageView = null;
+                background = null;
+                animAction = ACTION_IDEL;
+                if (mTransCallback != null) {
+                    mTransCallback.onEnd();
+                }
+            }
+        });
+        animator.setDuration(duration);
+        animator.start();
+    }
+
+    /**
+     * 根据进度，计算过渡值
+     */
+    private float calculateByProgress(float progress, float startVal, float endVal) {
+        return startVal + progress * (endVal - startVal);
+    }
+
+    public interface OnTransCallback {
+        void onStart();
+
+        void onRunning(float progress);
+
+        void onEnd();
+    }
+}
+package com.cnlive.core.imagepreview;
+
+import android.widget.ImageView;
+
+/**
+ * created by hanyayun
+ * on 2020/1/21
+ */
+public abstract class LoadImage {
+    /**
+     * 加载图片
+     */
+    public abstract void displayImage(Object src, ImageView imageView, LoadCallback callback);
+
+    public interface LoadCallback {
+        void onLoadStarted(Object placeholder);
+
+        void onLoading(float progress);
+
+        void onLoadSucceed(Object source);
+
+        void onLoadFailed(Object error);
+    }
+}
+
+package com.cnlive.core.imagepreview;
+
+import android.graphics.drawable.Drawable;
+import android.widget.ImageView;
+
+import com.bumptech.glide.request.target.CustomViewTarget;
+import com.bumptech.glide.request.transition.Transition;
+import com.cnlive.core.imageload.config.ScaleMode;
+import com.cnlive.core.imageload.loader.ImageLoader;
+import com.cnlive.core.libs.base.application.GlideApp;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+
+/**
+ * created by hanyayun
+ * on 2020/2/12
+ */
+public class PhotoLoader extends LoadImage {
+    @Override
+    public void displayImage(Object src, ImageView imageView, LoadCallback callback) {
+        GlideApp.with(imageView.getContext())
+                .load(src)
+                .into(new CustomViewTarget<ImageView, Drawable>(imageView) {
+                    @Override
+                    public void onLoadFailed(@Nullable Drawable errorDrawable) {
+                        if(callback!=null) {
+                            callback.onLoadFailed(errorDrawable);
+                        }
+                    }
+
+                    @Override
+                    public void onResourceReady(@NonNull Drawable resource, @Nullable Transition<? super Drawable> transition) {
+                        if(callback!=null) {
+                            callback.onLoadSucceed(resource);
+                        }
+                    }
+
+                    @Override
+                    protected void onResourceLoading(@Nullable Drawable placeholder) {
+                        super.onResourceLoading(placeholder);
+                        if(callback!=null){
+                            callback.onLoadStarted(placeholder);
+                        }
+                    }
+
+                    @Override
+                    protected void onResourceCleared(@Nullable Drawable placeholder) {
+
+                    }
+                });
+    }
+}
+package com.cnlive.core.imagepreview;
+
+import android.content.Context;
+import android.os.Handler;
+import android.os.Message;
+
+/**
+ * created by hanyayun
+ * on 2020/1/20
+ */
+public class Utils {
+
+    public static int dp2px(Context context, float dpVal) {
+        final float scale = context.getResources().getDisplayMetrics().density;
+        return (int) (dpVal * scale + 0.5f);
+    }
+
+    public static int getStatusBarHeight(Context context) {
+        int result = 0;
+        int resourceId = context.getResources().getIdentifier("status_bar_height", "dimen", "android");
+        if (resourceId > 0) {
+            result = context.getResources().getDimensionPixelSize(resourceId);
+        }
+        return result;
+    }
+
+    public static Handler sHandler = new Handler() {
+        @Override
+        public void handleMessage(Message msg) {
+            super.handleMessage(msg);
+
+        }
+    };
+}
+package com.cnlive.core.imagepreview;
+
+/**
+ * created by hanyayun
+ * on 2020/1/20
+ */
+public class ViewData {
+    // 图片资源
+    private Object imageSrc;
+    // 图片的原始宽度
+    private int imageWidth;
+    // 图片的原始高度
+    private int imageHeight;
+    // 目标 view 的 x 轴坐标
+    private float targetX;
+    // 目标 view 的 y 轴坐标
+    private float targetY;
+    // 目标 view 的宽度
+    private int targetWidth;
+    // 目标 view 的高度
+    private int targetHeight;
+
+    public ViewData() {
+
+    }
+
+    public ViewData(Object imageSrc) {
+        this.imageSrc = imageSrc;
+    }
+
+    public ViewData(float targetX, float targetY, int targetWidth, int targetHeight) {
+        this.targetX = targetX;
+        this.targetY = targetY;
+        this.targetWidth = targetWidth;
+        this.targetHeight = targetHeight;
+    }
+
+    public ViewData(Object imageSrc, float targetX, float targetY, int targetWidth, int targetHeight) {
+        this.imageSrc = imageSrc;
+        this.targetX = targetX;
+        this.targetY = targetY;
+        this.targetWidth = targetWidth;
+        this.targetHeight = targetHeight;
+    }
+
+    public ViewData(Object imageSrc, int imageWidth, int imageHeight, float targetX, float targetY, int targetWidth, int targetHeight) {
+        this.imageSrc = imageSrc;
+        this.imageWidth = imageWidth;
+        this.imageHeight = imageHeight;
+        this.targetX = targetX;
+        this.targetY = targetY;
+        this.targetWidth = targetWidth;
+        this.targetHeight = targetHeight;
+    }
+
+    public Object getImageSrc() {
+        return imageSrc;
+    }
+
+    public void setImageSrc(Object imageSrc) {
+        this.imageSrc = imageSrc;
+    }
+
+    public int getImageWidth() {
+        return imageWidth;
+    }
+
+    public void setImageWidth(int imageWidth) {
+        this.imageWidth = imageWidth;
+    }
+
+    public int getImageHeight() {
+        return imageHeight;
+    }
+
+    public void setImageHeight(int imageHeight) {
+        this.imageHeight = imageHeight;
+    }
+
+    public float getTargetX() {
+        return targetX;
+    }
+
+    public void setTargetX(float targetX) {
+        this.targetX = targetX;
+    }
+
+    public float getTargetY() {
+        return targetY;
+    }
+
+    public void setTargetY(float targetY) {
+        this.targetY = targetY;
+    }
+
+    public int getTargetWidth() {
+        return targetWidth;
+    }
+
+    public void setTargetWidth(int targetWidth) {
+        this.targetWidth = targetWidth;
+    }
+
+    public int getTargetHeight() {
+        return targetHeight;
+    }
+
+    public void setTargetHeight(int targetHeight) {
+        this.targetHeight = targetHeight;
+    }
+}
+package com.cnlive.core.imagepreview;
+
+/**
+ * created by hanyayun
+ * on 2020/1/21
+ */
+public final class ViewerStatus {
+    /**
+     * 图片浏览器处于未开启状态
+     */
+    public static final int STATUS_SILENCE = 0;
+    /**
+     * 图片浏览器开始执行进场动画
+     */
+    public static final int STATUS_BEGIN_OPEN = 1;
+    /**
+     * 图片浏览器正在执行进场动画
+     */
+    public static final int STATUS_OPENING = 2;
+    /**
+     *  图片正在被浏览中
+     */
+    public static final int STATUS_WATCHING = 3;
+    /**
+     * 图片浏览器开始执行退场动画
+     */
+    public static final int STATUS_BEGIN_CLOSE = 4;
+    /**
+     * 图片浏览器正在执行退场动画
+     */
+    public static final int STATUS_CLOSING = 5;
+}
+package com.cnlive.core.imagepreview.dragger;
+
+import android.graphics.drawable.Drawable;
+import android.view.MotionEvent;
+import android.widget.ImageView;
+
+import com.cnlive.core.imagepreview.ImageTransfer;
+import com.cnlive.core.imagepreview.ViewData;
+
+/**
+ * 拖拽工具类
+ * created by hanyayun
+ * on 2020/1/20
+ */
+public class DragHandler {
+    // 完全不透明的透明度值
+    private final int FULL_ALPHA = 255;
+    // 动画执行时间
+    private final int ANIM_DURATION = 300;
+    // 最小缩放比例
+    private final float MIN_SCALE = 0.2f;
+    // 在不退出浏览的情况下， 图片在 Y 轴上的最大可移动距离
+    private final float MAX_MOVABLE_DIS_ON_Y;
+    // 背景透明度的变换基数
+    private final float ALPHA_BASE;
+
+    // 拖拽模式
+    private int mMode;
+    // 浏览界面的宽高
+    private int mIfWidth, mIfHeight;
+    private Drawable mBackground;
+    private ImageTransfer mTransfer;
+    private int mAction;
+
+    public DragHandler(int ifWidth, int ifHeight) {
+        this.mIfWidth = ifWidth;
+        this.mIfHeight = ifHeight;
+        this.MAX_MOVABLE_DIS_ON_Y = ifHeight / 5f;
+        this.ALPHA_BASE = MAX_MOVABLE_DIS_ON_Y * 2;
+        this.mTransfer = new ImageTransfer(ifWidth, ifHeight);
+    }
+
+    /**
+     * 准备拖拽
+     */
+    public void onReay(int mode, Drawable bg) {
+        this.mMode = mode;
+        this.mBackground = bg;
+        mAction = ImageTransfer.ACTION_IDEL;
+    }
+
+    /**
+     * 拖拽中
+     *
+     * @param lastX     上一次触摸点的 x 轴坐标
+     * @param lastY     上一次触摸点的 y 轴坐标
+     * @param event     本次触摸点的手势事件
+     * @param imageView
+     */
+    public void onDrag(float lastX, float lastY, MotionEvent event, ImageView imageView) {
+        if (mMode == DragMode.MODE_SIMPLE) {
+            dragBySimple(lastY, event, imageView);
+        } else if (mMode == DragMode.MODE_AGILE) {
+            dragByAgile(lastX, lastY, event, imageView);
+        }
+    }
+
+    /**
+     * 手指抬起
+     */
+    public void onUp(ImageView imageView, ViewData viewData, ImageTransfer.OnTransCallback callback) {
+        final float transY = imageView.getTranslationY();
+        mTransfer.with(imageView)
+                .background(mBackground)
+                .duration(ANIM_DURATION);
+        // 执行复原动画
+        if (Math.abs(transY) <= MAX_MOVABLE_DIS_ON_Y) {
+            mAction = ImageTransfer.ACTION_DRAG_RESTORE;
+            mTransfer.loadDragRestoreData()
+                    .callback(callback);
+        }
+        // 执行退场动画
+        else {
+            if (mMode == DragMode.MODE_AGILE) {
+                if (transY < 0) {
+                    mAction = ImageTransfer.ACTION_DRAG_RESTORE;
+                    mTransfer.loadDragRestoreData()
+                            .callback(callback);
+                } else {
+                    mAction = ImageTransfer.ACTION_DRAG_EXIT_AGILE;
+                    mTransfer.loadDragExitDataInAgile(viewData)
+                            .callback(callback);
+                }
+            } else {
+                mAction = ImageTransfer.ACTION_DRAG_EXIT_SIMPLE;
+                mTransfer.loadDragExitDataInSimple(viewData)
+                        .callback(callback);
+            }
+        }
+        mTransfer.play();
+    }
+
+    public int getAction() {
+        return mAction;
+    }
+
+    public void clear() {
+        if (mTransfer != null) {
+            mTransfer = null;
+        }
+    }
+
+    /**
+     * 简单模式拖拽（类似今日头条）
+     */
+    private void dragBySimple(float lastY, MotionEvent event, ImageView imageView) {
+        final float disY = event.getY() - lastY;
+        final float nextY = imageView.getTranslationY() + disY;
+        imageView.setTranslationY(nextY);
+        // 计算背景透明度
+        final float value = Math.abs(nextY) / ALPHA_BASE;
+        transformBgAlpha((int) ((value < 0.8f ? 1 - value : 0.2f) * FULL_ALPHA));
+    }
+
+
+    /**
+     * 灵巧模式拖拽（类似微信朋友圈）
+     */
+    private void dragByAgile(float lastX, float lastY, MotionEvent event, ImageView imageView) {
+        // 手指的移动距离
+        final float disX = event.getX() - lastX;
+        final float disY = event.getY() - lastY;
+        // imageView 被拖拽后的坐标
+        final float nextX = imageView.getTranslationX() + disX;
+        final float nextY = imageView.getTranslationY() + disY;
+        // 向上移动
+        if (nextY <= 0) {
+            if (imageView.getLayoutParams().width != mIfWidth ||
+                    imageView.getLayoutParams().height != mIfHeight) {
+                imageView.getLayoutParams().width = mIfWidth;
+                imageView.getLayoutParams().height = mIfHeight;
+                imageView.requestLayout();
+            }
+            transformBgAlpha(FULL_ALPHA);
+        }
+        // 向下移动
+        else {
+            // 计算缩放比例
+            final float scale = Math.min(Math.max(1f - nextY / mIfHeight, MIN_SCALE), 1f);
+            imageView.getLayoutParams().width = (int) (mIfWidth * scale);
+            imageView.getLayoutParams().height = (int) (mIfHeight * scale);
+            imageView.requestLayout();
+            // 变换背景透明度
+            transformBgAlpha((int) (scale * FULL_ALPHA));
+        }
+        imageView.setTranslationX(nextX);
+        imageView.setTranslationY(nextY);
+    }
+
+    /**
+     * 变换背景透明度
+     */
+    private void transformBgAlpha(int alpha) {
+        if (mBackground != null && mBackground.getAlpha() != alpha) {
+            mBackground.setAlpha(alpha);
+        }
+    }
+
+}
+package com.cnlive.core.imagepreview.dragger;
+
+/**
+ * created by hanyayun
+ * on 2020/1/20
+ */
+public class DragMode {
+    // 简单拖拽模式
+    public final static int MODE_SIMPLE = 1;
+    // 灵巧的拖拽模式
+    public final static int MODE_AGILE = 2;
+}
+package com.cnlive.core.imagepreview.dragger;
+
+/**
+ * created by hanyayun
+ * on 2020/1/20
+ */
+public class DragStatus {
+    /**
+     * 准备开始拖拽
+     */
+    public static final int STATUS_READY = 1;
+    /**
+     * 正在拖拽中
+     */
+    public static final int STATUS_DRAGGING = 2;
+    /**
+     * 开始执行复原动画
+     */
+    public static final int STATUS_BEGIN_RESTORE = 3;
+    /**
+     * 复原动画执行中
+     */
+    public static final int STATUS_RESTORING = 4;
+    /**
+     * 复原动画执行完毕
+     */
+    public static final int STATUS_COMPLETE_RESTORE = 5;
+    /**
+     * 开始执行退出浏览动画
+     */
+    public static final int STATUS_BEGIN_EXIT = 6;
+    /**
+     * 退出浏览动画执行中
+     */
+    public static final int STATUS_EXITTING = 7;
+    /**
+     * 退出浏览动画执行完毕
+     */
+    public static final int STATUS_COMPLETE_EXIT = 8;
+}
+package com.cnlive.core.imagepreview.indexui;
+
+import android.content.Context;
+import android.graphics.Color;
+import android.util.TypedValue;
+import android.view.Gravity;
+import android.view.View;
+import android.widget.FrameLayout;
+import android.widget.TextView;
+
+import com.cnlive.core.imagepreview.Utils;
+
+/**
+ * 默认的索引视图
+ * created by hanyayun
+ * on 2020/1/20
+ */
+public class DefaultIndexUI extends IndexUI {
+    private boolean overlayStatusBar;
+
+    public DefaultIndexUI(boolean overlayStatusBar) {
+        this.overlayStatusBar = overlayStatusBar;
+    }
+
+    @Override
+    public View createView(Context context) {
+        TextView indexView = new TextView(context);
+        FrameLayout.LayoutParams textParams = new FrameLayout.LayoutParams(
+                FrameLayout.LayoutParams.WRAP_CONTENT,
+                FrameLayout.LayoutParams.WRAP_CONTENT);
+        textParams.setMargins(0,
+                Utils.dp2px(context, overlayStatusBar ? Utils.getStatusBarHeight(context) + 5 : 5),
+                0, 0);
+        textParams.gravity = Gravity.TOP | Gravity.CENTER_HORIZONTAL;
+        indexView.setLayoutParams(textParams);
+        indexView.setIncludeFontPadding(false);
+        indexView.setTextSize(TypedValue.COMPLEX_UNIT_SP, 16);
+        indexView.setTextColor(Color.WHITE);
+        return indexView;
+    }
+
+    @Override
+    public void init(int position, int length) {
+        ((TextView) getIndexView()).setText((position + 1) + "/" + length);
+    }
+
+    @Override
+    public void handleItemChanged(int position, int length) {
+        ((TextView) getIndexView()).setText((position + 1) + "/" + length);
+    }
+}
+package com.cnlive.core.imagepreview.indexui;
+
+import android.content.Context;
+import android.graphics.Color;
+import android.view.Gravity;
+import android.view.View;
+import android.widget.FrameLayout;
+
+import com.cnlive.core.imagepreview.Utils;
+import com.cnlive.core.imagepreview.uti.ProgressWheel;
+
+import java.text.DecimalFormat;
+
+import static android.view.View.VISIBLE;
+
+/**
+ * 默认的加载进度视图
+ * created by hanyayun
+ * on 2020/1/20
+ */
+public class DefaultProgressUI extends ProgressUI{
+    private DecimalFormat mProgressFormat;
+
+    public DefaultProgressUI() {
+        mProgressFormat = new DecimalFormat("#%");
+    }
+    @Override
+    public View createView(Context context) {
+        // 添加进度条
+        ProgressWheel progressView = new ProgressWheel(context);
+        final int size = Utils.dp2px(context, 60);
+        FrameLayout.LayoutParams barLp = new FrameLayout.LayoutParams(size, size);
+        barLp.gravity = Gravity.CENTER;
+        progressView.setLayoutParams(barLp);
+        final int barWidth = Utils.dp2px(context, 3);
+        progressView.setBarColor(Color.parseColor("#CCFFFFFF"));
+        progressView.setBarWidth(barWidth);
+        progressView.setBarLength(Utils.dp2px(context, 50));
+        progressView.setRimColor(Color.parseColor("#22FFFFFF"));
+        progressView.setRimWidth(barWidth);
+        progressView.setContourColor(Color.parseColor("#10000000"));
+        progressView.setSpinSpeed(3.5f);
+        progressView.setText("");
+        progressView.setTextColor(Color.parseColor("#CCFFFFFF"));
+        progressView.setTextSize(Utils.dp2px(context, 14));
+        return progressView;
+    }
+
+    @Override
+    public void handleProgress(float progress) {
+        if (getProgressView().getVisibility() == VISIBLE) {
+            ((ProgressWheel) getProgressView()).setText(mProgressFormat.format(progress));
+            ((ProgressWheel) getProgressView()).setProgress((int) (progress * 360));
+            if (progress == 1f) {
+                stop();
+            }
+        }
+    }
+
+    @Override
+    public void start() {
+        super.start();
+        ((ProgressWheel) getProgressView()).startSpinning();
+    }
+
+    @Override
+    public void stop() {
+        super.stop();
+        ((ProgressWheel) getProgressView()).stopSpinning();
+    }
+}
+package com.cnlive.core.imagepreview.indexui;
+
+import android.content.Context;
+import android.view.View;
+import android.view.ViewGroup;
+
+import androidx.annotation.NonNull;
+
+/**
+ * 索引视图基类
+ * created by hanyayun
+ * on 2020/1/20
+ */
+public abstract class IndexUI {
+    private View indexView;
+
+    /**
+     * 创建索引视图
+     */
+    public abstract View createView(Context context);
+
+    /**
+     * 初始设置
+     */
+    public abstract void init(int position, int length);
+
+    /**
+     * 处理 item 切换事件
+     */
+    public abstract void handleItemChanged(int position, int length);
+
+    public void setup(@NonNull ViewGroup parent, int startPosition, int length) {
+        if (indexView == null) {
+            indexView = createView(parent.getContext());
+        }
+        if (indexView.getParent() == null) {
+            parent.addView(indexView);
+        }
+        init(startPosition, length);
+        show();
+    }
+
+    /**
+     * 显示索引
+     */
+    public void show() {
+        if (indexView != null) {
+            indexView.setVisibility(View.VISIBLE);
+        }
+    }
+
+    /**
+     * 隐藏索引
+     */
+    public void hide() {
+        if (indexView != null) {
+            indexView.setVisibility(View.GONE);
+        }
+    }
+
+    public View getIndexView() {
+        return indexView;
+    }
+}
+package com.cnlive.core.imagepreview.indexui;
+
+import android.content.Context;
+import android.view.View;
+import android.view.ViewGroup;
+
+/**
+ * created by hanyayun
+ * on 2020/1/20
+ */
+public abstract class ProgressUI {
+    private View progressView;
+
+    /**
+     * 创建加载进度视图
+     */
+    public abstract View createView(Context context);
+
+    /**
+     * 处理进度
+     *
+     * @param progress 范围: 0-1
+     */
+    public abstract void handleProgress(float progress);
+
+    public void init(ViewGroup parent) {
+        if (progressView == null) {
+            progressView = createView(parent.getContext());
+        }
+        if (progressView.getParent() == null) {
+            parent.addView(progressView);
+        }
+    }
+
+    public void start() {
+        if (progressView != null) {
+            progressView.setVisibility(View.VISIBLE);
+        }
+    }
+
+    public void stop() {
+        if (progressView != null) {
+            progressView.setVisibility(View.GONE);
+        }
+    }
+
+    public View getProgressView() {
+        return progressView;
+    }
+}
+package com.cnlive.core.imagepreview.listener;
+
+/**
+ * 图片状态的监听事件
+ * created by hanyayun
+ * on 2020/1/20
+ */
+public interface OnBrowseStatusListener {
+
+    /**
+     * 监听图片预览的当前状态
+     */
+    void onBrowseStatus(int status);
+}
+package com.cnlive.core.imagepreview.listener;
+
+/**
+ * 监听图片被拖拽时的状态
+ * created by hanyayun
+ * on 2020/1/20
+ */
+public interface OnDragStatusListener {
+    /**
+     * 监听图片拖拽的状态
+     */
+    void onDragStatusChanged(int status);
+}
+package com.cnlive.core.imagepreview.listener;
+
+import com.cnlive.core.imagepreview.ImageDrawee;
+
+/**
+ * 图片item 的切换事件
+ * created by hanyayun
+ * on 2020/1/20
+ */
+public interface OnItemChangedListener {
+
+    void onItemChanged(int position, ImageDrawee drawee);
+}
+package com.cnlive.core.imagepreview.listener;
+
+import android.widget.ImageView;
+
+/**
+ * 图片单击事件
+ * created by hanyayun
+ * on 2020/1/20
+ */
+public interface OnItemClickListener {
+    /**
+     * @param position
+     * @param imageView
+     * @return {@code true}: 消费了点击事件，后续方法不再执行 {@code false}: 没有消费点击事件，后续方法继续执行
+     */
+    boolean onItemClick(int position, ImageView imageView);
+}
+package com.cnlive.core.imagepreview.listener;
+
+import android.widget.ImageView;
+
+/**
+ * 图片长按
+ * created by hanyayun
+ * on 2020/1/20
+ */
+public interface OnItemLongPressListener {
+
+    boolean onItemLongPress(int position, ImageView imageView);
+}
+package com.cnlive.core.imagepreview.uti;
+
+import android.content.Context;
+import android.content.res.TypedArray;
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.graphics.RectF;
+import android.graphics.Shader;
+import android.util.AttributeSet;
+import android.view.View;
+
+import com.cnlive.core.imageload.R;
+
+/**
+ * created by hanyayun
+ * on 2020/1/20
+ */
+public class ProgressWheel extends View {
+    // Sizes (with defaults)
+    private int layoutHeight = 0;
+    private int layoutWidth = 0;
+    private int fullRadius = 100;
+    private int circleRadius = 80;
+    private int barLength = 60;
+    private int barWidth = 20;
+    private int rimWidth = 20;
+    private int textSize = 20;
+    private float contourSize = 0;
+
+    // Padding (with defaults)
+    private int paddingTop = 5;
+    private int paddingBottom = 5;
+    private int paddingLeft = 5;
+    private int paddingRight = 5;
+
+    // Colors (with defaults)
+    private int barColor = 0xAA000000;
+    private int contourColor = 0xAA000000;
+    private int circleColor = 0x00000000;
+    private int rimColor = 0xAADDDDDD;
+    private int textColor = 0xFF000000;
+
+    // Paints
+    private Paint barPaint = new Paint();
+    private Paint circlePaint = new Paint();
+    private Paint rimPaint = new Paint();
+    private Paint textPaint = new Paint();
+    private Paint contourPaint = new Paint();
+
+    // Rectangles
+    private RectF innerCircleBounds = new RectF();
+    private RectF circleBounds = new RectF();
+    private RectF circleOuterContour = new RectF();
+    private RectF circleInnerContour = new RectF();
+
+    // Animation
+    // The amount of pixels to move the bar by on each draw
+    private float spinSpeed = 2f;
+    // The number of milliseconds to wait in between each draw
+    private int delayMillis = 10;
+    private float progress = 0;
+    boolean isSpinning = false;
+
+    // Other
+    private String text = "";
+    private String[] splitText = {};
+
+    public ProgressWheel(Context context){
+        super(context);
+    }
+
+    /**
+     * The constructor for the ProgressWheel
+     *
+     * @param context
+     * @param attrs
+     */
+    public ProgressWheel(Context context, AttributeSet attrs) {
+        super(context, attrs);
+        parseAttributes(context.obtainStyledAttributes(attrs, R.styleable.ivr_ProgressWheel));
+    }
+
+    /*
+     * When this is called, make the view square.
+     * From: http://www.jayway.com/2012/12/12/creating-custom-android-views-part-4-measuring-and-how-to-force-a-view-to-be-square/
+     *
+     */
+    @Override
+    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+        // The first thing that happen is that we call the superclass
+        // implementation of onMeasure. The reason for that is that measuring
+        // can be quite a complex process and calling the super method is a
+        // convenient way to get most of this complexity handled.
+        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
+
+        // We can’t use getWidth() or getHight() here. During the measuring
+        // pass the view has not gotten its final size yet (this happens first
+        // at the watch of the layout pass) so we have to use getMeasuredWidth()
+        // and getMeasuredHeight().
+        int size = 0;
+        int width = getMeasuredWidth();
+        int height = getMeasuredHeight();
+        int widthWithoutPadding = width - getPaddingLeft() - getPaddingRight();
+        int heightWithoutPadding = height - getPaddingTop() - getPaddingBottom();
+
+        // Finally we have some simple logic that calculates the size of the view
+        // and calls setMeasuredDimension() to set that size.
+        // Before we compare the width and height of the view, we remove the padding,
+        // and when we set the dimension we add it back again. Now the actual content
+        // of the view will be square, but, depending on the padding, the total dimensions
+        // of the view might not be.
+        int heightMode = MeasureSpec.getMode(heightMeasureSpec);
+        int widthMode = MeasureSpec.getMode(widthMeasureSpec);
+        if (heightMode != MeasureSpec.UNSPECIFIED && widthMode != MeasureSpec.UNSPECIFIED) {
+            if (widthWithoutPadding > heightWithoutPadding) {
+                size = heightWithoutPadding;
+            } else {
+                size = widthWithoutPadding;
+            }
+        } else {
+            size = Math.max(heightWithoutPadding, widthWithoutPadding);
+        }
+
+
+        // If you override onMeasure() you have to call setMeasuredDimension().
+        // This is how you report back the measured size.  If you don’t call
+        // setMeasuredDimension() the parent will throw an exception and your
+        // application will crash.
+        // We are calling the onMeasure() method of the superclass so we don’t
+        // actually need to call setMeasuredDimension() since that takes care
+        // of that. However, the purpose with overriding onMeasure() was to
+        // change the default behaviour and to do that we need to call
+        // setMeasuredDimension() with our own values.
+        setMeasuredDimension(
+                size + getPaddingLeft() + getPaddingRight(),
+                size + getPaddingTop() + getPaddingBottom());
+    }
+
+    /**
+     * Use onSizeChanged instead of onAttachedToWindow to get the dimensions of the view,
+     * because this method is called after measuring the dimensions of MATCH_PARENT & WRAP_CONTENT.
+     * Use this dimensions to setup the bounds and paints.
+     */
+    @Override
+    protected void onSizeChanged(int newWidth, int newHeight, int oldWidth, int oldHeight) {
+        super.onSizeChanged(newWidth, newHeight, oldWidth, oldHeight);
+        layoutWidth = newWidth;
+        layoutHeight = newHeight;
+        setupBounds();
+        setupPaints();
+        invalidate();
+    }
+
+    /**
+     * Set the properties of the paints we're using to
+     * draw the progress wheel
+     */
+    private void setupPaints() {
+        barPaint.setColor(barColor);
+        barPaint.setAntiAlias(true);
+        barPaint.setStyle(Paint.Style.STROKE);
+        barPaint.setStrokeWidth(barWidth);
+
+        rimPaint.setColor(rimColor);
+        rimPaint.setAntiAlias(true);
+        rimPaint.setStyle(Paint.Style.STROKE);
+        rimPaint.setStrokeWidth(rimWidth);
+
+        circlePaint.setColor(circleColor);
+        circlePaint.setAntiAlias(true);
+        circlePaint.setStyle(Paint.Style.FILL);
+
+        textPaint.setColor(textColor);
+        textPaint.setStyle(Paint.Style.FILL);
+        textPaint.setAntiAlias(true);
+        textPaint.setTextSize(textSize);
+
+        contourPaint.setColor(contourColor);
+        contourPaint.setAntiAlias(true);
+        contourPaint.setStyle(Paint.Style.STROKE);
+        contourPaint.setStrokeWidth(contourSize);
+    }
+
+    /**
+     * Set the bounds of the component
+     */
+    private void setupBounds() {
+        // Width should equal to Height, find the min value to setup the circle
+        int minValue = Math.min(layoutWidth, layoutHeight);
+
+        // Calc the Offset if needed
+        int xOffset = layoutWidth - minValue;
+        int yOffset = layoutHeight - minValue;
+
+        // Add the offset
+        paddingTop = this.getPaddingTop() + (yOffset / 2);
+        paddingBottom = this.getPaddingBottom() + (yOffset / 2);
+        paddingLeft = this.getPaddingLeft() + (xOffset / 2);
+        paddingRight = this.getPaddingRight() + (xOffset / 2);
+
+        int width = getWidth();
+        int height = getHeight();
+
+        innerCircleBounds = new RectF(
+                paddingLeft + (1.5f * barWidth),
+                paddingTop + (1.5f * barWidth),
+                width - paddingRight - (1.5f * barWidth),
+                height - paddingBottom - (1.5f * barWidth));
+        circleBounds = new RectF(
+                paddingLeft + barWidth,
+                paddingTop + barWidth,
+                width - paddingRight - barWidth,
+                height - paddingBottom - barWidth);
+        circleInnerContour = new RectF(
+                circleBounds.left + (rimWidth / 2.0f) + (contourSize / 2.0f),
+                circleBounds.top + (rimWidth / 2.0f) + (contourSize / 2.0f),
+                circleBounds.right - (rimWidth / 2.0f) - (contourSize / 2.0f),
+                circleBounds.bottom - (rimWidth / 2.0f) - (contourSize / 2.0f));
+        circleOuterContour = new RectF(
+                circleBounds.left - (rimWidth / 2.0f) - (contourSize / 2.0f),
+                circleBounds.top - (rimWidth / 2.0f) - (contourSize / 2.0f),
+                circleBounds.right + (rimWidth / 2.0f) + (contourSize / 2.0f),
+                circleBounds.bottom + (rimWidth / 2.0f) + (contourSize / 2.0f));
+
+        fullRadius = (width - paddingRight - barWidth) / 2;
+        circleRadius = (fullRadius - barWidth) + 1;
+    }
+
+    /**
+     * Parse the attributes passed to the view from the XML
+     *
+     * @param a the attributes to parse
+     */
+    private void parseAttributes(TypedArray a) {
+        barColor = a.getColor(R.styleable.ivr_ProgressWheel_pwBarColor, barColor);
+        barWidth = (int) a.getDimension(R.styleable.ivr_ProgressWheel_pwBarWidth, barWidth);
+        barLength = (int) a.getDimension(R.styleable.ivr_ProgressWheel_pwBarLength, barLength);
+        rimColor = a.getColor(R.styleable.ivr_ProgressWheel_pwRimColor, rimColor);
+        rimWidth = (int) a.getDimension(R.styleable.ivr_ProgressWheel_pwRimWidth, rimWidth);
+        contourColor = a.getColor(R.styleable.ivr_ProgressWheel_pwContourColor, contourColor);
+        contourSize = a.getDimension(R.styleable.ivr_ProgressWheel_pwContourSize, contourSize);
+        circleColor = a.getColor(R.styleable.ivr_ProgressWheel_pwCircleColor, circleColor);
+
+        // Only set the text if it is explicitly defined
+        if (a.hasValue(R.styleable.ivr_ProgressWheel_pwText)) {
+            setText(a.getString(R.styleable.ivr_ProgressWheel_pwText));
+        }
+        textColor = a.getColor(R.styleable.ivr_ProgressWheel_pwTextColor, textColor);
+        textSize = (int) a.getDimension(R.styleable.ivr_ProgressWheel_pwTextSize, textSize);
+
+        spinSpeed = a.getFloat(R.styleable.ivr_ProgressWheel_pwSpinSpeed, spinSpeed);
+        delayMillis = a.getInteger(R.styleable.ivr_ProgressWheel_pwDelayMillis, delayMillis);
+        if (delayMillis < 0) {
+            delayMillis = 10;
+        }
+        a.recycle();
+    }
+
+    //----------------------------------
+    //Animation stuff
+    //----------------------------------
+
+    protected void onDraw(Canvas canvas) {
+        super.onDraw(canvas);
+        //Draw the inner circle
+        canvas.drawArc(innerCircleBounds, 360, 360, false, circlePaint);
+        //Draw the rim
+        canvas.drawArc(circleBounds, 360, 360, false, rimPaint);
+        canvas.drawArc(circleOuterContour, 360, 360, false, contourPaint);
+        //canvas.drawArc(circleInnerContour, 360, 360, false, contourPaint);
+        //Draw the bar
+        if (isSpinning) {
+            canvas.drawArc(circleBounds, progress - 90, barLength, false, barPaint);
+        } else {
+            canvas.drawArc(circleBounds, -90, progress, false, barPaint);
+        }
+        //Draw the text (attempts to center it horizontally and vertically)
+        float textHeight = textPaint.descent() - textPaint.ascent();
+        float verticalTextOffset = (textHeight / 2) - textPaint.descent();
+
+        for (String line : splitText) {
+            float horizontalTextOffset = textPaint.measureText(line) / 2;
+            canvas.drawText(
+                    line,
+                    this.getWidth() / 2 - horizontalTextOffset,
+                    this.getHeight() / 2 + verticalTextOffset,
+                    textPaint);
+        }
+        if (isSpinning) {
+            scheduleRedraw();
+        }
+    }
+
+    private void scheduleRedraw() {
+        progress += spinSpeed;
+        if (progress > 360) {
+            progress = 0;
+        }
+        postInvalidateDelayed(delayMillis);
+    }
+
+    /**
+     * Check if the wheel is currently spinning
+     */
+    public boolean isSpinning() {
+        return isSpinning;
+    }
+
+    /**
+     * Reset the count (in increment mode)
+     */
+    public void resetCount() {
+        progress = 0;
+        setText("0%");
+        invalidate();
+    }
+
+    /**
+     * Turn off startSpinning mode
+     */
+    public void stopSpinning() {
+        isSpinning = false;
+        progress = 0;
+        postInvalidate();
+    }
+
+
+    /**
+     * Puts the view on spin mode
+     */
+    public void startSpinning() {
+        isSpinning = true;
+        postInvalidate();
+    }
+
+    /**
+     * Increment the progress by 1 (of 360)
+     */
+    public void incrementProgress() {
+        incrementProgress(1);
+    }
+
+    public void incrementProgress(int amount) {
+        isSpinning = false;
+        progress += amount;
+        if (progress > 360)
+            progress %= 360;
+        postInvalidate();
+    }
+
+
+    /**
+     * Set the progress to a specific value
+     */
+    public void setProgress(int i) {
+        isSpinning = false;
+        progress = i;
+        postInvalidate();
+    }
+
+    //----------------------------------
+    //Getters + setters
+    //----------------------------------
+
+    /**
+     * Set the text in the progress bar
+     * Doesn't invalidate the view
+     *
+     * @param text the text to show ('\n' constitutes a new line)
+     */
+    public void setText(String text) {
+        this.text = text;
+        splitText = this.text.split("\n");
+    }
+
+    public int getCircleRadius() {
+        return circleRadius;
+    }
+
+    public void setCircleRadius(int circleRadius) {
+        this.circleRadius = circleRadius;
+    }
+
+    public int getBarLength() {
+        return barLength;
+    }
+
+    public void setBarLength(int barLength) {
+        this.barLength = barLength;
+    }
+
+    public int getBarWidth() {
+        return barWidth;
+    }
+
+    public void setBarWidth(int barWidth) {
+        this.barWidth = barWidth;
+
+        if (this.barPaint != null) {
+            this.barPaint.setStrokeWidth(this.barWidth);
+        }
+    }
+
+    public int getTextSize() {
+        return textSize;
+    }
+
+    public void setTextSize(int textSize) {
+        this.textSize = textSize;
+
+        if (this.textPaint != null) {
+            this.textPaint.setTextSize(this.textSize);
+        }
+    }
+
+    public int getPaddingTop() {
+        return paddingTop;
+    }
+
+    public void setPaddingTop(int paddingTop) {
+        this.paddingTop = paddingTop;
+    }
+
+    public int getPaddingBottom() {
+        return paddingBottom;
+    }
+
+    public void setPaddingBottom(int paddingBottom) {
+        this.paddingBottom = paddingBottom;
+    }
+
+    public int getPaddingLeft() {
+        return paddingLeft;
+    }
+
+    public void setPaddingLeft(int paddingLeft) {
+        this.paddingLeft = paddingLeft;
+    }
+
+    public int getPaddingRight() {
+        return paddingRight;
+    }
+
+    public void setPaddingRight(int paddingRight) {
+        this.paddingRight = paddingRight;
+    }
+
+    public int getBarColor() {
+        return barColor;
+    }
+
+    public void setBarColor(int barColor) {
+        this.barColor = barColor;
+
+        if (this.barPaint != null) {
+            this.barPaint.setColor(this.barColor);
+        }
+    }
+
+    public int getCircleColor() {
+        return circleColor;
+    }
+
+    public void setCircleColor(int circleColor) {
+        this.circleColor = circleColor;
+
+        if (this.circlePaint != null) {
+            this.circlePaint.setColor(this.circleColor);
+        }
+    }
+
+    public int getRimColor() {
+        return rimColor;
+    }
+
+    public void setRimColor(int rimColor) {
+        this.rimColor = rimColor;
+
+        if (this.rimPaint != null) {
+            this.rimPaint.setColor(this.rimColor);
+        }
+    }
+
+    public Shader getRimShader() {
+        return rimPaint.getShader();
+    }
+
+    public void setRimShader(Shader shader) {
+        this.rimPaint.setShader(shader);
+    }
+
+    public int getTextColor() {
+        return textColor;
+    }
+
+    public void setTextColor(int textColor) {
+        this.textColor = textColor;
+
+        if (this.textPaint != null) {
+            this.textPaint.setColor(this.textColor);
+        }
+    }
+
+    public float getSpinSpeed() {
+        return spinSpeed;
+    }
+
+    public void setSpinSpeed(float spinSpeed) {
+        this.spinSpeed = spinSpeed;
+    }
+
+    public int getRimWidth() {
+        return rimWidth;
+    }
+
+    public void setRimWidth(int rimWidth) {
+        this.rimWidth = rimWidth;
+
+        if (this.rimPaint != null) {
+            this.rimPaint.setStrokeWidth(this.rimWidth);
+        }
+    }
+
+    public int getDelayMillis() {
+        return delayMillis;
+    }
+
+    public void setDelayMillis(int delayMillis) {
+        this.delayMillis = delayMillis;
+    }
+
+    public int getContourColor() {
+        return contourColor;
+    }
+
+    public void setContourColor(int contourColor) {
+        this.contourColor = contourColor;
+
+        if (contourPaint != null) {
+            this.contourPaint.setColor(this.contourColor);
+        }
+    }
+
+    public float getContourSize() {
+        return this.contourSize;
+    }
+
+    public void setContourSize(float contourSize) {
+        this.contourSize = contourSize;
+
+        if (contourPaint != null) {
+            this.contourPaint.setStrokeWidth(this.contourSize);
+        }
+    }
+
+    public int getProgress() {
+        return (int) progress;
+    }
+}
+package com.cnlive.core.imagepreview.viewpager;
+
+import android.view.View;
+import android.view.ViewGroup;
+
+import com.cnlive.core.imagepreview.ImageDrawee;
+
+import androidx.annotation.NonNull;
+import androidx.viewpager.widget.PagerAdapter;
+
+/**
+ * created by hanyayun
+ * on 2020/1/20
+ */
+public class ImagePagerAdapter extends PagerAdapter {
+    private int mItemCount;
+
+    public ImagePagerAdapter(int count) {
+        this.mItemCount = count;
+    }
+
+    @Override
+    public int getCount() {
+        return mItemCount;
+    }
+
+    @NonNull
+    @Override
+    public Object instantiateItem(@NonNull ViewGroup container, int position) {
+        return null;
+    }
+
+    @Override
+    public void destroyItem(@NonNull ViewGroup container, int position, @NonNull Object object) {
+        if (object != null) {
+            ((ImageDrawee) object).recycle();
+            // 移除页面
+            container.removeView((View) object);
+        }
+    }
+
+    @Override
+    public boolean isViewFromObject(@NonNull View view, @NonNull Object object) {
+        return view == object;
+    }
+}
+
+package com.cnlive.core.imagepreview.viewpager;
+
+import android.content.Context;
+import android.util.AttributeSet;
+import android.view.MotionEvent;
+
+import androidx.viewpager.widget.ViewPager;
+
+/**
+ * 预览器 ViewPager
+ * created by hanyayun
+ * on 2020/1/20
+ */
+public class ImageViewPager extends ViewPager {
+    // 是否可滑动
+    private boolean isScrollable = true;
+
+    public ImageViewPager(Context context) {
+        super(context);
+    }
+
+    public ImageViewPager(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    @Override
+    public void scrollTo(int x, int y) {
+        if (isScrollable) {
+            super.scrollTo(x, y);
+        }
+    }
+
+    /**
+     * 设置是否可滑动
+     *
+     * @param isScrollable
+     */
+    public void setScrollable(boolean isScrollable) {
+        this.isScrollable = isScrollable;
+    }
+
+    /**
+     * 重写 onInterceptTouchEvent 和 onTouchEvent 方法是为了解决
+     * PhotoView + Viewpager 双指缩放的时候出现 pointerIndex out of range 问题
+     */
+
+    @Override
+    public boolean onInterceptTouchEvent(MotionEvent ev) {
+        try {
+            return   super.onInterceptTouchEvent(ev);
+        } catch   (IllegalArgumentException ex) {
+            ex.printStackTrace();
+        }
+        return false;
+    }
+
+    @Override
+    public boolean onTouchEvent(MotionEvent   ev) {
+        try {
+            return   super.onTouchEvent(ev);
+        } catch   (IllegalArgumentException ex) {
+            ex.printStackTrace();
+        }
+        return false;
+    }
+}
 \ No newline at end of file
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:orientation="vertical">
+
+    <ImageView
+        android:id="@+id/iv_auto_grid_item_simple_pic"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:scaleType="centerCrop" />
+</LinearLayout>
 \ No newline at end of file
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:orientation="vertical">
+
+    <ImageView
+        android:id="@+id/iv_auto_grid_item_simple_pic"
+        android:layout_width="200dp"
+        android:layout_height="wrap_content"
+        android:adjustViewBounds="true" />
+</LinearLayout>
 \ No newline at end of file
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <!--网格控件-->
+    <declare-styleable name="AutoGridView">
+        <!--网格图的类型-->
+        <attr name="agv_mode">
+            <!--类似QQ空间、微信朋友圈的九宫格类型网格图-->
+            <enum name="nine" value="0" />
+            <!--依次显示网格的普通类型网格图-->
+            <enum name="normal" value="1" />
+        </attr>
+        <!--网格的行数-->
+        <attr name="agv_row" format="integer" />
+        <!--网格的列数-->
+        <attr name="agv_column" format="integer" />
+        <!--item 的高度-->
+        <attr name="agv_item_height" format="dimension" />
+        <!--item 之间的横向间距-->
+        <attr name="agv_horizontal_space" format="dimension" />
+        <!--item 之间的纵向间距-->
+        <attr name="agv_vertical_space" format="dimension" />
+        <!--九宫格模式下，单个 item 时，item 的宽与 parent 的可用总宽的比-->
+        <attr name="agv_nines_widthper" format="float" />
+        <!--九宫格模式下，单个 item 时，item 的高与 parent 的可用总宽的比-->
+        <attr name="agv_nines_heightper" format="float" />
+    </declare-styleable>
+</resources>
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <declare-styleable name="ImagePreView">
+        <!--是否开启进场动画-->
+        <attr name="ivr_playEnterAnim" format="boolean" />
+        <!--是否开启退场动画-->
+        <attr name="ivr_playExitAnim" format="boolean" />
+        <!--进场与退场动画的执行时间-->
+        <attr name="ivr_duration" format="integer" />
+        <!--是否显示图片位置-->
+        <attr name="ivr_showIndex" format="boolean" />
+        <!--是否允许图片拖拽-->
+        <attr name="ivr_draggable" format="boolean" />
+        <!--拖拽模式-->
+        <attr name="ivr_dragMode">
+            <enum name="simple" value="1" />
+            <enum name="agile" value="2" />
+        </attr>
+    </declare-styleable>
+</resources>
 \ No newline at end of file
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <declare-styleable name="ivr_ProgressWheel">
+        <attr name="pwText" format="string" />
+        <attr name="pwTextColor" format="color" />
+        <attr name="pwTextSize" format="dimension" />
+        <attr name="pwBarColor" format="color" />
+        <attr name="pwBarWidth" format="dimension" />
+        <attr name="pwBarLength" format="dimension" />
+        <attr name="pwRimColor" format="color" />
+        <attr name="pwRimWidth" format="dimension" />
+        <attr name="pwContourColor" format="color" />
+        <attr name="pwContourSize" format="dimension" />
+        <attr name="pwRadius" format="dimension" />
+        <attr name="pwCircleColor" format="color" />
+        <attr name="pwSpinSpeed" format="float" />
+        <attr name="pwDelayMillis" format="integer" />
+    </declare-styleable>
+</resources>
 \ No newline at end of file