#unity/白日梦/代码缓存 

```cs
#pragma warning disable 649  
using LightUI;  
using System;  
using System.Collections.Generic;  
using System.Linq;  
using ActivityModule.M.Events;  
using AnniversaryActivityModule.M.DataPool;  
using GameMessages;  
using LightUtility;  
using UnityEngine;  
using UIModule.M.UI;  
using UIModule.M.Events;  
using UnityEngine.UI;  
using DataModule.M;  
using EventsModule.M;  
using GLogic;  
  
namespace qiuqiuPrefabModule.M.UI  
{  
   public class UIqiuqiuPrefab : MonoBase  
   {  
      #region UI 节点 + 关联节点  (**不要手动添加定义，不要序列化字段** ) 当前 region 为格式化生成代码  
  
      [NonSerialized] private RectTransform m_RectTransExtra1;  
      [NonSerialized] private UnityEngine.UI.MixedScrollRect m_MixScrScrollView;  
      [NonSerialized] private UnityEngine.UI.MixedScrollInitializer m_MixScrInitScrollView;  
      [NonSerialized] private LightUI.UIDataScrollView m_DataScrollViewTop;  
      [NonSerialized] private LightUI.TextExt m_TxtText_Time;  
      [NonSerialized] private GameObject m_ObjRedPointOne;  
      [NonSerialized] private GameObject m_ObjRedPointTwo;  
  
      protected override void DoConnectComponent()  
      {         base.DoConnectComponent();  
  
         m_RectTransExtra1 = m_ComponentReferenceCtrl.GetComponentByIndex<RectTransform>(0);  
         m_MixScrScrollView = m_ComponentReferenceCtrl.GetComponentByIndex<UnityEngine.UI.MixedScrollRect>(1);  
         m_MixScrInitScrollView = m_ComponentReferenceCtrl.GetComponentByIndex<UnityEngine.UI.MixedScrollInitializer>(2);  
         m_DataScrollViewTop = m_ComponentReferenceCtrl.GetComponentByIndex<LightUI.UIDataScrollView>(3);  
         m_TxtText_Time = m_ComponentReferenceCtrl.GetComponentByIndex<LightUI.TextExt>(4);  
         m_ObjRedPointOne = m_ComponentReferenceCtrl.GetObjectByIndex(5);  
         m_ObjRedPointTwo = m_ComponentReferenceCtrl.GetObjectByIndex(6);  
      }  
  
      #endregion  
      #region 基类实现 Override  
      //这里主要是因为Xlua 修复子类没有 override 的方法需要在基类进行hotfix,所以子类默认都重写一下父类的方法方便hotfix  
      //默认 override 常用的几个接口  
  
      /// <summary>  
      /// 这里注册需要关心的事件，这个类由基类控制何时真正注册事件，不需要管何时取消监听(基类已经处理)  
      /// </summary>      protected override void DoRegisterEvent()  
      {         base.DoRegisterEvent();  
         EventListenerWrapper.AttachListener(MGlobalEventNode.Instance, (int) EActivityEventsKey.OnActivityLobbyRedPointChange, UpdateRedPointState, true);  
      }  
  
      public override void AwakeCallback()  
      {         base.AwakeCallback();         // RegisterButtonClickListener(Button, handler);  建议使用这种方式注册按钮点击事件，这样在OnDestroyed 时候会自动清理所有的点击事件监听  
      }  
  
      public override void EnableCallback()      {         base.EnableCallback();      }  
      public override void DisableCallback()      {         base.DisableCallback();      }  
      public override void DestroyCallback()      {         base.DestroyCallback();      }  
      public override void UpdateCallback()      {         base.UpdateCallback();      }  
      protected override void DoUIDataBinderDataChange(CommonDataCollection commonData)  
      {         base.DoUIDataBinderDataChange(commonData);  
         args = commonData;  
         m_activity = args["Activity"].val as Activity;  
                    
if (LocalPlayerDatabase.GetPrefValueInt("CommonTask_" + m_activity.activityId) != m_activity.startTime)  
         {            LocalPlayerDatabase.SetPrefValue("CommonTask_" + m_activity.activityId, m_activity.startTime);  
         }  
         EventTriggerController.TriggerOnActivityLobbyRedPointChange();  
                    
CreateItemsInfo();  
         InitTaskInfo();  
         SetTextInfo();  
         UpdateRedPointLogic();  
      }  
  
      #endregion  
      #region 界面显示逻辑处理  
   #endregion  
   #region 点击回调  
   #endregion  
   #region 事件回调  
   #endregion  
  
      #region 自定义GameObject  
  
      public GameObject m_ExchangeRedPoint;  
  
      #endregion        
      #region 内部数据  
      private CommonDataCollection args;  
        
      private static Dictionary<int,bool> m_RedPoint = new Dictionary<int, bool>();  
      private Dictionary<int, bool> m_tempTipsOpenData = new Dictionary<int, bool>();  
              
private HttpResponseExchangeActivityInfo m_HttpResponseExchangeActivityInfo;  
      private bool m_Inited;  
      private Activity m_activity;  
              
protected Action m_claimAction;  
      protected int m_TaskActivityParam;  
      private int m_lastRedPoint;//-1:false 0:未初始化 1:true      protected bool m_RefreshActivityLobbyRedPoint;  
      protected CommonDataCollection taskArg = new CommonDataCollection();  
      /// <summary>  
      /// 抽奖活动数据池  
      /// </summary>  
      private  MAnniversaryActivityDataPool m_MAnniversaryActivityDataPool => MDataMgr.Instance?.m_LobbyDataPool?.m_MAnniversaryActivityDataPool;  
  
      #endregion      /// <summary>  
      /// 显示时间文本  
      /// </summary>  
      void SetTextInfo()  
      {         if (m_TxtText_Time == null)  
            return;  
         m_TxtText_Time.text = string.Format(Localization.ActivityDuration,UITimeText.GetDateTime(m_activity.startTime),UITimeText.GetDateTime(m_activity.endTime));  
      }  
  
      #region 红点数据更新  
  
      protected virtual bool UpdateRedPointState(IGEvent baseEvent)  
      {         UpdateRedPointLogic();  
         return false;      }  
  
      private void UpdateRedPointLogic()  
      {         if (m_ObjRedPointOne != null)  
         {            m_ObjRedPointOne.FastSetActive(GetRedPoint(m_activity.activityId));  
         }  
  
         if (m_ObjRedPointTwo != null)  
         {            m_ObjRedPointTwo.FastSetActive(CommonTaskUI.GetRedPoint(m_activity.activityId));  
            // m_ObjRedPointTwo.FastSetActive(m_MAnniversaryActivityDataPool.LotteryRedPointState.GetLotteryRedPointState(m_activity.activityId));  
         }  
      }  
      #endregion  
  
  
      #region 奖品逻辑  
      void CreateItemsInfo()  
      {  
         HttpRequestExchangeActivityInfo msg = new HttpRequestExchangeActivityInfo();  
         msg.activityId = m_activity.activityId;  
         GameHttpManager.Inst.Send(msg, OnHttpResponse =>  
         {  
            m_HttpResponseExchangeActivityInfo = OnHttpResponse;  
            SetItemsInfo(OnHttpResponse);  
         }, null, null, LocalPlayerDatabase.DummyWait);  
      }  
        
       void SetItemsInfo(HttpResponseExchangeActivityInfo response)  
       {           bool oldRedPointState = GetRedPoint(m_activity.activityId);  
           CommonDataCollection arg = new CommonDataCollection();  
           Dictionary<int,ExchangeActivityInfo> topItems = new Dictionary<int,ExchangeActivityInfo>();  
           Dictionary<int,ExchangeActivityInfo> notComplete = new Dictionary<int,ExchangeActivityInfo>();  
           Dictionary<int,ExchangeActivityInfo> complete = new Dictionary<int,ExchangeActivityInfo>();  
           bool redPoint = false;  
           for (int i = 0; i < response.ids.Length; i++)  
           {               //info当表配错漏了一个id时,如果使用get还是会new一个出来,info不会空  
               ExchangeActivityInfo info = LocalResources.ExchangeActivityInfo.Find(response.ids[i]);  
               if (info == null)  
               {                   if (GLog.IsLogErrorEnabled)GLog.LogError(  
                       "CommonExchangeUI.Bind: ExchangeActivityInfoResponse id can't find in ExchangeActivityTable,id="+response.ids[i]);  
               }  
               else  
               {  
                   if (response.exchangeTimes[i] < info.Limit)  
                   {                       if (info.Rank == 0)  
                       {                           topItems.Add(i,info);  
                       }  
                       else  
                       {  
                           notComplete.Add(i,info);  
                       }  
                       bool tipOpen = false;  
                       if (!HaveLocalTipsOpenData(response.ids[i], out tipOpen))  
                       {                           tipOpen = response.tipsOpen[i];  
                       }  
                       if (!redPoint && tipOpen && CheckEnough(info))  
                       {                           redPoint = true;  
                       }  
                   }                   else  
                   {  
                       if (info.Rank == 0)  
                       {                           topItems.Add(i,info);  
                       }  
                       else  
                       {  
                           complete.Add(i,info);  
                       }  
                   }               }           }           WrapperData(topItems, response, ref arg);  
           WrapperData(notComplete, response, ref arg);  
           WrapperData(complete, response, ref arg);  
           m_MixScrInitScrollView.Args = arg;  
           if (m_MixScrScrollView != null)  
           {               try  
               {  
                   if (m_Inited)  
                   {                      m_MixScrScrollView.Refresh();  
                   }  
                   else  
                   {  
                      m_MixScrScrollView.Init();  
                   }  
               }               catch (Exception e)  
               {                   if (GLog.IsLogErrorEnabled) GLog.LogError($"CommonExchangeUI SetItemsInfo m_MixedScrollRect == null. ex:{e}");  
               }  
           }           else  
           {  
               if (GLog.IsLogErrorEnabled) GLog.LogError($"CommonExchangeUI SetItemsInfo m_MixedScrollRect == null. this:{this == null}");  
           }  
  
           m_Inited = true;  
           if (redPoint != oldRedPointState)  
           {               RefreshRedPoint(m_activity.activityId, redPoint);  
           }  
           if(m_ExchangeRedPoint)  
               m_ExchangeRedPoint.FastSetActive(redPoint);  
       }  
      void WrapperData(Dictionary<int,ExchangeActivityInfo> date, HttpResponseExchangeActivityInfo OnHttpResponse,ref CommonDataCollection arg)  
      {         date = date.OrderBy(k => k.Value.Rank).ToDictionary(k => k.Key, v => v.Value);  
         foreach (KeyValuePair<int, ExchangeActivityInfo> item in date)  
         {            int arraySize = arg.ArraySize;  
            arg[arraySize]["info"].val = item.Value;  
            arg[arraySize]["activityId"] = m_activity.activityId;  
            arg[arraySize]["exchangeTime"] = OnHttpResponse.exchangeTimes[item.Key];  
            arg[arraySize]["tipsOpen"] = OnHttpResponse.tipsOpen[item.Key];  
            arg[arraySize]["CommonExchangeUI"].val = this;  
         }  
      }      public static void RefreshRedPoint(int activityId,bool state = true)  
      {  
         bool redPointState = false;  
         if (!m_RedPoint.TryGetValue(activityId,out redPointState))  
         {            m_RedPoint.Add(activityId,state);  
         }  
         else  
         {  
            m_RedPoint[activityId] = state;  
         }  
         // if (m_RedPoint.ContainsKey(activityId))  
         // {         //     m_RedPoint[activityId] = state;         // }         // else         // {         //     m_RedPoint.Add(activityId,state);         // }  
         ActivityLobby.InvokeActivityLobbyRedPointChange();  
      }  
      public static bool GetRedPoint(int activityId)  
      {         Activity activity = ActivityLobby.GetActivityById(activityId);  
         if (activity == null)  
         {            return false;  
         }  
         if (activity.endTime<UtcTimeStamp.Now)  
         {            return false;  
         }  
  
         bool keyBool;  
  
         if (m_RedPoint.TryGetValue(activityId,out keyBool))  
         {            return keyBool;  
         }  
  
         // if (m_RedPoint.ContainsKey(activityId))  
         // {         //     return m_RedPoint[activityId];         // }         return false;  
      }  
      public bool HaveLocalTipsOpenData(int id,out bool state)  
      {         state = false;  
         return m_tempTipsOpenData.TryGetValue(id, out state);  
      }  
      public void OnTipsOpenToggleChange(int id,bool state)  
      {         if (m_tempTipsOpenData.ContainsKey(id))  
         {            m_tempTipsOpenData[id] = state;  
         }  
         else  
         {  
            m_tempTipsOpenData.Add(id,state);  
         }  
  
         if (m_HttpResponseExchangeActivityInfo != null)  
         {            bool oldRedPointState = GetRedPoint(m_activity.activityId);  
            bool redpoint = false;  
            for (int i = 0; i < m_HttpResponseExchangeActivityInfo.ids.Length; i++)  
            {               ExchangeActivityInfo info = LocalResources.ExchangeActivityInfo.Get(m_HttpResponseExchangeActivityInfo.ids[i]);  
               if (!redpoint&&m_HttpResponseExchangeActivityInfo.exchangeTimes[i] < info.Limit)  
               {                  bool tipsOpen = m_HttpResponseExchangeActivityInfo.tipsOpen[i];  
                  if(m_tempTipsOpenData.ContainsKey((m_HttpResponseExchangeActivityInfo.ids[i])))  
                  {                     tipsOpen = m_tempTipsOpenData[m_HttpResponseExchangeActivityInfo.ids[i]];  
                  }  
                  if (tipsOpen && CheckEnough(info))  
                  {                     redpoint = true;  
                  }  
               }            }            if (oldRedPointState != redpoint)  
            {               RefreshRedPoint(m_activity.activityId, redpoint);  
            }  
            if(m_ExchangeRedPoint)  
               m_ExchangeRedPoint.FastSetActive(redpoint);  
         }  
      }      public static bool CheckEnough(ExchangeActivityInfo info)  
      {         for (int i = 0; i < info.NeedIds.Length; i++)  
         {            if (ShopUtility.GetCurrencyAmount(info.NeedIds[i]) < info.NeedCounts[i])  
            {               return false;  
            }  
         }         return true;  
      }  
      #endregion  
  
      #region  任务逻辑  
  
      /// <summary>  
      /// 初始化任务信息  
      /// </summary>  
      void InitTaskInfo()  
      {         if (m_activity == null)  
         {            return;  
         }  
  
         m_claimAction = args["TaskClaimAction"].val as Action;  
         m_TaskActivityParam = args["Param"];  
         m_RefreshActivityLobbyRedPoint = args.ContainsKey("RefreshActivityLobbyRedPoint");  
                    
SetTaskInfo(m_activity, TaskUtility.GetTask(m_activity.activityId, m_TaskActivityParam));  
  
      }  
  
      protected virtual void SetTaskInfo(Activity activity, ActivityTaskData taskData)  
      {         taskArg.Clear();  
         if (taskData == null)  
            return;  
         List<int> completedIndexs = new List<int>();  
         List<int> receivedIndexs = new List<int>();  
         List<int> notcompletedIndexs = new List<int>();  
  
         for (int i = 0; i < taskData.taskIds.Length; i++)  
         {            if (taskData.received[i])  
            {               receivedIndexs.Add(i);  
            }  
            else  
            {  
               TaskActivityInfo info = LocalResources.TaskActivityInfo.Get(taskData.taskIds[i]);  
               if (taskData.progress[i] >= info.Condition)  
               {                  completedIndexs.Add(i);  
               }  
               else  
               {  
                  notcompletedIndexs.Add(i);  
               }  
            }         }         WrappeTaskData(completedIndexs, taskData,taskArg);  
         WrappeTaskData(notcompletedIndexs, taskData,taskArg);  
         WrappeTaskData(receivedIndexs, taskData,taskArg);  
  
         SetTaskArgs();  
         if (m_RefreshActivityLobbyRedPoint)  
         {            UpdateTaskRedPoint();  
         }  
      }        
      protected virtual void WrappeTaskData(List<int> indexs, ActivityTaskData taskData,CommonDataCollection arg)  
      {         indexs = indexs.OrderBy(x => LocalResources.TaskActivityInfo.Get(taskData.taskIds[x]).Rank).ToList();  
         foreach (int index in indexs)  
         {            int arraySize = arg.ArraySize;  
            arg[arraySize]["Activity"].val = m_activity;  
            arg[arraySize]["taskId"] = taskData.taskIds[index];  
            arg[arraySize]["progress"] = taskData.progress[index];  
            arg[arraySize]["received"] = taskData.received[index];  
            arg[arraySize]["receivedPro"] = taskData.receivedPro[index];  
            arg[arraySize]["index"] = arraySize;  
            arg[arraySize]["TaskActivityUI"].val = this;  
            arg [arraySize] ["stringParam"] = m_TaskActivityParam == 0 ?   
               GetTitle (LocalResources.TaskActivityInfo.Get(taskData.taskIds[index]).TaskParam) : GetTitle (m_TaskActivityParam);  
         }  
               }  
      public string GetTitle(int type)  
      {         switch ((PassTaskType)type)  
         {            case PassTaskType.Week1:  
               return string.Format(Localization.PassTaskTitle_Week, 1);  
            case PassTaskType.Week2:  
               return string.Format(Localization.PassTaskTitle_Week, 2);  
            case PassTaskType.Week3:  
               return string.Format(Localization.PassTaskTitle_Week, 3);  
            case PassTaskType.Week4:  
               return string.Format(Localization.PassTaskTitle_Week, 4);  
            case PassTaskType.Week5:  
               return string.Format(Localization.PassTaskTitle_Week, 5);  
            case PassTaskType.Week6:  
               return string.Format(Localization.PassTaskTitle_Week, 6);  
            case PassTaskType.Week7:  
               return string.Format(Localization.PassTaskTitle_Week, 7);  
            case PassTaskType.Week8:  
               return string.Format(Localization.PassTaskTitle_Week, 8);  
            case PassTaskType.Week9:  
               return string.Format(Localization.PassTaskTitle_Week, 9);  
            case PassTaskType.Week10:  
               return string.Format(Localization.PassTaskTitle_Week, 10);  
            case PassTaskType.TimeChallenge:  
               return Localization.PassTaskTitle_TimeChallenge;  
            case PassTaskType.ActiveChallenge:  
               return Localization.PassTaskTitle_ActiveChallenge;  
            case PassTaskType.SpeedUpChallenge:  
               return Localization.PassTaskTitle_SpeedUpChallenge;  
         }  
  
         return "";  
      }  
      protected void UpdateTaskRedPoint()  
      {         bool redPoint = TaskUtility.CanReceiveTaskReward(m_activity.activityId);  
         if (m_lastRedPoint!=0)  
         {            bool _lastRedPoint = m_lastRedPoint > 0;  
            if (_lastRedPoint != redPoint)  
            {               EventTriggerController.TriggerOnActivityLobbyRedPointChange();  
            }  
         }         m_lastRedPoint = redPoint ? 1 : -1;  
      }  
      /// <summary>  
      /// 设置任务滚动列表参数  
      /// </summary>  
      protected virtual void SetTaskArgs()  
      {         if (m_DataScrollViewTop != null)  
         {            m_DataScrollViewTop.SetItems(taskArg.Array);  
         }  
      }  
  
  
      #endregion  
              
        
}  
}
```