Pop-up

public void News()
{
    ViewUI.News((Result result, Dictionary<string, string> dictionary) =>
    {
        if (result.IsSuccessful)
        {
        }
        else
        {
            OperationUI.HandleResult(result, (Result operationResult) =>
            {
                /** ex) keep the current screen **/
            });
        }
    });
}

private fun newsPopup(activity: Activity) {
    ViewUI.news(activity) { result, map ->
        //closed view
    }
}

public void AutoPopup()
{
    ViewUI.Popup((Result result, Dictionary<string, string> dictionary) =>
    {
        if (result.IsSuccessful)
        {
        }
        else
        {
            OperationUI.HandleResult(result, (Result operationResult) =>
            {
                /** ex) keep the current screen **/
            });
        }
    });
}

private fun autoPopup(activity: Activity) {
    ViewUI.popup(activity) { result, map ->
        //closed view
    }
}

public void ManualPopup()
{
    /**
     * location : pop-up location (int)
     **/
    ViewUI.Popup("location", (Result result, Dictionary<string, string> dictionary) =>
    {
        if (result.IsSuccessful)
        {
        }
        else
        {
            OperationUI.HandleResult(result, (Result operationResult) =>
            {
                /** ex) keep the current screen **/
            });
        }
    });
}

private fun manualPopup(activity: Activity) {
    ViewUI.popup(activity, 1) { result, map ->
        //closed view
    }
}

public void UseCoupon()
{
    /**
     * code : coupon input (string)
     **/
    View.UseCoupon("code", (Result result) =>
    {
        if (result.IsSuccessful)
        {
        }
        else
        {
            OperationUI.HandleResult(result, (Result operationResult) =>
            {
                /** ex) keep the current screen **/
            });
        }
    });
}

fun useCoupon(context: Context, code: String) {
    View.useCoupon(context, code) { result, map ->

    }
}

public void Community()
{
    ViewUI.Community((Result result, Dictionary<string, string> dictionary) =>
    {
        if (result.IsSuccessful)
        {
            if (dictionary != null && dictionary.ContainsKey("received_data"))
            {
                string receivedData = dictionary["received_data"];
                Dictionary<string, object> data = Json.Deserialize(receivedData) as Dictionary<string, object>;

                if (data != null)
                {
                    if (data.TryGetValue("code", out object codeObj) && codeObj is long errorCode)
                    {
                        if (errorCode == 40104) {
                            /** SDK auth token expired — log out and go to the initial screen **/
                        }
                    }
                }
            }
        }
        else
        {
            OperationUI.HandleResult(result, (Result operationResult) => { });
        }
    });
}

private fun community(activity: Activity) {
    ViewUI.community(activity) { result, map ->
        //closed view
    }
}

public void CommunityWithURL()
{
    /**
     * url : url input (string)
     **/
    ViewUI.Community("url", (Result result, Dictionary<string, string> dictionary) =>
    {
        if (result.IsSuccessful)
        {
            if (dictionary != null && dictionary.ContainsKey("received_data"))
            {
                string receivedData = dictionary["received_data"];
                Dictionary<string, object> data = Json.Deserialize(receivedData) as Dictionary<string, object>;

                if (data != null)
                {
                    if (data.TryGetValue("code", out object codeObj) && codeObj is long errorCode)
                    {
                        if (errorCode == 40104) {
                            /** SDK auth token expired **/
                        }
                    }
                }
            }
        }
        else
        {
            OperationUI.HandleResult(result, (Result operationResult) => { });
        }
    });
}

private fun community(activity: Activity, url: String) {
    ViewUI.community(activity, url) { result, map ->
        //closed view
    }
}

public void Load()
{
    ViewConfiguration viewConfiguration = ViewConfiguration.Partial();
    ViewRequest viewRequest = new ViewRequest("url", viewConfiguration);
    ViewUI.Load(viewRequest, (Result result, Dictionary<string, string> dictionary) =>
    {
        if (result.IsSuccessful)
        {
            if (result.UserInfo != null && result.UserInfo.TryGetValue("userAction", out string userAction))
            {
                if (!string.IsNullOrEmpty(userAction) && userAction.Equals("withdraw_complete"))
                {
                    /** ex) game withdrawal complete **/
                }
            }
        }
        else
        {
            OperationUI.HandleResult(result, (Result operationResult) => { });
        }
    });
}

private fun load(activity: Activity) {
    val url = "https://www.onstove.com/"
    val viewConfiguration = ViewConfiguration.partial()
    val viewRequest = ViewRequest(url, viewConfiguration = viewConfiguration)
    ViewUI.load(activity, viewRequest) { result, map ->
        if (result.isSuccessful()) {
            result.userInfo?.let { userInfo ->
                when (userInfo["userAction"]) {
                    "withdraw_complete" -> {
                        // Withdrawn state
                    }
                }
            }
        }
    }
}

public void Load()
{
    ViewConfiguration viewConfiguration = ViewConfiguration.Full();
    ViewRequest viewRequest = new ViewRequest("url", viewConfiguration);
    ViewUI.Load(viewRequest, (Result result, Dictionary<string, string> dictionary) =>
    {
        if (result.IsSuccessful)
        {
            if (result.UserInfo != null && result.UserInfo.TryGetValue("userAction", out string userAction))
            {
                if (!string.IsNullOrEmpty(userAction) && userAction.Equals("withdraw_complete"))
                {
                    /** ex) game withdrawal complete **/
                }
            }
        }
        else
        {
            OperationUI.HandleResult(result, (Result operationResult) => { });
        }
    });
}

private void News()
{
    ViewUI.News((Result result, Dictionary<string, string> dictionary) =>
    {
        if (dictionary != null && dictionary.ContainsKey("received_data"))
        {
            string value = dictionary["received_data"];
        }
    });
}

public void SetProperties()
{
    AccessToken accessToken = Auth.AccessToken;
    if (accessToken == null) { return; }
    Dictionary<string, object> properties = new Dictionary<string, object>();
    properties.Add("testKey", "testValue");
    GameProfile gameProfile = accessToken.User.GameProfile;
    if (gameProfile == null)
    {
        accessToken.User.GameProfile = new GameProfile();
    }
    accessToken.User.GameProfile.Properties = properties;
}

/**
 * url : "the url to open in the external browser: coupon or community, etc.";
 **/
public void OpenExternalUrl()
{
    AccessToken accessToken = Auth.AccessToken;
    if (accessToken == null) { return; }

    string url = "the url to open in the external browser: coupon or community, etc.";

    ViewUI.OpenExternalUrl(url, (Result result) =>
    {
        if (result.IsSuccessful)
        {
            // External-browser integration success
        }
        else
        {
            OperationUI.HandleResult(result, (Result operationResult) => { });
        }
    });
}

#include "ViewSDK.h"

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

// 1) Initialize ViewSDK (after Base_Initialize completes)
auto initResult = View_Initialize();
if (!initResult.IsSuccessful())
{
    // Implement the logic for initialization failure.
    return;
}

// 2) Auto pop-up (use Ex if you need the close event)
//    The first argument is WebViewMode (EXTERNAL: external browser / INTERNAL: SDK built-in webview)
View_AutoPopupEx(
    WebViewMode::EXTERNAL,
    [](CallbackResult openResult) {
        if (openResult.GetResult().IsSuccessful())
        {
            // Handle pop-up open
        }
    },
    [](CallbackResult destroyResult) {
        // Resume the game flow when the pop-up closes
    }
);

// 3) Manual pop-up (specify the pop-up to show with resourceKey)
View_ManualPopup(L"your_resource_key", WebViewMode::EXTERNAL, /* onFinished */ nullptr);

// 4) Identity-verification pop-up (Korea only)
//    compareIdentifier=true: SDI validation / false: deliver simKey
View_VerifyIdentificationPopup(
    true, WebViewMode::INTERNAL,
    [](CallbackResult result) {
        if (!result.GetResult().IsSuccessful())
        {
            // Logic for failures such as NOT_SUPPORTED_COUNTRY(31)
        }
    },
    [](CallbackResult result, const wchar_t* simKey) {
        // Handle pop-up close (simKey delivered when compareIdentifier=false)
    });

// 5) Open external browser (BaseSDK module API — not ViewSDK, BaseSDK.h)
//    Only STOVE-related domains allowed; SSO kept.
{
    std::wstring url = L"https://www.onstove.com";
    Base_OpenExternalUrl(url.c_str(), [](CallbackResult callbackResult) {
        if (callbackResult.GetResult().IsSuccessful())
        {
            // Handle external-browser integration success
        }
    });
}

// 6) Clean up on exit
View_UnInitialize();
// Then call Base_UnInitialize