Link Idp

After sign-in, display the sync status of PlayerID that user currently use and provide the function to be able to link with other ID Providers (IdP). Display the sync status of IdP in the game settings menu, and configure the UI so that the user can connect and disconnect with the IdP.

Check the information of IdP sync status¶

You can use getPlayerInfo() method of AuthV4 class to see the IdP list synced with the currently logged-in PlayerID. In the game settings screen, make sure to configure the UI to see which IdP is synced, and expose the Phrases to suggest IdP sync.

In the game setting screen, PlayerID of each user should be displayed along with the IdP sync information. Display the PlayerID with the format of CS Code, and with the value of currently logged in user.

• An example screen to confirm the IdP synced with the currently logged in PlayerID

• Sample screen for account linking

The following is the list of IdPs that can be provided by the current app through providerTypeList returned from setup(). Please check the list of IdPs linked to PlayerID and display the linkage status using the given example code.

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

// Request the sync status of Hive SDK AuthV4    
        for( auto providerInfo : AuthV4::getPlayerInfo().providerInfoData ) {    
            cout<<"ProviderType : "<<ProviderInfo::stringProviderType(providerInfo.second.providerType)<<endl;    
            cout<<"ProviderUserId : "<<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]) {    
            // Synced Provider data    
            HIVEProviderInfo *providerInfo = playerInfo.providerInfoData[providerTypeStr];    
    }

Phrases to suggest IdP sync¶

IdP Sync¶

The currently logged-in PlayerID can sync with new IdPs. But when user attempts to sync with the IdP linked with different a PlayerID, an error is occurred. If the sync is successful, check the sync status information and update the sync info UI.

When the IdP that you want to add in the IdP connection is linked to another PlayerID, this is called Account conflict situation. To solve this conflict situation, see Handling account conflicts when working with an IdP.

For IdP integration, call the connect () method with the ProviderType you want to work with as parameters. Followings are sample codes to implement the IdP sync.

// 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:
                        // Success to sync IdP
                        break;
                case FHiveResultAPI::ECode::AuthV4ConflictPlayer:
                        // Account conflict
                        break;
                default:
                        // Exceptional case
                        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:    
                    // Success to sync IdP    
                    break;    
                case ResultAPI::AuthV4ConflictPlayer:    
                    // Account conflict    
                    break;    
                default:    
                    // Exceptional case    
                    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:    
                        // Success to sync IdP    
                        break;    
                    case AuthV4ConflictPlayer:    
                        // Account conflict    
                        break;    
                    default:    
                        // Exceptional case    
                        break;    
                }    
            }    
    });

// Hive SDK AuthV4 Request to sync with IdP    
        [[HIVEAuthV4 helper] connect:providerType handler:^(HIVEResultAPI *result, HIVEPlayerInfo *playerInfo) {    
            switch(result.code) {    
            case kSuccess:    
                // Success to sync IdP    
                break;    
            case kAuthV4ConflictPlayer:    
                // Account conflict    
                break;    
            default:    
                // Exceptional case    
                break;    
            }    
    }];

Handling account conflicts with IdP Sync¶

When connect() is called for IdP integration, if the IdP account the user is trying to connect to is already linked to another PlayerID, an account conflict occurs. For the further explanation, we assume the following situation.

• CurrentPlayer: The player of the account that a user is currently logged into (guest account or IdP account)
• ConflictPlayer: The player that already exists in the IdP account the user wants to link

When ConflictPlayer's game playing record exists in the game server¶

In this case, when an account conflict occurs, the ConflictPlayer's play information is notified to the user and the UI for choosing the ConflictPlayer is exposed. To use the UI provided by the Hive SDK, configure ConflictPlayer information to fit the game and call the showConflict() method with the ConflictPlayer information as a parameter. When called, you can convert to the ConflictPlayer or select Cancel to continue playing the game with the CurrentPlayer. In the UI image example below, clicking the check button switches over to the ConflictPlayer, and clicking the X button continues the game with the CurrentPlayer.

When ConflictPlayer's game playing record does not exist in the game server¶

Sometimes, only the player identifier (PlayerId) of ConflictPlayer exists but there is no actual play record on the game server. In this case, call resolveConflict(CB) to select the CurrentPlayer's PlayerID and continue the game. Expose the following UI when an account conflict occurs.

• When CurrentPlayer is a guest account and ConflictPlayer is an IdP account

  • "Confirm" button is exposed, and when a user clicks it, CurrentPlayer remains logged in

• When CurrentPlayer is IdP account 1 (example: Facebook) and ConflictPlayer is IdP account 2 (example: Google Play)

  • Cancel: Stay logged in with your current CurrentPlayer of the Facebook account
  • Confirm: Switch player to the ConflictPlayer of the Google Play account

When ConflictPlayer is a restricted account¶

When the ConflictPlayer (IdP account) is in a restricted state, if the CurrentPlayer (IdP account or guest account) attempts to connect on another device using AuthV4.connect, there will be no account conflict, and instead, a restriction popup will be displayed. If the app user closes the restriction popup, AuthV4.connect will return an error, and the attempt of the CurrentPlayer to connect to this IdP will fail.

Example 1: When CurrentPlayer is an IdP account¶

If the previously linked Facebook IdP account (ConflictPlayer) is in a suspended state and the user attempts to link the Google IdP (CurrentPlayer), a suspension popup will appear. Closing the popup will log out the Facebook IdP.

Example 2: When CurrentPlayer is a guest account¶

If the previously linked Facebook IdP account (ConflictPlayer) is in a suspended state and the user attempts to link to the Facebook IdP with a guest account (CurrentPlayer), a suspension popup will appear. Closing the popup will log out the Facebook IdP.

Notes on account selection¶

If a user selects ConflictPlayer and CurrentPlayer is in guest status, CurrentPlayer is no longer found. And If CurrentPlayer has data from another game server in the guest status, that game data also will no longer be found. Therefore, you should prevent users from making changes to the game server when they are guests to avoid this problem. If the user taps X button in the account selection page provided by the SDK, the account sync is canceled.

Composition of game data¶

ConflictPlayer data is composed of two essential keys, player_id and game_data.

• player_id: PlayerID of ConflictPlayer
• game_data: Organize the game data such as character name, the amount of game money, and level as Map<String, Object >; format

Following is a sample code to compose the data of ConflictPlayer.

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

Implementing account selection UI from Hive SDK (with game playing data)¶

Once you completed to configure the ConflictPlayer data, the showConflict () method is called to expose the UI provided by the SDK and the user's choice will be returned as a result. If the result is successful and the user selects the ConflictPlayer, then you need to load the game data again. The result returns failure when user skips or fails to select an account, and in this case, make sure to continue the game play as is. However, if failed to authenticate the device on a switched account (AuthV4NotRegisteredDevice), the game has to go back to the initial page so as to log in again. It causes that login to SDK is canceled and isAutoSignIn returns true.

Followings are sample codes to implement the UI which Hive SDK provides by configuring game data of the conflicted PlayerID.

// 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);    
    // Request Hive SDK AuthV4.Helper account selection UI    
    AuthV4.Helper.showConflict (conflictInfo, (ResultAPI result, AuthV4.PlayerInfo playerInfo) =>; {    
        if (result. needExit()) {    
            // TODO: implement the termination of the app.    
            // Example) Application.Quit();    
        } else {    
            switch(result.code) {    
                case ResultAPI.Code.AuthV4PlayerChange:    
                    // account switching: game restart required    
                    break;    
                case ResultAPI.Code.AuthV4PlayerResolved:    
                    // keep current user    
                    break;    
                case ResultAPI.Code.AuthV4NotRegisteredDevice:    
                    // 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;    
            }    
        }    
});

#include "HiveAuthV4.h"

int64 PlayerId = 12345678;
FHiveConflictSingleViewData ViewData = FHiveConflictSingleViewData(PlayerId);
ViewData.SetData(TEXT("Gold"), TEXT("2048"));
ViewData.SetData(TEXT("Gem"), TEXT("220"));

FHiveAuthV4::Helper::ShowConflict(ViewData, FHiveAuthV4HelperDelegate::CreateLambda([this](const FHiveResultAPI& Result, const TOptional<FHivePlayerInfo>& PlayerInfo) {
        if (Result.NeedExit()) {
                // TODO: implement the termination of the app.    
      // Example) Application.Quit();
        } 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 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;
                }
        }
}));

// 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 account selection UI request    
    AuthV4::Helper::showConflict(*conflictInfo, [=](ResultAPI const & result, std::shared_ptr playerInfo) {    
            if (result. needExit()) {    
                // TODO: implement the termination of the app.    
                // 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 ResultAPI::AuthV4PlayerChange:    
                        // account switching: game restart required    
                        break;    
                    case ResultAPI::AuthV4PlayerResolved:    
                        // keep current user    
                        break;    
                    case ResultAPI::Code::AuthV4NotRegisteredDevice:    
                        // 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;    
                }    
            }    
});

// create game info object of the conflicted account    
    val conflictInfo = AuthV4.Helper.ConflictSingleViewInfo(playerId)    
    conflictInfo.setValue("Gold", 2048)    
    conflictInfo.setValue("Gem", 220)    

    // Request Hive SDK AuthV4.Helper account selection UI    
    AuthV4.Helper.showConflict(conflictInfo, object : AuthV4.Helper.AuthV4HelperListener {    
            override fun onAuthV4Helper(result: ResultAPI, playerInfo: AuthV4.PlayerInfo?) {    
                if (result. needExit()) {    
                    // TODO: implement the termination of the app.    
                    // ex) exitProcess(0)    
                } else {    
                    when (result.code) {    
                        ResultAPI.Code.AuthV4PlayerChange ->; {    
                            // account switching: game restart required    
                        }    
                        ResultAPI.Code.AuthV4CancelDialog ->; {    
                            // keep current user    
                        }    
                        ResultAPI.Code.AuthV4NotRegisteredDevice ->; {    
                            // This is the case that the login is canceled due to device authentication failure. Try logging in back with AUTO, or log out.    
                        }    
                        else ->; {    
                            // handle other exceptions    
                        }    
                    }    
                }    
            }    
})

// 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);    


    // Request Hive SDK AuthV4.Helper account selection UI    
    AuthV4.Helper.showConflict(conflictInfo, new AuthV4.Helper.AuthV4HelperListener() {    
            @Override    
            public void onAuthV4Helper(ResultAPI result, AuthV4.PlayerInfo playerInfo) {    

                if (result. needExit()) {    
                    // TODO: implement the termination of the app.    
                    // ex) System.exit(0);    
                } else {    
                    switch(result.code) {    
                        case AuthV4PlayerChange:    
                            // account switching: game restart required    
                            break;    
                        case AuthV4CancelDialog:    
                            // keep current user    
                            break;    
                        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.    
                            break;    
                        default:    
                            // handle other exceptions    
                            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 account selection UI request    
    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    
                }    
            }    
}

// create game info object of the conflicted account    
    HIVEConflictSingleViewInfo *conflictInfo = [[HIVEConflictSingleViewInfo alloc] initWithPlayerId:12345678];    
    [conflictInfo setValue:@"Gold" intValue:2048];    
    [conflictInfo setValue:@"Gem" intValue:220];    


    // Hive SDK AuthV4:Helper account selection UI request    
    [[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;    
                }    
            }    
}];

Implementing account selection UI from Hive SDK (without game data or with unknown data)¶

If you can't verify game data at the time of displaying account-selecting UI or just inform to the change in sign-in, the simplified UI is suitable for the cases. The result returns failure when user skips or fails to select an account, and in this case, make sure to continue the game play as is. However, if failed to authenticate the device on a switched account (AuthV4NotRegisteredDevice), the game has to go back to the initial page so as to log in again. It causes that login to SDK is canceled and isAutoSignIn returns true.

Followings are sample codes to implement the UI which Hive SDK provides by hiding game data of the conflicted PlayerID.

// Request Hive SDK AuthV4.Helper account selection UI    
    AuthV4.Helper.showConflict ((ResultAPI result, AuthV4.PlayerInfo playerInfo) =>; {    
        if (result. needExit()) {    
            // TODO: implement app exit functionality    
            // Example) Application.Quit();    
        } else {    
            switch(result.code) {    
                case ResultAPI.Code.AuthV4PlayerChange:    
                    // account switching: game restart required    
                    break;    
                case ResultAPI.Code.AuthV4PlayerResolved:    
                    // keep current user    
                    break;    
                case ResultAPI.Code.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;    
            }    
        }    
});

#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 account selection UI request    
    AuthV4::Helper::showConflict([=](ResultAPI const & result, std::shared_ptr 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 ResultAPI::AuthV4PlayerChange:    
                    // account switching: game restart required    
                    break;    
                case ResultAPI::AuthV4PlayerResolved:    
                    // keep current user    
                    break;    
                case ResultAPI::Code::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;    
            }    
        }    
});

// Request Hive SDK AuthV4.Helper account selection UI    
    AuthV4.Helper.showConflict(object : AuthV4.Helper.AuthV4HelperListener {    
        override fun onAuthV4Helper(result: ResultAPI, playerInfo: AuthV4.PlayerInfo?) {    
            if (result. needExit()) {    
                // TODO: implement app exit functionality    
                // ex) exitProcess(0)    
            } else {    
                when (result.code) {    
                    ResultAPI.Code.AuthV4PlayerChange ->; {    
                        // account switching: game restart required    
                    }    
                    ResultAPI.Code.AuthV4CancelDialog ->; {    
                        // keep current user    
                    }    
                    ResultAPI.Code.AuthV4NotRegisteredDevice ->; {    
                        // This is the case when login is canceled due to device authentication failure. Try logging back in with AUTO or log out.    
                    }    
                    else ->; {    
                        // handle other exceptions    
                    }    
                }    
            }    
        }    
})

// Request Hive SDK AuthV4.Helper account selection UI    
    AuthV4.Helper.showConflict(new AuthV4.Helper.AuthV4HelperListener() {    
        @Override    
        public void onAuthV4Helper(ResultAPI result, AuthV4.PlayerInfo playerInfo) {    
            if (result. needExit()) {    
                // TODO: implement app exit functionality    
                // ex) System.exit(0);    
            } else {    
                switch(result.code) {    
                    case AuthV4PlayerChange:    
                        // account switching: game restart required    
                        break;    
                    case AuthV4CancelDialog:    
                        // keep current user    
                        break;    
                    case 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 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    
            }    
        }    
}

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

        if (result. needExit) {    
            // TODO: implement app exit functionality    
            // 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 when login is canceled due to device authentication failure. Try logging back in with AUTO or log out.    
                    break;    
                default:    
                    // handle other exceptions    
                    break;    
            }    
        }    
}];

Customization in case of IdP conflict¶

If IdP conflicts in the middle of IdP sync process, you can configure the game data by using the returned conflict PlayerID and implement the account selection UI directly in the game. If the user selects an account on the selection UI, implement the selectConflict() method with the PlayerID of the selected account as a parameter.

In the following description, the currently logged-in account is called CurrentPlayer, and the account occurred conflict is called ConfilctPlayer. When customizing the account selection UI, it is necessary to check the difference of the action by the user's selection and notify the appropriate precautions in the UI configuration. When IdP conflicts, following issues may occur depending on the user selection.

• Choosing ConfilctPlayer: selectConflict(ConfilctPlayer, CB) is called.
  • If CurrentPlayer is a guest, CurrentPlayer is unavailable to search.
• Choosing CurrentPlayer: selectConflict(CurrentPlayer, CB) is called.
  • CurrentPlayer is sync with IdP, so ConfilctPlayer is out of sync.
  • If ConflictPlayer is out of sync with other IdPs, so-called guest status, may cause ConflictPlayer unavailable to search.
• If cancelled (user just close the selection page): resolveConflict(CB) is called.
  • Keep playing the game with CurrentPlayer, without any change in IdP sync.

You need to configure the appropriate caution statement when configuring the account selection UI, because in some circumstances, unselected data may not be found in the guest state. Also, if you want to configure not to change the IdP-linked information in case of an account conflict, make sure to select the game data of ConflictPlayer or design the UI available to cancel the account selection.

Once the user selects an account on the account selection UI, implement the selectConflict() method with the PlayerID of the selected account as a parameter. If the user cancels the account selection, ensure to continue the game without calling any API. After the player chooses ConflictPlayer and receives a successful callback, make sure to load the game data again.

Followings are sample codes to select an account due to account conflict.

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

            if (result. isSuccess()) {    
                //account selection successful    
            } else 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);    
            }    
});

#include "HiveAuthV4.h"

int64 SelectedPlayerId = 12345678;
FHiveAuthV4::SelectConflict(SelectedPlayerId,
                                                        FHiveAuthV4OnSignInDelegate::CreateLambda([this](const FHiveResultAPI& Result, const FHivePlayerInfo& PlayerInfo) {
        if (Result.IsSuccess()) {
                // account selection successful  
        } else if (Result.NeedExit()) {
                // TODO: implement app exit functionality    
                    // ex) exitProcess(0)
        }
}));

val selectedPlayerId: Long = 1234567890    

    // Select Hive SDK AuthV4 Account Conflict    
    AuthV4.selectConflict(selectedPlayerId, object : AuthV4.AuthV4SignInListener {    
            override fun onAuthV4SignIn(result: ResultAPI, playerInfo: AuthV4.PlayerInfo?) {    
                if (result. isSuccess) {    
                    //account selection successful    
                } else if (result. needExit()) {    
                    // TODO: implement app exit functionality    
                    // ex) exitProcess(0)    
                }    
            }    
})

long selectedPlayerId = 1234567890;    

    // Select Hive SDK AuthV4 Account Conflict    
    AuthV4.selectConflict(selectedPlayerId, new AuthV4.AuthV4SignInListener() {    
            @Override    
            public void onAuthV4SignIn(ResultAPI result, AuthV4.PlayerInfo playerInfo) {    

                if(result. isSuccess()) {    
                    //account selection successful    
                }    
                else if (result. needExit()) {    
                    // TODO: implement app exit functionality    
                    // ex) System.exit(0);    
                }    
            }    
});

let selectedPlayerId: Int64 = 1234567890;    

    // Hive SDK AuthV4 account conflict selection request    
    AuthV4Interface.selectConflict(selectedPlayerId) { (result, playerInfo) in    
            if result. isSuccess() {    
                //account selection successful    
            }    
            else if result. needExit() {    
                // TODO: implement app exit functionality    
                // ex) exit(0)    
            }    
}

long long selectedPlayerId = 1234567890;    

    // Hive SDK AuthV4 account conflict selection request    
    [HIVEAuthV4 selectConflict:selectedPlayerId handler:^(HIVEResultAPI *result, HIVEPlayerInfo *playerInfo) {    

            if (result. isSuccess) {    
                //account selection successful    
            }    
            else if (result. needExit) {    
                // TODO: implement app exit functionality    
                // ex) exit(0);    
            }    
}];

Disconnect from IdP accounts¶

You can allow users unlink the linked IdP accounts on the IdP account list UI. If a user unlinks a specific IdP account on the IdP account list UI, the game studio calls the disconnect() method with the ProviderType argument, which is the specific kind of IdP, to disconnect from the IdP account. After calling disconnect() method, you need to check the connection status of users and then update the synced IdP list on the UI.

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:
                        // Provider disconnection successful
                        break;
                default:
                        // other exception situations  
                        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:    
        // Provider disconnection successful    
        break;    
        default:    
        // other exception situations    
        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 -> {    
                     // Provider disconnection successful    
                 }    
                 else -> {    
                     // other exception situations    
                 }    
             }    
         }    
})

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:    
            // Provider disconnection successful    
            default:    
            // other exception situations    
            break    
        }    
}

#import <HIVEService/HIVEService-Swift.h>    
    [[HIVEAuthV4 helper] disconnect: HIVEProviderTypeHive handler: ^(HIVEResultAPI *result, HIVEPlayerInfo *playerInfo) {    
       switch ([result getCode]) {    
    case HIVEResultAPICodeSuccess:    
           // Provider disconnection successful    
           break;    
         default:    
           // other exception situations    
           break;    
       }    
}];

The game studios can choose from the policies below when implementing IdP disconnection. 1. Unlink all IdP accounts and allow using a guest account. 2. Force to keep at least one IdP account linked.

Disconnect from IdP accounts: allow unlink all IdP accounts¶

The game studios can allow users unlink all IdP accounts and use a guest account. If a user use a guest account, the account cannot be recovered if the guest account is lost due to initialization or reinstallation of the game. Therefore, if a user tries to unlink the last IdP linked, use the phrase below to pop up the guidance about the guest user so that this user can reconsider unlinking. Note that a PlayerID will not be logged out even if its corresponding IdP is unlinked.

• If you want to unlink the last IdP account linked

If a user chooses to unlink the account even though the phrase above is exposed, call disconnect(). When a user account becomes a guest account, the following phrase can be exposed.

• If a user account becomes a guest account after disconnected from the last IdP linked

Disconnect from IdP accounts: maintain at least 1 account linked¶

The game studios may force users to keep at least one IdP account linked. When a user unlinks all IdP accounts, the user account is converted to a guest account, and if the guest account is lost due to initialization or reinstallation of the game, the account cannot be recovered. Therefore, if a user with a single linked IdP tries to unlink that IdP, you can implement a notification that restricts this by using the phrase below. Note that a PlayerID will not be logged out even if its corresponding IdP is unlinked.

• If you want to unlink the last IdP account linked

Custom IdP sync¶

Custom IdP sync is a customized function that enable the implementation of custom IdP adopted by the game, away from the IdPs provided by Hive SDK. After calling the custom login API, you can check logged-in user information of custom IdP by accessing customProviderInfoData data with the PlayerInfo class instance that is passed as the callback result. ProviderType (enum) of customProviderInfoData is set to CUSTOM, and can be differentiated by ProviderName (String).

The following is an example code that implements custom IdP sync.

// 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:
                    // sync success
                    break;
                case ResultAPI.Code.AuthV4ConflictPlayer:
                    // account conflict
                    Dictionary<string, ProviderInfo>; customProviderInfoData = playerInfo.customProviderInfoData;
                    ProviderInfo providerInfo = customProviderInfoData["CUSTOM_TWITTER"];
                    // Check the following sync information for the user
                    providerInfo.providerType;     // ProviderType.CUSTOM, providerType is fixed to ProviderType.CUSTOM. 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;
                }
        });
    });

#include "HiveAuthV4.h"

// Twitter sync that is implemented by the game itself.
void GameConnect(const FString& AuthKey)
{
        FHiveAuthV4::ConnectWithAuthKey(AuthKey, FHiveAuthV4OnConnectDelegate::CreateLambda([this](const FHiveResultAPI& Result, const FHivePlayerInfo& ConflictPlayerInfo) {
                switch(Result.Code) {
                        case FHiveResultAPI::ECode::Success:
                                // sync success
                                break;
                        case FHiveResultAPI::ECode::AuthV4ConflictPlayer: {
                                // account conflict
                                TMap<FString, FHiveProviderInfo> CustomProviderInfoData = ConflictPlayerInfo.CustomProviderInfoData;
                                if (const FHiveProviderInfo* ProviderInfo = CustomProviderInfoData.Find(TEXT("CUSTOM_TWITTER"))) {
                                        // Check the following sync information for the user
                                        EHiveProviderType ProviderType = ProviderInfo->ProviderType; // ProviderType::CUSTOM, providerType is fixed to ProviderType::CUSTOM. To distinguish, use providerName.
                                        FString ProviderName = ProviderInfo->ProviderName; // "CUSTOM_TWITTER"
                                        FString ProviderUserId = ProviderInfo->ProviderUserId; // the user id for the Twitter login, implemented by the game itself.
                                }
                        }
                                break;
                        default:
                                // Other exceptions
                                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:
                    // sync success
                    break;
                    case ResultAPI::AuthV4ConflictPlayer:
                    // account conflict
                    map<string, ProviderInfo>; customProviderInfoData = playerInfo.customProviderInfoData;
                    ProviderInfo providerInfo = customProviderInfoData["CUSTOM_TWITTER"];
                    // Check the following sync information for the user
                    providerInfo.providerType;     // ProviderType::CUSTOM, providerType is fixed to ProviderType::CUSTOM. 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;
                }
            });
        });

// Twitter sync that is implemented by the game itself.
        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 ->; {
                            // sync success
                        }
                        case ResultAPI.Code.AuthV4ConflictPlayer ->; {
                            // account conflict
                            playerInfo.customProviderInfoData["CUSTOM_TWITTER"]?.let { providerInfo ->;
                            providerInfo.providerType     // ProviderType.CUSTOM, providerType is fixed to ProviderType.CUSTOM. To distinguish, use providerName.
                            providerInfo.providerName   // "CUSTOM_TWITTER"
                            providerInfo.providerUserId  // the user id for the Twitter login, implemented by the game itself.
                        }
                        else ->; {
                            // Other exceptions
                        }
                    }
                }
            }
        }

// 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:
                                // sync success
                                break;
                            case ResultAPI.Code.AuthV4ConflictPlayer:
                                // account conflict
                                ProviderInfo providerInfo = conflictPlayer.getCustomProviderInfoData().get("CUSTOM_TWITTER");
                                providerInfo.getProviderType();     // ProviderType.CUSTOM, providerType is fixed to ProviderType.CUSTOM. To distinguish, use providerName.
                                providerInfo.getProviderName();   // "CUSTOM_TWITTER"
                                providerInfo.getProviderUserId();  // the user id for the Twitter login, implemented by the game itself.
                                break;
                            default:
                                // Other exceptions
                                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:
                        // sync success
                        break
                    case .authV4ConflictPlayer:
                        // account conflict
                    guard let customProviderInfoData = playerInfo?.customProviderInfoData,
                            let providerInfo = customProviderInfoData["CUSTOM_TWITTER"] else {
                        // No sync information for the user, failure handling
                        return
                    }

                    // Check the following sync information for the user
                    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
                    }
                }
        }

// 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<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;
                    }
            }];
        }];