Refactor UrlOpener to pimpl and add CanOpen

Move URL validation and shared UrlOpener logic into a new core `src/url_opener.cpp`, and switch each platform backend to a concrete `UrlOpener::Impl` class. This removes the old `url_opener_internal` launcher helpers and standardizes platform result construction. The C API was regenerated to add `native_url_opener_can_open`, rename error code constants, and simplify result string ownership/freeing. Tests were updated to validate `CanOpen` and `Open` behavior through the public singleton API.

Author: lijy91

src/capi/url_opener_c.cpp

@@ -1,79 +1,95 @@
+// AUTO-GENERATED. DO NOT EDIT.
+// Any manual changes WILL BE LOST when this file is regenerated.
+
 #include "url_opener_c.h"
 
-#include <exception>
+#include <cstdlib>
+#include <cstring>
 #include <string>
 
 #include "../url_opener.h"
-#include "string_utils_c.h"
 
-using namespace nativeapi;
+#include <cstdio>
 
 namespace {
 
-native_url_open_error_code_t ToCErrorCode(UrlOpenErrorCode code) {
-  switch (code) {
-    case UrlOpenErrorCode::kNone:
-      return NATIVE_URL_OPEN_ERROR_NONE;
-    case UrlOpenErrorCode::kInvalidUrlEmpty:
-      return NATIVE_URL_OPEN_ERROR_INVALID_URL_EMPTY;
-    case UrlOpenErrorCode::kInvalidUrlMissingScheme:
-      return NATIVE_URL_OPEN_ERROR_INVALID_URL_MISSING_SCHEME;
-    case UrlOpenErrorCode::kInvalidUrlUnsupportedScheme:
-      return NATIVE_URL_OPEN_ERROR_INVALID_URL_UNSUPPORTED_SCHEME;
-    case UrlOpenErrorCode::kUnsupportedPlatform:
-      return NATIVE_URL_OPEN_ERROR_UNSUPPORTED_PLATFORM;
-    case UrlOpenErrorCode::kInvocationFailed:
-      return NATIVE_URL_OPEN_ERROR_INVOCATION_FAILED;
+char* DupString(const std::string& value) {
+  if (value.empty()) {
+    return nullptr;
+  }
+  const auto size = value.size() + 1;
+  auto* buffer = static_cast<char*>(std::malloc(size));
+  if (!buffer) {
+    return nullptr;
+  }
+  std::memcpy(buffer, value.c_str(), size);
+  return buffer;
+}
+
+native_url_open_error_code_t ToCUrlOpenErrorCode(nativeapi::UrlOpenErrorCode value) {
+  switch (value) {
+    case nativeapi::UrlOpenErrorCode::kNone:
+      return NATIVE_URL_OPEN_ERROR_CODE_NONE;
+    case nativeapi::UrlOpenErrorCode::kInvalidUrlEmpty:
+      return NATIVE_URL_OPEN_ERROR_CODE_INVALID_URL_EMPTY;
+    case nativeapi::UrlOpenErrorCode::kInvalidUrlMissingScheme:
+      return NATIVE_URL_OPEN_ERROR_CODE_INVALID_URL_MISSING_SCHEME;
+    case nativeapi::UrlOpenErrorCode::kInvalidUrlUnsupportedScheme:
+      return NATIVE_URL_OPEN_ERROR_CODE_INVALID_URL_UNSUPPORTED_SCHEME;
+    case nativeapi::UrlOpenErrorCode::kUnsupportedPlatform:
+      return NATIVE_URL_OPEN_ERROR_CODE_UNSUPPORTED_PLATFORM;
+    case nativeapi::UrlOpenErrorCode::kInvocationFailed:
+      return NATIVE_URL_OPEN_ERROR_CODE_INVOCATION_FAILED;
     default:
-      return NATIVE_URL_OPEN_ERROR_INVOCATION_FAILED;
+      return NATIVE_URL_OPEN_ERROR_CODE_NONE;
   }
 }
 
-native_url_open_result_t MakeUrlOpenResult(bool success,
-                                           native_url_open_error_code_t error_code,
-                                           const std::string& message) {
+native_url_open_result_t ToCUrlOpenResult(const nativeapi::UrlOpenResult& value) {
   native_url_open_result_t result = {};
-  result.success = success;
-  result.error_code = error_code;
-  result.error_message = message.empty() ? nullptr : to_c_str(message);
+  result.success = value.success;
+  result.error_code = ToCUrlOpenErrorCode(value.error_code);
+  result.error_message = DupString(value.error_message);
   return result;
 }
 
 }  // namespace
 
 bool native_url_opener_is_supported(void) {
   try {
-    return UrlOpener::GetInstance().IsSupported();
+    return nativeapi::UrlOpener::GetInstance().IsSupported();
   } catch (...) {
+    fprintf(stderr, "[nativeapi] %s: unexpected exception\n", "native_url_opener_is_supported");
     return false;
   }
 }
 
-native_url_open_result_t native_url_opener_open(const char* url) {
-  if (!url) {
-    return MakeUrlOpenResult(false, NATIVE_URL_OPEN_ERROR_INVALID_URL_EMPTY, "URL is empty.");
+bool native_url_opener_can_open(const char* url) {
+  try {
+    return nativeapi::UrlOpener::GetInstance().CanOpen(std::string(url ? url : ""));
+  } catch (...) {
+    fprintf(stderr, "[nativeapi] %s: unexpected exception\n", "native_url_opener_can_open");
+    return false;
   }
+}
 
+native_url_open_result_t native_url_opener_open(const char* url) {
   try {
-    const UrlOpenResult result = UrlOpener::GetInstance().Open(std::string(url));
-    return MakeUrlOpenResult(result.success, ToCErrorCode(result.error_code), result.error_message);
-  } catch (const std::exception& e) {
-    return MakeUrlOpenResult(false, NATIVE_URL_OPEN_ERROR_INVOCATION_FAILED, e.what());
+    const auto cpp_result = nativeapi::UrlOpener::GetInstance().Open(std::string(url ? url : ""));
+    return ToCUrlOpenResult(cpp_result);
   } catch (...) {
-    return MakeUrlOpenResult(false, NATIVE_URL_OPEN_ERROR_INVOCATION_FAILED,
-                             "Unexpected error while opening URL.");
+    fprintf(stderr, "[nativeapi] %s: unexpected exception\n", "native_url_opener_open");
+    native_url_open_result_t result = {};
+    result.success = false;
+    return result;
   }
 }
 
-void native_url_open_result_free(native_url_open_result_t* result) {
-  if (!result) {
+void native_url_open_result_free(native_url_open_result_t* value) {
+  if (!value) {
     return;
   }
-
-  if (result->error_message) {
-    free_c_str(result->error_message);
-    result->error_message = nullptr;
-  }
-  result->success = false;
-  result->error_code = NATIVE_URL_OPEN_ERROR_NONE;
+  std::free(value->error_message);
+  value->error_message = nullptr;
 }
+

src/capi/url_opener_c.h

@@ -1,3 +1,6 @@
+// AUTO-GENERATED. DO NOT EDIT.
+// Any manual changes WILL BE LOST when this file is regenerated.
+
 #pragma once
 
 #include <stdbool.h>
@@ -12,46 +15,32 @@
 extern "C" {
 #endif
 
-/**
- * @brief Error codes returned by URL opening APIs.
- */
 typedef enum {
-  NATIVE_URL_OPEN_ERROR_NONE = 0,
-  NATIVE_URL_OPEN_ERROR_INVALID_URL_EMPTY = 1,
-  NATIVE_URL_OPEN_ERROR_INVALID_URL_MISSING_SCHEME = 2,
-  NATIVE_URL_OPEN_ERROR_INVALID_URL_UNSUPPORTED_SCHEME = 3,
-  NATIVE_URL_OPEN_ERROR_UNSUPPORTED_PLATFORM = 4,
-  NATIVE_URL_OPEN_ERROR_INVOCATION_FAILED = 5,
+  NATIVE_URL_OPEN_ERROR_CODE_NONE = 0,
+  NATIVE_URL_OPEN_ERROR_CODE_INVALID_URL_EMPTY = 1,
+  NATIVE_URL_OPEN_ERROR_CODE_INVALID_URL_MISSING_SCHEME = 2,
+  NATIVE_URL_OPEN_ERROR_CODE_INVALID_URL_UNSUPPORTED_SCHEME = 3,
+  NATIVE_URL_OPEN_ERROR_CODE_UNSUPPORTED_PLATFORM = 4,
+  NATIVE_URL_OPEN_ERROR_CODE_INVOCATION_FAILED = 5,
 } native_url_open_error_code_t;
 
-/**
- * @brief Result payload for URL open attempts.
- */
 typedef struct {
   bool success;
   native_url_open_error_code_t error_code;
   char* error_message;
 } native_url_open_result_t;
 
-/**
- * @brief Check whether URL opening is supported on this platform.
- */
 FFI_PLUGIN_EXPORT
 bool native_url_opener_is_supported(void);
 
-/**
- * @brief Attempt to open URL with the system default browser.
- *
- * Caller must release result.error_message via native_url_open_result_free().
- */
+FFI_PLUGIN_EXPORT
+bool native_url_opener_can_open(const char* url);
+
 FFI_PLUGIN_EXPORT
 native_url_open_result_t native_url_opener_open(const char* url);
 
-/**
- * @brief Free owned memory inside a native_url_open_result_t.
- */
 FFI_PLUGIN_EXPORT
-void native_url_open_result_free(native_url_open_result_t* result);
+void native_url_open_result_free(native_url_open_result_t* value);
 
 #ifdef __cplusplus
 }

src/platform/android/url_opener_android.cpp

@@ -1,31 +1,26 @@
 #include "../../url_opener.h"
-#include "../../url_opener_internal.h"
 
 namespace nativeapi {
 namespace {
 
-UrlLaunchOutcome LaunchUnsupported(const std::string& url) {
-  (void)url;
-  return {false, "URL opening is not implemented on Android in this native layer."};
-}
+class AndroidUrlOpenerImpl final : public UrlOpener::Impl {
+ public:
+  bool IsSupported() const override { return false; }
 
-}  // namespace
+  UrlOpenResult Open(const std::string& url) const override {
+    (void)url;
+    UrlOpenResult result;
+    result.success = false;
+    result.error_code = UrlOpenErrorCode::kUnsupportedPlatform;
+    result.error_message = "URL opening is not implemented on Android in this native layer.";
+    return result;
+  }
+};
 
-UrlOpener& UrlOpener::GetInstance() {
-  static UrlOpener instance;
-  return instance;
-}
+}  // namespace
 
-bool UrlOpener::IsSupported() const {
-  return false;
-}
+UrlOpener::UrlOpener() : pimpl_(std::make_unique<AndroidUrlOpenerImpl>()) {}
 
-UrlOpenResult UrlOpener::Open(const std::string& url) const {
-  UrlOpenResult result = OpenUrlWithLauncher(url, LaunchUnsupported);
-  if (!result.success && result.error_code == UrlOpenErrorCode::kInvocationFailed) {
-    result.error_code = UrlOpenErrorCode::kUnsupportedPlatform;
-  }
-  return result;
-}
+UrlOpener::~UrlOpener() = default;
 
 }  // namespace nativeapi