Idp 연동

로그인 후, 유저가 현재 이용중인 PlayerID의 연동 상태를 표시하고 다른 IdP (ID Provider, 이하 IdP)와 연동할 수 있도록 제공해야 합니다.

게임의 설정 메뉴 안에 IdP 연동 상태를 표시하고 IdP 연동 및 해제를 할 수있도록 UI를 구성해 주세요.

IdP 연동 상태 정보 확인¶

AuthV4 클래스의 getPlayerInfo() 메서드를 이용하여 현재 로그인된 PlayerID에 연동된 IdP 리스트를 확인할 수 있습니다. 게임 내 설정 화면에서 어떤 IdP와 연동되어 있는지 확인할 수 있도록 UI를 구성하고 IdP 연동을 유도하는 문구를 노출하세요.

게임 내 설정 화면에서는 IdP 연동 정보와 함께 유저의 PlayerID를 표시해야 합니다. PlayerID는 CS Code로 표기 후 현재 로그인된 유저의 PlayerID 값을 노출해야 합니다.

• 현재 로그인된 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)
        {
                // IdP 연동 상태 확인
        }
}

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

IdP 연동을 유도하는 문구¶

IdP 연동¶

현재 로그인된 PlayerID는 새로운 IdP를 추가 연동할 수 있습니다. 만약 다른 PlayerID에 연동한 IdP를 현재 로그인된 PlayerID에 연동하려고 할 때는 에러가 반환됩니다. 연동에 성공한 후에는 상태 정보를 다시 확인하여 연동 정보 UI를 업데이트해주세요.

IdP 연동 시 추가하려는 IdP가 다른 PlayerID에 연동되어 있는 경우를 계정 충돌 상황이라고 합니다. 해당 부분을 구현하려면 IdP 연동 시 계정 충돌 상황 처리를 참고하세요.

IdP 연동을 위해서는 연동하려는 ProviderType을 파라미터로 넣고 connect() 메서드를 호출하세요. 다음은 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:
                        // 연동 성공
                        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:    
                    // 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;    
            }    
    }];

IdP 연동 시 계정 충돌 상황 처리¶

IdP 연동을 위해 connect() 호출 시 유저가 연동하려는 IdP 계정이 이미 다른 PlayerID에 연동되어 있는 경우 계정 충돌 상황이 발생합니다. 이후 설명을 위해 다음과 같은 상황을 가정합니다.

• CurrentPlayer: 유저가 현재 로그인한 계정(게스트 계정 또는 IdP 계정)에 있는 플레이어
• ConflictPlayer: 유저가 연동하려는 IdP 계정에 이미 존재하는 플레이어

ConflictPlayer가 게임을 플레이한 기록이 게임 서버에 있을 때¶

이 경우, 계정 충돌이 발생하면 ConflictPlayer 플레이 정보를 유저에게 알려주고 ConflictPlayer를 선택할 수 있는 UI를 노출합니다. Hive SDK에서 제공하는 UI를 사용하기 위해 ConflictPlayer 정보를 게임에 맞도록 구성하고 ConflictPlayer의 정보를 파라미터로 showConflict() 메서드를 호출하세요. 호출 시 ConflictPlayer로 계정을 변경하거나 취소를 선택하여 IdP 연동 정보 변경 없이 CurrentPlayer로 게임을 계속 진행할 수 있습니다. 아래 UI 이미지 예시에서 체크 버튼을 클릭하면 ConflictPlayer 계정으로 전환, X 버튼을 클릭하면 CurrentPlayer로 게임을 계속 진행합니다.

ConflictPlayer가 게임을 플레이한 기록이 게임 서버에 없을 때¶

ConflictPlayer 플레이어 식별자(PlayerId) 데이터 정도만 존재할 뿐 게임 서버에 실제 플레이 기록이 없는 경우가 있습니다. 이 경우에는 resolveConflict(CB)를 호출해 CurrentPlayer의 PlayerID를 선택하고 계속 게임을 진행하도록 합니다. 계정 충돌이 발생하면 다음 UI를 노출합니다.

• CurrentPlayer가 게스트 계정, ConflictPlayer가 IdP 계정일 때
  • "확인" 버튼이 노출되며 확인 버튼 터치 시 CurrentPlayer 로그인 상태를 유지
  
• CurrentPlayer가 IdP 계정 1(예: Facebook), ConflictPlayer가 IdP 계정 2(예: Google Play)일 때
  • 취소: 현재 계정인 Facebook 계정 CurrentPlayer로 로그인 상태 유지
  • 확인: 연동할 Google Play 계정 ConflictPlayer로 플레이어 전환
  

ConflictPlayer가 이용 제한 계정일 때¶

ConflictPlayer(IdP 계정)가 이용 제한 상태일 때, 다른 기기에서 CurrentPlayer(IdP 계정 또는 게스트 계정)가 연동을 시도(AuthV4.connect)하면 계정 충돌이 발생하지 않으며, 그 대신 이용 제한 팝업을 노출합니다. 앱 사용자가 이용 제한 팝업창을 닫으면 AuthV4.connect는 에러를 반환하며, CurrentPlayer가 이 IdP에 연동하려는 시도는 실패합니다.

예시 1. CurrentPlayer가 IdP 계정일 때¶

기존에 연동되어 있는 Facebook IdP 계정(ConflictPlayer)이 이용 정지 상태일 때, 사용자가 Google IdP(CurrentPlayer)도 연동을 시도하면 이용 정지 팝업창이 나타납니다. 팝업창을 닫으면 Facebook IdP를 로그아웃시킵니다.

예시 2. CurrentPlayer가 게스트 계정일 때¶

기존에 연동되어 있는 Facebook IdP 계정(ConflictPlayer)이 이용 정지 상태일 때, 사용자가 게스트 계정(CurrentPlayer)으로 Facebook IdP에 연동을 시도하면 이용 정지 팝업창이 나타납니다. 팝업창을 닫으면 Facebook IdP를 로그아웃시킵니다.

계정 선택 시 주의점¶

ConflictPlayer를 선택 시, CurrentPlayer가 게스트 상태라면 CurrentPlayer를 더 이상 찾을 수 없습니다. 게스트 상태인 CurrentPlayer로 다른 게임 서버에서 플레이한 데이터가 있으면 해당 게임 데이터 역시 더 이상 찾을 수 없습니다. 이 문제를 방지하기 위해서는 게스트 상태일 때 게임 서버를 변경하지 못하도록 구현해야 합니다. 또 유저가 SDK에서 제공하는 계정 선택 UI에서 'X'를 눌러 닫은 경우, 계정 연동이 취소됩니다.

게임 데이터 구성¶

ConflictPlayer 정보는 player_id와 game_data로 구성되며 두 키는 필수입니다.

• • player_id : ConflictPlayer의 PlayerID
  • 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 입니다.

다음은 충돌이 발생한 PlayerID의 게임 데이터 정보를 구성하여 Hive SDK가 제공하는 UI를 호출하는 예제 코드입니다.

// 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: 앱 종료 기능을 구현하세요
                // 예) UKismetSystemLibrary::QuitGame(GetWorld(), nullptr, EQuitPreference::Quit, false);
        } else {
                switch (Result.Code) {
                        case FHiveResultAPI::ECode::AuthV4PlayerChange:
                                // 계정 전환 : 게임 재시작 필요
                                break;
                        case FHiveResultAPI::ECode::AuthV4PlayerResolved:
                                // 현재 사용자 유지
                                break;
                        case FHiveResultAPI::ECode::AuthV4NotRegisteredDevice:
                                // 기기 인증에 실패하여 로그인이 해제된 경우입니다. AUTO로 재로그인을 시도하거나 로그아웃하세요.
                                break;
                        default:
                                // 기타 예외 상황 처리
                                break;
                }
        }
}));

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

Hive SDK의 계정 선택 UI 호출(게임 데이터가 없거나 알 수 없는 경우)¶

계정 선택 UI를 표시하는 시점에 노출할 게임 데이터를 확인할 수 없거나, 단순히 로그인 변경을 안내하고자 하는 경우에는 간소화된 UI를 사용할 수 있습니다. 유저가 계정을 선택하지 않았거나 계정 선택 시 오류가 발생하면 결과는 실패로 반환되고, 이 경우에는 현재 상태 그대로 게임을 진행하도록 합니다. 단, 전환된 계정에서 기기 인증에 실패하면(AuthV4NotRegisteredDevice) 게임에서는 재로그인을 시도하는 초기 화면으로 돌아가야 합니다. SDK에서의 로그인은 해제되고 isAutoSignIn 값은 true 입니다.

다음은 충돌이 발생한 PlayerID의 게임 데이터를 노출하지 않는 UI 호출 예제 코드입니다.

// 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: 앱 종료 기능을 구현하세요
                // 예) UKismetSystemLibrary::QuitGame(GetWorld(), nullptr, EQuitPreference::Quit, false);
        } else {
                switch (Result.Code) {
                        case FHiveResultAPI::ECode::AuthV4PlayerChange:
                                // 계정 전환 : 게임 재시작 필요
                                break;
                        case FHiveResultAPI::ECode::AuthV4PlayerResolved:
                                // 현재 사용자 유지
                                break;
                        case FHiveResultAPI::ECode::AuthV4NotRegisteredDevice:
                                // 기기 인증에 실패하여 로그인이 해제된 경우입니다. AUTO로 재로그인을 시도하거나 로그아웃하세요.
                                break;
                        default:
                                // 기타 예외 상황 처리
                                break;
                }
        }
}));

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

IdP 충돌 상황 시 커스터마이징¶

IdP 연동 과정에서 IdP 충돌 상황 발생 시 반환된 충돌 PlayerID를 이용하여 게임데이터를 구성하고 계정 선택 UI를 게임에서 직접 구현할 수 있습니다. 게임에서 커스터마이징한 계정 선택 UI에서 유저가 계정을 선택했다면 선택된 계정의 PlayerID를 파라미터로 selectConflict() 메서드를 호출하세요.

다음 설명에서는 현재 로그인된 계정을 CurrentPlayer, 충돌이 발생한 계정을 ConfilctPlayer라고 칭합니다. 계정 선택 UI를 커스터마이징 할 경우 유저의 선택에 따른 동작의 차이를 확인하고 UI 구성 시 적절한 주의 사항 문구를 계정 선택 UI에 고지해야 합니다.

IdP 충돌 상황에서는 유저의 선택에 따라 다음과 같은 이슈가 발생할 수 있습니다.
• ConfilctPlayer 선택 시: `selectConflict(ConfilctPlayer, CB)` 호출
  • CurrentPlayer가 게스트 상태라면 CurrentPlayer를 더 이상 찾을 수 없습니다.
• CurrentPlayer 선택 시: `selectConflict(CurrentPlayer, CB)` 호출
  • CurrentPlayer에 IdP가 연동되고 ConfilctPlayer의 IdP 연동이 해지됩니다.
  • ConfilctPlayer에 다른 IdP가 연동되어 있지 않을 경우 게스트 상태가 되어 ConfilctPlayer를 더 이상 찾을 수 없습니다.
• 취소 시(유저가 어떤 것도 선택하지 않고 선택 UI를 닫은 경우): `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()) {    
                //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()) {
                // 계정 선택 성공
        } else if (Result.NeedExit()) {
                // TODO: 앱 종료 기능을 구현하세요
                // 예) UKismetSystemLibrary::QuitGame(GetWorld(), nullptr, EQuitPreference::Quit, false);
        }
}));

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

IdP 연동 해제¶

IdP 계정 목록 UI에서 이미 연동된 계정을 유저가 연동 해제하게 할 수 있습니다. 유저가 UI에서 특정 IdP 계정 연동을 해제하면 게임 스튜디오에서는 연동 해제할 IdP ProviderType을 인자로 disconnect() 메서드를 호출해 연동을 해제합니다. disconnect() 메서드 호출 후, 유저의 연동 상태 정보를 다시 확인하여 연동 목록 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 연결 해제 성공
                        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:    
        // 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;    
       }    
}];

게임 스튜디오는 IdP 연동 해제 구현 시 아래 정책 중에서 원하는 정책을 선택할 수 있습니다.

1. 모든 IdP 연동을 해제하고 게스트 계정을 사용하도록 허락
2. 1개 IdP 계정만은 반드시 연동 상태를 유지하게끔 강제

IdP 연동 해제: 모든 IdP 연동 해제 허용¶

게임 스튜디오는 유저가 모든 IdP 계정 연동을 해제하고 게스트 계정을 사용하도록 할 수 있습니다. 게스트 계정을 사용하면, 게임 초기화와 재설치 등으로 게스트 계정 분실 시 계정을 복구할 수 없습니다. 따라서, 현재 연동된 IdP가 하나만 남았을 때 유저가 이 IdP 연동마저 해제하려고 하면, 연동 해제를 재고할 수 있도록 게스트 유저 관련 안내를 아래 문구를 사용해 구현하세요. 단, IdP 연동을 해제해도 PlayerID는 로그아웃되지 않습니다.

• 현재 연동한 IdP 계정이 1개만 남은 상태에서 이 IdP 계정 연동마저 해제하려는 경우

위와 같이 안내 문구를 노출했음에도 유저가 계정 연동 해제를 선택하면 disconnect()를 호출합니다. 유저 계정이 게스트 계정이 되면 아래 문구를 노출할 수 있습니다.

• 마지막 IdP 계정 연동 해제 후 게스트 상태가 되었을 경우

IdP 연동 해제: 최소 1개 계정은 연동 상태를 유지¶

게임 스튜디오는 유저가 최소 1개 IdP 계정 연동은 유지하도록 할 수 있습니다. 유저가 모든 IdP 계정 연동을 해제하면 게스트 계정으로 전환되며, 게임 초기화와 재설치 등으로 게스트 계정 분실 시 계정을 복구할 수 없습니다. 따라서, 현재 연동된 IdP가 하나인 유저가 IdP 연동을 해제하려고 하면, 이를 제한하는 알림을 아래 문구를 사용해 구현할 수 있습니다. 단, IdP 연동을 해제해도 PlayerID는 로그아웃되지 않습니다.

• 현재 연동한 IdP 계정이 1개만 남은 상태에서 이 IdP 계정 연동마저 해제하려는 경우

커스텀 IdP 연동¶

커스텀 IdP 연동은 맞춤형 기능으로, Hive에서 제공하는 IdP 외에 게임 자체에서 구현한 IdP로 연동을 구현할 수 있습니다. 커스텀 로그인 API 호출 후 콜백으로 전달 받는 PlayerInfo 클래스 인스턴스로 customProviderInfoData 데이터에 접근하여 커스텀 로그인된 유저 정보를 확인할 수 있습니다. customProviderInfoData의 ProviderType(enum) 은 모두 CUSTOM으로 동일하게 설정되며, ProviderName(String)으로 상세히 구분할 수 있습니다.

다음은 커스텀 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:
                    // 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"

// 게임에서 "CUSTOM_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; // EHiveProviderType::CUSTOM, 커스텀들은 Type 이 고정
                                        FString ProviderName = ProviderInfo->ProviderName; // ProviderName으로 구분 필요
                                        FString ProviderUserId = ProviderInfo->ProviderUserId; // 직접 구현한 트위터 로그인에 사용된 사용자 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:
                    // 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;
                    }
            }];
        }];