Ui 调整赋值

调整布局
元素adapter
2025-12-08 19:24:56 +08:00 · 2025-12-08 18:54:26 +08:00 · 2025-12-08 18:51:37 +08:00 · 2025-12-08 18:26:52 +08:00 · 2025-12-08 18:12:28 +08:00 · 2025-12-08 15:12:53 +08:00
182 changed files with 6678 additions and 1669 deletions
--- a/app/proguard-rules.pro
+++ b/app/proguard-rules.pro
@ -19,3 +19,48 @@
 # If you keep the line number information, uncomment this to
 # hide the original source file name.
 #-renamesourcefileattribute SourceFile
+
+# 保持 Android 四大组件等系统类
+-keep public class * extends android.app.Activity
+-keep public class * extends android.app.Service
+-keep public class * extends android.content.BroadcastReceiver
+-keep public class * extends android.content.ContentProvider
+-keep public class * extends android.app.Application
+
+# 保持 Native 方法不被混淆
+-keepclasseswithmembernames class * {
+    native <methods>;
+}
+
+# 保持 Parcelable 序列化类不被混淆
+-keep class * implements android.os.Parcelable {
+    public static final android.os.Parcelable$Creator *;
+}
+
+# 保持 Serializable 序列化的类成员不被混淆
+-keepclassmembers class * implements java.io.Serializable {
+    static final long serialVersionUID;
+    private static final java.io.ObjectStreamField[] serialPersistentFields;
+    private void writeObject(java.io.ObjectOutputStream);
+    private void readObject(java.io.ObjectInputStream);
+    java.lang.Object writeReplace();
+    java.lang.Object readResolve();
+}
+
+# 保持自定义 View 的构造方法不被混淆（用于 XML 布局）
+-keep public class * extends android.view.View {
+    public <init>(android.content.Context);
+    public <init>(android.content.Context, android.util.AttributeSet);
+    public <init>(android.content.Context, android.util.AttributeSet, int);
+    public void set*(...);
+}
+
+# 保持枚举类不被混淆
+-keepclassmembers enum * {
+    public static **[] values();
+    public static ** valueOf(java.lang.String);
+}
+
+# 保持由 JSON 转换的 Bean 类（或者你的数据模型类）不被混淆
+-keep class com.gamedog.vididin.beans.** { *; }
+-keep class com.gamedog.vididin.router.** { *; }
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@ -2,7 +2,15 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">


+    <uses-feature
+        android:name="android.hardware.camera"
+        android:required="false" />
+
    <uses-permission android:name="android.permission.READ_PHONE_STATE" />
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
+    <uses-permission android:name="android.permission.CAMERA" />
+

    <application
        android:name=".VidiDinApp"
@ -16,10 +24,10 @@
        android:theme="@style/Theme.Architectureandroid">
        <activity
            android:name=".main.MainActivity"
-            android:exported="true">
+            android:exported="true"
+            android:launchMode="singleTask">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
-
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
@ -35,6 +43,7 @@
        <activity android:name=".features.feedback.FeedbackActivity"  android:exported="false" />
        <activity android:name=".features.withdrawrecord.WithdrawRecordActivity"  android:exported="false" />
        <activity android:name=".features.privacy.PrivacyActivity"  android:exported="false" />
+        <activity android:name=".features.watchad.WatchAdActivity"  android:exported="false" />



@ -46,6 +55,19 @@
                android:name="com.gamedog.vididin.router.RouterInitializer"
                android:value="androidx.startup" />
        </provider>
+
+
+        <receiver
+            android:name=".manager.DateChangeReceiver"
+            android:enabled="true"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="android.intent.action.DATE_CHANGED" />
+            </intent-filter>
+        </receiver>
+
+
+
    </application>

 </manifest>
--- a/app/src/main/assets/taskConfig.json
+++ b/app/src/main/assets/taskConfig.json
@ -4,7 +4,10 @@
      "module_name": "任务中心",
      "page_path": "底部第二个页签",
      "layout_style": "上下滑动长页面",
-      "currency_display": ["金币账户", "巴西雷亚尔现金账户"]
+      "currency_display": [
+        "金币账户",
+        "巴西雷亚尔现金账户"
+      ]
    },
    "task_categories": [
      {
@ -50,13 +53,34 @@
            "target_action": "用户每日完成签到操作（支持广告补签）",
            "reward_type": "金币",
            "reward_details": [
-              {"day": 1, "value": 100},
-              {"day": 2, "value": 300},
-              {"day": 3, "value": 300},
-              {"day": 4, "value": 500},
-              {"day": 5, "value": 300},
-              {"day": 6, "value": 300},
-              {"day": 7, "value": 800}
+              {
+                "day": 1,
+                "value": 100
+              },
+              {
+                "day": 2,
+                "value": 300
+              },
+              {
+                "day": 3,
+                "value": 300
+              },
+              {
+                "day": 4,
+                "value": 500
+              },
+              {
+                "day": 5,
+                "value": 300
+              },
+              {
+                "day": 6,
+                "value": 300
+              },
+              {
+                "day": 7,
+                "value": 800
+              }
            ],
            "support_makeup": true,
            "makeup_method": "观看15-30秒激励视频",
@ -78,13 +102,34 @@
            "target_action": "用户当日完成签到操作",
            "reward_type": "金币",
            "reward_details": [
-              {"day": 1, "value": 100},
-              {"day": 2, "value": 300},
-              {"day": 3, "value": 300},
-              {"day": 4, "value": 500},
-              {"day": 5, "value": 300},
-              {"day": 6, "value": 300},
-              {"day": 7, "value": 500}
+              {
+                "day": 1,
+                "value": 100
+              },
+              {
+                "day": 2,
+                "value": 300
+              },
+              {
+                "day": 3,
+                "value": 300
+              },
+              {
+                "day": 4,
+                "value": 500
+              },
+              {
+                "day": 5,
+                "value": 300
+              },
+              {
+                "day": 6,
+                "value": 300
+              },
+              {
+                "day": 7,
+                "value": 500
+              }
            ],
            "double_reward_method": "观看15-30秒激励视频",
            "support_makeup": true,
@ -99,9 +144,18 @@
            "target_action": "用户累计观看短视频",
            "reward_type": "金币",
            "reward_details": [
-              {"target_count": 10, "value": 100},
-              {"target_count": 20, "value": 150},
-              {"target_count": 30, "value": 200}
+              {
+                "target_count": 10,
+                "value": 100
+              },
+              {
+                "target_count": 20,
+                "value": 150
+              },
+              {
+                "target_count": 30,
+                "value": 200
+              }
            ],
            "reward_stackable": true,
            "is_one_time": false,
@ -114,9 +168,18 @@
            "target_action": "用户累计观看激励视频",
            "reward_type": "金币",
            "reward_details": [
-              {"target_count": 1, "value": 100},
-              {"target_count": 5, "value": 150},
-              {"target_count": 10, "value": 200}
+              {
+                "target_count": 1,
+                "value": 100
+              },
+              {
+                "target_count": 5,
+                "value": 150
+              },
+              {
+                "target_count": 10,
+                "value": 200
+              }
            ],
            "daily_limit": 10,
            "reward_stackable": true,
@ -125,6 +188,104 @@
          }
        ]
      }
-    ]
+    ],
+    "box_task": {
+      "category_id": "bonuses_task",
+      "category_name": "福利宝箱（Prémios únicos）",
+      "valid_period": "每个宝箱持续3天，完成对应任务即可领取现金奖励。",
+      "display_priority": 3,
+      "chests": [
+        {
+          "chest_id": "1",
+          "chest_name": "福利宝箱1",
+          "chest_desc": "完成福利宝箱1的全部任务后，获得R$0.1现金奖励",
+          "duration_days": 3,
+          "reward_type": "货币",
+          "reward_value": 0.1,
+          "is_one_time": true,
+          "status": "active",
+          "tasks": [
+            {
+              "task_id": "chest1_task1",
+              "task_name": "观看1个广告",
+              "required_count": 1,
+              "task_type": 1
+            },
+            {
+              "task_id": "chest1_task2",
+              "task_name": "观看3个视频",
+              "required_count": 3,
+              "task_type": 2
+            },
+            {
+              "task_id": "chest1_task3",
+              "task_name": "完成1次签到",
+              "required_count": 1,
+              "task_type": 3
+            }
+          ]
+        },
+        {
+          "chest_id": "2",
+          "chest_name": "福利宝箱2",
+          "chest_desc": "完成福利宝箱2的全部任务后，获得R$1现金奖励",
+          "duration_days": 3,
+          "reward_type": "货币",
+          "reward_value": 1,
+          "is_one_time": true,
+          "status": "locked",
+          "tasks": [
+            {
+              "task_id": "chest2_task1",
+              "task_name": "观看15个广告",
+              "required_count": 15,
+              "task_type": 1
+            },
+            {
+              "task_id": "chest2_task2",
+              "task_name": "观看30个视频",
+              "required_count": 30,
+              "task_type": 2
+            },
+            {
+              "task_id": "chest2_task3",
+              "task_name": "参与1次0元购",
+              "required_count": 1,
+              "task_type": 4
+            }
+          ]
+        },
+        {
+          "chest_id": "3",
+          "chest_name": "福利宝箱3",
+          "chest_desc": "完成福利宝箱3的全部任务后，获得R$2现金奖励",
+          "duration_days": 3,
+          "reward_type": "货币",
+          "reward_value": 2,
+          "is_one_time": true,
+          "status": "locked",
+          "tasks": [
+            {
+              "task_id": "chest3_task1",
+              "task_name": "观看30个广告",
+              "required_count": 30,
+              "task_type": 1
+            },
+            {
+              "task_id": "chest3_task2",
+              "task_name": "观看50个视频",
+              "required_count": 50,
+              "task_type": 2
+            },
+            {
+              "task_id": "chest3_task3",
+              "task_name": "参与10次0元购",
+              "required_count": 10,
+              "task_type": 4
+            }
+          ]
+        }
+      ]
+    }
  }
 }
--- a/app/src/main/assets/taskConfig_old.json
+++ b/app/src/main/assets/taskConfig_old.json
@ -0,0 +1,130 @@
+{
+  "task_module_config": {
+    "basic_info": {
+      "module_name": "任务中心",
+      "page_path": "底部第二个页签",
+      "layout_style": "上下滑动长页面",
+      "currency_display": ["金币账户", "巴西雷亚尔现金账户"]
+    },
+    "task_categories": [
+      {
+        "category_id": "newbie_task",
+        "category_name": "新手任务（Missão Para Iniciantes）",
+        "valid_period": "注册后7天内",
+        "display_priority": 1,
+        "tasks": [
+          {
+            "task_id": "newbie_first_withdraw",
+            "task_name": "完成第一次提现",
+            "task_desc": "完成首次提现操作（0.1 BRL门槛），即可获得100金币奖励",
+            "target_action": "用户完成首次提现流程（含绑定Pix账户、观看广告）",
+            "reward_type": "金币",
+            "reward_value": 100,
+            "is_one_time": true,
+            "status": "active"
+          },
+          {
+            "task_id": "newbie_push_notify",
+            "task_name": "开启消息推送",
+            "task_desc": "启用APP消息推送权限，实时获取任务更新与奖励通知",
+            "target_action": "用户授权APP系统推送通知",
+            "reward_type": "金币",
+            "reward_value": 300,
+            "is_one_time": true,
+            "status": "active"
+          },
+          {
+            "task_id": "newbie_join_discord",
+            "task_name": "加入Discord社区",
+            "task_desc": "通过APP内链接加入官方Discord社区，获取专属活动与客服支持",
+            "target_action": "用户通过指定链接成功加入Discord社区",
+            "reward_type": "金币",
+            "reward_value": 200,
+            "is_one_time": true,
+            "status": "active"
+          },
+          {
+            "task_id": "newbie_7day_checkin",
+            "task_name": "7日连续签到",
+            "task_desc": "连续7天完成签到，奖励逐级递增，第7天最高可得800金币",
+            "target_action": "用户每日完成签到操作（支持广告补签）",
+            "reward_type": "金币",
+            "reward_details": [
+              {"day": 1, "value": 100},
+              {"day": 2, "value": 300},
+              {"day": 3, "value": 300},
+              {"day": 4, "value": 500},
+              {"day": 5, "value": 300},
+              {"day": 6, "value": 300},
+              {"day": 7, "value": 800}
+            ],
+            "support_makeup": true,
+            "makeup_method": "观看15-30秒激励视频",
+            "is_one_time": true,
+            "status": "active"
+          }
+        ]
+      },
+      {
+        "category_id": "daily_task",
+        "category_name": "日常任务（Missão Diária）",
+        "valid_period": "每日凌晨00:00重置",
+        "display_priority": 2,
+        "tasks": [
+          {
+            "task_id": "daily_checkin",
+            "task_name": "每日签到",
+            "task_desc": "每日签到可获金币，7天为一周期，奖励循环递增（支持双倍广告奖励）",
+            "target_action": "用户当日完成签到操作",
+            "reward_type": "金币",
+            "reward_details": [
+              {"day": 1, "value": 100},
+              {"day": 2, "value": 300},
+              {"day": 3, "value": 300},
+              {"day": 4, "value": 500},
+              {"day": 5, "value": 300},
+              {"day": 6, "value": 300},
+              {"day": 7, "value": 500}
+            ],
+            "double_reward_method": "观看15-30秒激励视频",
+            "support_makeup": true,
+            "makeup_method": "观看15-30秒激励视频",
+            "is_one_time": false,
+            "status": "active"
+          },
+          {
+            "task_id": "daily_video_ladder",
+            "task_name": "阶梯观看视频",
+            "task_desc": "累计观看指定数量短视频，分3档领取奖励（与基础观看收益叠加）",
+            "target_action": "用户累计观看短视频",
+            "reward_type": "金币",
+            "reward_details": [
+              {"target_count": 10, "value": 100},
+              {"target_count": 20, "value": 150},
+              {"target_count": 30, "value": 200}
+            ],
+            "reward_stackable": true,
+            "is_one_time": false,
+            "status": "active"
+          },
+          {
+            "task_id": "daily_ad_ladder",
+            "task_name": "阶梯观看激励视频",
+            "task_desc": "累计观看指定数量激励视频，分3档领取奖励（每日上限10次）",
+            "target_action": "用户累计观看激励视频",
+            "reward_type": "金币",
+            "reward_details": [
+              {"target_count": 1, "value": 100},
+              {"target_count": 5, "value": 150},
+              {"target_count": 10, "value": 200}
+            ],
+            "daily_limit": 10,
+            "reward_stackable": true,
+            "is_one_time": false,
+            "status": "active"
+          }
+        ]
+      }
+    ]
+  }
+}
--- a/app/src/main/java/com/gamedog/vididin/Constants.kt
+++ b/app/src/main/java/com/gamedog/vididin/Constants.kt
@ -1,23 +0,0 @@
-package com.gamedog.vididin
-
-object VidiConst {
-    /**
-     * 描述：网络常量
-     *
-     */
-    const val URL_YOUTUBE_API = "https://www.googleapis.com"
-
-
-
-
-    /**
-     * 描述：其他常量
-     *
-     */
-    const val YOUTUBE_API_KEY = "AIzaSyBm9k2lS_j7Fdd43NEPkcfikJRotup5DMY"
-
-
-
-
-
-}
--- a/app/src/main/java/com/gamedog/vididin/VidiConst.kt
+++ b/app/src/main/java/com/gamedog/vididin/VidiConst.kt
@ -0,0 +1,41 @@
+package com.gamedog.vididin
+
+object VidiConst {
+
+
+
+    const val URL_DISCORD: String = "https://www.baidu.com"
+    const val URL_GAME: String = "https://www.baidu.com"
+
+    /**
+     * 描述：网络常量
+     *
+     */
+    const val URL_YOUTUBE_API_OLD = "https://www.googleapis.com"
+
+    const val URL_YOUTUBE_API = "https://vd.rsappinc.com"
+
+    const val URL_ZERO_BUY: String = "https://jt.3idiotstudio.com"
+
+
+
+    /**
+     * 描述：其他常量
+     *
+     */
+    const val YOUTUBE_API_KEY = "AIzaSyBm9k2lS_j7Fdd43NEPkcfikJRotup5DMY"
+
+    const val GOLD_IN_CONFIG: String = "金币"
+
+    const val PER_CASH_COST_GOLD_NUM = 1000
+    const val WATCH_AD_REWARD_GOLD = 200
+
+    const val ZEROBUY_SECRET: String = "1f04c57a"
+    const val ZEROBUY_APPID: String = "com.vididin.real.money.game"
+
+}
+
+
+
+
+
--- a/app/src/main/java/com/gamedog/vididin/VididinEvents.kt
+++ b/app/src/main/java/com/gamedog/vididin/VididinEvents.kt
@ -6,4 +6,36 @@ object VididinEvents {
    const val Event_Account_Cash_Changed = 602
    const val Event_Account_Bank_Info_Changed = 603

+
+    const val Event_HOME_WATCH_Time_TICK = 700
+    const val Event_Finish_One_Video = 701
+    const val Event_Finish_One_Ad = 702
+    const val Event_Finish_One_Sign = 703
+    const val Event_Finish_One_Zerobuy = 704
+
+    const val EVENT_DAILY_WATCHED_VIDEO_NUM_CHANGED = 705
+    const val EVENT_DAILY_WATCHED_AD_NUM_CHANGED = 706
+
+    const val EVENT_BOX_TASK_STATE_CHANGED = 707
+    const val EVENT_NEWBIE_NOTIFY_TASK_CHANGED = 708
+    const val EVENT_NEWBIE_FIRST_WITHDRAW_TASK_CHANGED = 709
+    const val EVENT_NEWBIE_DISCORD_TASK_CHANGED = 710
+
+
+
+    const val Event_AD_TASK_TYPE_Convert_Gold_2_Cash = 800
+    const val Event_AD_TASK_TYPE_Watch_Ad_Earn_Gold = 801
+    const val Event_AD_TASK_TYPE_Watch_Ad_Daily = 802
+    const val Event_AD_TASK_TYPE_Withdraw = 803
+    const val Event_AD_TASK_TYPE_Complement = 804
+    const val Event_AD_TASK_TYPE_BOX_TASK = 805
+
+
+
+
+    // UI jump related
+    const val EVENT_JUMP_2_FIRST_WITHDRAW = 900
+    const val EVENT_JUMP_2_VIDEO = 901
+    const val EVENT_JUMP_2_SIGN= 902
+
 }
--- a/app/src/main/java/com/gamedog/vididin/adapter/MainTabsAdapter.kt
+++ b/app/src/main/java/com/gamedog/vididin/adapter/MainTabsAdapter.kt
@ -103,10 +103,10 @@ class MainTabsAdapter(
        }
    }

+
    private fun ViewBinding.onTabClickAgainHandle(index: Int) {
        val currentFragment = mainFragmentStateAdapter.getFragmentByIndex(index)
        if (currentFragment is OnTabClickRefreshListener) {
-            // 刷新 - 展示Loading
            currentFragment.onTabClickRefresh(object : OnTabClickRefreshFinishListener {
                override fun onTabClickRefreshFinish() {
                    setTabStyle(1)
--- a/app/src/main/java/com/gamedog/vididin/api/YoutubeApi.kt
+++ b/app/src/main/java/com/gamedog/vididin/api/YoutubeApi.kt
@ -44,7 +44,7 @@ interface YoutubeApi {
    ): ResYoutubePlayList

    @GET("/youtube/v3/videos")
-    suspend fun getVideoList(
+    suspend fun getVideoList_old(
        @Query("part") part: String= URLEncoder.encode("snippet", "UTF-8"),
        @Query("key") key: String= VidiConst.YOUTUBE_API_KEY,
        @Query("videoDuration") videoDuration: String= "short",
@ -56,10 +56,9 @@ interface YoutubeApi {
    ): ResYoutubePlayList


-    /*
-    https://www.googleapis.com/youtube/v3/videos?part=id&chart=mostPopular&regionCode=BR&maxResults=10&key=AIzaSyBm9k2lS_j7Fdd43NEPkcfikJRotup5DMY
-    https://www.googleapis.com/youtube/v3/videos?part=snippet,statistics&chart=mostPopular&regionCode=BR&maxResults=10&key=AIzaSyBm9k2lS_j7Fdd43NEPkcfikJRotup5DMY
-     */
-
+    @GET("/videos")
+    suspend fun getVideoList(
+        @Query("video") video: String? = URLEncoder.encode("", "UTF-8"),
+    ): ResYoutubePlayList

 }
--- a/app/src/main/java/com/gamedog/vididin/beans/Account.kt
+++ b/app/src/main/java/com/gamedog/vididin/beans/Account.kt
@ -2,13 +2,17 @@ package com.gamedog.vididin.beans


 data class Account(
+    var userId: Int = 0,
    val accountId: String,
    val deviceUUId: String,
    val token: String="",
    val createdAt: Long,
+    @Volatile
    var goldCount: Long = 0L,
+    @Volatile
    var cashCount: Float = 0F,
    var bankInfo: BankInfo? = null,
+    val zeroBuyServerSecret: String = "",
    )


--- a/app/src/main/java/com/gamedog/vididin/beans/RecordCash.kt
+++ b/app/src/main/java/com/gamedog/vididin/beans/RecordCash.kt
@ -0,0 +1,15 @@
+package com.gamedog.vididin.beans
+
+data class RecordCash(
+    val id: Long,
+    val dateTime: String,
+    val status: TransactionStatus,
+    val statusText: String,
+    val description: String,
+    val amount: String,
+    val amountColor: Int
+)
+
+enum class TransactionStatus {
+    SUCCESS, FAILED, PROCESSING, REDEEM
+}
--- a/app/src/main/java/com/gamedog/vididin/beans/RecordGold.kt
+++ b/app/src/main/java/com/gamedog/vididin/beans/RecordGold.kt
@ -0,0 +1,12 @@
+package com.gamedog.vididin.beans
+
+data class RecordGold(
+    val id: Long,
+    val dateTime: String,
+    val status: TransactionStatus,
+    val statusText: String,
+    val description: String,
+    val amount: String,
+    val amountColor: Int
+)
+
--- a/app/src/main/java/com/gamedog/vididin/beans/YoutubeBeans.kt
+++ b/app/src/main/java/com/gamedog/vididin/beans/YoutubeBeans.kt
@ -5,92 +5,20 @@ import com.ama.core.model.BaseFragmentStateDiffItem
 import kotlinx.serialization.Serializable


-@Serializable
-data class ResYoutubeChannel(
-    val id: String,
-    val name: String,
-)
-


@Serializable
 data class ResYoutubePlayList (
-    val kind: String,
-    val etag: String, // TODO - this is Etag type
-    val nextPageToken: String,
-    val prevPageToken: String,
-    val pageInfo: PageInfo,
-    val items: List<YoutubeVideo>,
+    val videos: List<YoutubeVideo>,
 )

-@Serializable
-data class PageInfo(
-    val totalResults: Int,
-    val resultsPerPage: Int,
-)
+
@Serializable
 data class YoutubeVideo(
-    val kind: String,
-    val etag: String,
    val id: String,
-    val snippet: Snippet,
-    val status: Status,
-
-    val contentDetails: ContentDetails,
-    val player: Player,
-    val localizations: Localizations,
+    val channel_title: String,
+    val description: String,
 ) : BaseFragmentStateDiffItem {
    override fun getPrimaryKey() = id
    override fun getItemId() = id.hashCode().toLong()
 }
-
-
-
-@Serializable
-data class ContentDetails(
-    val itemCount: Int,
-)
-@Serializable
-data class Player(
-    val embedHtml: String,
-)
-
-@Serializable
-data class Localizations(
-    val title: String,
-    val description: String,
-)
-
-
-
-@Serializable
-data class Snippet(
-    val publishedAt: String,
-    val channelId: String,
-    val title: String,
-    val description: String,
-    //val thumbnails: Thumbnail,
-    val channelTitle: String,
-    val defaultLanguage: String,
-    val localized: Localized,
-)
-
-@Serializable
-data class Localized(
-    val title: String,
-    val description: String,
-)
-
-@Serializable
-data class Thumbnail(
-    val standard: String,
-)
-
-@Serializable
-data class Status(
-    val privacyStatus: String,
-    val podcastStatus: Int,
-)
-
-
-
--- a/app/src/main/java/com/gamedog/vididin/beans/YoutubeBeans_old.kt
+++ b/app/src/main/java/com/gamedog/vididin/beans/YoutubeBeans_old.kt
@ -0,0 +1,98 @@
+package com.gamedog.vididin.beans
+
+
+import com.ama.core.model.BaseFragmentStateDiffItem
+import kotlinx.serialization.Serializable
+
+
+@Serializable
+data class ResYoutubeChannel(
+    val id: String,
+    val name: String,
+)
+
+/*
+
+
+
+@Serializable
+data class ResYoutubePlayList (
+    val kind: String,
+    val etag: String, // TODO - this is Etag type
+    val nextPageToken: String,
+    val prevPageToken: String,
+    val pageInfo: PageInfo,
+    val items: List<YoutubeVideo>,
+)
+
+@Serializable
+data class PageInfo(
+    val totalResults: Int,
+    val resultsPerPage: Int,
+)
+@Serializable
+data class YoutubeVideo(
+    val kind: String,
+    val etag: String,
+    val id: String,
+    val snippet: Snippet,
+    val status: Status,
+
+    val contentDetails: ContentDetails,
+    val player: Player,
+    val localizations: Localizations,
+) : BaseFragmentStateDiffItem {
+    override fun getPrimaryKey() = id
+    override fun getItemId() = id.hashCode().toLong()
+}
+
+
+
+@Serializable
+data class ContentDetails(
+    val itemCount: Int,
+)
+@Serializable
+data class Player(
+    val embedHtml: String,
+)
+
+@Serializable
+data class Localizations(
+    val title: String,
+    val description: String,
+)
+
+
+
+@Serializable
+data class Snippet(
+    val publishedAt: String,
+    val channelId: String,
+    val title: String,
+    val description: String,
+    //val thumbnails: Thumbnail,
+    val channelTitle: String,
+    val defaultLanguage: String,
+    val localized: Localized,
+)
+
+@Serializable
+data class Localized(
+    val title: String,
+    val description: String,
+)
+
+@Serializable
+data class Thumbnail(
+    val standard: String,
+)
+
+@Serializable
+data class Status(
+    val privacyStatus: String,
+    val podcastStatus: Int,
+)
+
+
+*/
--- a/app/src/main/java/com/gamedog/vididin/beans/ZeroBuyResp.kt
+++ b/app/src/main/java/com/gamedog/vididin/beans/ZeroBuyResp.kt
@ -0,0 +1,32 @@
+package com.gamedog.vididin.beans
+
+
+data class ZeroBuyResp (
+    val Code: Int,
+    val Message: String,
+
+    val UserId: Int,
+    val CurrentPurchases: String,
+    val FinishedPurchases: String,
+    var mCurrentList: List<ZeroBuyItem>?,
+    var mFinishedList: List<ZeroBuyItem>?,
+    val Content: String,
+)
+
+
+data class ZeroBuyItem (
+    val id:Int = 0,
+    val title: String? = null,
+    val start_time:Long = 0,
+    val end_time:Long = 0,
+    val target_num:Int = 0,
+    val cost:Int = 0,
+    val price: String? = null,
+    val image:Int = 0,
+    val current_users: List<Int>? = null,
+    val winners: List<Int>? = null,
+    val redeem_code: String? = null,
+    val completed: Boolean = false,
+)
+
+
--- a/app/src/main/java/com/gamedog/vididin/di/ComponentModule.kt
+++ b/app/src/main/java/com/gamedog/vididin/di/ComponentModule.kt
@ -12,12 +12,14 @@ import com.gamedog.vididin.router.DefaultFeedbackRouter
 import com.gamedog.vididin.router.DefaultPrivacyRouter
 import com.gamedog.vididin.router.DefaultSplashRouter
 import com.gamedog.vididin.router.DefaultVersionRouter
+import com.gamedog.vididin.router.DefaultWatchAdRouter
 import com.gamedog.vididin.router.DefaultWithdrawRecordRouter
 import com.gamedog.vididin.router.IRouterFeedback
 import com.gamedog.vididin.router.IRouterPrivacy
 import com.gamedog.vididin.router.IRouterSplash
 import com.gamedog.vididin.router.IRouterVersion
 import com.gamedog.vididin.router.IRouterWithdrawRecord
+import com.gamedog.vididin.router.IRouterWatchAd
 import dagger.Module
 import dagger.Provides
 import dagger.hilt.InstallIn
@ -99,3 +101,11 @@ object VersionModule {
    @Singleton
    fun provideRouter(): IRouterVersion = DefaultVersionRouter()
 }
+
+@Module
+@InstallIn(SingletonComponent::class)
+object WatchAd {
+    @Provides
+    @Singleton
+    fun provideRouter(): IRouterWatchAd = DefaultWatchAdRouter()
+}
--- a/app/src/main/java/com/gamedog/vididin/di/GlobalInterceptor.kt
+++ b/app/src/main/java/com/gamedog/vididin/di/GlobalInterceptor.kt
@ -2,6 +2,8 @@ package com.gamedog.vididin.core.network.di


 import android.util.Log
+import com.ama.core.architecture.util.DeviceUtil
+import com.gamedog.vididin.request.RequestUtil
 import okhttp3.Headers
 import okhttp3.Interceptor
 import okhttp3.MediaType.Companion.toMediaType
@ -24,26 +26,23 @@ class GlobalInterceptor : Interceptor {
        val emptyBody = "{}".toRequestBody("application/json;charset=utf-8".toMediaType())
        val requestBody = if (bodyStr.isNotBlank()) request.body else emptyBody

+        val timeSec = RequestUtil.getTimestampSec()

-        val headersBuilder = Headers.Builder()
-            /*
-            .add("authorazation", "Bearer xxxxx")
-            .add("AUTH_DID", AppUtils.getAndroidID())
-            .add("platform", AppConstant.APP_CLIENT)
-            .add("Authorization", "Bearer xxx")
-            .add("versionNum", "100")
-            */
-            .add("User-Agent", "Android")
-            .add("Accept-Language", Locale.getDefault().toLanguageTag())
-            .add("Content-Type", "application/json")
-            .add("Accept", "application/json")
-            .add("Accept-Charset", "utf-8")
+        val requestBuilder = chain.request().newBuilder()
+            .addHeader("User-Agent", "Android")
+            .addHeader("Accept-Language", Locale.getDefault().toLanguageTag())
+            .addHeader("Content-Type", "application/json")
+            .addHeader("Accept", "application/json")
+            .addHeader("Accept-Charset", "utf-8")
+            // server real defined
+            .addHeader("ApplicationId", RequestUtil.Request_APPId)
+            .addHeader("Timestamp", timeSec.toString())
+            .addHeader("Sign", RequestUtil.getRequestSign(timeSec))
+            .addHeader("DeviceId", DeviceUtil.generateDeviceId())
+            .addHeader("authorazation", "Bearer xxxxx")

+        request = requestBuilder.build()

-        val headers = headersBuilder.build()
-        request = chain.request().newBuilder()
-            .headers(headers)
-            .build()
        val response = chain.proceed(request)


--- a/app/src/main/java/com/gamedog/vididin/di/GlobalInterceptor2.kt
+++ b/app/src/main/java/com/gamedog/vididin/di/GlobalInterceptor2.kt
@ -0,0 +1,98 @@
+package com.gamedog.vididin.core.network.di
+
+
+import android.util.Log
+import com.ama.core.architecture.util.DeviceUtil
+import com.gamedog.vididin.request.RequestUtil
+import okhttp3.Headers
+import okhttp3.Interceptor
+import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.Request
+import okhttp3.RequestBody
+import okhttp3.RequestBody.Companion.toRequestBody
+import okhttp3.Response
+import okhttp3.ResponseBody
+import okhttp3.ResponseBody.Companion.asResponseBody
+import okio.Buffer
+import java.io.IOException
+import java.util.Locale
+
+
+class GlobalInterceptor2 : Interceptor {
+
+    override fun intercept(chain: Interceptor.Chain): Response {
+        var request = chain.request()
+        val bodyStr = readBody(chain.request().body)
+        val emptyBody = "{}".toRequestBody("application/json;charset=utf-8".toMediaType())
+        val requestBody = if (bodyStr.isNotBlank()) request.body else emptyBody
+
+
+
+        val requestBuilder = chain.request().newBuilder()
+            .addHeader("User-Agent", "Android")
+            .addHeader("Accept-Language", Locale.getDefault().toLanguageTag())
+            .addHeader("Content-Type", "application/json")
+            .addHeader("Accept", "application/json")
+            .addHeader("Accept-Charset", "utf-8")
+            // server real defined
+            .addHeader("ApplicationId", RequestUtil.Request_ZeroBuy_APPId)
+            .addHeader("DeviceId", DeviceUtil.generateDeviceId())
+            .addHeader("authorazation", "Bearer xxxxx")
+
+        request = requestBuilder.build()
+
+        val response = chain.proceed(request)
+
+
+        if (true) {
+            try {
+                val contentStr = clone(response.body)?.string()
+                Log.d("RetroLog" ,
+                    """
+                    ———————————————— 请求 Start ——————————————————————————————
+                    ${request.url} 
+                    ******** 请求头 ${request.method} ********：
+                    ${getRequestHeadersString(request)}
+                    ******** 请求体(当post等时) ********：
+                    ${readBody(requestBody)}
+                    ******** 请求响应 ********：
+                    $contentStr
+                    ————————————————  请求 End ———————————————————————————————
+                """.trimIndent()
+                )
+            } catch (e: Exception) {
+                Log.d("RetroLog" , "GlobalInterceptor request.exception : ${e.localizedMessage}}")
+            }
+        }
+
+        return response
+    }
+
+
+    fun getRequestHeadersString(request: Request): String {
+        val headers = request.headers
+        val headerCount = headers.size
+
+        val sb = StringBuilder()
+        for (i in 0 until headerCount) {
+            val key = headers.name(i)
+            val value = headers.value(i)
+            sb.append("$key=$value\n")
+        }
+        return sb.toString()
+    }
+
+    private fun readBody(body: RequestBody?): String {
+        val buffer = Buffer()
+        body?.writeTo(buffer)
+        return buffer.readUtf8()
+    }
+
+    @Throws(IOException::class)
+    private fun clone(body: ResponseBody?): ResponseBody? {
+        val source = body?.source()
+        if (source?.request(Long.MAX_VALUE) == true) throw IOException("body too long!")
+        val bufferedCopy = source?.buffer?.clone()
+        return bufferedCopy?.asResponseBody(body.contentType(), body.contentLength())
+    }
+}
--- a/app/src/main/java/com/gamedog/vididin/di/NetworkModule.kt
+++ b/app/src/main/java/com/gamedog/vididin/di/NetworkModule.kt
@ -45,7 +45,6 @@ internal object NetworkModule {
    @Provides
    @Singleton
    fun providesRetrofit(
-        networkJson: Json,
        okhttpCallFactory: dagger.Lazy<Call.Factory>,
    ): Retrofit {
        return Retrofit.Builder()
--- a/app/src/main/java/com/gamedog/vididin/di/RouterEntryPoints.kt
+++ b/app/src/main/java/com/gamedog/vididin/di/RouterEntryPoints.kt
@ -13,6 +13,7 @@ import com.gamedog.vididin.router.IRouterPrivacy
 import com.gamedog.vididin.router.IRouterSplash
 import com.gamedog.vididin.router.IRouterVersion
 import com.gamedog.vididin.router.IRouterWithdrawRecord
+import com.gamedog.vididin.router.IRouterWatchAd
 import dagger.hilt.EntryPoint
 import dagger.hilt.InstallIn
 import dagger.hilt.components.SingletonComponent
@ -38,6 +39,7 @@ interface RouterEntryPoint {
    fun feedbackRouter(): IRouterFeedback
    fun splashRouter(): IRouterSplash
    fun withdrawRecordRouter(): IRouterWithdrawRecord
+    fun watchAdRouter(): IRouterWatchAd

 }

--- a/app/src/main/java/com/gamedog/vididin/features/benefit/BenefitActivity.kt
+++ b/app/src/main/java/com/gamedog/vididin/features/benefit/BenefitActivity.kt
@ -3,11 +3,33 @@ package com.gamedog.vididin.features.benefit
 import android.app.Activity
 import android.content.Intent
 import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import android.widget.LinearLayout
 import androidx.activity.viewModels
 import com.ama.core.architecture.appBase.AppViewsActivity
+import com.ama.core.architecture.ext.toast
+import com.ama.core.architecture.util.AndroidUtil
+import com.ama.core.architecture.util.ResUtil
+import com.ama.core.architecture.util.eventbus.NotifyMan
+import com.ama.core.architecture.util.setOnClickBatch
+import com.gamedog.vididin.R
+import com.gamedog.vididin.VididinEvents
+import com.gamedog.vididin.core.login.login.AccountManager
+import com.gamedog.vididin.features.benefit.widget.BenefitTaskItemView
+import com.gamedog.vididin.main.fragments.task.DailySignDialog
 import com.gamedog.vididin.main.interfaces.OnTabStyleListener
+import com.gamedog.vididin.manager.TaskManager
+import com.gamedog.vididin.manager.TaskManager.Companion.BOX_SUB_TASK_TYPE_AD
+import com.gamedog.vididin.manager.TaskManager.Companion.BOX_SUB_TASK_TYPE_VIDEO
+import com.gamedog.vididin.manager.TaskManager.Companion.BOX_SUB_TASK_TYPE_SIGN
+import com.gamedog.vididin.manager.TaskManager.Companion.BOX_SUB_TASK_TYPE_ZERO_BUY
 import dagger.hilt.android.AndroidEntryPoint
 import kotlin.getValue
+import com.gamedog.vididin.manager.taskbeans.BaseTaskState.Companion.STATE_FINISH
+import com.gamedog.vididin.manager.taskbeans.BaseTaskState.Companion.STATE_CLAIMED
+import com.gamedog.vididin.manager.taskbeans.BaseTaskState.Companion.STATE_EXPIRED
+import com.gamedog.vididin.router.Router
 import com.gamedog.vididin.databinding.ActivityBenefitBinding as ViewBinding
 import com.gamedog.vididin.main.MainUiState as UiState
 import com.gamedog.vididin.main.MainViewModel as ViewModel
@ -16,6 +38,8 @@ import com.gamedog.vididin.main.MainViewModel as ViewModel
@AndroidEntryPoint
 class BenefitActivity : AppViewsActivity<ViewBinding, UiState, ViewModel>(), OnTabStyleListener {

+    private val mSubTaskViewList = mutableListOf<BenefitTaskItemView>()
+

    override val mViewModel: ViewModel by viewModels()
    override fun inflateViewBinding(inflater: LayoutInflater) = ViewBinding.inflate(inflater)
@ -26,21 +50,20 @@ class BenefitActivity : AppViewsActivity<ViewBinding, UiState, ViewModel>(), OnT


    override fun ViewBinding.initViews() {
-
-        taskItem1.setActionFun {
-            gotoWatchVideo()
-        }
-        taskItem2.setActionFun {
-            gotoWatchVideo()
-        }
-        taskItem3.setActionFun {
-            gotoWatchVideo()
-        }
-
+        titlebar.setTitleText(R.string.benefit)
+        initViewsByTaskState()
    }

-    override fun ViewBinding.initListeners() {

+
+    override fun ViewBinding.initListeners() {
+        registerEvents({ data->
+            when (data?.mEventType) {
+                VididinEvents.EVENT_BOX_TASK_STATE_CHANGED -> {
+                    updateUI()
+                }
+            }
+        }, VididinEvents.EVENT_BOX_TASK_STATE_CHANGED)
    }

    override fun ViewBinding.initObservers() {
@ -56,10 +79,182 @@ class BenefitActivity : AppViewsActivity<ViewBinding, UiState, ViewModel>(), OnT
    }


-    private fun gotoWatchVideo() {
-        //TODO("Not yet implemented")
+    private fun initViewsByTaskState() {
+        initAddSubTaskViews()
+        updateSubTasksUI()
+        updateTopBoxesUI()
    }

+    private fun updateUI() {
+        updateSubTasksUI()
+        updateTopBoxesUI()
+    }
+
+    private fun initAddSubTaskViews() {
+        val taskStateHelper = TaskManager.instance().boxTaskStatus()
+        val currentBoxState = taskStateHelper.getStatusBean().tasks[taskStateHelper.getCurrentBoxIndex()]
+
+        currentBoxState.tasks.forEachIndexed { index, subTask ->
+            val separateLine = View(this@BenefitActivity)
+            separateLine.setBackgroundResource(R.color.gray_f2)
+            binding.llSubTaskContainer.addView(separateLine, ViewGroup.LayoutParams.MATCH_PARENT, ResUtil.getPixelSize(R.dimen.dp1))
+
+            val subTaskView = BenefitTaskItemView(this@BenefitActivity)
+            subTaskView.setActionFun { handleActionButClicked(subTask.task_type) }
+            val subViewParam = LinearLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT)
+            subViewParam.topMargin = ResUtil.getPixelSize(R.dimen.dp10)
+            subViewParam.bottomMargin = ResUtil.getPixelSize(R.dimen.dp10)
+            binding.llSubTaskContainer.addView(subTaskView, subViewParam)
+
+            mSubTaskViewList.add(subTaskView)
+        }
+    }
+
+    private fun handleActionButClicked(taskType: Int) {
+        when (taskType) {
+            BOX_SUB_TASK_TYPE_AD -> {
+                Router.WatchAd.startActivity(this@BenefitActivity, VididinEvents.Event_AD_TASK_TYPE_BOX_TASK, null)
+            }
+
+            BOX_SUB_TASK_TYPE_SIGN -> {
+                DailySignDialog(this@BenefitActivity).show()
+            }
+
+            BOX_SUB_TASK_TYPE_VIDEO -> {
+                finish()
+                NotifyMan.instance().sendEvent(VididinEvents.EVENT_JUMP_2_VIDEO, null)
+            }
+
+            BOX_SUB_TASK_TYPE_ZERO_BUY -> {
+                Router.ZeroBuy.startActivity(this@BenefitActivity)
+            }
+        }
+
+    }
+
+    private fun updateSubTasksUI() {
+        val taskStateHelper = TaskManager.instance().boxTaskStatus()
+        val currentBoxIndex = taskStateHelper.getCurrentBoxIndex()
+        val subTaskStateList = taskStateHelper.getStatusBean().tasks[currentBoxIndex].tasks
+
+        if (subTaskStateList.size == mSubTaskViewList.size) {
+            mSubTaskViewList.forEachIndexed { index, view ->
+                view.updateUIByState(subTaskStateList[index], currentBoxIndex,index)
+            }
+        }
+    }
+
+    private fun updateTopBoxesUI() {
+        val taskStateHelper = TaskManager.instance().boxTaskStatus()
+        val boxStateList = taskStateHelper.getStatusBean().tasks
+
+        with (binding) {
+            boxStateList.forEachIndexed { index, curBoxState ->
+                val stateEnum = taskStateHelper.getBoxStateEnum(index)
+                if (index == 0) {
+                    ivSubtask1.setImageResource(getIconResByState(stateEnum))
+                    tvSubtask1State.setText(getStrResByState(stateEnum))
+                    tvSubtask1State.setTextColor(getStrColorByState(stateEnum))
+
+                    with (tvSubtask1Reward) {
+                        compoundDrawablePadding = if (stateEnum == STATE_FINISH || stateEnum == STATE_CLAIMED) 0 else ResUtil.getPixelSize(R.dimen.dp3)
+                        val tvRewardIcon = getRewardTvDrawableRes(stateEnum)
+                        setCompoundDrawables(ResUtil.getDrawable(tvRewardIcon), null, null, null)
+                        val needShowNum = R.mipmap.icon_check_mark != tvRewardIcon
+                        setText(if (needShowNum) { ResUtil.getString(R.string.cash)  + " " + curBoxState.reward_value}  else "")
+                    }
+                }
+
+                if (index == 1) {
+                    ivSubtask2.setImageResource(getIconResByState(stateEnum))
+                    tvSubtask2State.setText(getStrResByState(stateEnum))
+                    tvSubtask2State.setTextColor(getStrColorByState(stateEnum))
+
+                    with (tvSubtask2Reward) {
+                        compoundDrawablePadding = if (stateEnum == STATE_FINISH || stateEnum == STATE_CLAIMED) 0 else ResUtil.getPixelSize(R.dimen.dp3)
+                        val tvRewardIcon = getRewardTvDrawableRes(stateEnum)
+                        setCompoundDrawables(ResUtil.getDrawable(tvRewardIcon), null, null, null)
+                        val needShowNum = R.mipmap.icon_check_mark != tvRewardIcon
+                        setText(if (needShowNum) { ResUtil.getString(R.string.cash)  + " " + curBoxState.reward_value}  else "")
+                    }
+                }
+
+                if (index == 2) {
+                    ivSubtask3.setImageResource(getIconResByState(stateEnum))
+                    tvSubtask3State.setText(getStrResByState(stateEnum))
+                    tvSubtask3State.setTextColor(getStrColorByState(stateEnum))
+
+                    with (tvSubtask3Reward) {
+                        compoundDrawablePadding = if (stateEnum == STATE_FINISH || stateEnum == STATE_CLAIMED) 0 else ResUtil.getPixelSize(R.dimen.dp3)
+                        val tvRewardIcon = getRewardTvDrawableRes(stateEnum)
+                        setCompoundDrawables(ResUtil.getDrawable(tvRewardIcon), null, null, null)
+                        val needShowNum = R.mipmap.icon_check_mark != tvRewardIcon
+                        setText(if (needShowNum) { ResUtil.getString(R.string.cash)  + " " + curBoxState.reward_value}  else "")
+                    }
+                }
+            }
+
+            val couldClaimCashNum = taskStateHelper.getCouldClaimCashNum()
+            with (tvResgatar) {
+                if (couldClaimCashNum > 0) {
+                    setBackgroundResource(R.mipmap.icon_but_bg_green)
+                    isClickable = true
+                } else {
+                    setBackgroundResource(R.mipmap.but_bg_grady)
+                    isClickable = false
+                }
+
+                setOnClickListener {
+                    if (taskStateHelper.executeClaimCash()) {
+                        AndroidUtil.showToast(String.format(ResUtil.getString(R.string.has_claim_box_cash_hint), couldClaimCashNum))
+                    }
+                }
+            }
+
+
+            // 总进度条, 奖励金额
+            val totalProgress = taskStateHelper.getCurrentBoxTotalProgress()
+            progressTasks.setProgress(totalProgress)
+            tvProgressNum.text = "($totalProgress%)"
+            tvHintRewardNum.text = buildString {
+                append(ResUtil.getString(R.string.cash))
+                append(" ")
+                append(taskStateHelper.getStatusBean().tasks[taskStateHelper.getCurrentBoxIndex()].reward_value)
+            }
+        }
+    }
+
+    private fun getIconResByState(state: Int): Int {
+        when (state) {
+            STATE_EXPIRED -> return R.mipmap.benefit_item_expired
+            STATE_FINISH, STATE_CLAIMED -> return R.mipmap.benefit_item_finished
+            else -> return R.mipmap.benefit_item_ongoing
+        }
+    }
+
+    private fun getStrResByState(state: Int): Int {
+        when (state) {
+            STATE_EXPIRED -> return R.string.expired
+            STATE_FINISH, STATE_CLAIMED -> return R.string.finished
+            else -> return R.string.ongoing
+        }
+    }
+
+    private fun getStrColorByState(state: Int): Int {
+        when (state) {
+            STATE_EXPIRED -> return R.color.gray_60
+            STATE_FINISH, STATE_CLAIMED -> return R.color.green_39
+            else -> return R.color.red_5c
+        }
+    }
+
+    private fun getRewardTvDrawableRes(state: Int): Int {
+        when (state) {
+            STATE_EXPIRED -> return R.mipmap.icon_cash_s_disable
+            STATE_FINISH, STATE_CLAIMED -> return R.mipmap.icon_check_mark
+            else -> return R.mipmap.icon_cash_s
+        }
+    }


    companion object {
--- a/app/src/main/java/com/gamedog/vididin/features/benefit/widget/BenefitTaskItemView.kt
+++ b/app/src/main/java/com/gamedog/vididin/features/benefit/widget/BenefitTaskItemView.kt
@ -5,7 +5,10 @@ import android.util.AttributeSet
 import android.view.LayoutInflater
 import android.widget.LinearLayout
 import com.ama.core.architecture.util.setOnClickBatch
+import com.gamedog.vididin.R
 import com.gamedog.vididin.databinding.BenefitTaskItemViewBinding
+import com.gamedog.vididin.manager.TaskManager
+import com.gamedog.vididin.manager.taskbeans.TaskStateBoxSub


 class BenefitTaskItemView @JvmOverloads constructor(
@ -40,11 +43,29 @@ class BenefitTaskItemView @JvmOverloads constructor(
    }


-    fun setProgressInfo(progress: String) {
-        mBinding.tvProgressInfo.text = progress
+    fun updateUIByState(subTaskState: TaskStateBoxSub, boxIndex: Int, subTaskIndex: Int) {
+        with (mBinding) {
+            val finishNum = if (subTaskState.finishedNum > subTaskState.required_count) subTaskState.required_count else subTaskState.finishedNum
+            val progressNum: Int = finishNum * 100 / subTaskState.required_count
+
+            //ivItemIcon.setImageResource(R.mipmap.icon_cash_s)
+            tvItemTitle.setText(TaskManager.instance().boxTaskStatus().getSubTaskHintStrRes(boxIndex, subTaskIndex))
+            progressBar.setProgress(progressNum)
+            tvProgressInfo.text = "($finishNum/${subTaskState.required_count})"
+
+            with (tvAction) {
+                if (progressNum < 100) {
+                    isClickable = true
+                    setBackgroundResource( R.drawable.bg_benefit_item_action_bg)
+                    setText(R.string.go_and_do)
+                } else {
+                    isClickable = false
+                    setBackgroundResource( R.drawable.bg_sub_task_disable)
+                    setText(R.string.finished)
+                }
+            }
+        }
    }


-
-
 }
--- a/app/src/main/java/com/gamedog/vididin/features/privacy/PrivacyActivity.kt
+++ b/app/src/main/java/com/gamedog/vididin/features/privacy/PrivacyActivity.kt
@ -28,17 +28,14 @@ class PrivacyActivity : AppViewsActivity<ViewBinding, UiState, ViewModel>(), OnT
        with(binding) {
            titlebar.setBackIconColor(R.color.black)
            titlebar.setTitleText(R.string.privacy, R.color.black)
+
+            webView.loadUrl("https://www.baidu.com")
        }

    }

    override fun ViewBinding.initWindowInsets() {
-        ViewCompat.setOnApplyWindowInsetsListener(contentRoot) { v, insets ->
-            val systemBars =
-                insets.getInsets(WindowInsetsCompat.Type.systemBars() or WindowInsetsCompat.Type.displayCutout())
-            v.updatePadding(top = systemBars.top)
-            insets
-        }
+        setImmerseRootView(contentRoot)
    }

    override fun ViewBinding.initListeners() {
--- a/app/src/main/java/com/gamedog/vididin/features/splash/SplashActivity.kt
+++ b/app/src/main/java/com/gamedog/vididin/features/splash/SplashActivity.kt
@ -8,7 +8,6 @@ import androidx.core.view.ViewCompat
 import androidx.core.view.WindowInsetsCompat
 import androidx.core.view.updatePadding
 import com.ama.core.architecture.appBase.AppViewsActivity
-import com.gamedog.vididin.R
 import com.gamedog.vididin.main.interfaces.OnTabStyleListener
 import dagger.hilt.android.AndroidEntryPoint
 import kotlin.getValue
--- a/app/src/main/java/com/gamedog/vididin/features/version/VersionActivity.kt
+++ b/app/src/main/java/com/gamedog/vididin/features/version/VersionActivity.kt
@ -4,10 +4,8 @@ import android.app.Activity
 import android.content.Intent
 import android.view.LayoutInflater
 import androidx.activity.viewModels
-import androidx.core.view.ViewCompat
-import androidx.core.view.WindowInsetsCompat
-import androidx.core.view.updatePadding
 import com.ama.core.architecture.appBase.AppViewsActivity
+import com.ama.core.architecture.util.AndroidUtil
 import com.gamedog.vididin.R
 import com.gamedog.vididin.main.interfaces.OnTabStyleListener
 import dagger.hilt.android.AndroidEntryPoint
@ -28,17 +26,15 @@ class VersionActivity : AppViewsActivity<ViewBinding, UiState, ViewModel>(), OnT
        with(binding) {
            titlebar.setBackIconColor(R.color.black)
            titlebar.setTitleText(R.string.version, R.color.black)
+
+
+            tvVersion.text = AndroidUtil.getAppVersionInfo()
        }

    }

    override fun ViewBinding.initWindowInsets() {
-        ViewCompat.setOnApplyWindowInsetsListener(contentRoot) { v, insets ->
-            val systemBars =
-                insets.getInsets(WindowInsetsCompat.Type.systemBars() or WindowInsetsCompat.Type.displayCutout())
-            v.updatePadding(top = systemBars.top)
-            insets
-        }
+        setImmerseRootView(contentRoot)
    }

    override fun ViewBinding.initListeners() {
--- a/app/src/main/java/com/gamedog/vididin/features/watchad/WatchAdActivity.kt
+++ b/app/src/main/java/com/gamedog/vididin/features/watchad/WatchAdActivity.kt
@ -0,0 +1,121 @@
+package com.gamedog.vididin.features.watchad
+
+import android.app.Activity
+import android.content.Intent
+import android.os.CountDownTimer
+import android.view.LayoutInflater
+import androidx.activity.addCallback
+import androidx.activity.viewModels
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsCompat
+import androidx.core.view.updatePadding
+import com.ama.core.architecture.appBase.AppViewsActivity
+import com.ama.core.architecture.util.AndroidUtil
+import com.ama.core.architecture.util.eventbus.NotifyMan
+import com.gamedog.vididin.VidiConst
+import com.gamedog.vididin.VididinEvents
+import com.gamedog.vididin.main.fragments.task.DailySignSuccessDialog
+import com.gamedog.vididin.main.interfaces.OnTabStyleListener
+import dagger.hilt.android.AndroidEntryPoint
+import kotlin.getValue
+import com.gamedog.vididin.databinding.ActivityWatchAdBinding as ViewBinding
+import com.gamedog.vididin.main.MainUiState as UiState
+import com.gamedog.vididin.main.MainViewModel as ViewModel
+
+
+@AndroidEntryPoint
+class WatchAdActivity : AppViewsActivity<ViewBinding, UiState, ViewModel>(), OnTabStyleListener {
+
+    override val mViewModel: ViewModel by viewModels()
+    override fun inflateViewBinding(inflater: LayoutInflater) = ViewBinding.inflate(inflater)
+
+
+    private lateinit var mCountDownTimer: CountDownTimer
+    private var mTaskType: Int = 0
+    private var mTaskData: String? = null
+
+    override fun ViewBinding.initViews() {
+        with(binding) {
+
+        }
+
+    }
+
+    override fun ViewBinding.initWindowInsets() {
+        ViewCompat.setOnApplyWindowInsetsListener(contentRoot) { v, insets ->
+            val systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars() or WindowInsetsCompat.Type.displayCutout())
+            v.updatePadding(top = systemBars.top)
+            insets
+        }
+    }
+
+    override fun ViewBinding.initListeners() {
+        onBackPressedDispatcher.addCallback(this@WatchAdActivity) {
+            AndroidUtil.showToast("Can't exit while watching video")
+        }
+
+        stateCounter()
+    }
+
+
+    private fun notifyAdWatchFinish() {
+        NotifyMan.instance().sendEvent(mTaskType, null)
+
+        if (mTaskType != VididinEvents.Event_AD_TASK_TYPE_Watch_Ad_Earn_Gold) {
+            NotifyMan.instance().sendEvent(VididinEvents.Event_Finish_One_Ad, NotifyMan.NotifyData(1))
+        }
+    }
+
+    private fun stateCounter() {
+        mCountDownTimer = object : CountDownTimer(3000, 1000) {
+            override fun onTick(millisUntilFinished: Long) {
+                val secondsRemaining = millisUntilFinished / 1000
+                binding.tvAdCounter.text = "${secondsRemaining}"
+            }
+
+            override fun onFinish() {
+                notifyAdWatchFinish()
+                finish()
+            }
+        }
+        mCountDownTimer.start()
+    }
+
+    override fun readIntent(intent: Intent) {
+        super.readIntent(intent)
+        mTaskType = intent.getIntExtra(KEY_TASK_TYPE, 0)
+        mTaskData = intent.getStringExtra(KEY_TASK_DATA)
+    }
+
+
+    override fun onDestroy() {
+        super.onDestroy()
+        mCountDownTimer.cancel()
+    }
+
+    override fun ViewBinding.initObservers() {
+        //TODO("Not yet implemented")
+    }
+
+    override fun ViewBinding.onUiStateCollect(uiState: UiState) {
+        //TODO("Not yet implemented")
+    }
+
+    override fun onTabIsDarkFont(isDarkFont: Boolean) {
+        //TODO("Not yet implemented")
+    }
+
+
+    companion object {
+        private val KEY_TASK_TYPE = "KEY_TASK_TYPE"
+        private val KEY_TASK_DATA = "KEY_TASK_DATA"
+
+        internal fun startActivity(activity: Activity, taskType: Int, taskDataJson: String?) {
+            val intent = Intent(activity.applicationContext, WatchAdActivity::class.java)
+            intent.putExtra(KEY_TASK_TYPE, taskType)
+            intent.putExtra(KEY_TASK_DATA, taskDataJson)
+            activity.startActivity(intent)
+        }
+    }
+
+}
--- a/app/src/main/java/com/gamedog/vididin/features/withdraw/BankUtil.kt
+++ b/app/src/main/java/com/gamedog/vididin/features/withdraw/BankUtil.kt
@ -48,4 +48,12 @@ object BankUtil {
        val remainder = sum % 11
        return if (remainder < 2) 0 else 11 - remainder
    }
+
+
+    private fun executeWithDraw() {
+
+
+    }
+
+
 }
--- a/app/src/main/java/com/gamedog/vididin/features/withdraw/WithDrawActivity.kt
+++ b/app/src/main/java/com/gamedog/vididin/features/withdraw/WithDrawActivity.kt
@ -8,7 +8,6 @@ import com.ama.core.architecture.appBase.AppViewsActivity
 import com.ama.core.architecture.util.setOnClickBatch
 import com.gamedog.vididin.R
 import com.gamedog.vididin.VididinEvents
-import com.gamedog.vididin.beans.Account
 import com.gamedog.vididin.core.login.login.AccountManager
 import com.gamedog.vididin.features.withdraw.widget.WithDrawItemView
 import com.gamedog.vididin.main.interfaces.OnTabStyleListener
@ -36,6 +35,8 @@ class WithDrawActivity : AppViewsActivity<ViewBinding, UiState, ViewModel>(), On
    }

    override fun ViewBinding.initViews() {
+        titlebar.setTitleText(R.string.sacar)
+
        mItemViewList.add(withdraw01)
        mItemViewList.add(withdraw10)
        mItemViewList.add(withdraw20)
@ -73,7 +74,7 @@ class WithDrawActivity : AppViewsActivity<ViewBinding, UiState, ViewModel>(), On
                updateUIItemSelectStates(itemIndex)
            })

-        withdrawPix2.setIconAndText(R.mipmap.pix2, R.string.pix2, {
+        withdrawPix2.setIconAndText(R.mipmap.pix2_big, R.string.pix2, {

        })

@ -85,8 +86,11 @@ class WithDrawActivity : AppViewsActivity<ViewBinding, UiState, ViewModel>(), On
            when(this) {
                tvSacar -> {
                    val hasBindBank = AccountManager.hasValidBankInfo()
+                    val cashNum = mItemViewList.get(mCurSelectedIndex).getCashNum()
                    if (!hasBindBank) {
-                        WithdrawBindBankDialog(this@WithDrawActivity).show()
+                        WithdrawBindBankDialog(this@WithDrawActivity).setWithDrawCashNum(cashNum).show()
+                    } else {
+                        WithdrawInfoConfirmDialog(this@WithDrawActivity).setWithDrawCashNum(cashNum).show()
                    }
                }

--- a/app/src/main/java/com/gamedog/vididin/features/withdraw/WithdrawBindBankDialog.kt
+++ b/app/src/main/java/com/gamedog/vididin/features/withdraw/WithdrawBindBankDialog.kt
@ -2,6 +2,7 @@ package com.gamedog.vididin.features.withdraw



+import android.app.Activity
 import android.content.Context
 import android.text.Editable
 import android.text.TextWatcher
@ -11,10 +12,11 @@ import com.ama.core.architecture.widget.BindingDialog
 import com.gamedog.vididin.R
 import com.gamedog.vididin.core.login.login.AccountManager
 import com.gamedog.vididin.databinding.DialogWithdrawBindingBankBinding as ViewBinding
-import com.gamedog.vididin.router.Router


-class WithdrawBindBankDialog(context: Context) : BindingDialog<ViewBinding>(context, ViewBinding::inflate) {
+class WithdrawBindBankDialog(activity: Activity) : BindingDialog<ViewBinding>(activity, ViewBinding::inflate) {
+
+    private var mWithdrawCashNum: Float = 0F

    init {
        build()
@ -36,6 +38,8 @@ class WithdrawBindBankDialog(context: Context) : BindingDialog<ViewBinding>(cont

                    tvConfirm -> {
                        saveBankAccount(mBinding.tvCpfEdit.text.toString().trim())
+                        WithdrawInfoConfirmDialog(mActivity).setWithDrawCashNum(mWithdrawCashNum).show()
+                        dismiss()
                    }
                }
            }
@ -90,14 +94,17 @@ class WithdrawBindBankDialog(context: Context) : BindingDialog<ViewBinding>(cont
        }
    }

-    private fun gotoWatchVideo() {
-        ownerActivity?.let { Router.Withdraw.startActivity(it) }
-    }
+

    override fun onDetachedFromWindow() {
        super.onDetachedFromWindow()
    }


+    fun setWithDrawCashNum(withdrawNum: Float): WithdrawBindBankDialog {
+        mWithdrawCashNum = withdrawNum
+        return this
+    }
+
 }

--- a/app/src/main/java/com/gamedog/vididin/features/withdraw/WithdrawBindBankFinishDialog.kt
+++ b/app/src/main/java/com/gamedog/vididin/features/withdraw/WithdrawBindBankFinishDialog.kt
@ -1,42 +0,0 @@
-package com.gamedog.vididin.features.withdraw
-
-
-import android.content.Context
-import com.ama.core.architecture.util.setOnClickBatch
-import com.ama.core.architecture.widget.BindingDialog
-import com.gamedog.vididin.databinding.DialogWithdrawBindingBankFinishBinding as ViewBinding
-import com.gamedog.vididin.router.Router
-
-
-class WithdrawBindBankFinishDialog(context: Context) : BindingDialog<ViewBinding>(context, ViewBinding::inflate) {
-
-    init {
-        build()
-    }
-
-
-    private fun build() {
-        with()
-        setCenter()
-        setMaskValue(0.8f)
-        setCanCancel(false)
-
-        mBinding.run {
-            setOnClickBatch(tvConfirm, ivClose) {
-                when (this) {
-                    tvConfirm, ivClose ->  {
-                        dismiss()
-                    }
-                }
-            }
-        }
-    }
-
-    private fun gotoWatchVideo() {
-        ownerActivity?.let { Router.Withdraw.startActivity(it) }
-    }
-
-
-
-}
-
--- a/app/src/main/java/com/gamedog/vididin/features/withdraw/WithdrawFailDialog.kt
+++ b/app/src/main/java/com/gamedog/vididin/features/withdraw/WithdrawFailDialog.kt
@ -1,14 +1,14 @@
 package com.gamedog.vididin.features.withdraw


-import android.content.Context
+import android.app.Activity
 import com.ama.core.architecture.util.setOnClickBatch
 import com.ama.core.architecture.widget.BindingDialog
 import com.gamedog.vididin.databinding.DialogWithdrawFailBinding as ViewBinding
 import com.gamedog.vididin.router.Router


-class WithdrawFailDialog(context: Context) : BindingDialog<ViewBinding>(context, ViewBinding::inflate) {
+class WithdrawFailDialog(context: Activity) : BindingDialog<ViewBinding>(context, ViewBinding::inflate) {

    init {
        build()
@ -22,9 +22,17 @@ class WithdrawFailDialog(context: Context) : BindingDialog<ViewBinding>(context,
        setCanCancel(false)

        mBinding.run {
-            setOnClickBatch(tvConfirm, ivClose) {
+            setOnClickBatch(tvActionFeedback, tvActionConfirm, ivClose) {
                when (this) {
-                    tvConfirm, ivClose ->  {
+                    ivClose ->  {
+                        dismiss()
+                    }
+
+                    tvActionFeedback ->  {
+                        gotoFeedback()
+                    }
+
+                    tvActionConfirm ->  {
                        dismiss()
                    }
                }
@ -32,8 +40,9 @@ class WithdrawFailDialog(context: Context) : BindingDialog<ViewBinding>(context,
        }
    }
    
-    private fun gotoWatchVideo() {
-        ownerActivity?.let { Router.Withdraw.startActivity(it) }
+
+    private fun gotoFeedback() {
+        Router.Feedback.startActivity(mActivity)
    }


--- a/app/src/main/java/com/gamedog/vididin/features/withdraw/WithdrawInfoConfirmDialog.kt
+++ b/app/src/main/java/com/gamedog/vididin/features/withdraw/WithdrawInfoConfirmDialog.kt
@ -0,0 +1,70 @@
+package com.gamedog.vididin.features.withdraw
+
+
+import android.app.Activity
+import android.content.Context
+import com.ama.core.architecture.util.ResUtil
+import com.ama.core.architecture.util.setOnClickBatch
+import com.ama.core.architecture.widget.BindingDialog
+import com.gamedog.vididin.R
+import com.gamedog.vididin.core.login.login.AccountManager
+import com.gamedog.vididin.databinding.DialogWithdrawInfoConfirmBinding as ViewBinding
+import com.gamedog.vididin.router.Router
+
+
+class WithdrawInfoConfirmDialog(context: Activity) : BindingDialog<ViewBinding>(context, ViewBinding::inflate) {
+
+    private var mWithdrawCashNum: Float = 0F
+
+    init {
+        build()
+    }
+
+
+    private fun build() {
+        with()
+        setCenter()
+        setMaskValue(0.8f)
+        setCanCancel(false)
+
+        mBinding.run {
+            setOnClickBatch(tvActionAlter, tvActionApply, ivClose) {
+                when (this) {
+                    ivClose ->  {
+                        dismiss()
+                    }
+
+                    tvActionAlter ->  {
+                        dismiss()
+                    }
+
+                    tvActionApply ->  {
+                        WithdrawWatchAdDialog(mActivity).show()
+                        dismiss()
+                    }
+                }
+            }
+        }
+    }
+
+
+    private fun gotoWatchVideo() {
+        Router.Withdraw.startActivity(mActivity)
+    }
+
+
+    fun setWithDrawCashNum(withdrawNum: Float): WithdrawInfoConfirmDialog {
+        mWithdrawCashNum = withdrawNum
+
+        mBinding.tvCashNum.text = buildString {
+            append(ResUtil.getString(R.string.cash))
+            append(" ")
+            append(mWithdrawCashNum)
+        }
+        mBinding.tvCpfAccount.text = AccountManager.getBankInfo()?.bankAccount
+
+        return this
+    }
+
+}
+
--- a/app/src/main/java/com/gamedog/vididin/features/withdraw/WithdrawSuccessDialog.kt
+++ b/app/src/main/java/com/gamedog/vididin/features/withdraw/WithdrawSuccessDialog.kt
@ -1,14 +1,14 @@
 package com.gamedog.vididin.features.withdraw


+import android.app.Activity
 import android.content.Context
 import com.ama.core.architecture.util.setOnClickBatch
 import com.ama.core.architecture.widget.BindingDialog
 import com.gamedog.vididin.databinding.DialogWithdrawSuccessBinding as ViewBinding
-import com.gamedog.vididin.router.Router


-class WithdrawSuccessDialog(context: Context) : BindingDialog<ViewBinding>(context, ViewBinding::inflate) {
+class WithdrawSuccessDialog(context: Activity) : BindingDialog<ViewBinding>(context, ViewBinding::inflate) {

    init {
        build()
@ -22,21 +22,17 @@ class WithdrawSuccessDialog(context: Context) : BindingDialog<ViewBinding>(conte
        setCanCancel(false)

        mBinding.run {
-            setOnClickBatch(tvConfirm, ivClose) {
+            setOnClickBatch(flAction, ivClose) {
                when (this) {
-                    tvConfirm, ivClose ->  {
+                    ivClose ->  {
+                        dismiss()
+                    }
+                    flAction ->  {
                        dismiss()
                    }
                }
            }
        }
    }
-
-    private fun gotoWatchVideo() {
-        ownerActivity?.let { Router.Withdraw.startActivity(it) }
-    }
-
-
-
 }

--- a/app/src/main/java/com/gamedog/vididin/features/withdraw/WithdrawWatchAdDialog.kt
+++ b/app/src/main/java/com/gamedog/vididin/features/withdraw/WithdrawWatchAdDialog.kt
@ -0,0 +1,57 @@
+package com.gamedog.vididin.features.withdraw
+
+
+import android.app.Activity
+import com.ama.core.architecture.util.setOnClickBatch
+import com.ama.core.architecture.widget.BindingDialog
+import com.gamedog.vididin.R
+import com.gamedog.vididin.databinding.DialogWithdrawWatchAdBinding as ViewBinding
+
+
+class WithdrawWatchAdDialog(context: Activity) : BindingDialog<ViewBinding>(context, ViewBinding::inflate) {
+
+    private var mWithdrawCashNum: Float = 0F
+
+    init {
+        build()
+    }
+
+
+    private fun build() {
+        with()
+        setCenter()
+        setMaskValue(0.8f)
+        setCanCancel(false)
+
+        mBinding.run {
+            progressBar.setBarColor(R.color.blue_ba, R.color.blue_ff)
+
+            setOnClickBatch(flAction, ivClose) {
+                when (this) {
+                    ivClose ->  {
+                        dismiss()
+                    }
+
+                    flAction ->  {
+                        gotoWatchVideo()
+                        dismiss()
+                    }
+                }
+            }
+        }
+    }
+
+
+    private fun gotoWatchVideo() {
+        // TODO -
+        //Router.Withdraw.startActivity(mActivity)
+
+        WithdrawFailDialog(mActivity).show()
+        WithdrawSuccessDialog(mActivity).show()
+    }
+
+
+
+
+}
+
--- a/app/src/main/java/com/gamedog/vididin/features/withdraw/widget/WithDrawItemView.kt
+++ b/app/src/main/java/com/gamedog/vididin/features/withdraw/widget/WithDrawItemView.kt
@ -54,5 +54,9 @@ class WithDrawItemView @JvmOverloads constructor(
        mBinding.root.setBackgroundResource(if (mIsSelected) R.drawable.withdraw_item_bg_selected else R.drawable.withdraw_item_bg_unselected)
    }

+    fun getCashNum(): Float {
+        return mCashNum
+    }
+

 }
--- a/app/src/main/java/com/gamedog/vididin/features/withdrawrecord/RecordCashRvAdapter.kt
+++ b/app/src/main/java/com/gamedog/vididin/features/withdrawrecord/RecordCashRvAdapter.kt
@ -0,0 +1,43 @@
+package com.gamedog.vididin.features.withdrawrecord
+
+import android.view.LayoutInflater
+import android.view.ViewGroup
+import androidx.core.content.ContextCompat
+import androidx.recyclerview.widget.DiffUtil
+import androidx.recyclerview.widget.ListAdapter
+import androidx.recyclerview.widget.RecyclerView
+import com.gamedog.vididin.beans.RecordCash
+import com.gamedog.vididin.databinding.FragmentWithdrawRecordCashItemBinding as ViewBinding
+
+class RecordCashRvAdapter : ListAdapter<RecordCash, RecordCashRvAdapter.ViewHolder>(DiffCallback()) {
+
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
+        val binding = ViewBinding.inflate(LayoutInflater.from(parent.context), parent, false)
+        return ViewHolder(binding)
+    }
+
+    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
+        holder.bind(getItem(position))
+    }
+
+    inner class ViewHolder(private val binding: ViewBinding) : RecyclerView.ViewHolder(binding.root) {
+        fun bind(transaction: RecordCash) {
+            binding.tvDate.text = transaction.dateTime
+            binding.tvTitle.text = transaction.statusText
+            binding.tvDescription.text = transaction.description
+            binding.tvAmount.text = transaction.amount
+            binding.tvAmount.setTextColor(ContextCompat.getColor(binding.root.context, transaction.amountColor))
+
+        }
+    }
+
+    class DiffCallback : DiffUtil.ItemCallback<RecordCash>() {
+        override fun areItemsTheSame(oldItem: RecordCash, newItem: RecordCash): Boolean {
+            return oldItem.id == newItem.id
+        }
+
+        override fun areContentsTheSame(oldItem: RecordCash, newItem: RecordCash): Boolean {
+            return oldItem == newItem
+        }
+    }
+}
--- a/app/src/main/java/com/gamedog/vididin/features/withdrawrecord/RecordCashViewModel.kt
+++ b/app/src/main/java/com/gamedog/vididin/features/withdrawrecord/RecordCashViewModel.kt
@ -0,0 +1,23 @@
+package com.gamedog.vididin.features.withdrawrecord
+
+
+import com.ama.core.architecture.appBase.vm.AppViewModel
+import com.gamedog.vididin.beans.RecordCash
+import dagger.hilt.android.lifecycle.HiltViewModel
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.flowOf
+import javax.inject.Inject
+import com.gamedog.vididin.features.withdrawrecord.RecordCashUiState as UiState
+
+
+@HiltViewModel
+class RecordCashViewModel @Inject constructor() : AppViewModel<UiState>() {
+    override val uiStateInitialValue: UiState = UiState()
+    override val uiStateFlow: Flow<UiState> = flowOf()
+
+
+}
+
+data class RecordCashUiState(
+    val mRecordList: MutableList<RecordCash> = mutableListOf()
+)
--- a/app/src/main/java/com/gamedog/vididin/features/withdrawrecord/RecordGoldRvAdapter.kt
+++ b/app/src/main/java/com/gamedog/vididin/features/withdrawrecord/RecordGoldRvAdapter.kt
@ -0,0 +1,42 @@
+package com.gamedog.vididin.features.withdrawrecord
+
+import android.view.LayoutInflater
+import android.view.ViewGroup
+import androidx.core.content.ContextCompat
+import androidx.recyclerview.widget.DiffUtil
+import androidx.recyclerview.widget.ListAdapter
+import androidx.recyclerview.widget.RecyclerView
+import com.gamedog.vididin.beans.RecordGold
+import com.gamedog.vididin.databinding.FragmentWithdrawRecordGoldItemBinding as ViewBinding
+
+class RecordGoldRvAdapter : ListAdapter<RecordGold, RecordGoldRvAdapter.ViewHolder>(DiffCallback()) {
+
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
+        val binding = ViewBinding.inflate(LayoutInflater.from(parent.context), parent, false)
+        return ViewHolder(binding)
+    }
+
+    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
+        holder.bind(getItem(position))
+    }
+
+    inner class ViewHolder(private val binding: ViewBinding) : RecyclerView.ViewHolder(binding.root) {
+        fun bind(transaction: RecordGold) {
+            binding.tvDate.text = transaction.dateTime
+            binding.tvTitle.text = transaction.statusText
+            binding.tvDescription.text = transaction.description
+            binding.tvAmount.text = transaction.amount
+            binding.tvAmount.setTextColor(ContextCompat.getColor(binding.root.context, transaction.amountColor))
+        }
+    }
+
+    class DiffCallback : DiffUtil.ItemCallback<RecordGold>() {
+        override fun areItemsTheSame(oldItem: RecordGold, newItem: RecordGold): Boolean {
+            return oldItem.id == newItem.id
+        }
+
+        override fun areContentsTheSame(oldItem: RecordGold, newItem: RecordGold): Boolean {
+            return oldItem == newItem
+        }
+    }
+}
--- a/app/src/main/java/com/gamedog/vididin/features/withdrawrecord/RecordGoldViewModel.kt
+++ b/app/src/main/java/com/gamedog/vididin/features/withdrawrecord/RecordGoldViewModel.kt
@ -0,0 +1,23 @@
+package com.gamedog.vididin.features.withdrawrecord
+
+
+import com.ama.core.architecture.appBase.vm.AppViewModel
+import com.gamedog.vididin.beans.RecordGold
+import dagger.hilt.android.lifecycle.HiltViewModel
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.flowOf
+import javax.inject.Inject
+import com.gamedog.vididin.features.withdrawrecord.RecordGoldUiState as UiState
+
+
+@HiltViewModel
+class RecordGoldViewModel @Inject constructor() : AppViewModel<UiState>() {
+    override val uiStateInitialValue: UiState = UiState()
+    override val uiStateFlow: Flow<UiState> = flowOf()
+
+
+}
+
+data class RecordGoldUiState(
+    val mRecordList: MutableList<RecordGold> = mutableListOf()
+)
--- a/app/src/main/java/com/gamedog/vididin/features/withdrawrecord/ViewPagerAdapter.kt
+++ b/app/src/main/java/com/gamedog/vididin/features/withdrawrecord/ViewPagerAdapter.kt
@ -0,0 +1,20 @@
+package com.gamedog.vididin.features.withdrawrecord
+
+import androidx.fragment.app.Fragment
+import androidx.fragment.app.FragmentActivity
+import androidx.viewpager2.adapter.FragmentStateAdapter
+import com.gamedog.vididin.features.withdrawrecord.fragments.CashRecordFragment
+import com.gamedog.vididin.features.withdrawrecord.fragments.GoldRecordFragment
+
+class ViewPagerAdapter(fragmentActivity: FragmentActivity) : FragmentStateAdapter(fragmentActivity) {
+
+    override fun getItemCount(): Int = 2
+
+    override fun createFragment(position: Int): Fragment {
+        return when (position) {
+            0 -> CashRecordFragment()
+            1 -> GoldRecordFragment()
+            else -> throw IllegalArgumentException("Invalid position: $position")
+        }
+    }
+}
--- a/app/src/main/java/com/gamedog/vididin/features/withdrawrecord/WithdrawRecordActivity.kt
+++ b/app/src/main/java/com/gamedog/vididin/features/withdrawrecord/WithdrawRecordActivity.kt
@ -8,8 +8,12 @@ import androidx.core.view.ViewCompat
 import androidx.core.view.WindowInsetsCompat
 import androidx.core.view.updatePadding
 import com.ama.core.architecture.appBase.AppViewsActivity
+import com.ama.core.architecture.util.ResUtil
+import com.ama.core.architecture.util.setOnClickBatch
 import com.gamedog.vididin.R
 import com.gamedog.vididin.main.interfaces.OnTabStyleListener
+import com.google.android.material.tabs.TabLayout
+import com.google.android.material.tabs.TabLayoutMediator
 import dagger.hilt.android.AndroidEntryPoint
 import kotlin.getValue
 import com.gamedog.vididin.databinding.ActivityWithdrawRecordBinding as ViewBinding
@ -26,8 +30,15 @@ class WithdrawRecordActivity : AppViewsActivity<ViewBinding, UiState, ViewModel>
    override fun ViewBinding.initViews() {

        with(binding) {
-            titlebar.setBackIconColor(R.color.black)
-            titlebar.setTitleText(R.string.title_cash_record, R.color.black)
+            setupViewPager()
+
+            setOnClickBatch(ivBack) {
+                when (this) {
+                    ivBack ->  {
+                        finish()
+                    }
+                }
+            }
        }

    }
@ -58,6 +69,36 @@ class WithdrawRecordActivity : AppViewsActivity<ViewBinding, UiState, ViewModel>
    }


+    private fun setupViewPager() {
+        val adapter = ViewPagerAdapter(this)
+        binding.viewPager.adapter = adapter
+
+        with (binding.tabLayout) {
+            addOnTabSelectedListener(object: TabLayout.OnTabSelectedListener {
+                override fun onTabSelected(tab: TabLayout.Tab?) {
+                    setTabTextColors(ResUtil.getColor(R.color.black),
+                        ResUtil.getColor(if (selectedTabPosition == 0) R.color.green_39 else R.color.yellow_0b))
+                }
+
+                override fun onTabUnselected(tab: TabLayout.Tab?) {
+                }
+
+                override fun onTabReselected(tab: TabLayout.Tab?) {
+                }
+
+            })
+        }
+
+        TabLayoutMediator(binding.tabLayout, binding.viewPager) { tab, position ->
+            tab.text = when (position) {
+                0 -> ResUtil.getString(R.string.record_cash_title)
+                1 -> ResUtil.getString(R.string.record_gold_title)
+                else -> null
+            }
+        }.attach()
+    }
+
+
    companion object {
        internal fun startActivity(activity: Activity) {
            activity.startActivity(Intent(activity.applicationContext, WithdrawRecordActivity::class.java))
@ -65,3 +106,8 @@ class WithdrawRecordActivity : AppViewsActivity<ViewBinding, UiState, ViewModel>
    }

 }
+
+
+
+
+
--- a/app/src/main/java/com/gamedog/vididin/features/withdrawrecord/fragments/CashRecordFragment.kt
+++ b/app/src/main/java/com/gamedog/vididin/features/withdrawrecord/fragments/CashRecordFragment.kt
@ -0,0 +1,118 @@
+package com.gamedog.vididin.features.withdrawrecord.fragments
+
+
+
+import android.view.LayoutInflater
+import android.view.ViewGroup
+import androidx.fragment.app.viewModels
+import androidx.recyclerview.widget.LinearLayoutManager
+import com.ama.core.architecture.appBase.AppViewsFragment
+import com.ama.core.architecture.appBase.OnFragmentBackgroundListener
+import com.ama.core.architecture.util.setStatusBarDarkFont
+import com.gamedog.vididin.R
+import com.gamedog.vididin.beans.RecordCash
+import com.gamedog.vididin.beans.TransactionStatus
+import com.gamedog.vididin.features.withdrawrecord.RecordCashRvAdapter
+import dagger.hilt.android.AndroidEntryPoint
+import kotlin.getValue
+import com.gamedog.vididin.databinding.FragmentWithdrawRecordCashBinding as ViewBinding
+import com.gamedog.vididin.features.withdrawrecord.RecordCashUiState as UiState
+import com.gamedog.vididin.features.withdrawrecord.RecordCashViewModel as ViewModel
+
+
+
+
+@AndroidEntryPoint
+class CashRecordFragment : AppViewsFragment<ViewBinding, UiState, ViewModel>(),
+    OnFragmentBackgroundListener {
+    private lateinit var mAdapter: RecordCashRvAdapter
+    override val mViewModel: ViewModel by viewModels()
+    override var isBackgroundBright: Boolean = true
+
+
+
+    private var isStatusBarDarkFont = false
+
+    override fun inflateViewBinding(
+        inflater: LayoutInflater,
+        container: ViewGroup?,
+    ) = ViewBinding.inflate(inflater, container, false)
+
+    override fun ViewBinding.initWindowInsets() {
+        binding?.root?.let { setImmerseRootView(it) }
+        isStatusBarDarkFont = true
+    }
+
+    override fun ViewBinding.initViews() {
+        setupRecyclerView()
+    }
+
+    override fun ViewBinding.initListeners() {
+
+    }
+
+    override fun ViewBinding.initObservers() {
+    }
+
+    override fun ViewBinding.onUiStateCollect(uiState: UiState) {
+
+    }
+
+    override fun onResume() {
+        super.onResume()
+        setStatusBarDarkFont(isDarkFont = isStatusBarDarkFont)
+    }
+
+
+    private fun setupRecyclerView() {
+        mAdapter = RecordCashRvAdapter()
+        binding?.recyclerView?.adapter = mAdapter
+        binding?.recyclerView?.layoutManager = LinearLayoutManager(requireContext())
+
+        // 模拟数据
+        val transactions = listOf(
+            RecordCash(
+                id = 1,
+                dateTime = "2025/10/31 17:30",
+                status = TransactionStatus.SUCCESS,
+                statusText = "Sucesso",
+                description = "Você solicitou o saque com sucesso!",
+                amount = "-R$ 0,1",
+                amountColor = R.color.red_11
+            ),
+            RecordCash(
+                id = 2,
+                dateTime = "2025/10/31 17:30",
+                status = TransactionStatus.FAILED,
+                statusText = "Falhou",
+                description = "Você solicitou o saque com sucesso!",
+                amount = "-R$ 0,0",
+                amountColor = R.color.red_11
+            ),
+            RecordCash(
+                id = 3,
+                dateTime = "2025/10/31 17:30",
+                status = TransactionStatus.PROCESSING,
+                statusText = "Em processamento...",
+                description = "Você solicitou o saque com sucesso!",
+                amount = "-R$ 10,0",
+                amountColor = R.color.red_11
+            ),
+            RecordCash(
+                id = 4,
+                dateTime = "2025/10/31 17:30",
+                status = TransactionStatus.REDEEM,
+                statusText = "Resgatar",
+                description = "Você resgatou 4980 moedas",
+                amount = "+R$ 10,0",
+                amountColor = R.color.green_39
+            )
+        )
+
+        mAdapter.submitList(transactions)
+    }
+
+    companion object {
+        internal fun newInstance() = CashRecordFragment()
+    }
+}
--- a/app/src/main/java/com/gamedog/vididin/features/withdrawrecord/fragments/GoldRecordFragment.kt
+++ b/app/src/main/java/com/gamedog/vididin/features/withdrawrecord/fragments/GoldRecordFragment.kt
@ -0,0 +1,119 @@
+package com.gamedog.vididin.features.withdrawrecord.fragments
+
+
+
+import android.view.LayoutInflater
+import android.view.ViewGroup
+import androidx.fragment.app.viewModels
+import androidx.recyclerview.widget.LinearLayoutManager
+import com.ama.core.architecture.appBase.AppViewsFragment
+import com.ama.core.architecture.appBase.OnFragmentBackgroundListener
+import com.ama.core.architecture.util.setStatusBarDarkFont
+import com.gamedog.vididin.R
+import com.gamedog.vididin.beans.RecordGold
+import com.gamedog.vididin.beans.TransactionStatus
+import com.gamedog.vididin.features.withdrawrecord.RecordCashRvAdapter
+import com.gamedog.vididin.features.withdrawrecord.RecordGoldRvAdapter
+import dagger.hilt.android.AndroidEntryPoint
+import kotlin.getValue
+import com.gamedog.vididin.databinding.FragmentWithdrawRecordGoldBinding as ViewBinding
+import com.gamedog.vididin.features.withdrawrecord.RecordGoldUiState as UiState
+import com.gamedog.vididin.features.withdrawrecord.RecordGoldViewModel as ViewModel
+
+
+
+
+@AndroidEntryPoint
+class GoldRecordFragment : AppViewsFragment<ViewBinding, UiState, ViewModel>(),
+    OnFragmentBackgroundListener {
+    private lateinit var mAdapter: RecordGoldRvAdapter
+    override val mViewModel: ViewModel by viewModels()
+    override var isBackgroundBright: Boolean = true
+
+
+
+    private var isStatusBarDarkFont = false
+
+    override fun inflateViewBinding(
+        inflater: LayoutInflater,
+        container: ViewGroup?,
+    ) = ViewBinding.inflate(inflater, container, false)
+
+    override fun ViewBinding.initWindowInsets() {
+        binding?.root?.let { setImmerseRootView(it) }
+        isStatusBarDarkFont = true
+    }
+
+    override fun ViewBinding.initViews() {
+        setupRecyclerView()
+    }
+
+    override fun ViewBinding.initListeners() {
+
+    }
+
+    override fun ViewBinding.initObservers() {
+    }
+
+    override fun ViewBinding.onUiStateCollect(uiState: UiState) {
+
+    }
+
+    override fun onResume() {
+        super.onResume()
+        setStatusBarDarkFont(isDarkFont = isStatusBarDarkFont)
+    }
+
+
+    private fun setupRecyclerView() {
+        mAdapter = RecordGoldRvAdapter()
+        binding?.recyclerView?.adapter = mAdapter
+        binding?.recyclerView?.layoutManager = LinearLayoutManager(requireContext())
+
+        // 模拟数据
+        val transactions = listOf(
+            RecordGold(
+                id = 1,
+                dateTime = "2025/10/31 17:30",
+                status = TransactionStatus.SUCCESS,
+                statusText = "Sucesso",
+                description = "Você solicitou o saque com sucesso!",
+                amount = "-R$ 0,1",
+                amountColor = R.color.red_11
+            ),
+            RecordGold(
+                id = 2,
+                dateTime = "2025/10/31 17:30",
+                status = TransactionStatus.FAILED,
+                statusText = "Falhou",
+                description = "Você solicitou o saque com sucesso!",
+                amount = "-R$ 0,0",
+                amountColor = R.color.red_11
+            ),
+            RecordGold(
+                id = 3,
+                dateTime = "2025/10/31 17:30",
+                status = TransactionStatus.PROCESSING,
+                statusText = "Em processamento...",
+                description = "Você solicitou o saque com sucesso!",
+                amount = "-R$ 10,0",
+                amountColor = R.color.red_11
+            ),
+            RecordGold(
+                id = 4,
+                dateTime = "2025/10/31 17:30",
+                status = TransactionStatus.REDEEM,
+                statusText = "Resgatar",
+                description = "Você resgatou 4980 moedas",
+                amount = "+R$ 10,0",
+                amountColor = R.color.green_39
+            )
+        )
+
+        mAdapter.submitList(transactions)
+    }
+
+    companion object {
+        internal fun newInstance() = CashRecordFragment()
+    }
+}
--- a/app/src/main/java/com/gamedog/vididin/features/zero/ZeroBuyActivity.kt
+++ b/app/src/main/java/com/gamedog/vididin/features/zero/ZeroBuyActivity.kt
@ -4,25 +4,32 @@ import android.app.Activity
 import android.content.Intent
 import android.view.LayoutInflater
 import androidx.activity.viewModels
-import androidx.core.view.ViewCompat
-import androidx.core.view.WindowInsetsCompat
-import androidx.core.view.updatePadding
-import com.ama.core.architecture.appBase.AppViewsActivity
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.lifecycleScope
+import androidx.lifecycle.repeatOnLifecycle
+import androidx.recyclerview.widget.GridLayoutManager
+import com.ama.core.architecture.appBase.AppViewsEmptyViewModelActivity
+import com.ama.core.architecture.util.CommonItemDecoration
 import com.ama.core.architecture.util.setOnClickBatch
 import com.gamedog.vididin.R
-import com.gamedog.vididin.main.interfaces.OnTabStyleListener
+import com.gamedog.vididin.beans.ZeroBuyResp
+import com.gamedog.vididin.core.login.login.AccountManager
+import com.gamedog.vididin.features.zero.dialogs.ZeroBuyRulesDialog
 import com.gamedog.vididin.router.Router
 import dagger.hilt.android.AndroidEntryPoint
-import kotlin.getValue
+import kotlinx.coroutines.launch
+import com.gamedog.vididin.netbase.Result
 import com.gamedog.vididin.databinding.ActivityZerobuyBinding as ViewBinding
-import com.gamedog.vididin.main.MainUiState as UiState
-import com.gamedog.vididin.main.MainViewModel as ViewModel
+


@AndroidEntryPoint
-class ZeroBuyActivity : AppViewsActivity<ViewBinding, UiState, ViewModel>(), OnTabStyleListener {
+class ZeroBuyActivity : AppViewsEmptyViewModelActivity<ViewBinding>() {
+    private val viewModel: ZeroBuyViewModel by viewModels()
+    private lateinit var mAdapter: ZeroItemAdapter
+
+

-    override val mViewModel: ViewModel by viewModels()
    override fun inflateViewBinding(inflater: LayoutInflater) = ViewBinding.inflate(inflater)

    override fun ViewBinding.initViews() {
@ -38,11 +45,22 @@ class ZeroBuyActivity : AppViewsActivity<ViewBinding, UiState, ViewModel>(), OnT
                }
            }

+            tvZeroGoldNum.text = AccountManager.getGold().toString()

            titlebar.setTitleText(R.string.zero_buy)
            titlebar.addRightIcon(R.mipmap.icon_question_mark, {
                showHintInfo()
            })
+
+
+            with(recyclerView) {
+                mAdapter = ZeroItemAdapter()
+                adapter = mAdapter
+                layoutManager = GridLayoutManager(this@ZeroBuyActivity, 2)
+                addItemDecoration(
+                    CommonItemDecoration.create(horizontalSpace = 45, verticalSpace = 45)
+                )
+            }
        }


@ -50,12 +68,7 @@ class ZeroBuyActivity : AppViewsActivity<ViewBinding, UiState, ViewModel>(), OnT
    }

    override fun ViewBinding.initWindowInsets() {
-        ViewCompat.setOnApplyWindowInsetsListener(contentRoot) { v, insets ->
-            val systemBars =
-                insets.getInsets(WindowInsetsCompat.Type.systemBars() or WindowInsetsCompat.Type.displayCutout())
-            v.updatePadding(top = systemBars.top)
-            insets
-        }
+        setImmerseRootView(contentRoot)
    }

    private fun showHintInfo() {
@ -64,26 +77,47 @@ class ZeroBuyActivity : AppViewsActivity<ViewBinding, UiState, ViewModel>(), OnT

    override fun ViewBinding.initListeners() {
        //TODO("Not yet implemented")
+        requestData()
    }

    override fun ViewBinding.initObservers() {
        //TODO("Not yet implemented")
    }

-    override fun ViewBinding.onUiStateCollect(uiState: UiState) {
-        //TODO("Not yet implemented")
-    }
-
-    override fun onTabIsDarkFont(isDarkFont: Boolean) {
-        //TODO("Not yet implemented")
-    }
-
-
    private fun gotoLotteryRecords() {
        Router.WinRecord.startActivity(this)
    }

+    //----------------------- start -----------------------------

+
+    private fun requestData() {
+        lifecycleScope.launch {
+            repeatOnLifecycle(Lifecycle.State.STARTED) {
+                viewModel.ZeroBuyListData.collect { result ->
+                    when (result) {
+                        is Result.Loading -> { }
+                        is Result.Success -> updateUIs(result.data)
+                        is Result.Error -> { }
+                    }
+                }
+            }
+        }
+
+        viewModel.requestZeroBuyInfo()
+    }
+
+
+
+    private fun updateUIs(data: ZeroBuyResp) {
+        mAdapter.submitList(data.mCurrentList)
+    }
+
+
+
+
+
+    //----------------------- end -----------------------------
    companion object {
        internal fun startActivity(activity: Activity) {
            activity.startActivity(Intent(activity.applicationContext, ZeroBuyActivity::class.java))
--- a/app/src/main/java/com/gamedog/vididin/features/zero/ZeroBuyViewModel.kt
+++ b/app/src/main/java/com/gamedog/vididin/features/zero/ZeroBuyViewModel.kt
@ -0,0 +1,102 @@
+package com.gamedog.vididin.features.zero
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import com.ama.core.architecture.util.AndroidUtil
+import com.ama.core.architecture.util.DeviceUtil
+import com.ama.core.architecture.util.SpUtil
+import com.gamedog.vididin.VidiConst
+import com.gamedog.vididin.beans.ZeroBuyItem
+import com.gamedog.vididin.beans.ZeroBuyResp
+import com.gamedog.vididin.core.login.login.AccountManager
+import com.gamedog.vididin.netbase.NetworkUtil
+import com.gamedog.vididin.netbase.Result
+import com.gamedog.vididin.request.RequestUtil
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.launch
+
+class ZeroBuyViewModel : ViewModel() {
+    private val _ZeroBuyListData = MutableStateFlow<Result<ZeroBuyResp>>(Result.Loading)
+    val ZeroBuyListData: StateFlow<Result<ZeroBuyResp>> = _ZeroBuyListData.asStateFlow()
+
+    private val _ZeroBuySecretData = MutableStateFlow<Result<String>>(Result.Loading)
+    val ZeroBuySecretData: StateFlow<Result<String>> = _ZeroBuySecretData.asStateFlow()
+
+
+    fun requestZeroBuySecret() {
+        viewModelScope.launch {
+            _ZeroBuySecretData.value = Result.Loading
+            val operationVal =  1
+            val curTimeSec = System.currentTimeMillis()/1000
+            val signStr = RequestUtil.getZeroBuyRequestSign(curTimeSec, operationVal)
+            val requestHeaders = mapOf("Operation" to operationVal.toString(), "Timestamp" to curTimeSec.toString(), "Sign" to signStr)
+
+            val result = NetworkUtil.get("${VidiConst.URL_ZERO_BUY}/anynameisok", requestHeaders)
+
+            when (result) {
+                is Result.Success -> {
+                    val respObj = AndroidUtil.json2Object<String>(result.data.string())
+                    _ZeroBuySecretData.value = Result.Success(respObj!!)
+                }
+                is Result.Error -> {
+                    _ZeroBuySecretData.value = Result.Error(result.exception, result.message)
+                }
+                else -> { }
+            }
+        }
+    }
+
+    fun requestZeroBuyInfo() {
+        viewModelScope.launch {
+            _ZeroBuyListData.value = Result.Loading
+
+            val operationVal = 0
+            val curTimeSec = System.currentTimeMillis()/1000
+            val signStr = RequestUtil.getZeroBuyRequestSign(curTimeSec, operationVal)
+            val requestHeaders = mapOf("Operation" to operationVal.toString(), "Timestamp" to curTimeSec.toString(), "Sign" to signStr)
+            val requestParams = mutableMapOf("AppId" to VidiConst.ZEROBUY_APPID, "DeviceId" to DeviceUtil.generateDeviceId())
+            val userId = AccountManager.getAccount()?.userId?: 0
+            if (userId > 0) {
+                requestParams.put("UserId", userId.toString())
+            }
+            val joinZeroBuyItemIds = SpUtil.instance().getList<Int>(SpUtil.KEY_ZEROBUY_JOINED_ACTIVITY_IDS)
+            if (joinZeroBuyItemIds.isNotEmpty()) {
+                requestParams.put("JoinedPurchaseIds", AndroidUtil.object2Json(joinZeroBuyItemIds))
+            }
+
+
+            val result = NetworkUtil.get("${VidiConst.URL_ZERO_BUY}/anynameisok", requestHeaders, requestParams)
+            when (result) {
+                is Result.Success -> {
+                    val respObj = AndroidUtil.json2Object<ZeroBuyResp>(result.data.string())?.apply {
+                        mCurrentList = AndroidUtil.json2Object<List<ZeroBuyItem>>(CurrentPurchases)
+                        mFinishedList = AndroidUtil.json2Object<List<ZeroBuyItem>>(FinishedPurchases)
+                    }
+
+                    respObj?.UserId?.let {
+                        if (userId <= 0) {
+                            AccountManager.saveUserIdInfo(it)
+                        }
+                    }
+
+                    // TODO - when to record joined activity Ids
+                    /*respObj?.Join?.let {
+                        if (userId <= 0) {
+                            AccountManager.saveUserIdInfo(it)
+                        }
+                    }*/
+
+                    _ZeroBuyListData.value = Result.Success(respObj!!)
+                }
+                is Result.Error -> {
+                    _ZeroBuyListData.value = Result.Error(result.exception, result.message)
+                }
+                else -> { }
+            }
+        }
+    }
+
+
+}
--- a/app/src/main/java/com/gamedog/vididin/features/zero/ZeroItemAdapter.kt
+++ b/app/src/main/java/com/gamedog/vididin/features/zero/ZeroItemAdapter.kt
@ -0,0 +1,45 @@
+package com.gamedog.vididin.features.zero
+
+import android.view.LayoutInflater
+import android.view.ViewGroup
+import androidx.recyclerview.widget.DiffUtil
+import androidx.recyclerview.widget.ListAdapter
+import androidx.recyclerview.widget.RecyclerView
+import com.gamedog.vididin.R
+import com.gamedog.vididin.beans.ZeroBuyItem
+import com.gamedog.vididin.databinding.LayoutItemZerobuyBinding as ViewBinding
+
+class ZeroItemAdapter : ListAdapter<ZeroBuyItem, ZeroItemAdapter.ViewHolder>(DiffCallback()) {
+
+    private val mBgResList = listOf<Int>(R.mipmap.zero_bg_item_sub1, R.mipmap.zero_bg_item_sub2, R.mipmap.zero_bg_item_sub3, R.mipmap.zero_bg_item_sub4)
+
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
+        val binding = ViewBinding.inflate(LayoutInflater.from(parent.context), parent, false)
+        return ViewHolder(binding)
+    }
+
+    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
+        holder.bind(getItem(position))
+    }
+
+    inner class ViewHolder(private val binding: ViewBinding) : RecyclerView.ViewHolder(binding.root) {
+        fun bind(item: ZeroBuyItem) {
+            binding.tvTitle.text = item.title
+            binding.tvJoinedNum.text = item.current_users?.size.toString()
+            binding.tvPeopleTotal.text = "/${item.target_num}"
+            binding.tvJoinGoldNum.text = item.cost.toString()
+            binding.ivBgType.setImageResource(mBgResList[item.image])
+            binding.tvRewardCashNum.text = item.price
+        }
+    }
+
+    class DiffCallback : DiffUtil.ItemCallback<ZeroBuyItem>() {
+        override fun areItemsTheSame(oldItem: ZeroBuyItem, newItem: ZeroBuyItem): Boolean {
+            return oldItem.id == newItem.id
+        }
+
+        override fun areContentsTheSame(oldItem: ZeroBuyItem, newItem: ZeroBuyItem): Boolean {
+            return oldItem == newItem
+        }
+    }
+}
--- a/app/src/main/java/com/gamedog/vididin/features/zero/dialogs/ZeroBuyFailDialog.kt
+++ b/app/src/main/java/com/gamedog/vididin/features/zero/dialogs/ZeroBuyFailDialog.kt
@ -1,14 +1,14 @@
-package com.gamedog.vididin.features.zero
+package com.gamedog.vididin.features.zero.dialogs


-import android.content.Context
+import android.app.Activity
 import com.ama.core.architecture.util.setOnClickBatch
 import com.ama.core.architecture.widget.BindingDialog
 import com.gamedog.vididin.databinding.DialogZeroBuyFailBinding as ViewBinding
 import com.gamedog.vididin.router.Router


-class ZeroBuyFailDialog(context: Context) : BindingDialog<ViewBinding>(context, ViewBinding::inflate) {
+class ZeroBuyFailDialog(context: Activity) : BindingDialog<ViewBinding>(context, ViewBinding::inflate) {

    init {
        build()
@ -33,7 +33,7 @@ class ZeroBuyFailDialog(context: Context) : BindingDialog<ViewBinding>(context,
    }

    private fun gotoWatchVideo() {
-        ownerActivity?.let { Router.Withdraw.startActivity(it) }
+        Router.Withdraw.startActivity(mActivity)
    }


--- a/app/src/main/java/com/gamedog/vididin/features/zero/dialogs/ZeroBuyNotWinDialog.kt
+++ b/app/src/main/java/com/gamedog/vididin/features/zero/dialogs/ZeroBuyNotWinDialog.kt
@ -1,14 +1,14 @@
-package com.gamedog.vididin.features.zero
+package com.gamedog.vididin.features.zero.dialogs


-import android.content.Context
+import android.app.Activity
 import com.ama.core.architecture.util.setOnClickBatch
 import com.ama.core.architecture.widget.BindingDialog
 import com.gamedog.vididin.databinding.DialogZeroBuyNotWinBinding as ViewBinding
 import com.gamedog.vididin.router.Router


-class ZeroBuyNotWinDialog(context: Context) : BindingDialog<ViewBinding>(context, ViewBinding::inflate) {
+class ZeroBuyNotWinDialog(context: Activity) : BindingDialog<ViewBinding>(context, ViewBinding::inflate) {

    init {
        build()
@ -33,7 +33,7 @@ class ZeroBuyNotWinDialog(context: Context) : BindingDialog<ViewBinding>(context
    }

    private fun gotoWatchVideo() {
-        ownerActivity?.let { Router.Withdraw.startActivity(it) }
+        Router.Withdraw.startActivity(mActivity)
    }


--- a/app/src/main/java/com/gamedog/vididin/features/zero/dialogs/ZeroBuyRulesDialog.kt
+++ b/app/src/main/java/com/gamedog/vididin/features/zero/dialogs/ZeroBuyRulesDialog.kt
@ -1,14 +1,14 @@
-package com.gamedog.vididin.features.zero
+package com.gamedog.vididin.features.zero.dialogs


-import android.content.Context
+import android.app.Activity
 import com.ama.core.architecture.util.setOnClickBatch
 import com.ama.core.architecture.widget.BindingDialog
 import com.gamedog.vididin.databinding.DialogZeroBuyRuleBinding as ViewBinding
 import com.gamedog.vididin.router.Router


-class ZeroBuyRulesDialog(context: Context) : BindingDialog<ViewBinding>(context, ViewBinding::inflate) {
+class ZeroBuyRulesDialog(context: Activity) : BindingDialog<ViewBinding>(context, ViewBinding::inflate) {

    init {
        build()
@ -33,7 +33,7 @@ class ZeroBuyRulesDialog(context: Context) : BindingDialog<ViewBinding>(context,
    }

    private fun gotoWatchVideo() {
-        ownerActivity?.let { Router.Withdraw.startActivity(it) }
+        Router.Withdraw.startActivity(mActivity)
    }


--- a/app/src/main/java/com/gamedog/vididin/features/zero/dialogs/ZeroBuyWinDialog.kt
+++ b/app/src/main/java/com/gamedog/vididin/features/zero/dialogs/ZeroBuyWinDialog.kt
@ -1,14 +1,14 @@
-package com.gamedog.vididin.features.zero
+package com.gamedog.vididin.features.zero.dialogs


-import android.content.Context
+import android.app.Activity
 import com.ama.core.architecture.util.setOnClickBatch
 import com.ama.core.architecture.widget.BindingDialog
 import com.gamedog.vididin.databinding.DialogZeroBuyWinBinding as ViewBinding
 import com.gamedog.vididin.router.Router


-class ZeroBuyWinDialog(context: Context) : BindingDialog<ViewBinding>(context, ViewBinding::inflate) {
+class ZeroBuyWinDialog(context: Activity) : BindingDialog<ViewBinding>(context, ViewBinding::inflate) {

    init {
        build()
@ -33,7 +33,7 @@ class ZeroBuyWinDialog(context: Context) : BindingDialog<ViewBinding>(context, V
    }

    private fun gotoWatchVideo() {
-        ownerActivity?.let { Router.Withdraw.startActivity(it) }
+        Router.Withdraw.startActivity(mActivity)
    }


--- a/app/src/main/java/com/gamedog/vididin/login/AccountManager.kt
+++ b/app/src/main/java/com/gamedog/vididin/login/AccountManager.kt
@ -1,16 +1,21 @@
 package com.gamedog.vididin.core.login.login

+import com.ama.core.architecture.util.AndroidUtil
 import com.ama.core.architecture.util.DateUtil
 import com.ama.core.architecture.util.DeviceUtil
 import com.ama.core.architecture.util.SpUtil
 import com.ama.core.architecture.util.eventbus.NotifyMan
+import com.gamedog.vididin.VidiConst
 import com.gamedog.vididin.VididinEvents
 import com.gamedog.vididin.beans.Account
 import com.gamedog.vididin.beans.BankInfo
+import kotlinx.coroutines.sync.Mutex


 object AccountManager {

+    private val mutex = Mutex()
+
    private val mAccount: Account? by lazy {
        var account = SpUtil.instance().getObject<Account>(SpUtil.KEY_ACCOUNT)
        if (account == null) {
@ -39,12 +44,14 @@ object AccountManager {
        return mAccount?.cashCount ?: 0F
    }

+    @Synchronized
    fun addGold(newGold: Int) {
        mAccount?.goldCount += newGold
        saveAccountInfo()
        NotifyMan.instance().sendEvent(VididinEvents.Event_Account_Gold_Changed, null)
    }

+    @Synchronized
    fun addCash(newCash: Float) {
        mAccount?.cashCount += newCash
        saveAccountInfo()
@ -71,5 +78,37 @@ object AccountManager {
            VididinEvents.Event_Account_Bank_Info_Changed, NotifyMan.NotifyData(bankAccount))
    }

+
+
+    @Synchronized
+    fun convertGold2Cash(): Boolean  {
+        try {
+            val couldCovertCashTotal = mAccount?.goldCount?.div(VidiConst.PER_CASH_COST_GOLD_NUM) ?: 0L
+            if (couldCovertCashTotal > 0) {
+                val costGoldNum = couldCovertCashTotal * VidiConst.PER_CASH_COST_GOLD_NUM
+                mAccount?.goldCount?.let {
+                    if (it > costGoldNum) {
+                        addGold(-1 * costGoldNum.toInt())
+                        addCash(couldCovertCashTotal.toFloat())
+                        AndroidUtil.showToast("Has convert $costGoldNum gold to $couldCovertCashTotal cash.")
+                        return true
+                    }
+                }
+            } else {
+                AndroidUtil.showToast("You don't have enough gold.")
+            }
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
+        return false
+    }
+
+    fun saveUserIdInfo(userId: Int) {
+        mAccount?.let {
+            it.userId = userId
+            saveAccountInfo()
+        }
+    }
+
 }

--- a/app/src/main/java/com/gamedog/vididin/main/BeginnerGiftDialog.kt
+++ b/app/src/main/java/com/gamedog/vididin/main/BeginnerGiftDialog.kt
@ -1,14 +1,15 @@
 package com.gamedog.vididin.main

 import android.app.Activity
-import android.content.Context
+import com.ama.core.architecture.util.eventbus.NotifyMan
 import com.ama.core.architecture.util.setOnClickBatch
 import com.ama.core.architecture.widget.BindingDialog
+import com.gamedog.vididin.VididinEvents
 import com.gamedog.vididin.databinding.DialogBeginnerGiftBinding
 import com.gamedog.vididin.router.Router


-class BeginnerGiftDialog(context: Context) : BindingDialog<DialogBeginnerGiftBinding>(context, DialogBeginnerGiftBinding::inflate) {
+class BeginnerGiftDialog(activity: Activity) : BindingDialog<DialogBeginnerGiftBinding>(activity, DialogBeginnerGiftBinding::inflate) {

    init {
        build()
@ -25,7 +26,10 @@ class BeginnerGiftDialog(context: Context) : BindingDialog<DialogBeginnerGiftBin
            setOnClickBatch(tvAction) {
                when (this) {
                    tvAction ->  {
-                        gotoWatchVideo()
+                        if (mActivity is MainActivity) {
+                            (mActivity as MainActivity).switchTab(1)
+                        }
+                        NotifyMan.instance().sendEvent(VididinEvents.EVENT_JUMP_2_FIRST_WITHDRAW, null)
                        dismiss()
                    }
                }
@ -34,7 +38,7 @@ class BeginnerGiftDialog(context: Context) : BindingDialog<DialogBeginnerGiftBin
    }

    private fun gotoWatchVideo() {
-        ownerActivity?.let { Router.Withdraw.startActivity(it) }
+        Router.Withdraw.startActivity(mActivity)
    }


--- a/app/src/main/java/com/gamedog/vididin/main/MainActivity.kt
+++ b/app/src/main/java/com/gamedog/vididin/main/MainActivity.kt
@ -1,6 +1,9 @@
 package com.gamedog.vididin.main


+
+import android.content.Intent
+import android.content.IntentFilter
 import com.ama.core.common.util.asSafe
 import androidx.core.view.ViewCompat
 import androidx.core.view.WindowInsetsCompat
@ -18,9 +21,13 @@ import com.ama.core.architecture.util.bindViewPager2
 import com.ama.core.architecture.util.setCommonNavigator
 import com.ama.core.architecture.util.setDataOrAdapter
 import com.gamedog.vididin.R
+import com.gamedog.vididin.VidiConst
+import com.gamedog.vididin.VididinEvents
 import com.gamedog.vididin.adapter.MainTabsAdapter
 import com.gamedog.vididin.adapter.MainViewPagerAdapter
+import com.gamedog.vididin.main.fragments.task.DailySignSuccessDialog
 import com.gamedog.vididin.main.interfaces.OnTabStyleListener
+import com.gamedog.vididin.manager.DateChangeReceiver
 import dagger.hilt.android.AndroidEntryPoint
 import kotlin.getValue
 import com.gamedog.vididin.databinding.ActivityMainBinding as ViewBinding
@ -36,6 +43,8 @@ class MainActivity : AppViewsActivity<ViewBinding, UiState, ViewModel>(), OnTabS
    override val mViewModel: ViewModel by viewModels()
    private lateinit var navigatorAdapter: MainTabsAdapter
    private val fragmentStateAdapter by lazy { MainViewPagerAdapter(this) }
+    private lateinit var mDateChangeReceiver: DateChangeReceiver
+


    override fun inflateViewBinding(inflater: LayoutInflater) = ViewBinding.inflate(inflater)
@ -54,6 +63,7 @@ class MainActivity : AppViewsActivity<ViewBinding, UiState, ViewModel>(), OnTabS
        }
    }

+
    override fun ViewBinding.initViews() {
        content.foreground.alpha = 0
        navigatorAdapter = MainTabsAdapter(
@ -71,6 +81,10 @@ class MainActivity : AppViewsActivity<ViewBinding, UiState, ViewModel>(), OnTabS
    }

    override fun ViewBinding.initListeners() {
+        mDateChangeReceiver = DateChangeReceiver()
+        val filter = IntentFilter(Intent.ACTION_DATE_CHANGED)
+        registerReceiver(mDateChangeReceiver, filter)
+
        onBackPressedDispatcher.addCallback(this@MainActivity) {
            if (mViewModel.canBack) {
                finish()
@ -97,6 +111,19 @@ class MainActivity : AppViewsActivity<ViewBinding, UiState, ViewModel>(), OnTabS
                onTabIsDarkFont(isBackgroundBright)
            }
        }, false)
+
+        registerEvents( { data->
+            when (data?.mEventType) {
+                VididinEvents.Event_AD_TASK_TYPE_Watch_Ad_Earn_Gold-> {
+                    DailySignSuccessDialog(this@MainActivity).initData(VidiConst.WATCH_AD_REWARD_GOLD.toInt(), false).show()
+                }
+
+                VididinEvents.EVENT_JUMP_2_VIDEO-> {
+                    switchTab(0)
+                }
+            }
+
+        }, VididinEvents.Event_AD_TASK_TYPE_Watch_Ad_Earn_Gold, VididinEvents.EVENT_JUMP_2_VIDEO)
    }

    override fun ViewBinding.initObservers() {
@ -114,7 +141,20 @@ class MainActivity : AppViewsActivity<ViewBinding, UiState, ViewModel>(), OnTabS
        super.onResume()
    }

+    override fun onDestroy() {
+        super.onDestroy()
+        unregisterReceiver(mDateChangeReceiver)
+    }
+
    override fun onTabIsDarkFont(isDarkFont: Boolean) {
        navigatorAdapter.setIsDarkFont(isDarkFont)
    }
+
+    fun switchTab(itemIndex: Int) {
+        binding.viewPager2.setCurrentItem(itemIndex, false)
+    }
+
+
+
+
 }
--- a/app/src/main/java/com/gamedog/vididin/main/WatchVideoDialog.kt
+++ b/app/src/main/java/com/gamedog/vididin/main/WatchVideoDialog.kt
@ -1,14 +1,15 @@
 package com.gamedog.vididin.main

-import android.content.Context
+import android.app.Activity
 import com.ama.core.architecture.util.setOnClickBatch
 import com.ama.core.architecture.widget.BindingDialog
 import com.gamedog.vididin.databinding.DialogWatchVideoBinding
-import com.gamedog.vididin.main.fragments.task.RewardDetail
+import com.gamedog.vididin.router.Router


-class WatchVideoDialog(context: Context) : BindingDialog<DialogWatchVideoBinding>(context, DialogWatchVideoBinding::inflate) {
-    private lateinit var mDataList: List<RewardDetail>
+class WatchAdDialog(context: Activity, private val mTaskType: Int, private val mGoldNum: Int? = 0,
+                    private val mTaskDataJson: String? = "")
+    : BindingDialog<DialogWatchVideoBinding>(context, DialogWatchVideoBinding::inflate) {

    init {
        build()
@ -29,15 +30,17 @@ class WatchVideoDialog(context: Context) : BindingDialog<DialogWatchVideoBinding
                    }
                    flAction ->  {
                        gotoWatchVideo()
-                        dismiss()
                    }
                }
            }
+
+            tvGoldNum.text = "+$mGoldNum"
        }
    }

    private fun gotoWatchVideo() {
-
+        Router.WatchAd.startActivity(mActivity, mTaskType, mTaskDataJson)
+        dismiss()
    }


--- a/app/src/main/java/com/gamedog/vididin/main/fragments/HomeFragment.kt
+++ b/app/src/main/java/com/gamedog/vididin/main/fragments/HomeFragment.kt
@ -15,10 +15,14 @@ import com.ama.core.architecture.appBase.AppViewsFragment
 import com.ama.core.architecture.appBase.OnFragmentBackgroundListener
 import com.ama.core.architecture.util.setStatusBarDarkFont
 import com.ama.core.common.util.asSafe
+import com.gamedog.vididin.VididinEvents
+import com.gamedog.vididin.core.login.login.AccountManager
 import com.gamedog.vididin.main.fragments.home.HomeFragmentStateAdapter
 import com.gamedog.vididin.main.fragments.home.fragment.HomeItemFragment
 import com.gamedog.vididin.main.interfaces.OnSwitchTabListener
 import com.gamedog.vididin.main.interfaces.OnTabStyleListener
+import com.gamedog.vididin.youtubestatistic.RewardConst
+import com.gamedog.vididin.youtubestatistic.RewardConst.Companion.Check_Interval_MS
 import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.launch
 import kotlin.getValue
@ -31,6 +35,7 @@ import com.gamedog.vididin.main.fragments.home.YoutubeUiState as UiState
@AndroidEntryPoint
 class HomeFragment : AppViewsFragment<ViewBinding, UiState, ViewModel>(), OnSwitchTabListener, OnFragmentBackgroundListener {

+    private var mTotalMs: Long = 0L
    override val mViewModel: ViewModel by viewModels()
    override var isBackgroundBright: Boolean = true

@ -54,15 +59,35 @@ class HomeFragment : AppViewsFragment<ViewBinding, UiState, ViewModel>(), OnSwit
        viewPager2.setPageTransformer { _, _ -> }
        viewPager2.offscreenPageLimit = 1
        viewPager2.adapter = mViewPagerAdapter
+
+        registerEvents({
+            handleWatchTimeTick()
+        }, VididinEvents.Event_HOME_WATCH_Time_TICK,)
+    }
+
+    private fun handleWatchTimeTick() {
+        mTotalMs += Check_Interval_MS
+
+        if (mTotalMs < RewardConst.HOME_WATCH_DURATION) {
+            binding?.dragIconView?.setProgress(mTotalMs * 100/RewardConst.HOME_WATCH_DURATION)
+        } else {
+            mTotalMs = 0L
+            binding?.dragIconView?.setProgress(mTotalMs * 100/ RewardConst.HOME_WATCH_DURATION)
+            AccountManager.addGold(RewardConst.HOME_WATCH_REWARD_NUM)
+            binding?.dragIconView?.showRewardGoldAnim()
+        }
    }

    override fun ViewBinding.initListeners() {
        viewPager2.registerOnPageChangeCallback(object : ViewPager2.OnPageChangeCallback() {
            override fun onPageSelected(position: Int) {
                super.onPageSelected(position)
-                setHomeTabStyle(mViewPagerAdapter.getFragmentByIndex(position))
-                val curFragment: HomeItemFragment = mViewPagerAdapter.getFragmentByIndex(position) as HomeItemFragment
-                curFragment.loadVideo()
+                val fragment = mViewPagerAdapter.getFragmentByIndex(position)
+                if (fragment != null) {
+                    setHomeTabStyle(fragment)
+                    val curFragment: HomeItemFragment = fragment as HomeItemFragment
+                    curFragment.loadVideo()
+                }

                // load more
                if (mViewPagerAdapter.itemCount > 0 && position == mViewPagerAdapter.itemCount - 2) {
@ -91,8 +116,21 @@ class HomeFragment : AppViewsFragment<ViewBinding, UiState, ViewModel>(), OnSwit
    }

    override fun ViewBinding.onUiStateCollect(uiState: UiState) {
+        /*val videoList = mutableListOf<YoutubeVideo>()
+        if (uiState.playLists == null) {
+            videoList.add(YoutubeVideo("TegalxCm1LA", "111", "bbbbb"))
+            videoList.add(YoutubeVideo("KA54UCs3E_4", "222", "bbbbb"))
+            videoList.add(YoutubeVideo("_bAxHM7O_9k", "333", "bbbbb"))
+            videoList.add(YoutubeVideo("6vAYPVTGs90", "444", "bbbbb"))
+            videoList.add(YoutubeVideo("bLAfi6cWcoI", "555", "bbbbb"))
+            videoList.add(YoutubeVideo("WX1MvqCzQ2k", "666", "bbbbb"))
+            videoList.add(YoutubeVideo("nkRPma2F4s4", "777", "bbbbb"))
+            videoList.add(YoutubeVideo("ssosMzYpQgc", "888", "bbbbb"))
+            videoList.add(YoutubeVideo("1sXHOCQcbwc", "999", "bbbbb"))
+            mViewPagerAdapter.submitList(videoList)
+            return
+        }*/
        mViewPagerAdapter.submitList(uiState.playLists)
-        //viewPager2.setDataOrAdapter(uiState.playLists, 1) { mViewPagerAdapter }
    }

    override fun onResume() {
--- a/app/src/main/java/com/gamedog/vididin/main/fragments/TasksFragment.kt
+++ b/app/src/main/java/com/gamedog/vididin/main/fragments/TasksFragment.kt
@ -1,7 +1,10 @@
 package com.gamedog.vididin.main.fragments

+import android.Manifest
 import android.view.LayoutInflater
+import android.view.View
 import android.view.ViewGroup
+import android.widget.LinearLayout
 import androidx.core.view.ViewCompat
 import androidx.core.view.WindowInsetsCompat
 import androidx.core.view.updatePadding
@ -9,20 +12,29 @@ import androidx.fragment.app.viewModels
 import androidx.lifecycle.lifecycleScope
 import com.ama.core.architecture.appBase.AppViewsFragment
 import com.ama.core.architecture.appBase.OnFragmentBackgroundListener
+import com.ama.core.architecture.util.AndroidUtil
 import com.ama.core.architecture.util.ResUtil
 import com.ama.core.architecture.util.eventbus.NotifyMan
+import com.ama.core.architecture.util.permission.PermissionUtil
 import com.ama.core.architecture.util.setOnClickBatch
 import com.ama.core.architecture.util.setStatusBarDarkFont
 import com.gamedog.vididin.R
+import com.gamedog.vididin.VidiConst
 import com.gamedog.vididin.VididinEvents
 import com.gamedog.vididin.core.login.login.AccountManager
-import com.gamedog.vididin.main.WatchVideoDialog
+import com.gamedog.vididin.main.MainActivity
+import com.gamedog.vididin.main.WatchAdDialog
 import com.gamedog.vididin.main.fragments.task.DailySignDialog
+import com.gamedog.vididin.main.fragments.task.DailySignSuccessDialog
 import com.gamedog.vididin.main.fragments.task.TaskBean
+import com.gamedog.vididin.main.fragments.task.widget.DailyTaskItemView
 import com.gamedog.vididin.main.interfaces.OnTabClickAgainListener
 import com.gamedog.vididin.manager.TaskManager
+import com.gamedog.vididin.manager.taskbeans.BaseTaskState.Companion.STATE_FINISH
+import com.gamedog.vididin.manager.taskbeans.BaseTaskState.Companion.STATE_ONGOING
 import com.gamedog.vididin.router.Router
 import dagger.hilt.android.AndroidEntryPoint
+import kotlinx.coroutines.Runnable
 import kotlinx.coroutines.launch
 import kotlin.getValue
 import com.gamedog.vididin.databinding.VididinappFeatureMessageFragmentMessageBinding as ViewBinding
@ -34,10 +46,14 @@ import com.gamedog.vididin.main.fragments.home.YoutubeUiState as UiState
@AndroidEntryPoint
 class TasksFragment : AppViewsFragment<ViewBinding, UiState, ViewModel>(), OnTabClickAgainListener, OnFragmentBackgroundListener {

+
    private var mTaskConfig: TaskBean? = null
    override val mViewModel: ViewModel by viewModels()
    override var isBackgroundBright: Boolean = true

+    private val mDailyWatchVideoViewList = mutableListOf<DailyTaskItemView>()
+    private val mDailyWatchAdViewList = mutableListOf<DailyTaskItemView>()
+

    override fun inflateViewBinding(
        inflater: LayoutInflater,
@ -56,30 +72,31 @@ class TasksFragment : AppViewsFragment<ViewBinding, UiState, ViewModel>(), OnTab

    override fun ViewBinding.initViews() {
        with(binding) {
-            setOnClickBatch(ivGotoDailySign, llTaskBenefit, llTaskWatchVideo, llTaskGame, llTaskZerobuy, tvWatchVideo, tvWithdraw) {
+            setOnClickBatch(ivGotoDailySign, llTaskBenefit, llTaskWatchAd, llTaskGame,
+                llTaskZerobuy, tvWatchVideoForConvertGoldToCash, tvWithdraw) {
                when(this) {
                    ivGotoDailySign->{
-                        DailySignDialog(context).show()
+                        DailySignDialog(requireActivity()).show()
                    }

                    llTaskBenefit->{
                        Router.Benefit.startActivity(requireActivity())
                    }

-                    llTaskWatchVideo->{
-                        WatchVideoDialog(requireContext()).show()
+                    llTaskWatchAd->{
+                        WatchAdDialog(requireActivity(), VididinEvents.Event_AD_TASK_TYPE_Watch_Ad_Earn_Gold, 200).show()
                    }

                    llTaskGame->{
-
+                        AndroidUtil.openUrl(VidiConst.URL_GAME)
                    }

                    llTaskZerobuy->{
                        Router.ZeroBuy.startActivity(requireActivity())
                    }

-                    tvWatchVideo->{
-                        WatchVideoDialog(requireContext()).show()
+                    tvWatchVideoForConvertGoldToCash->{
+                        WatchAdDialog(requireActivity(), VididinEvents.Event_AD_TASK_TYPE_Convert_Gold_2_Cash, null).show()
                    }

                    tvWithdraw->{
@ -90,51 +107,30 @@ class TasksFragment : AppViewsFragment<ViewBinding, UiState, ViewModel>(), OnTab



-            beginnerTaskWithdraw.initUI(R.mipmap.icon_cash_s, R.string.beginner_withdraw_title, R.string.beginner_withdraw_desc,R.string.resgatar)
-            beginnerTaskWithdraw.setRewardIcon(R.mipmap.icon_cash_s)
-            beginnerTaskWithdraw.setRewardTextStyle(21, R.color.green_39)
-            beginnerTaskWithdraw.setActionFun {
-                gotoWithDraw()
+            with(beginnerTaskWithdraw) {
+                initUI(R.mipmap.icon_cash_s, R.string.beginner_withdraw_title, R.string.resgatar)
+                //setRewardTextStyle(21, R.color.green_39)
+                updateNewBieFirstWithdrawUI()
            }

-            beginnerTaskDiscord.initUI(R.mipmap.icon_dicord, R.string.beginner_discord_title, R.string.beginner_discord_desc,R.string.resgatar)
-            beginnerTaskDiscord.setActionFun {
-                gotoDiscord()
+
+            with(beginnerTaskDiscord) {
+                initUI(R.mipmap.icon_dicord, R.string.beginner_discord_title,R.string.resgatar)
+                updateNewBieDiscordUI()
            }

-            beginnerTaskEnableNotify.initUI(R.mipmap.icon_notify, R.string.beginner_notify_title, R.string.beginner_notify_desc,R.string.Resgatado)
-            beginnerTaskEnableNotify.setActionFun {
-                gotoNotification()
+            with(beginnerTaskEnableNotify) {
+                initUI(R.mipmap.icon_notify, R.string.beginner_notify_title,R.string.Resgatado)
+                updateNewBieNotifyUI()
            }

-            dailyTaskWatch1.initUI(R.mipmap.icon_video_task, R.string.daily_video_task_title, 1, R.string.resgatar)
-            dailyTaskWatch1.setActionFun {
-                gotoWithVideo()
-            }
-
-            dailyTaskWatch5.initUI(R.mipmap.icon_video_task, R.string.daily_video_task_title, 5, R.string.go_and_do)
-            dailyTaskWatch5.setActionFun {
-                gotoWithVideo()
-            }
-
-            dailyTaskWatch10.initUI(R.mipmap.icon_video_task, R.string.daily_video_task_title, 10, R.string.go_and_do)
-            dailyTaskWatch10.setActionFun {
-                gotoWithVideo()
-            }
-
-            dailyTaskWatch20.initUI(R.mipmap.icon_video_task, R.string.daily_video_task_title, 20, R.string.go_and_do)
-            dailyTaskWatch20.setActionFun {
-                gotoWithVideo()
-            }
-
-            dailyTaskWatch30.initUI(R.mipmap.icon_video_task, R.string.daily_video_task_title, 30, R.string.go_and_do)
-            dailyTaskWatch30.setActionFun {
-                gotoWithVideo()
-            }

+            addDailySubTasks()

            updateUIGoldTotal()
            updateUICashTotal()
+            updateDailyWatchVideoUI()
+            updateDailyWatchAdUI()
        }

        lifecycleScope.launch {
@ -142,6 +138,60 @@ class TasksFragment : AppViewsFragment<ViewBinding, UiState, ViewModel>(), OnTab
        }
    }

+    private fun addDailySubTasks() {
+        //1. 阶梯广告
+        val dailyWatchAdTask = TaskManager.instance().getDailyAdTask()
+        if (dailyWatchAdTask != null && dailyWatchAdTask.status == "active"
+            && dailyWatchAdTask.reward_details.isNotEmpty()) {
+
+            dailyWatchAdTask.reward_details.forEachIndexed { index, detail ->
+                val watchTaskItemView = DailyTaskItemView(requireActivity())
+                watchTaskItemView.setActionFun {
+                    handleDailyAdButClicked(index)
+                }
+                mDailyWatchAdViewList.add(watchTaskItemView)
+
+                binding?.dailyTasksContainer!!.run {
+                    watchTaskItemView.initUI(R.mipmap.icon_ad, R.string.daily_ad_task_title,
+                        detail.target_count, detail.value)
+
+                    addView(watchTaskItemView, LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.WRAP_CONTENT)
+                    if (true) {
+                        val separateLine = View(requireActivity())
+                        separateLine.setBackgroundResource(R.color.gray_f2)
+                        addView(separateLine, LinearLayout.LayoutParams.MATCH_PARENT, ResUtil.getPixelSize(R.dimen.dp1))
+                    }
+                }
+            }
+        }
+
+        //2. 阶梯视频
+        val dailyWatchVideoTask = TaskManager.instance().getDailyVideoTask()
+        if (dailyWatchVideoTask != null && dailyWatchVideoTask.status == "active"
+            && dailyWatchVideoTask.reward_details.isNotEmpty()) {
+
+            dailyWatchVideoTask.reward_details.forEachIndexed {index, detail ->
+                val watchTaskItemView = DailyTaskItemView(requireActivity())
+                watchTaskItemView.setActionFun {
+                    handleDailyVideoButClicked(index)
+                }
+                mDailyWatchVideoViewList.add(watchTaskItemView)
+
+                binding?.dailyTasksContainer!!.run {
+                    watchTaskItemView.initUI(R.mipmap.icon_video_task, R.string.daily_video_task_title,
+                        detail.target_count, detail.value)
+
+                    addView(watchTaskItemView, LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.WRAP_CONTENT)
+                    if (index != dailyWatchVideoTask.reward_details.size - 1) {
+                        val separateLine = View(requireActivity())
+                        separateLine.setBackgroundResource(R.color.gray_f2)
+                        addView(separateLine, LinearLayout.LayoutParams.MATCH_PARENT, ResUtil.getPixelSize(R.dimen.dp1))
+                    }
+                }
+            }
+        }
+    }
+
    private fun updateUICashTotal() {
        binding?.tvCashTotal?.text = buildString {
            append(ResUtil.getString(R.string.cash))
@ -150,6 +200,22 @@ class TasksFragment : AppViewsFragment<ViewBinding, UiState, ViewModel>(), OnTab
        }
    }

+    private fun updateDailyWatchVideoUI() {
+        val statusBean = TaskManager.instance().dailyWatchVideoStatus().getStatusBean()
+        val subTaskStatusList = statusBean.getSubTaskRewardState()
+        mDailyWatchVideoViewList.forEachIndexed { index, view ->
+            view.updateProgress(statusBean.getTodayWatchedCount(), subTaskStatusList[index].state)
+        }
+    }
+
+    private fun updateDailyWatchAdUI() {
+        val statusBean = TaskManager.instance().dailyWatchAdStatus().getStatusBean()
+        val subTaskStatusList = statusBean.getSubTaskRewardState()
+        mDailyWatchAdViewList.forEachIndexed { index, view ->
+            view.updateProgress(statusBean.getTodayWatchedCount(), subTaskStatusList[index].state)
+        }
+    }
+
    private fun updateUIGoldTotal() {
        binding?.tvGoldTotal?.text = AccountManager.getGold().toString()
    }
@ -168,12 +234,49 @@ class TasksFragment : AppViewsFragment<ViewBinding, UiState, ViewModel>(), OnTab
                VididinEvents.Event_Account_Cash_Changed -> {
                    updateUICashTotal()
                }
+
+                VididinEvents.EVENT_DAILY_WATCHED_VIDEO_NUM_CHANGED -> {
+                    updateDailyWatchVideoUI()
+                }
+
+                VididinEvents.EVENT_DAILY_WATCHED_AD_NUM_CHANGED -> {
+                    updateDailyWatchAdUI()
+                }
+
+                VididinEvents.EVENT_JUMP_2_FIRST_WITHDRAW -> {
+                    binding?.newbieContainer?.postDelayed(object : Runnable {
+                        override fun run() {
+                            scroll2FirstWithdraw()
+                        }
+                    },1000)
+                }
+
+                VididinEvents.EVENT_NEWBIE_DISCORD_TASK_CHANGED -> {
+                    updateNewBieDiscordUI()
+                }
+
+                VididinEvents.EVENT_NEWBIE_NOTIFY_TASK_CHANGED -> {
+                    updateNewBieNotifyUI()
+                }
+
+                VididinEvents.EVENT_NEWBIE_FIRST_WITHDRAW_TASK_CHANGED -> {
+                    updateNewBieFirstWithdrawUI()
+                }
+
            }
-        }, VididinEvents.Event_Sign_State_Changed, VididinEvents.Event_Account_Cash_Changed, VididinEvents.Event_Account_Gold_Changed)
+        }, VididinEvents.Event_Sign_State_Changed, VididinEvents.Event_Account_Cash_Changed,
+            VididinEvents.Event_Account_Gold_Changed, VididinEvents.EVENT_DAILY_WATCHED_VIDEO_NUM_CHANGED,
+            VididinEvents.EVENT_DAILY_WATCHED_AD_NUM_CHANGED, VididinEvents.EVENT_JUMP_2_FIRST_WITHDRAW,
+            VididinEvents.EVENT_NEWBIE_DISCORD_TASK_CHANGED, VididinEvents.EVENT_NEWBIE_NOTIFY_TASK_CHANGED,
+            VididinEvents.EVENT_NEWBIE_FIRST_WITHDRAW_TASK_CHANGED,)
+    }
+
+    private fun scroll2FirstWithdraw() {
+        binding?.newbieContainer?.let { binding?.scrollView?.scroll2ChildView(it) }
    }

    private fun updateDailySignButUI() {
-        val hasFinishAllSignWork = TaskManager.instance().isDailySignAllOperationDone()
+        val hasFinishAllSignWork = TaskManager.instance().dailySignStatus().isDailySignAllOperationDone()

        binding?.ivGotoDailySign?.apply {
            setText(
@ -187,6 +290,58 @@ class TasksFragment : AppViewsFragment<ViewBinding, UiState, ViewModel>(), OnTab
        }
    }

+    private fun updateNewBieFirstWithdrawUI() {
+        with(binding?.beginnerTaskWithdraw!!) {
+            setActionFun {
+                gotoWithDraw()
+            }
+            val stateBean = TaskManager.instance().newbieFirstWithdrawStatus().getStatusBean()
+            setTaskStateInfo(
+                stateBean.rewardGoldNum.toString(),
+                if (stateBean.hasClaimReward) R.string.finished else R.string.go_and_do,
+                ResUtil.getString(R.string.beginner_withdraw_desc),
+                stateBean.hasClaimReward
+            )
+        }
+    }
+
+    private fun updateNewBieDiscordUI() {
+        with(binding?.beginnerTaskDiscord!!) {
+            setActionFun {
+                gotoDiscord()
+            }
+            val stateBean = TaskManager.instance().newbieJoinDiscordStatus().getStatusBean()
+            setTaskStateInfo(
+                stateBean.rewardGoldNum.toString(),
+                if (stateBean.hasClaimReward) R.string.finished else R.string.go_and_do,
+                String.format(ResUtil.getString(R.string.beginner_discord_desc), stateBean.rewardGoldNum),
+                stateBean.hasClaimReward
+            )
+        }
+    }
+
+    private fun updateNewBieNotifyUI() {
+        with(binding?.beginnerTaskEnableNotify!!) {
+            val isNotifyEnable = AndroidUtil.isNotificationEnabled()
+            val stateBean = TaskManager.instance().newbieEnableNotifyStatus().getStatusBean()
+            setActionFun {
+                if (!isNotifyEnable) {
+                    gotoNotification()
+                } else {
+                    if (TaskManager.instance().newbieEnableNotifyStatus().claimReward()) {
+                        DailySignSuccessDialog(requireActivity()).initData(stateBean.rewardGoldNum, false).show()
+                    }
+                }
+            }
+
+            val actionButRes = if (stateBean.hasClaimReward) R.string.Resgatado else (if (isNotifyEnable) R.string.resgatar else R.string.go_and_do)
+            setTaskStateInfo(stateBean.rewardGoldNum.toString(), actionButRes,
+                String.format(ResUtil.getString(R.string.beginner_notify_desc), stateBean.rewardGoldNum), stateBean.hasClaimReward)
+        }
+    }
+
+
+
    override fun ViewBinding.initObservers() {
    }

@ -211,15 +366,59 @@ class TasksFragment : AppViewsFragment<ViewBinding, UiState, ViewModel>(), OnTab
    }

    private fun gotoDiscord() {
-        //TODO("Not yet implemented")
+        AndroidUtil.openUrl(VidiConst.URL_DISCORD)
    }

    private fun gotoNotification() {
-        //TODO("Not yet implemented")
+        PermissionUtil.checkPermission(Manifest.permission.POST_NOTIFICATIONS, object : PermissionUtil.ICallback() {
+            override fun onAllGranted() {
+                AndroidUtil.openAppNotifySettings()
+            }
+
+            override fun onPartialGranted() {
+            }
+
+            override fun onAllRejected() {
+            }
+        })
    }

-    private fun gotoWithVideo() {
-        //TODO("Not yet implemented")
+
+    private fun handleDailyVideoButClicked(itemIndex: Int) {
+        val subTaskList = TaskManager.instance().dailyWatchVideoStatus().getStatusBean().getSubTaskRewardState()
+        if (itemIndex >= 0 && itemIndex < subTaskList.size) {
+            val subTaskState = subTaskList[itemIndex]
+            when (subTaskState.state) {
+                STATE_ONGOING -> {
+                    val activity = requireActivity()
+                    if (activity is MainActivity) {
+                        activity.switchTab(0)
+                    }
+                }
+                STATE_FINISH -> {
+                    if (TaskManager.instance().dailyWatchVideoStatus().claimSubTaskReward(itemIndex)) {
+                        DailySignSuccessDialog(requireActivity()).initData(subTaskState.mRewardNum, false).show()
+                    }
+                }
+            }
+        }
+    }
+
+    private fun handleDailyAdButClicked(itemIndex: Int) {
+        val subTaskList = TaskManager.instance().dailyWatchAdStatus().getStatusBean().getSubTaskRewardState()
+        if (itemIndex >= 0 && itemIndex < subTaskList.size) {
+            val subTaskState = subTaskList[itemIndex]
+            when (subTaskState.state) {
+                STATE_ONGOING -> {
+                    WatchAdDialog(requireActivity(), VididinEvents.Event_AD_TASK_TYPE_Watch_Ad_Daily, null).show()
+                }
+                STATE_FINISH -> {
+                    if (TaskManager.instance().dailyWatchAdStatus().claimSubTaskReward(itemIndex)) {
+                        DailySignSuccessDialog(requireActivity()).initData(subTaskState.mRewardNum, false).show()
+                    }
+                }
+            }
+        }
    }


--- a/app/src/main/java/com/gamedog/vididin/main/fragments/home/DefaultYoutubeDatasource.kt
+++ b/app/src/main/java/com/gamedog/vididin/main/fragments/home/DefaultYoutubeDatasource.kt
@ -17,6 +17,6 @@ class DefaultYoutubeDatasource @Inject constructor(retrofit: Retrofit) : Youtube
    override suspend fun getChannels(
    ) = shopApi.getChannelList()

-    override suspend fun getVideoList(pageToken: String?) = shopApi.getVideoList(pageToken = pageToken)
+    override suspend fun getVideoList(lastVideoId: String?) = shopApi.getVideoList(video = lastVideoId)

 }
--- a/app/src/main/java/com/gamedog/vididin/main/fragments/home/DefaultYoutubeRepository.kt
+++ b/app/src/main/java/com/gamedog/vididin/main/fragments/home/DefaultYoutubeRepository.kt
@ -20,7 +20,7 @@ class DefaultYoutubeRepository @Inject constructor(
        page: Int,
        size: Int
    ): ResYoutubePlayList {
-        return network.getVideoList(mRespPlayList?.nextPageToken)
+        return network.getVideoList(mRespPlayList?.videos?.last()?.id)
    }

    override suspend fun getChannelList(
@ -35,7 +35,7 @@ class DefaultYoutubeRepository @Inject constructor(
        pageSize: Int
    ): List<YoutubeVideo>? {
        mRespPlayList = getVideoList(key, pageSize)
-        return mRespPlayList?.items
+        return mRespPlayList?.videos
    }


--- a/app/src/main/java/com/gamedog/vididin/main/fragments/home/fragment/HomeItemFragment.kt
+++ b/app/src/main/java/com/gamedog/vididin/main/fragments/home/fragment/HomeItemFragment.kt
@ -1,7 +1,9 @@
 package com.gamedog.vididin.main.fragments.home.fragment


+import android.graphics.Bitmap
 import android.os.Bundle
+import android.view.Gravity
 import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
@ -9,15 +11,21 @@ import android.view.animation.AlphaAnimation
 import android.view.animation.Animation
 import android.view.animation.AnimationSet
 import android.view.animation.ScaleAnimation
+import android.widget.FrameLayout
 import androidx.annotation.NonNull
 import androidx.core.view.isVisible
 import com.ama.core.architecture.appBase.AppViewsEmptyViewModelFragment
+import com.ama.core.architecture.util.AndroidUtil
+import com.ama.core.architecture.util.setOnClickBatch
 import com.ama.core.common.widget.PopMenuIconView
 import com.gamedog.vididin.R
+import com.gamedog.vididin.VidiConst
+import com.gamedog.vididin.VididinEvents
 import com.gamedog.vididin.beans.YoutubeVideo
-import com.gamedog.vididin.main.WatchVideoDialog
+import com.gamedog.vididin.main.WatchAdDialog
 import com.gamedog.vididin.router.Router
 import com.gamedog.vididin.widget.MyPlayerControlView
+import com.gamedog.vididin.youtubestatistic.TickerTimer
 import com.pierfrancescosoffritti.androidyoutubeplayer.core.player.PlayerConstants
 import com.pierfrancescosoffritti.androidyoutubeplayer.core.player.YouTubePlayer
 import com.pierfrancescosoffritti.androidyoutubeplayer.core.player.listeners.AbstractYouTubePlayerListener
@ -27,13 +35,15 @@ import com.gamedog.vididin.databinding.VididinappFeatureHomeItemLayoutBinding as


 class HomeItemFragment : AppViewsEmptyViewModelFragment<ViewBinding>() {
+    private var mMaskBitmap: Bitmap? = null
    private var mPlayerView: YouTubePlayerView? = null
-    private var mIsStared = false
    private var mPlayer: YouTubePlayer? = null
    private var mVideoData: YoutubeVideo? = null
    private var mIsPlaying: Boolean = false
+    private var mIsIntroExpand: Boolean = false
    private var mCurPlayedSecond: Float = 0F
-    private var mTotalDuration: Float = -1F
+    private var mTotalDuration: Float = 0F
+    private val mTickerTimer = TickerTimer()


    override fun inflateViewBinding(
@ -43,16 +53,14 @@ class HomeItemFragment : AppViewsEmptyViewModelFragment<ViewBinding>() {


    override fun ViewBinding.initViews() {
-        maskView.setOnClickListener {
-            if (mIsPlaying) mPlayer?.pause() else mPlayer?.play()
-        }
-
        playIcon.setOnClickListener {
            if (mIsPlaying) mPlayer?.pause() else mPlayer?.play()
        }

-        tvVideoFrom.text = mVideoData?.snippet?.localized?.title
-        tvVideoIntro.text = mVideoData?.snippet?.localized?.description
+        tvVideoFrom.text = mVideoData?.channel_title
+        tvVideoIntro.text = mVideoData?.description
+        ivIntroExpand.isVisible = tvVideoIntro.lineCount > 2
+

        popMenu.setMenuList(
            mutableListOf(
@ -60,23 +68,34 @@ class HomeItemFragment : AppViewsEmptyViewModelFragment<ViewBinding>() {
                    Router.Benefit.startActivity(requireActivity())
                },
                PopMenuIconView.MenuItem(R.mipmap.home_menu_2) {
-                    WatchVideoDialog(requireContext()).show()
+                    WatchAdDialog(requireActivity(), VididinEvents.Event_AD_TASK_TYPE_Watch_Ad_Earn_Gold, null).show()
                },
                PopMenuIconView.MenuItem(R.mipmap.home_menu_3) {
-
+                    AndroidUtil.openUrl(VidiConst.URL_GAME)
                },
                PopMenuIconView.MenuItem(R.mipmap.home_menu_4) {
                    Router.Benefit.startActivity(requireActivity())
                }
            ))
+
+        setOnClickBatch(ivIntroExpand, clickMaskView) {
+            when (this) {
+                clickMaskView ->  {
+                    if (mIsPlaying) mPlayer?.pause() else mPlayer?.play()
+                }
+
+                ivIntroExpand ->  {
+                    mIsIntroExpand = !mIsIntroExpand
+                    tvVideoIntro.maxLines = if (mIsIntroExpand) 8 else 2
+                    ivIntroExpand.setImageResource(if (mIsIntroExpand) R.mipmap.arrow_down else R.mipmap.arrow_up)
+                }
+            }
+        }
    }


    override fun ViewBinding.initListeners() {
-        ivStar.setOnClickListener {
-            mIsStared = !mIsStared
-            ivStar.setImageResource(if (mIsStared) R.mipmap.home_star else R.mipmap.home_star_undo)
-        }
+

    }

@ -84,13 +103,35 @@ class HomeItemFragment : AppViewsEmptyViewModelFragment<ViewBinding>() {

    }

+    override fun onDestroy() {
+        super.onDestroy()
+        mMaskBitmap?.recycle()
+    }
+
+    private fun playVideo() {
+        if (mPlayer != null && mVideoData != null && !mVideoData?.id.isNullOrEmpty()) {
+            mPlayer?.loadOrCueVideo(
+                lifecycle,
+                mVideoData!!.id,
+                0f
+            )
+
+            /*mPlayerView?.isVisible?.let {
+                if (!it) {
+                    mPlayer?.pause()
+                }
+            }*/
+        }
+    }



    fun loadVideo() {
        if (null == mPlayerView) {
            mPlayerView = YouTubePlayerView(requireContext())
-            binding!!.playerContainer.addView(mPlayerView, ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT)
+            val layoutParam = FrameLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT)
+            layoutParam.gravity = Gravity.CENTER
+            binding!!.playerContainer.addView(mPlayerView, layoutParam)
            lifecycle.addObserver(mPlayerView!!)
            mPlayerView?.enableAutomaticInitialization = true
        }
@ -104,17 +145,7 @@ class HomeItemFragment : AppViewsEmptyViewModelFragment<ViewBinding>() {
                val playerUiController = MyPlayerControlView(playerView, youTubePlayer)
                playerView.setCustomPlayerUi(playerUiController.rootView)

-                if (mVideoData != null && !mVideoData?.id.isNullOrEmpty()) {
-                    youTubePlayer.loadOrCueVideo(
-                        lifecycle,
-                        mVideoData!!.id,
-                        0f
-                    )
-
-                    if (!playerView.isVisible) {
-                        youTubePlayer.pause()
-                    }
-                }
+                playVideo()
            }

            override fun onCurrentSecond(youTubePlayer: YouTubePlayer, second: Float) {
@ -126,6 +157,7 @@ class HomeItemFragment : AppViewsEmptyViewModelFragment<ViewBinding>() {
            override fun onVideoDuration(youTubePlayer: YouTubePlayer, duration: Float) {
                super.onVideoDuration(youTubePlayer, duration)
                mTotalDuration = duration
+                mTickerTimer.setVideoInfo(mVideoData!!.id, (1000L * mTotalDuration).toLong())
            }

            override fun onStateChange(
@ -147,9 +179,11 @@ class HomeItemFragment : AppViewsEmptyViewModelFragment<ViewBinding>() {
                    }
                    PlayerConstants.PlayerState.ENDED  -> {
                        togglePlayingState(false)
+                        playVideo()
                    }
                    PlayerConstants.PlayerState.BUFFERING  -> {
-                        togglePlayingState(false)
+                        binding?.circlePb?.isVisible = true
+                        //showLoading(true)
                    }
                    PlayerConstants.PlayerState.VIDEO_CUED  -> {
                        togglePlayingState(false)
@ -159,14 +193,38 @@ class HomeItemFragment : AppViewsEmptyViewModelFragment<ViewBinding>() {
        })
    }

+
+    private fun generateThumbAndSet() {
+        // capturePlayerView And Show as thumb
+        mPlayerView?.let {
+            mMaskBitmap?.recycle()
+
+            mMaskBitmap = AndroidUtil.getThumbOfView(it)
+            mMaskBitmap?.let {
+                binding?.ivMask?.setImageBitmap(mMaskBitmap)
+            }
+        }
+    }
+
    private fun togglePlayingState(isPlaying: Boolean) {
        if (mIsPlaying != isPlaying) {
            mIsPlaying = isPlaying
+            if (!mIsPlaying) {
+                generateThumbAndSet()
+            } else {
+                binding?.circlePb?.isVisible = false
+            }
+
+            binding?.ivMask?.isVisible = !mIsPlaying
+            binding?.playerContainer?.isVisible = mIsPlaying
+
            if (mIsPlaying) {
                hidePlayIconAnim()
            } else {
                showPlayIconAnim()
            }
+
+            if (mIsPlaying) mTickerTimer.start() else mTickerTimer.pause()
        }
    }

--- a/app/src/main/java/com/gamedog/vididin/main/fragments/task/DailySignDialog.kt
+++ b/app/src/main/java/com/gamedog/vididin/main/fragments/task/DailySignDialog.kt
@ -1,6 +1,6 @@
 package com.gamedog.vididin.main.fragments.task

-import android.content.Context
+import android.app.Activity
 import androidx.core.view.isVisible
 import com.ama.core.architecture.util.setOnClickBatch
 import com.ama.core.architecture.widget.BindingDialog
@ -9,7 +9,7 @@ import com.gamedog.vididin.manager.TaskManager
 import com.gamedog.vididin.widget.DailySignItemView


-class DailySignDialog(context: Context) : BindingDialog<DialogDailySignBinding>(context, DialogDailySignBinding::inflate) {
+class DailySignDialog(context: Activity) : BindingDialog<DialogDailySignBinding>(context, DialogDailySignBinding::inflate) {
    private var mCurDayIndex: Int = 0
    private var mConfigList: List<RewardDetail>? = emptyList()
    private var mSignItemViewList: MutableList<DailySignItemView> = mutableListOf()
@ -56,16 +56,16 @@ class DailySignDialog(context: Context) : BindingDialog<DialogDailySignBinding>(
    }

    private fun clickedNormalSign() {
-        if (TaskManager.instance().executeDailySign(mCurDayIndex, false, false)) {
-            DailySignSuccessDialog(context).initData(mConfigList?.get(mCurDayIndex)?.value, true).show()
+        if (TaskManager.instance().dailySignStatus().executeDailySign(mCurDayIndex, false, false)) {
+            DailySignSuccessDialog(mActivity).initData(mConfigList?.get(mCurDayIndex)?.value, true).show()
            updateUI(mCurDayIndex)
        }
    }

    private fun clickedAdSingleBut() {
        startAdTask("signalAd", {
-            if (TaskManager.instance().executeDailySign(mCurDayIndex, false, true)) {
-                DailySignSuccessDialog(context).initData(mConfigList?.get(mCurDayIndex)?.value, false).show()
+            if (TaskManager.instance().dailySignStatus().executeDailySign(mCurDayIndex, false, true)) {
+                DailySignSuccessDialog(mActivity).initData(mConfigList?.get(mCurDayIndex)?.value, false).show()
                updateUI(mCurDayIndex)
            }
        })
@ -73,8 +73,8 @@ class DailySignDialog(context: Context) : BindingDialog<DialogDailySignBinding>(

    private fun clickedAdDoubleBut() {
        startAdTask("doubleAd", {
-            if (TaskManager.instance().executeDailySign(mCurDayIndex, true, true)) {
-                DailySignSuccessDialog(context).initData((mConfigList?.get(mCurDayIndex)?.value)?.times(
+            if (TaskManager.instance().dailySignStatus().executeDailySign(mCurDayIndex, true, true)) {
+                DailySignSuccessDialog(mActivity).initData((mConfigList?.get(mCurDayIndex)?.value)?.times(
                    2
                ), false).show()
                updateUI(mCurDayIndex)
@ -83,11 +83,11 @@ class DailySignDialog(context: Context) : BindingDialog<DialogDailySignBinding>(
    }

    private fun clickedComplementSign() {
-        val firstForgotSignDayIndex = TaskManager.instance().getForgotSignFirstDayIndex()
+        val firstForgotSignDayIndex = TaskManager.instance().dailySignStatus().getForgotSignFirstDayIndex()
        if (firstForgotSignDayIndex > 0) {
            startAdTask("complementAd", {
-                if (TaskManager.instance().executeDailySign(firstForgotSignDayIndex, false, false)){
-                    DailySignSuccessDialog(context).initData(mConfigList?.get(firstForgotSignDayIndex)?.value, false).show()
+                if (TaskManager.instance().dailySignStatus().executeDailySign(firstForgotSignDayIndex, false, false)){
+                    DailySignSuccessDialog(mActivity).initData(mConfigList?.get(firstForgotSignDayIndex)?.value, false).show()
                    updateUI(firstForgotSignDayIndex)
                }
            })
@ -120,14 +120,14 @@ class DailySignDialog(context: Context) : BindingDialog<DialogDailySignBinding>(
            mConfigList?.let {
                mSignItemViewList.forEachIndexed { index, itemView->
                    itemView.setData(mConfigList!![index],
-                        TaskManager.instance().getDailySignStateBean(index))
+                        TaskManager.instance().dailySignStatus().getDailySignStateBean(index))
                }
            }
        }
    }

    private fun initSignState() {
-        mCurDayIndex = TaskManager.instance().getCurDayIndexOfDailyCheckIn()
+        mCurDayIndex = TaskManager.instance().dailySignStatus().getCurDayIndexOfDailyCheckIn()
        mSignItemViewList[mCurDayIndex].setSelectState(true)
        updateUI(mCurDayIndex)
    }
@ -140,7 +140,7 @@ class DailySignDialog(context: Context) : BindingDialog<DialogDailySignBinding>(


        mBinding.tvSignedTotal.text = buildString {
-            append(TaskManager.instance().getSignDaysTotal())
+            append(TaskManager.instance().dailySignStatus().getSignDaysTotal())
            append("/7")
        }
        mSignItemViewList[signedDayIndex].updateUI()
@ -162,7 +162,7 @@ class DailySignDialog(context: Context) : BindingDialog<DialogDailySignBinding>(
                    mConfigList?.get(mCurDayIndex)?.value
                }
            } else {
-                val forgotSignDays = TaskManager.instance().getForgotSignDays()
+                val forgotSignDays = TaskManager.instance().dailySignStatus().getForgotSignDays()
                if (forgotSignDays > 0) {
                    mBinding.actionNormalTwoButs.isVisible = false
                    mBinding.actionWatchAd.isVisible = false
--- a/app/src/main/java/com/gamedog/vididin/main/fragments/task/DailySignSuccessDialog.kt
+++ b/app/src/main/java/com/gamedog/vididin/main/fragments/task/DailySignSuccessDialog.kt
@ -1,13 +1,13 @@
 package com.gamedog.vididin.main.fragments.task

-import android.content.Context
+import android.app.Activity
 import androidx.core.view.isVisible
 import com.ama.core.architecture.util.setOnClickBatch
 import com.ama.core.architecture.widget.BindingDialog
 import com.gamedog.vididin.databinding.DialogDailySignSuccessBinding as ViewBinding


-class DailySignSuccessDialog(context: Context) : BindingDialog<ViewBinding>(context, ViewBinding::inflate) {
+class DailySignSuccessDialog(activity: Activity) : BindingDialog<ViewBinding>(activity, ViewBinding::inflate) {

    init {
        build()
--- a/app/src/main/java/com/gamedog/vididin/main/fragments/task/TaskConfigRoot.kt
+++ b/app/src/main/java/com/gamedog/vididin/main/fragments/task/TaskConfigRoot.kt
@ -6,7 +6,8 @@ data class TaskBean(

 data class TaskModuleConfig(
    val basic_info: BasicInfo,
-    val task_categories: List<TaskCategory>
+    val task_categories: List<TaskCategory>,
+    val box_task: BoxTaskRoot
 ) {
    fun getTaskCategoryById(categoryId: String): TaskCategory? {
        return task_categories.find { it.category_id == categoryId }
@ -54,3 +55,32 @@ data class RewardDetail(
    val target_count: Int,
    val value: Int
 )
+
+
+
+//----------------------------- 宝箱任务配置 -----------------------------
+data class BoxSubTask(
+    val task_id: String,
+    val task_name: String,
+    val required_count: Int,
+    val task_type: Int,
+)
+
+data class BoxTask(
+    val chest_id: String,
+    val chest_name: String,
+    val duration_days: Int,
+    val reward_type: String,
+    val reward_value: Float,
+    val is_one_time: Boolean,
+    val status: String,
+    val tasks: List<BoxSubTask>,
+)
+
+data class BoxTaskRoot(
+    val category_id: String,
+    val category_name: String,
+    val valid_period: String,
+    val display_priority: String,
+    val chests: List<BoxTask>,
+)
--- a/app/src/main/java/com/gamedog/vididin/main/fragments/task/WeekStatusView.kt
+++ b/app/src/main/java/com/gamedog/vididin/main/fragments/task/WeekStatusView.kt
@ -114,7 +114,7 @@ class WeekStatusView @JvmOverloads constructor(
    override fun onDraw(canvas: Canvas) {
        super.onDraw(canvas)

-        val dayStateList = TaskManager.instance().getDayStateList()
+        val dayStateList = TaskManager.instance().dailySignStatus().getDayStateList()
        if (dayStateList.isEmpty()) return

        val totalWidth = measuredWidth.toFloat()
@ -140,7 +140,7 @@ class WeekStatusView @JvmOverloads constructor(

            // reward text
            textPaint.textSize = rewardTextSize
-            val rewardNum = TaskManager.instance().getRewardNumOfDailySign(index)
+            val rewardNum = TaskManager.instance().dailySignStatus().getRewardNumOfDailySign(index)
            textPaint.color = if (dayStatus.hasSigned) rewardTextSignedColor else rewardTextColor
            canvas.drawText(rewardNum.toString(), centerX, vertiMagin + dayTextSize + componentGap + 2*circleRadius + componentGap, textPaint)
        }
--- a/app/src/main/java/com/gamedog/vididin/main/fragments/task/widget/BeginnerTaskItemView.kt
+++ b/app/src/main/java/com/gamedog/vididin/main/fragments/task/widget/BeginnerTaskItemView.kt
@ -5,7 +5,10 @@ import android.util.AttributeSet
 import android.view.LayoutInflater
 import android.widget.LinearLayout
 import com.ama.core.architecture.util.setOnClickBatch
+import com.gamedog.vididin.R
+import com.gamedog.vididin.VidiConst
 import com.gamedog.vididin.databinding.BeginnerTaskItemViewBinding
+import com.gamedog.vididin.main.fragments.task.Task


 class BeginnerTaskItemView @JvmOverloads constructor(
@ -31,20 +34,17 @@ class BeginnerTaskItemView @JvmOverloads constructor(
    }


-    fun initUI(titleIconRes: Int, titleRes: Int, desRes: Int, actionRes: Int) {
+    fun initUI(titleIconRes: Int, titleRes: Int, actionRes: Int) {
        mBinding.ivItemIcon.setImageResource(titleIconRes)
        mBinding.tvItemTitle.setText(titleRes)
        mBinding.tvAction.setText(actionRes)
-        mBinding.tvItemDescrible.setText(desRes)
    }


-    fun setRewardNum(rewardNum: String) {
-        mBinding.tvRewardNum.text = rewardNum
-    }
-
-    fun setRewardIcon(iconRes: Int) {
-        mBinding.ivRewardIcon.setImageResource(iconRes)
+    fun setRewardInfo(taskReward: Task) {
+        val isRewardGold = VidiConst.GOLD_IN_CONFIG == taskReward.reward_type;
+        mBinding.ivRewardIcon.setImageResource(if (isRewardGold) R.mipmap.icon_glod_small else R.mipmap.icon_cash_s)
+        mBinding.tvRewardNum.text = taskReward.reward_value.toString()
    }


@ -57,5 +57,20 @@ class BeginnerTaskItemView @JvmOverloads constructor(
        mBinding.tvRewardNum.setTextColor(color)
    }

+    fun setTaskStateInfo(
+        rewardNum: String,
+        textRes: Int,
+        describleStr: String,
+        hasClaimReward: Boolean
+    ) {
+        mBinding.tvRewardNum.text = rewardNum
+        mBinding.tvAction.setText(textRes)
+        mBinding.tvItemDescrible.text = describleStr
+        mBinding.tvAction.isClickable = !hasClaimReward
+        if (hasClaimReward) {
+            mBinding.tvAction.setBackgroundResource(R.drawable.bg_sub_task_disable)
+        }
+    }
+

 }
--- a/app/src/main/java/com/gamedog/vididin/main/fragments/task/widget/DailyTaskItemView.kt
+++ b/app/src/main/java/com/gamedog/vididin/main/fragments/task/widget/DailyTaskItemView.kt
@ -6,7 +6,11 @@ import android.view.LayoutInflater
 import android.widget.LinearLayout
 import com.ama.core.architecture.util.ResUtil
 import com.ama.core.architecture.util.setOnClickBatch
+import com.gamedog.vididin.R
 import com.gamedog.vididin.databinding.DailyTaskItemViewBinding
+import com.gamedog.vididin.manager.taskbeans.BaseTaskState.Companion.STATE_CLAIMED
+import com.gamedog.vididin.manager.taskbeans.BaseTaskState.Companion.STATE_FINISH
+import com.gamedog.vididin.manager.taskbeans.BaseTaskState.Companion.STATE_ONGOING


 class DailyTaskItemView @JvmOverloads constructor(
@ -14,8 +18,10 @@ class DailyTaskItemView @JvmOverloads constructor(
    attrs: AttributeSet? = null,
    defStyleAttr: Int = 0
 ) : LinearLayout(context, attrs, defStyleAttr) {
+    private var mRewardNum: Int = 0
+    private var mNeedWatchTotal: Int = 0
    private lateinit var mAction: () -> Unit
-    private lateinit var mBinding: DailyTaskItemViewBinding
+    private var mBinding: DailyTaskItemViewBinding


    init {
@ -33,20 +39,49 @@ class DailyTaskItemView @JvmOverloads constructor(



-    fun initUI(titleIconRes: Int, titleRes: Int, videosNum: Int, actionRes: Int) {
+    fun initUI(titleIconRes: Int, titleRes: Int, videosNum: Int, goldReward: Int) {
+        mRewardNum = goldReward
+        mNeedWatchTotal = videosNum
+
        mBinding.ivItemIcon.setImageResource(titleIconRes)
        mBinding.tvItemTitle.text = String.format(ResUtil.getString(titleRes), videosNum)
-        mBinding.tvAction.setText(actionRes)
+        mBinding.tvRewardNum.text = "+$goldReward"
+        mBinding.tvItemProgress.text = "(0/$videosNum)"
    }

-    fun setProgressText(progress: Int, progressText: String) {
-        mBinding.tvItemProgress.text = progressText
-        mBinding.itemProgress.setProgress(progress)
+    fun updateProgress(watchedCount: Int, subTaskState: Int) {
+        doUpdateProgress(watchedCount)
+
+        with(mBinding.tvAction) {
+            when(subTaskState) {
+                STATE_ONGOING -> {
+                    setText(R.string.go_and_do)
+                    setBackgroundResource(R.drawable.bg_sub_task_normal)
+                    isClickable = true
+                    alpha = 1F
+                }
+
+                STATE_FINISH -> {
+                    setText(R.string.resgatar)
+                    setBackgroundResource(R.drawable.bg_sub_task_normal)
+                    isClickable = true
+                    alpha = 1F
+                }
+
+                STATE_CLAIMED -> {
+                    setText(R.string.Resgatado)
+                    setBackgroundResource(R.drawable.bg_sub_task_disable)
+                    isClickable = false
+                    alpha = 0.4F
+                }
+            }
+        }
    }

-    fun setRewardInfo(rewardIconRes: Int, rewardNum: Int) {
-        mBinding.tvRewardNum.text = "" + rewardNum
-        mBinding.ivRewardIcon.setImageResource(rewardIconRes)
+    private fun doUpdateProgress(finishNum: Int) {
+        val properShowNumForCurSubTask = if (finishNum > mNeedWatchTotal) mNeedWatchTotal else finishNum
+        mBinding.tvItemProgress.text = "($properShowNumForCurSubTask/$mNeedWatchTotal)"
+        mBinding.itemProgress.setProgress(100*properShowNumForCurSubTask/mNeedWatchTotal)
    }

    fun setActionFun(action: ()->Unit) {
--- a/app/src/main/java/com/gamedog/vididin/manager/DateChangeReceiver.kt
+++ b/app/src/main/java/com/gamedog/vididin/manager/DateChangeReceiver.kt
@ -0,0 +1,13 @@
+package com.gamedog.vididin.manager
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+
+class DateChangeReceiver : BroadcastReceiver() {
+    override fun onReceive(context: Context, intent: Intent) {
+        if (intent.action == Intent.ACTION_DATE_CHANGED) {
+            TaskManager.instance().onDateChanged()
+        }
+    }
+}
--- a/app/src/main/java/com/gamedog/vididin/manager/TaskManager.kt
+++ b/app/src/main/java/com/gamedog/vididin/manager/TaskManager.kt
@ -1,13 +1,21 @@
 package com.gamedog.vididin.manager

-import com.ama.core.architecture.util.DateUtil
+
 import com.ama.core.architecture.util.FileUtil
-import com.ama.core.architecture.util.SpUtil
 import com.ama.core.architecture.util.eventbus.NotifyMan
+import com.gamedog.vididin.VidiConst
 import com.gamedog.vididin.VididinEvents
 import com.gamedog.vididin.core.login.login.AccountManager
+import com.gamedog.vididin.main.fragments.task.BoxTaskRoot
 import com.gamedog.vididin.main.fragments.task.Task
 import com.gamedog.vididin.main.fragments.task.TaskBean
+import com.gamedog.vididin.manager.helpers.BoxTaskHelper
+import com.gamedog.vididin.manager.helpers.DailySignTaskHelper
+import com.gamedog.vididin.manager.helpers.DailyWatchAdTaskHelper
+import com.gamedog.vididin.manager.helpers.DailyWatchVideoTaskHelper
+import com.gamedog.vididin.manager.helpers.NewbieEnableNotifyHelper
+import com.gamedog.vididin.manager.helpers.NewbieFirstWithdrawHelper
+import com.gamedog.vididin.manager.helpers.NewbieJoinDiscordHelper
 import com.google.gson.GsonBuilder
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
@ -31,6 +39,24 @@ class TaskManager private constructor() {



+
+
+        // 宝箱子任务类型对应
+        const val BOX_SUB_TASK_TYPE_AD = 1
+        const val BOX_SUB_TASK_TYPE_VIDEO = 2
+        const val BOX_SUB_TASK_TYPE_SIGN = 3
+        const val BOX_SUB_TASK_TYPE_ZERO_BUY = 4
+
+
+
+
+
+
+
+
+
+
+
        @Volatile
        private var instance: TaskManager? = null

@ -44,26 +70,52 @@ class TaskManager private constructor() {
    }


-    private var mCurDayIndexDailySign: Int = 0
-    private val mutex = Mutex()
+

    @Volatile
    private var initialized = false
-    private var mTaskConfig: TaskBean? = null
-    private var mDailySignData: DailySignBean = DailySignBean()
+    private val mutex = Mutex()
    private val mGson = GsonBuilder().create()
+    private var mTaskConfig: TaskBean? = null
+
+
+    private val mDailySignTaskHelper by lazy { DailySignTaskHelper() }
+    private val mDailyWatchVideoTaskHelper by lazy { DailyWatchVideoTaskHelper() }
+    private val mDailyWatchAdTaskHelper by lazy { DailyWatchAdTaskHelper() }
+    private val mBoxHelper by lazy { BoxTaskHelper() }
+    private val mNewbieJoinDiscordHelper by lazy { NewbieJoinDiscordHelper() }
+    private val mNewbieEnableNotifyHelper by lazy { NewbieEnableNotifyHelper() }
+    private val mNewbieFirstWithdrawHelper by lazy { NewbieFirstWithdrawHelper() }
+
+


    init {
        loadTaskConfigAsync()
-
+        registerEvents()

        // TODO - remove test code
        if (true) {
-            generateTestDailySignTestBean()
+            mDailySignTaskHelper.generateTestDailySignTestBean()
        }
    }

+    private fun registerEvents() {
+        NotifyMan.instance().register(object : NotifyMan.ICallback(true) {
+            override fun onEvent(data: NotifyMan.NotifyData<*>?) {
+                when (data?.mEventType) {
+                    VididinEvents.Event_AD_TASK_TYPE_Convert_Gold_2_Cash -> {
+                        AccountManager.convertGold2Cash()
+                    }
+
+                    VididinEvents.Event_AD_TASK_TYPE_Watch_Ad_Earn_Gold -> {
+                        AccountManager.addGold(VidiConst.WATCH_AD_REWARD_GOLD)
+                    }
+                }
+            }
+        }, VididinEvents.Event_AD_TASK_TYPE_Convert_Gold_2_Cash, VididinEvents.Event_AD_TASK_TYPE_Watch_Ad_Earn_Gold)
+    }
+

    suspend fun getTaskConfig(): TaskBean? = mutex.withLock {
        if (!initialized) {
@ -77,9 +129,7 @@ class TaskManager private constructor() {
            mutex.withLock {
                if (!initialized) {
                    loadTaskConfigFromAsset()
-                    loadTaskStatesFromSp()
-
-                    initCalculate()
+                    initHelpers()
                }
            }
        }
@ -93,20 +143,54 @@ class TaskManager private constructor() {
        }
    }

-
-    private suspend fun loadTaskStatesFromSp() {
-        return withContext(Dispatchers.IO) {
-            val taskStateBeanInSp = SpUtil.instance().getObject<DailySignBean>(SpUtil.KEY_TASK_BEAN)
-            if (taskStateBeanInSp == null) {
-                SpUtil.instance().putObject(SpUtil.KEY_TASK_BEAN, mDailySignData)
-            } else {
-                mDailySignData = taskStateBeanInSp
-            }
-        }
+    private suspend fun initHelpers() {
+        mDailySignTaskHelper.setConfigDatas(getDailyCheckInTask()!!)
+        mDailyWatchVideoTaskHelper.setConfigDatas(getDailyVideoTask()!!)
+        mDailyWatchAdTaskHelper.setConfigDatas(getDailyAdTask()!!)
+        mNewbieJoinDiscordHelper.setConfigDatas(getNewbieJoinDiscordTask()!!)
+        mNewbieEnableNotifyHelper.setConfigDatas(getNewbieEnableNotifyTask()!!)
+        mNewbieFirstWithdrawHelper.setConfigDatas(getNewbieFirstWithdrawTask()!!)
+        mBoxHelper.setConfigDatas(getBoxTaskConfig()!!)
    }

-    private fun initCalculate() {
+    fun onDateChanged() {
+        mDailySignTaskHelper.onDateChanged()
+        mDailyWatchVideoTaskHelper.onDateChanged()
+        mDailyWatchAdTaskHelper.onDateChanged()
+        mBoxHelper.onDateChanged()
+        mNewbieJoinDiscordHelper.onDateChanged()
+        mNewbieEnableNotifyHelper.onDateChanged()
+        mNewbieFirstWithdrawHelper.onDateChanged()
+    }

+
+    //------------------------- Tasks Getter ------------------------------
+    fun dailySignStatus(): DailySignTaskHelper {
+        return mDailySignTaskHelper
+    }
+
+    fun dailyWatchVideoStatus(): DailyWatchVideoTaskHelper {
+        return mDailyWatchVideoTaskHelper
+    }
+
+    fun dailyWatchAdStatus(): DailyWatchAdTaskHelper {
+        return mDailyWatchAdTaskHelper
+    }
+
+    fun boxTaskStatus(): BoxTaskHelper {
+        return mBoxHelper
+    }
+
+    fun newbieJoinDiscordStatus(): NewbieJoinDiscordHelper {
+        return mNewbieJoinDiscordHelper
+    }
+
+    fun newbieEnableNotifyStatus(): NewbieEnableNotifyHelper {
+        return mNewbieEnableNotifyHelper
+    }
+
+    fun newbieFirstWithdrawStatus(): NewbieFirstWithdrawHelper {
+        return mNewbieFirstWithdrawHelper
    }


@ -144,126 +228,17 @@ class TaskManager private constructor() {
    }


-
-
-    //----------------------------- 每日签到 -----------------------------//
-
-    fun getHomeWatchDurationRewardNum(): Int {
-        return 28;  // TODO - mTaskConfigBean.xxxx
+    // 宝箱任务
+    fun getBoxTaskConfig(): BoxTaskRoot? {
+        return mTaskConfig?.task_module_config?.box_task
    }


-    fun getCurDayIndexOfDailyCheckIn() : Int {
-        var dayIndexOfPeriod = 0
-
-        val periodStartMs = mDailySignData.startMs
-        if (periodStartMs > 0) {
-            dayIndexOfPeriod = DateUtil.getPassedDayNum(periodStartMs, DateUtil.getCurTimeMs())
-            if (dayIndexOfPeriod > 6) {
-                mDailySignData.startMs = DateUtil.getCurTimeMs()
-                SpUtil.instance().putObject(SpUtil.KEY_TASK_BEAN, mDailySignData)
-            }
-        } else {
-            mDailySignData.startMs = DateUtil.getCurTimeMs()
-            SpUtil.instance().putObject(SpUtil.KEY_TASK_BEAN, mDailySignData)
-        }
-
-        mCurDayIndexDailySign = dayIndexOfPeriod
-        return dayIndexOfPeriod
-    }
-
-    fun getDailySignStateBean(dayIndex: Int): DailySignDayInfoBean {
-        return mDailySignData.signStateList[dayIndex]
-    }
-
-    fun executeDailySign(dayIndex: Int, isDoubleReward: Boolean, isByAd: Boolean) : Boolean {
-        val daySignState = mDailySignData.signStateList[dayIndex]
-
-        if (!daySignState.hasSigned || (dayIndex == mCurDayIndexDailySign && !daySignState.hasWatchedAd)) {
-            val dayReward = getDailyCheckInTask()?.reward_details?.get(dayIndex)?.value ?: 0
-            val finalReward = if (isDoubleReward) 2*dayReward else dayReward
-            daySignState.hasRewardedNum += finalReward
-            daySignState.hasSigned = true
-            daySignState.hasWatchedAd = isByAd
-            saveDailySignInfo()
-            AccountManager.addGold(finalReward)
-            notifySignStateChanged(Pair(dayIndex, daySignState))
-            return true
-        }
-        return false
-    }
-
-    private fun notifySignStateChanged(dataPair: Pair<Int, DailySignDayInfoBean>) {
-        NotifyMan.instance().sendEvent(VididinEvents.Event_Sign_State_Changed, NotifyMan.NotifyData(dataPair))
-    }
-
-    private fun saveDailySignInfo() {
-        SpUtil.instance().putObject(SpUtil.KEY_DAILY_SIGN, mDailySignData)
-    }
-
-    private fun generateTestDailySignTestBean() {
-        mDailySignData = DailySignBean().apply {
-            startMs = DateUtil.getCurTimeMs() - 4 * DateUtil.MS_NUM_ONE_DAY
-            signStateList.clear()
-            signStateList.add(DailySignDayInfoBean(hasSigned = true, hasWatchedAd = true))
-            signStateList.add(DailySignDayInfoBean(hasSigned = false, hasWatchedAd = false))
-            signStateList.add(DailySignDayInfoBean(hasSigned = true, hasWatchedAd = false))
-            signStateList.add(DailySignDayInfoBean(hasSigned = false, hasWatchedAd = false))
-            signStateList.add(DailySignDayInfoBean(hasSigned = false, hasWatchedAd = false))
-            signStateList.add(DailySignDayInfoBean(hasSigned = false, hasWatchedAd = false))
-            signStateList.add(DailySignDayInfoBean(hasSigned = false, hasWatchedAd = false))
-        }
-
-        SpUtil.instance().putObject(SpUtil.KEY_TASK_BEAN, mDailySignData)
-        AccountManager.saveBankAccount(null)
-    }
-
-    fun getForgotSignDays(): Int {
-        var forgotSignDays = 0
-        val curDayIndex = getCurDayIndexOfDailyCheckIn()
-        mDailySignData.signStateList.forEachIndexed { index, item->
-            if (!item.hasSigned && index < curDayIndex) {
-                forgotSignDays++
-            }
-        }
-        return forgotSignDays
-    }
-
-    fun getSignDaysTotal(): Int {
-        var signDays = 0
-        mDailySignData.signStateList.forEachIndexed { index, item->
-            if (item.hasSigned) {
-                signDays++
-            }
-        }
-        return signDays
-    }
-
-    fun getForgotSignFirstDayIndex(): Int {
-        val curDayIndex = getCurDayIndexOfDailyCheckIn()
-        mDailySignData.signStateList.forEachIndexed { index, item->
-            if (!item.hasSigned && index < curDayIndex) {
-                return index
-            }
-        }
-        return -1;
-    }


-    fun getDayStateList(): List<DailySignDayInfoBean> {
-        return mDailySignData.signStateList
-    }
-
-    fun getRewardNumOfDailySign(dayIndex: Int) : Int {
-        return getDailyCheckInTask()?.reward_details?.get(dayIndex)?.value ?: 0
-    }
-
-    fun isDailySignAllOperationDone(): Boolean {
-        val curDayState = getDailySignStateBean(mCurDayIndexDailySign)
-        return curDayState.hasSigned && curDayState.hasWatchedAd && getForgotSignFirstDayIndex() <= 0
-    }


 }


+
--- a/app/src/main/java/com/gamedog/vididin/manager/helpers/BaseDailyTaskHelper.kt
+++ b/app/src/main/java/com/gamedog/vididin/manager/helpers/BaseDailyTaskHelper.kt
@ -0,0 +1,69 @@
+package com.gamedog.vididin.manager.helpers
+
+import com.ama.core.architecture.util.DateUtil
+import com.gamedog.vididin.core.login.login.AccountManager
+import com.gamedog.vididin.main.fragments.task.Task
+import com.gamedog.vididin.manager.taskbeans.BaseDailyTaskState
+import com.gamedog.vididin.manager.taskbeans.BaseTaskState.Companion.STATE_CLAIMED
+import com.gamedog.vididin.manager.taskbeans.BaseTaskState.Companion.STATE_FINISH
+import com.gamedog.vididin.manager.taskbeans.BaseTaskState.Companion.STATE_ONGOING
+import com.gamedog.vididin.manager.taskbeans.TaskStateWatchVideo
+import com.gamedog.vididin.manager.taskbeans.TaskStateWatchAd
+
+
+
+abstract class BaseDailyTaskHelper<T : BaseDailyTaskState> : BaseTaskHelper<T, Task>() {
+
+    abstract protected fun notifyEvents()
+    abstract protected fun generateTodayTask()
+
+    fun claimSubTaskReward(subTaskIndex: Int) : Boolean {
+        if (subTaskIndex >= 0 && subTaskIndex < mStateBean.getSubTaskRewardState().size) {
+            try {
+                val subTask = mStateBean.getSubTaskRewardState()[subTaskIndex]
+                if (subTask.state == STATE_FINISH) {
+                    AccountManager.addGold(subTask.mRewardNum)
+                    subTask.state = STATE_CLAIMED
+                    saveState2Sp()
+                    notifyEvents()
+                    return true
+                }
+            } catch (e: Exception) {
+                e.printStackTrace()
+            }
+        }
+        return false
+    }
+
+    override fun onDateChanged() {
+        super.onDateChanged()
+        generateTodayTask()
+        notifyEvents()
+    }
+
+
+    protected fun calculateNewState() {
+        val todayWatchedCount = mStateBean.getTodayWatchedCount()
+
+        mStateBean.getSubTaskRewardState().forEachIndexed { index, subTaskState ->
+            val targetCount = subTaskState.mTargetAdCount
+            when(subTaskState.state) {
+                STATE_ONGOING -> {
+                    if (todayWatchedCount >= targetCount) {
+                        subTaskState.state = STATE_FINISH
+                    }
+                }
+            }
+        }
+    }
+
+
+    protected fun isTodayStatusBean(stateBean: TaskStateWatchAd): Boolean {
+        return DateUtil.isToday(stateBean.todayMs)
+    }
+
+    protected fun isTodayStatusBean(stateBean: TaskStateWatchVideo): Boolean {
+        return DateUtil.isToday(stateBean.todayMs)
+    }
+
+}
--- a/app/src/main/java/com/gamedog/vididin/manager/helpers/BaseTaskHelper.kt
+++ b/app/src/main/java/com/gamedog/vididin/manager/helpers/BaseTaskHelper.kt
@ -0,0 +1,54 @@
+package com.gamedog.vididin.manager.helpers
+
+import com.ama.core.architecture.util.SpUtil
+import com.ama.core.architecture.util.eventbus.NotifyMan
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+abstract class BaseTaskHelper<T: Any, C: Any> {
+    abstract val mSpKey: String
+    protected lateinit var mStateBean: T
+    protected lateinit var mTaskConfig: C
+    private var mEventCallback: NotifyMan.ICallback? = null
+
+    abstract fun loadTaskFromSp()
+
+    suspend fun setConfigDatas(taskConfig: C) {
+        mTaskConfig = taskConfig
+
+        return withContext(Dispatchers.IO) {
+            loadTaskFromSp()
+        }
+    }
+
+    open fun onDateChanged() {
+        // TODO - sub class override this methods if daily task
+    }
+
+
+    protected fun registerEvents(onEvents: ((NotifyMan.NotifyData<*>?)->Unit), vararg eventTypes: Int) {
+        if (mEventCallback == null) {
+            mEventCallback = object : NotifyMan.ICallback(true) {
+                override fun onEvent(data: NotifyMan.NotifyData<*>?) {
+                    onEvents.invoke(data)
+                }
+            }
+        }
+
+        NotifyMan.instance().register(mEventCallback, *eventTypes)
+    }
+
+    protected fun saveState2Sp() {
+        SpUtil.instance().putObject(mSpKey, mStateBean)
+    }
+
+    fun getStatusBean() : T {
+        return mStateBean
+    }
+
+    fun release() {
+        NotifyMan.instance().unregister(mEventCallback)
+    }
+
+
+}
--- a/app/src/main/java/com/gamedog/vididin/manager/helpers/BoxTaskHelper.kt
+++ b/app/src/main/java/com/gamedog/vididin/manager/helpers/BoxTaskHelper.kt
@ -0,0 +1,287 @@
+package com.gamedog.vididin.manager.helpers
+
+import com.ama.core.architecture.util.DateUtil
+import com.ama.core.architecture.util.SpUtil
+import com.ama.core.architecture.util.eventbus.NotifyMan
+import com.gamedog.vididin.R
+import com.gamedog.vididin.VididinEvents
+import com.gamedog.vididin.core.login.login.AccountManager
+import com.gamedog.vididin.main.fragments.task.BoxTaskRoot
+import com.gamedog.vididin.manager.TaskManager.Companion.BOX_SUB_TASK_TYPE_ZERO_BUY
+import com.gamedog.vididin.manager.TaskManager.Companion.BOX_SUB_TASK_TYPE_SIGN
+import com.gamedog.vididin.manager.TaskManager.Companion.BOX_SUB_TASK_TYPE_AD
+import com.gamedog.vididin.manager.TaskManager.Companion.BOX_SUB_TASK_TYPE_VIDEO
+import com.gamedog.vididin.manager.taskbeans.TaskStateBox
+import com.gamedog.vididin.manager.taskbeans.TaskStateBoxRoot
+import com.gamedog.vididin.manager.taskbeans.TaskStateBoxSub
+import com.gamedog.vididin.manager.taskbeans.BaseTaskState.Companion.STATE_FINISH
+import com.gamedog.vididin.manager.taskbeans.BaseTaskState.Companion.STATE_ONGOING
+import com.gamedog.vididin.manager.taskbeans.BaseTaskState.Companion.STATE_CLAIMED
+import com.gamedog.vididin.manager.taskbeans.BaseTaskState.Companion.STATE_EXPIRED
+
+
+class BoxTaskHelper: BaseTaskHelper<TaskStateBoxRoot, BoxTaskRoot>() {
+
+    override val mSpKey = SpUtil.KEY_TASK_BOX
+
+    init {
+        registerEvents( { eventData->
+            when (eventData?.mEventType) {
+                VididinEvents.Event_Finish_One_Ad -> {
+                    handleEvents(BOX_SUB_TASK_TYPE_AD)
+                }
+
+                VididinEvents.Event_Finish_One_Video -> {
+                    handleEvents(BOX_SUB_TASK_TYPE_VIDEO)
+                }
+
+                VididinEvents.Event_Finish_One_Sign -> {
+                    handleEvents(BOX_SUB_TASK_TYPE_SIGN)
+                }
+
+                VididinEvents.Event_Finish_One_Zerobuy -> {
+                    handleEvents(BOX_SUB_TASK_TYPE_ZERO_BUY)
+                }
+            }
+
+        }, VididinEvents.Event_Finish_One_Ad, VididinEvents.Event_Finish_One_Video,
+            VididinEvents.Event_Finish_One_Sign, VididinEvents.Event_Finish_One_Zerobuy)
+    }
+
+    override fun loadTaskFromSp() {
+        val taskStateBeanInSp = SpUtil.instance().getObject<TaskStateBoxRoot>(mSpKey)
+        if (taskStateBeanInSp == null || isBoxRootTaskExpired(taskStateBeanInSp)) {
+            mStateBean = generateStateBeanFromConfig()
+            saveState2Sp()
+        } else {
+            mStateBean = taskStateBeanInSp
+        }
+    }
+
+    private fun generateStateBeanFromConfig(): TaskStateBoxRoot {
+        val boxStateList = mutableListOf<TaskStateBox>()
+        mTaskConfig.chests.forEachIndexed { index, task ->
+            val boxSubTaskStateList = mutableListOf<TaskStateBoxSub>()
+            task.tasks.forEachIndexed { index, task ->
+                boxSubTaskStateList.add(TaskStateBoxSub(task.task_id,
+                    task.task_name, task.required_count, task.task_type))
+            }
+
+            boxStateList.add(TaskStateBox(task.chest_id, task.chest_name, task.duration_days,
+                task.reward_type, task.reward_value, task.is_one_time, task.status, boxSubTaskStateList))
+        }
+
+        return TaskStateBoxRoot(DateUtil.getTodayStartTimeMs(), boxStateList)
+    }
+
+
+    @Synchronized
+    private fun handleEvents(taskType: Int) {
+        val currentBoxIndex = getCurrentBoxIndex()
+        if (!isBoxAllFinished(currentBoxIndex)) {
+            getCurrentBoxState()?.tasks?.forEachIndexed { index, subTask->
+                if (taskType == subTask.task_type
+                            && !isBoxSubTaskFinished(currentBoxIndex, index)) {
+                    subTask.finishedNum++
+                    saveState2Sp()
+
+                    notifyEvent()
+                }
+            }
+        }
+    }
+
+    private fun notifyEvent() {
+        NotifyMan.instance().sendEvent(VididinEvents.EVENT_BOX_TASK_STATE_CHANGED, null)
+    }
+
+
+    private fun isBoxRootTaskExpired(taskStateBoxRoot: TaskStateBoxRoot): Boolean {
+        var totalDurationDays = 0
+        taskStateBoxRoot.tasks.forEach {
+            totalDurationDays += it.duration_days
+        }
+        return DateUtil.isPeriodExpired(taskStateBoxRoot.startMs, totalDurationDays)
+    }
+
+    private fun isBoxTaskExpired(boxIndex: Int): Boolean {
+        if (boxIndex >= 0 && boxIndex < mStateBean.tasks.size) {
+            val curBoxState = mStateBean.tasks[boxIndex]
+            return DateUtil.isPeriodExpired(mStateBean.startMs, curBoxState.duration_days)
+        }
+
+        return false
+    }
+
+    private fun isBoxAllTasksFinish(boxIndex: Int) : Boolean {
+        if (boxIndex >= 0 && boxIndex < mStateBean.tasks.size) {
+            val curBoxState = mStateBean.tasks[boxIndex]
+
+            curBoxState.tasks.forEach {
+                if (it.required_count > it.finishedNum) {
+                    return false
+                }
+            }
+            return true
+        }
+
+        return false
+    }
+
+    fun getCurrentBoxIndex(): Int {
+        val boxRootStartMs = mStateBean.startMs
+
+        mStateBean.tasks.forEachIndexed { index, box ->
+            if (!DateUtil.isPeriodExpired(boxRootStartMs, box.duration_days)) {
+                return index
+            }
+        }
+        return -1
+    }
+
+    fun getCurrentBoxState(): TaskStateBox? {
+        val currentBoxIndex = getCurrentBoxIndex()
+
+        if (currentBoxIndex >= 0 && currentBoxIndex < mStateBean.tasks.size) {
+            return mStateBean.tasks[currentBoxIndex]
+        }
+        return null
+    }
+
+    fun isBoxAllFinished(boxIndex: Int) : Boolean {
+        val stateEnum = getBoxStateEnum(boxIndex)
+        return stateEnum == STATE_FINISH || stateEnum == STATE_CLAIMED
+    }
+
+    fun isBoxSubTaskFinished(boxIndex: Int, subTaskIndex: Int) : Boolean {
+        val subTaskState = mStateBean.tasks[boxIndex].tasks[subTaskIndex]
+        return subTaskState.finishedNum >= subTaskState.required_count
+    }
+
+    fun getBoxStateEnum(boxIndex: Int): Int {
+        if (boxIndex >= 0 && boxIndex < mStateBean.tasks.size) {
+            val curBoxState = mStateBean.tasks[boxIndex]
+
+            if (curBoxState.hasClaimedReward) {
+                return STATE_CLAIMED
+            } else {
+                if (isBoxAllTasksFinish(boxIndex)) {
+                    return STATE_FINISH
+                } else {
+                    if (isBoxTaskExpired(boxIndex)) {
+                        return STATE_EXPIRED
+                    } else {
+                        return STATE_ONGOING
+                    }
+                }
+            }
+        }
+        return -1
+    }
+
+    fun getCouldClaimCashNum(): Float {
+        var waitClaimCashNum = 0F
+        mStateBean.tasks.forEachIndexed { index, box ->
+            if (getBoxStateEnum(index) == STATE_FINISH) {
+                waitClaimCashNum += box.reward_value
+            }
+        }
+        return waitClaimCashNum
+    }
+
+    fun getSubTaskHintStrRes(boxIndex: Int, subTaskIndex: Int): Int {
+        when (boxIndex) {
+            0-> {
+                when (subTaskIndex) {
+                    0-> {
+                        return R.string.box_subtask_hint_1_1
+                    }
+
+                    1-> {
+                        return R.string.box_subtask_hint_1_2
+                    }
+
+                    2-> {
+                        return R.string.box_subtask_hint_1_3
+                    }
+                }
+            }
+
+            1-> {
+                when (subTaskIndex) {
+                    0-> {
+                        return R.string.box_subtask_hint_2_1
+                    }
+
+                    1-> {
+                        return R.string.box_subtask_hint_2_2
+                    }
+
+                    2-> {
+                        return R.string.box_subtask_hint_2_3
+                    }
+                }
+            }
+
+            2-> {
+                when (subTaskIndex) {
+                    0-> {
+                        return R.string.box_subtask_hint_3_1
+                    }
+
+                    1-> {
+                        return R.string.box_subtask_hint_3_2
+                    }
+
+                    2-> {
+                        return R.string.box_subtask_hint_3_3
+                    }
+                }
+            }
+        }
+
+        return 0
+    }
+
+    fun getCurrentBoxTotalProgress(): Int {
+        val currentBoxIndex = getCurrentBoxIndex()
+        val boxList = mStateBean.tasks
+        if (currentBoxIndex >= 0 && currentBoxIndex < boxList.size) {
+            var totalFinished = 0
+            var totalRequired = 0
+            val currentBox = boxList[currentBoxIndex]
+
+            currentBox.tasks.forEach {
+                totalFinished += it.finishedNum
+                totalRequired += it.required_count
+            }
+
+            if (totalRequired > 0) {
+                val totalProgress = (100 * totalFinished) / totalRequired
+                return if (totalProgress > 100) 100 else totalProgress
+            }
+        }
+        return 0
+    }
+
+    fun executeClaimCash(): Boolean {
+        try {
+            val couldClaimCashNum = getCouldClaimCashNum()
+            if (couldClaimCashNum > 0F) {
+                AccountManager.addCash(couldClaimCashNum)
+                mStateBean.tasks.forEachIndexed { index, box ->
+                    if (getBoxStateEnum(index) == STATE_FINISH) {
+                        box.hasClaimedReward = true
+                    }
+                }
+                saveState2Sp()
+                notifyEvent()
+                return true
+            }
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
+        return false
+    }
+
+}
--- a/app/src/main/java/com/gamedog/vididin/manager/helpers/DailySignTaskHelper.kt
+++ b/app/src/main/java/com/gamedog/vididin/manager/helpers/DailySignTaskHelper.kt
@ -0,0 +1,135 @@
+package com.gamedog.vididin.manager.helpers
+
+import com.ama.core.architecture.util.DateUtil
+import com.ama.core.architecture.util.SpUtil
+import com.ama.core.architecture.util.eventbus.NotifyMan
+import com.gamedog.vididin.VididinEvents
+import com.gamedog.vididin.core.login.login.AccountManager
+import com.gamedog.vididin.main.fragments.task.Task
+import com.gamedog.vididin.manager.taskbeans.TaskDailySignBean
+import com.gamedog.vididin.manager.taskbeans.DailySignDayInfoBean
+
+
+class DailySignTaskHelper : BaseTaskHelper<TaskDailySignBean, Task>() {
+    private var mCurDayIndexDailySign: Int = 0
+    override val mSpKey = SpUtil.KEY_TASK_BEAN
+
+
+    override fun loadTaskFromSp() {
+        val taskStateBeanInSp = SpUtil.instance().getObject<TaskDailySignBean>(mSpKey)
+        if (taskStateBeanInSp == null) {
+            mStateBean = TaskDailySignBean()
+            saveState2Sp()
+        } else {
+            mStateBean = taskStateBeanInSp
+        }
+    }
+
+    fun getCurDayIndexOfDailyCheckIn() : Int {
+        var dayIndexOfPeriod = 0
+
+        val periodStartMs = mStateBean.startDurationMs
+        if (periodStartMs > 0) {
+            dayIndexOfPeriod = DateUtil.getPassedDayNum(periodStartMs, DateUtil.getCurTimeMs())
+            if (dayIndexOfPeriod > 6) {
+                mStateBean?.startDurationMs = DateUtil.getCurTimeMs()
+                saveState2Sp()
+            }
+        } else {
+            mStateBean?.startDurationMs = DateUtil.getCurTimeMs()
+            saveState2Sp()
+        }
+
+        mCurDayIndexDailySign = dayIndexOfPeriod
+        return dayIndexOfPeriod
+    }
+
+    fun getDailySignStateBean(dayIndex: Int): DailySignDayInfoBean {
+        return mStateBean.signStateList[dayIndex]
+    }
+
+    fun executeDailySign(dayIndex: Int, isDoubleReward: Boolean, isByAd: Boolean) : Boolean {
+        val daySignState = mStateBean.signStateList[dayIndex]
+
+        if (!daySignState.hasSigned || (dayIndex == mCurDayIndexDailySign && !daySignState.hasWatchedAd)) {
+            val dayReward = getRewardNumOfDailySign(dayIndex)
+            val finalReward = if (isDoubleReward) 2*dayReward else dayReward
+            daySignState.hasRewardedNum += finalReward
+            daySignState.hasSigned = true
+            daySignState.hasWatchedAd = isByAd
+            saveState2Sp()
+            AccountManager.addGold(finalReward)
+            notifySignStateChanged(Pair(dayIndex, daySignState))
+            return true
+        }
+        return false
+    }
+
+    private fun notifySignStateChanged(dataPair: Pair<Int, DailySignDayInfoBean>) {
+        NotifyMan.instance().sendEvent(VididinEvents.Event_Sign_State_Changed, NotifyMan.NotifyData(dataPair))
+        NotifyMan.instance().sendEvent(VididinEvents.Event_Finish_One_Sign, null)
+    }
+
+    fun generateTestDailySignTestBean() {
+        mStateBean = TaskDailySignBean().apply {
+            startDurationMs = DateUtil.getCurTimeMs() - 4 * DateUtil.MS_NUM_ONE_DAY
+            signStateList.clear()
+            signStateList.add(DailySignDayInfoBean(hasSigned = true, hasWatchedAd = true))
+            signStateList.add(DailySignDayInfoBean(hasSigned = false, hasWatchedAd = false))
+            signStateList.add(DailySignDayInfoBean(hasSigned = true, hasWatchedAd = false))
+            signStateList.add(DailySignDayInfoBean(hasSigned = false, hasWatchedAd = false))
+            signStateList.add(DailySignDayInfoBean(hasSigned = false, hasWatchedAd = false))
+            signStateList.add(DailySignDayInfoBean(hasSigned = false, hasWatchedAd = false))
+            signStateList.add(DailySignDayInfoBean(hasSigned = false, hasWatchedAd = false))
+        }
+
+        saveState2Sp()
+        AccountManager.saveBankAccount(null)
+    }
+
+    fun getForgotSignDays(): Int {
+        var forgotSignDays = 0
+        val curDayIndex = getCurDayIndexOfDailyCheckIn()
+        mStateBean.signStateList.forEachIndexed { index, item->
+            if (!item.hasSigned && index < curDayIndex) {
+                forgotSignDays++
+            }
+        }
+        return forgotSignDays
+    }
+
+    fun getSignDaysTotal(): Int {
+        var signDays = 0
+        mStateBean.signStateList.forEachIndexed { index, item->
+            if (item.hasSigned) {
+                signDays++
+            }
+        }
+        return signDays
+    }
+
+    fun getForgotSignFirstDayIndex(): Int {
+        val curDayIndex = getCurDayIndexOfDailyCheckIn()
+        mStateBean.signStateList.forEachIndexed { index, item->
+            if (!item.hasSigned && index < curDayIndex) {
+                return index
+            }
+        }
+        return -1;
+    }
+
+
+    fun getDayStateList(): List<DailySignDayInfoBean> {
+        return mStateBean.signStateList
+    }
+
+    fun getRewardNumOfDailySign(dayIndex: Int) : Int {
+        return  mTaskConfig.reward_details[dayIndex].value
+    }
+
+    fun isDailySignAllOperationDone(): Boolean {
+        val curDayState = getDailySignStateBean(mCurDayIndexDailySign)
+        return curDayState.hasSigned && curDayState.hasWatchedAd && getForgotSignFirstDayIndex() <= 0
+    }
+
+}
--- a/app/src/main/java/com/gamedog/vididin/manager/helpers/DailyWatchAdTaskHelper.kt
+++ b/app/src/main/java/com/gamedog/vididin/manager/helpers/DailyWatchAdTaskHelper.kt
@ -0,0 +1,53 @@
+package com.gamedog.vididin.manager.helpers
+
+import com.ama.core.architecture.util.DateUtil
+import com.ama.core.architecture.util.SpUtil
+import com.ama.core.architecture.util.eventbus.NotifyMan
+import com.gamedog.vididin.VididinEvents
+import com.gamedog.vididin.manager.taskbeans.TaskStateWatchAd
+
+
+class DailyWatchAdTaskHelper : BaseDailyTaskHelper<TaskStateWatchAd>() {
+
+    override val mSpKey = SpUtil.KEY_DAILY_WATCH_AD_FOR_GOLD
+
+
+    init {
+        registerEvents( { eventData->
+            val watchedAdNum: Int = eventData?.mData as Int
+            handleOneAdWatched(watchedAdNum)
+        }, VididinEvents.Event_Finish_One_Ad)
+    }
+
+    override fun loadTaskFromSp() {
+        val spStateBean = SpUtil.instance().getObject<TaskStateWatchAd>(mSpKey)
+        if (spStateBean == null || !isTodayStatusBean(spStateBean)) {
+            generateTodayTask()
+        } else {
+            mStateBean = spStateBean
+            notifyEvents()
+        }
+    }
+
+    override fun generateTodayTask() {
+        mStateBean = TaskStateWatchAd(DateUtil.getCurTimeMs())
+        mStateBean.initSubTaskRewardList(mTaskConfig.reward_details)
+        saveState2Sp()
+    }
+
+    override fun notifyEvents() {
+        NotifyMan.instance().sendEvent(VididinEvents.EVENT_DAILY_WATCHED_AD_NUM_CHANGED, null)
+    }
+
+    private fun handleOneAdWatched(newAdWatchedNum: Int) {
+        mStateBean.run {
+            if (!isAllTaskFinish()) {
+                addWatchedCount(newAdWatchedNum)
+                calculateNewState()
+                saveState2Sp()
+                notifyEvents()
+            }
+        }
+    }
+
+}
--- a/app/src/main/java/com/gamedog/vididin/manager/helpers/DailyWatchVideoTaskHelper.kt
+++ b/app/src/main/java/com/gamedog/vididin/manager/helpers/DailyWatchVideoTaskHelper.kt
@ -0,0 +1,58 @@
+package com.gamedog.vididin.manager.helpers
+
+
+import com.ama.core.architecture.util.DateUtil
+import com.ama.core.architecture.util.SpUtil
+import com.ama.core.architecture.util.eventbus.NotifyMan
+import com.gamedog.vididin.VididinEvents
+import com.gamedog.vididin.manager.taskbeans.TaskStateWatchAd
+import com.gamedog.vididin.manager.taskbeans.TaskStateWatchVideo
+
+
+class DailyWatchVideoTaskHelper : BaseDailyTaskHelper<TaskStateWatchVideo>()  {
+
+    override val mSpKey = SpUtil.KEY_DAILY_WATCH_VIDEO
+
+
+    init {
+        registerEvents( { eventData->
+            val dataPair: Pair<String, Long> = eventData?.mData as Pair<String, Long>
+            handleOneVideoWatched(dataPair)
+        }, VididinEvents.Event_Finish_One_Video)
+    }
+
+    override fun loadTaskFromSp() {
+        val spStateBean = SpUtil.instance().getObject<TaskStateWatchVideo>(mSpKey)
+        if (spStateBean == null || !isTodayStatusBean(spStateBean)) {
+            generateTodayTask()
+        } else {
+            mStateBean = spStateBean
+            notifyEvents()
+        }
+    }
+
+    override fun generateTodayTask() {
+        mStateBean = TaskStateWatchVideo(DateUtil.getCurTimeMs())
+        mStateBean.initSubTaskRewardList(mTaskConfig.reward_details)
+        saveState2Sp()
+    }
+
+    override fun notifyEvents() {
+        NotifyMan.instance().sendEvent(VididinEvents.EVENT_DAILY_WATCHED_VIDEO_NUM_CHANGED, null)
+    }
+
+
+    private fun handleOneVideoWatched(dataPair: Pair<String, Long>) {
+        mStateBean.run {
+            if (!isAllTaskFinish()) {
+                if (addWatchedVideoInfo(dataPair)) {
+                    calculateNewState()
+                    saveState2Sp()
+                    notifyEvents()
+                }
+            }
+        }
+    }
+
+
+}
--- a/app/src/main/java/com/gamedog/vididin/manager/helpers/NewbieEnableNotifyHelper.kt
+++ b/app/src/main/java/com/gamedog/vididin/manager/helpers/NewbieEnableNotifyHelper.kt
@ -0,0 +1,45 @@
+package com.gamedog.vididin.manager.helpers
+
+
+import com.ama.core.architecture.util.SpUtil
+import com.ama.core.architecture.util.eventbus.NotifyMan
+import com.gamedog.vididin.VididinEvents
+import com.gamedog.vididin.core.login.login.AccountManager
+import com.gamedog.vididin.main.fragments.task.Task
+import com.gamedog.vididin.manager.taskbeans.TaskStateNewBieEnableNotify
+
+class NewbieEnableNotifyHelper: BaseTaskHelper<TaskStateNewBieEnableNotify, Task>() {
+
+    override val mSpKey = SpUtil.KEY_NEWBIE_ENABLE_NOTIFY
+
+
+    override fun loadTaskFromSp() {
+        val taskStateBeanInSp = SpUtil.instance().getObject<TaskStateNewBieEnableNotify>(mSpKey)
+        if (taskStateBeanInSp == null) {
+            mStateBean = generateStateBeanFromConfig()
+            saveState2Sp()
+        } else {
+            mStateBean = taskStateBeanInSp
+        }
+    }
+
+    private fun generateStateBeanFromConfig(): TaskStateNewBieEnableNotify {
+        return TaskStateNewBieEnableNotify(mTaskConfig.reward_value)
+    }
+
+    fun claimReward() : Boolean {
+        if (!mStateBean.hasClaimReward) {
+            AccountManager.addGold(mStateBean.rewardGoldNum)
+            mStateBean.hasClaimReward = true
+            saveState2Sp()
+            notifyStateChangeEvent()
+            return true
+        }
+        return false
+    }
+
+    private fun notifyStateChangeEvent() {
+        NotifyMan.instance().sendEvent(VididinEvents.EVENT_NEWBIE_NOTIFY_TASK_CHANGED, null)
+    }
+
+}
--- a/app/src/main/java/com/gamedog/vididin/manager/helpers/NewbieFirstWithdrawHelper.kt
+++ b/app/src/main/java/com/gamedog/vididin/manager/helpers/NewbieFirstWithdrawHelper.kt
@ -0,0 +1,43 @@
+package com.gamedog.vididin.manager.helpers
+
+import com.ama.core.architecture.util.SpUtil
+import com.ama.core.architecture.util.eventbus.NotifyMan
+import com.gamedog.vididin.VididinEvents
+import com.gamedog.vididin.core.login.login.AccountManager
+import com.gamedog.vididin.main.fragments.task.Task
+import com.gamedog.vididin.manager.taskbeans.TaskStateNewBieFirstWithDraw
+
+class NewbieFirstWithdrawHelper: BaseTaskHelper<TaskStateNewBieFirstWithDraw, Task>() {
+
+    override val mSpKey = SpUtil.KEY_NEWBIE_FIRST_WITHDRAW
+
+    override fun loadTaskFromSp() {
+        val taskStateBeanInSp = SpUtil.instance().getObject<TaskStateNewBieFirstWithDraw>(mSpKey)
+        if (taskStateBeanInSp == null) {
+            mStateBean = generateStateBeanFromConfig()
+            saveState2Sp()
+        } else {
+            mStateBean = taskStateBeanInSp
+        }
+    }
+
+    private fun generateStateBeanFromConfig(): TaskStateNewBieFirstWithDraw {
+        return TaskStateNewBieFirstWithDraw(mTaskConfig.reward_value)
+    }
+
+    fun claimReward(): Boolean {
+        if (!mStateBean.hasClaimReward) {
+            AccountManager.addGold(mStateBean.rewardGoldNum)
+            mStateBean.hasClaimReward = true
+            saveState2Sp()
+            notifyStateChangeEvent()
+            return true
+        }
+        return false
+    }
+
+    private fun notifyStateChangeEvent() {
+        NotifyMan.instance().sendEvent(VididinEvents.EVENT_NEWBIE_FIRST_WITHDRAW_TASK_CHANGED, null)
+    }
+
+}
--- a/app/src/main/java/com/gamedog/vididin/manager/helpers/NewbieJoinDiscordHelper.kt
+++ b/app/src/main/java/com/gamedog/vididin/manager/helpers/NewbieJoinDiscordHelper.kt
@ -0,0 +1,43 @@
+package com.gamedog.vididin.manager.helpers
+
+import com.ama.core.architecture.util.SpUtil
+import com.ama.core.architecture.util.eventbus.NotifyMan
+import com.gamedog.vididin.VididinEvents
+import com.gamedog.vididin.core.login.login.AccountManager
+import com.gamedog.vididin.main.fragments.task.Task
+import com.gamedog.vididin.manager.taskbeans.TaskStateNewBieJoinDiscord
+
+class NewbieJoinDiscordHelper: BaseTaskHelper<TaskStateNewBieJoinDiscord, Task>() {
+
+    override val mSpKey = SpUtil.KEY_NEWBIE_JOIN_DISCORD
+
+    override fun loadTaskFromSp() {
+        val taskStateBeanInSp = SpUtil.instance().getObject<TaskStateNewBieJoinDiscord>(mSpKey)
+        if (taskStateBeanInSp == null) {
+            mStateBean = generateStateBeanFromConfig()
+            saveState2Sp()
+        } else {
+            mStateBean = taskStateBeanInSp
+        }
+    }
+
+    private fun generateStateBeanFromConfig(): TaskStateNewBieJoinDiscord {
+        return TaskStateNewBieJoinDiscord(mTaskConfig.reward_value)
+    }
+
+    fun claimReward() : Boolean {
+        if (!mStateBean.hasClaimReward) {
+            AccountManager.addGold(mStateBean.rewardGoldNum)
+            mStateBean.hasClaimReward = true
+            saveState2Sp()
+            notifyStateChangeEvent()
+            return true
+        }
+        return false
+    }
+
+    private fun notifyStateChangeEvent() {
+        NotifyMan.instance().sendEvent(VididinEvents.EVENT_NEWBIE_DISCORD_TASK_CHANGED, null)
+    }
+
+}
--- a/app/src/main/java/com/gamedog/vididin/manager/taskbeans/BaseDailyTaskState.kt
+++ b/app/src/main/java/com/gamedog/vididin/manager/taskbeans/BaseDailyTaskState.kt
@ -0,0 +1,38 @@
+package com.gamedog.vididin.manager.taskbeans
+
+import com.gamedog.vididin.main.fragments.task.RewardDetail
+import com.gamedog.vididin.manager.taskbeans.BaseTaskState.Companion.STATE_ONGOING
+import kotlinx.serialization.Serializable
+import kotlin.collections.forEach
+
+
+@Serializable
+abstract class BaseDailyTaskState : BaseTaskState() {
+    protected val mSubTaskRewardState: MutableList<SubDailyTaskBean> = mutableListOf()
+
+    abstract fun getTodayWatchedCount(): Int
+    abstract fun addWatchedCount(newWatchedNum: Int)
+    abstract fun addWatchedVideoInfo(dataPair: Pair<String, Long>): Boolean
+
+
+    fun getSubTaskRewardState(): List<SubDailyTaskBean> {
+        return mSubTaskRewardState
+    }
+
+    fun isAllTaskFinish(): Boolean {
+        return mSubTaskRewardState.all { it.state >= STATE_CLAIMED }
+    }
+
+    fun initSubTaskRewardList(subTasks: List<RewardDetail>) {
+        mSubTaskRewardState.clear()
+
+        subTasks.forEach {
+            mSubTaskRewardState.add(SubDailyTaskBean(it.value, it.target_count, STATE_ONGOING))
+        }
+    }
+}
+
+data class SubDailyTaskBean(
+    val mRewardNum: Int,
+    val mTargetAdCount: Int,
+    var state: Int = STATE_ONGOING,)
--- a/app/src/main/java/com/gamedog/vididin/manager/taskbeans/BaseTaskState.kt
+++ b/app/src/main/java/com/gamedog/vididin/manager/taskbeans/BaseTaskState.kt
@ -0,0 +1,14 @@
+package com.gamedog.vididin.manager.taskbeans
+
+import kotlinx.serialization.Serializable
+
+
+@Serializable
+abstract class BaseTaskState {
+    companion object {
+        const val STATE_ONGOING = 0
+        const val STATE_FINISH = 1
+        const val STATE_CLAIMED = 2
+        const val STATE_EXPIRED = 3
+    }
+}
--- a/app/src/main/java/com/gamedog/vididin/manager/taskbeans/TaskDailySignBean.kt
+++ b/app/src/main/java/com/gamedog/vididin/manager/taskbeans/TaskDailySignBean.kt
@ -1,22 +1,12 @@
-package com.gamedog.vididin.manager
+package com.gamedog.vididin.manager.taskbeans

 import java.io.Serializable


-
-
-data class DailySignBean(
-    var startMs: Long = 0,
+data class TaskDailySignBean(
+    var startDurationMs: Long = 0,
    val signStateList: MutableList<DailySignDayInfoBean> = mutableListOf()
-
-): Serializable {
-    companion object{
-        const val SIGN_STATE_ENABLE = 1
-        const val SIGN_STATE_DISABLE = 2
-        const val SIGN_STATE_DONE = 3
-        const val SIGN_STATE_FORGOT = 4
-    }
-
+): BaseTaskState() {
    init {
        signStateList.add(DailySignDayInfoBean())
        signStateList.add(DailySignDayInfoBean())
--- a/app/src/main/java/com/gamedog/vididin/manager/taskbeans/TaskStateBoxRoot.kt
+++ b/app/src/main/java/com/gamedog/vididin/manager/taskbeans/TaskStateBoxRoot.kt
@ -0,0 +1,37 @@
+package com.gamedog.vididin.manager.taskbeans
+
+import java.io.Serializable
+
+
+
+
+data class TaskStateBoxRoot(
+    val startMs: Long = 0,
+    val tasks: List<TaskStateBox>
+): Serializable
+
+data class TaskStateBox(
+    val chest_id: String,
+    val chest_name: String,
+    val duration_days: Int,
+    val reward_type: String,
+    val reward_value: Float,
+    val is_one_time: Boolean,
+    val status: String,
+    val tasks: List<TaskStateBoxSub>,
+
+    // new added
+    var hasClaimedReward: Boolean = false,
+): Serializable
+
+data class TaskStateBoxSub(
+    val task_id: String,
+    val task_name: String,
+    val required_count: Int,
+    val task_type: Int, // This added by self for decide which task should be execute, detail see: #TaskManager.companion
+
+    // new added
+    var finishedNum: Int = 0,
+): Serializable
+
+
--- a/app/src/main/java/com/gamedog/vididin/manager/taskbeans/TaskStateNewBieEnableNotify.kt
+++ b/app/src/main/java/com/gamedog/vididin/manager/taskbeans/TaskStateNewBieEnableNotify.kt
@ -0,0 +1,17 @@
+package com.gamedog.vididin.manager.taskbeans
+
+import java.io.Serializable
+
+
+
+
+data class TaskStateNewBieEnableNotify(
+    var rewardGoldNum: Int,
+    var hasClaimReward: Boolean = false,
+): Serializable {
+
+}
+
+
+
+
--- a/app/src/main/java/com/gamedog/vididin/manager/taskbeans/TaskStateNewBieFirstWithDraw.kt
+++ b/app/src/main/java/com/gamedog/vididin/manager/taskbeans/TaskStateNewBieFirstWithDraw.kt
@ -0,0 +1,17 @@
+package com.gamedog.vididin.manager.taskbeans
+
+import java.io.Serializable
+
+
+
+
+data class TaskStateNewBieFirstWithDraw(
+    var rewardGoldNum: Int,
+    var hasClaimReward: Boolean = false,
+): Serializable {
+
+}
+
+
+
+
--- a/app/src/main/java/com/gamedog/vididin/manager/taskbeans/TaskStateNewBieJoinDiscord.kt
+++ b/app/src/main/java/com/gamedog/vididin/manager/taskbeans/TaskStateNewBieJoinDiscord.kt
@ -0,0 +1,17 @@
+package com.gamedog.vididin.manager.taskbeans
+
+import java.io.Serializable
+
+
+
+
+data class TaskStateNewBieJoinDiscord(
+    var rewardGoldNum: Int,
+    var hasClaimReward: Boolean = false,
+): Serializable {
+
+}
+
+
+
+
--- a/app/src/main/java/com/gamedog/vididin/manager/taskbeans/TaskStateWatchAd.kt
+++ b/app/src/main/java/com/gamedog/vididin/manager/taskbeans/TaskStateWatchAd.kt
@ -0,0 +1,39 @@
+package com.gamedog.vididin.manager.taskbeans
+
+
+
+
+data class TaskStateWatchAd(
+    var todayMs: Long = 0,
+): BaseDailyTaskState() {
+    private var mWatchAdCount: Int = 0
+
+
+
+    override fun addWatchedCount(newWatchedNum: Int) {
+        if (newWatchedNum > 0) {
+            mWatchAdCount += newWatchedNum
+        }
+    }
+
+    override fun addWatchedVideoInfo(dataPair: Pair<String, Long>): Boolean {
+        return false
+    }
+
+    override fun getTodayWatchedCount(): Int {
+        return mWatchAdCount
+    }
+
+
+
+
+}
+
+
+
+
+
+
+
+
+
--- a/app/src/main/java/com/gamedog/vididin/manager/taskbeans/TaskStateWatchVideo.kt
+++ b/app/src/main/java/com/gamedog/vididin/manager/taskbeans/TaskStateWatchVideo.kt
@ -0,0 +1,31 @@
+package com.gamedog.vididin.manager.taskbeans
+
+
+import java.util.concurrent.ConcurrentHashMap
+
+
+data class TaskStateWatchVideo(
+    var todayMs: Long = 0,
+): BaseDailyTaskState() {
+
+    private val mWatchedMap = ConcurrentHashMap<String, Long>()
+
+    override fun addWatchedVideoInfo(dataPair: Pair<String, Long>): Boolean {
+        if (!mWatchedMap.contains(dataPair.first)) {
+            mWatchedMap.put(dataPair.first, dataPair.second)
+            return true
+        }
+        return false
+    }
+
+    override fun addWatchedCount(newWatchedNum: Int) {
+
+    }
+
+    override fun getTodayWatchedCount(): Int {
+        return mWatchedMap.size
+    }
+
+}
+
+
--- a/app/src/main/java/com/gamedog/vididin/netbase/ApiService.kt
+++ b/app/src/main/java/com/gamedog/vididin/netbase/ApiService.kt
@ -0,0 +1,36 @@
+package com.gamedog.vididin.netbase
+
+import okhttp3.ResponseBody
+import retrofit2.http.Body
+import retrofit2.http.FieldMap
+import retrofit2.http.FormUrlEncoded
+import retrofit2.http.GET
+import retrofit2.http.HeaderMap
+import retrofit2.http.POST
+import retrofit2.http.QueryMap
+import retrofit2.http.Url
+
+interface ApiService {
+
+    @GET
+    suspend fun getRequest(
+        @Url url: String,
+        @HeaderMap headers: Map<String, String> = emptyMap(),
+        @QueryMap params: Map<String, String> = emptyMap()
+    ): ResponseBody
+
+    @FormUrlEncoded
+    @POST
+    suspend fun postRequest(
+        @Url url: String,
+        @HeaderMap headers: Map<String, String> = emptyMap(),
+        @FieldMap params: Map<String, String> = emptyMap()
+    ): ResponseBody
+
+    @POST
+    suspend fun postJsonRequest(
+        @Url url: String,
+        @HeaderMap headers: Map<String, String> = emptyMap(),
+        @Body body: Any
+    ): ResponseBody
+}
--- a/app/src/main/java/com/gamedog/vididin/netbase/NetworkUtil.kt
+++ b/app/src/main/java/com/gamedog/vididin/netbase/NetworkUtil.kt
@ -0,0 +1,56 @@
+package com.gamedog.vididin.netbase
+
+import okhttp3.ResponseBody
+import java.io.IOException
+
+object NetworkUtil {
+
+    private val apiService: ApiService by lazy {
+        RetrofitUtil.getRetrofitInstance().create(ApiService::class.java)
+    }
+
+
+    suspend fun get(
+        url: String,
+        headers: Map<String, String> = emptyMap(),
+        params: Map<String, String> = emptyMap()
+    ): Result<ResponseBody> {
+        return executeRequest {
+            apiService.getRequest(url, headers, params)
+        }
+    }
+
+
+    suspend fun post(
+        url: String,
+        headers: Map<String, String> = emptyMap(),
+        params: Map<String, String> = emptyMap()
+    ): Result<ResponseBody> {
+        return executeRequest {
+            apiService.postRequest(url, headers, params)
+        }
+    }
+
+
+    suspend fun postJson(
+        url: String,
+        body: Any,
+        headers: Map<String, String> = emptyMap()
+    ): Result<ResponseBody> {
+        return executeRequest {
+            apiService.postJsonRequest(url, headers, body)
+        }
+    }
+
+
+    private suspend fun <T> executeRequest(requestBlock: suspend () -> T): Result<T> {
+        return try {
+            Result.Success(requestBlock())
+        } catch (e: IOException) {
+            Result.Error(e, "网络连接失败，请检查网络设置")
+        } catch (e: Exception) {
+            Result.Error(e, "未知错误: ${e.message}")
+        }
+    }
+
+}
--- a/app/src/main/java/com/gamedog/vididin/netbase/Result.kt
+++ b/app/src/main/java/com/gamedog/vididin/netbase/Result.kt
@ -0,0 +1,7 @@
+package com.gamedog.vididin.netbase
+
+sealed class Result<out T> {
+    data class Success<out T>(val data: T) : Result<T>()
+    data class Error(val exception: Throwable, val message: String = exception.message ?: "Unknown error") : Result<Nothing>()
+    object Loading : Result<Nothing>()
+}
--- a/app/src/main/java/com/gamedog/vididin/netbase/RetrofitUtil.kt
+++ b/app/src/main/java/com/gamedog/vididin/netbase/RetrofitUtil.kt
@ -0,0 +1,49 @@
+package com.gamedog.vididin.netbase
+
+import com.gamedog.vididin.VidiConst
+import com.gamedog.vididin.core.network.di.GlobalInterceptor
+import com.gamedog.vididin.core.network.di.GlobalInterceptor2
+import okhttp3.OkHttpClient
+import retrofit2.Retrofit
+import retrofit2.converter.gson.GsonConverterFactory
+import java.util.concurrent.TimeUnit
+
+object RetrofitUtil {
+
+    private var retrofit: Retrofit? = null
+    private const val DEFAULT_BASE_URL = VidiConst.URL_ZERO_BUY
+
+
+    fun getRetrofitInstance(baseUrl: String = DEFAULT_BASE_URL, headers: Map<String, String> = emptyMap()): Retrofit {
+        return retrofit ?: createRetrofit(baseUrl, headers).also { retrofit = it }
+    }
+
+    private fun createRetrofit(baseUrl: String, headers: Map<String, String>): Retrofit {
+        val okHttpClient = OkHttpClient.Builder().apply {
+            // add request custom head
+            if (headers.isNotEmpty()) {
+                addInterceptor { chain ->
+                    val originalRequest = chain.request()
+                    val requestBuilder = originalRequest.newBuilder()
+                    headers.forEach { (key, value) ->
+                        requestBuilder.addHeader(key, value)
+                    }
+                    chain.proceed(requestBuilder.build())
+                }
+            }
+
+            // TODO - only enable in debug mode
+            addInterceptor(GlobalInterceptor2())
+
+            connectTimeout(30, TimeUnit.SECONDS)
+            readTimeout(30, TimeUnit.SECONDS)
+            writeTimeout(30, TimeUnit.SECONDS)
+        }.build()
+
+        return Retrofit.Builder()
+            .baseUrl(baseUrl)
+            .client(okHttpClient)
+            .addConverterFactory(GsonConverterFactory.create())
+            .build()
+    }
+}
--- a/app/src/main/java/com/gamedog/vididin/request/RequestUtil.kt
+++ b/app/src/main/java/com/gamedog/vididin/request/RequestUtil.kt
@ -0,0 +1,32 @@
+package com.gamedog.vididin.request
+
+
+import com.ama.core.architecture.util.DeviceUtil
+import com.ama.core.architecture.util.MD5Util
+import com.gamedog.vididin.VidiConst
+
+class RequestUtil private constructor(){
+    companion object {
+        const val Request_APPId = "video1"
+        const val Request_Sceret = "secret1"
+
+        const val Request_ZeroBuy_APPId = "com.vididin.real.money.game"
+
+        fun getTimestampSec(): Long {
+            return System.currentTimeMillis()/1000
+        }
+
+        fun getRequestSign(timeSec: Long): String {
+            val signOrigin = "$Request_APPId-${timeSec}-$Request_Sceret"
+            return MD5Util.md5(signOrigin)?:""
+        }
+
+        // applicationId-timestamp-deviceId-operation-secret
+        fun getZeroBuyRequestSign(timeSec: Long, operation: Int): String {
+            var signOrigin = "${VidiConst.ZEROBUY_APPID}-${timeSec}-${DeviceUtil.generateDeviceId()}-$operation-${VidiConst.ZEROBUY_SECRET}"
+            return MD5Util.md5(signOrigin)?:""
+        }
+
+
+    }
+}
--- a/app/src/main/java/com/gamedog/vididin/router/Router.kt
+++ b/app/src/main/java/com/gamedog/vididin/router/Router.kt
@ -39,7 +39,11 @@ object Router : RouterContract {
        get() = routerEntryPoint.feedbackRouter()
    override val WithdrawRecord: IRouterWithdrawRecord
        get() = routerEntryPoint.withdrawRecordRouter()
+
    override val Splash: IRouterSplash
        get() = routerEntryPoint.splashRouter()
+
+    override val WatchAd: IRouterWatchAd
+        get() = routerEntryPoint.watchAdRouter()
 }

--- a/app/src/main/java/com/gamedog/vididin/router/RouterContract.kt
+++ b/app/src/main/java/com/gamedog/vididin/router/RouterContract.kt
@ -27,5 +27,7 @@ interface RouterContract {
    val Feedback: IRouterFeedback
    val WithdrawRecord: IRouterWithdrawRecord
    val Splash: IRouterSplash
+    val WatchAd: IRouterWatchAd
+

 }
--- a/app/src/main/java/com/gamedog/vididin/router/RouterDefault.kt
+++ b/app/src/main/java/com/gamedog/vididin/router/RouterDefault.kt
@ -5,6 +5,7 @@ import com.gamedog.vididin.features.feedback.FeedbackActivity
 import com.gamedog.vididin.features.privacy.PrivacyActivity
 import com.gamedog.vididin.features.splash.SplashActivity
 import com.gamedog.vididin.features.version.VersionActivity
+import com.gamedog.vididin.features.watchad.WatchAdActivity
 import com.gamedog.vididin.features.withdrawrecord.WithdrawRecordActivity


@ -38,3 +39,9 @@ class DefaultVersionRouter: IRouterVersion {
    }
 }

+
+class DefaultWatchAdRouter: IRouterWatchAd {
+    override fun startActivity(activity: Activity, taskType: Int, taskDataJson: String?) {
+        WatchAdActivity.Companion.startActivity(activity, taskType, taskDataJson)
+    }
+}
--- a/app/src/main/java/com/gamedog/vididin/router/RouterInterfaces.kt
+++ b/app/src/main/java/com/gamedog/vididin/router/RouterInterfaces.kt
@ -23,4 +23,8 @@ interface IRouterSplash {
    fun startActivity(activity: Activity)
 }

+interface IRouterWatchAd {
+    fun startActivity(activity: Activity, taskType: Int, taskDataJson: String?)
+}
+

--- a/app/src/main/java/com/gamedog/vididin/widget/DailySignItemView.kt
+++ b/app/src/main/java/com/gamedog/vididin/widget/DailySignItemView.kt
@ -10,7 +10,7 @@ import com.ama.core.architecture.util.ResUtil
 import com.gamedog.vididin.R
 import com.gamedog.vididin.databinding.DailySignItemBinding
 import com.gamedog.vididin.main.fragments.task.RewardDetail
-import com.gamedog.vididin.manager.DailySignDayInfoBean
+import com.gamedog.vididin.manager.taskbeans.DailySignDayInfoBean
 import kotlin.run

 class DailySignItemView @JvmOverloads constructor(
--- a/app/src/main/java/com/gamedog/vididin/widget/HomeDragIconView.kt
+++ b/app/src/main/java/com/gamedog/vididin/widget/HomeDragIconView.kt
@ -10,7 +10,6 @@ import android.view.LayoutInflater
 import android.widget.LinearLayout
 import androidx.core.view.isVisible
 import com.gamedog.vididin.databinding.LayoutDragIconViewBinding
-import com.gamedog.vididin.manager.TaskManager

 class HomeDragIconView @JvmOverloads constructor(
    context: Context,
@ -24,45 +23,36 @@ class HomeDragIconView @JvmOverloads constructor(
    init {
        mBinding = LayoutDragIconViewBinding.inflate(LayoutInflater.from(context), this, true)
        mBinding.run {
-            progressBar.setProgressListener { progress->
-                if (progress >= 100) {
-                    tvGoldNum.text = buildString {
-                        append("+")
-                        append(TaskManager.instance().getHomeWatchDurationRewardNum())
-                    }

-                    executeGoldNumAnim()
-                }
-            }
        }
    }


-    private fun executeGoldNumAnim() {
+    fun showRewardGoldAnim() {
        val animView = mBinding.llGoldRoot

        val alphaAnimator = ObjectAnimator.ofFloat(
            animView,
            "alpha",
-            0.5f, 1.0f, 0.5f
+            0.5f, 1.0f
        ).apply {
-            duration = 500
+            duration = 1500
        }

        val scaleXAnimator = ObjectAnimator.ofFloat(
            animView,
            "scaleX",
-            0.5f, 1.0f, 0.5f
+            0.5f, 1.1f, 1F
        ).apply {
-            duration = 500
+            duration = 1500
        }

        val scaleYAnimator = ObjectAnimator.ofFloat(
            animView,
            "scaleY",
-            0.5f, 1.0f, 0.5f
+            0.5f, 1.1f, 1F
        ).apply {
-            duration = 500
+            duration = 1500
        }


@ -70,13 +60,15 @@ class HomeDragIconView @JvmOverloads constructor(
        animatorSet.playTogether(alphaAnimator, scaleXAnimator, scaleYAnimator)
        animatorSet.addListener(object : Animator.AnimatorListener {
            override fun onAnimationCancel(animation: Animator) {
-                animView.isVisible = false
-                mBinding.progressBar.setProgress(0)
+                postDelayed({
+                    animView.visibility = INVISIBLE
+                }, 1000)
            }

            override fun onAnimationEnd(animation: Animator) {
-                animView.isVisible = false
-                mBinding.progressBar.setProgress(0)
+                postDelayed({
+                    animView.visibility = INVISIBLE
+                }, 1000)
            }

            override fun onAnimationRepeat(animation: Animator) {
@ -84,12 +76,18 @@ class HomeDragIconView @JvmOverloads constructor(
            }

            override fun onAnimationStart(animation: Animator) {
-
+                animView.isVisible = true
            }
        })
        animatorSet.start()
    }

+
+
+    fun setProgress(progress: Long) {
+        mBinding.progressBar.setProgress(progress.toInt())
+    }
+
 }


--- a/app/src/main/java/com/gamedog/vididin/youtubestatistic/RewardConst.kt
+++ b/app/src/main/java/com/gamedog/vididin/youtubestatistic/RewardConst.kt
@ -0,0 +1,10 @@
+package com.gamedog.vididin.youtubestatistic
+
+class RewardConst {
+    companion object {
+        const val HOME_WATCH_DURATION = 5 * 1000L
+        const val HOME_WATCH_REWARD_NUM = 28
+        const val FINISH_RATIO = 0.05F // TODO - temp value, should be 0.8F
+        const val Check_Interval_MS = 50L
+    }
+}
--- a/app/src/main/java/com/gamedog/vididin/youtubestatistic/TickerTimer.kt
+++ b/app/src/main/java/com/gamedog/vididin/youtubestatistic/TickerTimer.kt
@ -0,0 +1,200 @@
+package com.gamedog.vididin.youtubestatistic
+
+import android.os.Handler
+import android.os.Looper
+import com.ama.core.architecture.util.eventbus.NotifyMan
+import com.gamedog.vididin.VididinEvents
+import com.gamedog.vididin.youtubestatistic.RewardConst.Companion.Check_Interval_MS
+
+
+class TickerTimer() {
+
+    private var mTotalMs = 0L
+    private var mHasFinishCurVideo = false
+    private var mVideoId: String? = null
+    private var mVideoDurationMs: Long = 0
+
+
+    private val mCountHandler: Handler by lazy {
+        Handler(Looper.getMainLooper())
+    }
+    private val mCounterRunnable by lazy {
+        object : Runnable {
+            override fun run() {
+                if (isRunning) {
+                    handleNewTick()
+                    mCountHandler.postDelayed(this, Check_Interval_MS)
+                }
+            }
+        }
+    }
+
+    @Volatile
+    private var isRunning = false
+
+
+
+    fun setVideoInfo(videoId: String, videoDurationMs: Long) {
+        mVideoId = videoId
+        mVideoDurationMs = videoDurationMs
+    }
+
+    fun start() {
+        isRunning = true
+        mCountHandler.postDelayed(mCounterRunnable, Check_Interval_MS)
+    }
+
+
+    private fun handleNewTick() {
+        NotifyMan.instance().sendEvent(VididinEvents.Event_HOME_WATCH_Time_TICK, null)
+
+        if (!mHasFinishCurVideo && mVideoDurationMs > 0L) {
+            mTotalMs += Check_Interval_MS
+            if (mTotalMs >= RewardConst.FINISH_RATIO * mVideoDurationMs) {
+                mHasFinishCurVideo = true
+                NotifyMan.instance().sendEvent(VididinEvents.Event_Finish_One_Video,
+                    NotifyMan.NotifyData(Pair(mVideoId, System.currentTimeMillis())))
+            }
+        }
+    }
+
+    fun pause() {
+        if (!isRunning) return
+        isRunning = false
+        mCountHandler.removeCallbacks(mCounterRunnable)
+    }
+
+
+    fun release() {
+        isRunning = false
+        mCounterRunnable.let { mCountHandler.removeCallbacks(it) }
+    }
+
+
+
+
+    /*private var mStartMs = 0L
+    private var mTotalMs = 0L
+    private var mHasFinishCurVideo = false
+    private var mVideoId: String? = null
+    private var mVideoDurationMs: Long = 0
+
+
+    private val mCountHandler: Handler by lazy {
+        Handler(Looper.getMainLooper())
+    }
+    private val mCounterRunnable by lazy {
+        object : Runnable {
+            override fun run() {
+                if (isRunning) {
+                    if (mVideoDurationMs > 0L && mStartMs <= 0) {
+                        mStartMs = SystemClock.elapsedRealtime()
+                    }
+
+                    handleNewTick()
+                    mCountHandler.postDelayed(this, Check_Interval_MS)
+                }
+            }
+        }
+    }
+
+    @Volatile
+    private var isRunning = false
+
+
+
+    fun setVideoInfo(videoId: String, videoDurationMs: Long) {
+        mVideoId = videoId
+        mVideoDurationMs = videoDurationMs
+    }
+
+    fun start() {
+        isRunning = true
+        if (mVideoDurationMs > 0L && mStartMs <= 0) {
+            mStartMs = SystemClock.elapsedRealtime()
+        }
+        mCountHandler.postDelayed(mCounterRunnable, Check_Interval_MS)
+    }
+
+
+    private fun handleNewTick() {
+        NotifyMan.instance().sendEvent(VididinEvents.Event_HOME_WATCH_Time_TICK, null)
+
+        if (!mHasFinishCurVideo && mStartMs > 0L && mVideoDurationMs > 0L) {
+            mTotalMs += (SystemClock.elapsedRealtime() - mStartMs)
+            if (mTotalMs >= RewardConst.FINISH_RATIO * mVideoDurationMs) {
+                mHasFinishCurVideo = true
+                NotifyMan.instance().sendEvent(VididinEvents.Event_Finish_Video,
+                    NotifyMan.NotifyData(Pair(mVideoId, System.currentTimeMillis())))
+            }
+        }
+    }
+
+    fun pause() {
+        if (!isRunning) return
+        isRunning = false
+        mCountHandler.removeCallbacks(mCounterRunnable)
+        mStartMs = 0L
+    }
+
+
+    fun release() {
+        isRunning = false
+        mCounterRunnable.let { mCountHandler.removeCallbacks(it) }
+    }*/
+
+    /*
+    private val mHandlerThread = HandlerThread("HomeCountTimeThread")
+    private val mCountHandler: Handler by lazy {
+        Handler(mHandlerThread.looper)
+    }
+    private val mCounterRunnable by lazy {
+        object : Runnable {
+            override fun run() {
+                if (isRunning) {
+                    handleNewTick()
+                    mCountHandler.postDelayed(this, Notify_Interval_MS)
+                }
+            }
+        }
+    }
+
+    @Volatile
+    private var isRunning = false
+
+
+
+
+    companion object {
+        const val HOME_WATCH_DURATION = 5 * 1000L
+        const val Notify_Interval_MS = 50L
+    }
+
+    init {
+        mHandlerThread.start()
+    }
+
+
+    @Synchronized
+    fun start() {
+        isRunning = true
+        mCountHandler.postDelayed(mCounterRunnable, Notify_Interval_MS)
+    }
+
+
+    private fun handleNewTick() {
+        NotifyMan.instance().sendEvent(VididinEvents.Event_HOME_WATCH_Time_TICK, null)
+    }
+
+    fun pause() {
+        if (!isRunning) return
+        isRunning = false
+    }
+
+
+    fun release() {
+        isRunning = false
+        mCounterRunnable.let { mCountHandler.removeCallbacks(it) }
+        mHandlerThread.quitSafely()
+    }*/
+}
--- a/app/src/main/res/drawable/bg_cash_record_item_.xml
+++ b/app/src/main/res/drawable/bg_cash_record_item_.xml
@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape android:shape="rectangle"
+    xmlns:android="http://schemas.android.com/apk/res/android">
+    <stroke android:width="2dp" android:color="#fff2f2f2" />
+    <solid android:color="@color/red_e0" />
+    <corners android:topLeftRadius="15dp" android:topRightRadius="15dp" android:bottomLeftRadius="15dp" android:bottomRightRadius="15dp" />
+</shape>
+
--- a/app/src/main/res/drawable/bg_gold_record_item_.xml
+++ b/app/src/main/res/drawable/bg_gold_record_item_.xml
@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape android:shape="rectangle"
+    xmlns:android="http://schemas.android.com/apk/res/android">
+    <stroke android:width="2dp" android:color="#fff2f2f2" />
+    <solid android:color="@color/transparent" />
+    <corners android:topLeftRadius="15dp" android:topRightRadius="15dp" android:bottomLeftRadius="15dp" android:bottomRightRadius="15dp" />
+</shape>
+
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
renhaoting	68f1119b4a	Ui 调整赋值	2025-12-08 19:24:56 +08:00
renhaoting	a95b8b84e9	调整布局	2025-12-08 18:54:26 +08:00
renhaoting	2dc819f916	元素adapter	2025-12-08 18:51:37 +08:00
renhaoting	ce0d5084ba	保存userId	2025-12-08 18:26:52 +08:00
renhaoting	1988f2448c	接口接入	2025-12-08 18:12:28 +08:00
renhaoting	0f06e04a4e	一些基础util	2025-12-08 15:12:53 +08:00
renhaoting	3f10238136	ui美化+1	2025-12-05 19:25:12 +08:00
renhaoting	b7ca0babe5	ui美化	2025-12-05 19:08:40 +08:00
renhaoting	47020ca736	去掉临时测试数据	2025-12-05 15:52:55 +08:00
renhaoting	b143f6a67d	增加tab title 字体	2025-12-05 15:42:30 +08:00
renhaoting	f934dd66ae	item UI 美化+1	2025-12-05 15:36:49 +08:00
renhaoting	435faca163	item UI 美化	2025-12-05 15:31:45 +08:00
renhaoting	6dd6502c5a	记录UI 调整优化	2025-12-05 14:56:50 +08:00
renhaoting	09d74032a9	进度圈	2025-12-05 13:37:51 +08:00
renhaoting	fedae8b98f	遮罩层 + 历史frag UI	2025-12-05 11:53:16 +08:00
renhaoting	fb1c6011e0	去掉不必要ui	2025-12-04 18:16:10 +08:00
renhaoting	f4b10782f0	key 和 proguadr	2025-12-04 17:50:51 +08:00
renhaoting	b8d848e0bf	适配返回数据+1	2025-12-04 16:56:32 +08:00
renhaoting	2e2f37c586	适配返回数据	2025-12-04 16:44:30 +08:00
renhaoting	dc65bd0562	请求接口更换-1	2025-12-04 16:29:15 +08:00
renhaoting	6831cfa898	层次调整	2025-12-04 15:42:14 +08:00
renhaoting	9bf2e8fef0	0元购底部布局	2025-12-04 15:36:24 +08:00
renhaoting	4feda5f879	0元购子view	2025-12-04 15:22:58 +08:00
renhaoting	4c4500b895	按钮置灰	2025-12-04 14:59:38 +08:00
renhaoting	81ab5823ec	新手任务状态事件接入 updateUI	2025-12-04 14:56:33 +08:00
renhaoting	294100b146	新手任务状态UI 跟随更新	2025-12-04 14:34:02 +08:00
renhaoting	2b8b0fb38d	新手任务状态state类	2025-12-04 14:17:07 +08:00
renhaoting	9e2b880a32	媒体权限	2025-12-04 13:53:48 +08:00
renhaoting	57ae7ff4ff	game跳转	2025-12-04 11:58:41 +08:00
renhaoting	95742607a0	跳转到三方二页面	2025-12-04 11:53:09 +08:00
renhaoting	f2cbc14727	显示金币数量	2025-12-04 11:51:50 +08:00
renhaoting	47e4d3dba5	version act 赋值	2025-12-04 11:42:28 +08:00
renhaoting	abe2f0ab90	隐私act 加载web	2025-12-04 11:30:37 +08:00
renhaoting	3b0abf5235	box 奖励获取	2025-12-04 11:27:27 +08:00
renhaoting	9189b845ef	box跳转 / 事件	2025-12-04 11:02:00 +08:00
renhaoting	929a95ed9c	跳转到新手第一次体现	2025-12-04 10:39:31 +08:00
renhaoting	0991ab3993	首页展开折叠优化	2025-12-03 19:30:11 +08:00
renhaoting	4ff522f3cd	签到事件发送	2025-12-03 19:11:10 +08:00
renhaoting	a6c56d6539	完成UI 优化	2025-12-03 19:05:26 +08:00
renhaoting	d7be7c30cb	4个类型的操作完成event 注册处理	2025-12-03 18:55:26 +08:00
renhaoting	66bcd4eb51	aciton but 跳转	2025-12-03 18:21:11 +08:00
renhaoting	114f7befbc	总进度及金额读取	2025-12-03 17:54:48 +08:00
renhaoting	0bf9922be7	子任务根据state 刷新	2025-12-03 17:38:23 +08:00
renhaoting	e6c0220019	当前box 子任务views	2025-12-03 17:09:05 +08:00
renhaoting	ff0ee2d612	宝箱act 顶部UI刷新 +1	2025-12-03 16:55:30 +08:00
renhaoting	82ff8c5c51	宝箱act 顶部UI刷新	2025-12-03 16:39:52 +08:00
renhaoting	77d93b0211	sp宝箱statusbean 读取及初始化	2025-12-03 15:11:03 +08:00
renhaoting	3c081c230a	UI调整	2025-12-03 14:30:42 +08:00
renhaoting	e93d76f316	宝箱taskState 数据结构	2025-12-03 11:58:36 +08:00
renhaoting	483fa7e930	加入宝箱任务，并读取配置	2025-12-03 11:20:03 +08:00
renhaoting	ca1f3662b0	日期变化监听	2025-12-03 10:48:32 +08:00
renhaoting	460270212d	当个观看广告奖励200	2025-12-02 18:42:05 +08:00
renhaoting	ef8d084744	调整视频任务完成后金币获取为主动获取	2025-12-02 17:56:44 +08:00
renhaoting	797d1c01a9	抽取 dailyTask 基类	2025-12-02 16:56:56 +08:00
renhaoting	554eaf31a3	跳转	2025-12-02 16:43:06 +08:00
renhaoting	9d8fc70c10	整理代码	2025-12-02 16:33:14 +08:00
renhaoting	16efb504e3	阶梯广告 UI 及时更新	2025-12-02 16:04:08 +08:00
renhaoting	62db69b1d4	更改事件	2025-12-02 15:23:39 +08:00
renhaoting	93543545c5	修改获取金币逻辑为手动获取	2025-12-02 15:00:33 +08:00
renhaoting	32d201030d	观看ad UI监听及更新	2025-12-02 13:58:21 +08:00
renhaoting	6f650df200	观看ad 事件发送	2025-12-02 13:28:41 +08:00
renhaoting	0e034f340d	激励视频 UI显示更新	2025-12-02 11:44:48 +08:00
renhaoting	b07c1cf4ab	光看广告task	2025-12-02 11:21:42 +08:00
renhaoting	0b0805d6bc	金币转现金	2025-12-01 19:26:14 +08:00
renhaoting	da56a8cb42	调整广告页参数	2025-12-01 18:56:29 +08:00
renhaoting	97f9a39e95	初始时读取	2025-12-01 18:21:29 +08:00
renhaoting	a063466f15	保存最新每日watch状态	2025-12-01 18:09:19 +08:00
renhaoting	dc7ff87e33	更新观看完成一个视频后更新 UI	2025-12-01 17:24:01 +08:00
renhaoting	63d636ff1a	每日观看优化	2025-12-01 17:06:47 +08:00
renhaoting	1542db851e	从配置文件动态读取每日观看个数阶梯任务	2025-12-01 16:13:44 +08:00
renhaoting	f4aebf8e9c	每日观看个数 task bean	2025-12-01 15:38:11 +08:00
renhaoting	6ea2af01fe	新建其他bean 和 statusHelper	2025-12-01 15:11:53 +08:00
renhaoting	738b0b3ae9	优化taskmanager 结构+1	2025-12-01 14:46:11 +08:00
renhaoting	5fdf3a4ad9	优化taskmanager 结构	2025-12-01 12:00:18 +08:00
renhaoting	e00bf1da76	计算已看视频个数	2025-11-28 19:06:09 +08:00
renhaoting	f5162cb3a8	首页金币获取逻辑及UI	2025-11-28 18:07:11 +08:00
renhaoting	df87261b62	读取新手任务金币数量到UI	2025-11-28 15:16:42 +08:00
renhaoting	58b33b9399	跳转discord	2025-11-28 14:54:51 +08:00
renhaoting	8b37a63a4a	打开系统通知设置	2025-11-28 14:47:21 +08:00
renhaoting	cfe4acbb78	看广告act+1	2025-11-28 13:49:08 +08:00
renhaoting	a8ab37a17b	看广告act	2025-11-28 11:25:45 +08:00
renhaoting	86214129b6	title	2025-11-28 11:16:10 +08:00
renhaoting	fc7fd9d578	title	2025-11-28 11:14:21 +08:00
renhaoting	b099f4cd99	dialog中使用mActivty	2025-11-28 11:06:25 +08:00
renhaoting	9efe53bf0d	dialog中传递activity	2025-11-28 11:03:45 +08:00
renhaoting	cb1e475a83	失败activity	2025-11-28 10:39:13 +08:00
renhaoting	de9f003d26	提现成功实现	2025-11-27 19:23:11 +08:00
renhaoting	df332187d6	提现观看视频dialog-2	2025-11-27 19:01:39 +08:00
renhaoting	88c2d8cf34	提现观看视频dialog-1	2025-11-27 18:27:21 +08:00
renhaoting	3eb186063f	提现数值传递	2025-11-27 18:11:10 +08:00
renhaoting	5a15d7d997	体现信息确认dialog UI	2025-11-27 17:59:52 +08:00