Athana SDK

For Games

Unity 集成

安装插件

  • 方式一：本地 UnityPackage 安装
  • 方式二：通过 Git URL 安装
    • 打开 Package Manager (Window -> Package Manger)
    • 点击左上角 + 图标，选择：Install Package form git URL
    • 输入：https://github.com/AthanaSDK/athana_unity_plugin.git

集成配置

Android

AGP - Android Gradle Plugin，是 Android Studio 项目构建环节的必要部分

AGP 与 Gradle 版本兼容表

AGP 与 Android Studio 版本兼容表

AGP 与 Android Level 版本兼容表

AGP 与 Kotlin 版本兼容表

AGP 与 Athana SDK 版本兼容表

Athana SDK Version AGP Version Gradle Version Kotlin Version
1.0.0 8.11 8.14 2.0.21
1.5.0 9.1 9.3.1 2.3.20

  1. 确认 Edit -> Project Settings -> Player -> Settings for Android -> Publishing Settings -> Build 中，勾选：

    • Custom Launcher Gradle Template
    • Custom Base Gradle Template

  2. 编辑 ${UNITY_PROJEECT}\Assets\Plugins\Android\baseProjectTemplate.gradle

1
2
3
4
5
6
7
8
9
10
11
12
13
plugins {
    ...

    // （可选）如果 AGP 版本低于 9.0，则需要补充以下插件
    id "org.jetbrains.kotlin.android"  version "2.0.21" apply false
    // （必须）插入插件声明↓
    id "com.google.gms.google-services" version "4.4.4" apply false
    id "com.google.firebase.crashlytics" version "3.0.6" apply false
    
    **BUILD_SCRIPT_DEPS**
}

...
  1. 编辑 ${UNITY_PROJEECT}\Assets\Plugins\Android\launcherTemplate.gradle
1
2
3
4
5
6
7
apply plugin: 'com.android.application'
// （可选）如果 AGP 版本低于 9.0，则需要补充以下插件
apply plugin: 'org.jetbrains.kotlin.android'
// （必须）插入插件声明↓
apply from: 'athana_options.gradle'

...
  1. 进入配置面板（Unity Editor -> Assets -> Athana -> Sdk Configuration），填选数据

iOS

SwiftPM

导出工程后，打开 {UNITY_EXPORT_XCODE_PROJEECT}/Unity-iPhone.xcworkspace 工作空间

  1. 引入依赖库，在 project 中找到 Package Dependencies，然后在 Packages 中点击 + ，在右上角搜索框输入 https://github.com/AthanaSDK/Athana-SDK-iOS.git 添加仓库，目标 Library 需要选 UnityFramework
    • AthanaCore - 必要依赖库
    • AthanaSdk - 必要依赖库
    • AthanaAdaptersApple - 可选，使用三方登录服务则必要
    • AthanaAdaptersAppLovin - 可选，使用广告服务则必要
    • AthanaAdaptersAppsFlyer - 必要依赖库
    • AthanaAdaptersFirebase - 必要依赖库
    • AthanaAdaptersGoogle - 可选，使用三方登录服务则必要
    • AthanaAdaptersGameCenter - 可选，使用三方登录服务或游戏中心服务则必要
    • AthanaAdaptersMeta - 必要依赖库
  2. 引入三方依赖库，目标 Library 需要选 Unity-iPhone：

CocoaPods

Signing & Capabilities 配置

  • 添加 User Tracking
    • 包含广告模块，则 value 可以参考：This identifier will be used to deliver personalized ads to you.
    • 不包含广告模块，则可参考：Your data will be used to analyze your gaming preferences, helping us provide better level recommendations and personalized content.
  • 添加 Associated Domains（可选，需要使用 Web to App 投放方式的时候需要添加）
  • 添加 GameKit Friend List（可选，需要使用游戏中心好友功能则进行添加）
    • value 可以参考：Accessing your friend list lets you see your friends' scores and rankings, allowing you to compete with them on the leaderboards.

初始化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
using Athana;
using Athana.Callbacks;
using Athana.Api;
using static Athana.Api.AthanaInterface;
using static Athana.Callbacks.AthanaCallbacks;

public class MainSceneController : MonoBehaviour
{
    void Start()
    {
        ...
        InitAthanaSdk()
        ...
        // 在合适的时机(隐私政策确认后、用户注册账户时)，启动 Athana
        AthanaSdk.Start(false);
    }

    private void InitAthanaSdk()
    {
        long appId = 00000000000;
        string appKey = "******************";
        string appSecret = "*****************************";

        // 三方SDK配置
        string appsFlyerDevKey = "******************";
        string maxDevKey = "******************";
        string googleWebClintId = "******************";
        
        // 如果需要开启调试或内购测试模式，请开启对应参数
        bool testMode = false; // 内购测试模式
        bool debug = false; // 调试模式

        // 如果需要进行预加载，则添加相应配置
        var preloadAds = new Dictionary<AdType, string>() {
            { AdType.AppOpen, "******************" },
            { AdType.Rewarded, "******************" },
            { AdType.Interstitial, "******************" },
        };
        
        AthanaSdk.Initialize(appId, appKey, appSecret, testMode: testMode, debug: debug, serviceConfig: new()
        {
            // 按需选择服务配置：
            // 三方登录配置（可选）
            AccountConfig = new()
            {
                googleWebClientId = googleWebClintId,
            },
            // 广告配置（可选）
            AdServiceConfigs = new()
            {
                // AppLovin MAX 配置
                max = new()
                {
                    sdkKey = maxDevKey,
                    debug = debug, // 是否开启 MAX 的调试日志
                    preloadAds = AthanaUtils.preloadAds2String(preloadAds)
                }
            },
            // 归因配置（可选）
            ConversionServiceConfigs = new()
            {
                // AppsFlyer 配置
                appsflyer = new()
                {
                    sdkKey = appsFlyerDevKey,
                }
            }
        });

    }
}

功能调用

  • 对于没有后端、账户体系的游戏，在 SDK 初始化后，需要走 注册平台账户 流程；
  • 对于有账户体系的游戏，在 SDK 初始化后，可参照以下流程：
    • 通过Athana.CurrentUser()查询当前是否有登录账户
    • 如果没有则可：注册游客账户 或 跳转至登录方式选择页面
    • 在通过新手教程后，引导用户绑定三方账号
    • 查询当前账户的三方登录绑定状态：``

注册平台账户

适用于无账户体系的游戏

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
using Athana;
using Athana.Callbacks;
using Athana.Api;
using static Athana.Api.AthanaInterface;
using static Athana.Callbacks.AthanaCallbacks;

private Action<SdkCallback<AccountInfo?>>? onCurrentUserResult;
private Action<SdkCallback<AccountInfo>>? onRegistryUserResult;

// 判断当前注册状态
public void CurrentUser()
{
    if (onCurrentUserResult == null)
    {
        onCurrentUserResult = (SdkCallback<AthanaInterface.AccountInfo?> result) =>
        {
            if (result.isSuccess())
            {
                var data = result.data;
                if (data == null)
                {
                    // 未登录或凭证失效
                    RegistryUser()
                }
                else
                {
                    // 已登录
                    // 进入游戏
                }
            }
            else
            {
                // 调用失败
                Debug.Log("Failed to get current user. error: " + result.error?.msg);
            }
        };
        AthanaCallbacks.OnCurrentUserResult += onCurrentUserResult;
    }
    
    AthanaSdk.CurrentUser();
}

// 注册用户
public void RegistryUser()
{
    if (onRegistryUserResult == null)
    {
        onRegistryUserResult = (SdkCallback<AthanaInterface.AccountInfo> result) =>
        {
            if (result.isSuccess())
            {
                var data = result.data;
                // 用户注册成功
                Debug.Log("User(" + data.userId + ") register is successed.");
            }
            else
            {
                // 调用失败
                Debug.Log("Failed to register user. error: " + result.error?.msg);
            }

        };
        AthanaCallbacks.OnRegistryUserResult += onRegistryUserResult;
    }
    var extra = new Dictionary<string, object>();
    AthanaSdk.RegistryUser(extra: extra);
}

三方登录

适用于有账户体系的游戏

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
using Athana;
using Athana.Callbacks;
using Athana.Api;
using static Athana.Api.AthanaInterface;
using static Athana.Callbacks.AthanaCallbacks;

private Action<SdkCallback<AccountInfo>>? onSignInResult;
private Action<SdkCallback<AccountInfo>>? onSignInWithUIResult;

// 选择指定登录方式
public void SignIn(AthanaInterface.SignInType type)
{
    if (onSignInResult == null)
    {
        onSignInResult = (SdkCallback<AthanaInterface.AccountInfo> result) =>
        {
            if (result.isSuccess())
            {
                var data = result.data;
                Debug.Log("User(" + data.userId + ") Sign-In is successed.");
                // 登录成功
            }
            else
            {
                Debug.Log("SignIn is failure. error: " + result.error?.msg);
                // 调用失败
            }

        };
        AthanaCallbacks.OnSignInResult += onSignInResult;
    }

    AthanaSdk.SignIn(signInType: type);
}

// 使用内置登录界面
public void SignInWithUI()
{
    if (onSignInWithUIResult == null)
    {
        onSignInWithUIResult = (SdkCallback<AthanaInterface.AccountInfo> result) =>
        {
            if (result.isSuccess())
            {
                var data = result.data;
                Debug.Log("User(" + data.userId + ") Sign-In is successed.");
                // 登录成功
            }
            else
            {
                Debug.Log("SignIn is failure. error: " + result.error?.msg);
                // 调用失败
            }

        };
        AthanaCallbacks.OnSignInWithUIResult += onSignInWithUIResult;
    }

    AthanaSdk.SignInWithUI();
}

三方账号绑定

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
using Athana;
using Athana.Callbacks;
using Athana.Api;
using static Athana.Api.AthanaInterface;
using static Athana.Callbacks.AthanaCallbacks;

private Action<SdkCallback<object?>>? onAccountBindingResult;
private Action<SdkCallback<object?>>? onAccountUnbindResult;
private Action<SdkCallback<TriAccountBindMap>>? onQueryAllAccountBindResult;

public void AccountBinding(SignInType signType)
{
    if (onAccountBindingResult == null)
    {
        onAccountBindingResult = (SdkCallback<object?> result) =>
        {
            if (result.isSuccess())
            {
                Debug.Log("Account Binding is successed.");
            }
            else
            {
                Debug.Log("Account Binding is failure.");
                Debug.Log("Account Binding is failure. error: " + result.error?.msg);
            }
        };
        AthanaCallbacks.OnAccountBindingResult += onAccountBindingResult;
    }

    AthanaSdk.AccountBinding(signInType: signType);
}

三方账号解绑

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
using Athana;
using Athana.Callbacks;
using Athana.Api;
using static Athana.Api.AthanaInterface;
using static Athana.Callbacks.AthanaCallbacks;

private Action<SdkCallback<object?>>? onAccountUnbindResult;

public void AccountUnbind(SignInType signType, TriAccount tri)
{
    if (onAccountUnbindResult == null)
    {
        onAccountUnbindResult = (SdkCallback<object?> result) =>
        {
            if (result.isSuccess())
            {
                Debug.Log("Account Unbind is successed.");
            }
            else
            {
                Debug.Log("Account Unbind is failure. error: " + result.error?.msg);
            }
        };
        AthanaCallbacks.OnAccountUnbindResult += onAccountUnbindResult;
    }

    AthanaSdk.AccountUnbind(signType, OpenId);
}

查询三方绑定状态

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
using Athana;
using Athana.Callbacks;
using Athana.Api;
using static Athana.Api.AthanaInterface;
using static Athana.Callbacks.AthanaCallbacks;

private Action<SdkCallback<TriAccountBindMap>>? onQueryAllAccountBindResult;

private TriAccountBindMap? BindResults;

public void QueryAllAccountBind()
{
    if (onQueryAllAccountBindResult == null)
    {
        onQueryAllAccountBindResult = (SdkCallback<TriAccountBindMap> result) =>
        {
            if (result.isSuccess())
            {
                BindResults = result.data;
                // TriAccountBindMap.Facebook 返回 null 表示未绑定 Facebook
                // TriAccountBindMap.Apple 返回 null 表示未绑定 Apple
                // TriAccountBindMap.Google 返回 null 表示未绑定 Google
                // TriAccountBindMap.GoogleGameV2 返回 null 表示未绑定 Google Play Game
                Debug.Log("Query Account Bind is successed.");
            }
            else
            {
                Debug.Log("Query Account Bind is failure. error: " + result.error?.msg);
            }
        };
        AthanaCallbacks.OnQueryAllAccountBindResult += onQueryAllAccountBindResult;
    }

    AthanaSdk.QueryAllAccountBind();
}

广告

广告适配器需要额外手动集成，详见：

注意：Athana SDK for Android 版本 1.4.6 及以下版本，只兼容 com.applovin.mediation:google-adapter:24.8.0.0，在添加广告源适配器时，google-adapter 的版本请勿使用 +

启动广告

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
using Athana;
using Athana.Callbacks;
using Athana.Api;
using static Athana.Api.AthanaInterface;
using static Athana.Callbacks.AthanaCallbacks;

private Action<ProxyAd>? onAdLoadedEvent = null;
private Action<ProxyAd, AdError>? onLoadFailedEvent = null;

public void LoadAppOpenAd()
{
    if (onAdLoadedEvent == null)
    {
        onAdLoadedEvent = (ad) =>
        {
            // 加载成功
            Debug.Log("Load AppOpen Ad is successed.");
        };
        AppOpenAd.OnLoadedEvent += onAdLoadedEvent;
    }
    if (onLoadFailedEvent == null)
    {
        onLoadFailedEvent = (ad, error) =>
        {
            // 加载失败
            Debug.Log("Load AppOpen Ad is failure.");
        };
        AppOpenAd.OnLoadFailedEvent += onLoadFailedEvent;
    }
    AthanaSdk.LoadAppOpenAd(AppOpenAdUnitId);
}

public void ShowAppOpenAd()
{
    if (AthanaSdk.IsReadyAppOpenAd(AppOpenAdUnitId))
    {
        AthanaSdk.ShowAppOpenAd(AppOpenAdUnitId, placement: "AppOpenAd");
    }
    else
    {
        LoadAppOpenAd();
    }
}

插屏广告

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
using Athana;
using Athana.Callbacks;
using Athana.Api;
using static Athana.Api.AthanaInterface;
using static Athana.Callbacks.AthanaCallbacks;

private Action<ProxyAd>? onAdLoadedEvent = null;
private Action<ProxyAd, AdError>? onLoadFailedEvent = null;

public void LoadInterstitialAd()
{
    if (onAdLoadedEvent == null)
    {
        onAdLoadedEvent = (ad) =>
        {
            // 加载成功
            Debug.Log("Load Interstitial Ad is successed.");
        };
        AppOpenAd.OnLoadedEvent += onAdLoadedEvent;
    }
    if (onLoadFailedEvent == null)
    {
        onLoadFailedEvent = (ad, error) =>
        {
            // 加载失败
            Debug.Log("Load Interstitial Ad is failure.");
        };
        AppOpenAd.OnLoadFailedEvent += onLoadFailedEvent;
    }
    AthanaSdk.LoadInterstitialAd(InterstitialAdUnitId);
}

public void ShowInterstitialAd()
{
    if (AthanaSdk.IsReadyInterstitialAd(InterstitialAdUnitId))
    {
        AthanaSdk.ShowInterstitialAd(InterstitialAdUnitId, placement: "InterstitialAd");
    }
    else
    {
        LoadInterstitialAd();
    }
}

激励广告

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
using Athana;
using Athana.Callbacks;
using Athana.Api;
using static Athana.Api.AthanaInterface;
using static Athana.Callbacks.AthanaCallbacks;

private Action<ProxyAd>? onAdLoadedEvent = null;
private Action<ProxyAd, AdError>? onLoadFailedEvent = null;
private Action<ProxyAd>? onRewardedEvent = null;

public void LoadRewardedAd()
{
    if (onAdLoadedEvent == null)
    {
        onAdLoadedEvent = (ad) =>
        {
            // 加载成功
            Debug.Log("Load Rewarded Ad is successed.");
        };
        AppOpenAd.OnLoadedEvent += onAdLoadedEvent;
    }
    if (onLoadFailedEvent == null)
    {
        onLoadFailedEvent = (ad, error) =>
        {
            // 加载失败
            Debug.Log("Load Rewarded Ad is failure.");
        };
        AppOpenAd.OnLoadFailedEvent += onLoadFailedEvent;
    }
    if (onRewardedEvent == null)
    {
        onRewardedEvent = (ad) =>
        {
            // 收到奖励
            Debug.Log("Reward received.");
        };
        RewardedAd.OnRewardedEvent += onRewardedEvent;
    }
    AthanaSdk.LoadRewardedAd(RewardedAdUnitId);
}

public void ShowRewardedAd()
{
    if (AthanaSdk.IsReadyRewardedAd(RewardedAdUnitId))
    {
        AthanaSdk.ShowRewardedAd(RewardedAdUnitId, placement: "RewardedAd");
    }
    else
    {
        LoadRewardedAd();
    }
}

横幅广告

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
using Athana;
using Athana.Api;

private BannerAd? _BannerAd = null;

public void CreateBanner()
{
    _BannerAd?.Destroy();
    _BannerAd = AthanaSdk.CreateBanner(BannerAdUnitId, AdSize.fullWidth(60), "Banner", AdAlignment.TOP_CENTER);
}

public void HideBanner()
{
    _BannerAd?.Hide();
}

public void ShowBanner()
{
    _BannerAd?.Show();
}

支付

查询商店服务是否可用

请在调用 QueryProducts、Purchase、QueryPurchaseHistory 方法前调用一次 StoreIsAvailable 方法

可以在调用 StoreIsAvailable 之后，异步延时 400ms 后调用 QueryProducts 或 QueryPurchaseHistory

1
2
3
// 在 AthanaSdk.Start 之后调用
// 首次调用可能返回 false，取决于 BillingClient 建立连接的耗时，平均耗时在 400ms 左右
bool check = AthanaSdk.StoreIsAvailable();

查询商品详情

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
using Athana;
using Athana.Callbacks;
using Athana.Api;
using static Athana.Api.AthanaInterface;
using static Athana.Callbacks.AthanaCallbacks;

// 内购商品详情列表
private List<IapProduct> products = new List<IapProduct>();

public void QueryProducts()
{
    if (onQueryProductsResult == null)
    {
        onQueryProductsResult = (SdkCallback<List<IapProduct>> result) =>
        {
            if (result.isSuccess())
            {
                var data = result.data;
                if (data == null || data.Count == 0)
                {
                    // 未查询到结果
                }
                else
                {
                    // 持久化查询结果
                    products.AddRange(data);
                    foreach (var product in data)
                    {
                        // 价格回显
                    }
                }
            }
            else
            {
                // 调用失败
                Debug.Log("Failed to query products. error: " + result.error?.msg);
            }

        };
        AthanaCallbacks.OnQueryProductsResult += onQueryProductsResult;
    }
    
    var keys = new HashSet<string>();
    // 添加需要查询的商品 Key
    keys.Add("*********");
    ...
    AthanaSdk.QueryProducts(keys);
}

购买

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public void Purchase(IapProduct product)
{
    if (onPurchaseResult == null)
    {
        onPurchaseResult = (SdkCallback<object?> result) =>
        {
            if (result.isSuccess())
            {
                // 购买成功
            }
            else
            {
                // 调用失败
                Debug.Log("Failed to Purchase. error: " + result.error?.msg);
            }

        };
        AthanaCallbacks.OnPurchaseResult += onPurchaseResult;
    }
    
    AthanaSdk.Purchase(product);
}

查询购买历史

PS：不包含一次性消耗类商品，只能提供：在有效期内的订阅订单、非一次性消耗类商品

此方法适用于以下场景：

  • 掉单处理，在应用每次启动都主动查询一次
  • 对内购商品做使用权验证，例如：永久去广告
  • 对订阅商品做有效期验证，例如：月度会员
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public void QueryPurchaseHistory()
{
    if (onQueryPurchaseHistoryResult == null)
    {
        onQueryPurchaseHistoryResult = (SdkCallback<List<IapPurchase>> result) =>
        {
            if (result.isSuccess())
            {
                var data = result.data;
                // 只包含未确认订单、非一次性消耗类商品订单以及有效期内的订阅订单
                foreach (var purchase in data)
                {
                    if (purchase.isAcknowledged != true)
                    {
                        // 对未确认订单做重新验证动作
                        var consumable = true; // 根据实际商品来设置，一个Google账号只能购买一次，例如：永久去广告，则设置为 false
                        AthanaSdk.VerifyOrder(purchase, consumable);
                    }
                    Debug.Log("Purchase: " + purchase.purchaseId + ", Product: " + purchase.productId + ", finished: " + purchase.isAcknowledged);
                }
            }
            else
            {
                // 调用失败
                Debug.Log("Failed to query PurchaseHistory. error: " + result.error?.msg);
            }

        };
        AthanaCallbacks.OnQueryPurchaseHistoryResult += onQueryPurchaseHistoryResult;
    }

    AthanaSdk.QueryPurchaseHistory();
}

事件

内置事件

参考：事件服务

发送自定义事件

1
2
3
4
5
6
7
8
// 自定义事件名
var eventKey = "CustomKey";
// 事件参数
var paramMap = new Dictionary<string, object>();
paramMap["key1"] = value1;
paramMap["keey2"] = value2;
// 发送事件
AthanaSdk.SendEvent(eventKey, paramMap: paramMap);

应用内评分

1
2
// 拉起评分对话框
AthanaSdk.RequestReview();

游戏中心

排行榜

提交分数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
using Athana;
using Athana.Callbacks;
using Athana.Api;
using static Athana.Api.AthanaInterface;
using static Athana.Callbacks.AthanaCallbacks;

private Action<SdkCallback<object?>>? onSubmitScoreResult;

public void SubmitScore()
{
    if (onSubmitScoreResult == null)
    {
        onSubmitScoreResult = (SdkCallback<object?> result) =>
        {
            if (result.isSuccess())
            {
                Debug.Log("Submit score is successed.");
            }
            else
            {
                Debug.Log("Submit score is failure. error: " + result.error?.msg);
            }
        };
        AthanaCallbacks.OnSubmitScoreResult += onSubmitScoreResult;
    }

    string leaderboardId = "your_leaderboard_id";
    long score = 10000;
    string? extra = null; // 额外信息，可选
    bool immediate = false; // false 为异步提交，true 为实时提交，只在 Android 平台生效

    AthanaSdk.SubmitScore(leaderboardId, score, extra, immediate);
}
获取玩家分数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
using Athana;
using Athana.Callbacks;
using Athana.Api;
using static Athana.Api.AthanaInterface;
using static Athana.Callbacks.AthanaCallbacks;

private Action<SdkCallback<ScoreData>>? onGetScoreResult;

public void GetScore()
{
    if (onGetScoreResult == null)
    {
        onGetScoreResult = (SdkCallback<ScoreData> result) =>
        {
            if (result.isSuccess())
            {
                var data = result.data;
                Debug.Log($"Score: {data?.score}, Rank: {data?.rank}");
            }
            else
            {
                Debug.Log("Get score is failure. error: " + result.error?.msg);
            }
        };
        AthanaCallbacks.OnGetScoreResult += onGetScoreResult;
    }

    string leaderboardId = "your_leaderboard_id";
    LeaderboardPlayerScope scope = LeaderboardPlayerScope.ALL;
    LeaderboardTimeSpan timeScope = LeaderboardTimeSpan.ALL_TIME;

    AthanaSdk.GetScore(leaderboardId, scope, timeScope);
}
打开排行榜 UI
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
using Athana;
using Athana.Callbacks;
using Athana.Api;
using static Athana.Api.AthanaInterface;
using static Athana.Callbacks.AthanaCallbacks;

private Action<SdkCallback<object?>>? onOpenLeaderboardUIResult;

public void OpenLeaderboardUI()
{
    if (onOpenLeaderboardUIResult == null)
    {
        onOpenLeaderboardUIResult = (SdkCallback<object?> result) =>
        {
            if (result.isSuccess())
            {
                Debug.Log("Open leaderboard UI is successed.");
            }
            else
            {
                Debug.Log("Open leaderboard UI is failure. error: " + result.error?.msg);
            }
        };
        AthanaCallbacks.OnOpenLeaderboardUIResult += onOpenLeaderboardUIResult;
    }

    string? leaderboardId = "your_leaderboard_id"; // 为空时显示所有排行榜
    LeaderboardPlayerScope? scope = LeaderboardPlayerScope.ALL;
    LeaderboardTimeSpan? timeScope = LeaderboardTimeSpan.ALL_TIME;

    AthanaSdk.OpenLeaderboardUI(leaderboardId, scope, timeScope);
}
获取排行榜信息
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
using Athana;
using Athana.Callbacks;
using Athana.Api;
using static Athana.Api.AthanaInterface;
using static Athana.Callbacks.AthanaCallbacks;

private Action<SdkCallback<List<LeaderboardInfo>>>? onGetLeaderboardInfoResult;

public void GetLeaderboardInfo()
{
    if (onGetLeaderboardInfoResult == null)
    {
        onGetLeaderboardInfoResult = (SdkCallback<List<LeaderboardInfo>> result) =>
        {
            if (result.isSuccess())
            {
                var data = result.data;
                foreach (var info in data)
                {
                    Debug.Log($"Leaderboard: {info.leaderboardId}, Name: {info.displayName}");
                }
            }
            else
            {
                Debug.Log("Get leaderboard info is failure. error: " + result.error?.msg);
            }
        };
        AthanaCallbacks.OnGetLeaderboardInfoResult += onGetLeaderboardInfoResult;
    }

    string? leaderboardId = null; // 为空时获取所有排行榜信息
    bool forceReload = false; // 是否强制刷新数据，只在 Android 平台生效

    AthanaSdk.GetLeaderboardInfo(leaderboardId, forceReload);
}
加载排行榜数据
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
using Athana;
using Athana.Callbacks;
using Athana.Api;
using static Athana.Api.AthanaInterface;
using static Athana.Callbacks.AthanaCallbacks;

private Action<SdkCallback<ScoreList>>? onLoadLeaderboardDataResult;

public void LoadLeaderboardData()
{
    if (onLoadLeaderboardDataResult == null)
    {
        onLoadLeaderboardDataResult = (SdkCallback<ScoreList> result) =>
        {
            if (result.isSuccess())
            {
                var data = result.data;
                foreach (var scoreData in data?.scores)
                {
                    Debug.Log($"Rank: {scoreData.rank}, Score: {scoreData.score}, Player: {scoreData.player?.displayName}");
                }
            }
            else
            {
                Debug.Log("Load leaderboard data is failure. error: " + result.error?.msg);
            }
        };
        AthanaCallbacks.OnLoadLeaderboardDataResult += onLoadLeaderboardDataResult;
    }

    string leaderboardId = "your_leaderboard_id";
    LeaderboardPlayerScope scope = LeaderboardPlayerScope.ALL;
    LeaderboardTimeSpan timeScope = LeaderboardTimeSpan.ALL_TIME;
    int pageSize = 20;
    bool userCenter = false; // 是否以当前用户为中心，只在 Android 平台生效

    AthanaSdk.LoadLeaderboardData(leaderboardId, scope, timeScope, pageSize, userCenter);
}
加载更多排行榜数据
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
using Athana;
using Athana.Callbacks;
using Athana.Api;
using static Athana.Api.AthanaInterface;
using static Athana.Callbacks.AthanaCallbacks;

private Action<SdkCallback<ScoreList>>? onLoadMoreLeaderboardDataResult;

public void LoadMoreLeaderboardData()
{
    if (onLoadMoreLeaderboardDataResult == null)
    {
        onLoadMoreLeaderboardDataResult = (SdkCallback<ScoreList> result) =>
        {
            if (result.isSuccess())
            {
                var data = result.data;
                Debug.Log($"Load more scores: {data?.scores?.Count}");
            }
            else
            {
                Debug.Log("Load more leaderboard data is failure. error: " + result.error?.msg);
            }
        };
        AthanaCallbacks.OnLoadMoreLeaderboardDataResult += onLoadMoreLeaderboardDataResult;
    }

    string leaderboardId = "your_leaderboard_id";
    int pageSize = 20;
    PageDirection pageDirection = PageDirection.NEXT; // 或 PageDirection.PREV，只在 Android 平台生效

    AthanaSdk.LoadMoreLeaderboardData(leaderboardId, pageSize, pageDirection);
}

成就

解锁成就
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
using Athana;
using Athana.Callbacks;
using Athana.Api;
using static Athana.Api.AthanaInterface;
using static Athana.Callbacks.AthanaCallbacks;

private Action<SdkCallback<object?>>? onUnlockAchievementResult;

public void UnlockAchievement()
{
    if (onUnlockAchievementResult == null)
    {
        onUnlockAchievementResult = (SdkCallback<object?> result) =>
        {
            if (result.isSuccess())
            {
                Debug.Log("Unlock achievement is successed.");
            }
            else
            {
                Debug.Log("Unlock achievement is failure. error: " + result.error?.msg);
            }
        };
        AthanaCallbacks.OnUnlockAchievementResult += onUnlockAchievementResult;
    }

    string achievementId = "your_achievement_id";
    bool immediate = false; // false 为异步提交，true 为实时提交，只在 Android 平台生效

    AthanaSdk.UnlockAchievement(achievementId, immediate);
}
更新成就进度
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
using Athana;
using Athana.Callbacks;
using Athana.Api;
using static Athana.Api.AthanaInterface;
using static Athana.Callbacks.AthanaCallbacks;

private Action<SdkCallback<object?>>? onUpdateAchievementProgressResult;

public void UpdateAchievementProgress()
{
    if (onUpdateAchievementProgressResult == null)
    {
        onUpdateAchievementProgressResult = (SdkCallback<object?> result) =>
        {
            if (result.isSuccess())
            {
                Debug.Log("Update achievement progress is successed.");
            }
            else
            {
                Debug.Log("Update achievement progress is failure. error: " + result.error?.msg);
            }
        };
        AthanaCallbacks.OnUpdateAchievementProgressResult += onUpdateAchievementProgressResult;
    }

    string achievementId = "your_achievement_id";
    int progress = 50; // 进度值，在 iOS 平台只能设置为（0-100）范围，在 Android 平台无限制
    bool immediate = false; // false 为异步提交，true 为实时提交，只在 Android 平台生效

    AthanaSdk.UpdateAchievementProgress(achievementId, progress, immediate);
}
打开成就 UI
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
using Athana;
using Athana.Callbacks;
using Athana.Api;
using static Athana.Api.AthanaInterface;
using static Athana.Callbacks.AthanaCallbacks;

private Action<SdkCallback<object?>>? onOpenAchievementUIResult;

public void OpenAchievementUI()
{
    if (onOpenAchievementUIResult == null)
    {
        onOpenAchievementUIResult = (SdkCallback<object?> result) =>
        {
            if (result.isSuccess())
            {
                Debug.Log("Open achievement UI is successed.");
            }
            else
            {
                Debug.Log("Open achievement UI is failure. error: " + result.error?.msg);
            }
        };
        AthanaCallbacks.OnOpenAchievementUIResult += onOpenAchievementUIResult;
    }

    AthanaSdk.OpenAchievementUI();
}
获取成就数据
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
using Athana;
using Athana.Callbacks;
using Athana.Api;
using static Athana.Api.AthanaInterface;
using static Athana.Callbacks.AthanaCallbacks;

private Action<SdkCallback<List<Achievement>>>? onGetAchievementDataResult;

public void GetAchievementData()
{
    if (onGetAchievementDataResult == null)
    {
        onGetAchievementDataResult = (SdkCallback<List<Achievement>> result) =>
        {
            if (result.isSuccess())
            {
                var data = result.data;
                foreach (var achievement in data)
                {
                    Debug.Log($"Achievement: {achievement.achievementId}, Name: {achievement.name}, Status: {achievement.status}");
                }
            }
            else
            {
                Debug.Log("Get achievement data is failure. error: " + result.error?.msg);
            }
        };
        AthanaCallbacks.OnGetAchievementDataResult += onGetAchievementDataResult;
    }

    bool forceReload = false; // 是否强制刷新数据，只在 Android 平台生效

    AthanaSdk.GetAchievementData(forceReload);
}

好友

请求好友列表访问权限
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
using Athana;
using Athana.Callbacks;
using Athana.Api;
using static Athana.Api.AthanaInterface;
using static Athana.Callbacks.AthanaCallbacks;

private Action<SdkCallback<object?>>? onRequestFriendListPermissionResult;

public void RequestFriendListPermission()
{
    if (onRequestFriendListPermissionResult == null)
    {
        onRequestFriendListPermissionResult = (SdkCallback<object?> result) =>
        {
            if (result.isSuccess())
            {
                Debug.Log("Request friend list permission is successed.");
            }
            else
            {
                Debug.Log("Request friend list permission is failure. error: " + result.error?.msg);
            }
        };
        AthanaCallbacks.OnRequestFriendListPermissionResult += onRequestFriendListPermissionResult;
    }

    AthanaSdk.RequestFriendListPermission();
}
加载好友列表
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
using Athana;
using Athana.Callbacks;
using Athana.Api;
using static Athana.Api.AthanaInterface;
using static Athana.Callbacks.AthanaCallbacks;

private Action<SdkCallback<FriendList>>? onLoadFriendsResult;

public void LoadFriends()
{
    if (onLoadFriendsResult == null)
    {
        onLoadFriendsResult = (SdkCallback<FriendList> result) =>
        {
            if (result.isSuccess())
            {
                var data = result.data;
                foreach (var friend in data?.friends)
                {
                    Debug.Log($"Friend: {friend.displayName}, ID: {friend.id}");
                }
            }
            else
            {
                Debug.Log("Load friends is failure. error: " + result.error?.msg);
            }
        };
        AthanaCallbacks.OnLoadFriendsResult += onLoadFriendsResult;
    }

    int pageSize = 20;
    bool forceReload = false; // 是否强制刷新数据，只在 Android 平台生效

    AthanaSdk.LoadFriends(pageSize, forceReload);
}
加载更多好友
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
using Athana;
using Athana.Callbacks;
using Athana.Api;
using static Athana.Api.AthanaInterface;
using static Athana.Callbacks.AthanaCallbacks;

private Action<SdkCallback<FriendList>>? onLoadMoreFriendsResult;

public void LoadMoreFriends()
{
    if (onLoadMoreFriendsResult == null)
    {
        onLoadMoreFriendsResult = (SdkCallback<FriendList> result) =>
        {
            if (result.isSuccess())
            {
                var data = result.data;
                Debug.Log($"Load more friends: {data?.friends?.Count}");
            }
            else
            {
                Debug.Log("Load more friends is failure. error: " + result.error?.msg);
            }
        };
        AthanaCallbacks.OnLoadMoreFriendsResult += onLoadMoreFriendsResult;
    }

    int pageSize = 20;

    AthanaSdk.LoadMoreFriends(pageSize);
}
打开玩家资料 UI
1
2
3
4
5
6
7
8
using Athana;
using Athana.Api;

public void OpenPlayerProfileUI()
{
    string playerId = "player_id"; // 只限于好友列表以及排行榜中加载过的玩家ID
    AthanaSdk.OpenPlayerProfileUI(playerId);
}

枚举类型说明

LeaderboardPlayerScope

排行榜玩家范围：

  • ALL - 全球玩家
  • FRIENDS - 社交圈玩家（好友）
LeaderboardTimeSpan

排行榜时间范围：

  • TODAY - 每日
  • WEEK - 每周
  • ALL_TIME - 所有时间
PageDirection

分页方向：

  • NEXT - 下一页
  • PREV - 上一页
AchievementState

成就状态：

  • UNLOCKED - 已解锁
  • VISIBLE - 已显示
  • HIDDEN - 隐藏（未显示给玩家）
0%