SDK_UnityMoney/Assets/Script/SDKManager/AdjustManager/AdjustManager.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Threading.Tasks;
using AdjustSdk;
using ThinkingData.Analytics;
using UnityEngine;
using WZ;

public class AdjustManager : D_MonoSingleton<AdjustManager>
{
    private AdjustEnvironment environment = AdjustEnvironment.Production;
    
    private const string KEY_FIRST_INIT_ADJUST = "FIRST_INIT_ADJUST";
    private const string KEY_ADJUST_INIT_COUNT = "ADJUST_INIT_COUNT";
    
    private long startTime = 0;
    private string Adid;
    private string Gdid;
    private string callbackNetwork = "";
    bool m_start = false;
    private int callGetTimes = 0;
    private string _adjustNetwork = "_adjustNetwork";
    private string _adjustCampaign = "_adjustCampaign";
    private string _adjustAdgroup = "_adjustAdgroup";
    private string _adjustCreative = "_adjustCreative";
    private string _adjustClickLabel = "_adjustClickLabel";

    private int adjnitialization;
    private decimal conditionsCount;
    private decimal curConditionsCount = -1;
  
    

    /// <summary>
    /// 之前已经初始化过Adjust，之后启动游戏可以直接初始化
    /// </summary>
    public void GameStarInit()
    {
        string netWork = AdjustNetwork.GetNetwork();
        if (!string.IsNullOrEmpty(netWork))
        {
            LoggerUtils.Debug("归因信息有缓存，直接初始化");
            InitAdjust();
        }
    }

    public IEnumerator DelayInit()
    {
        int time = RushSDKManager.Instance.GetRemoteConfigInt("Adjust_Times", 30);
        if (conditionsCount > 0)
        {
            yield return new WaitForSeconds(time);
        }
      
        UpdateConditionsCount(AdjustInitTiming.OpenGameTime);
    }

    /// <summary>
    /// TODO:在查询订单状态成功后调用： AdjustManager.Instance.UpdateConditionsCount(AdjustInitTiming.COSuccessTime);
    /// </summary>
    public void UpdateConditionsCount(AdjustInitTiming timing, decimal count = 1)
    {
        //条件不匹配
        if(adjnitialization != (int)timing) return;
        //已经初始化过了
        if(startTime != 0) return;

        if (conditionsCount == 1 && timing != AdjustInitTiming.AdRevenue)
        {
            //初始化
            InitAdjust();
            return;
        }

        InitCurConditionsCount();
        //累计数量
        UpdateCurConditionsCount(count);
        LoggerUtils.Debug($"当前条件：{timing.ToString()}, 目标次数{conditionsCount}，当前次数{curConditionsCount}");
       
        if (curConditionsCount >= conditionsCount)
        {
            LoggerUtils.Debug("满足条件，初始化");
            InitAdjust();
        }
    }

   

    /// <summary>
    /// 初始化Adjust
    /// </summary>
    private void InitAdjust()
    {
        if (!CanInitAdjust())
        {
            LoggerUtils.Debug("Adjust_Geting在线参数不是1，不能初始化");
            return;
        }
        
        //开始计时
        startTime = TimeUtils.GetLocalTimestamp();
        Adjust.AddGlobalCallbackParameter("ta_distinct_id", TDAnalytics.GetDistinctId());

        Adjust.AddGlobalCallbackParameter("rush_version", RushSDKManager.GetSDKVersion());
        Adjust.AddGlobalPartnerParameter("rush_version", RushSDKManager.GetSDKVersion());

        AdjustConfig config = new AdjustConfig(StaticValue.AdjustToken, environment);

        // 设置归因变更回调函数
        config.AttributionChangedDelegate = AttributionChangedDelegate;

        // （可选）设置其他配置，如日志级别
        config.LogLevel = AdjustLogLevel.Verbose;

        // 初始化Adjust SDK
        LoggerUtils.Debug("Adjust初始化");
        Adjust.InitSdk(config);
       
        //id
        LoadAdid();
        LoadGaid();

        ShuShuEvent.Instance.Track("adjust_init");
        FireBaseAnalyticsManager.Instance.LogEvent("adjust_init");
        Adjust.GetAdid((id) =>
        {
            ShuShuEvent.Instance.SetSuperProperties(new Dictionary<string, object>() { { "adid", id } });
            ShuShuEvent.Instance.UserSet(new Dictionary<string, object>() { { "adid", id } });
        });

        var network = AdjustNetwork.GetNetwork();
        if (!string.IsNullOrEmpty(network))
        {
            RushSDKManager.Instance.OnUserSourceListener?.Invoke(IsOrganic(network), network);
        }
    }

    public void InitConfig()
    {
        adjnitialization = RushSDKManager.Instance.GetRemoteConfigInt("Adjinitialization", 0);

        if (adjnitialization == (int)AdjustInitTiming.ShowAdTime)
        {
            conditionsCount = RushSDKManager.Instance.GetRemoteConfigInt("SHOW_AD_NUM", 1);
        }
        else if (adjnitialization == (int)AdjustInitTiming.AdRevenue)
        {
            conditionsCount = (decimal)RushSDKManager.Instance.GetRemoteConfigFloat("SHOW_AD_REVENUE", 0.005f); 
        }
        else if (adjnitialization == (int)AdjustInitTiming.COSuccessTime)
        {
            conditionsCount = RushSDKManager.Instance.GetRemoteConfigInt("CASH_OUT_NUM", 1);
        }
        else
        {
            conditionsCount = 1;
        }
    }
    
    /// <summary>
    /// 归因信息
    /// </summary>
    /// <param name="attribution"></param>
    private void AttributionChangedDelegate(AdjustAttribution attribution)
    {
        Debug.Log("Attribution changed network: " + attribution.Network + " campaign: " + attribution.Campaign + " adgroup: " + attribution.Adgroup + " creative: " + attribution.Creative);
        if (m_start) return;
        m_start = true;
        callbackNetwork = attribution.Network;
        if (IsOrganic(attribution.Network) == false)
        {
            OnReceiveCallback(attribution);
            return;
        }
        InvokeRepeating(nameof(CallGetAttributionAsync), 0, 1);
    }

    private async Task CallGetAttributionAsync()
    {
        callGetTimes++;

        AdjustAttribution attribute = await GetAttributionAsync();
        LoggerUtils.Debug("[adjust] adjust CallGetAttribution callGetTimes : " + callGetTimes + " attinfo:" + attribute.Network + " clicklabel:" + attribute.ClickLabel);
        if (attribute != null)       
        {
            LoggerUtils.Debug("[adjust] adjust 重试次数 : " + callGetTimes + ", attribute : " + attribute.Network + ", callbackNetwork : " + callbackNetwork);
            if (attribute.Network.Equals(callbackNetwork) == false) 
            {
                CancelInvoke(nameof(CallGetAttributionAsync));
                OnReceiveCallback(attribute);
            }
        }

        if (callGetTimes >= 3*60)
        {
            if (attribute != null)
            {
                OnReceiveCallback(attribute);
            }
            else
            {
                OnReceiveCallback(null);
            }
            CancelInvoke(nameof(CallGetAttributionAsync));
        }
    }

    public static Task<AdjustAttribution> GetAttributionAsync()
    {
        var tcs = new TaskCompletionSource<AdjustAttribution>();

        Adjust.GetAttribution(attribution =>
        {
            try
            {
                tcs.TrySetResult(attribution);
            }
            catch (Exception ex)
            {
                tcs.TrySetException(ex);
            }
        });

        return tcs.Task;
    }

    private void OnReceiveCallback(AdjustAttribution attribution)
    {
        string campaign = "";
        string adgroup = "";
        string creative = "";
        string network = "";

        if (attribution != null)
        {
            campaign = attribution.Campaign;
            adgroup = attribution.Adgroup;
            creative = attribution.Creative;

            if (!string.IsNullOrEmpty(attribution.Network))
            {
                network = attribution.Network;
            }
            else
            {
                network = "Organic";
            }
        }
        else
        {
            network = "Organic";
        }

        AdjustNetwork.Instance.SetNetwork(attribution.Network);
        RushSDKManager.Instance.OnUserSourceListener?.Invoke(IsOrganic(network), network);
        PlayerPrefsUtils.SavePlayerPrefsString(_adjustNetwork, network);
        PlayerPrefsUtils.SavePlayerPrefsString(_adjustCampaign, campaign);
        PlayerPrefsUtils.SavePlayerPrefsString(_adjustAdgroup, adgroup);
        PlayerPrefsUtils.SavePlayerPrefsString(_adjustCreative, creative);
        PlayerPrefsUtils.SavePlayerPrefsString(_adjustClickLabel, attribution?.ClickLabel);
        ShuShuEvent.Instance.UserSet(new Dictionary<string, object>
        {
            { "user_ad_network", network ?? "" },
            { "user_campaign", campaign ?? "" },
            { "user_adgroup", adgroup ?? "" },
            { "user_creative", creative ?? "" },
        });

        RushSDKManager.Instance.SetSuperProperties(new Dictionary<string, object>
        {
            { "ad_network", network ?? "" },
            { "campaign", campaign ?? "" },
            { "adgroup", adgroup ?? "" },
            { "creative", creative ?? "" },
        });
        AdjustNetwork.Instance.LogEventGetSuccess();
    }

    public string GetAdjustNetwork()
    {
        return PlayerPrefsUtils.GetPlayerPrefsString(_adjustNetwork);
    }
    
    public string GetAdjustCampaign()
    {
        return PlayerPrefsUtils.GetPlayerPrefsString(_adjustCampaign);
    }

    public string GetAdjustAdgroup()
    {
        return PlayerPrefsUtils.GetPlayerPrefsString(_adjustAdgroup);
    }

    public string GetAdjustCreative()
    { 
        return PlayerPrefsUtils.GetPlayerPrefsString(_adjustCreative);
    }

    public string GetAdjustClickLabel()
    { 
        return PlayerPrefsUtils.GetPlayerPrefsString(_adjustClickLabel);
    }

    private bool IsOrganic(string _network)
    {
        if (string.IsNullOrEmpty(_network) || _network.Equals("Organic") || _network.Equals("Untrusted Devices"))
        {
            return true;
        }
        return false;
    }

    public long GetStartTime()
    {
        return startTime;
    }
    
    private void LoadGaid()
    {
        Adjust.GetGoogleAdId(googleAdId => {
            Gdid = googleAdId;
        });
    }
    
    public string GetGdid()
    {
        return Gdid;
    }
    
    private void LoadAdid()
    {
        Adjust.GetAdid(adid =>
        {
            Adid = adid;
        });
    }

    public string GetAdid()
    {
        return Adid;
    }

    private bool IsFirstInitAdjust()
    {
        return PlayerPrefsUtils.GetPlayerPrefsInt(KEY_FIRST_INIT_ADJUST, 0) == 0;
    }

    private void UpdateInitAdjustCount()
    {
        PlayerPrefsUtils.SavePlayerPrefsInt(KEY_FIRST_INIT_ADJUST, 1);
    }

    private bool CanInitAdjust()
    {
        //判断之前有没有初始化成功过
        string netWork = AdjustNetwork.GetNetwork();
        if (!string.IsNullOrEmpty(netWork))
        {
            return true;
        }
        
        //判断开关是不是1
        int adjustGeting = RushSDKManager.Instance.GetRemoteConfigInt("Adjust_Geting", 0);
        if (IsFirstInitAdjust())
        {
            UpdateInitAdjustCount();
           
        }
        return adjustGeting == 1;
    }
    
    private void InitCurConditionsCount()
    {
        if (curConditionsCount == -1)
        {
            string curConditionsCountStr = PlayerPrefsUtils.GetPlayerPrefsString(KEY_ADJUST_INIT_COUNT);
            curConditionsCount = string.IsNullOrEmpty(curConditionsCountStr) ? 0 : decimal.Parse(curConditionsCountStr);
        }
    }

    private void UpdateCurConditionsCount(decimal count)
    {
        curConditionsCount += count;
        PlayerPrefsUtils.SavePlayerPrefsString(KEY_ADJUST_INIT_COUNT, curConditionsCount.ToString(CultureInfo.InvariantCulture));
    }
}