跳转至

链接 Idp

Note
  • 有关 AuthV4.Helper 的更多描述，请参阅 Authentication 页面。

登录后，显示用户当前使用的 PlayerID 的同步状态，并提供与其他身份提供者（IdP）链接的功能。 在游戏设置菜单中显示 IdP 的同步状态，并配置 UI 以便用户可以连接和断开与 IdP 的连接。

检查 IdP 同步状态的信息

您可以使用AuthV4类的getPlayerInfo()方法查看与当前登录的PlayerID同步的IdP列表。在游戏设置屏幕中，请确保配置UI以查看哪个IdP已同步，并公开建议IdP同步的短语。

在游戏设置屏幕中，每个用户的PlayerID应与IdP同步信息一起显示。以CS代码的格式显示PlayerID，并显示当前登录用户的值。

  • 一个示例屏幕，以确认IdP与当前登录的PlayerID同步

  • 账户链接的示例屏幕

以下是当前应用通过 providerTypeList 从 setup() 返回的 IdP 列表。请检查与 PlayerID 关联的 IdP 列表，并使用给定的示例代码显示关联状态。

API 参考: hive.AuthV4.getPlayerInfo

AuthV4.PlayerInfo playerInfo = AuthV4.getPlayerInfo();    

        foreach (AuthV4.ProviderInfo providerInfo in playerInfo.providerInfoData) {    
            // Synced-Provider data    
    }

#include "HiveAuthV4.h"

TOptional<FHivePlayerInfo> PlayerInfo = FHiveAuthV4::GetPlayerInfo();
if (PlayerInfo.IsSet())
{
        const FHivePlayerInfo& PlayerInfoData = PlayerInfo.GetValue();
        for (const auto& ProviderInfo : PlayerInfoData.ProviderInfoData)
        {
                // Synced-Provider data  
        }
}

API 参考: AuthV4::getPlayerInfo

// 请求 Hive SDK AuthV4 的同步状态    
        for( auto providerInfo : AuthV4::getPlayerInfo().providerInfoData ) {    
            cout&lt;&lt;"提供者类型 : "&lt;&lt;ProviderInfo::stringProviderType(providerInfo.second.providerType)&lt;&lt;endl;    
            cout&lt;&lt;"提供者用户ID : "&lt;&lt;providerInfo.second.providerUserId&lt;&lt;endl;    
    }

API 参考: com.hive.AuthV4.getPlayerInfo

//搜索经过验证的用户数据    
    AuthV4.PlayerInfo playerInfo = AuthV4.getPlayerInfo();

API 参考: HIVEAuthV4:getPlayerInfo

HIVEPlayerInfo *playerInfo = [HIVEAuthV4 getPlayerInfo];    

        for (NSString *providerTypeStr in [playerInfo.providerInfoData allKeys]) {    
            // 同步的提供者数据    
            HIVEProviderInfo *providerInfo = playerInfo.providerInfoData[providerTypeStr];    
    }

建议 IdP 同步

语言 短语
韩语 계정 연동을 통해 플레이 데이터를 안전하게 지키세요!
英语 Sync your account to protect your game data!
日语 アカウントを連動してプレイデータを守りましょう！
中文（简体） 绑定账号，保护游戏数据安全吧！
中文（繁体） 綁定帳號，保護帳號資料安全！
法语 Synchronise ton compte afin de protéger tes données de jeu !
德语 Synchronisiere dein Konto, um deine Spieldaten zu schützen!
俄语 Синхронизируйте аккаунт, чтобы обезопасить игровые данные.
西班牙语 ¡Sincronicen su cuenta para proteger sus datos del juego!
葡萄牙语 Sincronize sua conta para proteger seus dados de jogo!
印尼语 Hubungkan akunmu untuk mengamankan data game milikmu!
越南语 Vui lòng liên kết tài khoản để bảo vệ an toàn cho dữ liệu game của bạn!
泰语 ซิงค์บัญชีเพื่อปกป้องข้อมูลเกมของคุณ!
意大利语 Sincronizza il tuo account per proteggere i tuoi dati di gioco.
土耳其语 Oyun verilerini korumak için hesabınızı senkronize ediniz.
阿拉伯语 زامن حسابك لحماية بيانات اللعبة الخاصة بك!

IdP 同步

当前登录的 PlayerID 可以与新的 IdP 同步。但是当用户尝试与链接到不同 PlayerID 的 IdP 进行同步时，会发生错误。如果同步成功，请检查同步状态信息并更新同步信息 UI。

Note

要插入 IdP 图标或徽标，请查看我们针对每个 IdP 的指南。

Warning

iOS Steam 登录支持 iOS 版本 14 及以上。 有人怀疑与 Steam 登录页面的渲染问题有关，在 iOS 版本 14 以下的 Safari 浏览器和 WKWebView 中，用户名和密码输入字段无法显示。

Warning

从2020年3月起，Apple App Store 警告使用 UIWebView (ITMS-90809)，并要求在2020年4月之前删除与 UIWebView 相关的代码，适用于2019年9月之后发布的应用和游戏。我们确认从 Hive SDK v4.14.0 添加的 Twitter 框架使用了与 UIWebView 相关的类，并且每当提交游戏时，它会持续向 App Center 发出警告。为了避免被拒绝，Twitter 框架暂时被删除，直到没有 UIWebView 的新框架可用。简而言之，游戏工作室需要对用户使用 Twitter 登录时调用相关 API 的情况做出响应，ResultAPI 收到 NotSupportedProviderType 代码。

从 Hive SDK v4.14.4 开始，新的框架可以响应与 UIWebView 相关的警告，适用于 2019.3 之前的 Unity。 如果您的游戏需要 Unity 2019.3 及更高版本，Twitter 将无法进行身份验证，因此，请确保按照以下设置删除并防止 Hive SDK 引用与 Twitter 相关的框架。

  • 通过外部依赖设置删除 Twitter 框架
  • 在 Xcode 项目中删除 ProviderTwitter.framework
Warning
  • 确保以英语书写Google和Apple产品的名称。
  • 新的身份提供者，Apple应以Sign In with Apple的形式用英语表示，并以Apple로 로그인的形式用韩语表示。图标上的文本布局应居中对齐。
  • 有关在身份验证中应用的多语言登录按钮名称，请点击这里。


当您想要在 IdP 连接中添加的 IdP 与另一个 PlayerID 关联时，这称为账户冲突情况。要解决此冲突情况，请参见 处理与 IdP 相关的账户冲突。

对于 IdP 集成，使用您想要使用的 ProviderType 作为参数调用 connect () 方法。以下是实现 IdP 同步的示例代码。

API 参考: hive.AuthV4.Helper.connect

// Hive SDK AuthV4 请求与 IdP 同步    
        AuthV4.Helper.connect (providerType, delegate (ResultAPI result, AuthV4.PlayerInfo playerInfo) {    
            switch(result.code) {    
            case ResultAPI.Code.Success:    
                // 成功同步 IdP    
                break;    
            case ResultAPI.Code.AuthV4ConflictPlayer:    
                // 账户冲突    
                break;    
            default:    
                // 异常情况    
                break;    
            }    
    });

#include "HiveAuthV4.h"

EHiveProviderType ProviderType = EHiveProviderType::HIVE;
FHiveAuthV4::Helper::Connect(ProviderType, FHiveAuthV4HelperDelegate::CreateLambda([this](const FHiveResultAPI& Result, const TOptional<FHivePlayerInfo>& PlayerInfo) {
        switch (Result.Code) {
                case FHiveResultAPI::ECode::Success:
                        // 成功同步 IdP
                        break;
                case FHiveResultAPI::ECode::AuthV4ConflictPlayer:
                        // 账户冲突
                        break;
                default:
                        // 异常情况
                        break;
        }
}));

API 参考: AuthV4::Helper::connect

// Hive SDK AuthV4 请求以与 IdP 同步    
        AuthV4::Helper::connect(ProviderInfo::providerTypeFromString(providerType), [=](ResultAPI const &amp; result, std::shared_ptr playerInfo) {    
                switch (result.code) {    
                case ResultAPI::Success:    
                    // 成功同步 IdP    
                    break;    
                case ResultAPI::AuthV4ConflictPlayer:    
                    // 账户冲突    
                    break;    
                default:    
                    // 异常情况    
                    break;    
                }    
    });

API 参考: com.hive.AuthV4.Helper.connect

// Hive SDK AuthV4 请求以与 IdP 同步    
        AuthV4.Helper.connect(ProviderType providerType, new AuthV4.Helper.AuthV4HelperListener() {    
            @Override    
            public void onAuthV4Helper(ResultAPI result, AuthV4.PlayerInfo playerInfo) {    
                switch(result.code) {    
                    case Success:    
                        // 成功同步 IdP    
                        break;    
                    case AuthV4ConflictPlayer:    
                        // 账户冲突    
                        break;    
                    default:    
                        // 异常情况    
                        break;    
                }    
            }    
    });

API Reference: HIVEAuthV4Helper::connect:handler:

// Hive SDK AuthV4 请求与 IdP 同步    
        [[HIVEAuthV4 helper] connect:providerType handler:^(HIVEResultAPI *result, HIVEPlayerInfo *playerInfo) {    
            switch(result.code) {    
            case kSuccess:    
                // 成功同步 IdP    
                break;    
            case kAuthV4ConflictPlayer:    
                // 账户冲突    
                break;    
            default:    
                // 异常情况    
                break;    
            }    
    }];

处理与 IdP 同步的帐户冲突

当为 IdP 集成调用 connect() 时，如果用户尝试连接的 IdP 账户已经链接到另一个 PlayerID，则会发生账户冲突。为了进一步解释，我们假设以下情况。

  • CurrentPlayer: 用户当前登录的账户的玩家（访客账户或 IdP 账户）
  • ConflictPlayer: 用户想要链接的 IdP 账户中已经存在的玩家

当ConflictPlayer的游戏记录存在于游戏服务器中

在这种情况下，当发生账户冲突时，ConflictPlayer 的游戏信息会通知用户，并显示选择 ConflictPlayer 的 UI。要使用 Hive SDK 提供的 UI，请配置 ConflictPlayer 信息以适应游戏，并调用 showConflict() 方法，将 ConflictPlayer 信息作为参数传递。当调用时，您可以切换到 ConflictPlayer，或选择取消以继续与 CurrentPlayer 一起玩游戏。在下面的 UI 图像示例中，单击检查按钮会切换到 ConflictPlayer，单击 X 按钮则继续与 CurrentPlayer 一起玩游戏。

Note

账户选择 UI 可以是由 Hive SDK 提供的 UI，也可以由游戏方自定义。有关自定义账户选择 UI 的信息，请参阅 在 IdP 冲突中自定义。

当ConflictPlayer的游戏记录在游戏服务器中不存在时

有时，仅存在冲突玩家的玩家标识符（PlayerId），但游戏服务器上没有实际的游戏记录。在这种情况下，调用 resolveConflict(CB) 以选择当前玩家的 PlayerID 并继续游戏。当发生账户冲突时，显示以下用户界面。

  • 当 CurrentPlayer 是访客账户而 ConflictPlayer 是 IdP 账户时

    • “确认”按钮会被显示，当用户点击它时，CurrentPlayer 将保持登录状态！

  • 当 CurrentPlayer 是 IdP 账户 1（例如：Facebook），而 ConflictPlayer 是 IdP 账户 2（例如：Google Play）

    • 取消：保持登录当前的 Facebook 账户的 CurrentPlayer
    • 确认：切换玩家到 Google Play 账户的 ConflictPlayer

当 ConflictPlayer 是受限账户

当ConflictPlayer（IdP账户）处于受限状态时，如果CurrentPlayer（IdP账户或访客账户）尝试使用AuthV4.connect在另一台设备上连接，将不会出现账户冲突，而是会显示一个限制弹窗。 如果应用用户关闭限制弹窗，AuthV4.connect将返回一个错误，CurrentPlayer连接到此IdP的尝试将失败。

示例 1：当 CurrentPlayer 是 IdP 账户时

如果之前链接的 Facebook IdP 账户（ConflictPlayer）处于暂停状态，而用户尝试链接 Google IdP（CurrentPlayer），则会出现暂停弹窗。关闭弹窗将注销 Facebook IdP。

示例 2：当 CurrentPlayer 是访客账户

如果之前链接的 Facebook IdP 账户（ConflictPlayer）处于暂停状态，而用户尝试使用访客账户（CurrentPlayer）链接到 Facebook IdP，则会出现暂停弹出窗口。关闭弹出窗口将注销 Facebook IdP。

关于账户选择的注意事项

如果用户选择了ConflictPlayer，而CurrentPlayer处于访客状态，则将无法找到CurrentPlayer。如果CurrentPlayer在访客状态下有来自其他游戏服务器的数据，那么该游戏数据也将无法找到。因此，您应该在用户为访客时阻止他们对游戏服务器进行更改，以避免此问题。如果用户在SDK提供的账户选择页面上点击X按钮，则账户同步将被取消。

游戏数据的组成

ConflictPlayer 数据由两个基本键组成，player_id 和 game_data。

  • player_id: 冲突玩家的玩家ID
  • game_data: 以 Map<String, Object >; 格式组织游戏数据，例如角色名称、游戏货币数量和等级

以下是组合ConflictPlayer数据的示例代码。

{"player_id":123, "game_data":{"Name":"ConflictPlayer", "Level":52}}

从 Hive SDK 实现账户选择 UI（带游戏数据）

一旦您完成了对 ConflictPlayer 数据的配置，showConflict () 方法将被调用以暴露 SDK 提供的 UI，用户的选择将作为结果返回。如果结果成功并且用户选择了 ConflictPlayer，那么您需要重新加载游戏数据。当用户跳过或未能选择帐户时，结果返回失败，在这种情况下，请确保按原样继续游戏。然而，如果在切换帐户时未能对设备进行身份验证（AuthV4NotRegisteredDevice），游戏必须返回到初始页面以便重新登录。这会导致对 SDK 的登录被取消，并且 isAutoSignIn 返回 true。

以下是实现 UI 的示例代码，Hive SDK 通过配置冲突的 PlayerID 的游戏数据提供。

API 参考: hive .AuthV4.Helper.showConflict

// 创建冲突账户的游戏信息对象    
    AuthV4.Helper.ConflictSingleViewInfo conflictInfo = new AuthV4.Helper.ConflictSingleViewInfo(playerId);    
    conflictInfo.setValue("Gold", 2048);    
    conflictInfo.setValue("Gem", 220);    
    // 请求 Hive SDK AuthV4.Helper 账户选择 UI    
    AuthV4.Helper.showConflict (conflictInfo, (ResultAPI result, AuthV4.PlayerInfo playerInfo) =>; {    
        if (result. needExit()) {    
            // TODO: 实现应用程序的终止。    
            // 示例) Application.Quit();    
        } else {    
            switch(result.code) {    
                case ResultAPI.Code.AuthV4PlayerChange:    
                    // 账户切换：需要重新启动游戏    
                    break;    
                case ResultAPI.Code.AuthV4PlayerResolved:    
                    // 保持当前用户    
                    break;    
                case ResultAPI.Code.AuthV4NotRegisteredDevice:    
                    // 这是由于设备认证失败而取消登录的情况。尝试使用 AUTO 重新登录，或注销。    
                    break;    
                default:    
                    // 处理其他异常    
                    break;    
            }    
        }    
});

#include "HiveAuthV4.h"

int64 玩家ID = 12345678;
FHiveConflictSingleViewData 视图数据 = FHiveConflictSingleViewData(玩家ID);
视图数据.SetData(TEXT("金币"), TEXT("2048"));
视图数据.SetData(TEXT("宝石"), TEXT("220"));

FHiveAuthV4::Helper::ShowConflict(ViewData, FHiveAuthV4HelperDelegate::CreateLambda([this](const FHiveResultAPI& Result, const TOptional<FHivePlayerInfo>& PlayerInfo) {
        if (Result.NeedExit()) {
                // TODO: 实现应用程序的终止。    
      // 示例) Application.Quit();
        } else {
                switch (Result.Code) {
                        case FHiveResultAPI::ECode::AuthV4PlayerChange:
                                // 账户切换：需要重新启动游戏
                                break;
                        case FHiveResultAPI::ECode::AuthV4PlayerResolved:
                                // 保持当前用户
                                break;
                        case FHiveResultAPI::ECode::AuthV4NotRegisteredDevice:
                                // 这是由于设备认证失败而取消登录的情况。尝试使用AUTO重新登录，或注销。
                                break;
                        default:
                                // 处理其他异常 
                                break;
                }
        }
}));

API 参考: AuthV4 ::Helper::showConflict

// 创建冲突账户的游戏信息对象    
    ConflictSingleViewInfo* conflictInfo = new ConflictSingleViewInfo(playerId);    
    conflictInfo->;SetValue("Gold", 2048);    
    conflictInfo->;SetValue("Gem", 220);    


    // Hive SDK AuthV4::Helper 账户选择 UI 请求    
    AuthV4::Helper::showConflict(*conflictInfo, [=](ResultAPI const &amp; result, std::shared_ptr playerInfo) {    
            if (result. needExit()) {    
                // TODO: 实现应用程序的终止。    
                // Cocos2d-x 引擎的用户    
                // 例如) exit(0);    
                // 虚幻引擎用户    
                // 示例) UKismetSystemLibrary::QuitGame(GetWorld(), nullptr, EQuitPreference::Quit, false);    


            } else {    
                switch(result.code) {    
                    case ResultAPI::AuthV4PlayerChange:    
                        // 账户切换：需要重新启动游戏    
                        break;    
                    case ResultAPI::AuthV4PlayerResolved:    
                        // 保持当前用户    
                        break;    
                    case ResultAPI::Code::AuthV4NotRegisteredDevice:    
                        // 这是由于设备认证失败而取消登录的情况。请尝试使用AUTO重新登录，或登出。    
                        break;    
                    default:    
                        // 处理其他异常    
                        break;    
                }    
            }    
});

API 参考: com.hive.AuthV4.Helper.showConflict

// 创建冲突账户的游戏信息对象    
    val conflictInfo = AuthV4.Helper.ConflictSingleViewInfo(playerId)    
    conflictInfo.setValue("Gold", 2048)    
    conflictInfo.setValue("Gem", 220)    

    // 请求 Hive SDK AuthV4.Helper 账户选择 UI    
    AuthV4.Helper.showConflict(conflictInfo, object : AuthV4.Helper.AuthV4HelperListener {    
            override fun onAuthV4Helper(result: ResultAPI, playerInfo: AuthV4.PlayerInfo?) {    
                if (result. needExit()) {    
                    // TODO: 实现应用程序的终止。    
                    // 例如) exitProcess(0)    
                } else {    
                    when (result.code) {    
                        ResultAPI.Code.AuthV4PlayerChange ->; {    
                            // 账户切换：需要重新启动游戏    
                        }    
                        ResultAPI.Code.AuthV4CancelDialog ->; {    
                            // 保持当前用户    
                        }    
                        ResultAPI.Code.AuthV4NotRegisteredDevice ->; {    
                            // 这是由于设备认证失败而取消登录的情况。尝试使用 AUTO 重新登录，或注销。    
                        }    
                        else ->; {    
                            // 处理其他异常    
                        }    
                    }    
                }    
            }    
})

API 参考: com .hive.AuthV4.Helper.showConflict

// 创建冲突账户的游戏信息对象    
    AuthV4.Helper.ConflictSingleViewInfo conflictInfo = new AuthV4.Helper.ConflictSingleViewInfo(playerId);    
    conflictInfo.setValue("Gold", 2048);    
    conflictInfo.setValue("Gem", 220);    


    // 请求 Hive SDK AuthV4.Helper 账户选择 UI    
    AuthV4.Helper.showConflict(conflictInfo, new AuthV4.Helper.AuthV4HelperListener() {    
            @Override    
            public void onAuthV4Helper(ResultAPI result, AuthV4.PlayerInfo playerInfo) {    

                if (result. needExit()) {    
                    // TODO: 实现应用程序的终止。    
                    // ex) System.exit(0);    
                } else {    
                    switch(result.code) {    
                        case AuthV4PlayerChange:    
                            // 账户切换：需要重新启动游戏    
                            break;    
                        case AuthV4CancelDialog:    
                            // 保持当前用户    
                            break;    
                        case AuthV4NotRegisteredDevice:    
                            // 这是由于设备认证失败而取消登录的情况。尝试使用AUTO重新登录，或注销。    
                            break;    
                        default:    
                            // 处理其他异常    
                            break;    
                    }    
                }    
            }    
});

API 参考: HIVEAuthV4Helper::showConflict:handler:

// 创建冲突账户的游戏信息对象    
    let conflictInfo = ConflictSingleViewInfo(playerId: 12345678)    
    conflictInfo.setValue("Gold", intValue: 2048)    
    conflictInfo.setValue("Gem", intValue: 220)    

    // Hive SDK AuthV4:Helper 账户选择 UI 请求    
    AuthV4Interface.helper().showConflict(conflictInfo) { (result, playerInfo) in    

            if result.needExit() {    
                // TODO: implement the termination of the app.    
                // ex) exit(0)    
            } else {    
                switch result.getCode() {    
                case .authV4PlayerChange:    
                    // account switching: game restart required    
                case .authV4CancelDialog:    
                    // keep current user    
                case .authV4NotRegisteredDevice:    
                    // This is the case that the login is canceled due to device authentication failure. Try logging in back with AUTO, or log out.    
                default:    
                    // handle other exceptions    
                    break    
                }    
            }    
}

API 参考: HIVEAuthV4Helper ::showConflict:handler:

// 创建冲突账户的游戏信息对象    
    HIVEConflictSingleViewInfo *conflictInfo = [[HIVEConflictSingleViewInfo alloc] initWithPlayerId:12345678];    
    [conflictInfo setValue:@"Gold" intValue:2048];    
    [conflictInfo setValue:@"Gem" intValue:220];    


    // Hive SDK AuthV4:Helper 账户选择 UI 请求    
    [[HIVEAuthV4 helper] showConflict:conflictInfo handler:^(HIVEResultAPI *result, HIVEPlayerInfo *playerInfo) {    

            if (result. needExit) {    
                // TODO: 实现应用程序的终止。    
                // ex) exit(0);    
            } else {    
                switch(result.code) {    
                    case kAuthV4PlayerChange:    
                        // 账户切换：需要重新启动游戏    
                        break;    
                    case kAuthV4CancelDialog:    
                        // 保持当前用户    
                        break;    
                    case kAuthV4NotRegisteredDevice:    
                        // 这是由于设备验证失败而取消登录的情况。尝试使用AUTO重新登录，或注销。    
                        break;    
                    default:    
                        // 处理其他异常    
                        break;    
                }    
            }    
}];

从 Hive SDK 实现账户选择 UI（没有游戏数据或未知数据）

如果您无法在显示账户选择UI时验证游戏数据，或者只是通知登录的更改，则简化的UI适用于这种情况。当用户跳过或未能选择账户时，结果返回失败，在这种情况下，请确保继续游戏。但是，如果在切换账户时未能验证设备（AuthV4NotRegisteredDevice），游戏必须返回到初始页面以便重新登录。这会导致SDK的登录被取消，并且isAutoSignIn返回true。

以下是实现UI的示例代码，Hive SDK通过隐藏冲突的PlayerID的游戏数据来提供。

API 参考: hive .AuthV4.Helper.showConflict

// 请求 Hive SDK AuthV4.Helper 账户选择 UI    
    AuthV4.Helper.showConflict ((ResultAPI result, AuthV4.PlayerInfo playerInfo) =>; {    
        if (result. needExit()) {    
            // TODO: 实现应用退出功能    
            // 示例) Application.Quit();    
        } else {    
            switch(result.code) {    
                case ResultAPI.Code.AuthV4PlayerChange:    
                    // 账户切换：需要重启游戏    
                    break;    
                case ResultAPI.Code.AuthV4PlayerResolved:    
                    // 保持当前用户    
                    break;    
                case ResultAPI.Code.AuthV4NotRegisteredDevice:    
                    // 这是由于设备认证失败而取消登录的情况。尝试使用 AUTO 重新登录或注销。    
                    break;    
                default:    
                    // 处理其他异常    
                    break;    
            }    
        }    
});

#include "HiveAuthV4.h"

FHiveAuthV4::Helper::ShowConflict(FHiveAuthV4HelperDelegate::CreateLambda([this](const FHiveResultAPI& Result, const TOptional<FHivePlayerInfo>& PlayerInfo) {
        if (Result.NeedExit()) {
                // TODO: 实现应用退出功能    
            // Cocos2d-x 引擎的用户    
            // 例如) exit(0);    
            // Unreal 引擎用户    
            // 示例) UKismetSystemLibrary::QuitGame(GetWorld(), nullptr, EQuitPreference::Quit, false);  
        } else {
                switch (Result.Code) {
                        case FHiveResultAPI::ECode::AuthV4PlayerChange:
                                // 账户切换：需要重新启动游戏。
                                break;
                        case FHiveResultAPI::ECode::AuthV4PlayerResolved:
                                // 保持当前用户
                                break;
                        case FHiveResultAPI::ECode::AuthV4NotRegisteredDevice:
                                // 这是由于设备认证失败而取消登录的情况。尝试使用 AUTO 重新登录或注销。
                                break;
                        default:
                                // 处理其他异常
                                break;
                }
        }
}));

API 参考: AuthV4 ::Helper::showConflict

// Hive SDK AuthV4::Helper 账户选择 UI 请求    
    AuthV4::Helper::showConflict([=](ResultAPI const &amp; result, std::shared_ptr playerInfo) {    
        if (result. needExit()) {    
            // TODO: 实现应用退出功能    
            // Cocos2d-x 引擎的用户    
            // ex) exit(0);    
            // Unreal 引擎用户    
            // 示例) UKismetSystemLibrary::QuitGame(GetWorld(), nullptr, EQuitPreference::Quit, false);    
        } else {    
            switch(result.code) {    
                case ResultAPI::AuthV4PlayerChange:    
                    // 账户切换：需要重新启动游戏    
                    break;    
                case ResultAPI::AuthV4PlayerResolved:    
                    // 保持当前用户    
                    break;    
                case ResultAPI::Code::AuthV4NotRegisteredDevice:    
                    // 这是由于设备认证失败而取消登录的情况。尝试使用 AUTO 重新登录或注销。    
                    break;    
                default:    
                    // 处理其他异常    
                    break;    
            }    
        }    
});

API 参考: com.hive.AuthV4.Helper.showConflict

// 请求 Hive SDK AuthV4.Helper 账户选择 UI    
    AuthV4.Helper.showConflict(object : AuthV4.Helper.AuthV4HelperListener {    
        override fun onAuthV4Helper(result: ResultAPI, playerInfo: AuthV4.PlayerInfo?) {    
            if (result. needExit()) {    
                // TODO: 实现应用退出功能    
                // ex) exitProcess(0)    
            } else {    
                when (result.code) {    
                    ResultAPI.Code.AuthV4PlayerChange ->; {    
                        // 账户切换：需要重新启动游戏    
                    }    
                    ResultAPI.Code.AuthV4CancelDialog ->; {    
                        // 保持当前用户    
                    }    
                    ResultAPI.Code.AuthV4NotRegisteredDevice ->; {    
                        // 这是由于设备认证失败而取消登录的情况。尝试使用 AUTO 重新登录或注销。    
                    }    
                    else ->; {    
                        // 处理其他异常    
                    }    
                }    
            }    
        }    
})

API 参考: com .hive.AuthV4.Helper.showConflict

// 请求 Hive SDK AuthV4.Helper 账户选择 UI    
    AuthV4.Helper.showConflict(new AuthV4.Helper.AuthV4HelperListener() {    
        @Override    
        public void onAuthV4Helper(ResultAPI result, AuthV4.PlayerInfo playerInfo) {    
            if (result. needExit()) {    
                // TODO: 实现应用退出功能    
                // ex) System.exit(0);    
            } else {    
                switch(result.code) {    
                    case AuthV4PlayerChange:    
                        // 账户切换：需要重新启动游戏    
                        break;    
                    case AuthV4CancelDialog:    
                        // 保持当前用户    
                        break;    
                    case AuthV4NotRegisteredDevice:    
                        // 这是由于设备认证失败而取消登录的情况。尝试使用 AUTO 重新登录或注销。    
                        break;    
                    default:    
                        // 处理其他异常    
                        break;    
                }    
            }    
        }    
});

API 参考: HIVEAuthV4Helper::showConflict:

// Hive SDK AuthV4:Helper account selection UI request    
    AuthV4Interface.helper().showConflict() { (result, playerInfo) in    

        if result.needExit() {    
            // TODO: implement app exit functionality    
            // ex) exit(0)    
        } else {    
            switch result.getCode() {    
            case .authV4PlayerChange:    
                // account switching: game restart required    
            case .authV4CancelDialog:    
                // keep current user    
            case .authV4NotRegisteredDevice:    
                // This is the case when login is canceled due to device authentication failure. Try logging back in with AUTO or log out.    
            default:    
                // handle other exceptions    
                break    
            }    
        }    
}

API 参考: HIVEAuthV4Helper ::showConflict:

// Hive SDK AuthV4:Helper account selection UI request    
    [[HIVEAuthV4 helper] showConflict:^(HIVEResultAPI *result, HIVEPlayerInfo *playerInfo) {    

        if (result. needExit) {    
            // TODO: 实现应用退出功能    
            // ex) exit(0);    
        } else {    
            switch(result.code) {    
                case kAuthV4PlayerChange:    
                    // 账户切换：需要重新启动游戏    
                    break;    
                case kAuthV4CancelDialog:    
                    // 保持当前用户    
                    break;    
                case kAuthV4NotRegisteredDevice:    
                    // 这是由于设备认证失败而取消登录的情况。请尝试使用AUTO重新登录或注销。    
                    break;    
                default:    
                    // 处理其他异常    
                    break;    
            }    
        }    
}];

在 IdP 冲突情况下的自定义

如果在 IdP 同步过程中发生 IdP 冲突，您可以使用返回的冲突 PlayerID 配置游戏数据，并直接在游戏中实现账户选择 UI。如果用户在选择 UI 上选择了一个账户，请使用所选账户的 PlayerID 作为参数实现 selectConflict() 方法。

在以下描述中，当前登录的账户称为CurrentPlayer，发生冲突的账户称为ConflictPlayer。在自定义账户选择UI时，需要检查用户选择的操作差异，并在UI配置中通知适当的注意事项。 当IdP发生冲突时，可能会根据用户选择出现以下问题。

  • 选择冲突玩家: selectConflict(ConfilctPlayer, CB) 被调用。
    • 如果当前玩家是访客，则当前玩家无法搜索。
  • 选择当前玩家: selectConflict(CurrentPlayer, CB) 被调用。
    • 当前玩家与 IdP 同步，因此冲突玩家不同步。
    • 如果冲突玩家与其他 IdP 不同步，则所谓的访客状态可能导致冲突玩家无法搜索。
  • 如果取消（用户只是关闭选择页面）: resolveConflict(CB) 被调用。
    • 继续与当前玩家进行游戏，而不改变 IdP 同步。

在配置账户选择用户界面时，您需要配置适当的注意声明，因为在某些情况下，未选择的数据可能无法在访客状态中找到。此外，如果您希望在账户冲突的情况下配置不更改 IdP 关联的信息，请确保选择 ConflictPlayer 的游戏数据或设计可用于取消账户选择的用户界面。

一旦用户在账户选择 UI 上选择了一个账户，使用所选账户的 PlayerID 作为参数实现 selectConflict() 方法。如果用户取消账户选择，请确保在不调用任何 API 的情况下继续游戏。在玩家选择 ConflictPlayer 并收到成功回调后，请确保再次加载游戏数据。

以下是由于账户冲突而选择账户的示例代码。

API 参考: AuthV4::Conflict 

long long selectedPlayerId = 1234567890;    
    // Select Hive SDK AuthV4 Account Conflict    
    AuthV4::selectConflict(selectedPlayerId, [=](ResultAPI const &amp; result,PlayerInfo const &amp; playerInfo) {    

            if (result. isSuccess()) {    
                //账户选择成功    
            } else if (result. needExit()) {    
                // TODO: 实现应用退出功能    
                // Cocos2d-x 引擎的用户    
                // 例如) exit(0);    
                // Unreal 引擎用户    
                // 示例) UKismetSystemLibrary::QuitGame(GetWorld(), nullptr, EQuitPreference::Quit, false);    
            }    
});

#include "HiveAuthV4.h"

int64 SelectedPlayerId = 12345678;
FHiveAuthV4::SelectConflict(SelectedPlayerId,
                                                        FHiveAuthV4OnSignInDelegate::CreateLambda([this](const FHiveResultAPI& Result, const FHivePlayerInfo& PlayerInfo) {
        if (Result.IsSuccess()) {
                // 账户选择成功  
        } else if (Result.NeedExit()) {
                // TODO: 实现应用退出功能    
                    // ex) exitProcess(0)
        }
}));

API 参考: com.hive.AuthV4.selectConflict

val selectedPlayerId: Long = 1234567890    

    // 选择 Hive SDK AuthV4 账户冲突    
    AuthV4.selectConflict(selectedPlayerId, object : AuthV4.AuthV4SignInListener {    
            override fun onAuthV4SignIn(result: ResultAPI, playerInfo: AuthV4.PlayerInfo?) {    
                if (result. isSuccess) {    
                    // 账户选择成功    
                } else if (result. needExit()) {    
                    // TODO: 实现应用退出功能    
                    // 例如) exitProcess(0)    
                }    
            }    
})

API 参考: com.hive.AuthV4.selectConflict

long selectedPlayerId = 1234567890;    

    // 选择 Hive SDK AuthV4 账户冲突    
    AuthV4.selectConflict(selectedPlayerId, new AuthV4.AuthV4SignInListener() {    
            @Override    
            public void onAuthV4SignIn(ResultAPI result, AuthV4.PlayerInfo playerInfo) {    

                if(result. isSuccess()) {    
                    //账户选择成功    
                }    
                else if (result. needExit()) {    
                    // TODO: 实现应用退出功能    
                    // ex) System.exit(0);    
                }    
            }    
});

API 参考: HIVEAuthV4:selectConflict

let selectedPlayerId: Int64 = 1234567890;    

    // Hive SDK AuthV4 账户冲突选择请求    
    AuthV4Interface.selectConflict(selectedPlayerId) { (result, playerInfo) in    
            if result. isSuccess() {    
                //账户选择成功    
            }    
            else if result. needExit() {    
                // TODO: 实现应用退出功能    
                // ex) exit(0)    
            }    
}

API 参考: HIVEAuthV4:selectConflict

long long selectedPlayerId = 1234567890;    

    // Hive SDK AuthV4 账户冲突选择请求    
    [HIVEAuthV4 selectConflict:selectedPlayerId handler:^(HIVEResultAPI *result, HIVEPlayerInfo *playerInfo) {    

            if (result. isSuccess) {    
                //账户选择成功    
            }    
            else if (result. needExit) {    
                // TODO: 实现应用退出功能    
                // ex) exit(0);    
            }    
}];

从 IdP 账户断开连接

您可以允许用户在 IdP 账户列表 UI 上取消链接已链接的 IdP 账户。如果用户在 IdP 账户列表 UI 上取消链接特定的 IdP 账户，游戏工作室会调用 disconnect() 方法，并传入 ProviderType 参数，该参数是特定类型的 IdP，以断开与 IdP 账户的连接。在调用 disconnect() 方法后，您需要检查用户的连接状态，然后更新 UI 上的同步 IdP 列表。

Note

Windows环境不支持访客登录，与移动设备不同。因此，如果您尝试在仅同步一个IdP时调用断开连接API，将返回AuthV4LastProviderCantDisconnect作为结果API代码，并且同步状态将保持不变。

API 参考: hive .AuthV4.Helper.disconnect

using hive;    
    AuthV4.Helper.disconnect (AuthV4.ProviderType.HIVE, delegate (ResultAPI result, AuthV4.PlayerInfo playerInfo) {    
       switch (result.code) {    
         case ResultAPI.Code.Success:    
           // Provider disconnection successful    
           break;    
         default:    
           // other exception situations    
           break;    
       }    
});

#include "HiveAuthV4.h"

EHiveProviderType ProviderType = EHiveProviderType::HIVE;
FHiveAuthV4::Helper::Disconnect(ProviderType, FHiveAuthV4HelperDelegate::CreateLambda([this](const FHiveResultAPI& Result, const TOptional<FHivePlayerInfo>& PlayerInfo) {
        switch (Result.Code) {
                case FHiveResultAPI::ECode::Success:
                        // 提供者断开连接成功
                        break;
                default:
                        // 其他异常情况  
                        break;
        }
}));

API 参考: AuthV4 ::Helper::disconnect

#include <HIVE_SDK_Plugin/HIVE_CPP.h>    
    using namespace std;    
    using namespace hive;    
    AuthV4::Helper::disconnect(ProviderType::HIVE, [=](ResultAPI const & result, shared_ptr playerInfo) {    
    switch (result.code) {    
    case ResultAPI::Success:    
        // 提供者断开连接成功    
        break;    
        default:    
        // 其他异常情况    
        break;    
    }    
});

API 参考: Helper.disconnect

import com.hive.AuthV4    
    import com.hive.ResultAPI    
    AuthV4.Helper.disconnect(AuthV4.ProviderType.HIVE, object : AuthV4.Helper.AuthV4HelperListener {    
         override fun onAuthV4Helper(result: ResultAPI, playerInfo: AuthV4.PlayerInfo?) {    
             when (result.code) {    
                 ResultAPI.Code.Success -> {    
                     // 提供者断开连接成功    
                 }    
                 else -> {    
                     // 其他异常情况    
                 }    
             }    
         }    
})

API 参考: com .hive.AuthV4.Helper.disconnect

import com.hive.AuthV4;    
    import com.hive.ResultAPI;    
    AuthV4.Helper.INSTANCE.disconnect(AuthV4.ProviderType.HIVE, (result, playerInfo) -> {    
         switch (result.getCode()) {    
             case Success:    
                 // 提供者断开连接成功    
                 break;    
             default:    
                 // 其他异常情况    
                 break;    
         }    
});

API 参考: .disconnect

import HIVEService    
    AuthV4Interface.helper().disconnect(.Hive) { result, playerInfo in    
        switch result.getCode() {    
            case.success:    
            // 提供者断开连接成功    
            default:    
            // 其他异常情况    
            break    
        }    
}

API 参考: HIVEAuthV4Helper ::disconnect:handler:

#import <HIVEService/HIVEService-Swift.h>    
    [[HIVEAuthV4 helper] disconnect: HIVEProviderTypeHive handler: ^(HIVEResultAPI *result, HIVEPlayerInfo *playerInfo) {    
       switch ([result getCode]) {    
    case HIVEResultAPICodeSuccess:    
           // 提供者断开连接成功    
           break;    
         default:    
           // 其他异常情况    
           break;    
       }    
}];

游戏工作室在实现 IdP 断开连接时可以选择以下政策。 1. 解除所有 IdP 账户的链接，并允许使用访客账户。 2. 强制保持至少一个 IdP 账户链接。

从 IdP 账户断开连接：允许解除所有 IdP 账户

游戏工作室可以允许用户解除所有 IdP 账户的链接并使用访客账户。如果用户使用访客账户，则如果由于游戏的初始化或重新安装而丢失访客账户，该账户将无法恢复。因此，如果用户尝试解除最后一个链接的 IdP，请使用以下短语弹出关于访客用户的指导，以便该用户可以重新考虑解除链接。请注意，即使其对应的 IdP 被解除链接，PlayerID 也不会被注销。

  • 如果您想取消链接最后一个链接的 IdP 账户
语言 短语
韩语 最后一个账号关联解除时，将转换为游客状态。转换为游客状态后，重置设备或重装游戏时，游戏数据将被删除。确定要继续解除关联吗？
英语 如果您取消最后一个账户的同步，您将转移到访客账户。一旦您成为访客，当您重置设备或重新安装游戏时，您的游戏数据将被删除。您确定要继续取消账户同步吗？
日语 最後のアカウントの連動を解除すると、ゲストアカウントに切り替わります。ゲストアカウントに切り替わると、端末初期化またはゲームの再インストール時にゲームデータが削除されます。 アカウントの連動を解除しますか？
中文（简体） 解除最后一个账号关联时，将转换为游客状态。转换为游客状态后，重置设备或重装游戏时，游戏数据将被删除。确定要继续解除关联吗？
中文（繁体） 解除最後一個綁定的帳號時，將會切換為訪客帳號。使用訪客帳號時，若重置裝置或重新安裝遊戲，將會刪除遊戲數據。 確定要繼續解除帳號綁定？
法语 Si vous dissociez le dernier compte, votre compte sera converti en ""invité"". Si vous devenez ""invité"", votre historique de jeu sera supprimé lors de toute réinitialisation de votre appareil ou suppression du jeu. Êtes-vous sûr de vouloir procéder à la dissociation du compte ?
德语 Wenn du die Synchronisation des letzten Kontos aufhebst, wird dein Konto in ein Gastkonto umgewandelt. Sobald du ein Gast bist, werden deine Spieldaten gelöscht, wenn du dein Gerät zurücksetzt oder das Spiel neu installierst. Bist du sicher, dass du die Synchronisation des Kontos aufheben möchtest?
俄语 Если Вы отключите синхронизацию с последним аккаунтом, Ваша игровая учетная запись будет преобразована в гостевую. Если Вы используете гостевой аккаунт, Ваши игровые данные будут удалены при сбросе настроек устройства или переустановке игры. Вы действительно хотите отключить синхронизацию?
西班牙语 Si desvinculas la última cuenta, tu cuenta se convertirá en invitado. Si te conviertes en invitado, los datos del juego se eliminará cada vez que reinicies tu dispositivo o elimines el juego. ¿Estás seguro de que deseas desvincular la cuenta?
葡萄牙语 Se você dessincronizar a sua última conta, você será transferido para uma conta de convidado. Ao se tornar um convidado, os dados do seu jogo serão excluídos quando você resetar o aparelho ou reinstalar o jogo. Tem certeza de que deseja cancelar a sincronização da conta?
印尼语 Jika kamu batal sinkronisasi akun terakhir, akunn kamu akan diganti menjadi akun guest. Ketika kamu menjadi guest, data permainanmu akan dihapus ketika kamu mereset perangkat atau menginstall ulang game. Apakah kamu yakin mau membatalkan sinkronisasi akun?
越南语 Nếu bạn hủy đồng bộ tài khoản cuối cùng, bạn sẽ được chuyển sang tài khoản Khách. Khi bạn trở thành Khách, dữ liệu chơi game của bạn sẽ bị xóa khi bạn reset thiết bị hoặc cài đặt lại game. Bạn có chắc chắn muốn tiếp tục hủy đồng bộ tài khoản?
泰语 หากคุณยกเลิกการซิงค์บัญชีล่าสุด บัญชีของคุณจะย้อนกลับไปเป็นบัญชี Guest หากบัญชีคุณกลายเป็นบัญชี Guest ข้อมูลเกมของคุณจะถูกลบเมื่อคุณรีเซ็ตอุปกรณ์เล่นเกมหรือติดตั้งเกมใหม่อีกครั้ง ดำเนินการต่อโดยไม่ซิงค์บัญชีหรือไม่?
意大利语 Annullando la sincronizzazione dell'ultimo account, verrai trasferito/a a un account ospite. Una volta trasferito/a a un account ospite, i tuoi dati di gioco verranno eliminati in caso di ripristino di dispositivo o di reinstallazione del gioco. Sei sicuro/a di voler procedere con l'annullamento della sincronizzazione dell'account?
土耳其语 Son hesap senkronizasyonunu kaldırırsanız, misafir hesabına geçersiniz. Hesabınız misafire dönüştürüldüğünde, cihazı sıfırladığınızda veya oyunu yeniden yüklediğinizde oyun verileriniz silinir. Hesap senkronizasyonunu kaldırma işlemine devam etmek istediğinizden emin misiniz?
阿拉伯语 إذا ألغيت مزامنة الحساب الأخير ، فسيتم نقلك إلى حساب ضيف. وبمجرد أن تصبح ضيفًا ، سيتم حذف بيانات اللعبة عند إعادة ضبط الجهاز أو إعادة تثبيت اللعبة. هل أنت متأكد أنك تريد متابعة حساب غير متزامن؟

如果用户选择解除账户链接，即使上述短语被公开，调用 disconnect()。当用户账户变为访客账户时，以下短语可以被公开。

  • 如果用户帐户在与最后一个链接的身份提供者断开连接后变为访客帐户
语言 短语
韩语 已转换为游客状态。 关联账号时，有助于保护游戏数据。
英语 您已被转移到游客账户。通过同步您的账户，您可以保护您的游戏数据。
日语 ゲストアカウントに切り替わりました。 アカウントを連動することでゲームデータを守ることができます。
中文（简体） 已转换为游客状态。 关联账号时，有助于保护游戏数据。
中文（繁体） 已切換為訪客帳號。 請綁定帳號，保護您的遊戲數據。
法语 您已切换到“访客”账户。通过绑定您的账户，您可以确保保护您的游戏数据。
德语 您的账户已转换为游客账户。通过同步您的账户，您可以保护您的游戏数据。
俄语 您的账户已转换为访客账户。通过同步账户，您可以保护您的游戏数据。
西班牙语 您已切换到访客账户。通过绑定您的账户，您可以确保保护您的游戏数据。
葡萄牙语 您已转移到访客账户。通过同步您的账户，您可以保护您的游戏数据。
印尼语 您的状态已更改为访客。通过同步账户，您可以保护您的游戏数据。
越南语 您已被转移到游客账户。通过同步账户，您可以保护您的游戏数据。
泰语 您的账户已切换为访客账户。通过同步账户，您可以保护您的游戏数据。
意大利语 您已被转移到访客账户。通过同步您的账户，您可以保护您的游戏数据。
土耳其语 您的账户已转换为访客账户。通过绑定您的账户，您可以保护您的游戏数据。
阿拉伯语 您已被转移到访客账户。通过同步您的账户，您可以保护您的游戏数据。

从 IdP 账户断开连接：保持至少 1 个链接的账户

游戏工作室可能会强制用户保持至少一个 IdP 账户链接。当用户解除所有 IdP 账户的链接时，用户账户会转换为访客账户，如果由于初始化或重新安装游戏而丢失访客账户，则该账户无法恢复。因此，如果一个只有一个链接的 IdP 的用户尝试解除该 IdP 的链接，您可以使用下面的短语实现一个限制此操作的通知。请注意，即使解除其对应的 IdP 链接，PlayerID 也不会被注销。

  • 如果您想解除链接的最后一个 IdP 账户
语言 短语
韩语 최소 1개의 계정 연동을 유지해야 합니다.
英语 You must keep at least 1 of your accounts synced.
日语 少なくとも1つのアカウントを連動しなければなりません。
中文（简体） 需要绑定至少1个账号。
中文（繁体） 至少要有1個帳號是綁定的！
法语 Tu dois garder au moins l'un de tes comptes synchronisés.
德语 Du musst mindestens 1 deiner Konten synchronisieren.
俄语 Хотя бы 1 из аккаунтов должен быть синхронизирован.
西班牙语 Debe de mantener al menos 1 de sus cuentas sincronizada.
葡萄牙语 É necessário sincronizar pelo menos 1 das suas contas.
印度尼西亚语 Kamu harus punya paling tidak satu akun yang terhubung.
越南语 Bạn cần phải duy trì ít nhất 1 liên kết tài khoản.
泰语 ต้องซิงค์บัญชีอย่างหน่อย 1 บัญชี
意大利语 Devi mantenere almeno 1 dei tuoi account sincronizzato.
土耳其语 En az 1 hesabınızı senkronize etmeniz gerekmektedir.
阿拉伯语 يجب أن تحتفظ على الأقل بحساب واحد متزامن من بين حساباتك.

自定义 IdP 同步

自定义 IdP 同步是一个自定义功能，使游戏能够实现自定义 IdP，而不是使用 Hive SDK 提供的 IdP。 在调用自定义登录 API 后，您可以通过访问作为回调结果传递的 PlayerInfo 类实例中的 customProviderInfoData 数据来检查自定义 IdP 的登录用户信息。customProviderInfoData 的 ProviderType（枚举）被设置为 CUSTOM，并可以通过 ProviderName（字符串）进行区分。

以下是实现自定义 IdP 同步的示例代码。

// Twitter sync that is implemented by the game itself.
    Game.Connect"CUSTOM_TWITTER", (string authKey) =>; {

        AuthV4.connectWithAuthKeyauthKey, (ResultAPI result, PlayerInfo playerInfo) =>; {
                switchresult.code) {
                case ResultAPI.Code.Success:
                    // 同步成功
                    break;
                case ResultAPI.Code.AuthV4ConflictPlayer:
                    // 账户冲突
                    Dictionary&lt;string, ProviderInfo>; customProviderInfoData = playerInfo.customProviderInfoData;
                    ProviderInfo providerInfo = customProviderInfoData["CUSTOM_TWITTER"];
                    // 检查以下用户的同步信息
                    providerInfo.providerType;     // ProviderType.CUSTOM，providerType 固定为 ProviderType.CUSTOM。要区分，请使用 providerName。
                    providerInfo.providerName;   // "CUSTOM_TWITTER"
                    providerInfo.providerUserId;  // Twitter 登录的用户 ID，由游戏本身实现。
                    break;
                default:
                    // 其他异常
                    break;
                }
        });
    });

#include "HiveAuthV4.h"

// Twitter同步由游戏本身实现。
void GameConnect(const FString& AuthKey)
{
        FHiveAuthV4::ConnectWithAuthKey(AuthKey, FHiveAuthV4OnConnectDelegate::CreateLambda([this](const FHiveResultAPI& Result, const FHivePlayerInfo& ConflictPlayerInfo) {
                switch(Result.Code) {
                        case FHiveResultAPI::ECode::Success:
                                // 同步成功
                                break;
                        case FHiveResultAPI::ECode::AuthV4ConflictPlayer: {
                                // 账户冲突
                                TMap<FString, FHiveProviderInfo> CustomProviderInfoData = ConflictPlayerInfo.CustomProviderInfoData;
                                if (const FHiveProviderInfo* ProviderInfo = CustomProviderInfoData.Find(TEXT("CUSTOM_TWITTER"))) {
                                        // 检查以下用户的同步信息
                                        EHiveProviderType ProviderType = ProviderInfo->ProviderType; // ProviderType::CUSTOM，providerType固定为ProviderType::CUSTOM。要区分，请使用providerName。
                                        FString ProviderName = ProviderInfo->ProviderName; // "CUSTOM_TWITTER"
                                        FString ProviderUserId = ProviderInfo->ProviderUserId; // Twitter登录的用户ID，由游戏本身实现。
                                }
                        }
                                break;
                        default:
                                // 其他异常
                                break;
                }
        }));
}

// Twitter sync that is implemented by the game itself.
        Game::Connect"CUSTOM_TWITTER", [=]string authKey) {

            AuthV4::connectWithAuthKeyauthKey, [=]ResultAPI const &amp; result, PlayerInfo const &amp; playerInfo) {
                switch (result.code) {
                    case ResultAPI::Success:
                    // 同步成功
                    break;
                    case ResultAPI::AuthV4ConflictPlayer:
                    // 账户冲突
                    map&lt;string, ProviderInfo>; customProviderInfoData = playerInfo.customProviderInfoData;
                    ProviderInfo providerInfo = customProviderInfoData["CUSTOM_TWITTER"];
                    // 检查以下用户的同步信息
                    providerInfo.providerType;     // ProviderType::CUSTOM，providerType 固定为 ProviderType::CUSTOM。要区分，请使用 providerName。
                    providerInfo.providerName;   // "CUSTOM_TWITTER"
                    providerInfo.providerUserId;  // Twitter 登录的用户 ID，由游戏本身实现。
                    break;
                    default:
                    // 其他异常
                    break;
                }
            });
        });

// 由游戏本身实现的Twitter同步。
        Game.Connect"CUSTOM_TWITTER") { authKey: String ->;

            AuthV4.connectWithAuthKeyresponse.authKey, object : AuthV4.AuthV4ConnectListener {
                override fun onAuthV4Connectresult: ResultAPI, conflictPlayer: AuthV4.PlayerInfo?) {
                    whenresult.code) {
                        case ResultAPI.Code.Success ->; {
                            // 同步成功
                        }
                        case ResultAPI.Code.AuthV4ConflictPlayer ->; {
                            // 账户冲突
                            playerInfo.customProviderInfoData["CUSTOM_TWITTER"]?.let { providerInfo ->;
                            providerInfo.providerType     // ProviderType.CUSTOM，providerType 固定为 ProviderType.CUSTOM。要区分，请使用 providerName。
                            providerInfo.providerName   // "CUSTOM_TWITTER"
                            providerInfo.providerUserId  // Twitter 登录的用户 ID，由游戏本身实现。
                        }
                        else ->; {
                            // 其他异常
                        }
                    }
                }
            }
        }

// Twitter sync that is implemented by the game itself.
        Game.Connect"CUSTOM_TWITTER", new Callback) {
            @Override
            public void onResponseString authKey) {

                com.hive.AuthV4.INSTANCE.connectWithAuthKeyauthKey, new com.hive.AuthV4.AuthV4ConnectListener) {
                    @Override
                    public void onAuthV4ConnectResultAPI result, PlayerInfo conflictPlayer) {
                        switch (result.getCode)) {
                            case ResultAPI.Code.Success:
                                // 同步成功
                                break;
                            case ResultAPI.Code.AuthV4ConflictPlayer:
                                // 账户冲突
                                ProviderInfo providerInfo = conflictPlayer.getCustomProviderInfoData().get("CUSTOM_TWITTER");
                                providerInfo.getProviderType();     // ProviderType.CUSTOM，providerType 固定为 ProviderType.CUSTOM。要区分，请使用 providerName。
                                providerInfo.getProviderName();   // "CUSTOM_TWITTER"
                                providerInfo.getProviderUserId();  // Twitter 登录的用户 ID，由游戏本身实现。
                                break;
                            default:
                                // 其他异常
                                break;
                        }
                    }
                });
            }
        });

// Twitter sync that is implemented by the game itself.
        Game.connect"CUSTOM_TWITTER") { (authKey) in

            AuthV4Interface.connectWithAuthKeyauthKey) { result, conflictPlayer in
                    switch(result.getCode()){
                    case .success:
                        // 同步成功
                        break
                    case .authV4ConflictPlayer:
                        // 账户冲突
                    guard let customProviderInfoData = playerInfo?.customProviderInfoData,
                            let providerInfo = customProviderInfoData["CUSTOM_TWITTER"] else {
                        // 用户没有同步信息，失败处理
                        return
                    }

                    // 检查以下用户的同步信息
                    providerInfo.providerType     // HIVEProviderTypeCustom，providerType 固定为 HIVEProviderTypeCustom。要区分，请使用 providerName。
                    providerInfo.providerName   // "CUSTOM_TWITTER"
                    providerInfo.providerUserID  // Twitter 登录的用户 ID，由游戏本身实现。
                        break
                    default:
                        // 其他异常
                        break
                    }
                }
        }

// Twitter sync that is implemented by the game itself.
        [Game connect:@"CUSTOM_TWITTER" handler:^NSString* authKey) {

            [HIVEAuthV4 connectWithAuthKey:authKey handler:^HIVEResultAPI* result, HIVEPlayerInfo* playerInfo) {
                    switch(result.code) {
                    case kSuccess:
                        // sync success
                        break;
                    case kAuthV4ConflictPlayer:
                        // account conflict
                        NSDictionary&lt;NSString*, HIVEProviderInfo*>;* customProviderInfoData = playerInfo.customProviderInfoData;
                        ProviderInfo* providerInfo = [customProviderInfoData objectForKey:@"CUSTOM_TWITTER"];
                        // Check the following sync information for the user
                        providerInfo.providerType;  
    providerInfo.providerType     // HIVEProviderTypeCustom, providerType is fixed to HIVEProviderTypeCustom. To distinguish, use providerName.
                        providerInfo.providerName;   // "CUSTOM_TWITTER"
                        providerInfo.providerUserId;  // the user id for the Twitter login, implemented by the game itself.
                        break;
                    default:
                        // Other exceptions
                        break;
                    }
            }];
        }];

取消链接自定义 IdP

您可以禁用与自定义 IdP 的同步。基本上，过程与断开 IdP 相同，但它需要 providerName 来请求断开连接。

Note

注意所有 IdP 同步断开连接的情况。请参阅 IdP 断开连接部分中的注意事项。

以下示例代码展示了如何实现自定义 IdP 断开连接。

string customProviderName = "CUSTOM_TWITTER";

AuthV4.disconnectWithName (customProviderName, delegate (ResultAPI result) {
    switch(result.code) {
    case ResultAPI.Code.Success:
        // 提供者断开连接成功
        break;
    default:
        // 其他异常
        break;
    }
});

#include "HiveAuthV4.h"

FString CustomProviderName = TEXT("CUSTOM_TWITTER");
FHiveAuthV4::DisconnectWithName(CustomProviderName, FHiveAuthV4OnDisconnectDelegate::CreateLambda([this](const FHiveResultAPI& Result) {
        if (Result.IsSuccess()) {
                // Provider disconnection success
        } else {
                // Other exceptions
        }
}));

std::string customProviderName = "CUSTOM_TWITTER"

AuthV4::disconnectWithName(customProviderName, [=](ResultAPI const & result) {
        switch (result.code) {
        case ResultAPI::Success:
            // 提供者断开连接成功
            break;
        default:
            // 其他异常
            break;
        }
});

val customProviderName = "CUSTOM_TWITTER"

AuthV4.disconnectWithName(customProviderName, object : AuthV4.AuthV4DisconnectListener {
    override fun onAuthV4Disconnect(result: ResultAPI) {

            当(result.code) {
            成功 -> {
                // 提供者断开连接成功
            }
            其他 -> {
                // 其他异常
            }
        }
    }
})

String customProviderName = "CUSTOM_TWITTER";

AuthV4.INSTANCE.disconnectWithName(customProviderName, new AuthV4.AuthV4DisconnectListener() {

    @Override
    public void onAuthV4Disconnect(ResultAPI result) {
        switch(result.code) {
            case Success:
                // 提供者断开连接成功
                break;
            default:
                // 其他异常
                break;
        }
    }
});

let customProviderName = "CUSTOM_TWITTER"

AuthV4Interface.disconnectWithName(customProviderName) { result  in
        switch(result.getCode()){
        case .success:
            // 提供者断开连接成功
        break
        default:
            // 其他异常
        break
        }
    }

NSString* customProviderName = @"CUSTOM_TWITTER";

[HIVEAuthV4 disconnectWithName:customProviderName handler:^(HIVEResultAPI *result) {
    switch(result.code) {
    case kSuccess:
        // Provider disconnection success
        break;
    default:
        // Other exceptions
        break;
    }
}];

删除 IdP 和访客帐户

您需要配置用户界面，以便用户可以在游戏中删除他们的账户。

  • 用户界面的示例
Warning

从2022年6月30日起，提交到App Store的支持账户创建的应用程序必须允许用户在应用程序内启动删除其账户。如果您正在更新应用程序或提交带有账户创建的新应用程序，则必须实现账户删除API，以防止审核延迟。有关从App Store删除应用程序的更多信息，请参见Apple政策指南。

在游戏中配置并显示弹出窗口，以确认用户是否继续删除帐户。您可以查看下面的弹出窗口短语。

如果确认删除账户的请求，您可以使用 Hive SDK API 或 Hive 服务器 API 删除此 Authentication v4 账户。

  • 删除帐户的步骤

* **使用 Hive 服务器 API 删除时**: <br>
一旦在游戏客户端删除了账户，游戏服务器应调用 Hive 服务器 API [删除身份验证 v4 账户](../../api/hive-server-api/auth/authv4-account-deletion.md) 将已删除账户的信息发送到身份验证服务器。身份验证服务器接收此信息并删除该账户。删除后，身份验证服务器将账户删除的结果发送给游戏服务器，游戏服务器将其传递给游戏客户端。一旦游戏客户端收到账户删除的结果，它应提供弹出窗口，通知账户已被删除。在游戏客户端（Hive SDK）中，无论账户是<u>**基于 IdP 还是访客账户**</u>，在账户被删除后都调用 `signOut()`。

* **使用 Hive SDK API 删除时**: <br>
一旦游戏客户端侧的玩家账户被删除，游戏服务器应该调用 `playerDelete()
` 将已删除账户的信息发送到认证服务器。如果您收到了来自认证服务器的账户删除回调结果，您应该在游戏侧提供弹出窗口，通知账户已被删除。

以下是通过 Hive SDK API 删除帐户的 AuthV4 示例代码。

API 参考: AuthV4.playerDelete

// 请求 Hive SDK 账户删除
        AuthV4.playerDeletedelegate (ResultAPI result) {
            switchresult.code) {
                case ResultAPI.Code.Success:
                    // 删除完成
                    break;
                default:
                    // 其他异常
                    break;
            }
        });

#include "HiveAuthV4.h"

FHiveAuthV4::PlayerDelete(FHiveAuthV4OnSignOutDelegate::CreateLambda([this](const FHiveResultAPI& Result) {
        switch(Result.Code) {
                case FHiveResultAPI::ECode::Success:
                        // 删除完成
                        break;
                default:
                        // 其他异常
                        break;
        }
}));

API 参考:AuthV4::playerDelete

// 请求 Hive SDK 账户删除
        AuthV4::playerDelete[=]ResultAPI const &amp; result) {
                switch (result.code) {
                    case ResultAPI::Success:
                        // 删除完成
                        break;
                    default:
                        // 其他异常
                        break;
                }
        });

API 参考: AuthV4.playerDelete

// 请求 Hive SDK 账户删除
    AuthV4.playerDeleteobject : AuthV4.AuthV4SignOutListener {
        override fun onAuthV4SignOutresult: ResultAPI) {
            whenresult.code) {
                ResultAPI.Code.Success ->; {
                    // 删除完成
                }
                else ->; {
                    // 其他异常
                }
            }
        }
    })

API 参考: AuthV4.INSTANCE.playerDelete

// 请求 Hive SDK 账户删除
    AuthV4.INSTANCE.playerDeletenew AuthV4.AuthV4SignOutListener) {
        @Override
        public void onAuthV4SignOutResultAPI result) {
            switchresult.code) {
                case Success:
                    // 删除完成
                    break;
                default:
                    // 其他异常
                    break;
            }
        }
    });

// 请求 Hive SDK 账户删除
    AuthV4Interface.playerDelete { result in
        switchresult.code) {
        case Success:
            // 删除完成
            break;
        default:
            // 其他异常
            break;
        }
    }

API 参考: HIVEAuthV4Helper::playerDelete:

// 请求 Hive SDK 账户删除
    [[HIVEAuthV4] playerDelete:^HIVEResultAPI *result) {
        switchresult.code) {
        case Success:
            // 删除完成
            break;
        default:
            // 其他异常
            break;
        }
    }];

以下是通过 Hive SDK API 删除账户的 AuthV4.Helper 示例代码。

API 参考: AuthV4.playerDelete

// 请求 Hive SDK 账户删除
        AuthV4.Helper.playerDelete(delegate (ResultAPI result, AuthV4.PlayerInfo playerInfo) {
    switch(result.code) {
        case ResultAPI.Code.Success:
            // 删除成功
            break;
        default:
            // 其他异常情况
            break;
    }
});

API 参考:AuthV4::playerDelete

// Requesting Hive SDK account deletion
AuthV4::Helper::playerDelete([=](ResultAPI const & result, std::shared_ptr playerInfo) {
        switch (result.code) {
            case ResultAPI::Success:
                // 删除成功
                break;
            default:
                // 其他异常情况
                break;
        }
});

API Reference: AuthV4.playerDelete

// 请求 Hive SDK 账户删除
AuthV4.Helper.playerDelete(object : AuthV4.Helper.AuthV4HelperListener {
override fun onAuthV4Helper(result: ResultAPI, playerInfo: AuthV4.PlayerInfo?) {
    when(result.code) {
        ResultAPI.Code.Success -> {
            // 删除成功
        }
        else -> {
            // 其他异常情况
            }
        }
    }
})

API 参考: AuthV4.INSTANCE.playerDelete

// 请求 Hive SDK 账户删除
AuthV4.Helper.INSTANCE.playerDelete(new AuthV4.Helper.AuthV4HelperListener() {
@Override
public void onAuthV4Helper(ResultAPI result, AuthV4.PlayerInfo playerInfo) {
        switch(result.code) {
            case Success:
                // 删除成功
                break;
            default:
                // 其他异常情况
                break;
        }
    }
});

API 参考: AuthV4Interface.helper().playerDelete

// 请求 Hive SDK 账户删除
// Hive SDK 账户删除请求
AuthV4Interface.helper().playerDelete { result, playerInfo in
    switch(result.code) {
    case Success
            case Success:
            // 删除完成
            break;
    default:
        // 其他异常
        break;
        }
    }

API 参考: HIVEAuthV4Helper::playerDelete:

// 请求 Hive SDK 账户删除
    [[HIVEAuthV4 helper] playerDelete:^HIVEResultAPI *result, HIVEPlayerInfo *playerInfo) {
        switchresult.code) {
        case Success:
            // 删除完成
            break;
        default:
            // 其他异常
            break;
        }
    }];

当用户看到游戏标题屏幕时，显示 IdP 列表以让该用户登录（如果您不使用 Hive 平台提供的登录 UI，请显示您游戏特定的登录 UI）。

确认账户删除的弹出消息

用户在删除账户时出现的账户删除确认弹出窗口的文本如下。

语言 安卓 iOS
韩语 删除账户时，绑定的数据将被删除。 删除部分游戏数据最多需要90天时间。 * 付费相关咨询请联系[Company Name]客服中心。 删除账户时，绑定的数据将被删除。 删除部分游戏数据最多需要90天时间。 * 付费相关咨询请联系应用商店或[Company Name]客服中心。
英语 删除账户时，绑定的数据将被删除。 删除部分游戏数据最多需要90天时间。 * 请联系[Company Name]客服支持以获取与付款相关的咨询。 删除账户时，绑定的数据将被删除。 删除部分游戏数据最多需要90天时间。 * 请联系App Store或[Company Name]客服支持以获取与付款相关的咨询。
日语 アカウントを削除すると連動データも削除されます。 一部ゲームデータの削除には時間がかかる場合があります。(最大90日) ＊決済に関するお問い合わせは[Company Name]サポートセンターにご連絡ください。 アカウントを削除すると連動データも削除されます。 一部ゲームデータの削除には時間がかかる場合があります。(最大90日) ＊決済に関してはApp Storeまたは[Company Name]サポートセンターにお問い合わせください。
中文（简体） 删除账户时，绑定的数据将被删除。 删除部分游戏数据最多需要90天时间。 * 付费相关咨询请联系[Company Name]客服中心。 删除账户时，绑定的数据将被删除。 删除部分游戏数据最多需要90天时间。 * 付费相关咨询请联系应用商店或[Company Name]客服中心。
中文（繁体） 刪除帳號時也將刪除綁定的數據。 刪除部分遊戲數據最長需90天的時間。 * 結帳相關諮詢請至[Company Name]客服中心。 刪除帳號時也將刪除綁定的數據。 刪除部分遊戲數據最長需90天的時間。 * 結帳相關諮詢請至App Store或[Company Name]客服中心。
德语 Wenn du dein Konto löschst, werden alle verknüpften Daten gelöscht. Die Löschung einiger Spieldaten kann bis zu 90 Tage dauern. * Bei zahlungsbezogenen Fragen wende dich bitte an den [Company Name] Kundenservice. Wenn du dein Konto löschst, werden alle verknüpften Daten gelöscht. Die Löschung einiger Spieldaten kann bis zu 90 Tage dauern. * Bei zahlungsbezogenen Fragen wende dich bitte an den App-Store oder den [Company Name] Kundenservice.
法语 Si vous supprimez votre compte, les données associées seront également supprimées. La suppression de certaines données de jeu peut prendre jusqu'à 90 jours. * Pour toute demande relative aux paiements, veuillez contacter le service client [Company Name]. Si vous supprimez votre compte, les données associées seront également supprimées. La suppression de certaines données de jeu peut prendre jusqu'à 90 jours. * Pour toute demande relative aux paiements, veuillez contacter le service client de l'App Store ou de [Company Name].
俄语 Если Вы удалите свой аккаунт, привязанные к нему данные будут также удалены. Удаление некоторых игровых данных может занять до 90 дней. * По вопросам, связанным с оплатой, пожалуйста, обратитесь в службу поддержки [Company Name]. Если Вы удалите свой аккаунт, привязанные к нему данные будут также удалены. Удаление некоторых игровых данных может занять до 90 дней. * По вопросам, связанным с оплатой, пожалуйста, обратитесь в App Store или службу поддержки [Company Name].
西班牙语 Se eliminarán los datos asociados cuando elimine la cuenta. La eliminación de algunos datos del juego puede demorarse hasta 90 días. * Por favor, póngase en contacto con el servicio de atención al cliente de [Company Name] para consultas relacionadas con el pago. Se eliminarán los datos asociados cuando elimine la cuenta. La eliminación de algunos datos del juego puede demorarse hasta 90 días. * Por favor, póngase en contacto con el App Store o con el servicio de atención al cliente de [Company Name] para consultas relacionadas con el pago.
葡萄牙语 Os dados vinculados à conta serão excluídos quando você excluir a conta. A exclusão de alguns dados do jogo pode levar até 90 dias. * Entre em contato com o Suporte ao Cliente do(a) [Company Name] para consultas relacionadas a pagamentos. Os dados vinculados à conta serão excluídos quando você excluir a conta. A exclusão de alguns dados do jogo pode levar até 90 dias. * Entre em contato com a App Store ou com o Suporte ao Cliente do(a) [Company Name] para consultas relacionadas pagamentos.
印尼语 Data yang terhubung akan dihapus ketika kamu menghapus akun. Beberapa penghapusan data game akan memakan waktu hingga 90 hari. * Silakan hubungi Customer Support [Company Name] untuk melaporkan permasalahan terkait pembayaran. Data yang terhubung akan dihapus ketika kamu menghapus akun. Beberapa penghapusan data game akan memakan waktu hingga 90 hari. * Silakan hubungi Customer Support App Store atau [Company Name] untuk melaporkan permasalahan terkait pembayaran.
泰语 ถ้าคุณลบบัญชีของคุณ ข้อมูลที่เชื่อมต่อไว้จะถูกลบไปด้วย การลบข้อมูลเกมบางส่วนอาจใช้เวลาสูงสุดถึง 90 วัน * กรุณาติดต่อฝ่ายลูกค้าสัมพันธ์ [Company Name] หากต้องการส่งคำร้องหรือมีข้อสงสัยเกี่ยวกับการชำระเงิน ถ้าคุณลบบัญชีของคุณ ข้อมูลที่เชื่อมต่อไว้จะถูกลบไปด้วย การลบข้อมูลเกมบางส่วนอาจใช้เวลาสูงสุดถึง 90 วัน * กรุณาติดต่อ App Store หรือฝ่ายลูกค้าสัมพันธ์ [Company Name] หากต้องการส่งคำร้องหรือมีข้อสงสัยเกี่ยวกับการชำระเงิน
越南语 如果您删除帐户，连接的数据将被删除。某些游戏数据的删除可能需要最长90天。 * 有关付款的任何疑问，请联系[公司名称]的客户支持中心。 如果您删除帐户，连接的数据将被删除。某些游戏数据的删除可能需要最长90天。 * 有关付款的任何疑问，请联系[公司名称]的客户支持中心或应用商店。
意大利语 删除帐户时，相关数据也将被删除。删除某些游戏数据可能需要长达90天。 * 有关付款请求，请联系[公司名称]的客户支持。 "删除帐户时，相关数据也将被删除。删除某些游戏数据可能需要长达90天。 * 有关付款请求，请联系应用商店或[公司名称]的客户支持。
土耳其语 删除帐户时，连接的数据将被删除。某些游戏数据的删除可能需要长达90天。 * 有关付款问题，请联系[公司名称]客户支持。 删除帐户时，连接的数据将被删除。某些游戏数据的删除可能需要长达90天。 * 有关付款问题，请联系应用商店或[公司名称]客户支持。
阿拉伯语 删除帐户时，相关数据将被删除。某些游戏数据的删除可能需要长达90天。 * 有关付款的任何疑问，请联系[公司名称]的客户支持中心。 删除帐户时，相关数据将被删除。某些游戏数据的删除可能需要长达90天。 * 有关付款的任何疑问，请联系应用商店或[公司名称]的客户支持中心。
Note

在文本中输入您游戏公司客户服务中心的名称，[公司名称]。

提供订阅的游戏需要在确认账户删除的弹出消息中添加以下短语：“即使您删除账户，自动订阅仍会被收费，您需要手动取消订阅。”（以及以下表格中其他语言的短语）

韩语 即使删除账户，自动订阅商品也会收取费用，因此需要手动取消订阅。
英语 自动订阅将仍然会收费，即使您删除了账户，您需要手动取消订阅。
日语 アカウントを削除しても定期購入商品は解約されず料金が請求されますので、手動で解約してください。
中文（简体） 即使删除账号，自动订阅商品也会按期收取费用，因此必须手动解除订阅。
中文（繁体） 即使刪除帳號，自動訂閱商品仍會繼續扣款，需親自解除訂閱。
德语 Automatische Abonnements werden auch dann noch berechnet, wenn du dein Konto gelöscht hast. Du musst dich manuell abmelden.
法语 Les abonnements automatiques seront toujours facturés même si vous supprimez votre compte, vous devrez donc vous désabonner vous-même.
俄语 Автоматическая подписка будет по-прежнему взимать плату даже при удалении аккаунта, поэтому Вам необходимо отменить подписку отдельно.
西班牙语 Las suscripciones automáticas aún se cobrarán incluso si elimina su cuenta, y debe darlas de baja manualmente.
葡萄牙语 As assinaturas automáticas ainda serão cobradas mesmo se você excluir sua conta, sendo necessário que você as cancele manualmente.
印度尼西亚语 Berlangganan otomatis akan tetap dikenakan biaya meskipun kamu menghapus akun, kamu harus membatalkan berlangganan secara manual.
泰语 การสมัครแพ็กเกจต่าง ๆ โดยอัตโนมัติจะยังมีผลอยู่แม้ว่าคุณลบบัญชีไปแล้ว และคุณต้องยกเลิกการสมัครแพ็กเกจเหล่านั้นด้วยตัวเอง
越南语 Bạn vẫn sẽ phải trả phí cho các vật phẩm đã đăng ký thanh toán tự động kể cả khi đã xóa tài khoản, vì thế bạn cần phải trực tiếp hủy bỏ đăng ký.
意大利语 Gli abbonamenti automatici verranno comunque addebitati anche dopo aver eliminato l'account, quindi bisogna annullare le rispettive iscrizioni separatamente.
土耳其语 Hesabınızı silseniz bile otomatik abonelikler ücretlendirilecektir ve manuel olarak abonelikten çıkmanız gerekir.
阿拉伯语 سيستمر فرض رسوم على الاشتراكات التلقائية حتى إذا قمت بحذف حسابك ، وتحتاج إلى إلغاء الاشتراك يدويًا.

完成账户删除时的弹出消息

语言 短语
韩语 계정 삭제가 완료되었습니다.
英语 The account has been deleted.
日语 アカウント削除が完了しました。
中文（简体） 已删除账号。
中文（繁体） 已成功刪除帳號。
德语 Das Konto wurde gelöscht.
法语 La suppression du compte a été effectuée
俄语 Аккаунт удален.
西班牙语 La cuenta se ha suprimido.
葡萄牙语 A conta foi excluída.
印尼语 Akun telah dihapus.
泰语 บัญชีถูกลบแล้ว
越南语 Đã hoàn thành xóa tài khoản.
意大利语 L'account è stato cancellato.
土耳其语 Hesap silme tamamlandı.
阿拉伯语 تم حذف حسابك بنجاح.

账户删除失败时的弹出消息

语言 短语
韩语 계정 삭제가 실패되었습니다. 잠시 후 다시 진행해 주세요.
英语 Failed to delete the account. Please try again later.
日语 アカウント削除に失敗しました。しばらくしてからもう一度お試しください。
中文（简体） 账号删除失败。请稍后再试。
中文（繁体） 帳號刪除失敗，請稍後再試。
德语 Das Konto konnte nicht gelöscht werden. Bitte versuche es später erneut.
法语 La suppression du compte a échoué. Veuillez réessayer dans quelques instants.
俄语 Не удалось удалить аккаунт. Пожалуйста, попробуйте позже.
西班牙语 Hubo un error al eliminar la cuenta. Por favor, inténtelo de nuevo más tarde.
葡萄牙语 Falha ao excluir a conta. Por favor, tente novamente mais tarde.
印尼语 Gagal menghapus akun. Silakan coba lagi nanti.
泰语 การลบบัญชีล้มเหลว กรุณาลองใหม่ภายหลัง
越南语 Xóa tài khoản thất bại. Vui lòng thử lại sau.
意大利语 Eliminazione dell'account fallito. Riprova più tardi.
土耳其语 Hesap silme başarısız. Daha sonra tekrar deneyiniz.
阿拉伯语 فشل حذف الحساب. يرجى إعادة المحاولة في وقت لاحق.