Are you curious about the actual implementation flow?

Usage Scenario / Terminating Game Service

Game Termination

Understanding

Game termination (service termination) is a feature that allows users to delete their in-game data for a specific game.
The STOVE platform integrated account is maintained, and only the characters, currency, and all information within the world connected to that game are deleted.

Processing Method

To prevent user error, game termination must provide warning notices and confirmation features.
The termination flow varies depending on whether a grace period is set.

Termination Status Notification

The STOVE platform sends real-time events to the CP (developer) server when the game termination status changes.
The CP must implement a Callback API to receive these events and process them according to their operational policies.

Integration Guide

Preparation

Basic Integration Structure

• Client: Provide Withdrawal UI and Warning Notifications
  • Place a withdrawal button in the in-game settings screen.

• You must provide a warning notification and a confirmation pop-up before the withdrawal request.

• Since the user is automatically logged out upon completion of withdrawal, you must handle the subsequent flow (e.g., exiting the game or moving to the initial screen).

• Server: Game Withdrawal Processing
  • Calling the Game Withdrawal Complete API does not affect the Stove platform account.
  • Upon request, the Stove character information of the user identified by the provided server authentication token and game ID will be deleted across all worlds.
  • In-game information recorded in the game DB must be maintained/deleted directly by the game.
  • If using the Stove cash system, please note that the cash held by the character will also be deleted.

• Grace Period Settings and Data Deletion Method
  • The game withdrawal grace period is managed by each game's own policy.
    • When entering the game within the termination processing period (PC example)

• When entering the game within the termination processing period (Mobile example)

Development

Mobile SDK Integration

Operation Flow

When a user re-opens the game and logs in during the grace period, the SDK automatically checks the termination application status from STOVE and displays the cancellation UI. Once the user selects cancellation, the application status is cleared in STOVE, and the game server only needs to handle synchronization via the GAME_WITHDRAW_CANCEL event.

Implementation Requirements for Game

Reference

• Please refer to AuthUI.Login for the full call flow of 로그인 가이드.
• Please refer to the server integration guide for the game termination application API (REST), termination completion processing (STOVE automatic), and GAME_WITHDRAW* event specifications.

PC SDK Integration

PCSDK You can display the STOVE game termination (terms withdrawal) popup from the game client by using the game termination API (IAP_WithdrawGame) provided by IAPSDK. If the user agrees to the terms withdrawal in the popup, STOVE processes the game termination.

Preparation

• Complete Base initialization by calling Base_RestartAppIfNecessaryAsync in the restartAppIfNecessary == false branch of the Base_InitializeEx callback. Then, initialize the IAP module with IAP_Initialize(shopKey) (or IAP_InitializeWithWndInfo(shopKey, mainWndHandle) if a parent window needs to be specified). The game termination API must be called after initialization is complete.
• The callback execution function (Base_RunCallback()) must be called periodically in the game loop for asynchronous callbacks (termination result callback, popup close callback) to function.
• If terms withdrawal is successful, the SDK's internal user token expires. You should design the subsequent flow to handle the process from game termination guidance to process exit without further SDK calls.

Development Flow

1. Configure Options: Set the WebView mode (Internal/External) and position/size in the termination flow parameters (StovePCWithdrawGameOption). If you want to center the position, specify PosX/PosY as -1).
2. Call API: Display the terms withdrawal popup with the game termination API (IAP_WithdrawGame).
3. Handle Result Callback: If the termination result callback is gameWithdrawal == true, treat it as termination in progress.
4. Handle Popup Close Callback: Receive the point when the user closes the popup via the popup close callback and display the game termination guidance UI.
5. Handle Game Termination: Since the SDK token expires when terms withdrawal is complete, guide the user through the results and terminate the game process without further SDK calls.

Troubleshooting

Sequence Diagram

Sample Code

#include "IAPSDK.h"

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

void IAP_WithdrawGame_Example()
{
    StovePCWithdrawGameOption Option;
    Option.SetWebviewMode(WebViewMode::INTERNAL);
    // 정중앙 배치를 원할 경우 PosX/PosY를 -1로 지정
    Option.SetWebviewRect(0, 0, 800, 600);

    IAP_WithdrawGame(&Option,
        [](CallbackResult CallbackResult, bool GameWithdrawal)
        {
            if (CallbackResult.GetResult().IsSuccessful() && GameWithdrawal)
            {
                // 게임 해지 성공 처리
            }
        },
        [](CallbackResult CallbackResult)
        {
            // 팝업 종료 후 결과 안내 + 게임 종료
        }
    );
}
```=== "Unity"```cs
using static Stove.PCSDK.Base;
using static Stove.PCSDK.IAP;

private OnWithdrawGameFinished _onWithdrawGameFinished;
private OnIAPPopupDestroyFinished _onIAPPopupDestroyFinished;

void IAP_WithdrawGame_Example()
{
    var option = new StovePCWithdrawGameOption
    {
        webviewMode = WebViewMode.INTERNAL,
        webviewPosX = 0,
        webviewPosY = 0,
        webviewWidth = 800,
        webviewHeight = 600
    };

    _onWithdrawGameFinished = (callbackResult, gameWithdrawal) =>
    {
        if (callbackResult.result.IsSuccessful() && gameWithdrawal)
        {
            // 게임 해지 성공 — 추가 SDK 호출 금지, 종료 흐름 준비
        }
    };

    _onIAPPopupDestroyFinished = (callbackResult) =>
    {
        // 팝업 종료 후 결과 안내 + 게임 종료 처리
    };

    IAP_WithdrawGame(option, _onWithdrawGameFinished, _onIAPPopupDestroyFinished);
}

// Java 25 LTS — java.net.http.HttpClient + Jackson(ObjectMapper)
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import java.util.UUID;

ObjectMapper mapper = new ObjectMapper();
String baseUrl = "https://api.onstove.com";
String serviceId = "STOVE_EPIC7";
String callerId = serviceId + "_SERVER";
String callerDetail = UUID.randomUUID().toString();

try (HttpClient client = HttpClient.newBuilder()
        .connectTimeout(Duration.ofSeconds(5))
        .build()) {

    // 유예 처리(철회 예정 상태)는 URL 끝에 &delete_yn=N 추가
    URI uri = URI.create(baseUrl + "/stove-terms/v3.0/agree?service_id=" + serviceId);

    HttpRequest req = HttpRequest.newBuilder(uri)
            .header("Content-Type", "application/json")
            .header("Authorization", "Bearer " + gameUserAccessToken)
            .header("caller-id", callerId)
            .header("caller-detail", callerDetail)
            .DELETE()
            .build();
    HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
    JsonNode data = mapper.readTree(res.body());
    if (data.path("code").asInt() != 0) {
        // 트러블슈팅 표 참고 (70800 / 70816 / 70820 / 70825 / 70899 등)
        throw new IllegalStateException("withdraw failed: " + data.path("code"));
    }
    long withdrawDt = data.path("value").path("withdraw_dt").asLong(0L);
    if (withdrawDt > 0) {
        // 유예기간 모드 — withdrawDt 는 unix-ms 탈퇴 예정 일자. 안내 후 게임 세션 종료
    } else {
        // 즉시 철회 완료 — 게임 세션 종료
    }
}