Come aprire un URL dal codice nel browser Web incorporato anziché all'interno della mia applicazione?

Ho provato questo:

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

ma ho ottenuto un'eccezione:

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

Prova questo:

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

Funziona bene per me.

Per quanto riguarda il "http: //" mancante farei semplicemente una cosa del genere:

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

Probabilmente vorrei anche pre-popolare il tuo EditText in cui l'utente sta digitando un URL con "http: //".

un modo comune per raggiungere questo obiettivo è con il codice seguente:

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

che potrebbe essere modificato in una versione del codice funzione ...

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

il più corto! :

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

buona programmazione!

Risposta semplice

Puoi vedere l'esempio ufficiale da 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);
    }
}

Come funziona

Dai un'occhiata al costruttore di Intent:

public Intent (String action, Uri uri)

È possibile passare l' android.net.Uriistanza al secondo parametro e viene creato un nuovo Intento basato sull'URL dei dati indicato.

Quindi, chiama semplicemente startActivity(Intent intent)per iniziare una nuova attività, che è in bundle con l'intento con l'URL specificato.

Ho bisogno ifdell'estratto conto?

Sì. La documentazione dice:

Se sul dispositivo non sono presenti app in grado di ricevere l'intento implicito, l'app si arresterà in modo anomalo quando chiama startActivity (). Per verificare innanzitutto che esista un'app per ricevere l'intento, chiama resolActivity () sull'oggetto Intent. Se il risultato è non nullo, esiste almeno un'app in grado di gestire l'intento ed è sicuro chiamare startActivity (). Se il risultato è nullo, non è necessario utilizzare l'intento e, se possibile, è necessario disabilitare la funzione che invoca l'intento.

indennità

Puoi scrivere in una riga quando crei l'istanza Intent come di seguito:

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

In 2.3, ho avuto più fortuna con

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

La differenza sta nell'uso Intent.ACTION_VIEWpiuttosto che nella stringa"android.intent.action.VIEW"

Prova questo:

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

oppure se vuoi che il tuo browser sia aperto nella tua attività, fai così:

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

e se si desidera utilizzare il controllo zoom nel browser, è possibile utilizzare:

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

Se vuoi mostrare all'utente una finestra di dialogo con tutto l'elenco dei browser, in modo che possa scegliere il preferito, ecco il codice di esempio:

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

}

Proprio come le soluzioni che altri hanno scritto (che funzionano bene), vorrei rispondere alla stessa cosa, ma con un suggerimento che penso che la maggior parte preferirebbe usare.

Nel caso in cui desideri che l'app inizi ad aprirsi in una nuova attività, indipendente dal tuo, invece di rimanere nello stesso stack, puoi usare questo codice:

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

C'è anche un modo per aprire l'URL nelle schede personalizzate di Chrome . Esempio in 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)
}

altra opzione In Carica URL nella stessa applicazione utilizzando Webview

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

Puoi anche andare in questo modo

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

Nel codice 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");

 }

}

In Manifest non dimenticare di aggiungere l'autorizzazione Internet ...

Webview può essere utilizzato per caricare Url nella tua applicazione. L'URL può essere fornito dall'utente in visualizzazione testo oppure è possibile codificarlo.

Inoltre, non dimenticare le autorizzazioni Internet in 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 versione del codice funzione ...

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


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

All'interno del blocco try, incolla il seguente codice, Android Intent utilizza direttamente il link all'interno delle parentesi graffe URI (Uniform Resource Identifier) ​​per identificare la posizione del link.

Puoi provare questo:

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

Semplice e best practice

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

Metodo 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 risposta di MarkB è giusta. Nel mio caso sto usando Xamarin e il codice da usare con C # e Xamarin è:

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

Queste informazioni sono tratte da: https://developer.xamarin.com/recipes/android/fundamentals/intent/open_a_webpage_in_the_browser_application/

Le schede personalizzate di Chrome sono ora disponibili:

Il primo passo è l'aggiunta della Libreria di supporto per schede personalizzate al file build.gradle:

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

E poi, per aprire una scheda personalizzata di Chrome:

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

Per maggiori informazioni: https://developer.chrome.com/multidevice/android/customtabs

Sulla base della risposta di Mark B e dei seguenti commenti:

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.URLUtilha il metodo che guessUrl(String)funziona perfettamente (anche con file://o data://) da Api level 1(Android 1.0). Usare come:

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

Nella chiamata Attività:

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

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

Controlla il guessUrlcodice completo per maggiori informazioni.

Ok, ho controllato ogni risposta ma quale app ha il deeplinking con lo stesso URL che l'utente vuole usare?

Oggi ho ricevuto questo caso e la risposta è browserIntent.setPackage("browser_package_name");

per esempio :

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

Grazie!

Semplice, visualizzazione del sito Web tramite intento,

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

usa questo semplice codice per visualizzare il tuo sito Web nell'app Android.

Aggiungi l'autorizzazione Internet nel file manifest,

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

Tale errore si è verificato a causa di un URL non valido, il sistema operativo Android non è in grado di trovare la visualizzazione dell'azione per i tuoi dati. Quindi hai verificato che l'URL sia valido o meno.

Penso che questo sia il migliore

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

Inserisci il codice qui sotto in classe globale

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

In questo modo utilizza un metodo per consentire di immettere qualsiasi stringa anziché disporre di un input fisso. Ciò consente di risparmiare alcune righe di codice se utilizzato più volte, poiché sono necessarie solo tre righe per chiamare il metodo.

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

L'uso di questo metodo lo rende universalmente utilizzabile. L'IT non deve essere inserito in un'attività specifica, in quanto è possibile utilizzarlo in questo modo:

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

O se vuoi avviarlo al di fuori di un'attività, devi semplicemente chiamare startActivity sull'istanza dell'attività:

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

Come si vede in entrambi questi blocchi di codice, è presente un controllo null. Questo perché restituisce null se non esiste un'app per gestire l'intento.

Per impostazione predefinita, questo metodo è HTTP se non è stato definito alcun protocollo, in quanto vi sono siti Web che non dispongono di un certificato SSL (ciò che è necessario per una connessione HTTPS) e smetteranno di funzionare se si tenta di utilizzare HTTPS e non è presente . Qualsiasi sito Web può comunque passare a HTTPS, quindi quelle parti ti atterrano su HTTPS in entrambi i modi

Poiché questo metodo utilizza risorse esterne per visualizzare la pagina, non è necessario dichiarare l'autorizzazione INternet. L'app che visualizza la pagina Web deve farlo

// Listener OnClick

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

// Il tuo metodo di utilità

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 andare con uno breve per aprire l'URL nel browser:

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

La risposta di Kotlin:

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

Ho aggiunto un'estensione Uriper renderlo ancora più semplice

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

Come bonus, ecco una semplice funzione di estensione per convertire in sicurezza una stringa in Uri.

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

Quindi ho cercato questo per molto tempo perché tutte le altre risposte stavano aprendo l'app predefinita per quel link, ma non il browser predefinito ed è quello che volevo.

Finalmente sono riuscito a farlo:

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

A proposito, puoi notare contextqualsiasi cosa, perché l'ho usato per un metodo util statico, se lo stai facendo in un'attività, non è necessario.

Controlla se l'URL è corretto. Per me c'era uno spazio indesiderato prima dell'url.

Prova questo ... Funzionato per me!

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

        }

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