diff --git a/.idea/workspace.xml b/.idea/workspace.xml
index a6a1075..802443c 100644
--- a/.idea/workspace.xml
+++ b/.idea/workspace.xml
@@ -1,5 +1,15 @@
+
+
+
+
+
+
+
+
+
+
@@ -22,24 +32,144 @@
-
-
-
-
-
-
-
-
+
-
-
-
-
+
+
+
+
+ 1712032984672
+
+
+
+ 1712032984672
+
+
+
+ 1712033684730
+
+
+
+ 1712033684730
+
+
+
+ 1712033915076
+
+
+
+ 1712033915076
+
+
+
+ 1712034831650
+
+
+
+ 1712034831650
+
+
+
+ 1712036156380
+
+
+
+ 1712036156381
+
+
+
+ 1712036709821
+
+
+
+ 1712036709821
+
+
+
+ 1712037345074
+
+
+
+ 1712037345074
+
+
+
+ 1712038254499
+
+
+
+ 1712038254499
+
+
+
+ 1712038492030
+
+
+
+ 1712038492030
+
+
+
+ 1712040024402
+
+
+
+ 1712040024402
+
+
+
+ 1712041636822
+
+
+
+ 1712041636822
+
+
+
+ 1712043126356
+
+
+
+ 1712043126356
+
+
+
+ 1712043149932
+
+
+
+ 1712043149932
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
+
\ No newline at end of file
diff --git a/lib/src/webview.dart b/lib/src/webview.dart
index 4b54810..ac86647 100644
--- a/lib/src/webview.dart
+++ b/lib/src/webview.dart
@@ -7,8 +7,8 @@ import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:flutter/widgets.dart';
-import 'enums.dart';
import 'cursor.dart';
+import 'enums.dart';
class HistoryChanged {
final bool canGoBack;
@@ -397,6 +397,47 @@ class WebviewController extends ValueNotifier {
return _methodChannel.invokeMethod('clearCookies');
}
+ /// Get browser cookies as a list of maps, each representing a cookie.
+ Future>> getCookies(String url) async {
+ if (_isDisposed) {
+ return [];
+ }
+ assert(value.isInitialized);
+ final dynamic result = await _methodChannel.invokeMethod('getCookies', url);
+ if (result is List) {
+ return result.map>((e) => Map.from(e)).toList();
+ } else {
+ return [];
+ }
+ }
+
+ /// Sets browser cookies.
+ Future setCookies(String url, Map cookies) async {
+ assert(value.isInitialized); // 确保 WebView 已经初始化
+ if (_isDisposed) {
+ return;
+ }
+
+ final cookiesMap = cookies.map((key, value) => MapEntry(key, value));
+
+ await _methodChannel.invokeMethod('setCookies', {
+ 'url': url,
+ 'cookies': cookiesMap,
+ });
+ }
+
+ /// Sets browser cookies with specific domains.
+ Future setCookiesWithDomains(Map> cookiesWithDomains) async {
+ assert(value.isInitialized); // 确保 WebView 已经初始化
+ if (_isDisposed) {
+ return;
+ }
+
+ await _methodChannel.invokeMethod('setCookiesWithDomains', {
+ 'cookiesWithDomains': cookiesWithDomains,
+ });
+ }
+
/// Clears browser cache.
Future clearCache() async {
if (_isDisposed) {
diff --git a/webview_windows.iml b/webview_windows.iml
index 0fbe6fd..9f6c1c2 100644
--- a/webview_windows.iml
+++ b/webview_windows.iml
@@ -12,7 +12,6 @@
-
diff --git a/windows/webview.cc b/windows/webview.cc
index 0de207a..e2534b2 100644
--- a/windows/webview.cc
+++ b/windows/webview.cc
@@ -417,6 +417,202 @@ bool Webview::ClearCookies() {
L"{}", nullptr) == S_OK;
}
+void Webview::GetCookies(const std::string& url, GetCookiesFullInfoCallback callback) {
+ if (IsValid()) {
+
+ wil::com_ptr cookieManager;
+ auto webview2 = webview_.try_query();
+ webview2->get_CookieManager(cookieManager.put());
+
+ if (SUCCEEDED(cookieManager->GetCookies(
+ util::Utf16FromUtf8(url).c_str(),
+ Callback(
+ [this, url, callback](
+ HRESULT error_code,
+ ICoreWebView2CookieList* list) -> HRESULT {
+ std::vector> cookies;
+
+ UINT cookie_list_size;
+ list->get_Count(&cookie_list_size);
+ for (UINT i = 0; i < cookie_list_size; ++i) {
+ wil::com_ptr cookie;
+ list->GetValueAtIndex(i, &cookie);
+
+ std::map cookieDetails;
+
+ // Get name
+ wil::unique_cotaskmem_string name;
+ cookie->get_Name(&name);
+ cookieDetails["name"] = util::Utf8FromUtf16(name.get());
+
+ // Get value
+ wil::unique_cotaskmem_string value;
+ cookie->get_Value(&value);
+ cookieDetails["value"] = util::Utf8FromUtf16(value.get());
+
+ // Get domain
+ wil::unique_cotaskmem_string domain;
+ cookie->get_Domain(&domain);
+ cookieDetails["domain"] = util::Utf8FromUtf16(domain.get());
+
+ // Get path
+ wil::unique_cotaskmem_string path;
+ cookie->get_Path(&path);
+ cookieDetails["path"] = util::Utf8FromUtf16(path.get());
+
+ // Get Expires
+ double expires;
+ cookie->get_Expires(&expires);
+ cookieDetails["expires"] = std::to_string(expires); // Expires is a timestamp
+
+ // Get IsSecure
+ BOOL isSecure;
+ cookie->get_IsSecure(&isSecure);
+ cookieDetails["is_secure"] = isSecure ? "true" : "false";
+
+ // Get IsSession
+ BOOL isSession;
+ cookie->get_IsSession(&isSession);
+ cookieDetails["is_session"] = isSession ? "true" : "false";
+
+ // Get IsHttpOnly
+ BOOL isHttpOnly;
+ cookie->get_IsHttpOnly(&isHttpOnly);
+ cookieDetails["is_http_only"] = isHttpOnly ? "true" : "false";
+
+ // Get SameSite
+ COREWEBVIEW2_COOKIE_SAME_SITE_KIND sameSite;
+ cookie->get_SameSite(&sameSite);
+ cookieDetails["same_site"] = std::to_string(sameSite); // SameSite is an enum
+
+ cookies.push_back(cookieDetails);
+ }
+
+ callback(SUCCEEDED(error_code), cookies);
+ return S_OK;
+ })
+ .Get()))) {
+ return;
+ }
+ }
+ // In case of failure or WebView not valid
+ callback(false, {});
+}
+
+
+void Webview::SetCookies(const std::string& originalUrl, const std::map& cookies, SetCookiesCallback callback) {
+ OutputDebugStringA("Attempting to set cookies.\n");
+
+ std::string domain = ExtractDomainFromUrl(originalUrl);
+
+ if (IsValid()) {
+ OutputDebugStringA("WebView is valid.\n");
+ wil::com_ptr cookieManager;
+ auto webview2 = webview_.try_query();
+ if (webview2) {
+ OutputDebugStringA("ICoreWebView2_2 interface is available.\n");
+ webview2->get_CookieManager(cookieManager.put());
+ if (cookieManager) {
+ OutputDebugStringA("CookieManager is obtained.\n");
+ HRESULT hr = S_OK;
+ for (const auto& pair : cookies) {
+ std::string cookieInfo = "Setting cookie: " + pair.first + " = " + pair.second + " for domain: " + domain + "\n";
+ OutputDebugStringA(cookieInfo.c_str());
+
+ wil::com_ptr cookie;
+ hr = cookieManager->CreateCookie(util::Utf16FromUtf8(pair.first).c_str(), util::Utf16FromUtf8(pair.second).c_str(), util::Utf16FromUtf8(domain).c_str(), L"/", &cookie);
+ if (FAILED(hr)) {
+ OutputDebugStringA("Failed to create a cookie.\n");
+ callback(false);
+ return;
+ }
+
+ hr = cookieManager->AddOrUpdateCookie(cookie.get());
+ if (FAILED(hr)) {
+ OutputDebugStringA("Failed to add or update a cookie.\n");
+ callback(false);
+ return;
+ }
+ }
+
+ OutputDebugStringA("Cookies set successfully.\n");
+ callback(true);
+ return;
+ } else {
+ OutputDebugStringA("Failed to obtain CookieManager.\n");
+ callback(false);
+ }
+ } else {
+ OutputDebugStringA("ICoreWebView2_2 interface is not available.\n");
+ callback(false);
+ }
+ } else {
+ OutputDebugStringA("WebView is not valid.\n");
+ callback(false);
+ }
+}
+
+void Webview::SetCookiesWithDomains(const std::map>& cookiesWithDomains, SetCookiesCallback callback) {
+ if (!IsValid()) {
+ OutputDebugStringA("WebView is not valid.\n");
+ callback(false);
+ return;
+ }
+
+ wil::com_ptr cookieManager;
+ auto webview2 = webview_.try_query();
+ if (!webview2) {
+ OutputDebugStringA("ICoreWebView2_2 interface is not available.\n");
+ callback(false);
+ return;
+ }
+
+ webview2->get_CookieManager(cookieManager.put());
+ if (!cookieManager) {
+ OutputDebugStringA("Failed to obtain CookieManager.\n");
+ callback(false);
+ return;
+ }
+
+ HRESULT hr = S_OK;
+ for (const auto& domainAndCookies : cookiesWithDomains) {
+ const std::string& domain = domainAndCookies.first;
+ for (const auto& nameAndValue : domainAndCookies.second) {
+ wil::com_ptr cookie;
+ hr = cookieManager->CreateCookie(util::Utf16FromUtf8(nameAndValue.first).c_str(), util::Utf16FromUtf8(nameAndValue.second).c_str(), util::Utf16FromUtf8(domain).c_str(), L"/", &cookie);
+ if (FAILED(hr)) {
+ OutputDebugStringA(("Failed to create a cookie for domain: " + domain + "\n").c_str());
+ callback(false);
+ return;
+ }
+
+ hr = cookieManager->AddOrUpdateCookie(cookie.get());
+ if (FAILED(hr)) {
+ OutputDebugStringA(("Failed to add or update a cookie for domain: " + domain + "\n").c_str());
+ callback(false);
+ return;
+ }
+ }
+ }
+
+ OutputDebugStringA("Cookies set successfully for multiple domains.\n");
+ callback(true);
+}
+
+std::string Webview::ExtractDomainFromUrl(const std::string& url) {
+ auto pos = url.find("://");
+ if (pos != std::string::npos) {
+ pos += 3;
+ } else {
+ pos = 0;
+ }
+
+ auto endPos = url.find('/', pos);
+ std::string domain = (endPos != std::string::npos) ? url.substr(pos, endPos - pos) : url.substr(pos);
+
+ return domain;
+}
+
bool Webview::ClearCache() {
if (!IsValid()) {
return false;
diff --git a/windows/webview.h b/windows/webview.h
index 567e742..3310132 100644
--- a/windows/webview.h
+++ b/windows/webview.h
@@ -107,6 +107,8 @@ class Webview {
typedef std::function
AddScriptToExecuteOnDocumentCreatedCallback;
typedef std::function ScriptExecutedCallback;
+ typedef std::function>& cookies)> GetCookiesFullInfoCallback;
+ typedef std::function SetCookiesCallback;
typedef std::function WebMessageReceivedCallback;
typedef std::function
WebviewPermissionRequestedCompleter;
@@ -145,6 +147,10 @@ class Webview {
ScriptExecutedCallback callback);
bool PostWebMessage(const std::string& json);
bool ClearCookies();
+ void GetCookies(const std::string& url,GetCookiesFullInfoCallback callback);
+ void SetCookiesWithDomains(const std::map>& cookiesWithDomains, SetCookiesCallback callback);
+ void SetCookies(const std::string& url, const std::map& cookies, SetCookiesCallback callback);
+ std::string ExtractDomainFromUrl(const std::string& url);
bool ClearCache();
bool SetCacheDisabled(bool disabled);
void SetPopupWindowPolicy(WebviewPopupWindowPolicy policy);
diff --git a/windows/webview_bridge.cc b/windows/webview_bridge.cc
index 6ea5b7d..b6388a9 100644
--- a/windows/webview_bridge.cc
+++ b/windows/webview_bridge.cc
@@ -37,6 +37,9 @@ constexpr auto kMethodSetVirtualHostNameMapping = "setVirtualHostNameMapping";
constexpr auto kMethodClearVirtualHostNameMapping =
"clearVirtualHostNameMapping";
constexpr auto kMethodClearCookies = "clearCookies";
+constexpr auto kMethodGetCookies = "getCookies";
+constexpr auto kMethodSetCookies = "setCookies";
+constexpr auto kMethodSetCookiesWithDomains = "setCookiesWithDomains";
constexpr auto kMethodClearCache = "clearCache";
constexpr auto kMethodSetCacheDisabled = "setCacheDisabled";
constexpr auto kMethodSetPopupWindowPolicy = "setPopupWindowPolicy";
@@ -627,6 +630,98 @@ void WebviewBridge::HandleMethodCall(
return result->Error(kMethodFailed);
}
+ // getCookies
+ if (method_name.compare(kMethodGetCookies) == 0) {
+ if (const auto url = std::get_if(method_call.arguments())) {
+ std::shared_ptr> shared_result = std::move(result);
+ webview_->GetCookies(
+ *url, [shared_result](bool success, const std::vector>& cookies) {
+ if (success) {
+ flutter::EncodableList cookiesList;
+ for (const auto& cookie : cookies) {
+ flutter::EncodableMap cookieMap;
+ for (const auto& field : cookie) {
+ cookieMap[flutter::EncodableValue(field.first)] = flutter::EncodableValue(field.second);
+ }
+ cookiesList.push_back(flutter::EncodableValue(cookieMap));
+ }
+ shared_result->Success(flutter::EncodableValue(cookiesList));
+ } else {
+ shared_result->Error(kScriptFailed, "getCookies failed.");
+ }
+ });
+ return;
+ }
+ return result->Error(kErrorInvalidArgs);
+ }
+
+ // setCookies
+ if (method_name.compare(kMethodSetCookies) == 0) {
+ const auto* args_map = std::get_if(method_call.arguments());
+ if (args_map) {
+ std::shared_ptr>
+ shared_result = std::move(result);
+ const auto url_it = args_map->find(flutter::EncodableValue("url"));
+ const auto cookies_it = args_map->find(flutter::EncodableValue("cookies"));
+ if (url_it != args_map->end() && cookies_it != args_map->end()) {
+ const auto& url = std::get(url_it->second);
+
+ std::map cookies;
+ const auto& cookiesMap = std::get(cookies_it->second);
+ for (const auto& pair : cookiesMap) {
+ const auto& key = std::get(pair.first);
+ const auto& value = std::get(pair.second);
+ cookies[key] = value;
+ }
+ webview_->SetCookies(url, cookies, [shared_result](bool success) {
+ if (success) {
+ shared_result->Success();
+ } else {
+ shared_result->Error("SetCookiesFailed", "Failed to set cookies.");
+ }
+ });
+ return;
+ }
+ }
+ result->Error("InvalidArguments", "Invalid arguments for 'setCookies'. Expected 'url' and 'cookies'.");
+ }
+
+ if (method_name.compare(kMethodSetCookiesWithDomains) == 0) {
+ const auto* args_map = std::get_if(method_call.arguments());
+ if (args_map) {
+ std::shared_ptr> shared_result = std::move(result);
+ const auto cookies_it = args_map->find(flutter::EncodableValue("cookiesWithDomains"));
+ if (cookies_it != args_map->end()) {
+ const auto& cookiesWithDomainsMap = std::get(cookies_it->second);
+ std::map> cookiesWithDomains;
+
+ for (const auto& domainPair : cookiesWithDomainsMap) {
+ const auto& domain = std::get(domainPair.first);
+ const auto& cookiesMap = std::get(domainPair.second);
+
+ std::map cookies;
+ for (const auto& cookiePair : cookiesMap) {
+ const auto& cookieName = std::get(cookiePair.first);
+ const auto& cookieValue = std::get(cookiePair.second);
+ cookies[cookieName] = cookieValue;
+ }
+
+ cookiesWithDomains[domain] = cookies;
+ }
+
+ webview_->SetCookiesWithDomains(cookiesWithDomains, [shared_result](bool success) {
+ if (success) {
+ shared_result->Success();
+ } else {
+ shared_result->Error("SetCookiesWithDomainsFailed", "Failed to set cookies with domains.");
+ }
+ });
+ return;
+ }
+ }
+ result->Error("InvalidArguments", "Invalid arguments for 'setCookiesWithDomains'.");
+ }
+
// clearCache
if (method_name.compare(kMethodClearCache) == 0) {
if (webview_->ClearCache()) {