- Cập nhật lần cuối
Login (User Flow)
Understanding
STOVE Login is the standard procedure for users to access games or web services using their STOVE account. It supports various authentication methods such as Email, Guest, and 3rd party (Google, Facebook, Apple, etc.). Depending on the launch platform (Mobile/PC/Web), you can integrate it by using the SDK integrated UI or by configuring the UI directly within the game.
Login Flow
The login flow and the tools used vary depending on the platform where the game is released. You only need to integrate the necessary areas according to your game's launch format.
| Platform | Integration Tool | Login UI Configuration Method | Representative Entry Scenario |
|---|---|---|---|
| Mobile | Mobile SDK | Integrated UI (AuthUI) / Direct Configuration (Auth DATA API) |
App launch → Account login → Enter game |
| PC | PC SDK + STOVE PC Client | SDK automatically receives launcher login information | Game launch after launcher login → Auto-login |
| Web | STOVE Web Authentication (GNB / Login URL) | Responsive GNB UI or STOVE login page | Account login from official website/event page |
Note on Platform Integration
ㆍ Multi-platform games integrate necessary platforms together, such as Mobile + PC + Web.
ㆍ Even if the platforms are different, the STOVE member identifier remains the same, ensuring a seamless account experience.
Login Process
Existing members log in, while new users sign up or enter the game as guests.
Regardless of the platform (Mobile/PC/Web), the login process can be summarized into the following 3 steps.
| Step | Task | Description |
|---|---|---|
| 1 | Initialize SDK or Web Module | Acquire initial information for using STOVE services |
| 2 | Perform Login | Log in with an account and issue a User Access Token. Handle terms of service agreement if necessary |
| 3 | Prepare for Game Entry | Save character information after selecting a server/world. Used for identification in coupons, pop-ups, billing, push notifications, etc. |
Login Methods
The STOVE SDK supports two login methods. Although expressed based on the Mobile SDK, the same concepts apply to each platform.
| Method | Description |
|---|---|
| Integrated Login UI (Auth.UI) | Easily implement authentication with an integrated UI. Adding or removing authentication methods is flexible |
| Direct Login Implementation (DATA API) | Implement desired authentication directly using DATA API. Obtain tokens via provider-specific login |
Criteria for Choosing a Method
ㆍ If fast launch and using a standard UI are priorities, we recommend the Integrated Login UI.
ㆍ If a game-specific UI/UX is required, choose the Direct Login (DATA API) method.
Provider Types
A Provider is an authentication channel. Select and register the channels the game will expose. (Based on Mobile SDK)
| Provider | Android | iOS | Unity | Unreal |
|---|---|---|---|---|
| Email (STOVE) | O | O | O | O |
| Guest | O | O | O | O |
| O | O | O | O | |
| O | O | O | O | |
| Apple | O | O | O | O |
| Steam | O | O | O | O |
| LINE | O | O | O | O |
| Naver | O | O | O | O |
PC/Web Channel Reference
ㆍ PC uses the login channel of the Stove PC client, and Web uses the channel of the Stove login page.
ㆍ PC/Web channels may vary depending on platform policies, so please check with the technical PM in charge.
Provider Display Order
On the mobile SDK login screen, providers are displayed in the order you have set.
- Email is mandatory and must be displayed first in the list.
- Multi-platform (PC-supported) games must display all providers offered by Stove, and individual selection is not possible.
- The recommended display order by region can be found in 이용 시나리오 > 로그인하기.
Additional Login Features
These are additional features provided along with Stove login, in addition to basic login.
| Function | Supported Platforms | Description |
|---|---|---|
| GPG Login (Google Play Games) |
Mobile SDK (Android) | 1:1 connection between Google Play Games account and STOVE account |
| Auto-login | Mobile SDK, PC SDK | Automatic login without input if a valid token exists |
Precautions
Please check before integrating login
ㆍ Server-side token validation is mandatory after login. Please refer to 인증 가이드 for the validation flow.
ㆍ Character setup is mandatory. If not set, back-office integration features (coupons, pop-ups, billing, push, etc.) will not function.
Integration Guide
Preparation by Platform
You only need to proceed with the preparation for the platforms required based on your game's release format.
| Platform | Required Items |
|---|---|
| Mobile | ㆍ Apply Mobile SDK ㆍ Set App ID/Client ID ㆍ Register Package/Bundle ID ㆍ Pre-configuration per 3rd party Provider |
| PC | ㆍ Apply PC SDK (PCSDK3) ㆍ Set App ID/Client ID ㆍ Login handled by STOVE PC client (no separate Provider setup required) |
| Web | ㆍ Available if the domain is xxx.game.onstove.comㆍ Domain connection and referral path code handled by Technical PM ㆍ External infrastructure requires SSL certificate |
| Server | ㆍ Issue API Access Token for token validation (Authentication Guide reference) ㆍ Firewall settings required when using SSO |
3rd party Provider pre-configuration must be completed before launch
ㆍ Console settings, key issuance, and app settings for all Providers to be used must be completed for them to appear on the login screen.
ㆍ Failure to do so may delay the verification schedule.
Below is a summary of console settings, key issuance, and app settings for each 3rd party Provider. Please expand only the items for the Providers you intend to use. Follow Development Environment Setup for STOVE Maven repository registration and SDK module versions; this section only covers keys and settings per Provider. Console key values (Client ID, Secret, Channel ID, etc.) are issued and delivered through the publishing technical manager (Technical PM).
Overall Login Flow
Even if the platforms (Mobile/PC/Web) are different, the login sequence remains the same. Only the specific methods for implementing each step (SDK functions, UI configuration, etc.) vary depending on the platform.
Development
Integrated Login (Recommended Flow)
This is how to implement authentication using the STOVE SDK's integrated login UI. The core flow of the integrated login is Auth.initialize → setProvider → AuthUI.login → User.setGameProfile It proceeds in a 4-step sequence.
This is the step to acquire the initial information required to use the service. Initialization must be completed before you can use SDK features such as login, payment, and coupons.
- Acquire service settings (
service_id,market_game_id) - Check if an app update is required
- Check if the game is under maintenance
!info
App updates and game maintenance are handled automaticallyAuth.initializeIf you pass theResultreceived in the response toOperationUI.handleResult(activity, result, listener)as is, the SDK will automatically display the maintenance (MaintenanceError30003) / app update (AppUpdateError30004) screen. Continue the game entry flow within the callback.
Refer to the code example in the 앱 업데이트 및 게임 점검 처리 section below.
=== "Unity"
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 없음 → 사용자 로그인 방식을 선택할 수 있도록 화면 제공 (`게스트 시작 & 로그인`) **/
//사용자가 `게스트 시작`을 선택한 경우 → 게스트로 시작 (3.0.0 이상 Unity · Unreal: `AuthUI.GuestStart`)
//`로그인`을 선택한 경우 → 통합 로그인으로 시작 (`AuthUI.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) =>
{
});
}
});
}
=== "Unreal"
#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 없음 → 사용자 로그인 방식을 선택할 수 있도록 화면 제공 (`게스트 시작 & 로그인`) **/
//사용자가 `게스트 시작`을 선택한 경우 → 게스트로 시작 (3.0.0 이상 Unity · Unreal: `AuthUI.GuestStart`)
//`로그인`을 선택한 경우 → 통합 로그인으로 시작 (`AuthUI.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){
});
}
});
=== "Android (Kotlin)"
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)
}
}
}
}
}
=== "Android (Java)"
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;
});
}
=== "iOS"
[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) {
}];
}
}];
ErrorCodes
!info
Cases with clear actions
30001AuthConfigurationError: The partner key (client_id·service_id) is missing. Please ensure the partner-issued key is correctly applied before calling initialization.30003MaintenanceError /30004AppUpdateError: This is a normal response for maintenance or app updates.OperationUI.handleResultPass the result as-is to the SDK to display the automatic guidance UI. (Do not handle it manually)
| Domain | ErrorCode | Description |
|---|---|---|
| com.stove.success | 0 | Success |
| com.stove.auth | 30001 | AuthConfigurationError : Check constants server : client_id and service_id are null or empty |
| com.stove.auth | 30003 | MaintenanceError |
| com.stove.auth | 30004 | AppUpdateError |
| com.stove.base.network | 10001 | NoConnectionError |
| com.stove.base.network | 10002 | TimeoutError |
App Update and Game Maintenance Handling
If the initialization result is 'App Update' or 'Game Maintenance', the UI is displayed to guide the user.


=== "Unity"
public void HandleResult(Result result)
{
OperationUI.HandleResult(result, (Result handleResult) =>
{
});
}
=== "Unreal"
#include "OperationUI.h"
#include "Result.h"
OperationUI::HandleResult(result, [] (Result operationResult) {
});
=== "Android (Kotlin)"
fun handleResult(activity: Activity, result : Result){
OperationUI.handleResult(activity, result) {
}
}
=== "Android (Java)"
OperationUI.handleResult(activity, result, (@NotNull Result it) -> {
return null;
});
=== "iOS"
[SGSOperationUI handleResult:result fromViewController:fromViewController completionHandler:^(SGSResult * _Nonnull result) {
}];
AuthUI.loginBefore calling this, register the authentication channels (Providers) that the game will support. They will be displayed on the login screen in the exact order they were registered.
Adding Authentication Channels (Partner Pre-configuration)
Please pre-register authentication information in the Partners Console for each Provider you wish to display on the login screen. Refer to the links below for each channel's setup guide.
- The Provider list is displayed on the login screen in the order they were added.
- The Email Provider must be added.
- If the 'Email Provider' is not set in the connection screen, it will not be displayed.
Applying setProviders Code
AuthUI.setProvidersRegister the Providers the game will support. The order of the array passed is the order in which they appear on the screen. AuthUI.loginMust be executed before calling.

=== "Unity"
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()
};
AuthUI.Providers = providers;
}
=== "Unreal"
#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 "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());
AuthUI::SetProviders(provider);
=== "Android (Kotlin)"
fun setProviders(context : Context) {
AuthUI.setProviders(context, listOf(
EmailProvider(), StoveAppProvider(), GuestProvider(),
GoogleProvider(), FacebookProvider(), AppleProvider(),
SteamProvider(), LineProvider(), NaverProvider()
))
}
=== "Android (Java)"
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()
));
}
=== "iOS"
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];
NSArray *providers = @[emailProvider, stoveappProvider, guestProvider,
appleProvider, facebookProvider, googleProvider,
steamProvider, lineProvider, naverProvider];
[SGSAuthUI setProviders:providers];
!info
Flow automatically handled by the SDK within AuthUI.login
The following processes occur with a single integrated login call. If you use the integrated UI, no separate calls are required.
Feature Automatic Display Timing Cases Requiring Separate Calls Device Registration/Management Automatically displayed when a new device registration is required When launching the device management UI directly from the in-game settings screen Identity Verification Automatically displayed when verification is required by law/policy When forcing re-verification before entering payment or sensitive features
AuthUI.loginCalling this will automatically operate according to the login flow chart.
It displays the login screen or refreshes the AccessToken, and proceeds to handle terms and conditions if there are any to show the user.

AuthUI.loginBoth login UI display and AccessToken refresh are handled with a single call.- 'Login with STOVE APP' is only displayed on devices where the STOVE APP is installed.
=== "Unity"
csharp
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) Apply according to game scenario, such as logout or restart **/
}
}
}
else
{
if (result.IsServerError)
{
OperationUI.HandleResult(result, (Result operationResult) =>
{
// 2.9.x and below: The actual error code is returned as ErrorCode
if (result.ErrorCode == 44008 || result.ErrorCode == 45006) { Auth.Logout(); }
if (result.ErrorCode == 44010) { Auth.Logout(); }
// 3.0.0 and above: Mashup wrapping errors (60000 range) return the actual error code as origin_code
if (result.UserInfo != null && result.UserInfo.TryGetValue("origin_code", out string originCode))
{
// Refresh Token error (token expired, must logout and delete local token)
if (originCode == "44010")
{
Auth.Logout();
}
if (originCode == "44008" || originCode == "45006")
{
Auth.Logout();
}
}
});
}
else if(result.IsCanceled) {
if (Auth.AccessToken != null) {
//Retry automatic or manual login
Login();
}
else {
Login();
}
}
else
{
OperationUI.HandleResult(result, (Result operationResult) => { });
}
}
});
}
=== "Unreal"
```cpp
#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")) {
//Sanction handling
}
}
} else {
if (result.IsServerError()) {
OperationUI::HandleResult(result, [result] (Result operationResult){
//2.9.x and below: Actual error code is returned in errorCode
if (result.errorCode == 44008 || result.errorCode == 45006) { Auth::Logout(); }
if (result.errorCode == 44010) { Auth::Logout(); }
//3.0.0 and above: Mashup wrapping error (60000 range) returns the actual error code in origin_code
FString originCode = result.userInfo.FindRef(TEXT("origin_code"));
if (!originCode.IsEmpty()) {
//Refresh Token error (Token expired, must logout and delete local token)
if (originCode == TEXT("44010")) {
Auth::Logout();
}
if (originCode == TEXT("44008") || originCode == TEXT("45006")) {
Auth::Logout();
}
}
});
} else if(result.IsCanceled()) {
AccessToken accessToken = Auth::GetAccessToken();
if (!accessToken.IsNull()) {
//Retry automatic or manual login
}
} else {
OperationUI::HandleResult(result, [] (Result operationResult) { });
}
}
});
=== "Android (Kotlin)"
fun login(activity: Activity) {
AuthUI.login(activity) { result, accessToken ->
when {
result.isSuccessful() -> {
//Check for sanctioned user (=case handled directly in game)
if(result.userInfo == AuthUI.Sanctioned) {
//Apply according to game scenario, such as logout or restart
return@login
}
//Move to screen after 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() -> {
//User canceled, stay on login screen
}
result.isServerError() -> {
OperationUI.handleResult(activity, result) {
//2.9.x and below: Actual error code is returned in errorCode
if (result.errorCode == 44008 || result.errorCode == 45006) {
Auth.logout(activity)
}
//3.0.0 and above: Mashup wrapping error (60000 range) returns the actual error code in origin_code
result.userInfo?.get("origin_code")?.let { originCode ->
if (originCode == "44008" || originCode == "45006") {
Auth.logout(activity)
}
}
}
}
else -> {
OperationUI.handleResult(activity, result) { }
}
}
}
}
=== "Android (Java)"
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()) {
//User cancellation
} else if (result.isServerError()) {
OperationUI.handleResult(activity, result, (@NotNull Result it) -> {
//2.9.x or lower: Actual error code is returned as errorCode
if (result.getErrorCode() == 44008 || result.getErrorCode() == 45006) {
Auth.logout(activity);
}
//3.0.0 or higher: Mashup wrapping error (60000 range) returns actual error code as origin_code
Map<String, String> userInfo = result.getUserInfo();
String originCode = userInfo != null ? userInfo.get("origin_code") : null;
if ("44008".equals(originCode) || "45006".equals(originCode)) {
Auth.logout(activity);
}
return null;
});
} else {
OperationUI.handleResult(activity, result, (@NotNull Result it) -> null);
}
return null;
});
}
=== "iOS"
[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) {
//User cancellation
} else if (result.isServerError) {
[SGSOperationUI handleResult:result fromViewController:self completionHandler:^(SGSResult * _Nonnull result) { }];
} else {
[SGSOperationUI handleResult:result fromViewController:self completionHandler:^(SGSResult * _Nonnull result) { }];
}
}];
ErrorCodes
!info
명확한 조치가 있는 케이스
30001AuthConfigurationError:client_id·service_id가 null/빈 값이에요. SDK 초기화 호출 전에 파트너스에서 발급받은 키가 올바르게 설정됐는지 확인하세요.44010Invalid refresh token: 저장된 refresh token이 만료/무효예요. 토큰을 폐기하고 로그인 화면으로 유도해 신규 발급받으세요.44009Password has been changed: 비밀번호 변경 이후 기존 토큰이 무효예요. 토큰을 폐기하고 재로그인 흐름으로 유도하세요.30302ServerError (단말기 시간 변경): 이용자가 디바이스 시간을 임의로 변경한 케이스예요. 시간 설정을 자동으로 되돌리도록 안내하세요.- 3.0.0 이상 에러 코드 확인 방식 변경: 서버 에러가 매시업 래핑 에러(60000번대)로 내려오고, 실제 에러 코드(
44008·44010등)는userInfo의origin_code로 전달돼요. 2.9.x 이하는 기존처럼ErrorCode로 확인해요.
| Domain | ErrorCode | Description |
|---|---|---|
| com.stove.success | 0 | Success |
| com.stove.auth | 30001 | AuthConfigurationError : Check constants server : client_id and service_id are null or empty |
| com.stove.server | 43000 | ID or PW is incorrect. |
| com.stove.server | 43104 | Game restrict member |
| com.stove.server | 10125 | Error : It works only on normal devices. If this error persists, please contact Customer Service. |
| com.stove.server | 49500 | blocked IP address |
| com.stove.server | 41002 | Invalid game id |
| com.stove.server | 44001 | Withdrawal request member |
| com.stove.server | 44002 | Withdrawal member |
| com.stove.server | 44008 | Already Stove Account Link. |
| com.stove.server | 44010 | Invalid refresh token |
| com.stove.server | 41001 | Invalid client id |
| com.stove.server | 44000 | Sleep member |
| com.stove.server | 44009 | Password has been changed. Please login again. |
| com.stove.server | 30302 | ServerError — 이용자가 단말기 시간을 임의로 변경해서 플레이하는 경우 발생 |
| com.stove.base.network | 10001 | NoConnectionError |
| com.stove.base.network | 10002 | TimeoutError |
3.0.0 부터 Unity · Unreal 은 게임 화면의 게스트 시작 버튼에서 바로 게스트로 시작할 수 있는 AuthUI.GuestStart 를 제공해요. SDK 약관 동의 화면을 띄우고, 이용자가 동의한 약관으로 게스트 가입과 로그인까지 한 번에 처리해요. 2.9.x 처럼 통합 로그인(AuthUI.Login) 화면에서 게스트로 시작하는 방식도 그대로 쓸 수 있어요.
=== "Unity"
AuthUI.GuestStart((Result result, AccessToken accessToken) =>
{
if (result.IsSuccessful)
{
/** Guest login successful → Perform post-login tasks such as character setup (setGameProfile) **/
}
else if (result.IsCanceled)
{
/** Terms agreement screen closed → Stay on start screen **/
}
else
{
OperationUI.HandleResult(result, (Result operationResult) => { });
}
});
=== "Unreal"
#include "AuthUI.h"
#include "OperationUI.h"
#include "AccessToken.h"
#include "Result.h"
AuthUI::GuestStart([] (Result result, AccessToken accessToken) {
if (result.IsSuccessful()) {
/** Guest login successful → Perform post-login tasks such as character setup (setGameProfile) **/
} else if (result.IsCanceled()) {
/** Terms agreement screen closed → Stay on start screen **/
} else {
OperationUI::HandleResult(result, [] (Result operationResult) { });
}
});
로그인 완료 이후 이용자의 캐릭터 및 월드 정보를 입력해요. 입력된 정보는 각 기능(쿠폰/팝업/빌링/푸시)에서 월드·캐릭터별로 구분해 사용돼요. 게임 프로필의 유효성은 SDK가 별도로 검사하지 않으므로 입력 시 null 체크를 꼭 해주세요.
!danger
캐릭터 설정 작업은 필수예요
캐릭터 설정 작업을 하지 않으면 스토브 백오피스를 통해 설정한 기능(쿠폰/팝업/빌링/푸시)을 정상적으로 사용할 수 없어요.
사전 준비:
- 스토브 IAP·쿠폰 서비스를 사용하려면 파트너스에 World 정보가 사전 등록되어 있어야 해요.
- 월드 미지원 게임이라도 default로 최소 1개 world 지정이 필요해요.
월드 지원 게임
=== "Unity"
private void SetGameProfile()
{
string CharacterNumber = "setYourCharacterNumber";
string WorldId = "setYourWorld";
AccessToken accessToken = Auth.AccessToken;
if(accessToken == null) { return; }
accessToken.User.GameProfile = new GameProfile(CharacterNumber, WorldId);
}
=== "Unreal"
#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);
}
=== "Android (Kotlin)"
private fun setGameProfile() {
val characterNumber = "setYourCharacterNumber"
val worldId = "setYourWorld"
// Please ensure to validate (null check) the characterNumber and world values.
Auth.accessToken?.user?.gameProfile = GameProfile(characterNumber, worldId)
}
=== "Android (Java)"
private void setGameProfile(@NotNull Context context) {
Long characterNumber = 111L; // setYourCharacterNumber
String world = ""; // setYourCharacterWorld
// Please ensure to validate (null check) the characterNumber and world values.
AccessToken accessToken = Auth.getAccessToken();
if (accessToken != null) {
User user = accessToken.getUser();
user.setGameProfile(context, new GameProfile(characterNumber, world));
}
}
=== "iOS"
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];
월드 미지원 게임
월드를 지원하지 않는 게임이라도 characterNumber만 설정하면 돼요. world 인자는 null로 전달해요. 단, 파트너스에는 default world가 1개 이상 등록되어 있어야 해요.
=== "Unity"
private void SetGameProfile()
{
string CharacterNumber = "setYourCharacterNumber";
AccessToken accessToken = Auth.AccessToken;
if (accessToken == null) { return; }
accessToken.User.GameProfile = new GameProfile(CharacterNumber);
}
=== "Unreal"
#include "Auth.h"
#include "AccessToken.h"
#include "GameProfile.h"
int64 chracternumber = "setYourCharacterNumber";
GameProfile gameProfile = GameProfile();
gameProfile.characterNumber = chracternumber;
AccessToken accessToken = Auth::GetAccessToken();
if (!accessToken.IsNull()) {
accessToken.user.SetGameProfile(gameProfile);
}
<br><br>
=== "Android (Kotlin)"
```kotlin
private fun setGameProfile() {
val characterNumber = "setYourCharacterNumber"
// characterNumber 값의 유효성 체크(null)를 꼭 해주세요.
Auth.accessToken?.user?.gameProfile = GameProfile(characterNumber, null)
}
=== "Android (Java)"
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));
}
}
=== "iOS"
NSString *characterNumber = @"setYourCharacterNumber";
SGSAccessToken *accessToken = [SGSAuth accessToken];
if(accessToken == nil) { return; }
SGSGameProfile *gameProfile = [[SGSGameProfile alloc] initWithCharacterNumber:characterNumber world:nil];
[[accessToken user] setGameProfile:gameProfile];
SDK Token Management
The SDK automatically renews the AccessToken when it reaches 80% of its expiration time.
Since automatic renewal only works while the process is running, you must always query and use the AccessToken.
=== "Unity"
public void GetToken()
{
string token = Auth.AccessToken.Token;
}
=== "Unreal"
#include "Auth.h"
#include "AccessToken.h"
AccessToken accessToken = Auth::GetAccessToken();
if (!accessToken.IsNull()) {
FString token = accessToken.token;
}
=== "Android (Kotlin)"
fun getAccessToken() {
val token : String? = Auth.accessToken?.token
}
=== "Android (Java)"
public void getAccessToken() {
AccessToken accessToken = Auth.getAccessToken();
}
=== "iOS"
NSString *token = [[SGSAuth accessToken] token];
Implementing GPG Login
This is used when implementing a 1:1 account linkage between a PGS ID and a STOVE account for games preparing for the Google Play Games Service (GPG) launch. The SDK provides three APIs: Fetch (query linked account) / Load (load) / Link (link account).
!info
PGS ID ↔ STOVE Account 1:1 Policy
After the initial linkage, if you log in with a different STOVE account, it will overwrite the existing account information.
If a STOVE account change occurs, such as upgrading to a full member, you must call the GPG linkage again.
Prerequisites
API Console / Partners Tasks
- Console Permission Request: Send the package name (Android) for each service environment to the publishing technical representative to request Google
Allowlist(takes 1–2 days) - Private Key Generation: Issued from the Google Cloud Console. 생성 매뉴얼 PDF
- STOVE Partners Registration:
[파트너스] > [퍼블리싱 센터] > [게임 입점 관리] > [모바일 마켓 정보 관리] > [플레이스토어 마켓 앱] > [Private Key File 업로드]
SDK Module Application
play-services-games-v2Library: A module officially released as of 2023/09/18. Manual EAP application is no longer required. Google 공식 다운로드AUTH-GooglePlayGamesModule: STOVE SDK GPG linkage module. latest live version Required for use
Project ID Settings (Android)
- Google Play Console Select your app in
Play 게임서비스 > 설정 및 관리 > 설정Check the project ID in- Apply to the files below
=== "build.gradle"
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'
}
=== "strings.xml"
<?xml version="1.0" encoding="utf-8"?>
<resources>
<string name="google_play_games_project_id" translatable="false">{your_project_id}</string>
</resources>
=== "AndroidManifest.xml"
<manifest>
<application>
<meta-data
android:name="com.google.android.gms.games.APP_ID"
android:value="@string/google_play_games_project_id"/>
</application>
</manifest>
Project ID Settings (Unity / Unreal)
- Unity:
Stove > Edit Settings→Use Auth-GooglePlayGamesCheck →ProjectidEnter google_playgames_projectid in - Unreal:
프로젝트 셋팅 > Android > GooglePlayServices > 게임 앱 IDEnter
Development Flow
- PGS SignIn and obtain recallSessionID (CP implementation area): After processing Google Play Games v2 SignIn, obtain the
recallSessionID, which is the unique PGS identifier. Refer to Google 공식 가이드 for how to obtain it for each language. - SDK Initialization + Provider Settings: Call
Auth.initialize,AuthUI.setProvidersin the same way as the existing integrated login flow. - Automatic Login Branching:
Auth.AccessTokenExists → Proceed with existing automatic login flow (no separate GPG processing required)Auth.AccessTokenDoes not exist → Query the STOVE account linked viaGPGProvider(recallSessionID).fetch()
- Query Result Branching:
- No linked account → Enter guest start or integrated login screen
- Linked account exists + Game direct UI → Create
GPGProvider(recallSessionID, account)→Auth.Login(provider) - Linked account exists + SDK provided UI →
GPGProvider.load()→Auth.login(loadedProvider)
- Account Linkage (Link): After login is complete, at an appropriate time (e.g., entering the lobby, returning to account settings), link the PGS ID and STOVE account with
AccessToken.User.Link(GPGProvider). Must be called again when upgrading to a full member.
Full Linkage Sequence
This is a diagram representing the entire flow of PGS SignIn → obtaining recallSessionID → querying linked account, logging in, and linking.
!info
※1 Linkage follows a 1:1 policy, and the list of linked accounts is at most 1.
※2 Only applicable if the user configures the optimized UI directly in the game.```mermaid
sequenceDiagram
autonumber
participant Z as User
participant A as Game
participant B as Stove SDK
participant C as Stove Server
participant D as Google
Z ->> A: 게임 실행
A ->> A: recallSessionID 획득
A ->> A: SDK 초기화
A ->> A: AuthUI.setProviders(providers)
alt IF AccessToken 있음
A ->> B: AuthUI.login()
B ->> C: 자동로그인
C -->> B: 로그인 결과
B -->> A: AccessToken
A ->> Z: TOUCH TO START — 로그인 완료
else ELSE AccessToken 없음
A ->> A: GPGProvider(recallSessionID) 생성
A ->> B: GPGProvider.fetch()
B ->> C: 연결된 계정 조회(recallSessionID)
C ->> D: Recall API
D -->> C: 저장된 계정 목록
C -->> B: 연결된 계정 목록
B -->> A: 연결된 계정 목록
alt 연결 계정 없음
A ->> Z: 게스트 시작 / 통합 로그인 화면 (수동 로그인)
else 연결 계정 있음 + 게임 직접 UI (※2)
A ->> A: 캐릭터 상세정보 취합 후 선택 화면 노출
alt 사용자가 연결 계정으로 로그인 선택
A ->> A: GPGProvider(recallSessionID, account) 생성
A ->> B: Auth.Login(GPGProvider)
B ->> C: 로그인(UserInfo)
C -->> B: 로그인 결과
B -->> A: AccessToken
A ->> Z: TOUCH TO START — 로그인 완료
else 취소
Z ->> A: 취소 선택
A ->> Z: 게스트 시작 / 통합 로그인 화면
end
else 연결 계정 있음 + SDK 제공 UI
A ->> A: GPGProvider(recallSessionID) 생성
A ->> B: GPGProvider.load()
B -->> Z: 선택 화면 노출
alt 불러오기 선택
Z ->> B: 불러오기 선택
B -->> A: loadedProvider
A ->> B: Auth.login(loadedProvider)
B ->> C: 로그인(UserInfo)
C -->> B: 로그인 결과
B -->> A: AccessToken
A ->> Z: TOUCH TO START — 로그인 완료
else 새로 시작하기
Z ->> A: 취소 선택
A ->> Z: 게스트 시작 / 통합 로그인 화면
end
end
end
<br>**Fetch — Retrieve Linked Accounts**`recallSessionID`Retrieves the list of STOVE accounts linked to the corresponding PGS ID from the STOVE server.<br>=== "Unity" ```csharp
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 : 계정 목록
}
});
Load — Load linked accounts
Fetch Prepare the Provider so that after the user selects an account from the account information received as a result via the SDK-provided UI, they can automatically log in with that account. Pass the returned loadedProvider to the Auth.login.
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) =>
{
// 게스트 자동 로그인 불가 케이스
//2.9.x 이하 : 실제 에러 코드가 ErrorCode 로 내려온다
if (loginResult.ErrorCode == 44008 || loginResult.ErrorCode == 45006) {
Auth.Logout();
}
//3.0.0 이상 : 매시업 래핑 에러(60000대)는 실제 에러 코드가 origin_code 로 내려온다
if (loginResult.UserInfo != null && loginResult.UserInfo.TryGetValue("origin_code", out string originCode))
{
if (originCode == "44008" || originCode == "45006")
{
Auth.Logout();
}
}
});
}
});
}
});
}
Link — Link account
After login is complete, link the PGS ID with the current Stove account at an appropriate time. If a conversion to a full member occurs, you must call it again to maintain the link.
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 연결 성공
}
});
}
Troubleshooting
| Situation | Cause | Solution |
|---|---|---|
| GPG connection is disconnected after converting to a full member | The PGS ID ↔ STOVE account relationship follows a 1:1 policy. When a STOVE account is converted to a full member, the existing PGS connection must also be updated to function correctly. | Immediately after the full member conversion is complete, AccessToken.User.Link(GPGProvider(recallSessionID)) call it again. |
Google Console API Settings
This is how to register IAP (In-App Purchase) information for apps released on Google Play to STOVE Partners Billing. Since IAP authentication for STOVE SDK V2 uses Google's OAuth client method, Google Android Publisher API connection is required.
Perform Google Play Console tasks using the Owner (Master) account.
If you proceed with an account that has different permissions, some menus may be blocked, causing the task to stop.
The workflow consists of the following 4 steps.
- Connect Google Play Console API access permissions
- Create a Google Cloud project and configure API/OAuth
- Obtain a Refresh Token from OAuth 2.0 Playground
- Enter issuance information into STOVE Partners Billing settings
1. Obtain Google Play Console API access permissions
Connect to the Google Android Publisher API to verify apps registered on Google Play and IAP payments.


If the connected project status does not appear on the screen, check the connection with Google Cloud first. If the problem persists after configuration, refer to the official Google guide.
2. Create a Google Cloud project
Only proceed in the project connected to the actual service app (Service Project).
If you work in a test project, live billing verification will not work.
2-1) Create project
- Google Cloud ConsoleAccess. The login account must be the Google Play Console developer account owner.
IAM 및 관리자>프로젝트 만들기Select.- Enter the project name and location to create the project.


2-2) Add API to use in project (Play Android Developer API)
- After selecting the created project, go to
API 및 서비스>라이브러리Go to. - Search for and select
Play Android Developer API, and set it to사용in the product details.

It must be enabled in the same project connected to the Play Console's API 액세스.
For IAP verification, Google Play Android Developer API must be enabled.


2-3) Configure OAuth consent screen and create OAuth client ID
- Select the project to link in the
API 및 서비스dashboard. - In the
사용자 인증 정보menu, select사용자 인증 정보 만들기>OAuth 클라이언트 ID.



You can also check the values on the OAuth client information screen or in the downloaded client JSON.

For detailed OAuth setup instructions, please refer to the Google OAuth2 Guide.
3. Generate Refresh Token (OAuth 2.0 Playground)
- Go to Google OAuth 2.0 Playground.
- Click the gear icon in the top right corner of the screen to open the
OAuth 2.0 Configurationpanel, and check theUse your own OAuth credentialscheckbox. - Enter the
OAuth Client IDandOAuth Client Secretissued in the previous step, respectively. - Select
Step 1in theGoogle Play Android Developer APIarea on the left, or enterhttps://www.googleapis.com/auth/androidpublisherdirectly into the scope input field at the bottom. - Click the
Authorize APIsbutton in the bottom left.

- After authentication is complete, when the screen switches to
Step 2, click theExchange authorization code for tokensbutton. You can check theRefresh tokenvalue in the response area.

4. Enter Information in Stove Partners Billing Settings
Enter the following 3 values issued in the steps above into Manage IAP Information by Market in Stove Partners.
OAuth Client IDOAuth Client SecretRefresh Token
FAQ
- Developers Center Usage / Smilegate Publishing Games: stove.developers@smilegate.com
- STOVE Store Onboarding / STOVE Studio: store.support@smilegate.com