Como exibir HTML no TextView?

https://stackoverflow.com/questions/2116162

22-09-2019
|

Pergunta

Eu tenho simples Html:

<h2>Title</h2><br>
<p>description here</p>

Eu quero exibir um texto de estilo HTML TextView. Como fazer isso?

Solução

Você precisa usar Html.fromHtml() Para usar o HTML em suas cordas XML. Simplesmente referenciar uma string com HTML no seu layout XML não funcionará.

Isso é o que você deve fazer:

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
    textView.setText(Html.fromHtml("<h2>Title</h2><br><p>Description here</p>", Html.FROM_HTML_MODE_COMPACT));
} else { 
    textView.setText(Html.fromHtml("<h2>Title</h2><br><p>Description here</p>"));
}

Outras dicas

setText (html.fromhtml (bodydata)) é descontinuada depois da API 24. Agora você tem que fazer isso:

 if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.N) {
      tvDocument.setText(Html.fromHtml(bodyData,Html.FROM_HTML_MODE_LEGACY));
 } else {
      tvDocument.setText(Html.fromHtml(bodyData));
 }

Dê uma olhada nisso: https://stackoverflow.com/a/8558249/450148

É muito bom também !!

<resource>
    <string name="your_string">This is an <u>underline</u> text demo for TextView.</string>
</resources>

Funciona apenas para poucas tags.

Se você deseja configurá -lo através do XML sem qualquer modificação no código Java, poderá achar essa ideia útil. Simplesmente você chama init do construtor e define o texto como html

public class HTMLTextView extends TextView {
    ... constructors calling init...
    private void init(){
       setText(Html.fromHtml(getText().toString()));
    }    
}

xml:

        <com.package.HTMLTextView
        android:text="@string/about_item_1"/>

O código abaixo deu o melhor resultado para mim.

TextView myTextview = (TextView) findViewById(R.id.my_text_view);
htmltext = <your html (markup) character>;
Spanned sp = Html.fromHtml(htmltext);
myTextview.setText(sp);

Se você estiver tentando mostrar HTML a partir de um ID de recurso de string, a formatação pode não aparecer na tela. Se isso estiver acontecendo com você, tente usar tags CDATA:

strings.xml:
<string name="sample_string"><![CDATA[<h2>Title</h2><br><p>Description here</p>]]></string>

...

MainActivity.java:
text.setText(Html.fromHtml(getString(R.string.sample_string));

Veja isso publicar para mais detalhes.

String value = "<html> <a href=\"http://example.com/\">example.com</a> </html>";
    SiteLink= (TextView) findViewById(R.id.textViewSite);
    SiteLink.setText(Html.fromHtml(value));
    SiteLink.setMovementMethod(LinkMovementMethod.getInstance());

Se você quer apenas exibir algum texto em HTML e realmente não precisa de um TextView, então pegue um WebView e use -o como seguir:

String htmlText = ...;
webview.loadData(htmlText , "text/html; charset=UTF-8", null);

Isso também não o restringe a algumas tags HTML.

A melhor abordagem para usar seções CDATA para a string no arquivo strings.xml para obter uma exibição real do conteúdo HTML no TextView, o snippet de código abaixo fornecerá a ideia justa.

//in string.xml file
<string name="welcome_text"><![CDATA[<b>Welcome,</b> to the forthetyroprogrammers blog Logged in as:]]> %1$s.</string>

//and in Java code
String welcomStr=String.format(getString(R.string.welcome_text),username);
tvWelcomeUser.setText(Html.fromHtml(welcomStr));

A seção CDATA no texto da string mantém os dados de tag html intactos mesmo após a formatação do texto usando o método String.Format. Então, html.fromhtml (str) funciona bem e você verá o texto em negrito na mensagem de boas -vindas.

Resultado:

Bem -vindo, à sua loja de aplicativos de música favorita. Conectado como: nome de usuário

Vale a pena mencionar que o método Html.fromhtml (fonte da string) está obsoleto no nível da API 24. Se essa é a sua API alvo, você deve usar Html.fromhtml (fonte da string, int sinalizadores) em vez de.

Eu também gostaria de sugerir o seguinte projeto: https://github.com/nightwhistler/htmlspanner

O uso é quase o mesmo que o Conversor Android padrão:

(new HtmlSpanner()).fromHtml()

Encontrei depois que eu já comecei pela própria implementação do HTML para o conversor espanhável, porque o HTML padrão.

Uso simples Html.fromHtml("html string"). Isso vai funcionar. Se a string tiver tags como <h1> Então os espaços virão. Mas não podemos eliminar esses espaços. Se você ainda deseja remover os espaços, poderá remover as tags na string e depois passar a string para o método Html.fromHtml("html string"); . Geralmente, essas seqüências vêm do servidor (dinâmico), mas não frequentemente, se for melhor passar a string como é para o método do que tentar remover as tags da string.

String value = html value ....
mTextView.setText(Html.fromHtml(value),TextView.BufferType.SPANNABLE)

Faça um método global como:

public static Spanned stripHtml(String html) {
            if (!TextUtils.isEmpty(html)) {
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
                    return Html.fromHtml(html, Html.FROM_HTML_MODE_COMPACT);
                } else {
                    return Html.fromHtml(html);
                }
            }
            return null;
        }

Você também pode usá -lo em sua atividade/fragmento como:

text_view.setText(stripHtml(htmlText));

Eu implementei isso usando a Web View. No meu caso, tenho que carregar a imagem da URL junto com o texto na visualização de texto e isso funciona para mim.

WebView myWebView =new WebView(_context);
        String html = childText;
        String mime = "text/html";
        String encoding = "utf-8";
        myWebView.getSettings().setJavaScriptEnabled(true);
        myWebView.loadDataWithBaseURL(null, html, mime, encoding, null);

Foi sugerido através de várias respostas para usar o Html Classe de estrutura, conforme sugerido aqui, mas infelizmente essa classe tem um comportamento diferente em diferentes versões do Android e vários insetos não tratados, como demonstrado em questões 214637, 14778, 235128 e 75953.

Portanto, você pode usar uma biblioteca de compatibilidade para padronizar e fazer backport a classe HTML nas versões Android, que inclui mais retornos de chamada para elementos e estilo:

Projeto Github HtmlCompat

Embora seja semelhante à classe HTML da estrutura, foram necessárias algumas alterações de assinatura para permitir mais retornos de chamada. Aqui está a amostra da página do Github:

Spanned fromHtml = HtmlCompat.fromHtml(context, source, 0);
// You may want to provide an ImageGetter, TagHandler and SpanCallback:
//Spanned fromHtml = HtmlCompat.fromHtml(context, source, 0,
//        imageGetter, tagHandler, spanCallback);
textView.setMovementMethod(LinkMovementMethod.getInstance());
textView.setText(fromHtml);

Eu sei que essa pergunta é antiga. Outras respostas aqui sugerindo Html.fromHtml() método. Eu sugiro que você use HtmlCompat.fromHtml() a partir de androidx.core.text.HtmlCompat pacote. Como esta é a versão compatível com versões anteriores Html classe.

Código de amostra:

import androidx.core.text.HtmlCompat;
import android.text.Spanned;
import android.widget.TextView;

String htmlString = "<h1>Hello World!</h1>";

Spanned spanned = HtmlCompat.fromHtml(htmlString, HtmlCompat.FROM_HTML_MODE_COMPACT);

TextView tvOutput = (TextView) findViewById(R.id.text_view_id);

tvOutput.setText(spanned);

Dessa forma, você pode evitar a verificação da versão Android API e é fácil de usar (solução de linha única).

Sempre que você escrever texto personalizado, exibir o recurso Basic HTML Set Text, for desaparecido, formar alguns dos dispositivos.

Então, precisamos fazer as seguintes etapas adicionais, é funcionar

public class CustomTextView extends TextView {

    public CustomTextView(..) {
        // other instructions
        setText(Html.fromHtml(getText().toString()));
    }
}

public class HtmlTextView extends AppCompatTextView {

public HtmlTextView(Context context) {
    super(context);
    init();
}

private void init(){
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
        setText(Html.fromHtml(getText().toString(), Html.FROM_HTML_MODE_COMPACT));
    } else {
        setText(Html.fromHtml(getText().toString()));
    }
 }
}

atualização de Resposta acima

Posso sugerir uma solução um tanto hacky, mas ainda genial! Eu tive a ideia de Este artigo e adaptou -o para Android. Basicamente, você usa um WebView e insira o HTML que você deseja mostrar e editar em uma tag Div editável. Dessa forma, quando o usuário toca o WebView O teclado aparece e permite a edição. Eles você apenas adiciona javascript para recuperar o HTML e o pronto editado!

Aqui está o código:

public class HtmlTextEditor extends WebView {

    class JsObject {
        // This field always keeps the latest edited text
        public String text;
        @JavascriptInterface
        public void textDidChange(String newText) {
            text = newText.replace("\n", "");
        }
    }

    private JsObject mJsObject;

    public HtmlTextEditor(Context context, AttributeSet attrs) {
        super(context, attrs);

        getSettings().setJavaScriptEnabled(true);
        mJsObject = new JsObject();
        addJavascriptInterface(mJsObject, "injectedObject");
        setWebViewClient(new WebViewClient(){
            @Override
            public void onPageFinished(WebView view, String url) {
                super.onPageFinished(view, url);
                loadUrl(
                        "javascript:(function() { " +
                            "    var editor = document.getElementById(\"editor\");" +
                            "    editor.addEventListener(\"input\", function() {" +
                            "        injectedObject.textDidChange(editor.innerHTML);" +
                            "    }, false)" +
                            "})()");
            }
        });
    }

    public void setText(String text) {
        if (text == null) { text = ""; }

        String editableHtmlTemplate = "<!DOCTYPE html>" + "<html>" + "<head>" + "<meta name=\"viewport\" content=\"initial-scale=1.0\" />" + "</head>" + "<body>" + "<div id=\"editor\" contenteditable=\"true\">___REPLACE___</div>" + "</body>" + "</html>";
        String editableHtml = editableHtmlTemplate.replace("___REPLACE___", text);
        loadData(editableHtml, "text/html; charset=utf-8", "UTF-8");
        // Init the text field in case it's read without editing the text before
        mJsObject.text = text;
    }

    public String getText() {
        return mJsObject.text;
    }
}

E aqui é o componente como uma essência.

NOTA: Eu não precisava do retorno de chamada de altura da altura da solução original, então isso está faltando aqui, mas você pode adicioná -lo facilmente, se necessário.

Se você usar androidx.* Aulas em seu projeto, você deve usar HtmlCompat.fromHtml(text, flag). A fonte do método é:

@NonNull public static Spanned fromHtml(@NonNull String source, @FromHtmlFlags int flags) { if (Build.VERSION.SDK_INT >= 24) { return Html.fromHtml(source, flags); } //noinspection deprecation return Html.fromHtml(source); }

É uma maneira melhor do que html.fromhtml, pois há menos código, apenas uma linha e uma maneira recomendada de usá -la.

Licenciado em: CC-BY-SA com atribuição

Não afiliado a StackOverflow