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

1346

¿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
Arutha
fuente
66
Creo que es por esto: android-developers.blogspot.com/2009/12/…
Arutha
1
¿Por qué esto no funciona en algunos dispositivos? incluso si hay un navegador web, va a ActivityNotFoundException.
Estoy viendo el mismo problema que @Manu. La instalación básica en un Nexus 6 tiene cromo, pero los enlaces causan una excepción.
Brill Pappin

Respuestas:

2458

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: //".

Mark B
fuente
2
Excepto que su código y mbaird no son los mismos, por lo que puedo decir para lo que se publica. Asegúrese de que su URL tenga el http://esquema; la excepción que se muestra sugiere que su URL carece del esquema.
CommonsWare
55
Si ! Se perdió el http: //! El usuario ingresa la URL, ¿hay alguna forma de formatear automáticamente?
Arutha
44
URLUtil es una excelente manera de verificar las cadenas "url" ingresadas por el usuario
Dan
90
if (!url.startsWith("http://") && !url.startsWith("https://"))es un error común que puede llevarlo a URL como file: // y romper algunos buenos casos de uso. Intente analizar uri con la clase URI y verifique si hay un esquema. Si no, agregue "http: //";)
tuxSlayer
22
Necesita cheque nulo con resolveCheck. Consulte los 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 la intención, llame a resolveActivity () en su objeto Intent.
kenju
91

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!

Jorgesys
fuente
58

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));
kenju
fuente
3
Esto supone que la url suministrada tiene http .
IgorGanapolsky
57

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"

MikeNereson
fuente
1
¿Qué es lo diferente?
user1324936
1
Esta respuesta me ayudó inmensamente. No sé cuál fue la diferencia, pero tuvimos un problema con 2.3 que resolvió. ¿Alguien sabe cuál es la diferencia en la implementación?
Innova
2
Según el desarrollador de Android: esta respuesta: "Crear una intención con una acción determinada. Todos los demás campos (datos, tipo, clase) son nulos". y la respuesta aceptada: "Crear una intención con una acción determinada y para una URL de datos determinada"
Teo Inke
30

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);
nikki
fuente
44
Tenga en cuenta que los complementos y demás están deshabilitados en WebView, y que se requerirían los permisos de INTERNET. ( referencia )
22

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

}
Dmytro Danylyk
fuente
55
Si hay varias aplicaciones que pueden manejar la intención, el sistema proporcionará automáticamente un selector, ¿verdad?
Jeffrey Blattman
@ xmen-wk porque url puede iniciar ether con httpo https, y en java es una buena práctica declarar 'cadenas mágicas' como constantes.
Dmytro Danylyk
THX, no lo sabía context.startActivity. Muy útil cuando se llama desde una clase externa
WuerfelDev
18

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)
}
desarrollador de Android
fuente
¿Realizar 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. Por favor explique lo que está tratando de 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
2
@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_RESETestá en desuso
Pratik Butani
17

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");
Sanket
fuente
Tenga en cuenta que los complementos y demás están deshabilitados en WebView, y que se requerirían los permisos de INTERNET. ( referencia )
12

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 ...

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

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;
    }
}
Gorav Sharma
fuente
1
Esto solucionó mi problema de video: github.com/CrandellWS/VideoEnabledWebView/blob/master/app/src/…
CrandellWS
6

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)));
Jorgesys
fuente
6

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);
Kanwar_Singh
fuente
5

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*/
    }
Umasankar
fuente
Usar en context!!.packageManagerlugar de getPackageManager()en a Fragment.
CoolMind
4
String url = "http://www.example.com";
Intent i = new Intent(Intent.ACTION_VIEW);
i.setData(Uri.parse(url));
startActivity(i);
Pradeep Sodhi
fuente
3
Intent getWebPage = new Intent(Intent.ACTION_VIEW, Uri.parse(MyLink));          
startActivity(getWebPage);
TheOddAbhi
fuente
Bienvenido, novato. complete la respuesta, declarando las variables que no existen en el código original.
tony gil
3

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

francisco_ssb
fuente
2

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);
    }
}
divonas
fuente
2

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.

IG Pascual
fuente
2

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!

Vaibhav Kadam
fuente
Buena respuesta. Explica cómo abrir una URL de intención en un navegador específico (directamente) y no confiar en que el sistema elija un navegador.
Mr-IDE
2

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" /> 
apilamiento
fuente
2
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.

Mayur Sojitra
fuente
1

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);
    }
Karthik Sridharan
fuente
1

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

Zoe
fuente
1

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

    }
Faakhir
fuente
¿Dónde se define "isURL"?
Cabuxa.Mapache
1

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

Intent browserIntent = new Intent(Intent.ACTION_VIEW, Uri.parse("YourUrlHere"));
startActivity(browserIntent);
Gaurav Lambole
fuente
1

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
}
Gibolt
fuente
1

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.

bopol
fuente
0

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

Sonia John Kavery
fuente
0

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);
Debasish Ghosh
fuente
Para la mayoría de las aplicaciones, agregar un WebView es una forma difícil de hacerlo. Es más fácil abrir la URL en el navegador.
Zoe