웹 서비스 SSO 연동

/**
  * url : "외부브라우저를 연동할 url : 쿠폰 or 커뮤니티 등";
  **/

public void OpenExternalUrl()
{

   AccessToken accessToken = Auth.AccessToken;
   if (accessToken == null)
   {
     return;
   }

  string url = "외부브라우저를 연동할 url : 쿠폰 or 커뮤니티 등";

  ViewUI.OpenExternalUrl(url, (Result result) =>
  {
    if (result.IsSuccessful)
    {
        // 설정된 url 로 외부브라우저 연동 성공            
    }
    else
    {
        // 외부브라우저 호출 실패
        OperationUI.HandleResult(result, (Result operationResult) =>
        {
        });
    }
  });
}

void Base_OpenExternalUrl(const wchar_t* url, OnOpenExternalUrlFinished onFinished);

// 콜백
typedef void(__cdecl* OnOpenExternalUrlFinished)(CallbackResult callbackResult);

#include "BaseSDK.h"

using namespace Stove::PCSDK::Base;

// Base_Initialize() 성공 이후에 호출해요.
void OpenStoveCommunity()
{
    Base_OpenExternalUrl(L"https://www.onstove.com", [](CallbackResult callbackResult)
    {
        if (callbackResult.GetResult().IsSuccessful())
        {
            // 브라우저 실행 성공 시 로직을 구현해 주세요.
        }
        else
        {
            // 실패 시 로직을 구현해 주세요.
        }
    });
}

// 게임 루프에서 매 프레임 호출해야 콜백이 전달돼요.
void GameLoop()
{
    Base_RunCallback();
}

   // SsoUrl.h
   #pragma once
   #include <string>
   #include <sstream>
   #include <stdexcept>

   namespace sso {

   // RFC 3986 unreserved 외 문자를 %XX로 인코딩
   inline std::string UrlEncode(const std::string& value) {
       static const char hex[] = "0123456789ABCDEF";
       std::string out; out.reserve(value.size() * 3);
       for (unsigned char c : value) {
           if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') ||
               (c >= '0' && c <= '9') ||
               c == '-' || c == '_' || c == '.' || c == '~') {
               out.push_back(static_cast<char>(c));
           } else {
               out.push_back('%');
               out.push_back(hex[c >> 4]);
               out.push_back(hex[c & 0x0F]);
           }
       }
       return out;
   }

   struct SsoParams {
       std::string state;                 // 필수
       std::string redirectUrl;           // 필수
       std::string mode  = "game_token";  // game_token | web_token
       std::string theme = "light";       // light | dark
       std::string gameId;
       std::string lang  = "ko";
   };

   inline std::string BuildSsoCallbackUrl(const SsoParams& p) {
       static const char* kBaseUrl =
           "https://api.onstove.com/sim/auth/session/callback";
       if (p.state.empty())       throw std::invalid_argument("state is required.");
       if (p.redirectUrl.empty()) throw std::invalid_argument("redirect_url is required.");
       std::ostringstream url;
       url << kBaseUrl
           << "?state="        << UrlEncode(p.state)
           << "&redirect_url=" << UrlEncode(p.redirectUrl)
           << "&mode="         << UrlEncode(p.mode.empty()  ? "game_token" : p.mode)
           << "&theme="        << UrlEncode(p.theme.empty() ? "light"      : p.theme)
           << "&lang="         << UrlEncode(p.lang.empty()  ? "ko"         : p.lang);
       if (!p.gameId.empty()) url << "&game_id=" << UrlEncode(p.gameId);
       return url.str();
   }

 } // namespace sso

#include "include/cef_browser.h"
#include "include/cef_frame.h"
#include "SsoUrl.h"

void NavigateSso(CefRefPtr<CefBrowser> browser, const sso::SsoParams& baseParams) {
    if (!browser) return;
    sso::SsoParams params = baseParams;
    params.mode = "game_token";  // 웹뷰는 game_token
    const std::string url = sso::BuildSsoCallbackUrl(params);
    browser->GetMainFrame()->LoadURL(CefString(url));  // CefString은 UTF-8 처리
}

using UnityEngine;

public static class SsoUnityBrowser
{
    // 외부 브라우저는 web_token (SUAT + SURT)
    public static void OpenExternal(
        string state, string redirectUrl, string gameId, string theme = "light")
    {
        string url = SsoUrlBuilder.Build(
            state, redirectUrl, "web_token", theme, gameId, "ko");
        Application.OpenURL(url);
    }
}

using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Networking;

public static class SsoUtil
{
   private const string CALLBACK_URL =
       "https://api.onstove.com/sim/auth/session/callback";

   public static string CreateMobileSsoUrl(
       string state,
       string redirectUrl,
       string mode = "game_token",
       string theme = "light",
       string gameId = "",
       string lang = "ko")
   {
       if (string.IsNullOrWhiteSpace(state))
       {
           throw new ArgumentException("state is required.", nameof(state));
       }

       if (string.IsNullOrWhiteSpace(redirectUrl))
       {
           throw new ArgumentException(
               "redirectUrl is required.",
               nameof(redirectUrl)
           );
       }

       var queryParams = new List<string>
       {
           $"state={UnityWebRequest.EscapeURL(state)}",
           $"redirect_url={UnityWebRequest.EscapeURL(redirectUrl)}",
           $"mode={UnityWebRequest.EscapeURL(mode)}",
           $"theme={UnityWebRequest.EscapeURL(theme)}",
           $"lang={UnityWebRequest.EscapeURL(lang)}"
       };

       if (!string.IsNullOrWhiteSpace(gameId))
       {
           queryParams.Add(
               $"game_id={UnityWebRequest.EscapeURL(gameId)}"
           );
       }

       return $"{CALLBACK_URL}?{string.Join("&", queryParams)}";
   }
}

// URL 생성 예제
string ssoUrl = SsoUtil.CreateMobileSsoUrl(
   state: state,
   redirectUrl: "https://service.onstove.com/main",
   gameId: "STOVE_LORD"
);

import android.webkit.WebSettings;
import android.webkit.WebView;
import android.webkit.WebViewClient;

public class SsoWebView {

   public static void openWebView(
           WebView webView,
           String ssoCallbackUrl
   ) {
       if (webView == null) {
           throw new IllegalArgumentException("webView is required.");
       }

       if (ssoCallbackUrl == null || ssoCallbackUrl.isEmpty()) {
           throw new IllegalArgumentException("ssoCallbackUrl is required.");
       }

       WebSettings settings = webView.getSettings();
       settings.setJavaScriptEnabled(true);
       settings.setDomStorageEnabled(true);

       webView.setWebViewClient(new WebViewClient());

       // SSO Callback URL을 최초 진입 주소로 사용
       webView.loadUrl(ssoCallbackUrl);
   }
}

// 사용 예제
String ssoUrl = SsoUtil.createMobileSsoUrl(
state,
"https://service.onstove.com/main",
"game_token",
   "light",
   "STOVE_LORD",
   "ko"
);

SsoWebView.openWebView(webView, ssoUrl);

import android.content.Context
import android.content.Intent
import android.net.Uri

object SsoBrowser {

  fun openExternalBrowser(
    context: Context,
    ssoCallbackUrl: String
  ) {
      require(ssoCallbackUrl.isNotBlank()) {
          "ssoCallbackUrl is required."
      }

      val intent = Intent(
          Intent.ACTION_VIEW,
          Uri.parse(ssoCallbackUrl)
      ).apply {
          addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
      }

      context.startActivity(intent)
  }
}

// 사용 예제
val ssoUrl = SsoUtil.createMobileSsoUrl(
  state = state,
  redirectUrl = "https://service.onstove.com/main",
  mode = "web_token",      // 외부 브라우저는 web_token 권장
  gameId = "STOVE_LORD"
)

SsoBrowser.openExternalBrowser(
  context = this,
  ssoCallbackUrl = ssoUrl
)

function openExternalBrowser({
    state, redirectUrl,
    mode = "web_token", theme = "light", game_id = "", lang = "ko"
}) {
    const url = new URL("/sim/auth/session/callback", window.location.origin);
    url.searchParams.set("state", state);
    url.searchParams.set("redirect_url", redirectUrl);
    url.searchParams.set("mode", mode);
    url.searchParams.set("theme", theme);
    url.searchParams.set("lang", lang);

    if (game_id) {
        url.searchParams.set("game_id", game_id);
    }

    window.open(url.toString(), "EXTERNAL_BROWSER", "noopener,noreferrer");  // 새 창
}

openExternalBrowser({
    state: "issued-state",
    redirectUrl: "https://service.onstove.com/main"
});