Como abrir um URL a partir do código no navegador da Web incorporado, e não no meu aplicativo?

Eu tentei isso:

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

mas eu recebi uma exceção:

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

Tente o seguinte:

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

Isso funciona bem para mim.

Quanto ao "http: //" ausente, eu faria algo assim:

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

Eu provavelmente também preencheu seu EditText de que o usuário está digitando uma URL com "http: //".

Uma maneira comum de conseguir isso é com o próximo código:

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

que pode ser alterado para uma versão de código curto ...

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

ou:

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

o mais curto! :

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

feliz codificação!

Resposta Simples

Você pode ver a amostra oficial do Android Developer .

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

Como funciona

Por favor, dê uma olhada no construtor de Intent:

public Intent (String action, Uri uri)

Você pode passar a android.net.Uriinstância para o segundo parâmetro e um novo Intent é criado com base no URL de dados fornecido.

E, em seguida, basta ligar startActivity(Intent intent)para iniciar uma nova atividade, que acompanha o Intent com o URL fornecido.

Preciso da ifdeclaração de cheque?

Sim. Os documentos dizem:

Se não houver aplicativos no dispositivo que possam receber a intenção implícita, seu aplicativo falhará quando chamar startActivity (). Para verificar primeiro se existe um aplicativo para receber a intenção, chame resolveActivity () no seu objeto Intent. Se o resultado for não nulo, há pelo menos um aplicativo que pode lidar com a intenção e é seguro chamar startActivity (). Se o resultado for nulo, você não deve usar a intenção e, se possível, desabilitar o recurso que chama a intenção.

Bônus

Você pode escrever em uma linha ao criar a instância Intent, como abaixo:

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

Em 2.3, tive melhor sorte com

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

A diferença é o uso de, Intent.ACTION_VIEWe não a String"android.intent.action.VIEW"

Tente o seguinte:

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

ou, se desejar, o navegador da web será aberto em sua atividade e faça o seguinte:

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

e se você quiser usar o controle de zoom no seu navegador, poderá usar:

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

Se você deseja mostrar ao usuário um diálogo com toda a lista de navegadores, para que ele possa escolher o preferido, aqui está um código de exemplo:

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

}

Assim como as soluções que outros escreveram (que funcionam bem), gostaria de responder a mesma coisa, mas com uma dica que acho que a maioria prefere usar.

Caso deseje que o aplicativo comece a abrir em uma nova tarefa, independente de sua preferência, em vez de permanecer na mesma pilha, você pode 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);

Também há uma maneira de abrir o URL nas guias personalizadas do Chrome . Exemplo no 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)
}

outra opção Em Carregar URL no mesmo aplicativo usando Webview

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

Você também pode ir por esse caminho

Em 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" />

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

 }

}

No Manifest, não se esqueça de adicionar permissão à Internet ...

O Webview pode ser usado para carregar o URL em seu aplicativo. O URL pode ser fornecido pelo usuário na exibição de texto ou você pode codificá-lo.

Também não se esqueça das permissões da Internet no 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;
    }
}

Uma versão de código curto ...

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


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

No bloco try, cole o código a seguir, o Android Intent usa diretamente o link nos chaves URI (Uniform Resource Identifier) ​​para identificar o local do seu link.

Você pode tentar isso:

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

Simples e Prática Recomendada

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

A resposta do MarkB está certa. No meu caso, estou usando o Xamarin, e o código a ser usado com C # e Xamarin é:

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

Esta informação é obtida em: https://developer.xamarin.com/recipes/android/fundamentals/intent/open_a_webpage_in_the_browser_application/

As guias personalizadas do Chrome já estão disponíveis:

A primeira etapa é adicionar a Biblioteca de suporte a guias personalizadas ao seu arquivo build.gradle:

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

E então, para abrir uma guia personalizada do Chrome:

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

Para mais informações: https://developer.chrome.com/multidevice/android/customtabs

Com base na resposta de Mark B e nos comentários abaixo:

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.URLUtiltem o método guessUrl(String)funcionando perfeitamente (mesmo com file://ou data://) desde Api level 1(Android 1.0). Use 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

Na chamada de atividade:

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

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

Verifique o guessUrlcódigo completo para mais informações.

Ok, verifiquei todas as respostas, mas qual aplicativo tem um aprofundamento na mesma URL que o usuário deseja usar?

Hoje eu peguei esse caso e a resposta é browserIntent.setPackage("browser_package_name");

por exemplo :

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

Obrigado!

Visualização simples do site por intenção,

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

use este código simples para visualizar seu site no aplicativo Android.

Adicione permissão à Internet no arquivo de manifesto,

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

Esse erro ocorreu devido a URL inválido, o sistema operacional Android não consegue encontrar a exibição de ações para seus dados. Portanto, você confirma que o URL é válido ou não.

Eu acho que esse é o melhor

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

Coloque o código abaixo na classe 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);
    }

Dessa maneira, é utilizado um método para permitir a entrada de qualquer String em vez de ter uma entrada fixa. Isso economiza algumas linhas de código se usado várias vezes, pois você só precisa de três linhas para chamar o 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;
}

O uso desse método o torna universalmente utilizável. A TI não precisa ser colocada em uma atividade específica, pois você pode usá-la assim:

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

Ou, se você deseja iniciá-lo fora de uma atividade, basta chamar startActivity na instância da atividade:

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

Como visto nesses dois blocos de código, há uma verificação nula. É assim que retorna nulo se não houver um aplicativo para lidar com a intenção.

O método padrão é HTTP, se não houver um protocolo definido, pois existem sites que não possuem um certificado SSL (o que você precisa para uma conexão HTTPS) e esses pararão de funcionar se você tentar usar HTTPS e ele não estiver lá. . Qualquer site ainda pode forçar o HTTPS, então esses lados o levam ao HTTPS de qualquer maneira

Como esse método usa recursos externos para exibir a página, não é necessário declarar a permissão INternet. O aplicativo que exibe a página da web precisa fazer isso

// Ouvinte do OnClick

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

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

    }

Basta ir com um pequeno para abrir seu URL no navegador:

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

A resposta de Kotlin:

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

Eu adicionei uma extensão Uripara tornar isso ainda mais 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 bônus, aqui está uma função de extensão simples para converter com segurança uma String em Uri.

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

Por isso, procurei por um longo tempo, porque todas as outras respostas estavam abrindo o aplicativo padrão para esse link, mas não o navegador padrão e era isso que eu queria.

Finalmente consegui:

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

BTW, você pode notar. contextSeja como for, porque eu usei isso para um método utilitário estático, se você estiver fazendo isso em uma atividade, não será necessário.

Verifique se o seu URL está correto. Para mim, havia um espaço indesejado antes do URL.

Tente isso .. Trabalhou para mim!

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

--------- OU ------------------

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