로그인(이용자 흐름)

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) =>
            {
            });
        }
    });
}

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 HandleResult(Result result)
{
    OperationUI.HandleResult(result, (Result handleResult) =>
    {

    });
}

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

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) => { });
            }
        }
    });
}

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

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

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

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

public void GetToken()
{
    string token = Auth.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'
}

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

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

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 연결 성공
        }
    });
}