¿Cómo puedo abrir una URL en el navegador web de Android desde mi aplicación?

¿Cómo abrir una URL desde el código en el navegador web integrado en lugar de dentro de mi aplicación?

Intenté esto:

try {
    Intent myIntent = new Intent(Intent.ACTION_VIEW, Uri.parse(download_link));
    startActivity(myIntent);
} catch (ActivityNotFoundException e) {
    Toast.makeText(this, "No application can handle this request."
        + " Please install a webbrowser",  Toast.LENGTH_LONG).show();
    e.printStackTrace();
}

pero tengo una excepción:

No activity found to handle Intent{action=android.intent.action.VIEW data =www.google.com

preguntado el 04 de febrero de 10 a las 14:02

¿Por qué esto no funciona en algunos dispositivos? incluso si hay un navegador web, va a ActivityNotFoundException. -

Veo el mismo problema que @Manu. La instalación básica en un Nexus 6 tiene Chrome, pero los enlaces provocan una excepción. -

30 Respuestas

Prueba esto:

Intent browserIntent = new Intent(Intent.ACTION_VIEW, Uri.parse("http://www.google.com"));
startActivity(browserIntent);

Eso funciona bien para mí.

En cuanto al "http: //" que falta, haría algo como esto:

if (!url.startsWith("http://") && !url.startsWith("https://"))
   url = "http://" + url;

Probablemente también rellenaría previamente su EditText en el que el usuario está escribiendo una URL con "http: //".

Respondido 01 Abr '18, 10:04

Excepto que su código y el de mbaird no son los mismos, por lo que puedo decir de lo que se publicó. Asegúrese de que su URL tenga la http:// esquema: la excepción que se muestra sugiere que su URL carece del esquema. - CommonsWare

Sí ! ¡Se perdió el http: //! El usuario ingresa la URL, ¿hay alguna manera de formatearla automáticamente? - arutha

URLUtil es una excelente manera de verificar las cadenas "url" ingresadas por el usuario: Dan

if (!url.startsWith("http://") && !url.startsWith("https://")) es un error común que puede llevarlo a direcciones URL como expediente:// y romper algunos buenos casos de uso. Intente analizar uri con la clase URI y verifique si hay un esquema. Si no, agregue "http: //";) - esmoquin

Necesitas un cheque nulo con resolveCheck. Consulte las documentos oficiales : Precaución: Si no hay aplicaciones en el dispositivo que puedan recibir la intención implícita, su aplicación se bloqueará cuando llame a startActivity (). Para verificar primero que existe una aplicación para recibir el intent, llame a resolveActivity () en su objeto Intent. - Kenju

una forma común de lograr esto es con el siguiente código:

String url = "http://www.stackoverflow.com";
Intent i = new Intent(Intent.ACTION_VIEW);
i.setData(Uri.parse(url)); 
startActivity(i); 

que podría cambiarse a una versión de código corto ...

Intent intent = new Intent(Intent.ACTION_VIEW).setData(Uri.parse("http://www.stackoverflow.com"));      
startActivity(intent); 

o:

Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse("http://www.stackoverflow.com")); 
startActivity(intent);

¡el más corto! :

startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse("http://www.stackoverflow.com")));

codificación feliz!

Respondido el 17 de Septiembre de 15 a las 14:09

Respuesta simple

Usted puede ver la muestra oficial del desarrollador de Android.

/**
 * Open a web page of a specified URL
 *
 * @param url URL to open
 */
public void openWebPage(String url) {
    Uri webpage = Uri.parse(url);
    Intent intent = new Intent(Intent.ACTION_VIEW, webpage);
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivity(intent);
    }
}

Cómo funciona

Por favor, eche un vistazo al constructor de Intent:

public Intent (String action, Uri uri)

Puedes pasar android.net.Uri instancia al segundo parámetro, y se crea un nuevo Intent basado en la URL de datos dada.

Y luego, simplemente llama startActivity(Intent intent) para iniciar una nueva actividad, que se incluye con el Intent con la URL dada.

¿Necesito el if estado de cuenta?

Sí. La documentos dice:

Si no hay aplicaciones en el dispositivo que puedan recibir la intención implícita, su aplicación se bloqueará cuando llame a startActivity (). Para verificar primero que existe una aplicación para recibir el intent, llame a resolveActivity () en su objeto Intent. Si el resultado no es nulo, hay al menos una aplicación que puede manejar la intención y es seguro llamar a startActivity (). Si el resultado es nulo, no debe usar la intención y, si es posible, debe deshabilitar la función que invoca la intención.

Bono

Puede escribir en una línea al crear la instancia de Intent como se muestra a continuación:

Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(url));

Respondido 21 Jul 16, 15:07

Esto supone que la URL proporcionada tiene http en eso. - IgorGanapolsky

En 2.3, tuve mejor suerte con

final Intent intent = new Intent(Intent.ACTION_VIEW).setData(Uri.parse(url));
activity.startActivity(intent);

La diferencia es el uso de Intent.ACTION_VIEW en lugar de la Cadena "android.intent.action.VIEW"

respondido 16 mar '11, 15:03

¿Qué es lo diferente? - user1324936

Esta respuesta me ayudó inmensamente. No sé cuál fue la diferencia, pero tuvimos un problema con 2.3 que se solucionó. ¿Alguien sabe cuál es la diferencia en la implementación? - Innova

Según el desarrollador de Android: esta respuesta: "Crea una intención con una acción determinada. Todos los demás campos (datos, tipo, clase) son nulos". y la respuesta aceptada: "Crear un intent con una acción determinada y para una URL de datos determinada". - teo inke

Prueba esto:

Uri uri = Uri.parse("https://www.google.com");
startActivity(new Intent(Intent.ACTION_VIEW, uri));

o si desea que el navegador web se abra en su actividad, haga lo siguiente:

WebView webView = (WebView) findViewById(R.id.webView1);
WebSettings settings = webview.getSettings();
settings.setJavaScriptEnabled(true);
webView.loadUrl(URL);

y si desea utilizar el control de zoom en su navegador, puede utilizar:

settings.setSupportZoom(true);
settings.setBuiltInZoomControls(true);

contestado el 26 de mayo de 18 a las 11:05

Tenga en cuenta que los complementos y demás están deshabilitados en WebView y que se requerirían los permisos de INTERNET. (referencia) - usuario1544337

Si desea mostrar al usuario un diálogo con toda la lista del navegador, para que pueda elegir el preferido, aquí hay un código de muestra:

private static final String HTTPS = "https://";
private static final String HTTP = "http://";

public static void openBrowser(final Context context, String url) {

     if (!url.startsWith(HTTP) && !url.startsWith(HTTPS)) {
            url = HTTP + url;
     }

     Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(url));
     context.startActivity(Intent.createChooser(intent, "Choose browser"));// Choose browser is arbitrary :)

}

Respondido 19 Oct 16, 15:10

si hay varias aplicaciones que pueden manejar la intención, el sistema proporcionará automáticamente un selector, ¿verdad? - jeffrey blattman

@ xmen-wk porque la URL puede iniciar ether con http or https, y en Java es una buena práctica declarar 'cadenas mágicas' como constantes. - Dmitro Danylyk

gracias, no sabía sobre context.startActivity. Muy útil al llamarlo desde una clase externa - wuerfeldev

Al igual que las soluciones que otros han escrito (que funcionan bien), me gustaría responder lo mismo, pero con un consejo que creo que la mayoría preferiría usar.

En caso de que desee que la aplicación comience a abrirse en una nueva tarea, independiente de la suya, en lugar de permanecer en la misma pila, puede usar este código:

final Intent intent=new Intent(Intent.ACTION_VIEW,Uri.parse(url));
intent.addFlags(Intent.FLAG_ACTIVITY_NO_HISTORY|Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET|Intent.FLAG_ACTIVITY_NEW_TASK|Intent.FLAG_ACTIVITY_MULTIPLE_TASK);
startActivity(intent);

También hay una forma de abrir la URL en Chrome pestañas personalizadas . Ejemplo en Kotlin:

@JvmStatic
fun openWebsite(activity: Activity, websiteUrl: String, useWebBrowserAppAsFallbackIfPossible: Boolean) {
    var websiteUrl = websiteUrl
    if (TextUtils.isEmpty(websiteUrl))
        return
    if (websiteUrl.startsWith("www"))
        websiteUrl = "http://$websiteUrl"
    else if (!websiteUrl.startsWith("http"))
        websiteUrl = "http://www.$websiteUrl"
    val finalWebsiteUrl = websiteUrl
    //https://github.com/GoogleChrome/custom-tabs-client
    val webviewFallback = object : CustomTabActivityHelper.CustomTabFallback {
        override fun openUri(activity: Activity, uri: Uri?) {
            var intent: Intent
            if (useWebBrowserAppAsFallbackIfPossible) {
                intent = Intent(Intent.ACTION_VIEW, Uri.parse(finalWebsiteUrl))
                intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_NO_HISTORY
                        or Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET or Intent.FLAG_ACTIVITY_MULTIPLE_TASK)
                if (!CollectionUtil.isEmpty(activity.packageManager.queryIntentActivities(intent, 0))) {
                    activity.startActivity(intent)
                    return
                }
            }
            // open our own Activity to show the URL
            intent = Intent(activity, WebViewActivity::class.java)
            WebViewActivity.prepareIntent(intent, finalWebsiteUrl)
            activity.startActivity(intent)
        }
    }
    val uri = Uri.parse(finalWebsiteUrl)
    val intentBuilder = CustomTabsIntent.Builder()
    val customTabsIntent = intentBuilder.build()
    customTabsIntent.intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_NO_HISTORY
            or Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET or Intent.FLAG_ACTIVITY_MULTIPLE_TASK)
    CustomTabActivityHelper.openCustomTab(activity, customTabsIntent, uri, webviewFallback)
}

Respondido 20 Feb 19, 12:02

¿Hacer una nueva tarea protegerá la aplicación de origen de errores y fallas, en caso de que el navegador web tenga problemas? - El Android original

@TheOriginalAndroid No entiendo qué tiene que ver con los bloqueos y el navegador web. Explique lo que está intentando hacer. - desarrollador de Android

Gracias por su respuesta. Tu publicación es interesante. ¿Cuál es el beneficio de abrir una nueva tarea especialmente para un lanzamiento web? - El Android original

@TheOriginalAndroid Solo para que el usuario pueda volver a su aplicación y luego volver al navegador web. Si abre la pantalla de tareas recientes, verá 2 tareas aquí en lugar de una. Además, en lugar de ver una miniatura del navegador web en la tarea única (que pertenece a la tarea de su aplicación), verá 2: una de su aplicación y otra del navegador web. Creo que es menos confuso de esta manera. - desarrollador de Android

FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET es obsoleto - Pratik Butani

otra opción en Load Url en la misma aplicación usando Webview

webView = (WebView) findViewById(R.id.webView1);
webView.getSettings().setJavaScriptEnabled(true);
webView.loadUrl("http://www.google.com");

contestado el 26 de mayo de 18 a las 11:05

Tenga en cuenta que los complementos y demás están deshabilitados en WebView y que se requerirían los permisos de INTERNET. (referencia) - usuario1544337

También tenga en cuenta que .setJavaScriptEnabled(true); es peligroso. - dan1er

También puedes ir por este camino

En xml:

<?xml version="1.0" encoding="utf-8"?>
<WebView  
xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@+id/webView1"
android:layout_width="fill_parent"
android:layout_height="fill_parent" />

En código java:

public class WebViewActivity extends Activity {

private WebView webView;

public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.webview);

    webView = (WebView) findViewById(R.id.webView1);
    webView.getSettings().setJavaScriptEnabled(true);
    webView.loadUrl("http://www.google.com");

 }

}

En Manifiesto, no olvide agregar el permiso de Internet ...

Respondido 28 Abr '14, 12:04

Esto es interesante y diferente. Supongo que de esta manera el usuario ve un navegador web en mi aplicación. ¿Está bien? Yo voto a favor. - El Android original

Webview se puede utilizar para cargar la URL en su aplicación. La URL puede ser proporcionada por el usuario en la vista de texto o puede codificarla.

Además, no olvide los permisos de Internet en AndroidManifest.

String url="http://developer.android.com/index.html"

WebView wv=(WebView)findViewById(R.id.webView);
wv.setWebViewClient(new MyBrowser());
wv.getSettings().setLoadsImagesAutomatically(true);
wv.getSettings().setJavaScriptEnabled(true);
wv.setScrollBarStyle(View.SCROLLBARS_INSIDE_OVERLAY);
wv.loadUrl(url);

private class MyBrowser extends WebViewClient {
    @Override
    public boolean shouldOverrideUrlLoading(WebView view, String url) {
        view.loadUrl(url);
        return true;
    }
}

respondido 12 nov., 15:21

Dentro de su bloque de prueba, pegue el siguiente código, Android Intent usa directamente el enlace dentro de las llaves URI (Identificador uniforme de recursos) para identificar la ubicación de su enlace.

Puedes intentar esto:

Intent myIntent = new Intent(Intent.ACTION_VIEW, Uri.parse("http://www.google.com"));
startActivity(myIntent);

Respondido 21 Abr '15, 15:04

La respuesta de Kotlin:

val browserIntent = Intent(Intent.ACTION_VIEW, uri)
ContextCompat.startActivity(context, browserIntent, null)

He agregado una extensión en Uri para hacer esto aún más fácil

myUri.openInBrowser(context)

fun Uri?.openInBrowser(context: Context) {
    this ?: return // Do nothing if uri is null

    val browserIntent = Intent(Intent.ACTION_VIEW, this)
    ContextCompat.startActivity(context, browserIntent, null)
}

Como beneficio adicional, aquí hay una función de extensión simple para convertir de manera segura un String en Uri.

"https://stackoverflow.com".asUri()?.openInBrowser(context)

fun String?.asUri(): Uri? {
    try {
        return Uri.parse(this)
    } catch (e: Exception) {}
    return null
}

Respondido 30 Oct 20, 21:10

No aporta nada interesante. Incluso no funcionará si no hay una aplicación que maneje una URL. Se estrellará con una excepción. - CoolMind

Todos los dispositivos deben tener una aplicación para manejar una URL. Puede agregar su propio manejo de fallas / excepciones según sea necesario, - Gibolt

De acuerdo con usted. - CoolMind

Una versión de código corto ...

 if (!strUrl.startsWith("http://") && !strUrl.startsWith("https://")){
     strUrl= "http://" + strUrl;
 }


 startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse(strUrl)));

Respondido el 03 de diciembre de 13 a las 16:12

Práctica sencilla y óptima

Método 1:

String intentUrl="www.google.com";
Intent webIntent = new Intent(Intent.ACTION_VIEW, Uri.parse(intentUrl));
    if(webIntent.resolveActivity(getPackageManager())!=null){
        startActivity(webIntent);    
    }else{
      /*show Error Toast 
              or 
        Open play store to download browser*/
            }

Método 2:

try{
    String intentUrl="www.google.com";
    Intent webIntent = new Intent(Intent.ACTION_VIEW, Uri.parse(intentUrl));
        startActivity(webIntent);
    }catch (ActivityNotFoundException e){
                /*show Error Toast
                        or
                  Open play store to download browser*/
    }

respondido 11 mar '19, 07:03

Utiliza la context!!.packageManager en lugar de getPackageManager() en un parche de Fragment. - CoolMind

String url = "http://www.example.com";
Intent i = new Intent(Intent.ACTION_VIEW);
i.setData(Uri.parse(url));
startActivity(i);

Respondido el 04 de Septiembre de 14 a las 09:09

Intent getWebPage = new Intent(Intent.ACTION_VIEW, Uri.parse(MyLink));          
startActivity(getWebPage);

Respondido 17 Jul 14, 13:07

bienvenido, novato. Por favor, haga la respuesta más completa, declarando variables que no existen en el código original. - tony gil

La respuesta de Marca B es correcto. En mi caso estoy usando Xamarin, y el código para usar con C # y Xamarin es:

var uri = Android.Net.Uri.Parse ("http://www.xamarin.com");
var intent = new Intent (Intent.ActionView, uri);
StartActivity (intent);

Esta información se obtiene de: https://developer.xamarin.com/recipes/android/fundamentals/intent/open_a_webpage_in_the_browser_application/

Respondido 11 Jul 17, 14:07

Las pestañas personalizadas de Chrome ahora están disponibles:

El primer paso es agregar la biblioteca de soporte de pestañas personalizadas a su archivo build.gradle:

dependencies {
    ...
    compile 'com.android.support:customtabs:24.2.0'
}

Y luego, para abrir una pestaña personalizada de Chrome:

String url = "https://www.google.pt/";
CustomTabsIntent.Builder builder = new CustomTabsIntent.Builder();
CustomTabsIntent customTabsIntent = builder.build();
customTabsIntent.launchUrl(this, Uri.parse(url));

Para más información: https://developer.chrome.com/multidevice/android/customtabs

contestado el 26 de mayo de 18 a las 11:05

Vista simple del sitio web a través de la intención,

Intent viewIntent = new Intent("android.intent.action.VIEW", Uri.parse("http://www.yoursite.in"));
startActivity(viewIntent);  

use este código simple para ver su sitio web en la aplicación de Android.

Agregue permiso de Internet en el archivo de manifiesto,

<uses-permission android:name="android.permission.INTERNET" /> 

contestado el 26 de mayo de 18 a las 11:05

Así que busqué esto durante mucho tiempo porque todas las otras respuestas abrían la aplicación predeterminada para ese enlace, pero no por defecto del navegador y eso es lo que quería.

Finalmente logré hacerlo:

// gathering the default browser
final Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse("http://"));
final ResolveInfo resolveInfo = context.getPackageManager()
    .resolveActivity(intent, PackageManager.MATCH_DEFAULT_ONLY);
String defaultBrowserPackageName = resolveInfo.activityInfo.packageName;


final Intent intent2 = new Intent(Intent.ACTION_VIEW);
intent2.setData(Uri.parse(url));

if (!defaultBrowserPackageName.equals("android") {
    // android = no default browser is set 
    // (android < 6 or fresh browser install or simply no default set)
    // if it's the case (not in this block), it will just use normal way.
    intent2.setPackage(defaultBrowserPackageName);
}

context.startActivity(intent2);

Por cierto, puedes notar context.lo que sea, porque he usado esto para un método util estático, si está haciendo esto en una actividad, no es necesario.

contestado el 01 de mayo de 20 a las 10:05

Basado en la respuesta de Mark B y los comentarios a continuación:

protected void launchUrl(String url) {
    Uri uri = Uri.parse(url);

    if (uri.getScheme() == null || uri.getScheme().isEmpty()) {
        uri = Uri.parse("http://" + url);
    }

    Intent browserIntent = new Intent(Intent.ACTION_VIEW, uri);

    if (browserIntent.resolveActivity(getPackageManager()) != null) {
        startActivity(browserIntent);
    }
}

Respondido el 16 de diciembre de 16 a las 06:12

Te contrataría cualquier día ... Caring Code. Gracias - gordito

android.webkit.URLUtil tiene el método guessUrl(String) funcionando perfectamente bien (incluso con file:// or data://) ya que Api level 1 (Android 1.0). Usar como:

String url = URLUtil.guessUrl(link);

// url.com            ->  http://url.com/     (adds http://)
// http://url         ->  http://url.com/     (adds .com)
// https://url        ->  https://url.com/    (adds .com)
// url                ->  http://www.url.com/ (adds http://www. and .com)
// http://www.url.com ->  http://www.url.com/ 
// https://url.com    ->  https://url.com/
// file://dir/to/file ->  file://dir/to/file
// data://dataline    ->  data://dataline
// content://test     ->  content://test

En la llamada de actividad:

Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(URLUtil.guessUrl(download_link)));

if (intent.resolveActivity(getPackageManager()) != null)
    startActivity(intent);

Comprueba el completo guessUrl código para más información.

Respondido el 23 de junio de 17 a las 03:06

De acuerdo, verifiqué todas las respuestas, pero ¿qué aplicación tiene enlaces profundos con la misma URL que el usuario desea usar?

Hoy tengo este caso y la respuesta es browserIntent.setPackage("browser_package_name");

p.ej :

   Intent browserIntent = new Intent(Intent.ACTION_VIEW, Uri.parse("http://www.google.com"));
    browserIntent.setPackage("com.android.chrome"); // Whatever browser you are using
    startActivity(browserIntent);

¡Gracias!

Respondido el 10 de enero de 18 a las 03:01

Buena respuesta. Explica cómo abrir una URL de intención en un navegador específico (directamente) y no depender de que el sistema elija un navegador. - Sr-IDE

Simplemente elija uno corto para abrir su URL en el navegador:

Intent browserIntent = new Intent(Intent.ACTION_VIEW, Uri.parse("YourUrlHere"));
startActivity(browserIntent);

Respondido 02 Abr '19, 13:04

es posible abrirlo solo en la APLICACIÓN, como dentro de la vista web o algo así. - El Rahul Jha

String url = "https://www.thandroid-mania.com/";
if (url.startsWith("https://") || url.startsWith("http://")) {
    Uri uri = Uri.parse(url);
    Intent intent = new Intent(Intent.ACTION_VIEW, uri);
    startActivity(intent);
}else{
    Toast.makeText(mContext, "Invalid Url", Toast.LENGTH_SHORT).show();
}

Ese error se produjo debido a una URL no válida, el sistema operativo Android no puede encontrar la vista de acción para sus datos. Así que has validado que la URL sea válida o no.

Respondido 22 ago 19, 03:08

Creo que esto es lo mejor

openBrowser(context, "http://www.google.com")

Ponga el código debajo en la clase global

    public static void openBrowser(Context context, String url) {

        if (!url.startsWith("http://") && !url.startsWith("https://"))
            url = "http://" + url;

        Intent browserIntent = new Intent(Intent.ACTION_VIEW, Uri.parse(url));
        context.startActivity(browserIntent);
    }

respondido 16 nov., 16:14

De esta manera utiliza un método que le permite ingresar cualquier Cadena en lugar de tener una entrada fija. Esto ahorra algunas líneas de código si se usa una cantidad repetida de veces, ya que solo necesita tres líneas para llamar al método.

public Intent getWebIntent(String url) {
    //Make sure it is a valid URL before parsing the URL.
    if(!url.contains("http://") && !url.contains("https://")){
        //If it isn't, just add the HTTP protocol at the start of the URL.
        url = "http://" + url;
    }
    //create the intent
    Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(url)/*And parse the valid URL. It doesn't need to be changed at this point, it we don't create an instance for it*/);
    if (intent.resolveActivity(getPackageManager()) != null) {
        //Make sure there is an app to handle this intent
        return intent;
    }
    //If there is no app, return null.
    return null;
}

El uso de este método lo hace universalmente utilizable. No es necesario colocarlo en una actividad específica, ya que puede usarlo así:

Intent i = getWebIntent("google.com");
if(i != null)
    startActivity();

O si desea iniciarlo fuera de una actividad, simplemente llame a startActivity en la instancia de la actividad:

Intent i = getWebIntent("google.com");
if(i != null)
    activityInstance.startActivity(i);

Como se ve en ambos bloques de código, hay una verificación nula. Esto es porque devuelve nulo si no hay una aplicación para manejar la intención.

Este método tiene como valor predeterminado HTTP si no hay un protocolo definido, ya que hay sitios web que no tienen un certificado SSL (lo que necesita para una conexión HTTPS) y dejarán de funcionar si intenta usar HTTPS y no está allí. . Cualquier sitio web aún puede forzar el paso a HTTPS, por lo que esos lados lo llevan a HTTPS de cualquier manera


Debido a que este método utiliza recursos externos para mostrar la página, no es necesario que declare el permiso INternet. La aplicación que muestra la página web tiene que hacer eso.

contestado el 02 de mayo de 17 a las 17:05

// OnClick Listener

  @Override
      public void onClick(View v) {
        String webUrl = news.getNewsURL();
        if(webUrl!="")
        Utils.intentWebURL(mContext, webUrl);
      }

// Tu método util

public static void intentWebURL(Context context, String url) {
        if (!url.startsWith("http://") && !url.startsWith("https://")) {
            url = "http://" + url;
        }
        boolean flag = isURL(url);
        if (flag) {
            Intent browserIntent = new Intent(Intent.ACTION_VIEW,
                    Uri.parse(url));
            context.startActivity(browserIntent);
        }

    }

Respondido el 22 de enero de 18 a las 10:01

¿Dónde se define "isURL"? - Cabuxa.Mapache

Kotlin

startActivity(Intent(Intent.ACTION_VIEW).apply {
            data = Uri.parse(your_link)
        })

Respondido 04 Feb 20, 09:02

Desde Anko método de biblioteca

fun Context.browse(url: String, newTask: Boolean = false): Boolean {
    try {
        val intent = Intent(Intent.ACTION_VIEW)
        intent.data = Uri.parse(url)
        if (newTask) {
            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
        }
        startActivity(intent)
        return true
    } catch (e: ActivityNotFoundException) {
        e.printStackTrace()
        return false
    }
}

Respondido 13 Oct 20, 09:10

Anko está en desuso. Por favor mira esta página para más información. - phillipsk

@phillipsK Anko está obsoleto, pero no el SDK de Android - Vlad

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.