Skip to content
Stove
Last Updated

This guide covers the basic integration flow from SDK initialization to termination.

Basic SDK Integration

Mobile SDK


This guide covers the basic flow for integrating the STOVE platform in a mobile environment (STOVE Mobile SDK).

This page covers only the 5 core steps of the boot flow.
ㆍ Auth.initialize → AuthUI.setProviders → AuthUI.login → User.setGameProfile → Auth.AccessToken Proceed in order.
ㆍ Additional features such as push notifications, coupons, pop-ups, deep links, and Vietnam regulations are covered separately in 기능별 가이드.

Overview

  • The STOVE platform provides integrated services that simplify game launches.
  • By integrating the STOVE Mobile SDK (hereinafter referred to as Mobile SDK) into your game, you can easily incorporate authentication, operations, and payment features.
  • The Mobile SDK can be used in four build environments: Android (Kotlin/Java), iOS, Unity, and Unreal.
  • The Auth/AuthUI module handles integrated login and automatically processes device registration, identity verification, terms of service agreement, and push registration with a single AuthUI.login call.
  • Detailed options for the entire authentication and account management flow (direct login, account conversion, manual identity verification calls, etc.) are covered in 로그인 가이드.

Prerequisites

Before proceeding with this guide, the following items must be prepared.

Item Description Note
Partners Mobile Market Information Package name/Bundle ID used as an identifier during SDK initialization. Must be pre-registered in Partners. Publishing Center > Game Entry Management
Provider Authentication Channels Authentication channels that the game will support (STOVE, Google, Apple, Facebook, etc.).
The registration order in Partners AuthUI.setProviders matches the input order.
Integration guide for each Provider
SDK Version Apply STOVE Mobile SDK 2.x or higher Environment Setup Guide
Build Environment Setup SDK dependency, manifest, and Info.plist settings for each environment: Android (Gradle)/iOS (Xcode)/Unity/Unreal Platform-specific environment guide

Integration Flow

The Mobile SDK boot flow consists of 4 core calls and an automatic processing area.


  • Game Start Sequence
    • When the app launches, initialize the SDK with Auth.initialize. At this stage, app updates and game maintenance checks are also performed.
    • Register the authentication channels the game will support with AuthUI.setProviders. The order becomes the order in which the login screen is displayed.
    • Call AuthUI.login to display the integrated login screen and receive an AccessToken.
    • After login is complete, pass character and world information to the SDK with User.setGameProfile.

  • Flow Automatically Processed within AuthUI.login
    • With a single integrated login call, new device registration, mandatory identity verification, terms of service agreement, and push registration are processed together.
    • The game does not need to call these items directly. Separate calls are only required when displaying them again in in-game settings.

  • During Gameplay
    • Once character settings are finished, enter the main game screen.
    • Since the SDK automatically refreshes the AccessToken at 80% of its expiration time, do not cache the token; instead, query it every time with Auth.AccessToken to use it.

Integration Details

This guide provides the 5 core steps of the Mobile SDK boot flow with step-by-step scenarios and code examples.


1. SDK Initialization (Auth.initialize)

This is the step to acquire the initial information required to use the service. Initialization must be completed before subsequent login, payment, and operation features can be used.

  • Call Conditions
    • Call once when the app starts.
    • Must be called before any other Mobile SDK API.

  • How it works
    • Retrieves service settings registered in Partners (service_id, market_game_id).
    • Checks whether an app update is required (AppUpdateError 30004) and whether the game is under maintenance (MaintenanceError 30003).
    • If you pass the received Result to OperationUI.handleResult as is, the maintenance/app update notice UI will be displayed automatically. (No manual processing required)

  • Sequence Diagram


App updates and game maintenance are handled automatically by the SDK
ㆍ You do not need to analyze the Auth.initialize results yourself to create a notice screen.
ㆍ If you pass the received Result to OperationUI.handleResult as is, the maintenance (30003) and app update (30004) UI will be displayed automatically.
ㆍ Continue the next step (login) flow within the callback.



2. Setting Authentication Channels (AuthUI.setProviders)

AuthUI.loginRegister the authentication channels (Providers) that the game will support before calling this. The order of the array passed determines the display order on the login screen.

  • Prerequisites
    • Execute after Auth.initialize is complete and before calling AuthUI.login.
    • Registration is only required once per game.

  • How it works
    • Passes the list of Providers supported by the game to the SDK.
    • Only channels pre-registered in Partners will function correctly. Adding unregistered channels will not authenticate during login.
    • The Email Provider is displayed by default without needing separate addition. (Email Provider is mandatory for Login Screen Type B)


Must be executed before calling AuthUI.login.
ㆍ If you call AuthUI.login while Providers are empty, the user will not be able to select an authentication channel.
ㆍ The order in which you add them is the order they appear on the screen, so arrange them according to your marketing priorities.



3. Integrated Login (AuthUI.login)

This step handles everything at once, from displaying the login screen to issuing an AccessToken, device registration, identity verification, terms agreement, and push registration.

  • Prerequisites
    • Call after both Auth.initialize and AuthUI.setProviders are complete.
    • If an existing AccessToken exists, it will be processed as an auto-login; otherwise, the login screen will be displayed to the user.

  • How it works
    • Displays the integrated login UI and performs authentication using the Provider selected by the user.
    • After authentication is complete, it issues/refreshes the AccessToken and passes user information via a callback.
    • The items in the table below are all processed in a single call.

  • Flows automatically handled within AuthUI.login
Feature Automatic Display Timing Cases Requiring Separate Calls
Device Registration/Management Automatically displayed when a new device needs to be registered When manually displaying the device management UI from in-game settings
Identity Verification Automatically displayed when verification is required by law/policy When forcing re-verification before entering payment/sensitive features
Terms Agreement Automatically displayed when a user who has not agreed enters —
Push Registration Automatically processed upon completion of login, token refresh, or account linking —

  • Sequence Diagram


Items processed automatically do not need to be called separately
ㆍ Device registration, identity verification, terms, and push registration are handled automatically in one AuthUI.login call.
ㆍ Only call them when you need to display them again from in-game settings.로그인 가이드Please refer to the individual call section for each to call them directly.

4. Character/World Settings (User.setGameProfile)

After login is complete, pass the user's character and world information to the SDK. The entered information is used by each feature (coupon/popup/billing/push) to distinguish between worlds and characters.

  • Call Conditions
    • AuthUI.loginCall this after success, right before entering the game's main page.
    • Call it again when the user changes characters or connects to a different world.

  • Operation Method
    • characterNumberand worldIdas a GameProfile object and set it in AccessToken.user.
    • For games that do not support worlds, you can pass worldIdas null. However, at least one default world must be registered in Partners.
    • The SDK does not check the validity of the values (whether they are null), so please perform null checks on the game side.


Character settings are mandatory
ㆍ If character settings are not configured, features based on worlds/characters set in Partners (coupons/popups/billing/push) will not function correctly.
ㆍ Even for games that do not support worlds, you must register at least one default world in Partners, and then call it by passing worldIdas null.



5. Using AccessToken (Auth.AccessToken)

This is the step to retrieve the token used by the game to call SDK features after character settings are configured.

  • Call Condition
    • Call it whenever an AccessToken is required while the game is running.
    • Do not cache the token value as a variable within the game; fetch it anew each time it is needed.

  • Operating Principle
    • The SDK automatically refreshes the AccessToken when it reaches 80% of its expiration time.
    • Since automatic refresh only works while the process is running, you must always use Auth.AccessToken to receive the latest value.
    • If the AccessToken is null, it means the user is logged out, so please redirect them to the login flow.


Always fetch tokens anew before use
ㆍ Since the SDK automatically refreshes at the 80% expiration mark, continuing to use a cached token may cause you to miss the refreshed token.
ㆍ If the AccessToken is null, it means the user is logged out. AuthUI.login again to redirect the user to the re-login flow.

PC SDK


This guide explains the basic flow for integrating the Stove platform in a PC environment (PCSDK3).

  • The Stove platform provides integrated services that simplify game launches.
  • By integrating the STOVE PC SDK (hereinafter PC SDK) into your game, you can easily incorporate Stove platform services.
  • The STOVE PC Base SDK (hereinafter Base SDK) is a required module that provides the fundamental functions of Stove platform services.

The Base SDK is a prerequisite for all PC SDK features.
ㆍ The Base SDK is a module that must be integrated to use Stove platform services.
ㆍ Other PC SDK modules will not function if the Base SDK is not initialized.
ㆍ The Base SDK is applied via client integration.

Prerequisites

Please complete the 개발 환경 설정 process before proceeding with this guide. You must finish the Getting Started process to ensure the following flow proceeds without issues.

Fullscreen Mode Restrictions
ㆍ If you are using the View SDK (pop-up) or IAP SDK (purchase window) modules, there are restrictions regarding the game's Fullscreen mode.
ㆍ For more details, please refer to the integration overview for each module.
ㆍ These restrictions do not apply if you are not using the View SDK or IAP SDK.

Integration Flow

The Base SDK integration flow is as follows.


  • Game Start Sequence
    • Verify that the game was launched from the launcher when the game starts.
    • Initialize the Base SDK when the game starts.
    • Configure an API callback execution loop so that whenever PC SDK APIs are executed, any callbacks loaded in the callback queue are executed at each cycle.

  • Implement selectively according to the game after configuring the API callback execution loop
    • Set the language to be used in the PC SDK.
    • Character/World settings (Register the currently connected worldId and characterNumber with the PC SDK.)
    • Integrate over-immersion prevention features.
    • Integrate game time selection features.

  • Features that can be used selectively while the game is running
    • Obtain the current user's Game Access token.
    • Obtain current user information.
    • Obtain the current user's GDS information.
    • Obtain the current user's Signin information.
    • Register a Game Access token refresh notification callback. (The token is automatically refreshed within the SDK, and the registered callback is called at the time of refresh.)

  • Game Exit Sequence
    • When the user exits the game, ensure the Base SDK is cleaned up before the game finally terminates.

Integration Details

We provide the general scenario for integrating the Base SDK using sequence diagrams and code examples.


1. Launcher execution verification and Base SDK initialization

If the game is an official release version, first verify that the game was launched from the launcher, then immediately initialize the Base SDK. Verification and initialization are bundled into a single call flow.

This is a mandatory function that must be executed.
ㆍ If you do not call Base_RestartAppIfNecessaryAsync, you will not receive the essential information (service settings, authentication context, etc.) required to run the game from the launcher, and subsequent SDK APIs will not function properly.
ㆍ The initialization parameters passed during the call are cached within the SDK and become the input values for Base_InitializeEx, so please ensure verification and initialization are connected in a single flow.


  • Call Condition
    • In the official release version, you must verify that the game was launched via the launcher for it to run normally.
    • Base SDK initialization must take precedence over other PC SDK module initializations.
    • Both APIs must be called from the UI Thread.
    • Must be called after the game starts and before using other Base SDK features.
    • Should only run once when the game is executed. Do not repeat Init / UnInit during execution.

  • Operating Principle
    1. Launcher Verification: Base_RestartAppIfNecessaryAsync processes verification asynchronously. The result is passed to the restartAppIfNecessary argument of the callback.
      • If restartAppIfNecessary is true, it means the game was relaunched via the launcher, so the current game instance should be terminated.
      • The timeout (in milliseconds) to wait for the launcher response is passed to the Base_RestartAppIfNecessaryAsync argument of waitTimeMillisec. Generally, 60,000 (60 seconds) is used.
    2. Parameter Cache: The initParam passed during the verification call is cached within the SDK.
    3. Base SDK Initialization: Call restartAppIfNecessary == false in the Base_InitializeEx branch of the verification callback to initialize with the cached parameters. There is no need to pass separate parameters again.
      • If using other modules such as View or IAP, call the initialization function for each module (e.g., View_Initialize, IAP_Initialize) separately after Base SDK initialization. Other modules like PCBang also follow their own initialization flows.

Be careful with the lifespan of the initParam referenced in the callback.
ㆍ The initParam must be alive at the time the asynchronous callback is called. For Native/Unreal, declare it as a static or member variable; for Unity, declare it as a class member variable.

Base_InitializeEx will fail if there are no pre-cached parameters.
ㆍ Base_InitializeEx must be used only after calling Base_RestartAppIfNecessaryAsync first.


  • Sequence Diagram

  • Code Example

Functions in the example that do not start with Base_ are virtual functions not provided by the SDK.

GameLoop() · ProcessGameLogic() · Render() Functions corresponding to the game loop, such as , are named only for the purpose of explaining the example. The actual implementation must be written by the developer to suit the game. Functions provided by PCSDK3 start with a module prefix (Base_ · IAP_ · View_ etc.).

cpp
#include "BaseSDK.h"

using namespace Stove::PCSDK;
using namespace Stove::PCSDK::Base;

void Base_RestartAppIfNecessaryAsync_Example()
{
    // 콜백에서 참조하므로 static으로 선언
    static StovePCInitializeParam initParam;
    initParam.SetEnvironment(L"YOUR_ENV(ex.SANDBOX)");
    initParam.SetGameID(L"YOUR_GAME_ID");
    initParam.SetApplicationKey(L"YOUR_APP_KEY");

    // Base_RestartAppIfNecessaryAsync 호출 (타임아웃 60초)
    Base_RestartAppIfNecessaryAsync(&initParam, 60'000, [](
        CallbackResult callbackResult, bool restartAppIfNecessary)
    {
        if (restartAppIfNecessary)
        {
            // 런처를 통해 재실행되었으므로 현재 인스턴스는 종료
            return;
        }

        // 검증 통과 → 캐시된 파라미터로 Base SDK 초기화 (Base_InitializeEx)
        Base_InitializeEx([](CallbackResult initResult)
        {
            if (initResult.GetResult().IsSuccessful())
            {
                // Base SDK 초기화 성공 시 로직을 구현해 주세요.
                // ex) 이곳에서 다른 SDK 모듈의 Initialize를 진행할 수 있어요.
            }
            else
            {
                // Base SDK 초기화 실패 시 로직을 구현해 주세요.
            }
        });
    });
}



2. Execute API Callbacks

This step executes callbacks registered to the PC SDK's asynchronous APIs. Registered callbacks are added to a callback queue and are executed all at once when this API is called.

  • Callbacks registered to PC SDK modules other than the Base SDK (View, IAP, PCBang, etc.) are also executed here.
  • If not called periodically in the game's main loop, some PC SDK APIs may not function correctly.
  • This API must be called from the UI Thread.

  • Comparison of the two options
API Operation When to use
Base_RunCallback() Executes all callbacks in the queue at once General game loops where callback processing time does not significantly impact the frame rate
Base_RunCallbackWithTimeout(ms) Executes only up to the specified timeout (in milliseconds) and processes the rest in the next call Frame-sensitive games like action or MMO games where callback execution time could cause frame drops

Callback Execution Thread Guide
ㆍ All SDK callbacks are executed on the calling thread at the time of Base_RunCallback() / Base_RunCallbackWithTimeout() call.
ㆍ If called from the game's main loop, callbacks are safely executed on the main thread.

Caution when using variables in callbacks
ㆍ If you capture local variables by reference (&) in an asynchronous API callback (lambda), the variables may have already been destroyed by the time the callback is executed.
ㆍ Please declare variables used in callbacks as [&] or as class member variables.

static or as class member variables.


  • Sequence Diagram

  • Code Example
cpp
#include "BaseSDK.h"

using namespace Stove::PCSDK;
using namespace Stove::PCSDK::Base;

void GameLoop()
{
    while (gameRunning)
    {
        ProcessGameLogic();

        // 옵션 A: 큐에 쌓인 모든 콜백 한 번에 실행
        Base_RunCallback();

        // 옵션 B: 콜백 실행 시간을 최대 10ms로 제한
        // 시간을 초과하면 남은 콜백은 다음 호출 시 이어서 실행
        // Base_RunCallbackWithTimeout(10);

        Render();
    }
}



3. Access Token Retrieval and Renewal Notification Registration

The Access token used for STOVE platform authentication is automatically renewed within the PCSDK 10 minutes before expiration. In game code, you can handle tokens using two APIs.


  • Comparison of the two APIs
API Purpose When to use
Base_GetAccessToken Currently valid Access token immediate retrieval Call whenever you need to pass the token externally, such as for game server authentication or calling STOVE REST APIs. It always returns the latest value.
Base_AccessTokenRenewed At the moment of automatic renewal register notification callback Register a callback when post-processing is required, such as synchronizing with the game server or invalidating caches immediately after the token is automatically renewed within the SDK. You only need to register it once during game execution.

Do not cache tokens in game variables.
ㆍ Since tokens are automatically renewed 10 minutes before expiration, you must always retrieve and use the latest value using Base_GetAccessToken whenever an external call is required.
ㆍ No API is provided to force a renewal. If post-processing is required after renewal, register a callback using Base_AccessTokenRenewed.

Base_AccessTokenRenewed should be called only once.
ㆍ Since this API is for callback registration, you only need to call it once during game execution.
ㆍ The best place to call it is immediately after Base_InitializeEx succeeds, when other PCSDK initialization is complete.


  • Sequence Diagram

  • Code Example
cpp
#include "BaseSDK.h"

using namespace Stove::PCSDK;
using namespace Stove::PCSDK::Base;

// (1) 갱신 알림 콜백 등록 - 초기화 직후 1회 호출
void Base_AccessTokenRenewed_Example()
{
    Base_AccessTokenRenewed(
        [](CallbackResult callbackResult, StovePCToken token)
        {
            if(callbackResult.GetResult().IsSuccessful())
            {
                // Access token 자동 갱신 후 후속 처리를 구현해 주세요.
                const wchar_t* renewed = token.GetAccessToken();
            }
            else
            {
                // 갱신 실패 시 로직을 구현해 주세요.
            }
        }
    );
}

// (2) 현재 Access token 즉시 조회 - 외부 호출 직전마다 호출
void Base_GetAccessToken_Example()
{
    // 토큰을 받을 버퍼를 충분한 크기로 준비해 주세요.
    wchar_t accessToken[4096] = { 0 };
    auto result = Base_GetAccessToken(accessToken, 4096);
    if(result.IsSuccessful())
    {
        // accessToken 버퍼에 항상 최신 토큰이 채워져요. 외부 서버 호출 등에 사용해 주세요.
    }
    else
    {
        // 조회 실패 시 로직을 구현해 주세요.
    }
}



4. Retrieving User, Country, and Authentication Information

Information about the user currently logged in via the Stove Launcher is provided through three separate APIs. Choose the appropriate API for your needs, such as for game screens, policy branching, or determining payment eligibility.

API Return Structure Target
Base_GetUser StovePCUser Basic Stove user information (nickname, game user ID)
Base_GetGds StovePCGds Connected country, regulations, time zone, and language (Geo-based Distribution Service)
Base_GetSignin StovePCSignin Login authentication information (identity verification, email verification, registration country, IDP)

All three APIs can be called after the Base SDK initialization is complete.
ㆍ You can call them freely whenever user context is needed. Since the return values are cached by the SDK, the call cost is low.


4-1. Base_GetUser — Basic User Information

StovePCUser provides the following information:

Field Type Description
nickname string The Stove nickname of the user logged in via the Stove Launcher. Use this for in-game UI display names, chat, customer inquiries, etc.
gameUserId uint64 The game user identifier issued by the Stove platform. Use this as a key value for identifying Stove accounts on your game server, or for payments and log tracking.

4-2. Base_GetGds — Connected Country, Regulations, and Locale

GDS (Geo-based Distribution Service) is information about country, regulation, and locale based on the user's connection IP. It is used for regional policy branching such as Vietnam regulations, shutdown, and terms of service display language.Regional policy branchingis used for.

StovePCGdsInformation provided by :

Field Type Description
isDefault bool Returns the STOVE default value if the country code cannot be identified by IP, which is true. Returns false if identified by IP.
nation string Connection country code (ISO 3166-1 alpha-2). E.g., KR, VN, US.
regulation string The regulation name applied to the connection country code. (e.g., Vietnam age rating display / Korea shutdown policy, etc.)
timeZone string Connection time zone information. Used for displaying maintenance/event times, etc.
utcOffset int UTC offset of the connection time zone (in minutes).
language string Connection language code.

4-3. Base_GetSignin — Login Authentication Information

Queries the STOVE platform authentication context where the game is currently running. You can check whether identity verification or email verification has been completed, the country of registration, and the IDP (Identity Provider) used.

StovePCSigninInformation provided by :

Field Type Description
personVerify bool Whether identity verification has been completed.
emailVerify bool Whether email verification has been completed.
nationality string STOVE platform registration country code (ISO 3166-1 alpha-2).
providerCode string IDP classification code used for STOVE login. Use this field on PC.
SO STOVE Email / FB Facebook / NAVER Naver / GP Google / APPLE Apple / LINE LINE / STEAM Steam / QR QR Login / RT PC client-based auto-login, etc.

Please use providerCode on PC.
ㆍ accountType defined together in the Signin information is a mobile legacy specification and is not used on PC.


  • Sequence Diagram

  • Code Example
cpp
#include "BaseSDK.h"

using namespace Stove::PCSDK;
using namespace Stove::PCSDK::Base;

// (1) 사용자 기본 정보 조회
void Base_GetUser_Example()
{
    StovePCUser user;
    auto result = Base_GetUser(&user);
    if(result.IsSuccessful())
    {
        const wchar_t* nickname = user.GetNickname();
        uint64_t gameUserId = user.GetGameUserId();
    }
}

// (2) 접속 국가·규제·로케일 조회
void Base_GetGds_Example()
{
    StovePCGds gds;
    auto result = Base_GetGds(&gds);
    if(result.IsSuccessful())
    {
        const wchar_t* nation = gds.GetNation();
        bool isDefault = gds.IsDefault();
        const wchar_t* regulation = gds.GetRegulation();
        const wchar_t* language = gds.GetLanguage();
        const wchar_t* timeZone = gds.GetTimeZone();
    }
}

// (3) 로그인 인증 정보 조회
void Base_GetSignin_Example()
{
    StovePCSignin signin;
    auto result = Base_GetSignin(&signin);
    if(result.IsSuccessful())
    {
        const wchar_t* providerCode = signin.GetProviderCode();
        bool personVerify = signin.GetPersonVerify();
        bool emailVerify = signin.GetEmailVerify();
        const wchar_t* nationality = signin.GetNationality();
    }
}



5. Character/World Settings

Base_SetGameProfile Register the World Identifier (worldId) and Character Identifier (characterNumber) currently connected to the game with the PC SDK via the API. The registered identifiers are used as key values for payment and operation functions to distinguish user context.

Field Type Description
worldId string The identifier of the world (server) the user is connected to. For games that do not support worlds, register one default world in Partners and use that identifier.
characterNumber long The identifier of the character selected by the user. Please update this whenever the character is changed or the user reconnects to a different world.

This is directly linked to billing (payment) processing.
ㆍ STOVE In-App Purchase (IAP) processes receipts, item delivery, and refunds based on the worldId + characterNumber at the time of payment.
ㆍ If you call functions such as IAP_StartPurchase while the character/world is not set, payments may fail, or even if successful, the recipient may be identified incorrectly.
ㆍ If you are using user context-based modules such as payments or coupons, please be sure to call this right before entering the main screen (at the point when character selection is complete).


  • Calling conditions and precautions
    • If you do not set the character/world, some PC SDK modules such as IAP and coupons may not function properly.
    • Since the SDK does not separately validate input values, please check for null and empty strings on the game side before calling.
    • The entered character/world information is valid for the duration of the PC SDK lifecycle. Base_UnInitialize If you re-initialize after Base_SetGameProfile, you must call it again.
    • If the context changes due to a user changing characters or moving worlds, please re-call it immediately to update the identifier.

  • Sequence Diagram

  • Code Example
cpp
#include "BaseSDK.h"

using namespace Stove::PCSDK;
using namespace Stove::PCSDK::Base;

// 함수 네이밍은 예시이므로 게임 구현에 맞게 변경하세요.
void Base_SetGameProfile_Example()
{
    // StovePCGameProfile 구조체 생성
    // 구조체 필드에 적절한 worldId, characterNumber 값을 할당하세요.
    auto gameProfile = StovePCGameProfile(L"YOUR_WORLD_ID", 0L);

    // 생성한 구조체를 이용해 Base_SetGameProfile 호출
    auto result = Base_SetGameProfile(&gameProfile);
    if(result.IsSuccessful())
    {
        // 캐릭터·월드 설정 성공 시 로직을 구현해 주세요.
    }
    else
    {
        // 캐릭터·월드 설정 실패 시 로직을 구현해 주세요.
    }
}



6. Base SDK Cleanup

Base_UnInitialize Call the API to clean up the Base SDK and return resources in use. You must perform the Base SDK cleanup logic before the game terminates.

  • Calling conditions
    • Base SDK cleanup must be performed last, after other PC SDK cleanups. If you clean up the Base SDK before other PC SDKs, the cleanup may not be performed correctly.
    • You cannot use Base SDK features after cleaning up the Base SDK.
    • Base SDK cleanup must be called on the UI Thread.
    • It should only run once when the game terminates.

  • Sequence Diagram

  • Code Example
cpp
#include "BaseSDK.h"

using namespace Stove::PCSDK;
using namespace Stove::PCSDK::Base;

void Base_UnInitialize_Example()
{
    // 다른 SDK를 사용했다면 Base_UnInitialize()가 마지막으로 호출되어야 해요.
    // ex) 정리 순서
    // PCBang_UserLogOut();
    // PCBang_UnInitialize();
    // View_UnInitialize();
    // IAP_UnInitialize();
    // Base_UnInitialize();
    auto result = Base_UnInitialize();
    if(result.IsSuccessful())
    {
        // Base SDK 정리 성공 시 로직을 구현해 주세요.
    }
    else
    {
        // Base SDK 정리 실패 시 로직을 구현해 주세요.
    }
}



Do you have any inquiries?