Eu estou usando uma instância de UIWebViewpara processar algum texto e colori-lo corretamente, ele fornece o resultado como HTML, mas em vez de exibi-lo no UIWebVieweu quero exibi-lo usando Core Textcom a NSAttributedString.

Sou capaz de criar e desenhar o, NSAttributedStringmas não tenho certeza de como posso converter e mapear o HTML na string atribuída.

Entendo que, no Mac OS X, NSAttributedStringexiste um initWithHTML:método, mas isso foi apenas uma adição ao Mac e não está disponível para iOS.

Sei também que existe uma pergunta semelhante a essa, mas ela não tinha respostas. Embora tentasse novamente, verificaria se alguém criou uma maneira de fazer isso e, em caso afirmativo, se poderia compartilhá-lo.

No iOS 7, o UIKit adicionou um initWithData:options:documentAttributes:error:método que pode inicializar um NSAttributedStringuso de HTML, por exemplo:

[[NSAttributedString alloc] initWithData:[htmlString dataUsingEncoding:NSUTF8StringEncoding] 
                                 options:@{NSDocumentTypeDocumentAttribute: NSHTMLTextDocumentType,
                                           NSCharacterEncodingDocumentAttribute: @(NSUTF8StringEncoding)} 
                      documentAttributes:nil error:nil];

Em Swift:

let htmlData = NSString(string: details).data(using: String.Encoding.unicode.rawValue)
let options = [NSAttributedString.DocumentReadingOptionKey.documentType:
        NSAttributedString.DocumentType.html]
let attributedString = try? NSMutableAttributedString(data: htmlData ?? Data(),
                                                          options: options,
                                                          documentAttributes: nil)

Há uma adição de código aberto de trabalho em andamento ao NSAttributedString de Oliver Drobnik no Github. Ele usa o NSScanner para análise de HTML.

A criação de um NSAttributedString a partir do HTML deve ser feita no thread principal!

Atualização: Acontece que a renderização HTML NSAttributedString depende do WebKit, e deve ser executada no thread principal ou ocasionalmente trava o aplicativo com um SIGTRAP .

Novo log de falha da Relic:

Abaixo está uma extensão atualizada do Swift 2 String segura para threads :

extension String {
    func attributedStringFromHTML(completionBlock:NSAttributedString? ->()) {
        guard let data = dataUsingEncoding(NSUTF8StringEncoding) else {
            print("Unable to decode data from html string: \(self)")
            return completionBlock(nil)
        }

        let options = [NSDocumentTypeDocumentAttribute : NSHTMLTextDocumentType,
                   NSCharacterEncodingDocumentAttribute: NSNumber(unsignedInteger:NSUTF8StringEncoding)]

        dispatch_async(dispatch_get_main_queue()) {
            if let attributedString = try? NSAttributedString(data: data, options: options, documentAttributes: nil) {
                completionBlock(attributedString)
            } else {
                print("Unable to create attributed string from html string: \(self)")
                completionBlock(nil)
            }
        }
    }
}

Uso:

let html = "<center>Here is some <b>HTML</b></center>"
html.attributedStringFromHTML { attString in
    self.bodyLabel.attributedText = attString
}

Resultado:

Extensão do inicializador Swift em NSAttributedString

Minha inclinação era adicionar isso como uma extensão ao NSAttributedStringinvés de String. Eu tentei como uma extensão estática e um inicializador. Eu prefiro o inicializador, que é o que eu incluí abaixo.

Swift 4

internal convenience init?(html: String) {
    guard let data = html.data(using: String.Encoding.utf16, allowLossyConversion: false) else {
        return nil
    }

    guard let attributedString = try?  NSAttributedString(data: data, options: [.documentType: NSAttributedString.DocumentType.html, .characterEncoding: String.Encoding.utf8.rawValue], documentAttributes: nil) else {
        return nil
    }

    self.init(attributedString: attributedString)
}

Swift 3

extension NSAttributedString {

internal convenience init?(html: String) {
    guard let data = html.data(using: String.Encoding.utf16, allowLossyConversion: false) else {
        return nil
    }

    guard let attributedString = try? NSMutableAttributedString(data: data, options: [NSAttributedString.DocumentReadingOptionKey.documentType: NSAttributedString.DocumentType.html], documentAttributes: nil) else {
        return nil
    }

    self.init(attributedString: attributedString)
}
}

Exemplo

let html = "<b>Hello World!</b>"
let attributedString = NSAttributedString(html: html)

Esta é uma Stringextensão escrita em Swift para retornar uma string HTML como NSAttributedString.

extension String {
    func htmlAttributedString() -> NSAttributedString? {
        guard let data = self.dataUsingEncoding(NSUTF16StringEncoding, allowLossyConversion: false) else { return nil }
        guard let html = try? NSMutableAttributedString(data: data, options: [NSDocumentTypeDocumentAttribute: NSHTMLTextDocumentType], documentAttributes: nil) else { return nil }
        return html
    }
}

Usar,

label.attributedText = "<b>Hello</b> \u{2022} babe".htmlAttributedString()

Acima, propositadamente, adicionei um unicode \ u2022 para mostrar que ele é renderizado corretamente.

Um trivial: a codificação padrão que NSAttributedStringusa é NSUTF16StringEncoding(não UTF8!).

Fiz algumas modificações na solução de Andrew e atualize o código para Swift 3:

Este código agora usa o UITextView como selfcapaz de herdar sua fonte original, tamanho da fonte e cor do texto

Nota: toHexString()é extensão daqui

extension UITextView {
    func setAttributedStringFromHTML(_ htmlCode: String, completionBlock: @escaping (NSAttributedString?) ->()) {
        let inputText = "\(htmlCode)<style>body { font-family: '\((self.font?.fontName)!)'; font-size:\((self.font?.pointSize)!)px; color: \((self.textColor)!.toHexString()); }</style>"

        guard let data = inputText.data(using: String.Encoding.utf16) else {
            print("Unable to decode data from html string: \(self)")
            return completionBlock(nil)
        }

        DispatchQueue.main.async {
            if let attributedString = try? NSAttributedString(data: data, options: [NSDocumentTypeDocumentAttribute: NSHTMLTextDocumentType], documentAttributes: nil) {
                self.attributedText = attributedString
                completionBlock(attributedString)
            } else {
                print("Unable to create attributed string from html string: \(self)")
                completionBlock(nil)
            }
        }
    }
}

Exemplo de uso:

mainTextView.setAttributedStringFromHTML("<i>Hello world!</i>") { _ in }

Versão Swift 3.0 Xcode 8

func htmlAttributedString() -> NSAttributedString? {
    guard let data = self.data(using: String.Encoding.utf16, allowLossyConversion: false) else { return nil }
    guard let html = try? NSMutableAttributedString(data: data, options: [NSDocumentTypeDocumentAttribute: NSHTMLTextDocumentType], documentAttributes: nil) else { return nil }
    return html
}

Swift 4

• Inicializador de conveniência NSAttributedString
• Sem guardas extras
• lança erro

extension NSAttributedString {

    convenience init(htmlString html: String) throws {
        try self.init(data: Data(html.utf8), options: [
            .documentType: NSAttributedString.DocumentType.html,
            .characterEncoding: String.Encoding.utf8.rawValue
        ], documentAttributes: nil)
    }

}

Uso

UILabel.attributedText = try? NSAttributedString(htmlString: "<strong>Hello</strong> World!")

A única solução que você tem agora é analisar o HTML, criar alguns nós com os atributos point / font / etc, e combiná-los em um NSAttributedString. É muito trabalho, mas, se feito corretamente, pode ser reutilizável no futuro.

A solução acima está correta.

[[NSAttributedString alloc] initWithData:[htmlString dataUsingEncoding:NSUTF8StringEncoding] 
                                 options:@{NSDocumentTypeDocumentAttribute: NSHTMLTextDocumentType,
                                           NSCharacterEncodingDocumentAttribute: @(NSUTF8StringEncoding)} 
                      documentAttributes:nil error:nil];

Mas o aplicativo wioll falhará se você estiver executando o ios 8.1,2 ou 3.

Para evitar a falha, o que você pode fazer é: execute isso em uma fila. Para que ele esteja sempre no thread principal.

O uso do NSHTMLTextDocumentType é lento e difícil de controlar estilos. Eu sugiro que você tente minha biblioteca chamada Atributika. Ele possui seu próprio analisador HTML muito rápido. Além disso, você pode ter qualquer nome de tag e definir qualquer estilo para eles.

Exemplo:

let str = "<strong>Hello</strong> World!".style(tags:
    Style("strong").font(.boldSystemFont(ofSize: 15))).attributedString

label.attributedText = str

Você pode encontrá-lo aqui https://github.com/psharanda/Atributika

Swift 3 :
Experimente o seguinte :

extension String {
    func htmlAttributedString() -> NSAttributedString? {
        guard let data = self.data(using: String.Encoding.utf16, allowLossyConversion: false) else { return nil }
        guard let html = try? NSMutableAttributedString(
            data: data,
            options: [NSDocumentTypeDocumentAttribute: NSHTMLTextDocumentType],
            documentAttributes: nil) else { return nil }
        return html
    }
}  

E para usar:

let str = "<h1>Hello bro</h1><h2>Come On</h2><h3>Go sis</h3><ul><li>ME 1</li><li>ME 2</li></ul> <p>It is me bro , remember please</p>"

self.contentLabel.attributedText = str.htmlAttributedString()

Extensões úteis

Inspirado por esta discussão, um pod, e exemplo ObjC de Erica Sadun no iOS Gourmet Cookbook p.80, eu escrevi uma extensão Stringe em NSAttributedStringir e voltar entre HTML simples cordas e NSAttributedStrings e vice-versa - no GitHub aqui , que Eu achei útil.

As assinaturas são (novamente, código completo em um Gist, link acima):

extension NSAttributedString {
    func encodedString(ext: DocEXT) -> String?
    static func fromEncodedString(_ eString: String, ext: DocEXT) -> NSAttributedString? 
    static func fromHTML(_ html: String) -> NSAttributedString? // same as above, where ext = .html
}

extension String {
    func attributedString(ext: DocEXT) -> NSAttributedString?
}

enum DocEXT: String { case rtfd, rtf, htm, html, txt }

com fonte

extension NSAttributedString
{
internal convenience init?(html: String, font: UIFont? = nil) {
    guard let data = html.data(using: String.Encoding.utf16, allowLossyConversion: false) else {
        return nil
    }
    assert(Thread.isMainThread)
    guard let attributedString = try?  NSAttributedString(data: data, options: [.documentType: NSAttributedString.DocumentType.html, .characterEncoding: String.Encoding.utf8.rawValue], documentAttributes: nil) else {
        return nil
    }
    let mutable = NSMutableAttributedString(attributedString: attributedString)
    if let font = font {
        mutable.addAttribute(.font, value: font, range: NSRange(location: 0, length: mutable.length))
    }
    self.init(attributedString: mutable)
}
}

Como alternativa, você pode usar as versões derivadas e definir a fonte no UILabel após definir o atributoString

A conversão incorporada sempre define a cor do texto como UIColor.black, mesmo se você passar um dicionário de atributos com .forgroundColor definido para outra coisa. Para oferecer suporte ao modo DARK no iOS 13, tente esta versão da extensão em NSAttributedString.

extension NSAttributedString {
    internal convenience init?(html: String)                    {
        guard 
            let data = html.data(using: String.Encoding.utf16, allowLossyConversion: false) else { return nil }

        let options : [DocumentReadingOptionKey : Any] = [
            .documentType: NSAttributedString.DocumentType.html,
            .characterEncoding: String.Encoding.utf8.rawValue
        ]

        guard
            let string = try? NSMutableAttributedString(data: data, options: options,
                                                 documentAttributes: nil) else { return nil }

        if #available(iOS 13, *) {
            let colour = [NSAttributedString.Key.foregroundColor: UIColor.label]
            string.addAttributes(colour, range: NSRange(location: 0, length: string.length))
        }

        self.init(attributedString: string)
    }
}