Login (User Flow)

public void AuthInitialize()
{
    Auth.Initialize(result =>
    {
        if (result.IsSuccessful)
        {
            //초기화 성공
            /** 초기화 성공 및 앱 선택 업데이트 처리 **/
            OperationUI.HandleResult(result, (Result operationResult) =>
            {
                //IAP 초기화 | GameConfig 조회 | ...(중략)...
                /** ex) Touch To Screen 화면 노출 (=게임 시작이 준비되어 로그인 가능한 상태) **/
                //사용자가 화면을 터치
                if (Auth.AccessToken != null)
                {
                    /** AccessToken 있음 → 게스트 & 정회원 관계 없이 자동로그인으로 처리 **/
                    Login();
                }
                else
                {
                    /** AccessToken 없음 → 사용자 로그인 방식을 선택할 수 있도록 화면 제공 (`게스트 시작 & 로그인`) **/
                    //사용자가 `게스트 시작`을 선택한 경우 → `StartNewGuest()` 호출
                    //`로그인`을 선택한 경우 → `Login()` 호출
                }
            });

        }
        else if (result.Domain.Equals(Auth.Domain))
        {
            if (result.ErrorCode == AuthConfigurationError)
            {
                //설정 오류
                //set meta-data 'com.stove.environment' in AndroidManifest.xml
                //"check constants server :client_id and service_id are null or empty"
            }
            else
            {
                //ErrorCode == 30003 점검
                //ErrorCode == 30004 강제 업데이트
                /** 점검 및 앱 강제 업데이트 팝업 처리 **/
                OperationUI.HandleResult(result, (Result operationResult) =>
                {
                });
            }
        }
        else
        {
            //네트워크 또는 기타 서버 에러
            OperationUI.HandleResult(result, (Result operationResult) =>
            {
            });
        }
    });
}

#include "Auth.h"
#include "OperationUI.h"
#include "Result.h"

Auth::Initialize([] (Result result) {
    string resultString = result.ToJSONString();

    if (result.IsSuccessful()) {
        OperationUI::HandleResult(result, [] (Result operationResult) {
            //IAP 초기화 | GameConfig 조회 | ...(중략)...
            /** ex) Touch To Screen 화면 노출 (=게임 시작이 준비되어 로그인 가능한 상태) **/
            //사용자가 화면을 터치
            AccessToken accessToken = Auth::GetAccessToken();

            if (!accessToken.IsNull()) {
            {
                /** AccessToken 있음 → 게스트 & 정회원 관계 없이 자동로그인으로 처리 **/
                Login();
            }
            else
            {
                /** AccessToken 없음 → 사용자 로그인 방식을 선택할 수 있도록 화면 제공 (`게스트 시작 & 로그인`) **/
                //사용자가 `게스트 시작`을 선택한 경우 → `StartNewGuest()` 호출
                //`로그인`을 선택한 경우 → `Login()` 호출
            }
        });
    } else if (result.domain.Equals(Auth::Domain, ESearchCase::CaseSensitive)) {
        if (result.errorCode == Auth::AuthConfigurationError) {

        } else {
            // 강제 업데이트, 점검
            OperationUI::HandleResult(result, [] (Result operationResult){

            });
        }
    } else {
        // 네트워크 또는 기타 서버 에러
        OperationUI::HandleResult(result, [] (Result operationResult){

        });
    }
});

fun initialize(activity: Activity) {
    Auth.initialize(activity.applicationContext) { result ->
        when {
            result.isSuccessful() -> {
                //Init succeed. Handle optional app update
                OperationUI.handleResult(activity, result) {
                    //Do login.
                }
            }
            result.domain == Auth.Domain -> {
                when (result.errorCode) {
                    Auth.AuthConfigurationError -> {
                        //set meta-data 'com.stove.environment' in AndroidManifest.xml
                        //"check constants server :client_id and service_id are null or empty"
                    }
                    else -> {
                        //Handle required app update & maintenance
                        OperationUI.handleResult(activity, result) {

                        }
                    }
                }
            }
            else -> {
                //NetworkError
                //User notify & retry initialize
                OperationUI.handleResult(activity, result) {
                    initialize(activity)
                }
            }
        }
    }
}

public void initialize(@NotNull final Activity activity) {
    Auth.initialize(this, (@NotNull Result result) -> {
        if (result.isSuccessful()) {
            //Init succeed. Handle optional app update
            OperationUI.handleResult(activity, result, (@NotNull Result handleResult) -> {
                //Do login.
                return null;
            });
        } else if (result.getDomain().equals(Auth.Domain)) {
            switch (result.getErrorCode()) {
                case Auth.AuthConfigurationError:
                    //set meta-data 'com.stove.environment' in AndroidManifest.xml
                    //"check constants server :client_id and service_id are null or empty"
                    break;
                default:
                    //Handle required app update & maintenance
                    OperationUI.handleResult(activity, result, (@NotNull Result handleResult) -> null);
            }
        } else {
            //NetworkError
            //User notify & retry initialize
            OperationUI.handleResult(activity, result, (@NotNull Result handleResult) -> {
                initialize(activity);
                return null;
            });
        }
        return null;
    });
}

[SGSAuth initializeWithCompletionHandler:^(SGSResult * _Nonnull result) {
    if ([result isSuccessful]) {
        // 선택 업데이트 또는 성공
        [SGSOperationUI handleResult:result fromViewController:self completionHandler:^(SGSResult * _Nonnull result) {

        }];
    } else if ([[result domain] isEqualToString:SGSAuthErrorDomain]) {
        if ([result errorCode] == SGSAuthErrorAuthConfig) {
            // check constants server : client_id and service_id are null or empty
        } else {
            // 강제 업데이트, 점검
            [SGSOperationUI handleResult:result fromViewController:self completionHandler:^(SGSResult * _Nonnull result) {

            }];
        }
    } else {
        // 네트워크 또는 기타 서버 에러
        [SGSOperationUI handleResult:result fromViewController:self completionHandler:^(SGSResult * _Nonnull result) {

        }];
    }
}];

public void HandleResult(Result result)
{
    OperationUI.HandleResult(result, (Result handleResult) =>
    {

    });
}

#include "OperationUI.h"
#include "Result.h"

OperationUI::HandleResult(result, [] (Result operationResult) {

});

fun handleResult(activity: Activity, result : Result){
    OperationUI.handleResult(activity, result) {
    }
}

OperationUI.handleResult(activity, result, (@NotNull Result it) -> {
    return null;
});

[SGSOperationUI handleResult:result fromViewController:fromViewController completionHandler:^(SGSResult * _Nonnull result) {

}];

public void SetProviders()
{
    List<Provider> providers = new List<Provider>
    {
        new EmailProvider(),
        new StoveAppProvider(),
        new GuestProvider(),
        new GoogleProvider(),
        new FacebookProvider(),
        new AppleProvider(),
        new SteamProvider(),
        new LineProvider(),
        new NaverProvider(),
        new TwitterProvider()
    };
    AuthUI.Providers = providers;
}

#include "EmailProvider.h"
#include "StoveAppProvider.h"
#include "GuestProvider.h"
#include "GoogleProvider.h"
#include "FacebookProvider.h"
#include "AppleProvider.h"
#include "SteamProvider.h"
#include "LineProvider.h"
#include "NaverProvider.h"
#include "TwitterProvider.h"
#include "AuthUI.h"

list<Provider*> provider;
provider.push_back(new EmailProvider());
provider.push_back(new StoveAppProvider());
provider.push_back(new GuestProvider());
provider.push_back(new GoogleProvider());
provider.push_back(new FacebookProvider());
provider.push_back(new AppleProvider());
provider.push_back(new SteamProvider());
provider.push_back(new LineProvider());
provider.push_back(new NaverProvider());
provider.push_back(new TwitterProvider());

AuthUI::SetProviders(provider);

fun setProviders(context : Context) {
    AuthUI.setProviders(context, listOf(
        EmailProvider(), StoveAppProvider(), GuestProvider(),
        GoogleProvider(), FacebookProvider(), AppleProvider(),
        SteamProvider(), LineProvider(), NaverProvider(), TwitterProvider()
    ))
}

public void setProviders(@NotNull Context context) {
    AuthUI.setProviders(context, CollectionsKt.listOf(
        new EmailProvider(), new StoveAppProvider(), new GuestProvider(),
        new GoogleProvider(), new FacebookProvider(), new AppleProvider(),
        new SteamProvider(), new LineProvider(), new NaverProvider(), new TwitterProvider()
    ));
}

SGSEmailProvider *emailProvider = [[SGSEmailProvider alloc] init];
SGSStoveAppProvider *stoveappProvider = [[SGSStoveProvider alloc] init];
SGSGuestAppProvider *guestProvider = [[SGSGuestProvider alloc] init];
SGSAppleProvider *appleProvider = [[SGSAppleProvider alloc] init];
SGSGoogleProvider *googleProvider = [[SGSGoogleProvider alloc] init];
SGSFacebookProvider *facebookProvider = [[SGSFacebookProvider alloc] init];
SGSSteamProvider *steamProvider = [[SGSSteamProvider alloc] init];
SGSLineProvider *lineProvider = [[SGSLineProvider alloc] init];
SGSNaverProvider *naverProvider = [[SGSNaverProvider alloc] init];
SGSTwitterProvider *twitterProvider = [[SGSTwitterProvider alloc] init];

NSArray *providers = @[emailProvider, stoveappProvider, guestProvider,
                       appleProvider, facebookProvider, googleProvider,
                       steamProvider, lineProvider, naverProvider, twitterProvider];

[SGSAuthUI setProviders:providers];

public void Login()
{
    AuthUI.Login((Result result, AccessToken accessToken) =>
    {
        if (result.IsSuccessful)
        {
            if (result.UserInfo != null && result.UserInfo.TryGetValue("userAction", out string userAction))
            {
                if (!string.IsNullOrEmpty(userAction) && userAction.Equals("sanction"))
                {
                    /** ex) 로그아웃 or 재시작 등 게임 시나리오에 맞게 적용 **/
                }
            }
        }
        else
        {
            if (result.IsServerError)
            {
                OperationUI.HandleResult(result, (Result operationResult) =>
                {
                    if (result.ErrorCode == 44008 || result.ErrorCode == 45006) { Auth.Logout(); }
                    if (result.ErrorCode == 44010) { Auth.Logout(); }
                });
            }
            else if(result.IsCanceled) {
                if (Auth.AccessToken != null) {
                    //자동 또는 수동 로그인 재시도
                    Login();
                }
                else {
                    Login();
                }
            }
            else
            {
                OperationUI.HandleResult(result, (Result operationResult) => { });
            }
        }
    });
}

#include "AuthUI.h"
#include "AccessToken.h"
#include "OperationUI.h"
#include "Result.h"
#include "User.h"

AuthUI::Login([] (Result result, AccessToken accessToken) {
    if (result.IsSuccessful()) {
        if (!result.userInfo.IsEmpty()) {
            TMap<FString, FString> userInfoMap = result.userInfo;
            FString userAction = userInfoMap.FindRef(TEXT("userAction"));
            if (userAction == TEXT("sanction")) {
                //제재 처리
            }
        }
    } else {
        if (result.IsServerError()) {
            OperationUI::HandleResult(result, [] (Result operationResult){
                if (result.errorCode == 44008 || result.errorCode == 45006) { Auth::Logout(); }
                if (result.errorCode == 44010) { Auth::Logout(); }
            });
        } else if(result.IsCanceled()) {
            AccessToken accessToken = Auth::GetAccessToken();
            if (!accessToken.IsNull()) {
                //자동 또는 수동 로그인 재시도
            }
        } else {
            OperationUI::HandleResult(result, [] (Result operationResult) { });
        }
    }
});

fun login(activity: Activity) {
    AuthUI.login(activity) { result, accessToken ->
        when {
            result.isSuccessful() -> {
                //제재된 사용자 확인 (=게임에서 직접 처리하는 경우)
                if(result.userInfo == AuthUI.Sanctioned) {
                    // 로그아웃 or 재시작 등 게임 시나리오에 맞게 적용
                    return@login
                }

                //로그인 이후 화면으로 이동
                val token = accessToken!!.token //AccessToken
                val user = accessToken.user
                val memberNumber: Long = user.memberNumber
                val verifiedIdentity: Boolean = user.verifiedIdentity
                val nationality: String = user.nationality
                val isGuest: Boolean = user.isGuest()
                val providers = user.providerUsers
                for (provider in providers) {
                    val type: Int = provider.type //1:StoveEmail, 2:Facebook, 3:Twitter, 6:Naver, 9:Google, 12:Apple, 13:Line, 15:Steam
                    val userId: String = provider.userId
                    val email: String? = provider.email
                    val verifiedEmail: Boolean? = provider.verifiedEmail
                }
            }
            result.isCanceled() -> {
                //사용자 취소, 로그인 화면 유지
            }
            result.isServerError() -> {
                OperationUI.handleResult(activity, result) { }
            }
            else -> {
                OperationUI.handleResult(activity, result) { }
            }
        }
    }
}

public void login(@NotNull final Activity activity) {
    AuthUI.login(activity, (@NotNull Result result, @Nullable AccessToken accessToken) -> {
        if (result.isSuccessful()) {
            Map<String, String> userInfo = result.getUserInfo();
            if(userInfo != null && userInfo.containsKey("userAction")) {
                String userAction = userInfo.get("userAction");
                if(userAction != null && userAction.equals("sanction")) {
                    return null;
                }
            }
            String token = accessToken.getToken();
            User user = accessToken.getUser();
            long memberNumber = user.getMemberNumber();
            boolean verifiedIdentity = user.getVerifiedIdentity();
            String nationality = user.getNationality();
            boolean isGuest = user.isGuest();
            List<ProviderUser> providers = user.getProviderUsers();
            for (ProviderUser provider : providers) {
                int type = provider.getType();
                String userId = provider.getUserId();
                String email = provider.getEmail();
                boolean verifiedEmail = provider.getVerifiedEmail();
            }
        } else if (result.isCanceled()) {
            //사용자 취소
        } else if (result.isServerError()) {
            OperationUI.handleResult(activity, result, (@NotNull Result it) -> null);
        } else {
            OperationUI.handleResult(activity, result, (@NotNull Result it) -> null);
        }
        return null;
    });
}

[SGSAuthUI loginWithFromViewController:nil completionHandler:^(SGSResult * _Nonnull result, SGSAccessToken * _Nullable accessToken) {
    if (result.isSuccessful) {
        NSString *userAction = [result.userInfo objectForKey:@"userAction"];
        if ([userAction isEqualToString:@"sanction"]) {
            return;
        }

        NSString *token = accessToken.token;
        SGSUser *user = accessToken.user;
        NSNumber *memberNumber = user.memberNumber;
        BOOL verifiedIdentity = user.verifiedIdentity;
        NSString *nationality = user.nationality;
        BOOL isGuest = user.isGuest;
        NSArray *providers = user.providerUsers;
        for (SGSProviderUser *providerUser in providers) {
            int type = providerUser.type;
            NSString *userId = providerUser.userId;
            NSString *email = providerUser.email;
            BOOL verifiedEmail = providerUser.verifiedEmail;
        }
    } else if (result.isCanceled) {
        //사용자 취소
    } else if (result.isServerError) {
        [SGSOperationUI handleResult:result fromViewController:self completionHandler:^(SGSResult * _Nonnull result) { }];
    } else {
        [SGSOperationUI handleResult:result fromViewController:self completionHandler:^(SGSResult * _Nonnull result) { }];
    }
}];

private void SetGameProfile()
{
    string CharacterNumber = "setYourCharacterNumber";
    string WorldId = "setYourWorld";
    AccessToken accessToken = Auth.AccessToken;
    if(accessToken == null) { return; }
    accessToken.User.GameProfile = new GameProfile(CharacterNumber, WorldId);
}

#include "Auth.h"
#include "AccessToken.h"
#include "GameProfile.h"

FString world = "setYourWorld";
int64 chracternumber = "setYourCharacterNumber";

GameProfile gameProfile = GameProfile(chracternumber, world);

AccessToken accessToken = Auth::GetAccessToken();
if (!accessToken.IsNull()) {
    accessToken.user.SetGameProfile(gameProfile);
}

private fun setGameProfile() {
    val characterNumber = "setYourCharacterNumber"
    val worldId = "setYourWorld"
    // characterNumber, world 값의 유효성 체크(null)를 꼭 해주세요.
    Auth.accessToken?.user?.gameProfile = GameProfile(characterNumber, worldId)
}

private void setGameProfile(@NotNull Context context) {
    Long characterNumber = 111L; // setYourCharacterNumber
    String world = ""; // setYourCharacterWorld
    // characterNumber, world 값의 유효성 체크(null)를 꼭 해주세요.
    AccessToken accessToken = Auth.getAccessToken();
    if (accessToken != null) {
        User user = accessToken.getUser();
        user.setGameProfile(context, new GameProfile(characterNumber, world));
    }
}

NSString *characterNumber = @"setYourCharacterNumber";
NSString *worldId = @"setYourWorld";
SGSAccessToken *accessToken = [SGSAuth accessToken];
if(accessToken == nil) { return; }
SGSGameProfile *gameProfile = [[SGSGameProfile alloc] initWithCharacterNumber:characterNumber world:worldId];
[[accessToken user] setGameProfile:gameProfile];

private void SetGameProfile()
{
    string CharacterNumber = "setYourCharacterNumber";
    AccessToken accessToken = Auth.AccessToken;
    if (accessToken == null) { return; }
    accessToken.User.GameProfile = new GameProfile(CharacterNumber);
}

#include "Auth.h"
#include "AccessToken.h"
#include "GameProfile.h"

int64 chracternumber = "setYourCharacterNumber";

GameProfile gameProfile = GameProfile();
gameProfile.characterNumber = chracternumber;

AccessToken accessToken = Auth::GetAccessToken();
if ( accessToken != nullptr) {
    accessToken.user.SetGameProfile(gameProfile);
}

private fun setGameProfile() {
    val characterNumber = "setYourCharacterNumber"
    // characterNumber 값의 유효성 체크(null)를 꼭 해주세요.
    Auth.accessToken?.user?.gameProfile = GameProfile(characterNumber, null)
}

private void setGameProfile(@NotNull Context context) {
    Long characterNumber = 111L;
    AccessToken accessToken = Auth.getAccessToken();
    if (accessToken != null) {
        User user = accessToken.getUser();
        user.setGameProfile(context, new GameProfile(characterNumber, null));
    }
}

NSString *characterNumber = @"setYourCharacterNumber";
SGSAccessToken *accessToken = [SGSAuth accessToken];
if(accessToken == nil) { return; }
SGSGameProfile *gameProfile = [[SGSGameProfile alloc] initWithCharacterNumber:characterNumber world:nil];
[[accessToken user] setGameProfile:gameProfile];

public void GetToken()
{
    string token = Auth.AccessToken.Token;
}

#include "Auth.h"
#include "AccessToken.h"

AccessToken accessToken = Auth::GetAccessToken();

if (!accessToken.IsNull()) {
    FString token = accessToken.token;
}

fun getAccessToken() {
    val token : String? = Auth.accessToken?.token
}

public void getAccessToken() {
    AccessToken accessToken = Auth.getAccessToken();
}

NSString *token = [[SGSAuth accessToken] token];

repositories {
    google()
    jcenter()
    maven {
        url "https://externalnexus.iam0.com/repository/mvp"
        // Android Gradle Plugin 7.0 이상 사용 시 아래 옵션 추가
        allowInsecureProtocol = true
    }
    mavenCentral()
}

dependencies {
    implementation 'com.stove:auth-googleplaygames:2.8.1'
}

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="google_play_games_project_id" translatable="false">{your_project_id}</string>
</resources>

<manifest>
    <application>
        <meta-data
            android:name="com.google.android.gms.games.APP_ID"
            android:value="@string/google_play_games_project_id"/>
    </application>
</manifest>

public void googlePlayGamesFetch(string sessionId)
{
    GPGProvider provider = new GPGProvider(sessionId); // recallSessionId
    provider.Fetch((Result result, List<Dictionary<string, object>> accounts) =>
    {
        if (result.IsSuccessful)
        {
            // accounts : 계정 목록
        }
    });
}

#include "Auth.h"
#include "GPGProvider.h"
#include "Result.h"

GPGProvider* provider = new GPGProvider(googleGameSessionId);
provider->Fetch([] (Result result, list<map<string, string>> accounts) {
    if (result.IsSuccessful()) {
        // accounts : 계정 목록
    }
});

private fun googlePlayGamesFetch(context: Context, sessionId: String) {
    val provider = GPGProvider(sessionId) // recallSessionId
    provider.fetch(context) { result, jsonArray ->
        if (result.isSuccessful()) {
            // jsonArray : 계정 목록
        }
    }
}

public void googlePlayGamesFetch(@NotNull Context context, @NotNull String sessionId) {
    GPGProvider provider = new GPGProvider(sessionId); // recallSessionId
    provider.fetch(context, (result, jsonArray) -> {
        if (result.isSuccessful()) {
            // jsonArray : 계정 목록
        }
        return null;
    });
}

public void googlePlayGamesLoad(string sessionId, Dictionary<string, object> account)
{
    /** account → Fetch의 결과로 얻은 계정 목록에서 획득 **/
    GPGProvider provider = new GPGProvider(sessionId); // recallSessionId
    provider.Load(account, (Result result, GPGProvider loadedProvider) =>
    {
        if (loadedProvider != null) {
            Auth.Login(loadedProvider, (Result loginResult, AccessToken accessToken) => {
                if (loginResult.IsSuccessful) {
                    // 로그인 성공
                } else if (loginResult.IsServerError) {
                    OperationUI.HandleResult(loginResult, (Result operationResult) =>
                    {
                        // 게스트 자동 로그인 불가 케이스
                        if (loginResult.ErrorCode == 44008 || loginResult.ErrorCode == 45006) {
                            Auth.Logout();
                        }
                    });
                }
            });
        }
    });
}

#include "Auth.h"
#include "GPGProvider.h"
#include "Result.h"
#include "AccessToken.h"

GPGProvider* provider = new GPGProvider(googleGameSessionId);

provider->Load(list.front(), [] (Result result, GPGProvider* gpgProvider) {
    if (gpgProvider != nullptr) {
        Auth::Login(gpgProvider, [] (Result result, AccessToken* accessToken) {
            if (result.IsSuccessful()) {
                // 로그인 성공
            } else if (result.IsServerError()) {
                OperationUI::HandleResult(result, [] (Result operationResult) {
                    if (result.errorCode == 44008 || result.errorCode == 45006) {
                        Auth::Logout();
                    }
                });
            }
        });
    }
});

private fun googlePlayGamesLoad(activity: Activity, sessionId: String, jsonObject: JSONObject) {
    /** jsonObject → Fetch의 결과로 얻은 계정 목록에서 획득 **/
    val provider = GPGProvider(sessionId) // recallSessionId
    provider.load(activity, jsonObject) { result, loadProvider ->
        loadProvider?.let {
            Auth.login(activity, it) { loginResult: Result, accessToken: AccessToken? ->
                if (loginResult.isSuccessful()) {
                    // 로그인 성공
                }
            }
        }
    }
}

private void googlePlayGamesLoad(@NotNull Activity activity, @NotNull String sessionId, @NotNull JSONObject jsonObject) {
    /** jsonObject → Fetch의 결과로 얻은 계정 목록에서 획득 **/
    GPGProvider provider = new GPGProvider(sessionId); // recallSessionId
    provider.load(activity, jsonObject, (@NotNull Result result, @Nullable GPGProvider loadedProvider) -> {
        if (loadedProvider != null) {
            Auth.login(activity, loadedProvider, (@NotNull Result loginResult, @Nullable AccessToken accessToken) -> {
                if (loginResult.isSuccessful()) {
                    // 로그인 성공
                }
                return null;
            });
        }
        return null;
    });
}

public void googlePlayGamesLink(string sessionId)
{
    GPGProvider provider = new GPGProvider(sessionId); // recallSessionId

    AccessToken accessToken = Auth.AccessToken;
    if (accessToken == null) { return; }
    accessToken.User.Link(provider, (Result result) =>
    {
        if (result.IsSuccessful)
        {
            // Google Play Games 연결 성공
        }
    });
}

#include "Auth.h"
#include "GPGProvider.h"
#include "Result.h"
#include "AccessToken.h"

GPGProvider* provider = new GPGProvider(googleGameSessionId);

AccessToken *accessToken = Auth::GetAccessToken();
if (accessToken != nullptr) {
    accessToken->user.Link(provider, [] (Result result) {
        if (result.IsSuccessful()) {
            // Google Play Games 연결 성공
        }
    });
}

private fun googlePlayGamesLink(activity: Activity, sessionId: String) {
    val provider = GPGProvider(sessionId) // recallSessionId
    Auth.accessToken?.user?.link(activity, provider) { result: Result ->
        if (result.isSuccessful()) {
            // Google Play Games 연결 성공
        }
    }
}

private void googlePlayGamesLink(@NotNull Activity activity, @NotNull String sessionId) {
    GPGProvider provider = new GPGProvider(sessionId); // recallSessionId
    AccessToken accessToken = Auth.getAccessToken();
    if (accessToken != null) {
        User user = accessToken.getUser();
        if (user != null) {
            user.link(activity, provider, (@NotNull Result result) -> {
                if (result.isSuccessful()) {
                    // Google Play Games 연결 성공
                }
                return null;
            });
        }
    }
}