From 945d50689290c5609111342679fe21de09fcf290 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E8=91=A3=E5=AE=8F=E5=AE=87?= <martindhy@gmail.com>
Date: Tue, 9 Feb 2021 15:10:42 +0800
Subject: [PATCH] =?UTF-8?q?=E5=8E=BB=E9=99=A4Androidx=EF=BC=8C=E4=BF=9D?=
 =?UTF-8?q?=E8=AF=81=E6=97=A7=E7=89=88=E6=9C=AC=E9=A1=B9=E7=9B=AE=E5=8F=AF?=
 =?UTF-8?q?=E7=94=A8?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .idea/codeStyles/Project.xml                  |   6 +
 .idea/codeStyles/codeStyleConfig.xml          |   5 +
 .idea/gradle.xml                              |   2 +-
 app/build.gradle                              |   5 +-
 .../java/com/mogo/cloud/BaseLiveActivity.java |   2 +-
 .../com/mogo/cloud/ConfigInfoActivity.java    |   6 +-
 .../java/com/mogo/cloud/LivePlayActivity.java |   2 +-
 .../java/com/mogo/cloud/LivePushActivity.java |   1 +
 .../java/com/mogo/cloud/MainActivity.java     |   2 +-
 .../java/com/mogo/cloud/MoGoApplication.java  |   6 +-
 .../java/com/mogo/cloud/RealTimeActivity.java |   4 +-
 .../com/mogo/cloud/RoadConditionActivity.java |   5 +-
 .../mogo/cloud/network/NetworkActivity.java   |   3 +-
 .../main/res/layout/actitity_config_info.xml  |   4 +-
 .../main/res/layout/activity_live_play.xml    |   6 +-
 config.gradle                                 |  18 +-
 foudations/mogo-live/build.gradle             |   3 +-
 foudations/mogo-network/build.gradle          |   5 +
 .../com/mogo/cloud/network/RetrofitFactory.kt |   2 +-
 .../interceptor/HttpPassportInterceptor.kt    |   2 +-
 foudations/mogo-passport/build.gradle         |   3 +-
 .../cloud/passport/MoGoAiCloudClient.java     |   5 +-
 .../com/mogo/cloud/socket/SocketManager.java  |   5 +-
 .../cloud/socket/SocketServicesConstants.java |   3 +-
 .../{mogo-common => mogo-utils}/.gitignore    |   0
 .../{mogo-common => mogo-utils}/build.gradle  |   8 +-
 .../consumer-rules.pro                        |   0
 .../gradle.properties                         |   2 +-
 .../proguard-rules.pro                        |   0
 .../src/main/AndroidManifest.xml              |   0
 .../java/com/mogo}/utils/DevicesUtils.java    |   2 +-
 .../main/java/com/mogo/utils/GsonUtil.java    |  79 ++
 .../com/mogo/utils/WorkThreadHandler.java     |  81 ++
 .../java/com/mogo/utils/logger/LogLevel.java  |  24 +
 .../java/com/mogo/utils/logger/Logger.java    |  57 ++
 .../com/mogo/utils/logger/LoggerPrinter.java  | 261 +++++
 .../java/com/mogo/utils/logger/Printer.java   |  26 +
 .../java/com/mogo/utils/logger/Settings.java  |  52 +
 .../mogo/utils/storage/SharedPrefsMgr.java    | 154 +++
 .../utils/storage/lrucache/CacheUtil.java     |  77 ++
 .../storage/lrucache/DiskCacheManager.java    | 374 +++++++
 .../utils/storage/lrucache/DiskLruCache.java  | 947 ++++++++++++++++++
 .../utils/storage/lrucache/SecretUtil.java    |  34 +
 .../storage/lrucache/StrictLineReader.java    | 196 ++++
 gradle.properties                             |  43 +-
 modules.txt                                   |   1 +
 .../core/SimpleLocationCorrectStrategy.java   |   3 +-
 .../realtime/core/UploadInTimeHandler.java    |   3 +-
 .../realtime/entity/CloudLocationInfo.java    |   2 +-
 .../mogo/realtime/socket/SocketHandler.java   |   2 +-
 .../com/mogo/realtime/util/MogoLatLng.java    |   3 +-
 .../tanlu/api/MogoRoadSearchManager.java      |   2 +-
 .../com/mogo/cloud/tanlu/utils/FileUtil.kt    |   3 +-
 .../mogo/cloud/tanlu/utils/TanluUtils.java    |   3 +-
 settings.gradle                               |   2 +-
 55 files changed, 2457 insertions(+), 89 deletions(-)
 create mode 100644 .idea/codeStyles/codeStyleConfig.xml
 rename foudations/{mogo-common => mogo-utils}/.gitignore (100%)
 rename foudations/{mogo-common => mogo-utils}/build.gradle (79%)
 rename foudations/{mogo-common => mogo-utils}/consumer-rules.pro (100%)
 rename foudations/{mogo-common => mogo-utils}/gradle.properties (73%)
 rename foudations/{mogo-common => mogo-utils}/proguard-rules.pro (100%)
 rename foudations/{mogo-common => mogo-utils}/src/main/AndroidManifest.xml (100%)
 rename foudations/{mogo-common/src/main/java/com/mogo/cloud/common => mogo-utils/src/main/java/com/mogo}/utils/DevicesUtils.java (59%)
 create mode 100644 foudations/mogo-utils/src/main/java/com/mogo/utils/GsonUtil.java
 create mode 100644 foudations/mogo-utils/src/main/java/com/mogo/utils/WorkThreadHandler.java
 create mode 100644 foudations/mogo-utils/src/main/java/com/mogo/utils/logger/LogLevel.java
 create mode 100644 foudations/mogo-utils/src/main/java/com/mogo/utils/logger/Logger.java
 create mode 100644 foudations/mogo-utils/src/main/java/com/mogo/utils/logger/LoggerPrinter.java
 create mode 100644 foudations/mogo-utils/src/main/java/com/mogo/utils/logger/Printer.java
 create mode 100644 foudations/mogo-utils/src/main/java/com/mogo/utils/logger/Settings.java
 create mode 100644 foudations/mogo-utils/src/main/java/com/mogo/utils/storage/SharedPrefsMgr.java
 create mode 100644 foudations/mogo-utils/src/main/java/com/mogo/utils/storage/lrucache/CacheUtil.java
 create mode 100644 foudations/mogo-utils/src/main/java/com/mogo/utils/storage/lrucache/DiskCacheManager.java
 create mode 100644 foudations/mogo-utils/src/main/java/com/mogo/utils/storage/lrucache/DiskLruCache.java
 create mode 100644 foudations/mogo-utils/src/main/java/com/mogo/utils/storage/lrucache/SecretUtil.java
 create mode 100644 foudations/mogo-utils/src/main/java/com/mogo/utils/storage/lrucache/StrictLineReader.java

diff --git a/.idea/codeStyles/Project.xml b/.idea/codeStyles/Project.xml
index 681f41a..88ea3aa 100644
--- a/.idea/codeStyles/Project.xml
+++ b/.idea/codeStyles/Project.xml
@@ -1,5 +1,8 @@
 <component name="ProjectCodeStyleConfiguration">
   <code_scheme name="Project" version="173">
+    <JetCodeStyleSettings>
+      <option name="CODE_STYLE_DEFAULTS" value="KOTLIN_OFFICIAL" />
+    </JetCodeStyleSettings>
     <codeStyleSettings language="XML">
       <indentOptions>
         <option name="CONTINUATION_INDENT_SIZE" value="4" />
@@ -112,5 +115,8 @@
         </rules>
       </arrangement>
     </codeStyleSettings>
+    <codeStyleSettings language="kotlin">
+      <option name="CODE_STYLE_DEFAULTS" value="KOTLIN_OFFICIAL" />
+    </codeStyleSettings>
   </code_scheme>
 </component>
\ No newline at end of file
diff --git a/.idea/codeStyles/codeStyleConfig.xml b/.idea/codeStyles/codeStyleConfig.xml
new file mode 100644
index 0000000..79ee123
--- /dev/null
+++ b/.idea/codeStyles/codeStyleConfig.xml
@@ -0,0 +1,5 @@
+<component name="ProjectCodeStyleConfiguration">
+  <state>
+    <option name="USE_PER_PROJECT_SETTINGS" value="true" />
+  </state>
+</component>
\ No newline at end of file
diff --git a/.idea/gradle.xml b/.idea/gradle.xml
index 1f8e3ef..1563bc1 100644
--- a/.idea/gradle.xml
+++ b/.idea/gradle.xml
@@ -13,12 +13,12 @@
             <option value="$PROJECT_DIR$" />
             <option value="$PROJECT_DIR$/app" />
             <option value="$PROJECT_DIR$/foudations" />
-            <option value="$PROJECT_DIR$/foudations/mogo-common" />
             <option value="$PROJECT_DIR$/foudations/mogo-httpdns" />
             <option value="$PROJECT_DIR$/foudations/mogo-live" />
             <option value="$PROJECT_DIR$/foudations/mogo-network" />
             <option value="$PROJECT_DIR$/foudations/mogo-passport" />
             <option value="$PROJECT_DIR$/foudations/mogo-socket" />
+            <option value="$PROJECT_DIR$/foudations/mogo-utils" />
             <option value="$PROJECT_DIR$/modules" />
             <option value="$PROJECT_DIR$/modules/mogo-realtime" />
             <option value="$PROJECT_DIR$/modules/mogo-tanlu" />
diff --git a/app/build.gradle b/app/build.gradle
index 88379d3..c550529 100644
--- a/app/build.gradle
+++ b/app/build.gradle
@@ -10,7 +10,6 @@ android {
         versionCode 1
         versionName "1.0"
 
-        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
         multiDexEnabled true
         packagingOptions {
             //解决编译时com.android.builder.merge.DuplicateRelativeFileException: More than one file was found with OS independent path 'META-INF/rxjava.properties'这个错误
@@ -38,8 +37,8 @@ dependencies {
     implementation fileTree(dir: "libs", include: ["*.jar"])
     implementation 'com.android.support:multidex:1.0.3'
 
-    implementation rootProject.ext.dependencies.androidxappcompat
-    implementation rootProject.ext.dependencies.androidxconstraintlayout
+    implementation rootProject.ext.dependencies.androidAppCompat
+    implementation rootProject.ext.dependencies.androidConstraintLayout
     implementation rootProject.ext.dependencies.rxjava
     implementation rootProject.ext.dependencies.rxandroid
     // 从车机获取视频流
diff --git a/app/src/main/java/com/mogo/cloud/BaseLiveActivity.java b/app/src/main/java/com/mogo/cloud/BaseLiveActivity.java
index 1b25c30..c071752 100644
--- a/app/src/main/java/com/mogo/cloud/BaseLiveActivity.java
+++ b/app/src/main/java/com/mogo/cloud/BaseLiveActivity.java
@@ -1,13 +1,13 @@
 package com.mogo.cloud;
 
 import android.os.Bundle;
+import android.support.v7.app.AppCompatActivity;
 import android.util.Log;
 import android.view.SurfaceHolder;
 import android.view.SurfaceView;
 import android.widget.Toast;
 import android.widget.ToggleButton;
 
-import androidx.appcompat.app.AppCompatActivity;
 
 import com.mogo.cloud.util.YuvToolUtils;
 import com.zhidao.manager.camera.FrameBufferCallBack;
diff --git a/app/src/main/java/com/mogo/cloud/ConfigInfoActivity.java b/app/src/main/java/com/mogo/cloud/ConfigInfoActivity.java
index be5546b..e8b9a9a 100644
--- a/app/src/main/java/com/mogo/cloud/ConfigInfoActivity.java
+++ b/app/src/main/java/com/mogo/cloud/ConfigInfoActivity.java
@@ -1,13 +1,13 @@
 package com.mogo.cloud;
 
 import android.os.Bundle;
+import android.support.annotation.Nullable;
+import android.support.v7.app.AppCompatActivity;
 import android.widget.TextView;
 
-import androidx.annotation.Nullable;
-import androidx.appcompat.app.AppCompatActivity;
 
 import com.mogo.cloud.passport.MoGoAiCloudClientConfig;
-import com.mogo.utils.network.utils.GsonUtil;
+import com.mogo.utils.GsonUtil;
 
 /**
  * 查看配置信息
diff --git a/app/src/main/java/com/mogo/cloud/LivePlayActivity.java b/app/src/main/java/com/mogo/cloud/LivePlayActivity.java
index 8f93bb6..4b6da7a 100644
--- a/app/src/main/java/com/mogo/cloud/LivePlayActivity.java
+++ b/app/src/main/java/com/mogo/cloud/LivePlayActivity.java
@@ -1,13 +1,13 @@
 package com.mogo.cloud;
 
 import android.os.Bundle;
+import android.support.v7.app.AppCompatActivity;
 import android.util.Log;
 import android.view.SurfaceView;
 import android.widget.EditText;
 import android.widget.Toast;
 import android.widget.ToggleButton;
 
-import androidx.appcompat.app.AppCompatActivity;
 
 import com.mogo.cloud.trafficlive.api.ITrafficLiveCallBack;
 import com.mogo.cloud.trafficlive.api.MoGoAiCloudTrafficLive;
diff --git a/app/src/main/java/com/mogo/cloud/LivePushActivity.java b/app/src/main/java/com/mogo/cloud/LivePushActivity.java
index b90ce68..8829eee 100644
--- a/app/src/main/java/com/mogo/cloud/LivePushActivity.java
+++ b/app/src/main/java/com/mogo/cloud/LivePushActivity.java
@@ -42,6 +42,7 @@ public class LivePushActivity extends BaseLiveActivity {
     public void toggleCameraState(boolean isLive) {
         Log.i(TAG, "toggleCameraState isLive: " + isLive);
         if (isLive) {
+            // 上报摄像头状态，1-可用，2-不可用
             liveStreamManager.uploadCamStatus(1, 1);
         } else {
             liveStreamManager.uploadCamStatus(2, 2);
diff --git a/app/src/main/java/com/mogo/cloud/MainActivity.java b/app/src/main/java/com/mogo/cloud/MainActivity.java
index 21a6fa9..d43d3af 100644
--- a/app/src/main/java/com/mogo/cloud/MainActivity.java
+++ b/app/src/main/java/com/mogo/cloud/MainActivity.java
@@ -2,11 +2,11 @@ package com.mogo.cloud;
 
 import android.content.Intent;
 import android.os.Bundle;
+import android.support.v7.app.AppCompatActivity;
 import android.text.TextUtils;
 import android.widget.Button;
 import android.widget.TextView;
 
-import androidx.appcompat.app.AppCompatActivity;
 
 import com.mogo.cloud.network.NetworkActivity;
 import com.mogo.cloud.passport.IMoGoTokenCallback;
diff --git a/app/src/main/java/com/mogo/cloud/MoGoApplication.java b/app/src/main/java/com/mogo/cloud/MoGoApplication.java
index 2c4748c..da24f05 100644
--- a/app/src/main/java/com/mogo/cloud/MoGoApplication.java
+++ b/app/src/main/java/com/mogo/cloud/MoGoApplication.java
@@ -1,16 +1,16 @@
 package com.mogo.cloud;
 
-import androidx.multidex.MultiDexApplication;
+
+import android.support.annotation.Nullable;
+import android.support.multidex.MultiDexApplication;
 
 import com.mogo.cloud.httpdns.MogoHttpDnsConfig;
 import com.mogo.cloud.httpdns.bean.HttpDnsSimpleLocation;
 import com.mogo.cloud.httpdns.listener.IHttpDnsCurrentLocation;
-import com.mogo.cloud.passport.IMoGoTokenCallback;
 import com.mogo.cloud.passport.MoGoAiCloudClient;
 import com.mogo.cloud.passport.MoGoAiCloudClientConfig;
 import com.mogo.cloud.util.Devices;
 
-import org.jetbrains.annotations.Nullable;
 
 import java.util.ArrayList;
 import java.util.List;
diff --git a/app/src/main/java/com/mogo/cloud/RealTimeActivity.java b/app/src/main/java/com/mogo/cloud/RealTimeActivity.java
index 73fcfe3..fa45bb9 100644
--- a/app/src/main/java/com/mogo/cloud/RealTimeActivity.java
+++ b/app/src/main/java/com/mogo/cloud/RealTimeActivity.java
@@ -1,11 +1,11 @@
 package com.mogo.cloud;
 
 import android.os.Bundle;
+import android.support.annotation.Nullable;
+import android.support.v7.app.AppCompatActivity;
 import android.util.Log;
 import android.widget.Button;
 
-import androidx.annotation.Nullable;
-import androidx.appcompat.app.AppCompatActivity;
 
 import com.mogo.cloud.passport.MoGoAiCloudClient;
 import com.mogo.realtime.api.MoGoAiCloudRealTime;
diff --git a/app/src/main/java/com/mogo/cloud/RoadConditionActivity.java b/app/src/main/java/com/mogo/cloud/RoadConditionActivity.java
index 6bb96df..372d496 100644
--- a/app/src/main/java/com/mogo/cloud/RoadConditionActivity.java
+++ b/app/src/main/java/com/mogo/cloud/RoadConditionActivity.java
@@ -1,12 +1,11 @@
 package com.mogo.cloud;
 
 import android.os.Bundle;
+import android.support.annotation.Nullable;
+import android.support.v7.app.AppCompatActivity;
 import android.widget.Button;
 import android.widget.TextView;
 
-import androidx.annotation.Nullable;
-import androidx.appcompat.app.AppCompatActivity;
-
 import com.google.gson.Gson;
 import com.mogo.cloud.network.BaseData;
 import com.mogo.cloud.tanlu.api.MogoRoadSearchManager;
diff --git a/app/src/main/java/com/mogo/cloud/network/NetworkActivity.java b/app/src/main/java/com/mogo/cloud/network/NetworkActivity.java
index 28ea228..0d4cc30 100644
--- a/app/src/main/java/com/mogo/cloud/network/NetworkActivity.java
+++ b/app/src/main/java/com/mogo/cloud/network/NetworkActivity.java
@@ -1,12 +1,11 @@
 package com.mogo.cloud.network;
 
 import android.os.Bundle;
+import android.support.v7.app.AppCompatActivity;
 import android.view.View;
 import android.widget.Button;
 import android.widget.TextView;
 
-import androidx.appcompat.app.AppCompatActivity;
-
 import com.google.gson.Gson;
 import com.mogo.cloud.R;
 
diff --git a/app/src/main/res/layout/actitity_config_info.xml b/app/src/main/res/layout/actitity_config_info.xml
index e95d3c6..3811fd5 100644
--- a/app/src/main/res/layout/actitity_config_info.xml
+++ b/app/src/main/res/layout/actitity_config_info.xml
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
+<android.support.constraint.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:tools="http://schemas.android.com/tools"
     android:layout_width="match_parent"
     android:layout_height="match_parent">
@@ -13,4 +13,4 @@
         android:textSize="20dp"
         tools:text="测试数据测试数据测试数据测试数据测试数据测试数据测试数据测试数据测试数据测试数据测试数据测试数据测试数据测试数据测试数据测试数据" />
 
-</androidx.constraintlayout.widget.ConstraintLayout>
\ No newline at end of file
+</android.support.constraint.ConstraintLayout>
\ No newline at end of file
diff --git a/app/src/main/res/layout/activity_live_play.xml b/app/src/main/res/layout/activity_live_play.xml
index b3f5411..d9099ef 100644
--- a/app/src/main/res/layout/activity_live_play.xml
+++ b/app/src/main/res/layout/activity_live_play.xml
@@ -1,10 +1,10 @@
 <?xml version="1.0" encoding="utf-8"?>
-<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
+<android.support.constraint.ConstraintLayout 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=".LivePlayActivity">
+    >
 
     <SurfaceView
         android:id="@+id/surfaceView"
@@ -32,4 +32,4 @@
         app:layout_constraintBottom_toBottomOf="parent"
         app:layout_constraintLeft_toLeftOf="parent" />
 
-</androidx.constraintlayout.widget.ConstraintLayout>
\ No newline at end of file
+</android.support.constraint.ConstraintLayout>
\ No newline at end of file
diff --git a/config.gradle b/config.gradle
index b573d3a..2e8d9cd 100644
--- a/config.gradle
+++ b/config.gradle
@@ -8,17 +8,14 @@ ext {
             targetSdkVersion : 22,
     ]
     dependencies = [
-            // androidx
-            androidxappcompat        : "androidx.appcompat:appcompat:1.2.0",
-            androidxconstraintlayout : "androidx.constraintlayout:constraintlayout:1.1.3",
+            // android
+            androidAppCompat         : "com.android.support:support-compat:28.0.0",
+            androidConstraintLayout  : "com.android.support.constraint:constraint-layout:2.0.4",
             boostmultidex            : "com.bytedance.boost_multidex:boost_multidex:1.0.1",
-            localbroadcastmanager    : "androidx.localbroadcastmanager:localbroadcastmanager:1.0.0",
             // flexbox
             flexbox                  : 'com.google.android:flexbox:2.0.1',
             // 测试
             junit                    : "junit:junit:4.12",
-            androidxjunit            : "androidx.test.ext:junit:1.1.0",
-            androidxespressocore     : "androidx.test.espresso:espresso-core:3.1.1",
             // 地图
             amapnavi3dmap            : "com.amap.api:navi-3dmap:7.2.0_3dmap7.2.0",
             amapsearch               : "com.amap.api:search:7.1.0",
@@ -63,7 +60,7 @@ ext {
             videoprocessor           : "com.zhidao.video:video-processor:1.0.2.1",
 
             // 直播SDK
-            live_sdk_zego                  : "im.zego:express-video:2.0.1",
+            live_sdk_zego            : "im.zego:express-video:2.0.1",
 
             aspectj                  : "org.aspectj:aspectjrt:1.8.9",
             adasapi                  : "com.zhidao.autopilot.support:adas:1.0.6.6",
@@ -75,13 +72,6 @@ ext {
             // google
             googlezxing              : "com.google.zxing:core:3.3.3",
             litezxing                : "com.google.zxing:litezxing:1.0.29.8",
-
-            // android - room
-            androidxroomruntime      : "androidx.room:room-runtime:2.2.3",
-            androidxroomcompiler     : "androidx.room:room-compiler:2.2.3",
-            androidxroomktx          : "androidx.room:room-ktx:2.2.3",
-
-            mogoutils                : "com.mogo.commons:mogo-utils:2.0.12",
             cossdk                   : "com.zhidao.cosupload:cosuploadsdk:1.1.6",
             spi                      : 'com.elegant.spi:api:1.0.9'  //运行时spi库
 
diff --git a/foudations/mogo-live/build.gradle b/foudations/mogo-live/build.gradle
index cbacbcc..921fa07 100644
--- a/foudations/mogo-live/build.gradle
+++ b/foudations/mogo-live/build.gradle
@@ -10,7 +10,6 @@ android {
         versionCode 1
         versionName "${MOGO_LIVE_VERSION}"
 
-        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
         consumerProguardFiles "consumer-rules.pro"
     }
 
@@ -32,7 +31,7 @@ android {
 
 dependencies {
     implementation fileTree(dir: "libs", include: ["*.jar"])
-    implementation rootProject.ext.dependencies.androidxappcompat
+    implementation rootProject.ext.dependencies.androidAppCompat
     implementation rootProject.ext.dependencies.live_sdk_zego
 
     api 'com.zhidao.libyuv:libyuv:1.0.1.0'
diff --git a/foudations/mogo-network/build.gradle b/foudations/mogo-network/build.gradle
index 9ae7b11..7021111 100644
--- a/foudations/mogo-network/build.gradle
+++ b/foudations/mogo-network/build.gradle
@@ -51,6 +51,11 @@ dependencies {
     implementation fileTree(dir: "libs", include: ["*.jar"])
     implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
 
+    api rootProject.ext.dependencies.retrofit
+    api rootProject.ext.dependencies.retrofitadapter
+    api rootProject.ext.dependencies.retrofitconvertergson
+    api rootProject.ext.dependencies.retrofitconverterscalars
+
     if (Boolean.valueOf(RELEASE)) {
         api "com.mogo.cloud:passport:${MOGO_PASSPORT_VERSION}"
     } else {
diff --git a/foudations/mogo-network/src/main/java/com/mogo/cloud/network/RetrofitFactory.kt b/foudations/mogo-network/src/main/java/com/mogo/cloud/network/RetrofitFactory.kt
index 6c1f9d0..d1a9fb4 100644
--- a/foudations/mogo-network/src/main/java/com/mogo/cloud/network/RetrofitFactory.kt
+++ b/foudations/mogo-network/src/main/java/com/mogo/cloud/network/RetrofitFactory.kt
@@ -1,6 +1,6 @@
 package com.mogo.cloud.network
 
-import androidx.collection.ArrayMap
+import android.util.ArrayMap
 import retrofit2.Retrofit
 import retrofit2.adapter.rxjava2.RxJava2CallAdapterFactory
 import retrofit2.converter.gson.GsonConverterFactory
diff --git a/foudations/mogo-network/src/main/java/com/mogo/cloud/network/interceptor/HttpPassportInterceptor.kt b/foudations/mogo-network/src/main/java/com/mogo/cloud/network/interceptor/HttpPassportInterceptor.kt
index 21567cb..8139340 100644
--- a/foudations/mogo-network/src/main/java/com/mogo/cloud/network/interceptor/HttpPassportInterceptor.kt
+++ b/foudations/mogo-network/src/main/java/com/mogo/cloud/network/interceptor/HttpPassportInterceptor.kt
@@ -2,8 +2,8 @@ package com.mogo.cloud.network.interceptor
 
 import com.mogo.cloud.network.BaseData
 import com.mogo.cloud.passport.MoGoAiCloudClient
+import com.mogo.utils.GsonUtil
 import com.mogo.utils.logger.Logger
-import com.mogo.utils.network.utils.GsonUtil
 import okhttp3.Interceptor
 import okhttp3.MediaType
 import okhttp3.Response
diff --git a/foudations/mogo-passport/build.gradle b/foudations/mogo-passport/build.gradle
index 38e4721..71a5476 100644
--- a/foudations/mogo-passport/build.gradle
+++ b/foudations/mogo-passport/build.gradle
@@ -27,14 +27,15 @@ android {
 
 dependencies {
     implementation fileTree(dir: "libs", include: ["*.jar"])
-    api rootProject.ext.dependencies.mogoutils
     // passport
     implementation 'com.zhidao.thirdlogin:third-login:1.0.2'
 
     if (Boolean.valueOf(RELEASE)) {
         api "com.mogo.cloud:httpdns:${MOGO_HTTPDNS_VERSION}"
+        api "com.mogo.cloud:utils:${MOGO_UTILS_VERSION}"
     } else {
         api project(':foudations:mogo-httpdns')
+        api project(':foudations:mogo-utils')
     }
 
 }
diff --git a/foudations/mogo-passport/src/main/java/com/mogo/cloud/passport/MoGoAiCloudClient.java b/foudations/mogo-passport/src/main/java/com/mogo/cloud/passport/MoGoAiCloudClient.java
index 71e3b7d..6368385 100644
--- a/foudations/mogo-passport/src/main/java/com/mogo/cloud/passport/MoGoAiCloudClient.java
+++ b/foudations/mogo-passport/src/main/java/com/mogo/cloud/passport/MoGoAiCloudClient.java
@@ -1,15 +1,12 @@
 package com.mogo.cloud.passport;
 
 import android.content.Context;
+import android.support.annotation.Keep;
 import android.util.Log;
 import android.widget.Toast;
 
-import androidx.annotation.Keep;
-
-import com.elegant.utils.DeviceIdUtil;
 import com.mogo.cloud.httpdns.MogoHttpDnsClient;
 import com.mogo.cloud.httpdns.MogoHttpDnsConfig;
-import com.mogo.utils.DeviceIdUtils;
 import com.mogo.utils.logger.LogLevel;
 import com.mogo.utils.logger.Logger;
 import com.zhidao.thirdlogin.Environment;
diff --git a/foudations/mogo-socket/src/main/java/com/mogo/cloud/socket/SocketManager.java b/foudations/mogo-socket/src/main/java/com/mogo/cloud/socket/SocketManager.java
index 1a3c727..d718ebb 100644
--- a/foudations/mogo-socket/src/main/java/com/mogo/cloud/socket/SocketManager.java
+++ b/foudations/mogo-socket/src/main/java/com/mogo/cloud/socket/SocketManager.java
@@ -2,15 +2,14 @@ package com.mogo.cloud.socket;
 
 
 import android.content.Context;
-
-import androidx.annotation.NonNull;
+import android.support.annotation.NonNull;
 
 import com.google.protobuf.ByteString;
 import com.google.protobuf.InvalidProtocolBufferException;
 import com.mogo.cloud.passport.MoGoAiCloudClient;
 import com.mogo.cloud.passport.MoGoAiCloudClientConfig;
+import com.mogo.utils.GsonUtil;
 import com.mogo.utils.logger.Logger;
-import com.mogo.utils.network.utils.GsonUtil;
 import com.zhidao.locupload.Platform;
 import com.zhidao.ptech.connsvr.commom.protocol.MogoCommon;
 import com.zhidao.ptech.connsvr.protocol.MogoConnsvr;
diff --git a/foudations/mogo-socket/src/main/java/com/mogo/cloud/socket/SocketServicesConstants.java b/foudations/mogo-socket/src/main/java/com/mogo/cloud/socket/SocketServicesConstants.java
index 24c9271..e7f72e9 100644
--- a/foudations/mogo-socket/src/main/java/com/mogo/cloud/socket/SocketServicesConstants.java
+++ b/foudations/mogo-socket/src/main/java/com/mogo/cloud/socket/SocketServicesConstants.java
@@ -1,6 +1,7 @@
 package com.mogo.cloud.socket;
 
-import androidx.annotation.Keep;
+
+import android.support.annotation.Keep;
 
 public class SocketServicesConstants {
 
diff --git a/foudations/mogo-common/.gitignore b/foudations/mogo-utils/.gitignore
similarity index 100%
rename from foudations/mogo-common/.gitignore
rename to foudations/mogo-utils/.gitignore
diff --git a/foudations/mogo-common/build.gradle b/foudations/mogo-utils/build.gradle
similarity index 79%
rename from foudations/mogo-common/build.gradle
rename to foudations/mogo-utils/build.gradle
index 8a5d99c..5120be3 100644
--- a/foudations/mogo-common/build.gradle
+++ b/foudations/mogo-utils/build.gradle
@@ -10,7 +10,6 @@ android {
         versionCode 1
         versionName "${MOGO_LIVE_VERSION}"
 
-        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
         consumerProguardFiles "consumer-rules.pro"
     }
 
@@ -31,6 +30,9 @@ android {
 
 dependencies {
     implementation fileTree(dir: "libs", include: ["*.jar"])
-    implementation rootProject.ext.dependencies.androidxappcompat
+    implementation rootProject.ext.dependencies.androidAppCompat
+    implementation rootProject.ext.dependencies.gson
 
-}
\ No newline at end of file
+}
+
+apply from: new File(rootProject.rootDir, "gradle/upload.gradle").toString()
diff --git a/foudations/mogo-common/consumer-rules.pro b/foudations/mogo-utils/consumer-rules.pro
similarity index 100%
rename from foudations/mogo-common/consumer-rules.pro
rename to foudations/mogo-utils/consumer-rules.pro
diff --git a/foudations/mogo-common/gradle.properties b/foudations/mogo-utils/gradle.properties
similarity index 73%
rename from foudations/mogo-common/gradle.properties
rename to foudations/mogo-utils/gradle.properties
index 2d94279..f6a851f 100644
--- a/foudations/mogo-common/gradle.properties
+++ b/foudations/mogo-utils/gradle.properties
@@ -1,4 +1,4 @@
 GROUP=com.mogo.cloud
-POM_ARTIFACT_ID=common
+POM_ARTIFACT_ID=utils
 VERSION_CODE=1
 VERSION_NAME=1.0.2-SNAPSHOT
\ No newline at end of file
diff --git a/foudations/mogo-common/proguard-rules.pro b/foudations/mogo-utils/proguard-rules.pro
similarity index 100%
rename from foudations/mogo-common/proguard-rules.pro
rename to foudations/mogo-utils/proguard-rules.pro
diff --git a/foudations/mogo-common/src/main/AndroidManifest.xml b/foudations/mogo-utils/src/main/AndroidManifest.xml
similarity index 100%
rename from foudations/mogo-common/src/main/AndroidManifest.xml
rename to foudations/mogo-utils/src/main/AndroidManifest.xml
diff --git a/foudations/mogo-common/src/main/java/com/mogo/cloud/common/utils/DevicesUtils.java b/foudations/mogo-utils/src/main/java/com/mogo/utils/DevicesUtils.java
similarity index 59%
rename from foudations/mogo-common/src/main/java/com/mogo/cloud/common/utils/DevicesUtils.java
rename to foudations/mogo-utils/src/main/java/com/mogo/utils/DevicesUtils.java
index 1f0b8bb..810d3c6 100644
--- a/foudations/mogo-common/src/main/java/com/mogo/cloud/common/utils/DevicesUtils.java
+++ b/foudations/mogo-utils/src/main/java/com/mogo/utils/DevicesUtils.java
@@ -1,4 +1,4 @@
-package com.mogo.cloud.common.utils;
+package com.mogo.utils;
 
 /**
  * 设备信息
diff --git a/foudations/mogo-utils/src/main/java/com/mogo/utils/GsonUtil.java b/foudations/mogo-utils/src/main/java/com/mogo/utils/GsonUtil.java
new file mode 100644
index 0000000..96fbbd5
--- /dev/null
+++ b/foudations/mogo-utils/src/main/java/com/mogo/utils/GsonUtil.java
@@ -0,0 +1,79 @@
+package com.mogo.utils;
+
+import android.text.TextUtils;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+
+import org.json.JSONObject;
+
+import java.util.ArrayList;
+import java.util.List;
+
+
+public class GsonUtil {
+
+    private static volatile Gson gson;
+
+    private GsonUtil() {}
+
+    public static Gson getGson() {
+        if(gson == null){
+            synchronized (GsonUtil.class) {
+                if (gson == null) {
+                    GsonBuilder builder = new GsonBuilder();
+                    gson = builder.create();
+                }
+            }
+        }
+        return gson;
+    }
+
+    public static String jsonFromObject( Object object) {
+        if (object == null) {
+            return null;
+        } else {
+            try {
+                return getGson().toJson(object);
+            } catch ( Exception var2) {
+                var2.printStackTrace();
+                return null;
+            }
+        }
+    }
+
+    public static <T> T objectFromJson( String json, Class<T> klass) {
+        if (json == null) {
+            return null;
+        } else {
+            try {
+                return getGson().fromJson(json, klass);
+            } catch ( Exception var3) {
+                var3.printStackTrace();
+                return null;
+            }
+        }
+    }
+
+
+    public static <T> List<T> arrayFromJson( String json, Class<T> clazz) {
+        List<T> list = new ArrayList<T>();
+        if ( TextUtils.isEmpty(json)) {
+            return null;
+        }
+        try {
+            org.json.JSONArray array = new org.json.JSONArray(json);
+            for (int i = 0; i < array.length(); i++) {
+                JSONObject object = array.getJSONObject(i);
+                String js = object.toString();
+                T t = GsonUtil.objectFromJson(js, clazz);
+                list.add(t);
+            }
+            return list;
+        } catch ( Exception e) {
+            e.printStackTrace();
+        }
+        return null;
+
+    }
+}
diff --git a/foudations/mogo-utils/src/main/java/com/mogo/utils/WorkThreadHandler.java b/foudations/mogo-utils/src/main/java/com/mogo/utils/WorkThreadHandler.java
new file mode 100644
index 0000000..3bde8ef
--- /dev/null
+++ b/foudations/mogo-utils/src/main/java/com/mogo/utils/WorkThreadHandler.java
@@ -0,0 +1,81 @@
+package com.mogo.utils;
+
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.os.Looper;
+
+/**
+ * @author congtaowang
+ * @since 2020-03-23
+ * <p>
+ * 描述
+ */
+public class WorkThreadHandler {
+
+    private Looper mThreadLooper;
+    private Handler mHandler;
+    private HandlerThread mThread;
+
+    public static WorkThreadHandler newInstance(String name ) {
+        return new WorkThreadHandler( name );
+    }
+
+    private WorkThreadHandler(String name ) {
+        // private constructor
+        mThread = new HandlerThread( name );
+        mThread.start();
+        mThreadLooper = mThread.getLooper();
+        mHandler = new Handler( mThreadLooper );
+    }
+
+    private WorkThreadHandler() {
+        // private constructor
+        this( "work-thread-handler" );
+    }
+
+    private static final class InstanceHolder {
+        private static final WorkThreadHandler INSTANCE = new WorkThreadHandler();
+    }
+
+    public static WorkThreadHandler getInstance() {
+        return InstanceHolder.INSTANCE;
+    }
+
+    public Looper getLooper() {
+        return mThreadLooper;
+    }
+
+    private Object readResolve() {
+        // 阻止反序列化，必须实现 Serializable 接口
+        return InstanceHolder.INSTANCE;
+    }
+
+    private Object sToken = new Object();
+
+    public boolean post( Runnable r ) {
+        return mHandler != null && mHandler.post( r );
+    }
+
+    public boolean postDelayed( Runnable r, long delayMillis ) {
+        return mHandler != null && mHandler.postDelayed( r, delayMillis );
+    }
+
+    public Handler getWorkThreadHandler() {
+        return mHandler;
+    }
+
+    public boolean postOnceDelayed( Runnable r, long delayMillis ) {
+        if ( mHandler == null ) {
+            return false;
+        } else {
+            mHandler.removeCallbacks( r, sToken );
+            return mHandler.postDelayed( r, delayMillis );
+        }
+    }
+
+    public void removeCallbacks( Runnable runnable ) {
+        if ( mHandler != null ) {
+            mHandler.removeCallbacks( runnable );
+        }
+    }
+}
diff --git a/foudations/mogo-utils/src/main/java/com/mogo/utils/logger/LogLevel.java b/foudations/mogo-utils/src/main/java/com/mogo/utils/logger/LogLevel.java
new file mode 100644
index 0000000..1296d3a
--- /dev/null
+++ b/foudations/mogo-utils/src/main/java/com/mogo/utils/logger/LogLevel.java
@@ -0,0 +1,24 @@
+
+package com.mogo.utils.logger;
+
+public enum LogLevel {
+
+    OFF( Integer.MAX_VALUE),
+
+    VERBOSE(1),
+
+    DEBUG(2),
+
+    INFO(3),
+
+    WARN(4),
+
+    ERROR(5);
+
+    public final int level;
+
+    private LogLevel(final int level) {
+        this.level = level;
+    }
+
+}
diff --git a/foudations/mogo-utils/src/main/java/com/mogo/utils/logger/Logger.java b/foudations/mogo-utils/src/main/java/com/mogo/utils/logger/Logger.java
new file mode 100644
index 0000000..1527799
--- /dev/null
+++ b/foudations/mogo-utils/src/main/java/com/mogo/utils/logger/Logger.java
@@ -0,0 +1,57 @@
+
+package com.mogo.utils.logger;
+
+public final class Logger {
+    private static final Printer sPrinter = new LoggerPrinter();
+
+    private Logger() {
+    }
+
+    public static Settings init() {
+        return sPrinter.init(LogLevel.DEBUG);
+    }
+
+    public static Settings init(LogLevel logLevel) {
+        return sPrinter.init(logLevel);
+    }
+
+    public static void d( String tag, String message, Object... args) {
+        if(isLoggable(LogLevel.DEBUG)) sPrinter.d(tag, message, args);
+    }
+
+    public static void e( String tag, String message, Object... args) {
+        if(isLoggable(LogLevel.ERROR)) sPrinter.e(tag, null, message, args);
+    }
+
+    public static void e( String tag, Throwable throwable, String message, Object... args) {
+        if(isLoggable(LogLevel.ERROR)) sPrinter.e(tag, throwable, message, args);
+    }
+
+    public static void i( String tag, String message, Object... args) {
+        if(isLoggable(LogLevel.INFO)) sPrinter.i(tag, message, args);
+    }
+
+    public static void v( String tag, String message, Object... args) {
+        if(isLoggable(LogLevel.VERBOSE)) sPrinter.v(tag, message, args);
+    }
+
+    public static void w( String tag, String message, Object... args) {
+        if(isLoggable(LogLevel.WARN)) sPrinter.w(tag, message, args);
+    }
+
+    public static void easyLog( String tag, String message) {
+        if(isLoggable(LogLevel.DEBUG)) sPrinter.d(tag, message);
+    }
+
+    public static void json( String tag, String json) {
+        if(isLoggable(LogLevel.DEBUG)) sPrinter.json(tag, json);
+    }
+
+    public static void xml( String tag, String xml) {
+        if(isLoggable(LogLevel.DEBUG)) sPrinter.xml(tag, xml);
+    }
+
+    private static boolean isLoggable(LogLevel logLevel){
+        return sPrinter.getSettings().getLogLevel().level <= logLevel.level;
+    }
+}
diff --git a/foudations/mogo-utils/src/main/java/com/mogo/utils/logger/LoggerPrinter.java b/foudations/mogo-utils/src/main/java/com/mogo/utils/logger/LoggerPrinter.java
new file mode 100644
index 0000000..d822a53
--- /dev/null
+++ b/foudations/mogo-utils/src/main/java/com/mogo/utils/logger/LoggerPrinter.java
@@ -0,0 +1,261 @@
+
+package com.mogo.utils.logger;
+
+import android.text.TextUtils;
+import android.util.Log;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.io.StringReader;
+import java.io.StringWriter;
+
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerException;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.stream.StreamResult;
+import javax.xml.transform.stream.StreamSource;
+
+final class LoggerPrinter implements Printer {
+    private static final String TAG = "LoggerPrinter";
+
+    private static final int CHUNK_SIZE = 4000;
+    private static final int JSON_INDENT = 4;
+    private static final int MIN_STACK_OFFSET = 3;
+    private static final char TOP_LEFT_CORNER = '╔';
+    private static final char BOTTOM_LEFT_CORNER = '╚';
+    private static final char MIDDLE_CORNER = '╟';
+    private static final char HORIZONTAL_DOUBLE_LINE = '║';
+    private static final String DOUBLE_DIVIDER = "════════════════════════════════════════════";
+    private static final String SINGLE_DIVIDER = "────────────────────────────────────────────";
+    private static final String TOP_BORDER = "╔════════════════════════════════════════════════════════════════════════════════════════";
+    private static final String BOTTOM_BORDER = "╚════════════════════════════════════════════════════════════════════════════════════════";
+    private static final String MIDDLE_BORDER = "╟────────────────────────────────────────────────────────────────────────────────────────";
+
+    private final Settings mSettings = new Settings();
+
+    LoggerPrinter() {
+    }
+
+    public Settings init(LogLevel logLevel) {
+        return mSettings.setLogLevel(logLevel);
+    }
+
+    public Settings getSettings() {
+        return mSettings;
+    }
+
+    public void d( String tag, String message, Object... args) {
+        this.log(tag, LogLevel.DEBUG, message, args);
+    }
+
+    public void e( String tag, String message, Object... args) {
+        this.e(tag, null, message, args);
+    }
+
+    public void e( String tag, Throwable throwable, String message, Object... args) {
+        if (throwable != null && message != null) {
+            message = message + " : " + Log.getStackTraceString( throwable);
+        }
+
+        if (throwable != null && message == null) {
+            message = throwable.toString();
+        }
+
+        if (message == null) {
+            message = "No message/exception is set";
+        }
+
+        this.log(tag, LogLevel.ERROR, message, args);
+    }
+
+    public void w( String tag, String message, Object... args) {
+        this.log(tag, LogLevel.WARN, message, args);
+    }
+
+    public void i( String tag, String message, Object... args) {
+        this.log(tag, LogLevel.INFO, message, args);
+    }
+
+    public void v( String tag, String message, Object... args) {
+        this.log(tag, LogLevel.VERBOSE, message, args);
+    }
+
+    public void json( String tag, String json) {
+        if ( TextUtils.isEmpty(json)) {
+            this.d(tag, "Empty/Null json content");
+        } else {
+            try {
+                String message;
+                if (json.startsWith("{")) {
+                    JSONObject e1 = new JSONObject(json);
+                    message = e1.toString(4);
+                    this.d(tag, message);
+                    return;
+                }
+
+                if (json.startsWith("[")) {
+                    JSONArray e = new JSONArray(json);
+                    message = e.toString(4);
+                    this.d(tag, message);
+                }
+            } catch ( JSONException var4) {
+                this.e(tag, var4.getCause().getMessage() + "\n" + json);
+            }
+
+        }
+    }
+
+    public void xml( String tag, String xml) {
+        if ( TextUtils.isEmpty(xml)) {
+            this.d(tag, "Empty/Null xml content");
+        } else {
+            try {
+                StreamSource e = new StreamSource(new StringReader(xml));
+                StreamResult xmlOutput = new StreamResult(new StringWriter());
+                Transformer transformer = TransformerFactory.newInstance().newTransformer();
+                transformer.setOutputProperty("indent", "yes");
+                transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");
+                transformer.transform(e, xmlOutput);
+                this.d(tag, xmlOutput.getWriter().toString().replaceFirst(">", ">\n"));
+            } catch ( TransformerException var5) {
+                this.e(tag, var5.getCause().getMessage() + "\n" + xml);
+            }
+
+        }
+    }
+
+    public void normalLog( String tag, String message) {
+        if (!TextUtils.isEmpty(message)) {
+            this.logChunk(LogLevel.DEBUG, tag, message);
+        }
+    }
+
+    private synchronized void log(String tag, LogLevel logLevel, String msg, Object... args) {
+        String message = this.createMessage(msg, args);
+        int methodCount = this.getMethodCount();
+        this.logTopBorder(logLevel, tag);
+        this.logHeaderContent(logLevel, tag, methodCount);
+        byte[] bytes = message.getBytes();
+        int length = bytes.length;
+        if (length <= 4000) {
+            if (methodCount > 0) {
+                this.logDivider(logLevel, tag);
+            }
+
+            this.logContent(logLevel, tag, message);
+            this.logBottomBorder(logLevel, tag);
+        } else {
+            if (methodCount > 0) {
+                this.logDivider(logLevel, tag);
+            }
+
+            for (int i = 0; i < length; i += 4000) {
+                int count = Math.min(length - i, 4000);
+                this.logContent(logLevel, tag, new String(bytes, i, count));
+            }
+
+            this.logBottomBorder(logLevel, tag);
+        }
+    }
+
+    private void logTopBorder(LogLevel logLevel, String tag) {
+        this.logChunk(logLevel, tag, "╔════════════════════════════════════════════════════════════════════════════════════════");
+    }
+
+    private void logHeaderContent(LogLevel logLevel, String tag, int methodCount) {
+        StackTraceElement[] trace = Thread.currentThread().getStackTrace();
+        if (mSettings.isShowThreadInfo()) {
+            this.logChunk(logLevel, tag, "║ Thread: " + Thread.currentThread().getName());
+            this.logDivider(logLevel, tag);
+        }
+
+        String level = "";
+        int stackOffset = this.getStackOffset(trace) + mSettings.getMethodOffset();
+        if (methodCount + stackOffset > trace.length) {
+            methodCount = trace.length - stackOffset - 1;
+        }
+
+        for (int i = methodCount; i > 0; --i) {
+            int stackIndex = i + stackOffset;
+            if (stackIndex < trace.length) {
+                StringBuilder builder = new StringBuilder();
+                builder.append("║ ").append(level).append(this.getSimpleClassName(trace[stackIndex].getClassName())).append(".").append(trace[stackIndex].getMethodName()).append(" ").append(" (").append(trace[stackIndex].getFileName()).append(":").append(trace[stackIndex].getLineNumber()).append(")");
+                level = level + "   ";
+                this.logChunk(logLevel, tag, builder.toString());
+            }
+        }
+
+    }
+
+    private void logBottomBorder(LogLevel logLevel, String tag) {
+        this.logChunk(logLevel, tag, "╚════════════════════════════════════════════════════════════════════════════════════════");
+    }
+
+    private void logDivider(LogLevel logLevel, String tag) {
+        this.logChunk(logLevel, tag, "╟────────────────────────────────────────────────────────────────────────────────────────");
+    }
+
+    private void logContent(LogLevel logLevel, String tag, String chunk) {
+        String[] lines = chunk.split( System.getProperty("line.separator"));
+
+        for ( String line : lines) {
+            this.logChunk(logLevel, tag, "║ " + line);
+        }
+    }
+
+    private void logChunk(LogLevel logLevel, String tag, String chunk) {
+        String finalTag = this.checkTag(tag);
+        switch (logLevel) {
+            case VERBOSE:
+                Log.v(finalTag, chunk);
+                break;
+            case INFO:
+                Log.i(finalTag, chunk);
+                break;
+            case DEBUG:
+                Log.d(finalTag, chunk);
+                break;
+            case WARN:
+                Log.w(finalTag, chunk);
+                break;
+            case ERROR:
+                Log.e(finalTag, chunk);
+                break;
+            case OFF:
+                break;
+        }
+
+    }
+
+    private String getSimpleClassName( String name) {
+        int lastIndex = name.lastIndexOf(".");
+        return name.substring(lastIndex + 1);
+    }
+
+    private String checkTag( String tag) {
+        return TextUtils.isEmpty(tag) ? TAG : tag;
+    }
+
+    private String createMessage( String message, Object... args) {
+        return (args == null || args.length == 0) ? message : String.format(message, args);
+    }
+
+    private int getMethodCount() {
+        return mSettings.getMethodCount();
+    }
+
+    private int getStackOffset( StackTraceElement[] trace) {
+        for (int i = 3; i < trace.length; ++i) {
+            StackTraceElement e = trace[i];
+            String name = e.getClassName();
+            if (!name.equals(LoggerPrinter.class.getName()) && !name.equals(Logger.class.getName())) {
+                --i;
+                return i;
+            }
+        }
+
+        return -1;
+    }
+}
diff --git a/foudations/mogo-utils/src/main/java/com/mogo/utils/logger/Printer.java b/foudations/mogo-utils/src/main/java/com/mogo/utils/logger/Printer.java
new file mode 100644
index 0000000..7bfec3f
--- /dev/null
+++ b/foudations/mogo-utils/src/main/java/com/mogo/utils/logger/Printer.java
@@ -0,0 +1,26 @@
+
+package com.mogo.utils.logger;
+
+public interface Printer {
+    Settings init(LogLevel logLevel);
+
+    Settings getSettings();
+
+    void d(String tag, String message, Object... args);
+
+    void e(String tag, String message, Object... args);
+
+    void e(String tag, Throwable throwable, String message, Object... args);
+
+    void w(String tag, String message, Object... args);
+
+    void i(String tag, String message, Object... args);
+
+    void v(String tag, String message, Object... args);
+
+    void json(String tag, String json);
+
+    void xml(String tag, String xml);
+
+    void normalLog(String tag, String message);
+}
diff --git a/foudations/mogo-utils/src/main/java/com/mogo/utils/logger/Settings.java b/foudations/mogo-utils/src/main/java/com/mogo/utils/logger/Settings.java
new file mode 100644
index 0000000..af6ec22
--- /dev/null
+++ b/foudations/mogo-utils/src/main/java/com/mogo/utils/logger/Settings.java
@@ -0,0 +1,52 @@
+
+package com.mogo.utils.logger;
+
+public final class Settings {
+    private int methodCount = 2;
+    private boolean showThreadInfo = true;
+    private int methodOffset = 0;
+    private LogLevel logLevel = LogLevel.DEBUG;
+
+    public Settings() {
+    }
+
+    public Settings hideThreadInfo() {
+        this.showThreadInfo = false;
+        return this;
+    }
+
+    public Settings setMethodCount(int methodCount) {
+        if(methodCount < 0) {
+            methodCount = 0;
+        }
+
+        this.methodCount = methodCount;
+        return this;
+    }
+
+    public Settings setLogLevel(LogLevel logLevel) {
+        this.logLevel = logLevel;
+        return this;
+    }
+
+    public Settings setMethodOffset(int offset) {
+        this.methodOffset = offset;
+        return this;
+    }
+
+    public int getMethodCount() {
+        return this.methodCount;
+    }
+
+    public boolean isShowThreadInfo() {
+        return this.showThreadInfo;
+    }
+
+    public LogLevel getLogLevel() {
+        return this.logLevel;
+    }
+
+    public int getMethodOffset() {
+        return this.methodOffset;
+    }
+}
diff --git a/foudations/mogo-utils/src/main/java/com/mogo/utils/storage/SharedPrefsMgr.java b/foudations/mogo-utils/src/main/java/com/mogo/utils/storage/SharedPrefsMgr.java
new file mode 100644
index 0000000..c57aa62
--- /dev/null
+++ b/foudations/mogo-utils/src/main/java/com/mogo/utils/storage/SharedPrefsMgr.java
@@ -0,0 +1,154 @@
+package com.mogo.utils.storage;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.support.annotation.NonNull;
+
+
+import java.util.Set;
+
+public class SharedPrefsMgr {
+
+    private static final String File_Name = "app_shared_pref";
+    private static SharedPrefsMgr sInstance;
+    private static SharedPreferences sSharedPrefs;
+
+    public synchronized static SharedPrefsMgr getInstance(@NonNull Context context ) {
+        if ( sInstance == null ) {
+            try {
+                sInstance = new SharedPrefsMgr( context.getApplicationContext() );
+            } catch ( Exception e ) {
+                sInstance = new SharedPrefsMgr();
+            }
+        }
+        return sInstance;
+    }
+
+    private SharedPrefsMgr() {
+
+    }
+
+    private SharedPrefsMgr( Context context ) {
+        try {
+            sSharedPrefs = context.getSharedPreferences( File_Name, Context.MODE_PRIVATE );
+        } catch ( Exception e ) {
+            e.printStackTrace();
+        }
+    }
+
+    public void putString( String key, String value ) {
+        try {
+            SharedPreferences.Editor editor = sSharedPrefs.edit();
+            editor.putString( key, value );
+            editor.apply();
+        } catch ( Exception e ) {
+        }
+    }
+
+    public String getString( String tag ) {
+        try {
+            return sSharedPrefs.getString( tag, "" );
+        } catch ( Exception e ) {
+            return "";
+        }
+    }
+
+    public String getString( String tag, String defVal ) {
+        try {
+            return sSharedPrefs.getString( tag, defVal );
+        } catch ( Exception e ) {
+            return "";
+        }
+    }
+
+    public boolean getBoolean( String key, boolean defaultValue ) {
+        try {
+            return sSharedPrefs.getBoolean( key, defaultValue );
+        } catch ( Exception e ) {
+            return defaultValue;
+        }
+    }
+
+    public long getLong( String key, long defaultValue ) {
+        try {
+            return sSharedPrefs.getLong( key, defaultValue );
+        } catch ( Exception e ) {
+            return defaultValue;
+        }
+    }
+
+    public float getFloat( String key, float defaultValue ) {
+        try {
+            return sSharedPrefs.getFloat( key, defaultValue );
+        } catch ( Exception e ) {
+            return defaultValue;
+        }
+    }
+
+    public int getInt( String key, int value ) {
+        try {
+            return sSharedPrefs.getInt( key, value );
+        } catch ( Exception e ) {
+            return value;
+        }
+    }
+
+    public void putBoolean( String key, boolean value ) {
+        try {
+            SharedPreferences.Editor editor = sSharedPrefs.edit();
+            editor.putBoolean( key, value );
+            editor.apply();
+        } catch ( Exception e ) {
+        }
+    }
+
+    public void putLong( String key, long value ) {
+        try {
+            SharedPreferences.Editor editor = sSharedPrefs.edit();
+            editor.putLong( key, value );
+            editor.apply();
+        } catch ( Exception e ) {
+        }
+    }
+
+    public void putInt( String key, int value ) {
+        try {
+            SharedPreferences.Editor editor = sSharedPrefs.edit();
+            editor.putInt( key, value );
+            editor.apply();
+        } catch ( Exception e ) {
+        }
+    }
+
+    public void putFloat( String key, float value ) {
+        try {
+            SharedPreferences.Editor editor = sSharedPrefs.edit();
+            editor.putFloat( key, value );
+            editor.apply();
+        } catch ( Exception e ) {
+        }
+    }
+
+    public void remove( String key ) {
+        try {
+            SharedPreferences.Editor editor = sSharedPrefs.edit();
+            editor.remove( key );
+            editor.apply();
+        } catch ( Exception e ) {
+        }
+    }
+
+    public void putStringSet( String key, Set< String > values ) {
+        try {
+            SharedPreferences.Editor editor = sSharedPrefs.edit();
+            editor.putStringSet( key, values );
+            editor.apply();
+        } catch ( Exception e ) {
+        }
+    }
+
+    public Set<String> getStringSet( String key ) {
+        return sSharedPrefs.getStringSet( key, null );
+    }
+
+}
\ No newline at end of file
diff --git a/foudations/mogo-utils/src/main/java/com/mogo/utils/storage/lrucache/CacheUtil.java b/foudations/mogo-utils/src/main/java/com/mogo/utils/storage/lrucache/CacheUtil.java
new file mode 100644
index 0000000..ca7c761
--- /dev/null
+++ b/foudations/mogo-utils/src/main/java/com/mogo/utils/storage/lrucache/CacheUtil.java
@@ -0,0 +1,77 @@
+/*
+ * 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.utils.storage.lrucache;
+
+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 CacheUtil {
+  static final Charset US_ASCII = Charset.forName("US-ASCII");
+  static final Charset UTF_8 = Charset.forName("UTF-8");
+
+  private CacheUtil() {
+  }
+
+  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 imageContent 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) {
+      }
+    }
+  }
+}
diff --git a/foudations/mogo-utils/src/main/java/com/mogo/utils/storage/lrucache/DiskCacheManager.java b/foudations/mogo-utils/src/main/java/com/mogo/utils/storage/lrucache/DiskCacheManager.java
new file mode 100644
index 0000000..a37aa56
--- /dev/null
+++ b/foudations/mogo-utils/src/main/java/com/mogo/utils/storage/lrucache/DiskCacheManager.java
@@ -0,0 +1,374 @@
+package com.mogo.utils.storage.lrucache;
+
+import android.content.Context;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Serializable;
+
+public class DiskCacheManager {
+
+    private static DiskLruCache mDiskLruCache = null;
+    private DiskLruCache.Editor mEditor = null;
+    private DiskLruCache.Snapshot mSnapshot = null;
+    public static final long CACHE_MAXSIZE = 10 * 1024 * 1024;
+
+    public DiskCacheManager( Context context, String uniqueName) {
+        try {
+            if (mDiskLruCache != null) {
+                mDiskLruCache.close();
+                mDiskLruCache = null;
+            }
+            File cacheFile = getCacheFile(context, uniqueName);
+            mDiskLruCache = DiskLruCache.open(cacheFile, 1, 1, CACHE_MAXSIZE);
+        } catch ( IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * 获取缓存的路径 两个路径在卸载程序时都会删除，因此不会在卸载后还保留乱七八糟的缓存
+     * 有SD卡时获取  /sdcard/Android/data/<application package>/cache
+     * 无SD卡时获取  /data/labelList/<application package>/cache
+     *
+     * @param context    上下文
+     * @param uniqueName 缓存目录下的细分目录，用于存放不同类型的缓存
+     * @return 缓存目录 File
+     */
+    private File getCacheFile( Context context, String uniqueName) {
+        String cachePath = null;
+        try {
+            cachePath = context.getCacheDir().getPath();
+        }catch ( Exception e){
+            e.printStackTrace();
+        }
+        return new File(cachePath + File.separator + uniqueName);
+    }
+
+    /**
+     * 获取缓存 editor
+     *
+     * @param key 缓存的key
+     * @return editor
+     * @throws IOException
+     */
+    private DiskLruCache.Editor edit( String key) throws IOException {
+        key = SecretUtil.getMD5Result(key); //存取的 key
+        if (mDiskLruCache != null) {
+            mEditor = mDiskLruCache.edit(key);
+        }
+        return mEditor;
+    }
+
+    /**
+     * 根据 key 获取缓存缩略
+     *
+     * @param key 缓存的key
+     * @return Snapshot
+     */
+    private DiskLruCache.Snapshot snapshot( String key) {
+        if (mDiskLruCache != null) {
+            try {
+                mSnapshot = mDiskLruCache.get(key);
+            } catch ( IOException e) {
+                e.printStackTrace();
+            }
+        }
+        return mSnapshot;
+    }
+    /*************************
+     * 字符串读写
+     *************************/
+    /**
+     * 缓存 String
+     *
+     * @param key   缓存文件键值（MD5加密结果作为缓存文件名）
+     * @param value 缓存内容
+     */
+    public void put( String key, String value) {
+        DiskLruCache.Editor editor = null;
+        BufferedWriter writer = null;
+        try {
+            editor = edit(key);
+            if (editor == null) {
+                return;
+            }
+            OutputStream os = editor.newOutputStream(0);
+            writer = new BufferedWriter(new OutputStreamWriter(os));
+            writer.write(value);
+            editor.commit();
+        } catch ( IOException e) {
+            e.printStackTrace();
+            try {
+                if (editor != null)
+                    editor.abort();
+            } catch ( IOException e1) {
+                e1.printStackTrace();
+            }
+        } finally {
+            try {
+                if (writer != null) {
+                    writer.close();
+                }
+            } catch ( IOException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    /**
+     * 获取字符串缓存
+     *
+     * @param key cache'key
+     * @return string
+     */
+    public String getString( String key) {
+        InputStream inputStream = getCacheInputStream(key);
+        if (inputStream == null) {
+            return null;
+        }
+        try {
+            return inputStream2String(inputStream);
+        } catch ( IOException e) {
+            e.printStackTrace();
+            return null;
+        } finally {
+            try {
+                inputStream.close();
+            } catch ( IOException e1) {
+                e1.printStackTrace();
+            }
+        }
+    }
+
+    /*************************
+     * Json对象读写
+     *************************/
+    //Json 数据转换成 String 存储
+    public void put( String key, JSONObject value) {
+        put(key, value.toString());
+    }
+
+    //取得 json 字符串再转为 Json对象
+    public JSONObject getJsonObject( String key) {
+        String json = getString(key);
+        try {
+            return new JSONObject(json);
+        } catch ( JSONException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    /*************************
+     * Json数组对象读写
+     *************************/
+
+    public void put( String key, JSONArray array) {
+        put(key, array.toString());
+    }
+
+    public JSONArray getJsonArray( String key) {
+        try {
+            return new JSONArray(getString(key));
+        } catch ( JSONException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    /*************************
+     * byte 数据读写
+     *************************/
+    /**
+     * 存入byte数组
+     *
+     * @param key   cache'key
+     * @param bytes bytes to save
+     */
+    public void put( String key, byte[] bytes) {
+        OutputStream out = null;
+        DiskLruCache.Editor editor = null;
+        try {
+            editor = edit(key);
+            if (editor == null) {
+                return;
+            }
+            out = editor.newOutputStream(0);
+            out.write(bytes);
+            out.flush();
+            editor.commit();
+        } catch ( IOException e) {
+            e.printStackTrace();
+            try {
+                if (editor != null) {
+                    editor.abort();
+                }
+            } catch ( IOException e1) {
+                e1.printStackTrace();
+            }
+        } finally {
+            if (out != null) {
+                try {
+                    out.close();
+                } catch ( IOException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+
+    /**
+     * 获取缓存的 byte 数组
+     *
+     * @param key cache'key
+     * @return bytes
+     */
+    public byte[] getBytes( String key) {
+        byte[] bytes = null;
+        InputStream inputStream = getCacheInputStream(key);
+        if (inputStream == null) {
+            return null;
+        }
+        ByteArrayOutputStream bos = new ByteArrayOutputStream();
+        byte[] buf = new byte[256];
+        int len = 0;
+        try {
+            while ((len = inputStream.read(buf)) != -1) {
+                bos.write(buf, 0, len);
+            }
+            bytes = bos.toByteArray();
+        } catch ( IOException e) {
+            e.printStackTrace();
+        }
+        return bytes;
+    }
+
+    /*************************
+     * 序列化对象数据读写
+     *************************/
+
+    /**
+     * 序列化对象写入
+     *
+     * @param key    cache'key
+     * @param object 待缓存的序列化对象
+     */
+    public void put( String key, Serializable object) {
+        ObjectOutputStream oos = null;
+        DiskLruCache.Editor editor = null;
+        try {
+            editor = edit(key);
+            if (editor == null) {
+                return;
+            }
+            oos = new ObjectOutputStream(editor.newOutputStream(0));
+            oos.writeObject(object);
+            oos.flush();
+            editor.commit();
+        } catch ( IOException e) {
+            e.printStackTrace();
+            try {
+                if (editor != null)
+                    editor.abort();
+            } catch ( IOException e1) {
+                e1.printStackTrace();
+            }
+        } finally {
+            try {
+                if (oos != null) {
+                    oos.close();
+                }
+            } catch ( IOException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    /**
+     * 获取 序列化对象
+     *
+     * @param key cache'key
+     * @param <T> 对象类型
+     * @return 读取到的序列化对象
+     */
+    @SuppressWarnings("unchecked")
+    public <T> T getSerializable( String key) {
+        T object = null;
+        ObjectInputStream ois = null;
+        InputStream in = getCacheInputStream(key);
+        if (in == null) {
+            return null;
+        }
+        try {
+            ois = new ObjectInputStream(in);
+            object = (T) ois.readObject();
+        } catch ( IOException | ClassNotFoundException e) {
+            e.printStackTrace();
+        }
+        return object;
+    }
+
+
+    /************************************************************************
+     **********************  辅助工具方法 分割线  ****************************
+     ************************************************************************/
+    /**
+     * inputStream 转 String
+     *
+     * @param is 输入流
+     * @return 结果字符串
+     */
+    private String inputStream2String( InputStream is) throws IOException {
+        BufferedReader in = new BufferedReader(new InputStreamReader(is, "UTF-8"));
+        StringBuilder buffer = new StringBuilder();
+        String line;
+        while ((line = in.readLine()) != null) {
+            buffer.append(line);
+        }
+        return buffer.toString();
+    }
+
+    /**
+     * 获取 缓存数据的 InputStream
+     *
+     * @param key cache'key
+     * @return InputStream
+     */
+    private InputStream getCacheInputStream( String key) {
+        key = SecretUtil.getMD5Result(key);
+        InputStream in;
+        DiskLruCache.Snapshot snapshot = snapshot(key);
+        if (snapshot == null) {
+            return null;
+        }
+        in = snapshot.getInputStream(0);
+        return in;
+    }
+
+    /**
+     * 同步记录文件
+     */
+    public static void flush() {
+        if (mDiskLruCache != null) {
+            try {
+                mDiskLruCache.flush();
+            } catch ( IOException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+}
diff --git a/foudations/mogo-utils/src/main/java/com/mogo/utils/storage/lrucache/DiskLruCache.java b/foudations/mogo-utils/src/main/java/com/mogo/utils/storage/lrucache/DiskLruCache.java
new file mode 100644
index 0000000..6e945af
--- /dev/null
+++ b/foudations/mogo-utils/src/main/java/com/mogo/utils/storage/lrucache/DiskLruCache.java
@@ -0,0 +1,947 @@
+/*
+ * 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.utils.storage.lrucache;
+
+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,120}</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.
+ */
+public 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 String STRING_KEY_PATTERN = "[a-z0-9_-]{1,120}";
+  static final Pattern LEGAL_KEY_PATTERN = Pattern.compile(STRING_KEY_PATTERN);
+  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 final int valueCount;
+  private long size = 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();
+        if (journalRebuildRequired()) {
+          rebuildJournal();
+          redundantOpCount = 0;
+        }
+      }
+      return null;
+    }
+  };
+
+  private DiskLruCache( File directory, int appVersion, int valueCount, long maxSize) {
+    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;
+  }
+
+  /**
+   * 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
+   * @throws IOException if reading or writing the cache directory fails
+   */
+  public static DiskLruCache open(File directory, int appVersion, int valueCount, long maxSize)
+      throws IOException {
+    if (maxSize <= 0) {
+      throw new IllegalArgumentException("maxSize <= 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);
+    if (cache.journalFile.exists()) {
+      try {
+        cache.readJournal();
+        cache.processJournal();
+        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);
+    cache.rebuildJournal();
+    return cache;
+  }
+
+  private void readJournal() throws IOException {
+    StrictLineReader reader = new StrictLineReader(new FileInputStream(journalFile), CacheUtil.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();
+
+      // If we ended on a truncated line, rebuild the journal before appending to it.
+      if (reader.hasUnterminatedLine()) {
+        rebuildJournal();
+      } else {
+        journalWriter = new BufferedWriter(new OutputStreamWriter(
+            new FileOutputStream(journalFile, true), CacheUtil.US_ASCII));
+      }
+    } finally {
+      CacheUtil.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];
+        }
+      } 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), CacheUtil.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), CacheUtil.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.
+    InputStream[] ins = new InputStream[valueCount];
+    try {
+      for (int i = 0; i < valueCount; i++) {
+        ins[i] = new FileInputStream(entry.getCleanFile(i));
+      }
+    } catch ( FileNotFoundException e) {
+      // A file must have been deleted manually!
+      for (int i = 0; i < valueCount; i++) {
+        if (ins[i] != null) {
+          CacheUtil.closeQuietly(ins[i]);
+        } else {
+          break;
+        }
+      }
+      return null;
+    }
+
+    redundantOpCount++;
+    journalWriter.append(READ + ' ' + key + '\n');
+    if (journalRebuildRequired()) {
+      executorService.submit(cleanupCallable);
+    }
+
+    return new Snapshot(key, entry.sequenceNumber, 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;
+  }
+
+  /**
+   * 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;
+  }
+
+  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;
+        }
+      } 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 || 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];
+      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();
+    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();
+    journalWriter.close();
+    journalWriter = null;
+  }
+
+  private void trimToSize() throws IOException {
+    while (size > maxSize) {
+      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();
+    CacheUtil.deleteContents(directory);
+  }
+
+  private void validateKey( String key) {
+    Matcher matcher = LEGAL_KEY_PATTERN.matcher(key);
+    if (!matcher.matches()) {
+      throw new IllegalArgumentException("keys must match regex "
+              + STRING_KEY_PATTERN + ": \"" + key + "\"");
+    }
+  }
+
+  private static String inputStreamToString( InputStream in) throws IOException {
+    return CacheUtil.readFully(new InputStreamReader(in, CacheUtil.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 final InputStream[] ins;
+    private final long[] lengths;
+
+    private Snapshot( String key, long sequenceNumber, InputStream[] ins, long[] lengths) {
+      this.key = key;
+      this.sequenceNumber = sequenceNumber;
+      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 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) {
+        CacheUtil.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 {
+      if (index < 0 || index >= valueCount) {
+        throw new IllegalArgumentException("Expected index " + index + " to "
+                + "be greater than 0 and less than the maximum value count "
+                + "of " + valueCount);
+      }
+      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), CacheUtil.UTF_8);
+        writer.write(value);
+      } finally {
+        CacheUtil.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");
+    }
+  }
+}
diff --git a/foudations/mogo-utils/src/main/java/com/mogo/utils/storage/lrucache/SecretUtil.java b/foudations/mogo-utils/src/main/java/com/mogo/utils/storage/lrucache/SecretUtil.java
new file mode 100644
index 0000000..dc833b9
--- /dev/null
+++ b/foudations/mogo-utils/src/main/java/com/mogo/utils/storage/lrucache/SecretUtil.java
@@ -0,0 +1,34 @@
+package com.mogo.utils.storage.lrucache;
+import java.io.UnsupportedEncodingException;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+
+public class SecretUtil {
+
+    public static String getMD5Result( String value) {
+        try {
+            MessageDigest md = MessageDigest.getInstance("MD5");
+            md.update(value.getBytes("UTF-8"));
+            byte[] result = md.digest();
+            return getString(result);
+        } catch ( NoSuchAlgorithmException e) {
+            e.printStackTrace();
+            return "";
+        } catch ( UnsupportedEncodingException e) {
+            e.printStackTrace();
+            return "";
+        }
+    }
+
+    private static String getString( byte[] result) {
+        StringBuilder sb = new StringBuilder();
+        for (byte b : result) {
+            int i = b & 0xff;
+            if (i <= 0xf) {
+                sb.append(0);
+            }
+            sb.append( Integer.toHexString(i));
+        }
+        return sb.toString().toLowerCase();
+    }
+}
diff --git a/foudations/mogo-utils/src/main/java/com/mogo/utils/storage/lrucache/StrictLineReader.java b/foudations/mogo-utils/src/main/java/com/mogo/utils/storage/lrucache/StrictLineReader.java
new file mode 100644
index 0000000..5ee84ab
--- /dev/null
+++ b/foudations/mogo-utils/src/main/java/com/mogo/utils/storage/lrucache/StrictLineReader.java
@@ -0,0 +1,196 @@
+/*
+ * 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.utils.storage.lrucache;
+
+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(CacheUtil.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 labelList.
+      // 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();
+          }
+        }
+      }
+    }
+  }
+
+  public boolean hasUnterminatedLine() {
+    return end == -1;
+  }
+
+  /**
+   * 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;
+  }
+}
+
diff --git a/gradle.properties b/gradle.properties
index a980ec8..a425807 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1,35 +1,40 @@
 # Project-wide Gradle settings.
 # IDE (e.g. Android Studio) users:
-# Gradle settings configured through the IDE *will override*
-# any settings specified in this file.
+# Settings specified in this file will override any Gradle settings
+# configured through the IDE.
 # For more details on how to configure your build environment visit
 # http://www.gradle.org/docs/current/userguide/build_environment.html
+# The Gradle daemon aims to improve the startup and execution time of Gradle.
+# When set to true the Gradle daemon is to run the build.
+org.gradle.daemon=true
 # Specifies the JVM arguments used for the daemon process.
 # The setting is particularly useful for tweaking memory settings.
-org.gradle.jvmargs=-Xmx2048m
+# Default value: -Xmx10248m -XX:MaxPermSize=256m
+org.gradle.jvmargs=-Xmx2048m -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
 # When configured, Gradle will run in incubating parallel mode.
 # This option should only be used with decoupled projects. More details, visit
 # http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
-# org.gradle.parallel=true
-# AndroidX package structure to make it clearer which packages are bundled with the
-# Android operating system, and which are packaged with your app"s APK
-# https://developer.android.com/topic/libraries/support-library/androidx-rn
-android.useAndroidX=true
-# Automatically convert third-party libraries to use AndroidX
-android.enableJetifier=true
+org.gradle.parallel=true
+# Enables new incubating mode that makes Gradle selective when configuring projects.
+# Only relevant projects are configured which results in faster builds for large multi-projects.
+# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:configuration_on_demand
+org.gradle.configureondemand=true
+# Kotlin code style for this project: "official" or "obsolete":
+kotlin.code.style=official
 ## maven 配置
 RELEASE_REPOSITORY_URL=http://nexus.zhidaoauto.com/repository/maven-releases/
 SNAPSHOT_REPOSITORY_URL=http://nexus.zhidaoauto.com/repository/maven-snapshots/
 USERNAME=xintai
 PASSWORD=xintai2018
 # 编译模式: false - 依赖本地版本， true - 依赖 maven 版本
-RELEASE=false
+RELEASE=true
 # AI CLOUD 云平台
-MOGO_NETWORK_VERSION=1.0.12-SNAPSHOT
-MOGO_HTTPDNS_VERSION=1.0.12-SNAPSHOT
-MOGO_PASSPORT_VERSION=1.0.12-SNAPSHOT
-MOGO_SOCKET_VERSION=1.0.12-SNAPSHOT
-MOGO_REALTIME_VERSION=1.0.12-SNAPSHOT
-MOGO_TANLU_VERSION=1.0.12-SNAPSHOT
-MOGO_LIVE_VERSION=1.0.12-SNAPSHOT
-MOGO_TRAFFICLIVE_VERSION=1.0.12-SNAPSHOT
+MOGO_UTILS_VERSION=1.0.13-SNAPSHOT
+MOGO_NETWORK_VERSION=1.0.13-SNAPSHOT
+MOGO_HTTPDNS_VERSION=1.0.13-SNAPSHOT
+MOGO_PASSPORT_VERSION=1.0.13-SNAPSHOT
+MOGO_SOCKET_VERSION=1.0.13-SNAPSHOT
+MOGO_REALTIME_VERSION=1.0.13-SNAPSHOT
+MOGO_TANLU_VERSION=1.0.13-SNAPSHOT
+MOGO_LIVE_VERSION=1.0.13-SNAPSHOT
+MOGO_TRAFFICLIVE_VERSION=1.0.13-SNAPSHOT
diff --git a/modules.txt b/modules.txt
index 5881de5..9c3c2e8 100644
--- a/modules.txt
+++ b/modules.txt
@@ -1,3 +1,4 @@
+:foudations:mogo-utils
 :foudations:mogo-httpdns
 :foudations:mogo-passport
 :foudations:mogo-network
diff --git a/modules/mogo-realtime/src/main/java/com/mogo/realtime/core/SimpleLocationCorrectStrategy.java b/modules/mogo-realtime/src/main/java/com/mogo/realtime/core/SimpleLocationCorrectStrategy.java
index f50927d..ac806c5 100644
--- a/modules/mogo-realtime/src/main/java/com/mogo/realtime/core/SimpleLocationCorrectStrategy.java
+++ b/modules/mogo-realtime/src/main/java/com/mogo/realtime/core/SimpleLocationCorrectStrategy.java
@@ -1,8 +1,7 @@
 package com.mogo.realtime.core;
 
 import android.os.SystemClock;
-
-import androidx.annotation.Keep;
+import android.support.annotation.Keep;
 
 import com.mogo.cloud.commons.utils.CoordinateUtils;
 import com.mogo.cloud.passport.MoGoAiCloudClient;
diff --git a/modules/mogo-realtime/src/main/java/com/mogo/realtime/core/UploadInTimeHandler.java b/modules/mogo-realtime/src/main/java/com/mogo/realtime/core/UploadInTimeHandler.java
index 700ff2c..9ed7490 100644
--- a/modules/mogo-realtime/src/main/java/com/mogo/realtime/core/UploadInTimeHandler.java
+++ b/modules/mogo-realtime/src/main/java/com/mogo/realtime/core/UploadInTimeHandler.java
@@ -2,8 +2,7 @@ package com.mogo.realtime.core;
 
 import android.os.Handler;
 import android.os.Message;
-
-import androidx.annotation.Keep;
+import android.support.annotation.Keep;
 
 import com.mogo.utils.WorkThreadHandler;
 
diff --git a/modules/mogo-realtime/src/main/java/com/mogo/realtime/entity/CloudLocationInfo.java b/modules/mogo-realtime/src/main/java/com/mogo/realtime/entity/CloudLocationInfo.java
index 919bf0e..d2b6259 100644
--- a/modules/mogo-realtime/src/main/java/com/mogo/realtime/entity/CloudLocationInfo.java
+++ b/modules/mogo-realtime/src/main/java/com/mogo/realtime/entity/CloudLocationInfo.java
@@ -3,7 +3,7 @@ package com.mogo.realtime.entity;
 import android.os.Build;
 import android.os.Parcel;
 import android.os.Parcelable;
-import androidx.annotation.RequiresApi;
+import android.support.annotation.RequiresApi;
 
 import com.mogo.cloud.commons.utils.CoordinateUtils;
 
diff --git a/modules/mogo-realtime/src/main/java/com/mogo/realtime/socket/SocketHandler.java b/modules/mogo-realtime/src/main/java/com/mogo/realtime/socket/SocketHandler.java
index 8e60e8f..2adf80b 100644
--- a/modules/mogo-realtime/src/main/java/com/mogo/realtime/socket/SocketHandler.java
+++ b/modules/mogo-realtime/src/main/java/com/mogo/realtime/socket/SocketHandler.java
@@ -16,8 +16,8 @@ import com.mogo.realtime.entity.MogoSnapshotSetData;
 import com.mogo.realtime.entity.OnePerSecondSendContent;
 import com.mogo.realtime.spi.RealTimeProviderImp;
 import com.mogo.realtime.util.MortonCode;
+import com.mogo.utils.GsonUtil;
 import com.mogo.utils.logger.Logger;
-import com.mogo.utils.network.utils.GsonUtil;
 import com.zhidao.ptech.connsvr.protocol.MogoConnsvr;
 
 import java.util.ArrayList;
diff --git a/modules/mogo-realtime/src/main/java/com/mogo/realtime/util/MogoLatLng.java b/modules/mogo-realtime/src/main/java/com/mogo/realtime/util/MogoLatLng.java
index 99ccc37..df38fdb 100644
--- a/modules/mogo-realtime/src/main/java/com/mogo/realtime/util/MogoLatLng.java
+++ b/modules/mogo-realtime/src/main/java/com/mogo/realtime/util/MogoLatLng.java
@@ -3,8 +3,7 @@ package com.mogo.realtime.util;
 import android.os.Build;
 import android.os.Parcel;
 import android.os.Parcelable;
-
-import androidx.annotation.RequiresApi;
+import android.support.annotation.RequiresApi;
 
 import java.util.Objects;
 
diff --git a/modules/mogo-tanlu/src/main/java/com/mogo/cloud/tanlu/api/MogoRoadSearchManager.java b/modules/mogo-tanlu/src/main/java/com/mogo/cloud/tanlu/api/MogoRoadSearchManager.java
index b6dbed7..801e907 100644
--- a/modules/mogo-tanlu/src/main/java/com/mogo/cloud/tanlu/api/MogoRoadSearchManager.java
+++ b/modules/mogo-tanlu/src/main/java/com/mogo/cloud/tanlu/api/MogoRoadSearchManager.java
@@ -11,7 +11,7 @@ import com.mogo.cloud.tanlu.bean.RoadInfoRequest;
 import com.mogo.cloud.tanlu.bean.RoadInfos;
 import com.mogo.cloud.tanlu.constant.HttpConstant;
 import com.mogo.cloud.tanlu.net.TanluApiService;
-import com.mogo.utils.network.utils.GsonUtil;
+import com.mogo.utils.GsonUtil;
 
 import java.util.HashMap;
 import java.util.Map;
diff --git a/modules/mogo-tanlu/src/main/java/com/mogo/cloud/tanlu/utils/FileUtil.kt b/modules/mogo-tanlu/src/main/java/com/mogo/cloud/tanlu/utils/FileUtil.kt
index 0449e4b..03b2f15 100644
--- a/modules/mogo-tanlu/src/main/java/com/mogo/cloud/tanlu/utils/FileUtil.kt
+++ b/modules/mogo-tanlu/src/main/java/com/mogo/cloud/tanlu/utils/FileUtil.kt
@@ -3,8 +3,7 @@ package com.mogo.cloud.tanlu.utils
 import android.graphics.Bitmap
 import android.media.MediaMetadataRetriever
 import android.os.Environment
-import android.util.Log
-import androidx.annotation.Keep
+import android.support.annotation.Keep
 import java.io.*
 import java.text.SimpleDateFormat
 import java.util.*
diff --git a/modules/mogo-tanlu/src/main/java/com/mogo/cloud/tanlu/utils/TanluUtils.java b/modules/mogo-tanlu/src/main/java/com/mogo/cloud/tanlu/utils/TanluUtils.java
index 6392114..2eef7e2 100644
--- a/modules/mogo-tanlu/src/main/java/com/mogo/cloud/tanlu/utils/TanluUtils.java
+++ b/modules/mogo-tanlu/src/main/java/com/mogo/cloud/tanlu/utils/TanluUtils.java
@@ -1,6 +1,7 @@
 package com.mogo.cloud.tanlu.utils;
 
-import androidx.annotation.Keep;
+
+import android.support.annotation.Keep;
 
 import java.util.regex.Pattern;
 
diff --git a/settings.gradle b/settings.gradle
index 43363df..fe16c67 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -1,5 +1,5 @@
 include ':modules:mogo-trafficlive'
-include ':foudations:mogo-common'
+include ':foudations:mogo-utils'
 include ':foudations:mogo-live'
 include ':foudations:mogo-socket'
 include ':modules:mogo-realtime'