PC SDK Native Reference

Based on SDK version 3.5.0. 100 items combined in alphabetical order.

Contents

Basic Integration Guide

Kind Integration Guide · Module Base · Version 3.5.0

Description

The Stove PCSDK Native API provides two main types of declarations: C++ methods and C flat functions. You can choose the one that best suits your environment and needs.

• In a typical C/C++ development environment, you can easily use the C++ method syntax.
• The C flat function can be used in environments where C++ syntax is not supported (e.g., Go, JavaScript-based game engine plugin development, etc.).

All SDK objects are represented by IStove* opaque pointers, and properties are accessed through accessor functions of the Stove_<Interface>_<Method>(self, ...) type.

Header files are provided in four different formats, one for each module, depending on the single binary (BaseSDK) integration.

Declaration Forms

This document is organized and presented in the following formats depending on the subject matter.

• C++ Method: This is a member function defined in the IStove* interface structure within *_types.h. Since most compilers support C++, you can use this form as-is to call it directly, as shown in self->Method().
• C flat function: This is an entry point exposed from *_api.h / *_flat_api.h to extern "C" + __cdecl. It is provided for environments where C++ vtable calls are not possible, such as pure C or C#, but it can also be called in a C++ environment.
• Both forms perform the same action. The C flat function internally calls the C++ method of the corresponding object.

The ## Example section in each function's documentation lists both forms side by side under the C · C++ tabs. Since calling the same API using either form yields the same result, you only need to refer to the tab that matches your project environment.

The SDK API functions (Stove_<Method>) are the same in both tabs. The only differences are in how interface members are accessed and how they are released. The C++ mentioned here refers to calling the new interface using C++ syntax, which differs from the old C++ interfaces (Stove::PCSDK::<Module>, old_native/).

Naming Rules

Memory Lifetime

The responsibility for freeing an SDK object is determined by the ShouldDestroy flag set by IStoveTypeBase.

if (Stove_IStoveTypeBase_ShouldDestroy(obj))   // In C++: obj->ShouldDestroy()
    Stove_IStoveTypeBase_Destroy(obj); // In C++, obj->Destroy()

// Example: Create an IStoveRestartAppIfNecessaryParam using Stove_CreateParam
IStoveRestartAppIfNecessaryParam* restartParam = (IStoveRestartAppIfNecessaryParam*)
    Stove_CreateParam(k_EStoveBaseTypeKind_RestartAppIfNecessaryParam);

Stove_IStoveRestartAppIfNecessaryParam_SetGameId(restartParam, L"my_game_id");
Stove_IStoveRestartAppIfNecessaryParam_SetAppKey(restartParam, L"my_app_key");
// ... other setter calls ...

Stove_RestartAppIfNecessary(restartParam, OnRestartAppCallback, NULL);

// Be sure to release the resource after the API call returns
Stove_IStoveTypeBase_Destroy((IStoveTypeBase*)restartParam);

Example of Calling C — Passing order parameters to Stove_StartPurchase() and then releasing them:

// 1) Create parameter objects using the Factory
IStoveOrderProductParam* order = (IStoveOrderProductParam*)Stove_CreateParam(k_EStoveIAPTypeKind_OrderProductParam);
Stove_IStoveOrderProductParam_SetProductId(order, 12345);
Stove_IStoveOrderProductParam_SetQuantity(order, 1);

IStovePurchaseParam* option = (IStovePurchaseParam*)Stove_CreateParam(k_EStoveIAPTypeKind_PurchaseParam);
Stove_IStovePurchaseParam_SetOperation(option, k_EStovePurchaseOperation_WithWebViewAndConfirmResult);

IStoveStartPurchaseParam* params = (IStoveStartPurchaseParam*)Stove_CreateParam(k_EStoveIAPTypeKind_StartPurchaseParam);
IStoveOrderProductParam* products[] = { order };
Stove_IStoveStartPurchaseParam_SetProducts(params, products, 1);
Stove_IStoveStartPurchaseParam_SetPurchaseParam(params, option);

// 2) API Call
//    OnPopupDestroyed is an IAP callback that is called when the payment web view is closed.
Stove_StartPurchase(params, OnPurchaseFinished, OnPopupDestroyed, NULL, NULL);

// 3) After the API call returns, destroy all the parameter objects that were passed
//    (Since the caller created it using the Factory, ShouldDestroy == true)
Stove_IStoveTypeBase_Destroy((IStoveTypeBase*)params);
Stove_IStoveTypeBase_Destroy((IStoveTypeBase*)option);
Stove_IStoveTypeBase_Destroy((IStoveTypeBase*)order);

C++ Call Example — Same scenario, direct call to a C++ method:

auto* order = static_cast<IStoveOrderProductParam*>(
    Stove_CreateParam(k_EStoveIAPTypeKind_OrderProductParam));
order->SetProductId(12345);
order->SetQuantity(1);

// ... (omitted)

Stove_StartPurchase(params, OnPurchaseFinished, OnPopupDestroyed, nullptr, nullptr);

params->Destroy();
option->Destroy();
order->Destroy();

Initialization Order

The initialization parameters are divided into two types of objects—IStoveRestartAppIfNecessaryParam for verifying launcher restart and IStoveInitializeParam for the actual initialization. Each is created separately and passed to the corresponding function.

1. Created IStoveRestartAppIfNecessaryParam as Stove_CreateParam(k_EStoveBaseTypeKind_RestartAppIfNecessaryParam)
2. Configure settings such as environment variables, game IDs, and app keys using Stove_IStoveRestartAppIfNecessaryParam_Set*() (or restartParam->SetXxx() in C++)
3. Call Stove_RestartAppIfNecessary(restartParam, callback, userData) — Asynchronous. The SDK checks whether the launcher is running in a separate thread, and the result is passed via a callback.
4. In the game's main loop, we begin calling Stove_RunCallback() every frame. Since the callback for Stove_RestartAppIfNecessary() is dispatched when Stove_RunCallback() is called, the Stove_RunCallback() loop must start running immediately after the call in order to receive the callback.
5. In the callback, if IsRestartRequired() == false, call Stove_Initialize() in the order shown below — (if IsRestartRequired() == true, the SDK will relaunch the launcher, so terminate the current process)
   1. Created as Stove_CreateParam(k_EStoveBaseTypeKind_InitializeParam) from IStoveInitializeParam
   2. To use View, configure SetMainWndHandle(); to use IAP, configure SetShopKey()
   3. Stove_Initialize(initParam) call — Synchronous, IStoveResult* returns immediately. Depending on the set value, the View and IAP modules are also initialized.
6. If the returned IStoveResult* result code is 0 (success), it can be used. Destroy after use.
7. Keep the Stove_RunCallback() loop running while the game is running (main thread)
8. Call Stove_Uninitialize() upon termination (must return IStoveResult* Destroy)
9. restartParam and initParam are each released to Stove_IStoveTypeBase_Destroy() after they have finished being used (after the callback completes / after Stove_Initialize() is returned).

Callback Execution Rules

• All callbacks for asynchronous APIs use the __cdecl calling convention.
• The callback runs on the thread (main/UI thread) that called Stove_RunCallback(). It does not run on an internal SDK thread.
• The IStoveCallbackResult* and associated object pointer passed as callback parameters are valid only during the callback call. Destroy() is not valid.
• One-time callbacks (such as VietnamAgeRating and VietnamOverimmersion) must be called after rendering is complete.
• The onFinished callback for the asynchronous API is a required parameter. If it is not specified, k_EStoveCommonResultCode_InvalidParam(5) occurs.

userData Parameter Rules

Asynchronous APIs accept the void* userData parameter along with a callback function. This value is not interpreted by the SDK but is passed on as-is when the callback is invoked. It serves as a channel for the game (or developer) to pass arbitrary context data into the callback.

Usage Pattern: Passes information to be used within the callback, such as object pointers from the game code, request IDs, and identifiers for ongoing tasks. Within the callback, this information is retrieved using IStoveCallbackResult::GetUserData() (Stove_IStoveCallbackResult_GetUserData(callbackResult) in C).

Memory Lifespan:

Example C — The game dynamically allocates and passes a context structure, which is then freed after use in the callback:

typedef struct GamePurchaseCtx
{
    int     requestId;
    void*   uiHandle;
} GamePurchaseCtx;

void __cdecl OnPurchaseFinished(const IStoveCallbackResult* result, const IStoveStartPurchaseOutcome* purchase)
{
    GamePurchaseCtx* ctx = (GamePurchaseCtx*)Stove_IStoveCallbackResult_GetUserData(result);
    // Post-processing on the game side using ctx->requestId and ctx->uiHandle

    free(ctx);  // Called by the caller directly — the SDK is not involved
}

// Call Section
GamePurchaseCtx* ctx = (GamePurchaseCtx*)malloc(sizeof(GamePurchaseCtx));
ctx->requestId = 12345;
ctx->uiHandle  = myUiHandle;

Stove_StartPurchase(params, OnPurchaseFinished, OnPopupDestroyed, ctx, NULL);
//                                                                  ^^^  ^^^^
//                                                                  userData1 (onFinished)
//                                                                       userData2 (onDestroy) — not used

Common Interface

For types shared by all modules, we only provide links to the respective documentation. Please refer to each document for details.

• IStoveTypeBase — This is the top-level interface for all SDK objects. It is responsible for runtime type identification and deallocation (ShouldDestroy / Destroy).
• IStoveResult — This is the result of a synchronous API call. It contains the method code and the result code.
• IStoveCallbackResult — This is the result passed to an asynchronous callback. It is valid only while the callback is being called.

Notes

• Stove_RestartAppIfNecessary() must be called before Stove_Initialize(), and to receive its callback, Stove_RunCallback() must be running in the game loop immediately after the call.
• Stove_Initialize() is a synchronous function, so it does not accept a callback, but it must be called from within the callback of Stove_RestartAppIfNecessary() (the IsRestartRequired() == false branch).
• Since userData is a void* that is not managed by the SDK, if it is allowed to point to a stack variable or a temporary object, it will become a dangling pointer at the time of the callback.

See Also

EStoveBaseMethodCode

Kind Enum · Module Base · Version 3.5.0

Description

Identifies which SDK method generated this result based on the value retrieved as IStoveResult::GetMethodCode(). It is used for logging and error routing.

Declaration

typedef enum EStoveBaseMethodCode
{
    k_EStoveBaseMethodCode_Invalid = -1,
    k_EStoveBaseMethodCode_BaseInitialize = 1,
    // ... See the table of enumerated values below
    k_EStoveBaseMethodCode_GetTranslateLanguage = 119U,

    k_EStoveBaseMethodCode_Max = 0x7fffffff
} EStoveBaseMethodCode;

Enum Values

Lifecycle / Versioning

Public APIs

Private getters (private getters exposed to other SDK modules—not exposed to the game)

Other

Values whose names include Internal (3, 4, 96–108, 110–114) are for internal SDK use only and have been excluded from the table. 109 is a reserved number that appears in the source code without a name, marked only with a "Deprecated" comment.

Example

IStoveResult* result = Stove_Initialize(initParam);

if (Stove_IStoveResult_GetMethodCode(result) == k_EStoveBaseMethodCode_BaseInitialize)
{
    // Please implement logic to verify that this result was generated by a call to `Stove_Initialize()`.
}

Notes

• The code for the "Internal" methods starting from number 96 is used for internal SDK operations, such as reporting playtime, configuring the server, and processing tokens, and does not correspond to any APIs that can be called directly from the game.
• The private getters numbered 115–119 were included in the table because their names do not contain Internal, but they are private APIs exposed only to other SDK modules and are not available in the game.
• Items 3 and 4 (InternalSend81Plug, InternalUpdate81Plug) are also excluded from the table because their names contain Internal.
• In the old interface, value names did not include underscores (e.g., k_EStoveBaseMethodCodeInvalid). In the current interface, an underscore is inserted between the type name and the value name, as in k_EStoveBaseMethodCode_Invalid.

Changelog

See Also

• IStoveResult
• EStoveCommonResultCode
• EStoveResultCode

EStoveBaseTypeKind

Kind Enum · Module Base · Version 3.5.0

Description

IStoveTypeBase is the value that identifies the concrete type instance. It is used when requesting a specific parameter object in Stove_CreateParam() and when identifying the runtime type in IStoveTypeBase::GetTypeKind().

The value range is 0 to 999. These are divided into the result and data types returned or passed by the SDK, and the parameter types created by the caller using Stove_CreateParam(). This range is designed not to overlap with the TypeKind enumeration of other SDK modules, so you can create parameters for all modules using just Stove_CreateParam().

Declaration

typedef enum EStoveBaseTypeKind
{
    k_EStoveBaseTypeKind_Invalid = -1,
    k_EStoveBaseTypeKind_Base = 0,
    // ... See the table of enumerated values below
    k_EStoveBaseTypeKind_SetGameProfileParam = 502,
    k_EStoveBaseTypeKind_Max = 0x7fffffff,
} EStoveBaseTypeKind;

Enum Values

Result / Data types (returned by the SDK or passed via callback)

Parameter types (created by the caller using Stove_CreateParam())

Example

IStoveSetGameProfileParam* profileParam =
    (IStoveSetGameProfileParam*)Stove_CreateParam(k_EStoveBaseTypeKind_SetGameProfileParam);

Notes

• The parameter type (500 series) is used as the Stove_CreateParam() argument. The result/data type (0–11) is returned by the SDK or passed via a callback, so you do not create it yourself.
• In the old interface, value names did not include an underscore (e.g., k_EStoveBaseTypeKindInvalid). In the current interface, an underscore is inserted between the type name and the value name, as in k_EStoveBaseTypeKind_Invalid.
• In the old interface, IStoveInitializeParam was a larger structure that included Environment, GameId, and AppKey, but now those fields have been separated into field 500 (RestartAppIfNecessaryParam), while field 501 (InitializeParam) contains only ShopKey and MainWndHandle.

Changelog

See Also

• Stove_CreateParam

EStoveCommonResultCode

Kind Result Code · Module Base · Version 3.5.0

Description

This is the result code used by all Stove SDK modules. It is retrieved as IStoveResult::GetResultCode(); a value of 0 (Success) indicates success.

For module-specific result codes (300 and above), see EStoveResultCode.

Declaration

typedef enum EStoveCommonResultCode
{
    k_EStoveCommonResultCode_Success = 0,
    k_EStoveCommonResultCode_Fail = 1,
    // ... See the table of enumerated values below
    k_EStoveCommonResultCode_UnknownError = 255,

    k_EStoveCommonResultCode_Max = 0x7fffffff
} EStoveCommonResultCode;

Enum Values

General Results

Configuration/Parameter Validation Failed

Initialization State Error

Token/Entity Error

If you receive the code below, you must exit the game. The game cannot proceed normally.

• 19 k_EStoveCommonResultCode_InvalidAccessToken — Your login session has expired and needs to be refreshed

HTTP/Response Errors

Other Conditions

Local DB Failure (Common to All Modules)

WebView/Popup UI Failure (Shared Module)

Parameter/Payload Validation (Common to All Modules)

Network Transmission Failure

System/Runtime Failure

Example

IStoveResult* result = Stove_Uninitialize();

if (Stove_IStoveResult_GetResultCode(result) == k_EStoveCommonResultCode_Success)
{
    // Please implement the logic for a successful outcome.
}
else
{
    // Please implement the logic for when an error occurs.
}

Stove_IStoveTypeBase_Destroy((IStoveTypeBase*)result);

Notes

• These are the result codes used by all APIs and other SDK modules.
• Module-specific codes are defined as EStoveResultCode (300~), and ranges are divided to ensure that the numbers do not overlap with this enumeration. Module-specific codes such as EStoveBaseResultCode and EStoveIAPResultCode from the old interface no longer exist.
• In the old interface, value names did not include underscores (e.g., k_EStoveCommonResultCodeSuccess). In the current interface, an underscore is inserted between the type name and the value name, as in k_EStoveCommonResultCode_Success.

Changelog

See Also

• EStoveResultCode
• IStoveResult
• IStoveCallbackResult

EStoveDiscountType

Kind Enum · Module IAP · Version 3.5.0

Description

It returns IStoveProduct as DiscountType and determines how to interpret DiscountTypeValue.

Declaration

typedef enum EStoveDiscountType
{
    k_EStoveDiscountType_None = 0,
    k_EStoveDiscountType_FixedRate = 1,
    k_EStoveDiscountType_FlatRate = 2,
    k_EStoveDiscountType_Max = 0x7fffffff
} EStoveDiscountType;

Enum Values

Example

int32_t discountType = Stove_IStoveProduct_GetDiscountType(product);
int32_t discountValue = Stove_IStoveProduct_GetDiscountTypeValue(product);

if (discountType == k_EStoveDiscountType_FixedRate)
{
    // Please interpret `discountValue` as a percentage.
}
else if (discountType == k_EStoveDiscountType_FlatRate)
{
    // Please interpret "discountValue" as a fixed amount based on the product's currency.
}

Notes

• The unit of IStoveProduct::DiscountTypeValue depends on this value.

See Also

• IStoveProduct

EStoveIAPMethodCode

Kind Enum · Module IAP · Version 3.5.0

Description

Search for IStoveResult::GetMethodCode() to identify which payment API call generated this result. This is used when branching log entries or error handling by API.

The values range from 2000 to 2999 and are assigned sequentially according to the order of the payment feature's public APIs.

Declaration

typedef enum EStoveIAPMethodCode
{
    k_EStoveIAPMethodCode_Invalid = -1,
    k_EStoveIAPMethodCode_FetchShopCategories = 2000,
    // ... See the table of enumerated values below
    k_EStoveIAPMethodCode_Max = 0x7fffffff
} EStoveIAPMethodCode;

Enum Values

Example

IStoveResult* result = Stove_IStoveCallbackResult_GetResult(callbackResult);
uint32_t methodCode = Stove_IStoveResult_GetMethodCode(result);

if (methodCode == k_EStoveIAPMethodCode_StartPurchase)
{
    // This is the result of the Stove_StartPurchase() call.
}

Notes

• Although the value range (2000–2006) appears to overlap numerically with the data type range (2000–2005) for EStoveIAPTypeKind, these are different enumerations, so be careful not to confuse them.
• The module-specific EStoveIAPResultCode from the previous interface has been removed. To determine the cause of the failure, check the value of GetResultCode() in EStoveResultCode or EStoveCommonResultCode along with this method's code.

See Also

• IStoveResult
• EStoveResultCode
• EStoveCommonResultCode

EStoveIAPTypeKind

Kind Enum · Module IAP · Version 3.5.0

Description

It is used to create the desired payment parameter object by passing it to Stove_CreateParam(), and it is also used to determine the actual type of the object at runtime via IStoveTypeBase::GetTypeKind().

The value range is 2000–2999. Within this range, the 2000s represent the result/data types passed by the SDK via callback, while the 2500s represent the parameter types created by the caller using Stove_CreateParam().

Declaration

typedef enum EStoveIAPTypeKind
{
    k_EStoveIAPTypeKind_Invalid = -1,
    k_EStoveIAPTypeKind_ShopCategory = 2000,
    // ... See the table of enumerated values below
    k_EStoveIAPTypeKind_Max = 0x7fffffff
} EStoveIAPTypeKind;

Enum Values

IStoveWebViewLayoutParam is an abstract base type shared by IStovePurchaseParam, IStoveFetchTermsAgreementParam, and IStoveWithdrawGameParam; there are no values corresponding to this enumeration. It cannot be instantiated on its own as Stove_CreateParam().

Internal-use-only values have been excluded from the table.

Example

IStoveFetchProductsParam* param = (IStoveFetchProductsParam*)Stove_CreateParam(k_EStoveIAPTypeKind_FetchProductsParam);

Notes

• Since the TypeKind enumerations for each module—such as Base and IAP—use non-overlapping integer ranges, you can generate parameters for all modules using just a single Stove_CreateParam().
• The 2000 series (result/data type) is not created directly by the caller; it appears only as the GetTypeKind() value of the object passed via callback.
• k_EStoveIAPTypeKind_StartPurchaseOutcome was renamed from its former name, PurchaseResult. Please keep this in mind when transferring past links.

See Also

• Stove_CreateParam
• Stove_FetchProducts
• Stove_StartPurchase

EStoveLogMethodCode

Kind Enum · Module Log · Version 3.5.0

Description

It queries IStoveResult::GetMethodCode() and is used for logging and error routing.

Use module blocks 6000 through 6999 in sequence.

Declaration

typedef enum EStoveLogMethodCode
{
    k_EStoveLogMethodCode_Invalid = -1,

    k_EStoveLogMethodCode_SendLog = 6000,

    k_EStoveLogMethodCode_Max = 0x7fffffff
} EStoveLogMethodCode;

Enum Values

Example

IStoveResult* result = Stove_IStoveCallbackResult_GetResult(callbackResult);

if (Stove_IStoveResult_GetMethodCode(result) == k_EStoveLogMethodCode_SendLog)
{
    // This is the result of the Stove_SendLog() call.
}

Notes

• Only one logging function, Stove_SendLog(), is provided via the public API. The SDK handles initialization and termination.
• EStoveLogResultCode has been removed from each module. The resulting code has been merged into EStoveResultCode and EStoveCommonResultCode.

See Also

• Stove_SendLog

EStoveLogTypeKind

Kind Enum · Module Log · Version 3.5.0

Description

Stove_CreateParam() is used when creating this specific parameter object, and IStoveTypeBase::GetTypeKind() is used to check its runtime type. The integer range is 6000–6999.

Declaration

typedef enum EStoveLogTypeKind
{
    k_EStoveLogTypeKind_Invalid = -1,

    k_EStoveLogTypeKind_SendLogParam = 6500,

    k_EStoveLogTypeKind_Max = 0x7fffffff
} EStoveLogTypeKind;

Enum Values

Example

IStoveSendLogParam* logParam = (IStoveSendLogParam*)Stove_CreateParam(k_EStoveLogTypeKind_SendLogParam);

Notes

• The TypeKind range (6000–6999) for the log function does not overlap with the TypeKind ranges of other modules.
• Currently, there is only one parameter type defined by the log function: k_EStoveLogTypeKind_SendLogParam.

See Also

• IStoveSendLogParam
• Stove_SendLog

EStoveOverlayMode

Kind Enum · Module Base · Version 3.5.0

Description

This value indicates the display status of regulatory and notification overlays, such as Vietnam's age rating notices and excessive use prevention notices.

Search for IStoveVietnamAgeRatingInfo::GetOverlayMode() and IStoveVietnamOverimmersionInfo::GetOverlayMode().

Declaration

typedef enum EStoveOverlayMode
{
    k_EStoveOverlayMode_Invalid = -1,

    k_EStoveOverlayMode_Show = 0,
    k_EStoveOverlayMode_Hide = 1,
    k_EStoveOverlayMode_Expanded = 2,

    k_EStoveOverlayMode_Max = 0x7fffffff
} EStoveOverlayMode;

Enum Values

Example

void __cdecl OnVietnamAgeRatingNotificationCallback(const IStoveCallbackResult* callbackResult, const IStoveVietnamAgeRatingInfo* ageRatingInfo)
{
    int32_t overlayMode = Stove_IStoveVietnamAgeRatingInfo_GetOverlayMode(ageRatingInfo);
    if (overlayMode == k_EStoveOverlayMode_Show)
    {
        // Please implement the logic to display the overlay.
    }
}

Notes

• k_EStoveOverlayMode_Expanded is a value used exclusively in the Vietnamese Excessive Gaming Prevention Notice (IStoveVietnamOverimmersionInfo). Only "Show/Hide" is passed to the Age Rating Notice (IStoveVietnamAgeRatingInfo).
• In the old interface, value names did not include an underscore (e.g., k_EStoveOverlayModeInvalid). In the current interface, an underscore is inserted between the type name and the value name, as in k_EStoveOverlayMode_Invalid.

Changelog

See Also

• IStoveVietnamAgeRatingInfo
• IStoveVietnamOverimmersionInfo

EStovePCBangMethodCode

Kind Enum · Module PCBang · Version 3.5.0

Description

Based on the value retrieved as IStoveResult::GetMethodCode(), this identifies which PC Bang function generated that result. It can be used for logging or error routing.

Use module blocks 3000 through 3999 in sequence.

Declaration

typedef enum EStovePCBangMethodCode
{
    k_EStovePCBangMethodCode_Invalid = -1,

    k_EStovePCBangMethodCode_Login = 3000,
    k_EStovePCBangMethodCode_Logout = 3001,
    k_EStovePCBangMethodCode_CheckStatus = 3002,
    k_EStovePCBangMethodCode_RefreshBenefit = 3003,

    k_EStovePCBangMethodCode_Max = 0x7fffffff
} EStovePCBangMethodCode;

Enum Values

Example

IStoveResult* result = Stove_IStoveCallbackResult_GetResult(callbackResult);

if (Stove_IStoveResult_GetMethodCode(result) == k_EStovePCBangMethodCode_Login)
{
    // This is the result of the first login to Stove_PCBangLogin().
}

Notes

• k_EStovePCBangMethodCode_RefreshBenefit is the code corresponding to the result of the onRefreshBenefit callback for Stove_PCBangLogin. This callback is sent repeatedly at 4-minute intervals after a successful login and continues to be called regardless of whether the account is Premium or Free. It differs from the Login code (initial login, one-time) in terms of when it occurs and how often it is triggered.

See Also

• Stove_PCBangLogin
• Stove_PCBangLogout
• Stove_PCBangCheckStatus

EStovePCBangPremium

Kind Enum · Module PCBang · Version 3.5.0

Description

This value indicates the PC Bang premium (paid) subscription status of the logged-in user. IStovePCBangLoginOutcome::GetPremiumCheck(), IStovePCBangBenefitInfo::GetPremiumCheck(), and IStovePCBangStatus::GetPremiumCheck() return this value.

This enumeration does not include separate codes to indicate success or failure. k_EStovePCBangPremium_Error is a value that indicates a server error or an unrecognized condition; whether the operation was successful is determined separately by checking whether the value of Stove_IStoveResult_GetResultCode() is 0.

Declaration

typedef enum EStovePCBangPremium
{
    k_EStovePCBangPremium_Error = -1,
    k_EStovePCBangPremium_Premium = 1,
    k_EStovePCBangPremium_Free = 2,
    k_EStovePCBangPremium_FreeOther = 3,

    k_EStovePCBangPremium_Max = 0x7fffffff
} EStovePCBangPremium;

Enum Values

Example

void __cdecl OnUserLogin(const IStoveCallbackResult* callbackResult, const IStovePCBangLoginOutcome* loginOutcome)
{
    IStoveResult* result = Stove_IStoveCallbackResult_GetResult(callbackResult);
    if (Stove_IStoveResult_GetResultCode(result) == 0)
    {
        int32_t premium = Stove_IStovePCBangLoginOutcome_GetPremiumCheck(loginOutcome);
        if (premium == k_EStovePCBangPremium_Premium)
        {
            // Please implement the logic for premium benefits.
        }
    }
}

Notes

• This value is returned by all three structures: IStovePCBangLoginOutcome, IStovePCBangBenefitInfo, and IStovePCBangStatus.
• PC Bang Benefit renewal (the onRefreshBenefit callback for Stove_PCBangLogin) is called repeatedly every 4 minutes and continues to be called in both Premium and Free states. If the update response is received successfully but its value is FreeOther, the loop stops. However, if the update request itself fails due to network issues or other reasons, the loop does not stop and will retry in the next cycle.

See Also

• IStovePCBangLoginOutcome
• IStovePCBangBenefitInfo
• IStovePCBangStatus

EStovePCBangTypeKind

Kind Enum · Module PCBang · Version 3.5.0

Description

This value, which is returned as IStoveTypeBase::GetTypeKind(), is used to identify the runtime type of the result/data object passed via the PCBang asynchronous callback.

The price range is reserved from 3,000 to 3,999.

Declaration

typedef enum EStovePCBangTypeKind
{
    k_EStovePCBangTypeKind_Invalid = -1,

    k_EStovePCBangTypeKind_StovePCBangLoginOutcome = 3000,
    k_EStovePCBangTypeKind_StovePCBangBenefitInfo = 3001,
    k_EStovePCBangTypeKind_StovePCBangStatus = 3002,

    k_EStovePCBangTypeKind_Max = 0x7fffffff
} EStovePCBangTypeKind;

Enum Values

Example

void __cdecl OnUserLogin(const IStoveCallbackResult* callbackResult, const IStovePCBangLoginOutcome* loginOutcome)
{
    if (Stove_IStoveTypeBase_GetTypeKind((const IStoveTypeBase*)loginOutcome) == k_EStovePCBangTypeKind_StovePCBangLoginOutcome)
    {
        // Use `loginOutcome` as `IStovePCBangLoginOutcome`.
    }
}

Notes

• All values included in this enumeration are result/data types passed by the PC Bang function as callbacks; there are no input parameter types created by the caller.
• The range 3000–3999 is reserved exclusively for the PC Bang function, so it does not overlap with the TypeKind values of other modules.

See Also

• IStovePCBangLoginOutcome
• IStovePCBangBenefitInfo
• IStovePCBangStatus

EStoveProductTypeCode

Kind Enum · Module IAP · Version 3.5.0

Description

This is the product category code that returns ProductTypeCode out of IStoveProduct.

Declaration

typedef enum EStoveProductTypeCode
{
    k_EStoveProductTypeCode_None = 0,
    k_EStoveProductTypeCode_IndiePackageGameItem = 1,
    k_EStoveProductTypeCode_InGameItem = 2,
    k_EStoveProductTypeCode_PackageItem = 3,
    k_EStoveProductTypeCode_Max = 0x7fffffff
} EStoveProductTypeCode;

Enum Values

Example

int32_t typeCode = Stove_IStoveProduct_GetProductTypeCode(product);
if (typeCode == k_EStoveProductTypeCode_InGameItem)
{
    // Please implement logic specifically for in-game items.
}

Notes

• This is used when interpreting the value IStoveProduct::ProductTypeCode.

See Also

• IStoveProduct

EStovePurchaseLimitTypeCode

Kind Enum · Module IAP · Version 3.5.0

Description

It returns IStoveProduct as PurchaseLimitTypeCode, indicating the scope (account-based or character-based) to which PurchaseLimitCount applies.

Declaration

typedef enum EStovePurchaseLimitTypeCode
{
    k_EStovePurchaseLimitTypeCode_None = 0,
    k_EStovePurchaseLimitTypeCode_Unlimited = 1,
    k_EStovePurchaseLimitTypeCode_Member = 2,
    k_EStovePurchaseLimitTypeCode_Character = 3,
    k_EStovePurchaseLimitTypeCode_Max = 0x7fffffff
} EStovePurchaseLimitTypeCode;

Enum Values

Example

int32_t limitType = Stove_IStoveProduct_GetPurchaseLimitTypeCode(product);
int32_t limitCount = Stove_IStoveProduct_GetPurchaseLimitCount(product);

Notes

• This value is used when interpreting IStoveProduct::PurchaseLimitCount.

See Also

• IStoveProduct

EStovePurchaseOperation

Kind Enum · Module IAP · Version 3.5.0

Description

Pass a value of Operation to IStovePurchaseParam to select which flow Stove_StartPurchase() will follow: manual URL, Stove WebView, or WebView + auto-complete.

Declaration

typedef enum EStovePurchaseOperation
{
    k_EStovePurchaseOperation_Default = 0,
    k_EStovePurchaseOperation_WithWebView = 1,
    k_EStovePurchaseOperation_WithWebViewAndConfirmResult = 2,
    k_EStovePurchaseOperation_Max = 0x7fffffff
} EStovePurchaseOperation;

Enum Values

Example

IStovePurchaseParam* purchaseParam = (IStovePurchaseParam*)Stove_CreateParam(k_EStoveIAPTypeKind_PurchaseParam);
Stove_IStovePurchaseParam_SetOperation(purchaseParam, k_EStovePurchaseOperation_WithWebViewAndConfirmResult);

Notes

• When entering values other than Default, you must also fill in the WebView* field (WebView position and size), which is inherited by IStovePurchaseParam.
• Which field is populated in the results depends on this value. For more information, see the IStoveStartPurchaseOutcome documentation.

See Also

• IStovePurchaseParam
• Stove_StartPurchase
• IStoveStartPurchaseOutcome

EStovePurchaseProgress

Kind Enum · Module IAP · Version 3.5.0

Description

It returns IStoveStartPurchaseOutcome as PurchaseProgress.

Declaration

typedef enum EStovePurchaseProgress
{
    k_EStovePurchaseProgress_None = 0,
    k_EStovePurchaseProgress_NeedPaymentWindow = 1,
    k_EStovePurchaseProgress_NotNeedPaymentWindow = 2,
    k_EStovePurchaseProgress_Max = 0x7fffffff
} EStovePurchaseProgress;

Enum Values

Example

int32_t progress = Stove_IStoveStartPurchaseOutcome_GetPurchaseProgress(outcome);
if (progress == k_EStovePurchaseProgress_NeedPaymentWindow)
{
    const wchar_t* paymentUrl = Stove_IStoveStartPurchaseOutcome_GetTempPaymentUrl(outcome);
    // Please open the payment window using `paymentUrl`.
}

Notes

• When NeedPaymentWindow, use IStoveStartPurchaseOutcome::TempPaymentUrl to open the payment window, and after making the payment, you must confirm the purchase using Stove_ConfirmPurchase.

See Also

• IStoveStartPurchaseOutcome
• Stove_StartPurchase

EStoveResultCode

Kind Result Code · Module Base · Version 3.5.0

Description

Among the values returned by IStoveResult::GetResultCode(), these are codes in the 300s range that belong to a global dictionary shared by multiple modules. The category is distinguished by the digit in the hundreds place (3xx: Base, 4xx: webview/popup UI, 5xx: IAP purchase/payload). Since separating codes by module is meaningless in a single-binary structure, codes that were used with the same meaning across multiple modules have been consolidated into a single number. You can determine which module generated a particular code by checking the GetMethodCode() value (code / 1000 = module block).

For the result code (0–299) used by all modules, please refer to EStoveCommonResultCode.

The module-specific result code enumerations (EStoveBaseResultCode, EStoveIAPResultCode, etc.) from the old interface have been removed. They have now been consolidated into this enumeration (300–) and EStoveCommonResultCode (0–299).

Declaration

typedef enum EStoveResultCode
{
    k_EStoveResultCode_LanguageNotSet = 300,
    // ... See the table of enumerated values below
    k_EStoveResultCode_InvalidOrderProductInformation = 503,

    k_EStoveResultCode_Max = 0x7fffffff
} EStoveResultCode;

Enum Values

3xx — Base Language / GDS / Launcher / Token / IPC

If you receive the code below, you must exit the game. The game cannot proceed normally.

• 304 k_EStoveResultCode_NeedStoveLauncher — This is not running via the Stove PC client, so it needs to be restarted.
• 307 k_EStoveResultCode_IpcConnectFailed — Failed to connect to the launcher; please try again.
• 308 k_EStoveResultCode_IpcAesKeyNotReceived — Failed to establish communication with the launcher; a retry is required
• 309 k_EStoveResultCode_IpcTimeout — Communication with the launcher timed out; a retry is required

4xx — (Reserved, Unused)

5xx — IAP Purchase / Payload

Example

IStoveResult* result = Stove_SetGameProfile(profileParam);

if (Stove_IStoveResult_GetResultCode(result) == k_EStoveResultCode_LanguageNotSet)
{
    // Please implement logic that calls `Stove_SetLanguage()` first.
}

Notes

• This replaces EStoveBaseResultCode (80s) from the old interface. With the single binary integration, the result codes for each module have been reorganized into this enumeration (300–) and EStoveCommonResultCode (0–299).
• The values 401–499, 501, and 502 are merely reserved; they do not actually exist in this enumeration. The actual code can be found in EStoveCommonResultCode, specifically in the ranges 60–68 (WebView/popup UI) and 80–81 (IAP parameter validation).

Changelog

See Also

• EStoveCommonResultCode
• IStoveResult

EStoveTermsOperation

Kind Enum · Module IAP · Version 3.5.0

Description

Pass a value of Operation to IStoveFetchTermsAgreementParam to choose how Stove_FetchTermsAgreement() displays the terms and conditions page.

Declaration

typedef enum EStoveTermsOperation
{
    k_EStoveTermsOperation_Default = 0,
    k_EStoveTermsOperation_WithWebView = 1,
    k_EStoveTermsOperation_Max = 0x7fffffff
} EStoveTermsOperation;

Enum Values

Example

IStoveFetchTermsAgreementParam* param = (IStoveFetchTermsAgreementParam*)Stove_CreateParam(k_EStoveIAPTypeKind_FetchTermsAgreementParam);
Stove_IStoveFetchTermsAgreementParam_SetOperation(param, k_EStoveTermsOperation_WithWebView);

Notes

• When using WithWebView, you must also fill in the WebView* fields (WebView position and size) that IStoveFetchTermsAgreementParam inherits.
• If a user has already agreed to the latest terms of service, regardless of this value, IsAgreed in IStoveTermsAgreementOutcome will be returned as true, and Url will be returned as an empty string.

See Also

• IStoveFetchTermsAgreementParam
• Stove_FetchTermsAgreement
• IStoveTermsAgreementOutcome

EStoveViewMethodCode

Kind Enum · Module View · Version 3.5.0

Description

EStoveViewMethodCode is a value that identifies the pop-up API that generated IStoveResult. It can be queried as IStoveResult::GetMethodCode()(Stove_IStoveResult_GetMethodCode()) and is used in logging and error-handling branches.

The value range for this enumeration is 1000 to 1999 (module block), and the pop-up APIs use consecutive numbers.

Declaration

typedef enum EStoveViewMethodCode
{
    k_EStoveViewMethodCode_Invalid = -1,
    k_EStoveViewMethodCode_AutoPopup = 1000,
    // ... See the table of enumerated values below
    k_EStoveViewMethodCode_SetPopupDisallowed = 1005,
    k_EStoveViewMethodCode_Max = 0x7fffffff
} EStoveViewMethodCode;

Enum Values

Example

IStoveResult* result = Stove_IStoveCallbackResult_GetResult(callbackResult);

if (Stove_IStoveResult_GetMethodCode(result) == k_EStoveViewMethodCode_ManualPopup)
{
    // Please implement the logic if this is the result of a call to `Stove_ManualPopup()`.
}

Notes

• The value range (1000–1999) does not overlap with the MethodCode values of other modules.
• Stove_CloseAllPopups() is a unified function in the BaseSDK that closes not only the View but also the IAP popup; it does not correspond to any value in this enumeration.
• Even for the same pop-up, the values differ from those in the old interface. The old interface (such as View_AutoPopup) returns 81, 83, 85, 87, 91, and 160, while the new interface returns the value in the 1000 range of this enumeration. While both versions are in use, please keep the log aggregation criteria separate for each version.

Changelog

See Also

• Stove_AutoPopup
• Stove_ManualPopup
• Stove_NewsPopup
• Stove_CouponPopup
• Stove_VerifyIdentificationPopup
• Stove_SetPopupDisallowed

EStoveViewTypeKind

Kind Enum · Module View · Version 3.5.0

Description

EStoveViewTypeKind is a value that identifies the concrete type of the IStoveTypeBase series of objects handled by the pop-up feature. This value is passed when requesting a specific parameter object via Stove_CreateParam(), and it is also used when checking the actual type of an object at runtime via IStoveTypeBase::GetTypeKind() (Stove_IStoveTypeBase_GetTypeKind()).

The value range for this enumeration is 1000 to 1999. There are 1500 parameter types, and the payload type passed to the callback is 1504. Since the value range does not overlap with the TypeKind enumerations of other modules, Stove_CreateParam() can be used to generate parameters for all modules.

Declaration

typedef enum EStoveViewTypeKind
{
    k_EStoveViewTypeKind_Invalid = -1,
    k_EStoveViewTypeKind_SetPopupDisallowedParam = 1500,
    // ... See the table of enumerated values below
    k_EStoveViewTypeKind_VerifyIdentificationPopupDestroyInfo = 1504,
    k_EStoveViewTypeKind_Max = 0x7fffffff
} EStoveViewTypeKind;

Enum Values

Parameter types (created by the caller using Stove_CreateParam())

Callback payload types (generated by the SDK and passed to the callback)

Example

IStovePopupParam* param =
    (IStovePopupParam*)Stove_CreateParam(k_EStoveViewTypeKind_PopupParam);

// After using `param`
Stove_IStoveTypeBase_Destroy((IStoveTypeBase*)param);

Notes

• Parameter types (1500–1503) are used as Stove_CreateParam() arguments. The callback payload type (1504) is generated and passed by the SDK, so you do not need to create it yourself.
• The value range (1000–1999) does not overlap with the EStove<Module>TypeKind value of another module.

Changelog

See Also

• Stove_CreateParam
• IStoveSetPopupDisallowedParam
• IStovePopupParam

EStoveWebViewMode

Kind Enum · Module Base · Version 3.5.0

Description

This setting in the View SDK and IAP SDK determines whether a web view opens as an external pop-up (the system's default browser) or an internal pop-up (the SDK's built-in web view).

Declaration

typedef enum EStoveWebViewMode
{
    k_EStoveWebViewMode_Invalid = -1,

    k_EStoveWebViewMode_External = 0,
    k_EStoveWebViewMode_Internal = 1,

    k_EStoveWebViewMode_Max = 0x7fffffff
} EStoveWebViewMode;

Enum Values

Example

int32_t webViewMode = k_EStoveWebViewMode_Internal;

Notes

• This value is used to specify how pop-ups are displayed in the View SDK and IAP SDK.
• k_EStoveWebViewMode_Internal is a value that indicates the domain meaning "uses an internal WebView"; it is not an "Internal-only" value.
• In the old interface, value names did not include underscores (e.g., k_EStoveWebViewModeInvalid). In the current interface, an underscore is inserted between the type name and the value name, as in k_EStoveWebViewMode_Invalid.

Changelog

See Also

• None

IStoveAccessToken

Kind Struct · Module Base · Version 3.5.0

Description

This is the token structure passed as a callback when the AccessToken is renewed upon calling Stove_AccessTokenRenewed().

The SDK is created and passed only as a callback argument; the caller does not release it.

Declaration

typedef struct IStoveAccessToken IStoveAccessToken;
// To access members, use the access functions listed in the member table below.

Members

Memory Management

Example

void __cdecl OnAccessTokenRenewedCallback(const IStoveCallbackResult* callbackResult, const IStoveAccessToken* token)
{
    IStoveResult* result = Stove_IStoveCallbackResult_GetResult(callbackResult);

    if (Stove_IStoveResult_GetResultCode(result) == k_EStoveCommonResultCode_Success)
    {
        const wchar_t* accessToken = Stove_IStoveAccessToken_GetAccessToken(token);
        int32_t expireIn = Stove_IStoveAccessToken_GetExpireIn(token);
        // Please implement the logic for a successful outcome.
    }
    else
    {
        // Please implement the logic for when an error occurs.
    }

    // The token does not call Destroy().
}

Notes

• This structure accepts data only through the callback registered as Stove_AccessTokenRenewed(). To immediately look up a currently valid token, use Stove_GetAccessToken.
• The SDK automatically renews tokens internally; use this callback only if you want to perform the renewal yourself when it is due.

See Also

• Stove_AccessTokenRenewed
• Stove_GetAccessToken

IStoveCallbackResult

Kind Struct · Module Base · Version 3.5.0

Description

This is the result passed to the asynchronous callback. It wraps IStoveResult and includes additional error information along with the userData pointer provided at the time of the call.

It is passed as the first callback argument to callback-based asynchronous APIs such as Stove_RestartAppIfNecessary() and Stove_AccessTokenRenewed(). The lifetime of this object and its internal pointers is limited to the duration of the callback call. It is created by the SDK and passed only as a callback argument; the caller does not free it.

Once the callback finishes, both this object and IStoveResult*—obtained from GetResult()—will be invalidated. Destroy() will not be called.

Declaration

typedef struct IStoveCallbackResult IStoveCallbackResult;
// To access members, use the access functions listed in the member table below.

Members

Memory Management

Example

void __cdecl OnAccessTokenRenewedCallback(const IStoveCallbackResult* callbackResult, const IStoveAccessToken* token)
{
    IStoveResult* result = Stove_IStoveCallbackResult_GetResult(callbackResult);

    if (Stove_IStoveResult_GetResultCode(result) == k_EStoveCommonResultCode_Success)
    {
        // Please implement the logic for a successful outcome.
    }
    else
    {
        // Please implement the logic for when an error occurs.
    }

    // `callbackResult`, `result`, and `token` do not call `Destroy()`.
}

Notes

• Asynchronous callbacks in the SDK (OnRestartAppIfNecessaryCallback, OnAccessTokenRenewedCallback, OnOverImmersionNotificationCallback, OnShutdownNotificationCallback, OnVietnamAgeRatingNotificationCallback, OnVietnamOverimmersionNotificationCallback, OnOpenExternalUrlCallback) in the SDK.
• The callback runs in the thread that called Stove_RunCallback() (or Stove_RunCallbackWithTimeout()).

See Also

• Stove_RunCallback
• IStoveResult

IStoveChargeInfo

Kind Struct · Module IAP · Version 3.5.0

Description

This represents a single payment method (such as coupons, Stove Cash, points, or PG) used for a single purchase. It is passed as an array containing both IStoveStartPurchaseOutcome and IStoveConfirmPurchaseOutcome.

This is a data type that the SDK fills in and passes via a callback. The caller does not create it directly.

The array and each item passed to the callback are owned by the SDK and are no longer valid once the callback call ends. Do not call Destroy(); instead, copy any values you need to preserve within the callback.

Declaration

typedef struct IStoveChargeInfo IStoveChargeInfo;
// To access members, use the access functions listed in the member table below.

Members

Memory Management

Example

void __cdecl OnConfirmPurchaseCallback(const IStoveCallbackResult* callbackResult, const IStoveConfirmPurchaseOutcome* outcome)
{
    IStoveResult* result = Stove_IStoveCallbackResult_GetResult(callbackResult);

    if (Stove_IStoveResult_GetResultCode(result) == 0 && Stove_IStoveConfirmPurchaseOutcome_IsConfirmed(outcome))
    {
        uint32_t count = Stove_IStoveConfirmPurchaseOutcome_GetChargeInfoCount(outcome);

        for (uint32_t i = 0; i < count; ++i)
        {
            const IStoveChargeInfo* chargeInfo = Stove_IStoveConfirmPurchaseOutcome_GetChargeInfoAt(outcome, i);

            double deductVal = Stove_IStoveChargeInfo_GetChargeDeductVal(chargeInfo);
            const wchar_t* typeName = Stove_IStoveChargeInfo_GetChargeTypeName(chargeInfo);

            // Please copy and save only the values you need.
        }
        // The `outcome` and its items will be invalidated once this callback completes. Do not call `Destroy()`.
    }
    else
    {
        // Please implement the logic for when an error occurs.
    }
}

Notes

• It is passed from both ChargeInfoAt() of IStoveStartPurchaseOutcome and ChargeInfoAt() of IStoveConfirmPurchaseOutcome.
• If multiple payment methods are used in a single purchase, the items are organized into an array, with one entry for each payment method.

See Also

• IStoveStartPurchaseOutcome
• IStoveConfirmPurchaseOutcome
• IStovePurchasedProduct

IStoveConfirmPurchaseOutcome

Kind Struct · Module IAP · Version 3.5.0

Description

This represents the result of the Stove_ConfirmPurchase call. It is passed to the OnConfirmPurchaseCallback callback. Previously, the confirmation flag and the array of product/payment information were passed separately as callback arguments, but now they are combined into a single structure and passed together.

This is a data type that the SDK populates and passes via a callback. The caller does not create it directly.

All values obtained via PurchasedProductAt() / ChargeInfoAt() are owned by the SDK and are no longer valid once the callback completes. Do not call Destroy(); instead, copy any values you need to retain within the callback.

Declaration

typedef struct IStoveConfirmPurchaseOutcome IStoveConfirmPurchaseOutcome;
// To access members, use the access functions listed in the member table below.

Members

Memory Management

Example

void __cdecl OnConfirmPurchaseCallback(const IStoveCallbackResult* callbackResult, const IStoveConfirmPurchaseOutcome* outcome)
{
    IStoveResult* result = Stove_IStoveCallbackResult_GetResult(callbackResult);

    if (Stove_IStoveResult_GetResultCode(result) == 0 && Stove_IStoveConfirmPurchaseOutcome_IsConfirmed(outcome))
    {
        uint32_t productCount = Stove_IStoveConfirmPurchaseOutcome_GetPurchasedProductCount(outcome);
        for (uint32_t i = 0; i < productCount; ++i)
        {
            const IStovePurchasedProduct* product = Stove_IStoveConfirmPurchaseOutcome_GetPurchasedProductAt(outcome, i);
            // Please implement the item distribution logic. Please prevent duplicate distributions by checking the TxnDetailNo.
        }
        // The `outcome` and its items will be invalidated once this callback finishes. Do not call `Destroy()`.
    }
    else
    {
        // Please implement the logic for when an error occurs.
    }
}

Notes

• It is passed only as the output of Stove_ConfirmPurchase.
• If IsConfirmed is false, the product/payment information array may be empty.

See Also

• Stove_ConfirmPurchase
• IStoveStartPurchaseOutcome
• IStovePurchasedProduct
• IStoveChargeInfo

IStoveConfirmPurchaseParam

Kind Struct · Module IAP · Version 3.5.0

Description

This is the input parameter passed when calling Stove_ConfirmPurchase. It is used to confirm a purchase using the transaction master number received from IStoveStartPurchaseOutcome.

Create it as Stove_CreateParam(k_EStoveIAPTypeKind_ConfirmPurchaseParam), fill in the value using the setter, and then release it as Destroy() once the call is complete.

Declaration

typedef struct IStoveConfirmPurchaseParam IStoveConfirmPurchaseParam;
// To access members, use the access functions listed in the member table below.

Members

Memory Management

Example

IStoveConfirmPurchaseParam* confirmParam = (IStoveConfirmPurchaseParam*)Stove_CreateParam(k_EStoveIAPTypeKind_ConfirmPurchaseParam);

Stove_IStoveConfirmPurchaseParam_SetTxnMasterNo(confirmParam, txnMasterNo);

Stove_ConfirmPurchase(confirmParam, OnConfirmPurchaseCallback, NULL);

Stove_IStoveTypeBase_Destroy((IStoveTypeBase*)confirmParam);

Notes

• For TxnMasterNo, please use the TxnMasterNo value from IStoveStartPurchaseOutcome, which is the result of Stove_StartPurchase, as is.
• Purchases that begin with Operation == Default must be confirmed using this API after completing payment on the payment page.

See Also

• Stove_ConfirmPurchase
• Stove_StartPurchase
• IStoveStartPurchaseOutcome

IStoveFetchProductsParam

Kind Struct · Module IAP · Version 3.5.0

Description

These are the input parameters passed when calling Stove_FetchProducts. They specify the category and page range to query.

Create it as Stove_CreateParam(k_EStoveIAPTypeKind_FetchProductsParam), set its value using the setter, and then release it as Destroy() once the call is complete.

Declaration

typedef struct IStoveFetchProductsParam IStoveFetchProductsParam;
// To access members, use the access functions listed in the member table below.

Members

Memory Management

Example

IStoveFetchProductsParam* param = (IStoveFetchProductsParam*)Stove_CreateParam(k_EStoveIAPTypeKind_FetchProductsParam);

Stove_IStoveFetchProductsParam_SetCategoryId(param, L"");
Stove_IStoveFetchProductsParam_SetPageIndex(param, 1);
Stove_IStoveFetchProductsParam_SetPageSize(param, 20);

Stove_FetchProducts(param, OnFetchProductsCallback, NULL);

Stove_IStoveTypeBase_Destroy((IStoveTypeBase*)param);

Notes

• If you leave CategoryId blank, products from all categories will be displayed. To view products from a specific category, please specify the value of CategoryId in IStoveShopCategory.

See Also

• Stove_FetchProducts
• IStoveProductList
• IStoveShopCategory

IStoveFetchTermsAgreementParam

Kind Struct · Module IAP · Version 3.5.0

Description

These are the input parameters passed when calling Stove_FetchTermsAgreement. It inherits from IStoveWebViewLayoutParam, and the WebView* fields apply only when Operation is not Default.

Create it as Stove_CreateParam(k_EStoveIAPTypeKind_FetchTermsAgreementParam), populate it with a value using the setter, and then release it as Destroy() once the call is complete.

Declaration

typedef struct IStoveFetchTermsAgreementParam IStoveFetchTermsAgreementParam;
// To access members, use the access functions listed in the member table below.

Members

Memory Management

Example

IStoveFetchTermsAgreementParam* param = (IStoveFetchTermsAgreementParam*)Stove_CreateParam(k_EStoveIAPTypeKind_FetchTermsAgreementParam);

Stove_IStoveFetchTermsAgreementParam_SetOperation(param, k_EStoveTermsOperation_WithWebView);
Stove_IStoveFetchTermsAgreementParam_SetWebViewMode(param, k_EStoveWebViewMode_Internal);
Stove_IStoveFetchTermsAgreementParam_SetWebViewWidth(param, 480);
Stove_IStoveFetchTermsAgreementParam_SetWebViewHeight(param, 640);

Stove_FetchTermsAgreement(param, OnFetchTermsAgreementCallback, NULL, NULL, NULL);

Stove_IStoveTypeBase_Destroy((IStoveTypeBase*)param);

Notes

• Operation If this is Default, the WebView* field is ignored.

See Also

• Stove_FetchTermsAgreement
• IStoveWebViewLayoutParam
• IStoveTermsAgreementOutcome

IStoveGds

Kind Struct · Module Base · Version 3.5.0

Description

This is the structure containing the country, regulatory, time zone, and language information passed when calling Stove_GetGds().

The country code based on the logged-in user's IP address is provided by default; if the country cannot be determined from the IP address, it is replaced with the default country code (separated by IsDefault). The SDK creates and returns it via the Stove_GetGds() out parameter, and the caller releases it via Destroy() after use.

Declaration

typedef struct IStoveGds IStoveGds;
// To access members, use the access functions listed in the member table below.

Members

Memory Management

Example

IStoveGds* gds = NULL;
IStoveResult* result = Stove_GetGds(&gds);

if (Stove_IStoveResult_GetResultCode(result) == k_EStoveCommonResultCode_Success)
{
    const wchar_t* nation = Stove_IStoveGds_GetNation(gds);
    const wchar_t* timezone = Stove_IStoveGds_GetTimezone(gds);
    // Please implement the logic for a successful outcome.

    Stove_IStoveTypeBase_Destroy((IStoveTypeBase*)gds);
}
else
{
    // Please implement the logic for when an error occurs.
}

Stove_IStoveTypeBase_Destroy((IStoveTypeBase*)result);

Notes

• You must call this after initialization is complete with Stove_Initialize() to receive a valid value.

See Also

• Stove_GetGds

IStoveInitializeParam

Kind Struct · Module Base · Version 3.5.0

Description

Contains the parameters required for the Stove_Initialize() call. It is used solely to set the IAP store key and the game's main window handle.

Create it using Stove_CreateParam(k_EStoveBaseTypeKind_InitializeParam), configure the necessary fields, and then release it using Destroy() when the call is complete. If ShopKey is not left empty, Stove_Initialize() will initialize the IAP module as well; if MainWndHandle is set, it will initialize the View module (and the IAP module, if ShopKey is present). If you pass initParam itself as null, only the SDK is initialized.

MainWndHandle is a valid value only after the game's main window has actually been created.

Declaration

typedef struct IStoveInitializeParam IStoveInitializeParam;
// To access members, use the access functions listed in the member table below.

Members

Memory Management

Example

IStoveInitializeParam* initParam =
    (IStoveInitializeParam*)Stove_CreateParam(k_EStoveBaseTypeKind_InitializeParam);

Stove_IStoveInitializeParam_SetShopKey(initParam, L"YOUR_SHOP_KEY");
Stove_IStoveInitializeParam_SetMainWndHandle(initParam, hWnd);

IStoveResult* result = Stove_Initialize(initParam);

if (Stove_IStoveResult_GetResultCode(result) == k_EStoveCommonResultCode_Success)
{
    // Please implement the logic for a successful outcome.
}
else
{
    // Please implement the logic for when a failure occurs.
}

Stove_IStoveTypeBase_Destroy((IStoveTypeBase*)result);
Stove_IStoveTypeBase_Destroy((IStoveTypeBase*)initParam);

Notes

• Environment/GameId/AppKey is not present in this type. In the current interface, it has been moved to IStoveRestartAppIfNecessaryParam, and the SDK reuses the cached value from Stove_RestartAppIfNecessary() when calling Stove_Initialize().
• ShopKey and MainWndHandle are fields added to initialize the IAP and View modules together following the single binary integration.
• If Stove_Initialize() succeeds only partially (e.g., SDK/View succeeds, but IAP fails), the SDK may remain in a partially initialized state. To recover, you must call Stove_Uninitialize() and then call Stove_Initialize() again.

See Also

• Stove_Initialize
• Stove_CreateParam
• IStoveRestartAppIfNecessaryParam

IStoveInventoryItem

Kind Struct · Module IAP · Version 3.5.0

Description

Represents a single user purchase history entry. The result of the Stove_FetchInventory call is stored in IStoveInventoryList and passed to the OnFetchInventoryCallback callback.

This is a data type that the SDK populates and passes via a callback. The caller does not create it directly.

The list and each item passed to the callback are owned by the SDK and are no longer valid once the callback completes. Do not call Destroy(); instead, copy any values you need to preserve within the callback.

Declaration

typedef struct IStoveInventoryItem IStoveInventoryItem;
// To access members, use the access functions listed in the member table below.

Members

Memory Management

Example

void __cdecl OnFetchInventoryCallback(const IStoveCallbackResult* callbackResult, const IStoveInventoryList* list)
{
    IStoveResult* result = Stove_IStoveCallbackResult_GetResult(callbackResult);

    if (Stove_IStoveResult_GetResultCode(result) == 0)
    {
        uint32_t count = Stove_IStoveInventoryList_GetCount(list);

        for (uint32_t i = 0; i < count; ++i)
        {
            const IStoveInventoryItem* item = Stove_IStoveInventoryList_GetAt(list, i);

            int64_t productId = Stove_IStoveInventoryItem_GetProductId(item);
            int32_t quantity = Stove_IStoveInventoryItem_GetQuantity(item);

            // Please copy and save only the values you need.
        }
        // The list and its items will be invalidated once this callback finishes. Do not call Destroy().
    }
    else
    {
        // Please implement the logic for when an error occurs.
    }
}

Notes

• It is passed only as the output of Stove_FetchInventory.
• When verifying whether game items have been awarded, you must prevent duplicate processing based on TxnDetailNo.

See Also

• Stove_FetchInventory
• IStoveInventoryList
• IStoveProduct

IStoveInventoryList

Kind Struct · Module IAP · Version 3.5.0

Description

OnFetchInventoryCallback is the container passed to the callback. It wraps the IStoveInventoryItem array returned by Stove_FetchInventory.

This is a data type that the SDK populates and passes via a callback. It is not created directly by the caller.

This object and each item obtained via GetAt() are all owned by the SDK and are no longer valid once the callback call ends. Do not call Destroy(); instead, copy any values that need to be preserved within the callback.

Declaration

typedef struct IStoveInventoryList IStoveInventoryList;
// To access members, use the access functions listed in the member table below.

Members

Memory Management

Example

void __cdecl OnFetchInventoryCallback(const IStoveCallbackResult* callbackResult, const IStoveInventoryList* list)
{
    IStoveResult* result = Stove_IStoveCallbackResult_GetResult(callbackResult);

    if (Stove_IStoveResult_GetResultCode(result) == 0)
    {
        uint32_t count = Stove_IStoveInventoryList_GetCount(list);
        for (uint32_t i = 0; i < count; ++i)
        {
            const IStoveInventoryItem* item = Stove_IStoveInventoryList_GetAt(list, i);
            // Please copy and save only the values you need.
        }
        // The list and its individual items will be invalidated once this callback completes. Do not call Destroy().
    }
    else
    {
        // Please implement the logic for when an error occurs.
    }
}

Notes

• It is passed only as the output of Stove_FetchInventory.
• Previously, the array and count were passed as separate callback arguments, but now they are wrapped into this single container and passed together.

See Also

• Stove_FetchInventory
• IStoveInventoryItem

IStoveManualPopupParam

Kind Struct · Module View · Version 3.5.0

Description

IStoveManualPopupParam is a parameter type used when displaying a manual popup. It specifies the popup content to be displayed using ResourceKey. It is used as an input for Stove_ManualPopup.

The caller creates it as Stove_CreateParam(k_EStoveViewTypeKind_ManualPopupParam), fills in the value, and then releases it as Destroy() once the API call is complete.

Declaration

typedef struct IStoveManualPopupParam IStoveManualPopupParam;
// To access members, use the access functions listed in the member table below.

Members

Memory Management

Example

IStoveManualPopupParam* param =
    (IStoveManualPopupParam*)Stove_CreateParam(k_EStoveViewTypeKind_ManualPopupParam);
Stove_IStoveManualPopupParam_SetWebViewMode(param, k_EStoveWebViewMode_Internal);
Stove_IStoveManualPopupParam_SetResourceKey(param, L"EVENT_BANNER_01");

Stove_ManualPopup(param, OnPopupFinished, OnPopupDestroyed, NULL, NULL);

Stove_IStoveTypeBase_Destroy((IStoveTypeBase*)param);

Notes

• If you do not set ResourceKey, you cannot determine what pop-up content to display.

See Also

• Stove_ManualPopup
• EStoveWebViewMode

IStoveOrderProductParam

Kind Struct · Module IAP · Version 3.5.0

Description

These are the order items for each product stored in IStoveStartPurchaseParam. One is created for each product to be purchased and passed to SetProducts().

Create it as Stove_CreateParam(k_EStoveIAPTypeKind_OrderProductParam), populate it with a value using the setter, and once the purchase call is complete (or after the parent IStoveStartPurchaseParam is released), you must release it as Destroy().

Declaration

typedef struct IStoveOrderProductParam IStoveOrderProductParam;
// To access members, use the access functions listed in the member table below.

Members

Memory Management

Example

IStoveOrderProductParam* orderProduct = (IStoveOrderProductParam*)Stove_CreateParam(k_EStoveIAPTypeKind_OrderProductParam);

Stove_IStoveOrderProductParam_SetProductId(orderProduct, productId);
Stove_IStoveOrderProductParam_SetSalePrice(orderProduct, salePrice);
Stove_IStoveOrderProductParam_SetQuantity(orderProduct, 1);

IStoveOrderProductParam* orderProducts[] = { orderProduct };

// Please create the `startPurchaseParam` in advance by referring to the IStoveStartPurchaseParam documentation.
Stove_IStoveStartPurchaseParam_SetProducts(startPurchaseParam, orderProducts, 1);

Stove_StartPurchase(startPurchaseParam, OnStartPurchaseCallback, NULL, NULL, NULL);

Stove_IStoveTypeBase_Destroy((IStoveTypeBase*)orderProduct);

Notes

• SetProducts() does not take ownership of the object. The caller retains ownership of the IStoveOrderProductParam object and must call Destroy() directly after the purchase call is complete.
• For SalePrice, please use the same SalePrice value as IStoveProduct. If the values differ, the server may treat this as a price discrepancy.

See Also

• Stove_StartPurchase
• IStoveStartPurchaseParam
• IStoveProduct

IStoveOverImmersionInfo

Kind Struct · Module Base · Version 3.5.0

Description

Stove_OverImmersionNotification() This is the excessive use prevention notice information passed via the callback. This API is for use in South Korea only.

Contains the excessive use warning message, cumulative game playtime (in hours), and the duration the message is displayed. It is created by the SDK and passed only as a callback argument; the caller does not release it.

This callback is not a one-time event; it is sent to the target user repeatedly every hour. You must register it after the time when the notification can be displayed on the screen.

Declaration

typedef struct IStoveOverImmersionInfo IStoveOverImmersionInfo;
// To access members, use the access functions listed in the member table below.