Posso configurar os cookies para serem usados ​​por um WKWebView?

Estou tentando mudar um aplicativo existente de UIWebViewpara WKWebView. O aplicativo atual gerencia o login / sessão do usuário fora do webviewe define o cookiesnecessário para autenticação no NSHTTPCookieStore. Infelizmente o novo WKWebViewnão usa o cookiesde NSHTTPCookieStorage. Existe outra maneira de conseguir isso?

Editar apenas para iOS 11 ou superior

Use WKHTTPCookieStore :

let cookie = HTTPCookie(properties: [
    .domain: "example.com",
    .path: "/",
    .name: "MyCookieName",
    .value: "MyCookieValue",
    .secure: "TRUE",
    .expires: NSDate(timeIntervalSinceNow: 31556926)
])! 

webView.configuration.websiteDataStore.httpCookieStore.setCookie(cookie)

Como você está puxando-os do HTTPCookeStorage, você pode fazer isso:

let cookies = HTTPCookieStorage.shared.cookies ?? []
for cookie in cookies {
    webView.configuration.websiteDataStore.httpCookieStore.setCookie(cookie)
}

Resposta antiga para iOS 10 e abaixo

Se você precisar que seus cookies sejam definidos na solicitação de carregamento inicial, será possível configurá-los em NSMutableURLRequest. Como os cookies são apenas um cabeçalho de solicitação especialmente formatado, isso pode ser alcançado da seguinte maneira:

WKWebView * webView = /*set up your webView*/
NSMutableURLRequest * request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"http://example.com/index.html"]];
[request addValue:@"TeskCookieKey1=TeskCookieValue1;TeskCookieKey2=TeskCookieValue2;" forHTTPHeaderField:@"Cookie"];
// use stringWithFormat: in the above line to inject your values programmatically
[webView loadRequest:request];

Se você solicitar que as solicitações AJAX subseqüentes na página tenham seus cookies definidos, isso pode ser alcançado simplesmente usando WKUserScript para definir os valores programaticamente via javascript no início do documento, da seguinte maneira:

WKUserContentController* userContentController = WKUserContentController.new;
WKUserScript * cookieScript = [[WKUserScript alloc] 
    initWithSource: @"document.cookie = 'TeskCookieKey1=TeskCookieValue1';document.cookie = 'TeskCookieKey2=TeskCookieValue2';"
    injectionTime:WKUserScriptInjectionTimeAtDocumentStart forMainFrameOnly:NO];
// again, use stringWithFormat: in the above line to inject your values programmatically
[userContentController addUserScript:cookieScript];
WKWebViewConfiguration* webViewConfig = WKWebViewConfiguration.new;
webViewConfig.userContentController = userContentController;
WKWebView * webView = [[WKWebView alloc] initWithFrame:CGRectMake(/*set your values*/) configuration:webViewConfig];

A combinação dessas duas técnicas deve fornecer ferramentas suficientes para transferir valores de cookies do Native App Land para o Web View Land. Você pode encontrar mais informações na API de cookies javascript na página da Mozilla se precisar de alguns cookies mais avançados.

Sim, é péssimo que a Apple não suporte muitas das vantagens do UIWebView . Não tenho certeza se eles irão apoiá-los, mas espero que eles continuem com isso em breve. Espero que isto ajude!

Depois de jogar com esta resposta (que foi extraordinariamente útil :), tivemos que fazer algumas alterações:

• Precisamos de visualizações da web para lidar com vários domínios sem vazar informações de cookies particulares entre esses domínios
• Precisamos honrar cookies seguros
• Se o servidor alterar um valor de cookie, queremos que nosso aplicativo saiba sobre ele em NSHTTPCookieStorage
• Se o servidor alterar um valor de cookie, não queremos que nossos scripts o redefinam para seu valor original quando você segue um link / AJAX etc.

Então, modificamos nosso código para ser esse;

Criando uma solicitação

NSMutableURLRequest *request = [originalRequest mutableCopy];
NSString *validDomain = request.URL.host;
const BOOL requestIsSecure = [request.URL.scheme isEqualToString:@"https"];

NSMutableArray *array = [NSMutableArray array];
for (NSHTTPCookie *cookie in [[NSHTTPCookieStorage sharedHTTPCookieStorage] cookies]) {
    // Don't even bother with values containing a `'`
    if ([cookie.name rangeOfString:@"'"].location != NSNotFound) {
        NSLog(@"Skipping %@ because it contains a '", cookie.properties);
        continue;
    }

    // Is the cookie for current domain?
    if (![cookie.domain hasSuffix:validDomain]) {
        NSLog(@"Skipping %@ (because not %@)", cookie.properties, validDomain);
        continue;
    }

    // Are we secure only?
    if (cookie.secure && !requestIsSecure) {
        NSLog(@"Skipping %@ (because %@ not secure)", cookie.properties, request.URL.absoluteString);
        continue;
    }

    NSString *value = [NSString stringWithFormat:@"%@=%@", cookie.name, cookie.value];
    [array addObject:value];
}

NSString *header = [array componentsJoinedByString:@";"];
[request setValue:header forHTTPHeaderField:@"Cookie"];

// Now perform the request...

Isso garante que a primeira solicitação tenha os cookies corretos definidos, sem enviar cookies do armazenamento compartilhado para outros domínios e sem enviar cookies seguros para uma solicitação não segura.

Lidar com pedidos adicionais

Também precisamos garantir que outras solicitações tenham os cookies definidos. Isso é feito usando um script que é executado em carga documento que verifica para ver se há um conjunto de cookies e se não, defina-o para o valor NSHTTPCookieStorage.

// Get the currently set cookie names in javascriptland
[script appendString:@"var cookieNames = document.cookie.split('; ').map(function(cookie) { return cookie.split('=')[0] } );\n"];

for (NSHTTPCookie *cookie in [[NSHTTPCookieStorage sharedHTTPCookieStorage] cookies]) {
    // Skip cookies that will break our script
    if ([cookie.value rangeOfString:@"'"].location != NSNotFound) {
        continue;
    }

    // Create a line that appends this cookie to the web view's document's cookies
    [script appendFormat:@"if (cookieNames.indexOf('%@') == -1) { document.cookie='%@'; };\n", cookie.name, cookie.wn_javascriptString];
}

WKUserContentController *userContentController = [[WKUserContentController alloc] init];
WKUserScript *cookieInScript = [[WKUserScript alloc] initWithSource:script
                                                      injectionTime:WKUserScriptInjectionTimeAtDocumentStart
                                                   forMainFrameOnly:NO];
[userContentController addUserScript:cookieInScript];

...

// Create a config out of that userContentController and specify it when we create our web view.
WKWebViewConfiguration *config = [[WKWebViewConfiguration alloc] init];
config.userContentController = userContentController;

self.webView = [[WKWebView alloc] initWithFrame:webView.bounds configuration:config];

Lidando com alterações de cookies

Também precisamos lidar com o servidor alterando o valor de um cookie. Isso significa adicionar outro script para retornar à visualização na web que estamos criando para atualizar nossa NSHTTPCookieStorage.

WKUserScript *cookieOutScript = [[WKUserScript alloc] initWithSource:@"window.webkit.messageHandlers.updateCookies.postMessage(document.cookie);"
                                                       injectionTime:WKUserScriptInjectionTimeAtDocumentStart
                                                    forMainFrameOnly:NO];
[userContentController addUserScript:cookieOutScript];

[userContentController addScriptMessageHandler:webView
                                          name:@"updateCookies"];

e implementando o método delegate para atualizar os cookies que foram alterados, certificando-se de que estamos atualizando apenas os cookies do domínio atual!

- (void)userContentController:(WKUserContentController *)userContentController didReceiveScriptMessage:(WKScriptMessage *)message {
    NSArray<NSString *> *cookies = [message.body componentsSeparatedByString:@"; "];
    for (NSString *cookie in cookies) {
        // Get this cookie's name and value
        NSArray<NSString *> *comps = [cookie componentsSeparatedByString:@"="];
        if (comps.count < 2) {
            continue;
        }

        // Get the cookie in shared storage with that name
        NSHTTPCookie *localCookie = nil;
        for (NSHTTPCookie *c in [[NSHTTPCookieStorage sharedHTTPCookieStorage] cookiesForURL:self.wk_webView.URL]) {
            if ([c.name isEqualToString:comps[0]]) {
                localCookie = c;
                break;
            }
        }

        // If there is a cookie with a stale value, update it now.
        if (localCookie) {
            NSMutableDictionary *props = [localCookie.properties mutableCopy];
            props[NSHTTPCookieValue] = comps[1];
            NSHTTPCookie *updatedCookie = [NSHTTPCookie cookieWithProperties:props];
            [[NSHTTPCookieStorage sharedHTTPCookieStorage] setCookie:updatedCookie];
        }
    }
}

Isso parece resolver nossos problemas de cookies sem precisar lidar com cada local em que usamos o WKWebView de maneira diferente. Agora, podemos apenas usar esse código como um auxiliar para criar nossas visualizações da Web e ele é atualizado de forma transparente NSHTTPCookieStorage.

Edição: Acontece que eu usei uma categoria privada no NSHTTPCookie - aqui está o código:

- (NSString *)wn_javascriptString {
    NSString *string = [NSString stringWithFormat:@"%@=%@;domain=%@;path=%@",
                        self.name,
                        self.value,
                        self.domain,
                        self.path ?: @"/"];

    if (self.secure) {
        string = [string stringByAppendingString:@";secure=true"];
    }

    return string;
}

Os cookies devem ser definidos na configuração antes da WKWebViewcriação. Caso contrário, mesmo com WKHTTPCookieStoreo setCookiemanipulador de conclusão, os cookies não serão sincronizados de maneira confiável com a visualização da web. Isso remonta a essa linha nos documentos emWKWebViewConfiguration

@NSCopying var configuration: WKWebViewConfiguration { get }

Isso @NSCopyingé uma cópia profunda. A implementação está além de mim, mas o resultado final é que, a menos que você defina cookies antes de inicializar a visualização na web, não poderá contar com a presença dos cookies. Isso pode complicar a arquitetura do aplicativo, pois a inicialização de uma exibição se torna um processo assíncrono. Você vai acabar com algo assim

extension WKWebViewConfiguration {
    /// Async Factory method to acquire WKWebViewConfigurations packaged with system cookies
    static func cookiesIncluded(completion: @escaping (WKWebViewConfiguration?) -> Void) {
        let config = WKWebViewConfiguration()
        guard let cookies = HTTPCookieStorage.shared.cookies else {
            completion(config)
            return
        }
        // Use nonPersistent() or default() depending on if you want cookies persisted to disk
        // and shared between WKWebViews of the same app (default), or not persisted and not shared
        // across WKWebViews in the same app.
        let dataStore = WKWebsiteDataStore.nonPersistent()
        let waitGroup = DispatchGroup()
        for cookie in cookies {
            waitGroup.enter()
            dataStore.httpCookieStore.setCookie(cookie) { waitGroup.leave() }
        }
        waitGroup.notify(queue: DispatchQueue.main) {
            config.websiteDataStore = dataStore
            completion(config)
        }
    }
}

e então usar algo como

override func loadView() {
    view = UIView()
    WKWebViewConfiguration.cookiesIncluded { [weak self] config in
        let webView = WKWebView(frame: .zero, configuration: webConfiguration)
        webView.load(request)
        self.view = webView
    }
}

O exemplo acima adia a criação de visualizações até o último momento possível; outra solução seria criar a configuração ou a visualização na Web com bastante antecedência e lidar com a natureza assíncrona antes da criação de um controlador de exibição.

Uma observação final: depois de criar essa visualização na Web, você a soltou na natureza, não poderá adicionar mais cookies sem usar os métodos descritos nesta resposta . No entanto, você pode usar a WKHTTPCookieStoreObserverAPI para observar pelo menos as alterações ocorridas nos cookies. Portanto, se um cookie de sessão for atualizado na visualização da web, você poderá atualizar manualmente o sistema HTTPCookieStoragecom esse novo cookie, se desejar.

Para saber mais, pule para as 18:00 neste carregamento personalizado de conteúdo da web da sessão da WWDC de 2017 . No início desta sessão, há um exemplo de código enganoso que omite o fato de que a visualização da web deve ser criada no manipulador de conclusão.

cookieStore.setCookie(cookie!) {
    webView.load(loggedInURLRequest)
}

A demonstração ao vivo às 18:00 esclarece isso.

Editar No Mojave Beta 7 e iOS 12 Beta 7, pelo menos, estou vendo um comportamento muito mais consistente com os cookies. O setCookie(_:)método até parece permitir a configuração de cookies após a WKWebViewcriação. Mas achei importante não tocar na processPoolvariável. A funcionalidade de configuração de cookie funciona melhor quando nenhum pool adicional é criado e quando essa propriedade é deixada em paz. Eu acho que é seguro dizer que estávamos tendo problemas devido a alguns erros no WebKit.

trabalhe para mim

func webView(webView: WKWebView, decidePolicyForNavigationAction navigationAction: WKNavigationAction, decisionHandler: (WKNavigationActionPolicy) -> Void) {
    let headerFields = navigationAction.request.allHTTPHeaderFields
    var headerIsPresent = contains(headerFields?.keys.array as! [String], "Cookie")

    if headerIsPresent {
        decisionHandler(WKNavigationActionPolicy.Allow)
    } else {
        let req = NSMutableURLRequest(URL: navigationAction.request.URL!)
        let cookies = yourCookieData
        let values = NSHTTPCookie.requestHeaderFieldsWithCookies(cookies)
        req.allHTTPHeaderFields = values
        webView.loadRequest(req)

        decisionHandler(WKNavigationActionPolicy.Cancel)
    }
}

Aqui está minha versão da solução Mattrs no Swift para injetar todos os cookies do HTTPCookieStorage. Isso foi feito principalmente para injetar um cookie de autenticação para criar uma sessão do usuário.

public func setupWebView() {
    let userContentController = WKUserContentController()
    if let cookies = HTTPCookieStorage.shared.cookies {
        let script = getJSCookiesString(for: cookies)
        let cookieScript = WKUserScript(source: script, injectionTime: .atDocumentStart, forMainFrameOnly: false)
        userContentController.addUserScript(cookieScript)
    }
    let webViewConfig = WKWebViewConfiguration()
    webViewConfig.userContentController = userContentController

    self.webView = WKWebView(frame: self.webViewContainer.bounds, configuration: webViewConfig)
}

///Generates script to create given cookies
public func getJSCookiesString(for cookies: [HTTPCookie]) -> String {
    var result = ""
    let dateFormatter = DateFormatter()
    dateFormatter.timeZone = TimeZone(abbreviation: "UTC")
    dateFormatter.dateFormat = "EEE, d MMM yyyy HH:mm:ss zzz"

    for cookie in cookies {
        result += "document.cookie='\(cookie.name)=\(cookie.value); domain=\(cookie.domain); path=\(cookie.path); "
        if let date = cookie.expiresDate {
            result += "expires=\(dateFormatter.stringFromDate(date)); "
        }
        if (cookie.secure) {
            result += "secure; "
        }
        result += "'; "
    }
    return result
}

definir cookie

self.webView.evaluateJavaScript("document.cookie='access_token=your token';domain='your domain';") { (data, error) -> Void in
        self.webView.reload()
}

excluir cookie

self.webView.evaluateJavaScript("document.cookie='access_token=';domain='your domain';") { (data, error) -> Void in
        self.webView.reload()
}

Atualização Swift 3:

func webView(_ webView: WKWebView, decidePolicyFor navigationResponse: WKNavigationResponse, decisionHandler: @escaping (WKNavigationResponsePolicy) -> Void) {
    if let urlResponse = navigationResponse.response as? HTTPURLResponse,
       let url = urlResponse.url,
       let allHeaderFields = urlResponse.allHeaderFields as? [String : String] {
       let cookies = HTTPCookie.cookies(withResponseHeaderFields: allHeaderFields, for: url)
       HTTPCookieStorage.shared.setCookies(cookies , for: urlResponse.url!, mainDocumentURL: nil)
       decisionHandler(.allow)
    }
}

Depois de analisar várias respostas aqui e não ter sucesso, vasculhei a documentação do WebKit e deparei-me com o requestHeaderFieldsmétodo estático HTTPCookie, que converte uma matriz de cookies em um formato adequado para um campo de cabeçalho. Combinar isso com o insight do mattr de atualizar o URLRequestantes de carregá-lo com os cabeçalhos dos cookies me levou até a linha de chegada.

Swift 4.1, 4.2, 5.0:

var request = URLRequest(url: URL(string: "https://example.com/")!)
let headers = HTTPCookie.requestHeaderFields(with: cookies)
for (name, value) in headers {
    request.addValue(value, forHTTPHeaderField: name)
}

let webView = WKWebView(frame: self.view.frame)
webView.load(request)

Para tornar isso ainda mais simples, use uma extensão:

extension WKWebView {
    func load(_ request: URLRequest, with cookies: [HTTPCookie]) {
        var request = request
        let headers = HTTPCookie.requestHeaderFields(with: cookies)
        for (name, value) in headers {
            request.addValue(value, forHTTPHeaderField: name)
        }

        load(request)
    }
}

Agora, apenas se torna:

let request = URLRequest(url: URL(string: "https://example.com/")!)
let webView = WKWebView(frame: self.view.frame)
webView.load(request, with: cookies)

Esta extensão também está disponível no LionheartExtensions se você deseja apenas uma solução drop-in. Felicidades!

No iOS 11, você pode gerenciar o cookie agora :), consulte esta sessão: https://developer.apple.com/videos/play/wwdc2017/220/

A razão por trás da postagem desta resposta é que eu tentei muitas soluções, mas ninguém funciona corretamente, a maioria das respostas não funciona no caso em que é necessário definir o cookie pela primeira vez e o resultado obtido não é sincronizado pela primeira vez. Use esta solução para ambos iOS> = 11.0 <= iOS 11 até 8.0, também funciona com sincronização de cookies pela primeira vez.

Para iOS> = 11.0 - Swift 4.2

Obtenha cookies http e defina na loja de cookies wkwebview dessa maneira, é um ponto muito complicado para carregar sua solicitação no wkwebview , deve-se enviar uma solicitação para carregar quando os cookies serão definidos completamente, aqui está a função que eu escrevi.

Chamar a função com o fechamento concluído, você chama carregar a webview. Para sua informação, esta função suporta apenas iOS> = 11.0

self.WwebView.syncCookies {
    if let request = self.request {
       self.WwebView.load(request)
    }
}

Aqui está a implementação da função syncCookies .

func syncCookies(completion:@escaping ()->Void) {

if #available(iOS 11.0, *) {

      if let yourCookie = "HERE_YOUR_HTTP_COOKIE_OBJECT" {
        self.configuration.websiteDataStore.httpCookieStore.setCookie(yourCookie, completionHandler: {
              completion()
        })
     }
  } else {
  //Falback just sent 
  completion()
}
}

Para iOS 8 até iOS 11

você precisa configurar algumas coisas extras para definir dois cookies únicos, usando o WKUserScript e também não se esqueça de adicionar cookies no pedido, caso contrário, o cookie não será sincronizado pela primeira vez e você verá que a página não será carregada corretamente pela primeira vez. este é o diabo que eu encontrei para suportar cookies para iOS 8.0

antes de criar o objeto Wkwebview.

func setUpWebView() {

    let userController: WKUserContentController = WKUserContentController.init()

    if IOSVersion.SYSTEM_VERSION_LESS_THAN(version: "11.0") {
        if let cookies = HTTPCookieStorage.shared.cookies {
            if let script = getJSCookiesString(for: cookies) {
                cookieScript = WKUserScript(source: script, injectionTime: .atDocumentStart, forMainFrameOnly: false)
                userController.addUserScript(cookieScript!)
            }
        }
    }

    let webConfiguration = WKWebViewConfiguration()
    webConfiguration.processPool = BaseWebViewController.processPool


    webConfiguration.userContentController = userController


    let customFrame = CGRect.init(origin: CGPoint.zero, size: CGSize.init(width: 0.0, height: self.webContainerView.frame.size.height))
    self.WwebView = WKWebView (frame: customFrame, configuration: webConfiguration)
    self.WwebView.translatesAutoresizingMaskIntoConstraints = false
    self.webContainerView.addSubview(self.WwebView)
    self.WwebView.uiDelegate = self
    self.WwebView.navigationDelegate = self
    self.WwebView.allowsBackForwardNavigationGestures = true // A Boolean value indicating whether horizontal swipe gestures will trigger back-forward list navigations
    self.WwebView.addObserver(self, forKeyPath: #keyPath(WKWebView.estimatedProgress), options: .new, context: nil)


 self.view.addConstraint(NSLayoutConstraint(item: WwebView, attribute: .trailing, relatedBy: .equal, toItem: self.webContainerView, attribute: .trailing, multiplier: 1, constant: 0))
    self.view.addConstraint(NSLayoutConstraint(item: WwebView, attribute: .leading, relatedBy: .equal, toItem: self.webContainerView, attribute: .leading, multiplier: 1, constant: 0))
    self.view.addConstraint(NSLayoutConstraint(item: WwebView, attribute: .top, relatedBy: .equal, toItem: self.webContainerView, attribute: .top, multiplier: 1, constant: 0))
    self.view.addConstraint(NSLayoutConstraint(item: WwebView, attribute: .bottom, relatedBy: .equal, toItem: self.webContainerView, attribute: .bottom, multiplier: 1, constant: 0))


}

Concentre-se nessa função getJSCookiesString

 public func getJSCookiesString(for cookies: [HTTPCookie]) -> String? {

    var result = ""
    let dateFormatter = DateFormatter()
    dateFormatter.timeZone = TimeZone(abbreviation: "UTC")
    dateFormatter.dateFormat = "EEE, d MMM yyyy HH:mm:ss zzz"

    for cookie in cookies {
        if cookie.name == "yout_cookie_name_want_to_sync" {
            result += "document.cookie='\(cookie.name)=\(cookie.value); domain=\(cookie.domain); path=\(cookie.path); "
            if let date = cookie.expiresDate {
                result += "expires=\(dateFormatter.string(from: date)); "
            }
            if (cookie.isSecure) {
                result += "secure; "
            }
            result += "'; "
        }

    }

    return result
}

Aqui está outra etapa em que o wkuserscript não sincroniza os cookies imediatamente; há muitas coisas para carregar a primeira página com o cookie 1: recarregar a visualização na web novamente se ela terminar o processo, mas eu não recomendo usá-la, isso não é bom para o ponto de vista do usuário , heck, sempre que você estiver pronto para carregar os cookies do conjunto de solicitações no cabeçalho da solicitação, assim, não esqueça de adicionar a verificação de versão do iOS. antes da solicitação de carregamento, chame esta função.

request?.addCookies()

eu escrevi extensão para URLRequest

extension URLRequest {

internal mutating func addCookies() {
    //"appCode=anAuY28ucmFrdXRlbi5yZXdhcmQuaW9zLXpOQlRTRmNiejNHSzR0S0xuMGFRb0NjbUg4Ql9JVWJH;rpga=kW69IPVSYZTo0JkZBicUnFxC1g5FtoHwdln59Z5RNXgJoMToSBW4xAMqtf0YDfto;rewardadid=D9F8CE68-CF18-4EE6-A076-CC951A4301F6;rewardheader=true"
    var cookiesStr: String = ""

    if IOSVersion.SYSTEM_VERSION_LESS_THAN(version: "11.0") {
        let mutableRequest = ((self as NSURLRequest).mutableCopy() as? NSMutableURLRequest)!
        if let yourCookie = "YOUR_HTTP_COOKIE_OBJECT" {
            // if have more than one cookies dont forget to add ";" at end
            cookiesStr += yourCookie.name + "=" + yourCookie.value + ";"

            mutableRequest.setValue(cookiesStr, forHTTPHeaderField: "Cookie")
            self = mutableRequest as URLRequest

        }
    }

  }
}

agora você está pronto para testar o iOS> 8

Encontre a solução que provavelmente funcionará para você imediatamente. Basicamente, é modificado e atualizado para a resposta do Swift 4 @ user3589213 .

func webView(_ webView: WKWebView, decidePolicyFor navigationAction: WKNavigationAction, decisionHandler: @escaping (WKNavigationActionPolicy) -> Void) {
    let headerKeys = navigationAction.request.allHTTPHeaderFields?.keys
    let hasCookies = headerKeys?.contains("Cookie") ?? false

    if hasCookies {
        decisionHandler(.allow)
    } else {
        let cookies = HTTPCookie.requestHeaderFields(with: HTTPCookieStorage.shared.cookies ?? [])

        var headers = navigationAction.request.allHTTPHeaderFields ?? [:]
        headers += cookies

        var req = navigationAction.request
        req.allHTTPHeaderFields = headers

        webView.load(req)

        decisionHandler(.cancel)
    }
}

Eu tentei todas as respostas acima, mas nenhuma delas funciona. Após tantas tentativas, finalmente encontrei uma maneira confiável de definir o cookie WKWebview.

Primeiro, você deve criar uma instância do WKProcessPool e configurá-la como WKWebViewConfiguration que será usada para inicializar o próprio WkWebview:

    private lazy var mainWebView: WKWebView = {
        let webConfiguration = WKWebViewConfiguration()
        webConfiguration.processPool = WKProcessPool()
        let webView = WKWebView(frame: .zero, configuration: webConfiguration)
        webView.navigationDelegate = self
        return webView
    }()

A configuração do WKProcessPool é a etapa mais importante aqui. O WKWebview faz uso do isolamento do processo - o que significa que ele é executado em um processo diferente do processo do seu aplicativo. Às vezes, isso pode causar conflitos e impedir que seu cookie seja sincronizado corretamente com o WKWebview.

Agora, vejamos a definição de WKProcessPool

O conjunto de processos associado a uma visualização na web é especificado por sua configuração de visualização na web. Cada visualização da Web recebe seu próprio processo de Conteúdo da Web até que um limite de processo definido pela implementação seja atingido; depois disso, as exibições da Web com o mesmo pool de processos acabam compartilhando os processos de Conteúdo da Web.

Preste atenção na última frase se você planeja usar o mesmo WKWebview para solicitações subsequentes

visualizações da web com o mesmo conjunto de processos acabam compartilhando processos de conteúdo da web

o que quero dizer é que, se você não usar a mesma instância do WKProcessPool cada vez que configurar um WKWebView para o mesmo domínio (talvez você tenha um VC A que contém um WKWebView e deseje criar instâncias diferentes do VC A em locais diferentes ), pode haver cookies de configuração de conflito. Para resolver o problema, após a primeira criação do WKProcessPool para um WKWebView que carrega o domínio B, eu o salvo em um singleton e uso o mesmo WKProcessPool toda vez que tenho que criar um WKWebView que carrega o mesmo domínio B

private lazy var mainWebView: WKWebView = {
    let webConfiguration = WKWebViewConfiguration()
    if Enviroment.shared.processPool == nil {
        Enviroment.shared.processPool = WKProcessPool()
    }
    webConfiguration.processPool = Enviroment.shared.processPool!
    webConfiguration.processPool = WKProcessPool()
    let webView = WKWebView(frame: .zero, configuration: webConfiguration)
    webView.navigationDelegate = self
    return webView
}()

Após o processo de inicialização, você pode carregar um URLRequest dentro do bloco de conclusão de httpCookieStore.setCookie. Aqui, você deve anexar o cookie ao cabeçalho da solicitação, caso contrário não funcionará.

P / s: roubei a extensão da fantástica resposta acima de Dan Loewenherz

mainWebView.configuration.websiteDataStore.httpCookieStore.setCookie(your_cookie) {
        self.mainWebView.load(your_request, with: [your_cookie])
}

extension WKWebView {
   func load(_ request: URLRequest, with cookies: [HTTPCookie]) {
      var request = request
      let headers = HTTPCookie.requestHeaderFields(with: cookies)
      for (name, value) in headers {
         request.addValue(value, forHTTPHeaderField: name)
      }        
      load(request)
   }
}

Minha versão da resposta de nteiss. Testado em iOS 11, 12, 13. Parece que você não tem que usar DispatchGroupem iOS 13mais.

Eu uso função non-static includeCustomCookieson WKWebViewConfiguration, para que eu possa atualizar cookiescada vez que eu criar novos WKWebViewConfiguration.

extension WKWebViewConfiguration {
    func includeCustomCookies(cookies: [HTTPCookie], completion: @escaping  () -> Void) {
        let dataStore = WKWebsiteDataStore.nonPersistent()
        let waitGroup = DispatchGroup()

        for cookie in cookies {
            waitGroup.enter()
            dataStore.httpCookieStore.setCookie(cookie) { waitGroup.leave() }
        }

        waitGroup.notify(queue: DispatchQueue.main) {
            self.websiteDataStore = dataStore
            completion()
        }
    }
}

Então eu uso assim:

let customUserAgent: String = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_5) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.1.1 Safari/605.1.15"

let customCookies: [HTTPCookie] = {
    let cookie1 = HTTPCookie(properties: [
        .domain: "yourdomain.com",
        .path: "/",
        .name: "auth_token",
        .value: APIManager.authToken
    ])!

    let cookie2 = HTTPCookie(properties: [
        .domain: "yourdomain.com",
        .path: "/",
        .name: "i18next",
        .value: "ru"
    ])!

    return [cookie1, cookie2]
}()

override func viewDidLoad() {
    super.viewDidLoad()

    activityIndicatorView.startAnimating()

    let webConfiguration = WKWebViewConfiguration()
    webConfiguration.includeCustomCookies(cookies: customCookies, completion: { [weak self] in
        guard let strongSelf = self else { return }
        strongSelf.webView = WKWebView(frame: strongSelf.view.bounds, configuration: webConfiguration)
        strongSelf.webView.customUserAgent = strongSelf.customUserAgent
        strongSelf.webView.navigationDelegate = strongSelf
        strongSelf.webView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
        strongSelf.view.addSubview(strongSelf.webView)
        strongSelf.view.bringSubviewToFront(strongSelf.activityIndicatorView)
        strongSelf.webView.load(strongSelf.request)
    })
}

A melhor correção para solicitações XHR é mostrada aqui

Versão Swift 4:

func webView(_ webView: WKWebView, decidePolicyFor navigationResponse: WKNavigationResponse, decisionHandler: @escaping (WKNavigationResponsePolicy) -> Swift.Void) {
    guard
        let response = navigationResponse.response as? HTTPURLResponse,
        let url = navigationResponse.response.url
    else {
        decisionHandler(.cancel)
        return
    }

    if let headerFields = response.allHeaderFields as? [String: String] {
        let cookies = HTTPCookie.cookies(withResponseHeaderFields: headerFields, for: url)
        cookies.forEach { (cookie) in
            HTTPCookieStorage.shared.setCookie(cookie)
        }
    }

    decisionHandler(.allow)
}

Se alguém estiver usando o Alamofire, essa é a melhor solução.

  let cookies = Alamofire.SessionManager.default.session.configuration.httpCookieStorage?.cookies(for: URL(string: BASE_URL)!)
  for (cookie) in cookies ?? [] {
      webView.configuration.websiteDataStore.httpCookieStore.setCookie(cookie)
  }

Isso funciona para mim: Após setcookies, adicione fetchdatarecords

   let cookiesSet = NetworkProvider.getCookies(forKey : 
    PaywallProvider.COOKIES_KEY, completionHandler: nil)
                let dispatchGroup = DispatchGroup()
                for (cookie) in cookiesSet {
                    if #available(iOS 11.0, *) {
                        dispatchGroup.enter()
                        self.webView.configuration.websiteDataStore.httpCookieStore.setCookie(cookie){
                            dispatchGroup.leave()
                            print ("cookie added: \(cookie.description)")
                            }
                        } else {
                                            // TODO Handle ios 10 Fallback on earlier versions
                        }
                    }
                    dispatchGroup.notify(queue: .main, execute: {


    self.webView.configuration.websiteDataStore.fetchDataRecords(ofTypes: 
    WKWebsiteDataStore.allWebsiteDataTypes()) { records in
                            records.forEach { record in

                                print("[WebCacheCleaner] Record \(record)")
                            }
                            self.webView.load(URLRequest(url: 
    self.dataController.premiumArticleURL , 
    cachePolicy:NSURLRequest.CachePolicy.reloadIgnoringLocalAndRemoteCacheData,
                                                         timeoutInterval: 10.0))
                        }

                    })
                }

Ao adicionar itens de cookie multiplicados, você pode fazer o seguinte: ( pathe domainé necessário para cada item)

NSString *cookie = [NSString stringWithFormat:@"document.cookie = 'p1=%@;path=/;domain=your.domain;';document.cookie = 'p2=%@;path=/;domain=your.domain;';document.cookie = 'p3=%@;path=/;domain=your.domain;';", p1_string, p2_string, p3_string];

WKUserScript *cookieScript = [[WKUserScript alloc]
            initWithSource:cookie
            injectionTime:WKUserScriptInjectionTimeAtDocumentStart forMainFrameOnly:NO];

[userContentController addUserScript:cookieScript];

caso contrário, apenas o primeiro item do cookie será definido.

Você também pode usar o WKWebsiteDataStore para obter um comportamento semelhante ao HTTPCookieStorage no UIWebView.

let dataStore = WKWebsiteDataStore.default()
let cookies = HTTPCookieStorage.shared.cookies ?? [HTTPCookie]()
cookies.forEach({
    dataStore.httpCookieStore.setCookie($0, completionHandler: nil)
})

O código abaixo funciona bem no meu projeto Swift5. tente carregar o URL pelo WKWebView abaixo:

    private func loadURL(urlString: String) {
        let url = URL(string: urlString)
        guard let urlToLoad = url else { fatalError("Cannot find any URL") }

        // Cookies configuration
        var urlRequest = URLRequest(url: urlToLoad)
        if let cookies = HTTPCookieStorage.shared.cookies(for: urlToLoad) {
            let headers = HTTPCookie.requestHeaderFields(with: cookies)
            for header in headers { urlRequest.addValue(header.value, forHTTPHeaderField: header.key) }
        }

        webview.load(urlRequest)
    }

Esta é a minha solução para lidar com cookies e WKWebView no iOS 9 ou posterior.

import WebKit

extension WebView {

    enum LayoutMode {
        case fillContainer
    }

    func autoLayout(_ view: UIView?, mode: WebView.LayoutMode = .fillContainer) {
        guard let view = view else { return }
        self.translatesAutoresizingMaskIntoConstraints = false
        view.addSubview(self)

        switch mode {
        case .fillContainer:
                NSLayoutConstraint.activate([
                self.topAnchor.constraint(equalTo: view.topAnchor),
                self.leadingAnchor.constraint(equalTo: view.leadingAnchor),
                self.trailingAnchor.constraint(equalTo: view.trailingAnchor),
                self.bottomAnchor.constraint(equalTo: view.bottomAnchor)
            ])
        }
    }

}

class WebView : WKWebView {

    var request : URLRequest?

    func load(url: URL, useSharedCookies: Bool = false) {
        if useSharedCookies, let cookies = HTTPCookieStorage.shared.cookies(for: url) {
            self.load(url: url, withCookies: cookies)
        } else {
            self.load(URLRequest(url: url))
        }
    }

    func load(url: URL, withCookies cookies: [HTTPCookie]) {
        self.request = URLRequest(url: url)
        let headers = HTTPCookie.requestHeaderFields(with: cookies)
        self.request?.allHTTPHeaderFields = headers
        self.load(request!)
    }

}

Esse erro que eu estava cometendo era passar o URL inteiro no atributo de domínio, que deveria ser apenas o nome de domínio.

let cookie = HTTPCookie(properties: [
.domain: "example.com",
.path: "/",
.name: "MyCookieName",
.value: "MyCookieValue",
.secure: "TRUE",
])! 

webView.configuration.websiteDataStore.httpCookieStore.setCookie(cookie)