Initial commit

services/mogo-service-api/.gitignore

@@ -0,0 +1 @@
+/build

services/mogo-service-api/build.gradle

@@ -0,0 +1,38 @@
+apply plugin: 'com.android.library'
+
+android {
+    compileSdkVersion 29
+    buildToolsVersion "29.0.2"
+
+
+    defaultConfig {
+        minSdkVersion 19
+        targetSdkVersion 29
+        versionCode 1
+        versionName "1.0"
+
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+        consumerProguardFiles 'consumer-rules.pro'
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+        }
+    }
+
+}
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+
+    implementation 'androidx.appcompat:appcompat:1.0.2'
+    testImplementation 'junit:junit:4.12'
+    androidTestImplementation 'androidx.test.ext:junit:1.1.0'
+    androidTestImplementation 'androidx.test.espresso:espresso-core:3.1.1'
+
+    implementation project(":libraries:mogo-map")
+    implementation rootProject.ext.dependencies.arouter
+    api rootProject.ext.dependencies.fresco
+}

services/mogo-service-api/proguard-rules.pro

@@ -0,0 +1,21 @@
+# Add project specific ProGuard rules here.
+# You can control the set of applied configuration files using the
+# proguardFiles setting in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile

services/mogo-service-api/src/androidTest/java/com/mogo/service/map/ExampleInstrumentedTest.java

@@ -0,0 +1,27 @@
+package com.mogo.service.map;
+
+import android.content.Context;
+
+import androidx.test.platform.app.InstrumentationRegistry;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static org.junit.Assert.*;
+
+/**
+ * Instrumented test, which will execute on an Android device.
+ *
+ * @see <a href="http://d.android.com/tools/testing">Testing documentation</a>
+ */
+@RunWith( AndroidJUnit4.class )
+public class ExampleInstrumentedTest {
+    @Test
+    public void useAppContext() {
+        // Context of the app under test.
+        Context appContext = InstrumentationRegistry.getInstrumentation().getTargetContext();
+
+        assertEquals( "com.mogo.service.amap.test", appContext.getPackageName() );
+    }
+}

services/mogo-service-api/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.mogo.service" />

services/mogo-service-api/src/main/java/com/mogo/service/MogoServicePaths.java

@@ -0,0 +1,25 @@
+package com.mogo.service;
+
+/**
+ * @author congtaowang
+ * @since 2019-12-23
+ * <p>
+ * 对外服务模块路径
+ * <p>
+ * <p>
+ * 使用方式：
+ * <p>
+ * Arouter.getInstance().path("").navigate()
+ */
+public class MogoServicePaths {
+
+    /**
+     * 地图服务接口路径
+     */
+    public static final String PATH_MAP_SERVICE = "/mogo/services/map";
+
+    /**
+     * 图片接口
+     */
+    public static final String PATH_IMAGE_LOADER = "/mogo/utils/imageloader";
+}

services/mogo-service-api/src/main/java/com/mogo/service/imageloader/IMogoImageLoaderListener.java

@@ -0,0 +1,20 @@
+package com.mogo.service.imageloader;
+
+import android.graphics.Bitmap;
+
+/**
+ * @author congtaowang
+ * @since 2019-12-23
+ * <p>
+ * 图片下载接口
+ */
+public interface IMogoImageLoaderListener {
+
+    void onStart();
+
+//    void onProcess( int completedSize, int totalSize );
+
+    void onCompleted( Bitmap bitmap );
+
+    void onFailure( Exception e );
+}

services/mogo-service-api/src/main/java/com/mogo/service/imageloader/IMogoImageloader.java

@@ -0,0 +1,28 @@
+package com.mogo.service.imageloader;
+
+import android.content.Context;
+
+import com.alibaba.android.arouter.facade.template.IProvider;
+
+/**
+ * @author congtaowang
+ * @since 2019-12-23
+ * <p>
+ * 图片接口
+ */
+public interface IMogoImageloader extends IProvider {
+
+    void init( Context context );
+
+    void displayImage( String url, MogoImageView imageView );
+
+    void displayImage( String url, MogoImageView imageView, int width, int height );
+
+    void displayImage( String url, MogoImageView imageView, int width, int height, final IMogoImageLoaderListener listener );
+
+    void displayImage( String url, MogoImageView imageView, final IMogoImageLoaderListener listener );
+
+    void downloadImage( Context context, String url, IMogoImageLoaderListener listener );
+
+    void destroy();
+}

services/mogo-service-api/src/main/java/com/mogo/service/imageloader/MogoImageView.java

@@ -0,0 +1,174 @@
+package com.mogo.service.imageloader;
+
+import android.content.Context;
+import android.content.res.TypedArray;
+import android.graphics.Color;
+import android.graphics.Matrix;
+import android.util.AttributeSet;
+
+import androidx.annotation.DrawableRes;
+
+import com.facebook.drawee.view.GenericDraweeView;
+import com.mogo.service.R;
+
+/**
+ * @author congtaowang
+ * @since 2019-12-23
+ * <p>
+ * 封装 facebook GenericDraweeView，实现占位图、失败占位图、形状、边框、模糊等效果
+ */
+public class MogoImageView extends GenericDraweeView {
+
+    private int mPlaceHolder;
+    private int mFailureHolder;
+    private int mOverlayImageId;
+    private int mShape;
+    private int mRadius;
+    private int mTopLeftRadius;
+    private int mTopRightRadius;
+    private int mBottomLeftRadius;
+    private int mBottomRightRadius;
+    private int mBorderWidth;
+    private int mBorderColor;
+    private int mBlurRadius;
+    private boolean mIsBlur;
+
+    public static final int SHAPE_NORMAL = 0;
+    public static final int SHAPE_CIRCLE = 1;
+    public static final int SHAPE_ROUND = 2;
+
+    public MogoImageView( Context context ) {
+        this( context, null, 0 );
+    }
+
+    public MogoImageView( Context context, AttributeSet attrs ) {
+        this( context, attrs, 0 );
+    }
+
+    public MogoImageView( Context context, AttributeSet attrs, int theme ) {
+        super( context, attrs, theme );
+        TypedArray arrays = context.obtainStyledAttributes( attrs, R.styleable.MogoImageView );
+        mPlaceHolder = arrays.getResourceId( R.styleable.MogoImageView_placeHolder, 0 );
+        mFailureHolder = arrays.getResourceId( R.styleable.MogoImageView_failureHolder, 0 );
+        mOverlayImageId = arrays.getResourceId( R.styleable.MogoImageView_overlayImageId, 0 );
+        mShape = arrays.getInt( R.styleable.MogoImageView_shape, SHAPE_NORMAL );
+        mRadius = arrays.getDimensionPixelSize( R.styleable.MogoImageView_radius, 0 );
+        mTopLeftRadius = arrays.getDimensionPixelSize( R.styleable.MogoImageView_topLeftRadius, 0 );
+        mTopRightRadius = arrays.getDimensionPixelSize( R.styleable.MogoImageView_topRightRadius, 0 );
+        mBottomLeftRadius = arrays.getDimensionPixelSize( R.styleable.MogoImageView_bottomLeftRadius, 0 );
+        mBottomRightRadius = arrays.getDimensionPixelSize( R.styleable.MogoImageView_bottomRightRadius, 0 );
+        mBorderWidth = arrays.getDimensionPixelSize( R.styleable.MogoImageView_shapeBorderWidth, 0 );
+        mBorderColor = arrays.getColor( R.styleable.MogoImageView_borderColor, Color.WHITE );
+        mIsBlur = arrays.getBoolean( R.styleable.MogoImageView_isBlur, false );
+        mBlurRadius = arrays.getInt( R.styleable.MogoImageView_blurRadius, 25 );
+        arrays.recycle();
+    }
+
+    public void setRadius( float radius ) {
+        this.mRadius = ( int ) radius;
+    }
+
+    public void setRadius( int[] radius ) {
+        if ( radius != null && radius.length == 8 ) {
+            mTopLeftRadius = radius[0] >= radius[1] ? radius[0] : radius[1];
+            mTopRightRadius = radius[2] >= radius[3] ? radius[2] : radius[3];
+            mBottomRightRadius = radius[4] >= radius[5] ? radius[4] : radius[5];
+            mBottomLeftRadius = radius[6] >= radius[7] ? radius[6] : radius[7];
+        }
+    }
+
+    public void setShape( int shape ) {
+        this.mShape = shape;
+    }
+
+    public void setBorderWidth( int width ) {
+        this.mBorderWidth = width;
+    }
+
+    public void setBorderColor( int color ) {
+        this.mBorderColor = color;
+    }
+
+    public void setPlaceHolder( int placeHolder ) {
+        this.mPlaceHolder = placeHolder;
+    }
+
+    public void setFailureHolder( int failureHolder ) {
+        this.mFailureHolder = failureHolder;
+    }
+
+    public void setOverlayImageId( @DrawableRes int overlayImageId ) {
+        this.mOverlayImageId = overlayImageId;
+    }
+
+    public void setBlur( boolean isBlur ) {
+        this.mIsBlur = isBlur;
+    }
+
+    public void setBlurRadius( int blurRadius ) {
+        this.mBlurRadius = blurRadius;
+    }
+
+    public int getPlaceHolder() {
+        return mPlaceHolder;
+    }
+
+    public int getFailureHolder() {
+        return mFailureHolder;
+    }
+
+    public int getOverlayImageId() {
+        return mOverlayImageId;
+    }
+
+    public int getShape() {
+        return mShape;
+    }
+
+    public float[] getRadii() {
+        if ( mTopLeftRadius != 0 || mTopRightRadius != 0 || mBottomRightRadius != 0 || mBottomLeftRadius != 0 ) {
+            float[] radii = {mTopLeftRadius, mTopLeftRadius, mTopRightRadius, mTopRightRadius,
+                    mBottomRightRadius, mBottomRightRadius, mBottomLeftRadius, mBottomLeftRadius};
+            return radii;
+        }
+
+        return null;
+    }
+
+    public int getRadius() {
+        return mRadius;
+    }
+
+    public int getBorderWidth() {
+        return mBorderWidth;
+    }
+
+    public int getBorderColor() {
+        return mBorderColor;
+    }
+
+    public boolean isBlur() {
+        return mIsBlur;
+    }
+
+    public int getBlurRadius() {
+        return mBlurRadius;
+    }
+
+    public String getParams() {
+        StringBuilder builder = new StringBuilder();
+        builder.append( mIsBlur ).append( mBlurRadius )
+                .append( mShape ).append( mRadius )
+                .append( mBorderWidth ).append( mBorderColor );
+        return builder.toString();
+    }
+
+    /**
+     * 解决共享动画无效的问题
+     *
+     * @param matrix
+     */
+    public void animateTransform( Matrix matrix ) {
+        invalidate();
+    }
+}

services/mogo-service-api/src/main/java/com/mogo/service/map/IMogoMapService.java

@@ -0,0 +1,64 @@
+package com.mogo.service.map;
+
+import android.content.Context;
+
+import com.alibaba.android.arouter.facade.template.IProvider;
+import com.mogo.map.location.IMogoLocationClient;
+import com.mogo.map.marker.IMogoMarker;
+import com.mogo.map.marker.MogoMarkerOptions;
+import com.mogo.map.search.IMogoGeoSearch;
+import com.mogo.map.search.IMogoInputtipsSearch;
+import com.mogo.map.search.query.MogoInputtipsQuery;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author congtaowang
+ * @since 2019-12-18
+ * <p>
+ * 地图对外地接口
+ */
+public interface IMogoMapService extends IProvider {
+
+    /**
+     * 获取定位服务实例
+     *
+     * @param context
+     * @return
+     */
+    IMogoLocationClient getSingletonLocationClient( Context context );
+
+    /**
+     * 添加marker
+     *
+     * @param options
+     * @return
+     */
+    IMogoMarker addMarker( MogoMarkerOptions options );
+
+    /**
+     * 添加多个marker
+     *
+     * @param options
+     * @return
+     */
+    List< IMogoMarker > addMarkers( ArrayList< MogoMarkerOptions > options, boolean moveToCenter );
+
+    /**
+     * 获取关键字搜索地址服务
+     *
+     * @param context
+     * @param query
+     * @return
+     */
+    IMogoInputtipsSearch getInputtipsSearch( Context context, MogoInputtipsQuery query );
+
+    /**
+     * 地理编码或逆地理编码服务
+     *
+     * @param context
+     * @return
+     */
+    IMogoGeoSearch getGeoSearch( Context context );
+}

services/mogo-service-api/src/main/res/values/attrs.xml

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <declare-styleable name="MogoImageView">
+        <attr name="placeHolder" format="reference" />
+        <attr name="failureHolder" format="reference" />
+        <attr name="overlayImageId" format="reference" />
+        <attr name="shape">
+            <enum name="normal" value="0" />
+            <enum name="circle" value="1" />
+            <enum name="round" value="2" />
+        </attr>
+        <attr name="radius" format="dimension" />
+        <attr name="topLeftRadius" format="dimension" />
+        <attr name="topRightRadius" format="dimension" />
+        <attr name="bottomLeftRadius" format="dimension" />
+        <attr name="bottomRightRadius" format="dimension" />
+        <attr name="shapeBorderWidth" format="dimension" />
+        <attr name="borderColor" format="color" />
+        <attr name="isBlur" format="boolean" />
+        <attr name="blurRadius" format="integer" />
+    </declare-styleable>
+</resources>

services/mogo-service-api/src/main/res/values/strings.xml

@@ -0,0 +1,3 @@
+<resources>
+    <string name="app_name">amap-api</string>
+</resources>

services/mogo-service-api/src/test/java/com/mogo/service/map/ExampleUnitTest.java

@@ -0,0 +1,17 @@
+package com.mogo.service.map;
+
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+/**
+ * Example local unit test, which will execute on the development machine (host).
+ *
+ * @see <a href="http://d.android.com/tools/testing">Testing documentation</a>
+ */
+public class ExampleUnitTest {
+    @Test
+    public void addition_isCorrect() {
+        assertEquals( 4, 2 + 2 );
+    }
+}

services/mogo-service/.gitignore

@@ -0,0 +1 @@
+/build

services/mogo-service/build.gradle

@@ -0,0 +1,47 @@
+apply plugin: 'com.android.library'
+
+android {
+    compileSdkVersion 29
+    buildToolsVersion "29.0.2"
+
+
+    defaultConfig {
+        minSdkVersion 19
+        targetSdkVersion 29
+        versionCode 1
+        versionName "1.0"
+
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+        consumerProguardFiles 'consumer-rules.pro'
+
+
+        javaCompileOptions {
+            annotationProcessorOptions {
+                arguments = [AROUTER_MODULE_NAME: project.getName()]
+            }
+        }
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+        }
+    }
+
+}
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+
+    implementation 'androidx.appcompat:appcompat:1.0.2'
+    testImplementation 'junit:junit:4.12'
+    androidTestImplementation 'androidx.test.ext:junit:1.1.0'
+    androidTestImplementation 'androidx.test.espresso:espresso-core:3.1.1'
+
+    implementation project(":libraries:mogo-map")
+    implementation project(":foudations:mogo-utils")
+    implementation project(':services:mogo-service-api')
+    implementation rootProject.ext.dependencies.arouter
+    annotationProcessor rootProject.ext.dependencies.aroutercompiler
+}

services/mogo-service/proguard-rules.pro

@@ -0,0 +1,21 @@
+# Add project specific ProGuard rules here.
+# You can control the set of applied configuration files using the
+# proguardFiles setting in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile

services/mogo-service/src/androidTest/java/com/mogo/service/map/ExampleInstrumentedTest.java

@@ -0,0 +1,27 @@
+package com.mogo.service.map;
+
+import android.content.Context;
+
+import androidx.test.platform.app.InstrumentationRegistry;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static org.junit.Assert.*;
+
+/**
+ * Instrumented test, which will execute on an Android device.
+ *
+ * @see <a href="http://d.android.com/tools/testing">Testing documentation</a>
+ */
+@RunWith( AndroidJUnit4.class )
+public class ExampleInstrumentedTest {
+    @Test
+    public void useAppContext() {
+        // Context of the app under test.
+        Context appContext = InstrumentationRegistry.getInstrumentation().getTargetContext();
+
+        assertEquals( "com.mogo.service.amap.test", appContext.getPackageName() );
+    }
+}

services/mogo-service/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.mogo.service.map" />

services/mogo-service/src/main/java/com/mogo/service/impl/imageloader/MogoImageLoader.java

@@ -0,0 +1,69 @@
+package com.mogo.service.impl.imageloader;
+
+import android.content.Context;
+
+import com.alibaba.android.arouter.facade.annotation.Route;
+import com.mogo.service.MogoServicePaths;
+import com.mogo.service.imageloader.IMogoImageLoaderListener;
+import com.mogo.service.imageloader.IMogoImageloader;
+import com.mogo.service.imageloader.MogoImageView;
+import com.mogo.service.impl.imageloader.glide.GlideImageLoader;
+
+/**
+ * @author congtaowang
+ * @since 2019-12-23
+ * <p>
+ * 实现图片接口
+ */
+@Route( path = MogoServicePaths.PATH_IMAGE_LOADER )
+public class MogoImageLoader implements IMogoImageloader {
+
+    private IMogoImageloader mDelegate;
+
+    @Override
+    public void init( Context context ) {
+        mDelegate = GlideImageLoader.getInstance();
+    }
+
+    @Override
+    public void displayImage( String url, MogoImageView imageView ) {
+        if ( mDelegate != null ) {
+            mDelegate.displayImage( url, imageView );
+        }
+    }
+
+    @Override
+    public void displayImage( String url, MogoImageView imageView, int width, int height ) {
+        if ( mDelegate != null ) {
+            mDelegate.displayImage( url, imageView, width, height );
+        }
+    }
+
+    @Override
+    public void displayImage( String url, MogoImageView imageView, int width, int height, IMogoImageLoaderListener listener ) {
+        if ( mDelegate != null ) {
+            mDelegate.displayImage( url, imageView, width, height, listener );
+        }
+    }
+
+    @Override
+    public void displayImage( String url, MogoImageView imageView, IMogoImageLoaderListener listener ) {
+        if ( mDelegate != null ) {
+            mDelegate.displayImage( url, imageView, 0, 0, listener );
+        }
+    }
+
+    @Override
+    public void downloadImage( Context context, String url, IMogoImageLoaderListener listener ) {
+        if ( mDelegate != null ) {
+            mDelegate.downloadImage( context, url, listener );
+        }
+    }
+
+    @Override
+    public void destroy() {
+        if ( mDelegate != null ) {
+            mDelegate.destroy();
+        }
+    }
+}

services/mogo-service/src/main/java/com/mogo/service/impl/imageloader/glide/GlideImageLoader.java

@@ -0,0 +1,169 @@
+package com.mogo.service.impl.imageloader.glide;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+
+import androidx.annotation.Nullable;
+
+import com.alibaba.android.arouter.facade.annotation.Route;
+import com.bumptech.glide.load.DataSource;
+import com.bumptech.glide.load.engine.GlideException;
+import com.bumptech.glide.request.RequestListener;
+import com.bumptech.glide.request.RequestOptions;
+import com.bumptech.glide.request.target.Target;
+import com.mogo.service.MogoServicePaths;
+import com.mogo.service.imageloader.IMogoImageLoaderListener;
+import com.mogo.service.imageloader.IMogoImageloader;
+import com.mogo.service.imageloader.MogoImageView;
+import com.mogo.service.impl.imageloader.glide.transform.GlideBlurTransform;
+import com.mogo.service.impl.imageloader.glide.transform.GlideCircleBitmapTransform;
+import com.mogo.service.impl.imageloader.glide.transform.GlideRoundBitmapTransform;
+import com.mogo.service.impl.imageloader.glide.utils.DiskLruCacheManager;
+import com.mogo.utils.glide.GlideApp;
+
+/**
+ * @author congtaowang
+ * @since 2019-12-23
+ * <p>
+ * 实现图片接口
+ */
+@Route( path = MogoServicePaths.PATH_IMAGE_LOADER )
+public class GlideImageLoader implements IMogoImageloader {
+
+    private static volatile GlideImageLoader sInstance;
+
+    private GlideImageLoader() {
+    }
+
+    public static GlideImageLoader getInstance() {
+        if ( sInstance == null ) {
+            synchronized ( GlideImageLoader.class ) {
+                if ( sInstance == null ) {
+                    sInstance = new GlideImageLoader();
+                }
+            }
+        }
+        return sInstance;
+    }
+
+    @Override
+    public void init( Context context ) {
+
+    }
+
+    @Override
+    public void displayImage( String url, MogoImageView imageView ) {
+        displayImage( url, imageView, null );
+    }
+
+    @Override
+    public void displayImage( String url, MogoImageView imageView, int width, int height ) {
+        displayImage( url, imageView, width, height, null );
+    }
+
+    @Override
+    public void displayImage( String url, MogoImageView imageView, IMogoImageLoaderListener listener ) {
+        displayImage( url, imageView, 0, 0, listener );
+    }
+
+    @Override
+    public void displayImage( String url, MogoImageView imageView, int width, int height, final IMogoImageLoaderListener listener ) {
+
+        if ( listener != null ) {
+            listener.onStart();
+        }
+        // 缓存的key
+        Context context = imageView.getContext().getApplicationContext();
+        String key = url + imageView.getParams();
+        Bitmap bitmap = DiskLruCacheManager.getInstance( context ).get( key );
+        if ( bitmap != null && !bitmap.isRecycled() ) {
+            imageView.setImageBitmap( bitmap );
+            if ( listener != null ) {
+                listener.onCompleted( bitmap );
+            }
+            return;
+        }
+
+        RequestOptions options = new RequestOptions()
+                .placeholder( imageView.getPlaceHolder() )
+                .error( imageView.getFailureHolder() )
+                .dontAnimate();
+
+        // 根据imageView的形状，设置相应的transform
+        boolean isBlur = imageView.isBlur();
+        int shape = imageView.getShape();
+        if ( isBlur ) {
+            if ( shape == MogoImageView.SHAPE_CIRCLE ) {
+                options.transforms( new GlideBlurTransform( context, key, imageView.getBlurRadius() ),
+                        new GlideCircleBitmapTransform( context, key, imageView.getBorderWidth(), imageView.getBorderColor() ) );
+            } else if ( shape == MogoImageView.SHAPE_ROUND ) {
+                options.transforms( new GlideBlurTransform( context, key, imageView.getBlurRadius() ),
+                        new GlideRoundBitmapTransform( context, key, imageView.getRadius(), imageView.getBorderWidth(), imageView.getBorderColor() ) );
+            } else {
+                options.transforms( new GlideBlurTransform( context, key, imageView.getBlurRadius() ) );
+            }
+        } else {
+            if ( shape == MogoImageView.SHAPE_CIRCLE ) {
+                options.transforms( new GlideCircleBitmapTransform( context, key, imageView.getBorderWidth(), imageView.getBorderColor() ) );
+            } else if ( shape == MogoImageView.SHAPE_ROUND ) {
+                options.transforms( new GlideRoundBitmapTransform( context, key, imageView.getRadius(), imageView.getBorderWidth(), imageView.getBorderColor() ) );
+            }
+        }
+
+        GlideApp.with( context )
+                .asBitmap()
+                .load( url )
+                .apply( options )
+                .addListener( new RequestListener< Bitmap >() {
+
+                    @Override
+                    public boolean onLoadFailed( @Nullable GlideException e, Object model, Target< Bitmap > target, boolean isFirstResource ) {
+                        if ( listener != null ) {
+                            listener.onFailure( e );
+                        }
+                        return false;
+                    }
+
+                    @Override
+                    public boolean onResourceReady( Bitmap resource, Object model, Target< Bitmap > target, DataSource dataSource, boolean isFirstResource ) {
+                        if ( listener != null ) {
+                            listener.onCompleted( resource );
+                        }
+                        return false;
+                    }
+                } )
+                .into( imageView );
+    }
+
+    @Override
+    public void downloadImage( Context context, String url, final IMogoImageLoaderListener listener ) {
+        if ( listener != null ) {
+            listener.onStart();
+        }
+        GlideApp.with( context.getApplicationContext() )
+                .asBitmap()
+                .load( url )
+                .listener( new RequestListener< Bitmap >() {
+
+                    @Override
+                    public boolean onLoadFailed( @Nullable GlideException e, Object model, Target< Bitmap > target, boolean isFirstResource ) {
+                        if ( listener != null ) {
+                            listener.onFailure( e );
+                        }
+                        return false;
+                    }
+
+                    @Override
+                    public boolean onResourceReady( Bitmap resource, Object model, Target< Bitmap > target, DataSource dataSource, boolean isFirstResource ) {
+                        if ( listener != null ) {
+                            listener.onCompleted( resource );
+                        }
+                        return false;
+                    }
+                } );
+    }
+
+    @Override
+    public void destroy() {
+    }
+}

services/mogo-service/src/main/java/com/mogo/service/impl/imageloader/glide/transform/GlideBlurTransform.java

@@ -0,0 +1,39 @@
+package com.mogo.service.impl.imageloader.glide.transform;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+
+import androidx.annotation.NonNull;
+
+import com.bumptech.glide.load.engine.bitmap_recycle.BitmapPool;
+import com.bumptech.glide.load.resource.bitmap.BitmapTransformation;
+import com.mogo.service.impl.imageloader.glide.utils.DiskLruCacheManager;
+import com.mogo.service.impl.imageloader.glide.utils.FastBlurUtil;
+
+import java.security.MessageDigest;
+
+public class GlideBlurTransform extends BitmapTransformation {
+
+    private String key;
+    private Context context;
+    private int blurRadius;
+
+    public GlideBlurTransform( Context context, String key, int blurRadius ) {
+        this.context = context;
+        this.key = key;
+        this.blurRadius = blurRadius;
+    }
+
+    @Override
+    protected Bitmap transform( @NonNull BitmapPool pool, @NonNull Bitmap toTransform, int outWidth, int outHeight ) {
+        Bitmap bitmap = FastBlurUtil.doBlur( toTransform, 8, blurRadius );
+        // 缓存高斯模糊图片
+        DiskLruCacheManager.getInstance( context ).put( key, bitmap );
+        return bitmap;
+    }
+
+    @Override
+    public void updateDiskCacheKey( MessageDigest messageDigest ) {
+
+    }
+}

services/mogo-service/src/main/java/com/mogo/service/impl/imageloader/glide/transform/GlideCircleBitmapTransform.java

@@ -0,0 +1,68 @@
+
+package com.mogo.service.impl.imageloader.glide.transform;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.BitmapShader;
+import android.graphics.Canvas;
+import android.graphics.Paint;
+
+import androidx.annotation.NonNull;
+
+import com.bumptech.glide.load.engine.bitmap_recycle.BitmapPool;
+import com.bumptech.glide.load.resource.bitmap.BitmapTransformation;
+import com.mogo.service.impl.imageloader.glide.utils.DiskLruCacheManager;
+
+import java.security.MessageDigest;
+
+public class GlideCircleBitmapTransform extends BitmapTransformation {
+
+    private int mBorderWidth;
+    private int mBorderColor;
+    private String mKey;
+    private Context mContext;
+
+    public GlideCircleBitmapTransform( Context context, String key, int borderWidth, int borderColor ) {
+        this.mContext = context;
+        this.mKey = key;
+        this.mBorderWidth = borderWidth;
+        this.mBorderColor = borderColor;
+    }
+
+    @Override
+    protected Bitmap transform( @NonNull BitmapPool pool, @NonNull Bitmap toTransform, int outWidth, int outHeight ) {
+        int size = Math.min( toTransform.getWidth(), toTransform.getHeight() );
+        int x = ( toTransform.getWidth() - size ) / 2 + mBorderWidth;
+        int y = ( toTransform.getHeight() - size ) / 2 + mBorderWidth;
+        int newSize = size - mBorderWidth * 2;
+        int radius = newSize / 2;
+        Bitmap bitmap = Bitmap.createBitmap( toTransform, x, y, newSize, newSize );
+        Bitmap result = pool.get( newSize, newSize, toTransform.getConfig() );
+        if ( result == null ) {
+            result = Bitmap.createBitmap( newSize, newSize, toTransform.getConfig() );
+        }
+
+        Canvas canvas = new Canvas( result );
+        if ( mBorderWidth > 0 ) {
+            Paint borderPaint = new Paint();
+            borderPaint.setStyle( Paint.Style.STROKE );
+            borderPaint.setStrokeWidth( mBorderWidth );
+            borderPaint.setColor( mBorderColor );
+            borderPaint.setAntiAlias( true );
+            canvas.drawCircle( radius, radius, radius - mBorderWidth / 2, borderPaint );
+        }
+        Paint paint = new Paint();
+        paint.setShader( new BitmapShader( bitmap, BitmapShader.TileMode.CLAMP, BitmapShader.TileMode.CLAMP ) );
+        paint.setAntiAlias( true );
+        canvas.drawCircle( radius, radius, radius - mBorderWidth, paint );
+
+        DiskLruCacheManager.getInstance( mContext ).put( mKey, result );
+
+        return result;
+    }
+
+    @Override
+    public void updateDiskCacheKey( MessageDigest messageDigest ) {
+
+    }
+}

services/mogo-service/src/main/java/com/mogo/service/impl/imageloader/glide/transform/GlideRoundBitmapTransform.java

@@ -0,0 +1,69 @@
+
+package com.mogo.service.impl.imageloader.glide.transform;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.BitmapShader;
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.graphics.RectF;
+
+import androidx.annotation.NonNull;
+
+import com.bumptech.glide.load.engine.bitmap_recycle.BitmapPool;
+import com.bumptech.glide.load.resource.bitmap.BitmapTransformation;
+import com.mogo.service.impl.imageloader.glide.utils.DiskLruCacheManager;
+
+import java.security.MessageDigest;
+
+public class GlideRoundBitmapTransform extends BitmapTransformation {
+
+    private int mRadius;
+    private int mBorderWidth;
+    private int mBorderColor;
+    private String mKey;
+    private Context mContext;
+
+    public GlideRoundBitmapTransform( Context context, String key, int radius, int borderWidth, int borderColor ) {
+        this.mContext = context;
+        this.mKey = key;
+        this.mRadius = radius;
+        this.mBorderWidth = borderWidth;
+        this.mBorderColor = borderColor;
+    }
+
+    @Override
+    protected Bitmap transform( @NonNull BitmapPool pool, @NonNull Bitmap toTransform, int outWidth, int outHeight ) {
+        if ( mRadius == 0 && mBorderWidth == 0 ) {
+            return toTransform;
+        }
+        int width = toTransform.getWidth();
+        int height = toTransform.getHeight();
+        RectF rectF = new RectF( mBorderWidth, mBorderWidth, width - mBorderWidth, height - mBorderWidth );
+        Bitmap result = pool.get( width, height, toTransform.getConfig() );
+        if ( result == null ) {
+            result = toTransform.copy( toTransform.getConfig(), true );
+        }
+        Canvas canvas = new Canvas( result );
+        Paint paint = new Paint();
+        paint.setShader( new BitmapShader( toTransform, BitmapShader.TileMode.CLAMP, BitmapShader.TileMode.CLAMP ) );
+        paint.setAntiAlias( true );
+        canvas.drawRoundRect( rectF, mRadius, mRadius, paint );
+        if ( mBorderWidth > 0 ) {
+            Paint borderPaint = new Paint();
+            borderPaint.setStyle( Paint.Style.STROKE );
+            borderPaint.setStrokeWidth( mBorderWidth );
+            borderPaint.setColor( mBorderColor );
+            borderPaint.setAntiAlias( true );
+            canvas.drawRoundRect( rectF, mRadius, mRadius, borderPaint );
+        }
+        DiskLruCacheManager.getInstance( mContext ).put( mKey, result );
+
+        return result;
+    }
+
+    @Override
+    public void updateDiskCacheKey( MessageDigest messageDigest ) {
+
+    }
+}

services/mogo-service/src/main/java/com/mogo/service/impl/imageloader/glide/utils/DiskLruCache.java

@@ -0,0 +1,974 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.mogo.service.impl.imageloader.glide.utils;
+
+import java.io.BufferedWriter;
+import java.io.Closeable;
+import java.io.EOFException;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.FilterOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * A cache that uses a bounded amount of space on a filesystem. Each cache
+ * entry has a string key and a fixed number of values. Each key must match
+ * the regex <strong>[a-z0-9_-]{1,64}</strong>. Values are byte sequences,
+ * accessible as streams or files. Each value must be between {@code 0} and
+ * {@code Integer.MAX_VALUE} bytes in length.
+ *
+ * <p>The cache stores its data in a directory on the filesystem. This
+ * directory must be exclusive to the cache; the cache may delete or overwrite
+ * files from its directory. It is an error for multiple processes to use the
+ * same cache directory at the same time.
+ *
+ * <p>This cache limits the number of bytes that it will store on the
+ * filesystem. When the number of stored bytes exceeds the limit, the cache will
+ * remove entries in the background until the limit is satisfied. The limit is
+ * not strict: the cache may temporarily exceed it while waiting for files to be
+ * deleted. The limit does not include filesystem overhead or the cache
+ * journal so space-sensitive applications should set a conservative limit.
+ *
+ * <p>Clients call {@link #edit} to create or update the values of an entry. An
+ * entry may have only one editor at one time; if a value is not available to be
+ * edited then {@link #edit} will return null.
+ * <ul>
+ * <li>When an entry is being <strong>created</strong> it is necessary to
+ * supply a full set of values; the empty value should be used as a
+ * placeholder if necessary.
+ * <li>When an entry is being <strong>edited</strong>, it is not necessary
+ * to supply data for every value; values default to their previous
+ * value.
+ * </ul>
+ * Every {@link #edit} call must be matched by a call to {@link Editor#commit}
+ * or {@link Editor#abort}. Committing is atomic: a read observes the full set
+ * of values as they were before or after the commit, but never a mix of values.
+ *
+ * <p>Clients call {@link #get} to read a snapshot of an entry. The read will
+ * observe the value at the time that {@link #get} was called. Updates and
+ * removals after the call do not impact ongoing reads.
+ *
+ * <p>This class is tolerant of some I/O errors. If files are missing from the
+ * filesystem, the corresponding entries will be dropped from the cache. If
+ * an error occurs while writing a cache value, the edit will fail silently.
+ * Callers should handle other problems by catching {@code IOException} and
+ * responding appropriately.
+ */
+final class DiskLruCache implements Closeable {
+	static final String JOURNAL_FILE = "journal";
+	static final String JOURNAL_FILE_TEMP = "journal.tmp";
+	static final String JOURNAL_FILE_BACKUP = "journal.bkp";
+	static final String MAGIC = "libcore.io.DiskLruCache";
+	static final String VERSION_1 = "1";
+	static final long ANY_SEQUENCE_NUMBER = -1;
+	static final Pattern LEGAL_KEY_PATTERN = Pattern.compile("[a-z0-9_-]{1,64}");
+	private static final String CLEAN = "CLEAN";
+	private static final String DIRTY = "DIRTY";
+	private static final String REMOVE = "REMOVE";
+	private static final String READ = "READ";
+
+    /*
+     * This cache uses a journal file named "journal". A typical journal file
+     * looks like this:
+     *     libcore.io.DiskLruCache
+     *     1
+     *     100
+     *     2
+     *
+     *     CLEAN 3400330d1dfc7f3f7f4b8d4d803dfcf6 832 21054
+     *     DIRTY 335c4c6028171cfddfbaae1a9c313c52
+     *     CLEAN 335c4c6028171cfddfbaae1a9c313c52 3934 2342
+     *     REMOVE 335c4c6028171cfddfbaae1a9c313c52
+     *     DIRTY 1ab96a171faeeee38496d8b330771a7a
+     *     CLEAN 1ab96a171faeeee38496d8b330771a7a 1600 234
+     *     READ 335c4c6028171cfddfbaae1a9c313c52
+     *     READ 3400330d1dfc7f3f7f4b8d4d803dfcf6
+     *
+     * The first five lines of the journal form its header. They are the
+     * constant string "libcore.io.DiskLruCache", the disk cache's version,
+     * the application's version, the value count, and a blank line.
+     *
+     * Each of the subsequent lines in the file is a record of the state of a
+     * cache entry. Each line contains space-separated values: a state, a key,
+     * and optional state-specific values.
+     *   o DIRTY lines track that an entry is actively being created or updated.
+     *     Every successful DIRTY action should be followed by a CLEAN or REMOVE
+     *     action. DIRTY lines without a matching CLEAN or REMOVE indicate that
+     *     temporary files may need to be deleted.
+     *   o CLEAN lines track a cache entry that has been successfully published
+     *     and may be read. A publish line is followed by the lengths of each of
+     *     its values.
+     *   o READ lines track accesses for LRU.
+     *   o REMOVE lines track entries that have been deleted.
+     *
+     * The journal file is appended to as cache operations occur. The journal may
+     * occasionally be compacted by dropping redundant lines. A temporary file named
+     * "journal.tmp" will be used during compaction; that file should be deleted if
+     * it exists when the cache is opened.
+     */
+
+	private final File directory;
+	private final File journalFile;
+	private final File journalFileTmp;
+	private final File journalFileBackup;
+	private final int appVersion;
+	private long maxSize;
+	private int maxFileCount;
+	private final int valueCount;
+	private long size = 0;
+	private int fileCount = 0;
+	private Writer journalWriter;
+	private final LinkedHashMap<String, Entry> lruEntries =
+			new LinkedHashMap<String, Entry>(0, 0.75f, true);
+	private int redundantOpCount;
+
+	/**
+	 * To differentiate between old and current snapshots, each entry is given
+	 * a sequence number each time an edit is committed. A snapshot is stale if
+	 * its sequence number is not equal to its entry's sequence number.
+	 */
+	private long nextSequenceNumber = 0;
+
+	/** This cache uses a single background thread to evict entries. */
+	final ThreadPoolExecutor executorService =
+			new ThreadPoolExecutor(0, 1, 60L, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());
+	private final Callable<Void> cleanupCallable = new Callable<Void>() {
+		public Void call() throws Exception {
+			synchronized (DiskLruCache.this) {
+				if (journalWriter == null) {
+					return null; // Closed.
+				}
+				trimToSize();
+				trimToFileCount();
+				if (journalRebuildRequired()) {
+					rebuildJournal();
+					redundantOpCount = 0;
+				}
+			}
+			return null;
+		}
+	};
+
+	private DiskLruCache(File directory, int appVersion, int valueCount, long maxSize, int maxFileCount) {
+		this.directory = directory;
+		this.appVersion = appVersion;
+		this.journalFile = new File(directory, JOURNAL_FILE);
+		this.journalFileTmp = new File(directory, JOURNAL_FILE_TEMP);
+		this.journalFileBackup = new File(directory, JOURNAL_FILE_BACKUP);
+		this.valueCount = valueCount;
+		this.maxSize = maxSize;
+		this.maxFileCount = maxFileCount;
+	}
+
+	/**
+	 * Opens the cache in {@code directory}, creating a cache if none exists
+	 * there.
+	 *
+	 * @param directory a writable directory
+	 * @param valueCount the number of values per cache entry. Must be positive.
+	 * @param maxSize the maximum number of bytes this cache should use to store
+	 * @param maxFileCount the maximum file count this cache should store
+	 * @throws IOException if reading or writing the cache directory fails
+	 */
+	public static DiskLruCache open(File directory, int appVersion, int valueCount, long maxSize, int maxFileCount)
+			throws IOException {
+		if (maxSize <= 0) {
+			throw new IllegalArgumentException("maxSize <= 0");
+		}
+		if (maxFileCount <= 0) {
+			throw new IllegalArgumentException("maxFileCount <= 0");
+		}
+		if (valueCount <= 0) {
+			throw new IllegalArgumentException("valueCount <= 0");
+		}
+
+		// If a bkp file exists, use it instead.
+		File backupFile = new File(directory, JOURNAL_FILE_BACKUP);
+		if (backupFile.exists()) {
+			File journalFile = new File(directory, JOURNAL_FILE);
+			// If journal file also exists just delete backup file.
+			if (journalFile.exists()) {
+				backupFile.delete();
+			} else {
+				renameTo(backupFile, journalFile, false);
+			}
+		}
+
+		// Prefer to pick up where we left off.
+		DiskLruCache cache = new DiskLruCache(directory, appVersion, valueCount, maxSize, maxFileCount);
+		if (cache.journalFile.exists()) {
+			try {
+				cache.readJournal();
+				cache.processJournal();
+				cache.journalWriter = new BufferedWriter(
+						new OutputStreamWriter(new FileOutputStream(cache.journalFile, true), Util.US_ASCII));
+				return cache;
+			} catch (IOException journalIsCorrupt) {
+				System.out
+						.println("DiskLruCache "
+								+ directory
+								+ " is corrupt: "
+								+ journalIsCorrupt.getMessage()
+								+ ", removing");
+				cache.delete();
+			}
+		}
+
+		// Create a new empty cache.
+		directory.mkdirs();
+		cache = new DiskLruCache(directory, appVersion, valueCount, maxSize, maxFileCount);
+		cache.rebuildJournal();
+		return cache;
+	}
+
+	private void readJournal() throws IOException {
+		StrictLineReader reader = new StrictLineReader(new FileInputStream(journalFile), Util.US_ASCII);
+		try {
+			String magic = reader.readLine();
+			String version = reader.readLine();
+			String appVersionString = reader.readLine();
+			String valueCountString = reader.readLine();
+			String blank = reader.readLine();
+			if (!MAGIC.equals(magic)
+					|| !VERSION_1.equals(version)
+					|| !Integer.toString(appVersion).equals(appVersionString)
+					|| !Integer.toString(valueCount).equals(valueCountString)
+					|| !"".equals(blank)) {
+				throw new IOException("unexpected journal header: [" + magic + ", " + version + ", "
+						+ valueCountString + ", " + blank + "]");
+			}
+
+			int lineCount = 0;
+			while (true) {
+				try {
+					readJournalLine(reader.readLine());
+					lineCount++;
+				} catch (EOFException endOfJournal) {
+					break;
+				}
+			}
+			redundantOpCount = lineCount - lruEntries.size();
+		} finally {
+			Util.closeQuietly(reader);
+		}
+	}
+
+	private void readJournalLine(String line) throws IOException {
+		int firstSpace = line.indexOf(' ');
+		if (firstSpace == -1) {
+			throw new IOException("unexpected journal line: " + line);
+		}
+
+		int keyBegin = firstSpace + 1;
+		int secondSpace = line.indexOf(' ', keyBegin);
+		final String key;
+		if (secondSpace == -1) {
+			key = line.substring(keyBegin);
+			if (firstSpace == REMOVE.length() && line.startsWith(REMOVE)) {
+				lruEntries.remove(key);
+				return;
+			}
+		} else {
+			key = line.substring(keyBegin, secondSpace);
+		}
+
+		Entry entry = lruEntries.get(key);
+		if (entry == null) {
+			entry = new Entry(key);
+			lruEntries.put(key, entry);
+		}
+
+		if (secondSpace != -1 && firstSpace == CLEAN.length() && line.startsWith(CLEAN)) {
+			String[] parts = line.substring(secondSpace + 1).split(" ");
+			entry.readable = true;
+			entry.currentEditor = null;
+			entry.setLengths(parts);
+		} else if (secondSpace == -1 && firstSpace == DIRTY.length() && line.startsWith(DIRTY)) {
+			entry.currentEditor = new Editor(entry);
+		} else if (secondSpace == -1 && firstSpace == READ.length() && line.startsWith(READ)) {
+			// This work was already done by calling lruEntries.get().
+		} else {
+			throw new IOException("unexpected journal line: " + line);
+		}
+	}
+
+	/**
+	 * Computes the initial size and collects garbage as a part of opening the
+	 * cache. Dirty entries are assumed to be inconsistent and will be deleted.
+	 */
+	private void processJournal() throws IOException {
+		deleteIfExists(journalFileTmp);
+		for (Iterator<Entry> i = lruEntries.values().iterator(); i.hasNext(); ) {
+			Entry entry = i.next();
+			if (entry.currentEditor == null) {
+				for (int t = 0; t < valueCount; t++) {
+					size += entry.lengths[t];
+					fileCount++;
+				}
+			} else {
+				entry.currentEditor = null;
+				for (int t = 0; t < valueCount; t++) {
+					deleteIfExists(entry.getCleanFile(t));
+					deleteIfExists(entry.getDirtyFile(t));
+				}
+				i.remove();
+			}
+		}
+	}
+
+	/**
+	 * Creates a new journal that omits redundant information. This replaces the
+	 * current journal if it exists.
+	 */
+	private synchronized void rebuildJournal() throws IOException {
+		if (journalWriter != null) {
+			journalWriter.close();
+		}
+
+		Writer writer = new BufferedWriter(
+				new OutputStreamWriter(new FileOutputStream(journalFileTmp), Util.US_ASCII));
+		try {
+			writer.write(MAGIC);
+			writer.write("\n");
+			writer.write(VERSION_1);
+			writer.write("\n");
+			writer.write(Integer.toString(appVersion));
+			writer.write("\n");
+			writer.write(Integer.toString(valueCount));
+			writer.write("\n");
+			writer.write("\n");
+
+			for (Entry entry : lruEntries.values()) {
+				if (entry.currentEditor != null) {
+					writer.write(DIRTY + ' ' + entry.key + '\n');
+				} else {
+					writer.write(CLEAN + ' ' + entry.key + entry.getLengths() + '\n');
+				}
+			}
+		} finally {
+			writer.close();
+		}
+
+		if (journalFile.exists()) {
+			renameTo(journalFile, journalFileBackup, true);
+		}
+		renameTo(journalFileTmp, journalFile, false);
+		journalFileBackup.delete();
+
+		journalWriter = new BufferedWriter(
+				new OutputStreamWriter(new FileOutputStream(journalFile, true), Util.US_ASCII));
+	}
+
+	private static void deleteIfExists(File file) throws IOException {
+		if (file.exists() && !file.delete()) {
+			throw new IOException();
+		}
+	}
+
+	private static void renameTo(File from, File to, boolean deleteDestination) throws IOException {
+		if (deleteDestination) {
+			deleteIfExists(to);
+		}
+		if (!from.renameTo(to)) {
+			throw new IOException();
+		}
+	}
+
+	/**
+	 * Returns a snapshot of the entry named {@code key}, or null if it doesn't
+	 * exist is not currently readable. If a value is returned, it is moved to
+	 * the head of the LRU queue.
+	 */
+	public synchronized Snapshot get(String key) throws IOException {
+		checkNotClosed();
+		validateKey(key);
+		Entry entry = lruEntries.get(key);
+		if (entry == null) {
+			return null;
+		}
+
+		if (!entry.readable) {
+			return null;
+		}
+
+		// Open all streams eagerly to guarantee that we see a single published
+		// snapshot. If we opened streams lazily then the streams could come
+		// from different edits.
+		File[] files = new File[valueCount];
+		InputStream[] ins = new InputStream[valueCount];
+		try {
+			File file;
+			for (int i = 0; i < valueCount; i++) {
+				file = entry.getCleanFile(i);
+				files[i] = file;
+				ins[i] = new FileInputStream(file);
+			}
+		} catch (FileNotFoundException e) {
+			// A file must have been deleted manually!
+			for (int i = 0; i < valueCount; i++) {
+				if (ins[i] != null) {
+					Util.closeQuietly(ins[i]);
+				} else {
+					break;
+				}
+			}
+			return null;
+		}
+
+		redundantOpCount++;
+		journalWriter.append(READ + ' ' + key + '\n');
+		if (journalRebuildRequired()) {
+			executorService.submit(cleanupCallable);
+		}
+
+		return new Snapshot(key, entry.sequenceNumber, files, ins, entry.lengths);
+	}
+
+	/**
+	 * Returns an editor for the entry named {@code key}, or null if another
+	 * edit is in progress.
+	 */
+	public Editor edit(String key) throws IOException {
+		return edit(key, ANY_SEQUENCE_NUMBER);
+	}
+
+	private synchronized Editor edit(String key, long expectedSequenceNumber) throws IOException {
+		checkNotClosed();
+		validateKey(key);
+		Entry entry = lruEntries.get(key);
+		if (expectedSequenceNumber != ANY_SEQUENCE_NUMBER && (entry == null
+				|| entry.sequenceNumber != expectedSequenceNumber)) {
+			return null; // Snapshot is stale.
+		}
+		if (entry == null) {
+			entry = new Entry(key);
+			lruEntries.put(key, entry);
+		} else if (entry.currentEditor != null) {
+			return null; // Another edit is in progress.
+		}
+
+		Editor editor = new Editor(entry);
+		entry.currentEditor = editor;
+
+		// Flush the journal before creating files to prevent file leaks.
+		journalWriter.write(DIRTY + ' ' + key + '\n');
+		journalWriter.flush();
+		return editor;
+	}
+
+	/** Returns the directory where this cache stores its data. */
+	public File getDirectory() {
+		return directory;
+	}
+
+	/**
+	 * Returns the maximum number of bytes that this cache should use to store
+	 * its data.
+	 */
+	public synchronized long getMaxSize() {
+		return maxSize;
+	}
+
+	/** Returns the maximum number of files that this cache should store */
+	public synchronized int getMaxFileCount() {
+		return maxFileCount;
+	}
+
+	/**
+	 * Changes the maximum number of bytes the cache can store and queues a job
+	 * to trim the existing store, if necessary.
+	 */
+	public synchronized void setMaxSize(long maxSize) {
+		this.maxSize = maxSize;
+		executorService.submit(cleanupCallable);
+	}
+
+	/**
+	 * Returns the number of bytes currently being used to store the values in
+	 * this cache. This may be greater than the max size if a background
+	 * deletion is pending.
+	 */
+	public synchronized long size() {
+		return size;
+	}
+
+	/**
+	 * Returns the number of files currently being used to store the values in
+	 * this cache. This may be greater than the max file count if a background
+	 * deletion is pending.
+	 */
+	public synchronized long fileCount() {
+		return fileCount;
+	}
+
+	private synchronized void completeEdit(Editor editor, boolean success) throws IOException {
+		Entry entry = editor.entry;
+		if (entry.currentEditor != editor) {
+			throw new IllegalStateException();
+		}
+
+		// If this edit is creating the entry for the first time, every index must have a value.
+		if (success && !entry.readable) {
+			for (int i = 0; i < valueCount; i++) {
+				if (!editor.written[i]) {
+					editor.abort();
+					throw new IllegalStateException("Newly created entry didn't create value for index " + i);
+				}
+				if (!entry.getDirtyFile(i).exists()) {
+					editor.abort();
+					return;
+				}
+			}
+		}
+
+		for (int i = 0; i < valueCount; i++) {
+			File dirty = entry.getDirtyFile(i);
+			if (success) {
+				if (dirty.exists()) {
+					File clean = entry.getCleanFile(i);
+					dirty.renameTo(clean);
+					long oldLength = entry.lengths[i];
+					long newLength = clean.length();
+					entry.lengths[i] = newLength;
+					size = size - oldLength + newLength;
+					fileCount++;
+				}
+			} else {
+				deleteIfExists(dirty);
+			}
+		}
+
+		redundantOpCount++;
+		entry.currentEditor = null;
+		if (entry.readable | success) {
+			entry.readable = true;
+			journalWriter.write(CLEAN + ' ' + entry.key + entry.getLengths() + '\n');
+			if (success) {
+				entry.sequenceNumber = nextSequenceNumber++;
+			}
+		} else {
+			lruEntries.remove(entry.key);
+			journalWriter.write(REMOVE + ' ' + entry.key + '\n');
+		}
+		journalWriter.flush();
+
+		if (size > maxSize || fileCount > maxFileCount || journalRebuildRequired()) {
+			executorService.submit(cleanupCallable);
+		}
+	}
+
+	/**
+	 * We only rebuild the journal when it will halve the size of the journal
+	 * and eliminate at least 2000 ops.
+	 */
+	private boolean journalRebuildRequired() {
+		final int redundantOpCompactThreshold = 2000;
+		return redundantOpCount >= redundantOpCompactThreshold //
+				&& redundantOpCount >= lruEntries.size();
+	}
+
+	/**
+	 * Drops the entry for {@code key} if it exists and can be removed. Entries
+	 * actively being edited cannot be removed.
+	 *
+	 * @return true if an entry was removed.
+	 */
+	public synchronized boolean remove(String key) throws IOException {
+		checkNotClosed();
+		validateKey(key);
+		Entry entry = lruEntries.get(key);
+		if (entry == null || entry.currentEditor != null) {
+			return false;
+		}
+
+		for (int i = 0; i < valueCount; i++) {
+			File file = entry.getCleanFile(i);
+			if (file.exists() && !file.delete()) {
+				throw new IOException("failed to delete " + file);
+			}
+			size -= entry.lengths[i];
+			fileCount--;
+			entry.lengths[i] = 0;
+		}
+
+		redundantOpCount++;
+		journalWriter.append(REMOVE + ' ' + key + '\n');
+		lruEntries.remove(key);
+
+		if (journalRebuildRequired()) {
+			executorService.submit(cleanupCallable);
+		}
+
+		return true;
+	}
+
+	/** Returns true if this cache has been closed. */
+	public synchronized boolean isClosed() {
+		return journalWriter == null;
+	}
+
+	private void checkNotClosed() {
+		if (journalWriter == null) {
+			throw new IllegalStateException("cache is closed");
+		}
+	}
+
+	/** Force buffered operations to the filesystem. */
+	public synchronized void flush() throws IOException {
+		checkNotClosed();
+		trimToSize();
+		trimToFileCount();
+		journalWriter.flush();
+	}
+
+	/** Closes this cache. Stored values will remain on the filesystem. */
+	public synchronized void close() throws IOException {
+		if (journalWriter == null) {
+			return; // Already closed.
+		}
+		for (Entry entry : new ArrayList<Entry>(lruEntries.values())) {
+			if (entry.currentEditor != null) {
+				entry.currentEditor.abort();
+			}
+		}
+		trimToSize();
+		trimToFileCount();
+		journalWriter.close();
+		journalWriter = null;
+	}
+
+	private void trimToSize() throws IOException {
+		while (size > maxSize) {
+			Map.Entry<String, Entry> toEvict = lruEntries.entrySet().iterator().next();
+			remove(toEvict.getKey());
+		}
+	}
+
+	private void trimToFileCount() throws IOException {
+		while (fileCount > maxFileCount) {
+			Map.Entry<String, Entry> toEvict = lruEntries.entrySet().iterator().next();
+			remove(toEvict.getKey());
+		}
+	}
+
+	/**
+	 * Closes the cache and deletes all of its stored values. This will delete
+	 * all files in the cache directory including files that weren't created by
+	 * the cache.
+	 */
+	public void delete() throws IOException {
+		close();
+		Util.deleteContents(directory);
+	}
+
+	private void validateKey(String key) {
+		Matcher matcher = LEGAL_KEY_PATTERN.matcher(key);
+		if (!matcher.matches()) {
+			throw new IllegalArgumentException("keys must match regex [a-z0-9_-]{1,64}: \"" + key + "\"");
+		}
+	}
+
+	private static String inputStreamToString(InputStream in) throws IOException {
+		return Util.readFully(new InputStreamReader(in, Util.UTF_8));
+	}
+
+	/** A snapshot of the values for an entry. */
+	public final class Snapshot implements Closeable {
+		private final String key;
+		private final long sequenceNumber;
+		private File[] files;
+		private final InputStream[] ins;
+		private final long[] lengths;
+
+		private Snapshot(String key, long sequenceNumber, File[] files, InputStream[] ins, long[] lengths) {
+			this.key = key;
+			this.sequenceNumber = sequenceNumber;
+			this.files = files;
+			this.ins = ins;
+			this.lengths = lengths;
+		}
+
+		/**
+		 * Returns an editor for this snapshot's entry, or null if either the
+		 * entry has changed since this snapshot was created or if another edit
+		 * is in progress.
+		 */
+		public Editor edit() throws IOException {
+			return DiskLruCache.this.edit(key, sequenceNumber);
+		}
+
+		/** Returns file with the value for {@code index}. */
+		public File getFile(int index) {
+			return files[index];
+		}
+
+		/** Returns the unbuffered stream with the value for {@code index}. */
+		public InputStream getInputStream(int index) {
+			return ins[index];
+		}
+
+		/** Returns the string value for {@code index}. */
+		public String getString(int index) throws IOException {
+			return inputStreamToString(getInputStream(index));
+		}
+
+		/** Returns the byte length of the value for {@code index}. */
+		public long getLength(int index) {
+			return lengths[index];
+		}
+
+		public void close() {
+			for (InputStream in : ins) {
+				Util.closeQuietly(in);
+			}
+		}
+	}
+
+	private static final OutputStream NULL_OUTPUT_STREAM = new OutputStream() {
+		@Override
+		public void write(int b) throws IOException {
+			// Eat all writes silently. Nom nom.
+		}
+	};
+
+	/** Edits the values for an entry. */
+	public final class Editor {
+		private final Entry entry;
+		private final boolean[] written;
+		private boolean hasErrors;
+		private boolean committed;
+
+		private Editor(Entry entry) {
+			this.entry = entry;
+			this.written = (entry.readable) ? null : new boolean[valueCount];
+		}
+
+		/**
+		 * Returns an unbuffered input stream to read the last committed value,
+		 * or null if no value has been committed.
+		 */
+		public InputStream newInputStream(int index) throws IOException {
+			synchronized (DiskLruCache.this) {
+				if (entry.currentEditor != this) {
+					throw new IllegalStateException();
+				}
+				if (!entry.readable) {
+					return null;
+				}
+				try {
+					return new FileInputStream(entry.getCleanFile(index));
+				} catch (FileNotFoundException e) {
+					return null;
+				}
+			}
+		}
+
+		/**
+		 * Returns the last committed value as a string, or null if no value
+		 * has been committed.
+		 */
+		public String getString(int index) throws IOException {
+			InputStream in = newInputStream(index);
+			return in != null ? inputStreamToString(in) : null;
+		}
+
+		/**
+		 * Returns a new unbuffered output stream to write the value at
+		 * {@code index}. If the underlying output stream encounters errors
+		 * when writing to the filesystem, this edit will be aborted when
+		 * {@link #commit} is called. The returned output stream does not throw
+		 * IOExceptions.
+		 */
+		public OutputStream newOutputStream(int index) throws IOException {
+			synchronized (DiskLruCache.this) {
+				if (entry.currentEditor != this) {
+					throw new IllegalStateException();
+				}
+				if (!entry.readable) {
+					written[index] = true;
+				}
+				File dirtyFile = entry.getDirtyFile(index);
+				FileOutputStream outputStream;
+				try {
+					outputStream = new FileOutputStream(dirtyFile);
+				} catch (FileNotFoundException e) {
+					// Attempt to recreate the cache directory.
+					directory.mkdirs();
+					try {
+						outputStream = new FileOutputStream(dirtyFile);
+					} catch (FileNotFoundException e2) {
+						// We are unable to recover. Silently eat the writes.
+						return NULL_OUTPUT_STREAM;
+					}
+				}
+				return new FaultHidingOutputStream(outputStream);
+			}
+		}
+
+		/** Sets the value at {@code index} to {@code value}. */
+		public void set(int index, String value) throws IOException {
+			Writer writer = null;
+			try {
+				writer = new OutputStreamWriter(newOutputStream(index), Util.UTF_8);
+				writer.write(value);
+			} finally {
+				Util.closeQuietly(writer);
+			}
+		}
+
+		/**
+		 * Commits this edit so it is visible to readers.  This releases the
+		 * edit lock so another edit may be started on the same key.
+		 */
+		public void commit() throws IOException {
+			if (hasErrors) {
+				completeEdit(this, false);
+				remove(entry.key); // The previous entry is stale.
+			} else {
+				completeEdit(this, true);
+			}
+			committed = true;
+		}
+
+		/**
+		 * Aborts this edit. This releases the edit lock so another edit may be
+		 * started on the same key.
+		 */
+		public void abort() throws IOException {
+			completeEdit(this, false);
+		}
+
+		public void abortUnlessCommitted() {
+			if (!committed) {
+				try {
+					abort();
+				} catch (IOException ignored) {
+				}
+			}
+		}
+
+		private class FaultHidingOutputStream extends FilterOutputStream {
+			private FaultHidingOutputStream(OutputStream out) {
+				super(out);
+			}
+
+			@Override public void write(int oneByte) {
+				try {
+					out.write(oneByte);
+				} catch (IOException e) {
+					hasErrors = true;
+				}
+			}
+
+			@Override public void write(byte[] buffer, int offset, int length) {
+				try {
+					out.write(buffer, offset, length);
+				} catch (IOException e) {
+					hasErrors = true;
+				}
+			}
+
+			@Override public void close() {
+				try {
+					out.close();
+				} catch (IOException e) {
+					hasErrors = true;
+				}
+			}
+
+			@Override public void flush() {
+				try {
+					out.flush();
+				} catch (IOException e) {
+					hasErrors = true;
+				}
+			}
+		}
+	}
+
+	private final class Entry {
+		private final String key;
+
+		/** Lengths of this entry's files. */
+		private final long[] lengths;
+
+		/** True if this entry has ever been published. */
+		private boolean readable;
+
+		/** The ongoing edit or null if this entry is not being edited. */
+		private Editor currentEditor;
+
+		/** The sequence number of the most recently committed edit to this entry. */
+		private long sequenceNumber;
+
+		private Entry(String key) {
+			this.key = key;
+			this.lengths = new long[valueCount];
+		}
+
+		public String getLengths() throws IOException {
+			StringBuilder result = new StringBuilder();
+			for (long size : lengths) {
+				result.append(' ').append(size);
+			}
+			return result.toString();
+		}
+
+		/** Set lengths using decimal numbers like "10123". */
+		private void setLengths(String[] strings) throws IOException {
+			if (strings.length != valueCount) {
+				throw invalidLengths(strings);
+			}
+
+			try {
+				for (int i = 0; i < strings.length; i++) {
+					lengths[i] = Long.parseLong(strings[i]);
+				}
+			} catch (NumberFormatException e) {
+				throw invalidLengths(strings);
+			}
+		}
+
+		private IOException invalidLengths(String[] strings) throws IOException {
+			throw new IOException("unexpected journal line: " + java.util.Arrays.toString(strings));
+		}
+
+		public File getCleanFile(int i) {
+			return new File(directory, key + "" + i);
+		}
+
+		public File getDirtyFile(int i) {
+			return new File(directory, key + "" + i + ".tmp");
+		}
+	}
+}

services/mogo-service/src/main/java/com/mogo/service/impl/imageloader/glide/utils/DiskLruCacheManager.java

@@ -0,0 +1,101 @@
+package com.mogo.service.impl.imageloader.glide.utils;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.text.TextUtils;
+
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.math.BigInteger;
+import java.security.MessageDigest;
+
+/*******************************************************************************
+ * Description: 用于缓存经过高斯模糊的图片
+ *
+ * Author: Freeman
+ *
+ * Date: 2018/9/4
+ *
+ * Copyright: all rights reserved by Freeman.
+ *******************************************************************************/
+public class DiskLruCacheManager {
+
+	private DiskLruCache diskLruCache;
+	private static DiskLruCacheManager instance;
+
+	private final int MAX_CACHE_SIZE = 64 * 1024 * 1024;
+
+	private DiskLruCacheManager(Context context) {
+		try {
+			diskLruCache = DiskLruCache.open(context.getCacheDir(), 1, 1,
+					MAX_CACHE_SIZE, Integer.MAX_VALUE);
+		} catch (Exception e) {
+			e.printStackTrace(System.err);
+		}
+	}
+
+	public static DiskLruCacheManager getInstance(Context context) {
+		if (instance == null) {
+			synchronized (DiskLruCacheManager.class) {
+				if (instance == null) {
+					instance = new DiskLruCacheManager(context.getApplicationContext());
+				}
+			}
+		}
+
+		return instance;
+	}
+
+	public void put(String url, Bitmap bitmap) {
+		if (TextUtils.isEmpty(url) || bitmap == null || bitmap.isRecycled()) {
+			return;
+		}
+
+		try {
+			DiskLruCache.Editor editor = diskLruCache.edit(getKey(url));
+			OutputStream outputStream = editor.newOutputStream(0);
+			if (bitmap.compress(Bitmap.CompressFormat.PNG, 100, outputStream)) {
+				editor.commit();
+			}
+			diskLruCache.flush();
+		} catch (Exception e) {
+			e.printStackTrace(System.err);
+		}
+	}
+
+	public Bitmap get(String url) {
+		try {
+			DiskLruCache.Snapshot snapshot = diskLruCache.get(getKey(url));
+			if (snapshot != null) {
+				InputStream inputStream = snapshot.getInputStream(0);
+				return BitmapFactory.decodeStream(inputStream);
+			}
+		} catch (Exception e) {
+			e.printStackTrace(System.err);
+		}
+
+		return null;
+	}
+
+	public static String getKey(String url) {
+		try {
+			MessageDigest digest = MessageDigest.getInstance("MD5");
+			byte[] md5 = digest.digest(url.getBytes());
+			BigInteger bigInteger = new BigInteger(1, md5);
+			return bigInteger.toString(16);
+		} catch (Exception e) {
+			e.printStackTrace(System.err);
+		}
+
+		return null;
+	}
+
+	public void close() {
+		try {
+			diskLruCache.close();
+		} catch (Exception e) {
+			e.printStackTrace(System.err);
+		}
+	}
+}

services/mogo-service/src/main/java/com/mogo/service/impl/imageloader/glide/utils/FastBlurUtil.java

@@ -0,0 +1,241 @@
+package com.mogo.service.impl.imageloader.glide.utils;
+
+import android.graphics.Bitmap;
+
+/**
+ * Created by jay on 11/7/15.
+ */
+public class FastBlurUtil {
+
+    public static Bitmap doBlur(Bitmap sentBitmap, int scaleRadius, int radius) {
+
+        // Stack Blur v1.0 from
+        // http://www.quasimondo.com/StackBlurForCanvas/StackBlurDemo.html
+        //
+        // Java Author: Mario Klingemann <mario at quasimondo.com>
+        // http://incubator.quasimondo.com
+        // created Feburary 29, 2004
+        // Android port : Yahel Bouaziz <yahel at kayenko.com>
+        // http://www.kayenko.com
+        // ported april 5th, 2012
+
+        // This is a compromise between Gaussian Blur and Box blur
+        // It creates much better looking blurs than Box Blur, but is
+        // 7x faster than my Gaussian Blur implementation.
+        //
+        // I called it Stack Blur because this describes best how this
+        // filter works internally: it creates a kind of moving stack
+        // of colors whilst scanning through the image. Thereby it
+        // just has to add one new block of color to the right side
+        // of the stack and remove the leftmost color. The remaining
+        // colors on the topmost layer of the stack are either added on
+        // or reduced by one, depending on if they are on the right or
+        // on the left side of the stack.
+        //
+        // If you are using this algorithm in your code please add
+        // the following line:
+        //
+        // Stack Blur Algorithm by Mario Klingemann <mario@quasimondo.com>
+        if (scaleRadius > 0) {
+            sentBitmap = Bitmap.createScaledBitmap(sentBitmap, sentBitmap.getWidth() / scaleRadius,
+                    sentBitmap.getHeight() / scaleRadius, false);
+        }
+        Bitmap bitmap = sentBitmap.copy(sentBitmap.getConfig(), true);
+
+        if (radius < 1) {
+            return (null);
+        }
+        int w = bitmap.getWidth();
+        int h = bitmap.getHeight();
+
+        int[] pix = new int[w * h];
+        bitmap.getPixels(pix, 0, w, 0, 0, w, h);
+
+        int wm = w - 1;
+        int hm = h - 1;
+        int wh = w * h;
+        int div = radius + radius + 1;
+
+        int r[] = new int[wh];
+        int g[] = new int[wh];
+        int b[] = new int[wh];
+        int rsum, gsum, bsum, x, y, i, p, yp, yi, yw;
+        int vmin[] = new int[Math.max(w, h)];
+
+        int divsum = (div + 1) >> 1;
+        divsum *= divsum;
+        int dv[] = new int[256 * divsum];
+        for (i = 0; i < 256 * divsum; i++) {
+            dv[i] = (i / divsum);
+        }
+
+        yw = yi = 0;
+
+        int[][] stack = new int[div][3];
+        int stackpointer;
+        int stackstart;
+        int[] sir;
+        int rbs;
+        int r1 = radius + 1;
+        int routsum, goutsum, boutsum;
+        int rinsum, ginsum, binsum;
+
+        for (y = 0; y < h; y++) {
+            rinsum = ginsum = binsum = routsum = goutsum = boutsum = rsum = gsum = bsum = 0;
+            for (i = -radius; i <= radius; i++) {
+                p = pix[yi + Math.min(wm, Math.max(i, 0))];
+                sir = stack[i + radius];
+                sir[0] = (p & 0xff0000) >> 16;
+                sir[1] = (p & 0x00ff00) >> 8;
+                sir[2] = (p & 0x0000ff);
+                rbs = r1 - Math.abs(i);
+                rsum += sir[0] * rbs;
+                gsum += sir[1] * rbs;
+                bsum += sir[2] * rbs;
+                if (i > 0) {
+                    rinsum += sir[0];
+                    ginsum += sir[1];
+                    binsum += sir[2];
+                } else {
+                    routsum += sir[0];
+                    goutsum += sir[1];
+                    boutsum += sir[2];
+                }
+            }
+            stackpointer = radius;
+
+            for (x = 0; x < w; x++) {
+
+                r[yi] = dv[rsum];
+                g[yi] = dv[gsum];
+                b[yi] = dv[bsum];
+
+                rsum -= routsum;
+                gsum -= goutsum;
+                bsum -= boutsum;
+
+                stackstart = stackpointer - radius + div;
+                sir = stack[stackstart % div];
+
+                routsum -= sir[0];
+                goutsum -= sir[1];
+                boutsum -= sir[2];
+
+                if (y == 0) {
+                    vmin[x] = Math.min(x + radius + 1, wm);
+                }
+                p = pix[yw + vmin[x]];
+
+                sir[0] = (p & 0xff0000) >> 16;
+                sir[1] = (p & 0x00ff00) >> 8;
+                sir[2] = (p & 0x0000ff);
+
+                rinsum += sir[0];
+                ginsum += sir[1];
+                binsum += sir[2];
+
+                rsum += rinsum;
+                gsum += ginsum;
+                bsum += binsum;
+
+                stackpointer = (stackpointer + 1) % div;
+                sir = stack[(stackpointer) % div];
+
+                routsum += sir[0];
+                goutsum += sir[1];
+                boutsum += sir[2];
+
+                rinsum -= sir[0];
+                ginsum -= sir[1];
+                binsum -= sir[2];
+
+                yi++;
+            }
+            yw += w;
+        }
+        for (x = 0; x < w; x++) {
+            rinsum = ginsum = binsum = routsum = goutsum = boutsum = rsum = gsum = bsum = 0;
+            yp = -radius * w;
+            for (i = -radius; i <= radius; i++) {
+                yi = Math.max(0, yp) + x;
+
+                sir = stack[i + radius];
+
+                sir[0] = r[yi];
+                sir[1] = g[yi];
+                sir[2] = b[yi];
+
+                rbs = r1 - Math.abs(i);
+
+                rsum += r[yi] * rbs;
+                gsum += g[yi] * rbs;
+                bsum += b[yi] * rbs;
+
+                if (i > 0) {
+                    rinsum += sir[0];
+                    ginsum += sir[1];
+                    binsum += sir[2];
+                } else {
+                    routsum += sir[0];
+                    goutsum += sir[1];
+                    boutsum += sir[2];
+                }
+
+                if (i < hm) {
+                    yp += w;
+                }
+            }
+            yi = x;
+            stackpointer = radius;
+            for (y = 0; y < h; y++) {
+                // Preserve alpha channel: ( 0xff000000 & pix[yi] )
+                pix[yi] = (0xff000000 & pix[yi]) | (dv[rsum] << 16) | (dv[gsum] << 8) | dv[bsum];
+
+                rsum -= routsum;
+                gsum -= goutsum;
+                bsum -= boutsum;
+
+                stackstart = stackpointer - radius + div;
+                sir = stack[stackstart % div];
+
+                routsum -= sir[0];
+                goutsum -= sir[1];
+                boutsum -= sir[2];
+
+                if (x == 0) {
+                    vmin[y] = Math.min(y + r1, hm) * w;
+                }
+                p = x + vmin[y];
+
+                sir[0] = r[p];
+                sir[1] = g[p];
+                sir[2] = b[p];
+
+                rinsum += sir[0];
+                ginsum += sir[1];
+                binsum += sir[2];
+
+                rsum += rinsum;
+                gsum += ginsum;
+                bsum += binsum;
+
+                stackpointer = (stackpointer + 1) % div;
+                sir = stack[stackpointer];
+
+                routsum += sir[0];
+                goutsum += sir[1];
+                boutsum += sir[2];
+
+                rinsum -= sir[0];
+                ginsum -= sir[1];
+                binsum -= sir[2];
+
+                yi += w;
+            }
+        }
+
+        bitmap.setPixels(pix, 0, w, 0, 0, w, h);
+
+        return (bitmap);
+    }
+}

services/mogo-service/src/main/java/com/mogo/service/impl/imageloader/glide/utils/StrictLineReader.java

@@ -0,0 +1,191 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.mogo.service.impl.imageloader.glide.utils;
+
+import java.io.ByteArrayOutputStream;
+import java.io.Closeable;
+import java.io.EOFException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.UnsupportedEncodingException;
+import java.nio.charset.Charset;
+
+/**
+ * Buffers input from an {@link InputStream} for reading lines.
+ *
+ * <p>This class is used for buffered reading of lines. For purposes of this class, a line ends
+ * with "\n" or "\r\n". End of input is reported by throwing {@code EOFException}. Unterminated
+ * line at end of input is invalid and will be ignored, the caller may use {@code
+ * hasUnterminatedLine()} to detect it after catching the {@code EOFException}.
+ *
+ * <p>This class is intended for reading input that strictly consists of lines, such as line-based
+ * cache entries or cache journal. Unlike the {@link java.io.BufferedReader} which in conjunction
+ * with {@link java.io.InputStreamReader} provides similar functionality, this class uses different
+ * end-of-input reporting and a more restrictive definition of a line.
+ *
+ * <p>This class supports only charsets that encode '\r' and '\n' as a single byte with value 13
+ * and 10, respectively, and the representation of no other character contains these values.
+ * We currently check in constructor that the charset is one of US-ASCII, UTF-8 and ISO-8859-1.
+ * The default charset is US_ASCII.
+ */
+class StrictLineReader implements Closeable {
+	private static final byte CR = (byte) '\r';
+	private static final byte LF = (byte) '\n';
+
+	private final InputStream in;
+	private final Charset charset;
+
+	/*
+	   * Buffered data is stored in {@code buf}. As long as no exception occurs, 0 <= pos <= end
+	   * and the data in the range [pos, end) is buffered for reading. At end of input, if there is
+	   * an unterminated line, we set end == -1, otherwise end == pos. If the underlying
+	   * {@code InputStream} throws an {@code IOException}, end may remain as either pos or -1.
+	   */
+	private byte[] buf;
+	private int pos;
+	private int end;
+
+	/**
+	 * Constructs a new {@code LineReader} with the specified charset and the default capacity.
+	 *
+	 * @param in the {@code InputStream} to read data from.
+	 * @param charset the charset used to decode data. Only US-ASCII, UTF-8 and ISO-8859-1 are
+	 * supported.
+	 * @throws NullPointerException if {@code in} or {@code charset} is null.
+	 * @throws IllegalArgumentException if the specified charset is not supported.
+	 */
+	public StrictLineReader(InputStream in, Charset charset) {
+		this(in, 8192, charset);
+	}
+
+	/**
+	 * Constructs a new {@code LineReader} with the specified capacity and charset.
+	 *
+	 * @param in the {@code InputStream} to read data from.
+	 * @param capacity the capacity of the buffer.
+	 * @param charset the charset used to decode data. Only US-ASCII, UTF-8 and ISO-8859-1 are
+	 * supported.
+	 * @throws NullPointerException if {@code in} or {@code charset} is null.
+	 * @throws IllegalArgumentException if {@code capacity} is negative or zero
+	 * or the specified charset is not supported.
+	 */
+	public StrictLineReader(InputStream in, int capacity, Charset charset) {
+		if (in == null || charset == null) {
+			throw new NullPointerException();
+		}
+		if (capacity < 0) {
+			throw new IllegalArgumentException("capacity <= 0");
+		}
+		if (!(charset.equals(Util.US_ASCII))) {
+			throw new IllegalArgumentException("Unsupported encoding");
+		}
+
+		this.in = in;
+		this.charset = charset;
+		buf = new byte[capacity];
+	}
+
+	/**
+	 * Closes the reader by closing the underlying {@code InputStream} and
+	 * marking this reader as closed.
+	 *
+	 * @throws IOException for errors when closing the underlying {@code InputStream}.
+	 */
+	public void close() throws IOException {
+		synchronized (in) {
+			if (buf != null) {
+				buf = null;
+				in.close();
+			}
+		}
+	}
+
+	/**
+	 * Reads the next line. A line ends with {@code "\n"} or {@code "\r\n"},
+	 * this end of line marker is not included in the result.
+	 *
+	 * @return the next line from the input.
+	 * @throws IOException for underlying {@code InputStream} errors.
+	 * @throws EOFException for the end of source stream.
+	 */
+	public String readLine() throws IOException {
+		synchronized (in) {
+			if (buf == null) {
+				throw new IOException("LineReader is closed");
+			}
+
+			// Read more data if we are at the end of the buffered data.
+			// Though it's an error to read after an exception, we will let {@code fillBuf()}
+			// throw again if that happens; thus we need to handle end == -1 as well as end == pos.
+			if (pos >= end) {
+				fillBuf();
+			}
+			// Try to find LF in the buffered data and return the line if successful.
+			for (int i = pos; i != end; ++i) {
+				if (buf[i] == LF) {
+					int lineEnd = (i != pos && buf[i - 1] == CR) ? i - 1 : i;
+					String res = new String(buf, pos, lineEnd - pos, charset.name());
+					pos = i + 1;
+					return res;
+				}
+			}
+
+			// Let's anticipate up to 80 characters on top of those already read.
+			ByteArrayOutputStream out = new ByteArrayOutputStream(end - pos + 80) {
+				@Override
+				public String toString() {
+					int length = (count > 0 && buf[count - 1] == CR) ? count - 1 : count;
+					try {
+						return new String(buf, 0, length, charset.name());
+					} catch (UnsupportedEncodingException e) {
+						throw new AssertionError(e); // Since we control the charset this will never happen.
+					}
+				}
+			};
+
+			while (true) {
+				out.write(buf, pos, end - pos);
+				// Mark unterminated line in case fillBuf throws EOFException or IOException.
+				end = -1;
+				fillBuf();
+				// Try to find LF in the buffered data and return the line if successful.
+				for (int i = pos; i != end; ++i) {
+					if (buf[i] == LF) {
+						if (i != pos) {
+							out.write(buf, pos, i - pos);
+						}
+						pos = i + 1;
+						return out.toString();
+					}
+				}
+			}
+		}
+	}
+
+	/**
+	 * Reads new input data into the buffer. Call only with pos == end or end == -1,
+	 * depending on the desired outcome if the function throws.
+	 */
+	private void fillBuf() throws IOException {
+		int result = in.read(buf, 0, buf.length);
+		if (result == -1) {
+			throw new EOFException();
+		}
+		pos = 0;
+		end = result;
+	}
+}
+

services/mogo-service/src/main/java/com/mogo/service/impl/imageloader/glide/utils/Util.java

@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.mogo.service.impl.imageloader.glide.utils;
+
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.io.Reader;
+import java.io.StringWriter;
+import java.nio.charset.Charset;
+
+/** Junk drawer of utility methods. */
+final class Util {
+	static final Charset US_ASCII = Charset.forName("US-ASCII");
+	static final Charset UTF_8 = Charset.forName("UTF-8");
+
+	private Util() {
+	}
+
+	static String readFully(Reader reader) throws IOException {
+		try {
+			StringWriter writer = new StringWriter();
+			char[] buffer = new char[1024];
+			int count;
+			while ((count = reader.read(buffer)) != -1) {
+				writer.write(buffer, 0, count);
+			}
+			return writer.toString();
+		} finally {
+			reader.close();
+		}
+	}
+
+	/**
+	 * Deletes the contents of {@code dir}. Throws an IOException if any file
+	 * could not be deleted, or if {@code dir} is not a readable directory.
+	 */
+	static void deleteContents(File dir) throws IOException {
+		File[] files = dir.listFiles();
+		if (files == null) {
+			throw new IOException("not a readable directory: " + dir);
+		}
+		for (File file : files) {
+			if (file.isDirectory()) {
+				deleteContents(file);
+			}
+			if (!file.delete()) {
+				throw new IOException("failed to delete file: " + file);
+			}
+		}
+	}
+
+	static void closeQuietly(/*Auto*/Closeable closeable) {
+		if (closeable != null) {
+			try {
+				closeable.close();
+			} catch (RuntimeException rethrown) {
+				throw rethrown;
+			} catch (Exception ignored) {
+			}
+		}
+	}
+}

services/mogo-service/src/main/java/com/mogo/service/impl/map/MogoMapService.java

@@ -0,0 +1,68 @@
+package com.mogo.service.impl.map;
+
+import android.content.Context;
+
+import com.alibaba.android.arouter.facade.annotation.Route;
+import com.mogo.map.MogoMap;
+import com.mogo.map.location.IMogoLocationClient;
+import com.mogo.map.location.MogoLocationClient;
+import com.mogo.map.marker.IMogoMarker;
+import com.mogo.map.marker.MogoMarkerOptions;
+import com.mogo.map.search.IMogoGeoSearch;
+import com.mogo.map.search.IMogoInputtipsSearch;
+import com.mogo.map.search.MogoGeoSearch;
+import com.mogo.map.search.MogoInputtipsSearch;
+import com.mogo.map.search.query.MogoInputtipsQuery;
+import com.mogo.service.map.IMogoMapService;
+import com.mogo.service.MogoServicePaths;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author congtaowang
+ * @since 2019-12-18
+ * <p>
+ * 地图对外地接口
+ */
+@Route( path = MogoServicePaths.PATH_MAP_SERVICE )
+public class MogoMapService implements IMogoMapService {
+
+    @Override
+    public IMogoLocationClient getSingletonLocationClient( Context context ) {
+        return MogoLocationClient.getInstance( context );
+    }
+
+    @Override
+    public IMogoMarker addMarker( MogoMarkerOptions options ) {
+        try {
+            return MogoMap.getInstance().getMogoMap().addMarker( options );
+        } catch ( Exception e ) {
+            return null;
+        }
+    }
+
+    @Override
+    public List< IMogoMarker > addMarkers( ArrayList< MogoMarkerOptions > options, boolean moveToCenter ) {
+        try {
+            return MogoMap.getInstance().getMogoMap().addMarkers( options, moveToCenter );
+        } catch ( Exception e ) {
+            return null;
+        }
+    }
+
+    @Override
+    public IMogoInputtipsSearch getInputtipsSearch( Context context, MogoInputtipsQuery query ) {
+        return new MogoInputtipsSearch( context, query );
+    }
+
+    @Override
+    public IMogoGeoSearch getGeoSearch( Context context ) {
+        return new MogoGeoSearch( context );
+    }
+
+    @Override
+    public void init( Context context ) {
+
+    }
+}

services/mogo-service/src/main/res/values/strings.xml

@@ -0,0 +1,3 @@
+<resources>
+    <string name="app_name">amap-api</string>
+</resources>

services/mogo-service/src/test/java/com/mogo/service/map/ExampleUnitTest.java

@@ -0,0 +1,17 @@
+package com.mogo.service.map;
+
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+/**
+ * Example local unit test, which will execute on the development machine (host).
+ *
+ * @see <a href="http://d.android.com/tools/testing">Testing documentation</a>
+ */
+public class ExampleUnitTest {
+    @Test
+    public void addition_isCorrect() {
+        assertEquals( 4, 2 + 2 );
+    }
+}