¿Cómo abrir una URL desde el código en el navegador web incorporado 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

Prueba esto:

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

Eso funciona bien para mi.

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

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

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

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); 

eso 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")));

feliz codificación!

Respuesta simple

Puedes 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)

Puede pasar la android.net.Uriinstancia al segundo parámetro, y se crea una nueva intención basada en la URL de datos dada.

Y luego, simplemente llame startActivity(Intent intent)para comenzar una nueva Actividad, que se incluye con la Intención con la URL dada.

¿Necesito el ifestado de cuenta?

Si. Los documentos dicen:

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 la intención, 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.

Prima

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

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

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_VIEWString en lugar de"android.intent.action.VIEW"

Prueba esto:

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

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

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

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

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

Si desea mostrarle al usuario un diálogo con toda la lista del navegador, para que pueda elegir 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 :)

}

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 manera de abrir la URL en las pestañas personalizadas de Chrome . 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)
}

otra opción En cargar URL en la misma aplicación usando Webview

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

También puedes ir por aquí

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 el Manifiesto, no se olvide de agregar el permiso de Internet ...

Webview se puede utilizar para cargar la URL en su aplicación. El usuario puede proporcionar la URL 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;
    }
}

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)));

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 probar esto:

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

Simple y mejor práctica

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*/
    }

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

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

La respuesta de MarkB es correcta. 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/

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

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);
    }
}

android.webkit.URLUtiltiene el método guessUrl(String)funcionando perfectamente bien (incluso con file://o data://) desde 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);

Consulte el guessUrlcódigo completo para más información.

De acuerdo, verifiqué cada respuesta, pero ¿qué aplicación tiene enlaces profundos con la misma URL que el usuario quiere 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!

Vista simple del sitio web por 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.

Agregar permiso de internet en el archivo de manifiesto,

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

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. Por lo tanto, debe validar que la URL es válida o no.

Creo que este es el mejor

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

Poner el siguiente código 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);
    }

De esta manera, se utiliza un método que le permite ingresar cualquier Cadena en lugar de tener una entrada fija. Esto guarda algunas líneas de código si se usa varias 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 ubicarlo 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 actividad:

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

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

Este método predeterminado es 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 esos dejarán de funcionar si intenta usar HTTPS y no está allí . Cualquier sitio web todavía puede pasar a HTTPS, por lo que esos lados te 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

// OnClick Listener

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

// Su método de utilidad

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);
        }

    }

Simplemente vaya con uno corto para abrir su URL en el navegador:

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

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

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 forma segura una Cadena a Uri.

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

Así que lo he buscado durante mucho tiempo porque todas las otras respuestas estaban abriendo la aplicación predeterminada para ese enlace, pero no el navegador predeterminado y eso era 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, puede notar. contextLo que sea, porque he usado esto para un método de utilidad estática, si está haciendo esto en una actividad, no es necesario.

Comprueba si tu url es correcta. Para mí había un espacio no deseado antes de la url.

Prueba esto ... ¡Trabajó para mí!

    public void webLaunch(View view) {
            WebView myWebView = (WebView) findViewById(R.id.webview);
            myWebView.setVisibility(View.VISIBLE);
            View view1=findViewById(R.id.recharge);
            view1.setVisibility(View.GONE);
            myWebView.getSettings().setJavaScriptEnabled(true);
            myWebView.loadUrl("<your link>");

        }

código xml: -

 <WebView  xmlns:android="http://schemas.android.com/apk/res/android"
        android:id="@+id/webview"
        android:visibility="gone"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
        />

--------- O ------------------

String url = "";
Intent i = new Intent(Intent.ACTION_VIEW);
i.setData(Uri.parse(url));
startActivity(i);