Idpのリンク

サインイン後、ユーザーが現在使用しているPlayerIDの同期状況を表示し、他のIDプロバイダー（IdP）とリンクできる機能を提供します。 ゲーム設定メニューにIdPの同期状況を表示し、ユーザーがIdPに接続および切断できるようにUIを構成します。

IdP同期ステータスの情報を確認する¶

現在ログインしているPlayerIDと同期されたIdPリストを見るには、AuthV4クラスのgetPlayerInfo()メソッドを使用できます。ゲーム設定画面では、どのIdPが同期されているかを確認できるようにUIを設定し、IdP同期を提案するフレーズを公開してください。

ゲーム設定画面では、各ユーザーのPlayerIDをIdP同期情報とともに表示する必要があります。PlayerIDはCSコードの形式で、現在ログインしているユーザーの値で表示してください。

• 現在ログインしているPlayerIDと同期されたIdPを確認するための例の画面

• アカウントリンクのサンプル画面

以下は、setup()から返されるproviderTypeListを通じて現在のアプリによって提供されるIdPのリストです。PlayerIDにリンクされたIdPのリストを確認し、指定された例のコードを使用してリンク状況を表示してください。

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  
        }
}

// Hive SDK AuthV4の同期ステータスをリクエストする    
        for( auto providerInfo : AuthV4::getPlayerInfo().providerInfoData ) {    
            cout<<"プロバイダータイプ : "<<ProviderInfo::stringProviderType(providerInfo.second.providerType)<<endl;    
            cout<<"プロバイダーユーザーID : "<<providerInfo.second.providerUserId<<endl;    
    }

//Search the verified user data    
    AuthV4.PlayerInfo playerInfo = AuthV4.getPlayerInfo();

HIVEPlayerInfo *playerInfo = [HIVEAuthV4 getPlayerInfo];    

        for (NSString *providerTypeStr in [playerInfo.providerInfoData allKeys]) {    
            // 同期されたプロバイダーデータ    
            HIVEProviderInfo *providerInfo = playerInfo.providerInfoData[providerTypeStr];    
    }

IdP同期を提案するフレーズ¶

IdP同期¶

現在ログインしているPlayerIDは新しいIdPと同期できます。しかし、ユーザーが異なるPlayerIDにリンクされたIdPと同期しようとすると、エラーが発生します。同期が成功した場合は、同期ステータス情報を確認し、同期情報UIを更新してください。

IdP接続に追加したいIdPが別のPlayerIDにリンクされている場合、これはアカウントの競合状況と呼ばれます。この競合状況を解決するには、IdPを使用してアカウントの競合を処理するを参照してください。

IdP統合のために、connect ()メソッドを呼び出し、作業したいProviderTypeをパラメータとして渡します。以下はIdP同期を実装するためのサンプルコードです。

// Hive SDK AuthV4 Request to sync with IdP    
        AuthV4.Helper.connect (providerType, delegate (ResultAPI result, AuthV4.PlayerInfo playerInfo) {    
            switch(result.code) {    
            case ResultAPI.Code.Success:    
                // Success to sync IdP    
                break;    
            case ResultAPI.Code.AuthV4ConflictPlayer:    
                // Account conflict    
                break;    
            default:    
                // Exceptional case    
                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;
        }
}));

// Hive SDK AuthV4 Request to sync with IdP    
        AuthV4::Helper::connect(ProviderInfo::providerTypeFromString(providerType), [=](ResultAPI const & result, std::shared_ptr playerInfo) {    
                switch (result.code) {    
                case ResultAPI::Success:    
                    // IdPとの同期に成功    
                    break;    
                case ResultAPI::AuthV4ConflictPlayer:    
                    // アカウントの競合    
                    break;    
                default:    
                    // 異常ケース    
                    break;    
                }    
    });

// Hive SDK AuthV4 Request to sync with 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;    
                }    
            }    
    });

// 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 Syncによるアカウントの競合処理¶

IdP統合のためにconnect()が呼び出されると、ユーザーが接続しようとしているIdPアカウントが別のPlayerIDに既にリンクされている場合、アカウントの競合が発生します。さらなる説明のために、以下の状況を仮定します。

• CurrentPlayer: ユーザーが現在ログインしているアカウントのプレイヤー（ゲストアカウントまたはIdPアカウント）
• ConflictPlayer: ユーザーがリンクしたいIdPアカウントに既に存在するプレイヤー

ConflictPlayerのゲームプレイ記録がゲームサーバーに存在する場合¶

この場合、アカウントの競合が発生したとき、ConflictPlayerのプレイ情報がユーザーに通知され、ConflictPlayerを選択するためのUIが表示されます。Hive SDKが提供するUIを使用するには、ゲームに合わせたConflictPlayer情報を設定し、ConflictPlayer情報をパラメータとしてshowConflict()メソッドを呼び出します。呼び出されると、ConflictPlayerに切り替えることができ、キャンセルを選択するとCurrentPlayerでゲームを続けることができます。以下のUI画像の例では、チェックボタンをクリックするとConflictPlayerに切り替わり、XボタンをクリックするとCurrentPlayerでゲームが続行されます。

ConflictPlayerのゲームプレイ記録がゲームサーバーに存在しない場合¶

時には、ConflictPlayerのプレイヤー識別子（PlayerId）だけが存在し、ゲームサーバー上に実際のプレイ記録がない場合があります。この場合、resolveConflict(CB)を呼び出してCurrentPlayerのPlayerIDを選択し、ゲームを続行します。アカウントの競合が発生した場合は、以下のUIを表示します。

• 現在のプレイヤーがゲストアカウントで、対立するプレイヤーがIdPアカウントの場合

  • 「確認」ボタンが表示され、ユーザーがそれをクリックすると、現在のプレイヤーはログインしたままになります

• 現在のプレイヤーがIdPアカウント1（例：Facebook）で、コンフリクトプレイヤーが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の2つの重要なキーで構成されています。

• player_id: ConflictPlayerのPlayerID\n
• 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を返します。

以下は、Hive SDK が提供する UI を実装するためのサンプルコードで、衝突した PlayerID のゲームデータを設定しています。

// 競合したアカウントのゲーム情報オブジェクトを作成    
    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;
                }
        }
}));

// create game info object of the conflicted account    
    ConflictSingleViewInfo* conflictInfo = new ConflictSingleViewInfo(playerId);    
    conflictInfo->;SetValue("Gold", 2048);    
    conflictInfo->;SetValue("Gem", 220);    


    // Hive SDK AuthV4::Helper アカウント選択 UI リクエスト    
    AuthV4::Helper::showConflict(*conflictInfo, [=](ResultAPI const & 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;    
                }    
            }    
});    

// 矛盾したアカウントのゲーム情報オブジェクトを作成する    
    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 ->; {    
                            // 他の例外を処理    
                        }    
                    }    
                }    
            }    
})

// create game info object of the conflicted account    
    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: アプリの終了を実装する。    
                    // 例) System.exit(0);    
                } else {    
                    switch(result.code) {    
                        case AuthV4PlayerChange:    
                            // アカウント切り替え: ゲームの再起動が必要    
                            break;    
                        case AuthV4CancelDialog:    
                            // 現在のユーザーを維持    
                            break;    
                        case AuthV4NotRegisteredDevice:    
                            // これはデバイス認証の失敗によってログインがキャンセルされた場合です。AUTOで再ログインするか、ログアウトしてください。    
                            break;    
                        default:    
                            // 他の例外を処理する    
                            break;    
                    }    
                }    
            }    
});

// create game info object of the conflicted account    
    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: アプリの終了を実装する。    
                // 例) exit(0)    
            } else {    
                switch result.getCode() {    
                case .authV4PlayerChange:    
                    // アカウント切り替え: ゲームの再起動が必要    
                case .authV4CancelDialog:    
                    // 現在のユーザーを保持    
                case .authV4NotRegisteredDevice:    
                    // これはデバイス認証の失敗によりログインがキャンセルされた場合です。AUTOで再度ログインを試みるか、ログアウトしてください。    
                default:    
                    // 他の例外を処理    
                    break    
                }    
            }    
}

// 競合アカウントのゲーム情報オブジェクトを作成する    
    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: implement the termination of the app.    
                // ex) exit(0);    
            } else {    
                switch(result.code) {    
                    case kAuthV4PlayerChange:    
                        // account switching: game restart required    
                        break;    
                    case kAuthV4CancelDialog:    
                        // keep current user    
                        break;    
                    case kAuthV4NotRegisteredDevice:    
                        // This is the case that the login is canceled due to device authentication failure. Try logging in back with AUTO, or log out.    
                        break;    
                    default:    
                        // handle other exceptions    
                        break;    
                }    
            }    
}];

Hive SDKからのアカウント選択UIの実装（ゲームデータなしまたは不明なデータ）¶

アカウント選択UIを表示する際にゲームデータを確認できない場合や、サインインの変更を通知するだけの場合、簡易UIが適しています。ユーザーがアカウントをスキップしたり選択に失敗した場合、結果は失敗を返し、この場合はゲームプレイをそのまま続行することを確認してください。ただし、切り替えたアカウントでデバイスの認証に失敗した場合（AuthV4NotRegisteredDevice）、ゲームは再度ログインするために初期ページに戻る必要があります。これによりSDKへのログインがキャンセルされ、isAutoSignInはtrueを返します。

以下は、Hive SDK が提供する UI を実装するためのサンプルコードであり、対立する PlayerID のゲームデータを隠すものです。

// リクエスト 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: implement app exit functionality    
            // Users of the Cocos2d-x engine    
            // ex) exit(0);    
            // Unreal engine users    
            // Example) UKismetSystemLibrary::QuitGame(GetWorld(), nullptr, EQuitPreference::Quit, false);  
        } else {
                switch (Result.Code) {
                        case FHiveResultAPI::ECode::AuthV4PlayerChange:
                                // account switching: game restart required.
                                break;
                        case FHiveResultAPI::ECode::AuthV4PlayerResolved:
                                // keep current user
                                break;
                        case FHiveResultAPI::ECode::AuthV4NotRegisteredDevice:
                                // This is the case when login is canceled due to device authentication failure. Try logging back in with AUTO or log out.
                                break;
                        default:
                                // handle other exceptions
                                break;
                }
        }
}));

// Hive SDK AuthV4::Helper アカウント選択 UI リクエスト    
    AuthV4::Helper::showConflict([=](ResultAPI const & result, std::shared_ptr playerInfo) {    
        if (result. needExit()) {    
            // TODO: アプリ終了機能を実装する    
            // Cocos2d-x エンジンのユーザー    
            // 例) 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;    
            }    
        }    
});

// リクエスト 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 ->; {    
                        // その他の例外を処理する    
                    }    
                }    
            }    
        }    
})

// リクエスト 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;    
                }    
            }    
        }    
});

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

        if result.needExit() {    
            // TODO: アプリ終了機能を実装する    
            // 例) exit(0)    
        } else {    
            switch result.getCode() {    
            case .authV4PlayerChange:    
                // アカウント切り替え: ゲームの再起動が必要    
            case .authV4CancelDialog:    
                // 現在のユーザーを保持    
            case .authV4NotRegisteredDevice:    
                // これはデバイス認証の失敗によりログインがキャンセルされた場合です。AUTOで再ログインするか、ログアウトしてください。    
            default:    
                // 他の例外を処理する    
                break    
            }    
        }    
}

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

        if (result. needExit) {    
            // TODO: アプリ終了機能を実装する    
            // 例) 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の競合が発生した場合、ユーザーの選択に応じて以下の問題が発生する可能性があります。

• ConfilctPlayerを選択中: selectConflict(ConfilctPlayer, CB) が呼び出されます。
  • CurrentPlayerがゲストの場合、CurrentPlayerは検索できません。
• CurrentPlayerを選択中: selectConflict(CurrentPlayer, CB) が呼び出されます。
  • CurrentPlayerはIdPと同期しているため、ConfilctPlayerは同期していません。
  • ConflictPlayerが他のIdPと同期していない場合、いわゆるゲストステータスがConflictPlayerの検索不可を引き起こす可能性があります。
• キャンセルされた場合（ユーザーが選択ページを閉じた場合）: resolveConflict(CB) が呼び出されます。
  • IdPの同期に変更を加えずにCurrentPlayerでゲームを続けます。

アカウント選択UIを設定する際には、適切な注意事項を設定する必要があります。なぜなら、特定の状況下では、未選択のデータがゲスト状態に見つからない場合があるからです。また、アカウントの競合が発生した場合にIdPリンク情報を変更しないように設定したい場合は、ConflictPlayerのゲームデータを選択するか、アカウント選択をキャンセルできるUIを設計することを確認してください。

ユーザーがアカウント選択UIでアカウントを選択すると、選択されたアカウントのPlayerIDをパラメータとしてselectConflict()メソッドを実装します。ユーザーがアカウント選択をキャンセルした場合は、APIを呼び出さずにゲームを続行することを確認してください。プレイヤーがConflictPlayerを選択し、成功のコールバックを受け取ったら、ゲームデータを再度ロードすることを確認してください。

アカウントの競合により、アカウントを選択するためのサンプルコードは以下の通りです。

long long selectedPlayerId = 1234567890;    
    // Select Hive SDK AuthV4 Account Conflict    
    AuthV4::selectConflict(selectedPlayerId, [=](ResultAPI const & result,PlayerInfo const & 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)
        }
}));

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)    
                }    
            }    
})

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: アプリ終了機能を実装する    
                    // 例) System.exit(0);    
                }    
            }    
});

let selectedPlayerId: Int64 = 1234567890;    

    // Hive SDK AuthV4 アカウント競合選択リクエスト    
    AuthV4Interface.selectConflict(selectedPlayerId) { (result, playerInfo) in    
            if result. isSuccess() {    
                //アカウント選択成功    
            }    
            else if result. needExit() {    
                // TODO: アプリ終了機能を実装    
                // ex) exit(0)    
            }    
}

long long selectedPlayerId = 1234567890;    

    // Hive SDK AuthV4 アカウントの競合選択リクエスト    
    [HIVEAuthV4 selectConflict:selectedPlayerId handler:^(HIVEResultAPI *result, HIVEPlayerInfo *playerInfo) {    

            if (result. isSuccess) {    
                //アカウント選択成功    
            }    
            else if (result. needExit) {    
                // TODO: アプリ終了機能を実装する    
                // 例) exit(0);    
            }    
}];

IdPアカウントからの切断¶

ユーザーがIdPアカウントリストUIでリンクされたIdPアカウントのリンクを解除できるようにすることができます。ユーザーがIdPアカウントリストUIで特定のIdPアカウントのリンクを解除すると、ゲームスタジオは特定のIdPの種類であるProviderType引数を持つdisconnect()メソッドを呼び出して、IdPアカウントから切断します。disconnect()メソッドを呼び出した後、ユーザーの接続状態を確認し、その後UI上の同期されたIdPリストを更新する必要があります。

using hive;    
    AuthV4.Helper.disconnect (AuthV4.ProviderType.HIVE, delegate (ResultAPI result, AuthV4.PlayerInfo playerInfo) {    
       switch (result.code) {    
         case ResultAPI.Code.Success:    
           // プロバイダーの切断に成功しました    
           break;    
         default:    
           // その他の例外状況    
           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;
        }
}));

#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;    
    }    
});

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 -> {    
                     // その他の例外状況    
                 }    
             }    
         }    
})

import com.hive.AuthV4;    
    import com.hive.ResultAPI;    
    AuthV4.Helper.INSTANCE.disconnect(AuthV4.ProviderType.HIVE, (result, playerInfo) -> {    
         switch (result.getCode()) {    
             case Success:    
                 // Provider disconnection successful    
                 break;    
             default:    
                 // other exception situations    
                 break;    
         }    
});

import HIVEService    
    AuthV4Interface.helper().disconnect(.Hive) { result, playerInfo in    
        switch result.getCode() {    
            case.success:    
            // プロバイダーの切断に成功しました    
            default:    
            // その他の例外状況    
            break    
        }    
}

#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. 少なくとも1つのIdPアカウントをリンクしたままにする。

IdPアカウントからの切断: すべてのIdPアカウントのリンク解除を許可する¶

ゲームスタジオは、ユーザーがすべてのIdPアカウントのリンクを解除し、ゲストアカウントを使用できるようにすることができます。ユーザーがゲストアカウントを使用する場合、そのアカウントはゲームの初期化や再インストールによって失われた場合に回復できません。したがって、ユーザーが最後のIdPリンクを解除しようとする場合、以下のフレーズを使用してゲストユーザーに関するガイダンスをポップアップし、このユーザーがリンク解除を再考できるようにします。なお、PlayerIDは、対応するIdPがリンク解除されてもログアウトされることはありません。

• 最後のIdPアカウントのリンクを解除したい場合

ユーザーが上記のフレーズが公開されているにもかかわらずアカウントのリンクを解除することを選択した場合は、disconnect()を呼び出します。ユーザーアカウントがゲストアカウントになると、以下のフレーズが公開される可能性があります。

• ユーザーアカウントが最後にリンクされたIdPから切断された後、ゲストアカウントになる場合

IdPアカウントからの切断: 1つ以上のリンクされたアカウントを維持する¶

ゲームスタジオは、ユーザーに少なくとも1つのIdPアカウントをリンクさせることを強制する場合があります。ユーザーがすべてのIdPアカウントのリンクを解除すると、ユーザーアカウントはゲストアカウントに変換され、ゲストアカウントがゲームの初期化や再インストールによって失われた場合、そのアカウントは回復できません。したがって、単一のリンクされたIdPを持つユーザーがそのIdPのリンクを解除しようとした場合、以下のフレーズを使用してこれを制限する通知を実装できます。なお、対応するIdPがリンク解除されても、PlayerIDはログアウトされません。

• 最後のIdPアカウントのリンクを解除したい場合

カスタム 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<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 & result, PlayerInfo const & playerInfo) {
                switch (result.code) {
                    case ResultAPI::Success:
                    // 同期成功
                    break;
                    case ResultAPI::AuthV4ConflictPlayer:
                    // アカウントの競合
                    map<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同期。
        [Game connect:@"CUSTOM_TWITTER" handler:^NSString* authKey) {

            [HIVEAuthV4 connectWithAuthKey:authKey handler:^HIVEResultAPI* result, HIVEPlayerInfo* playerInfo) {
                    switch(result.code) {
                    case kSuccess:
                        // 同期成功
                        break;
                    case kAuthV4ConflictPlayer:
                        // アカウントの競合
                        NSDictionary<NSString*, HIVEProviderInfo*>;* customProviderInfoData = playerInfo.customProviderInfoData;
                        ProviderInfo* providerInfo = [customProviderInfoData objectForKey:@"CUSTOM_TWITTER"];
                        // ユーザーのための以下の同期情報を確認してください
                        providerInfo.providerType;  
    providerInfo.providerType     // HIVEProviderTypeCustom、providerTypeはHIVEProviderTypeCustomに固定されています。区別するために、providerNameを使用してください。
                        providerInfo.providerName;   // "CUSTOM_TWITTER"
                        providerInfo.providerUserId;  // TwitterログインのためのユーザーID、ゲーム自体によって実装されています。
                        break;
                    default:
                        // その他の例外
                        break;
                    }
            }];
        }];