Wie öffne ich eine URL aus Code im integrierten Webbrowser und nicht in meiner Anwendung?

Ich habe es versucht:

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

aber ich habe eine Ausnahme:

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

Versuche dies:

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

Das funktioniert gut für mich.

Was das fehlende "http: //" betrifft, würde ich einfach so etwas machen:

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

Ich würde wahrscheinlich auch Ihren EditText vorab ausfüllen, dass der Benutzer eine URL mit "http: //" eingibt.

Ein üblicher Weg, dies zu erreichen, ist der nächste Code:

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

das könnte in eine Kurzcodeversion geändert werden ...

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

oder :

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

der kürzeste! ::

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

Viel Spaß beim Codieren!

Einfache Antwort

Sie können das offizielle Beispiel von Android Developer sehen .

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

Wie es funktioniert

Bitte werfen Sie einen Blick auf den Konstruktor von Intent:

public Intent (String action, Uri uri)

Sie können die android.net.UriInstanz an den zweiten Parameter übergeben, und basierend auf der angegebenen Daten-URL wird eine neue Absicht erstellt.

Rufen Sie dann einfach startActivity(Intent intent)an, um eine neue Aktivität zu starten, die mit der Absicht mit der angegebenen URL gebündelt ist.

Benötige ich die ifScheckanweisung?

Ja. Die Dokumentation sagt:

Wenn sich auf dem Gerät keine Apps befinden, die die implizite Absicht empfangen können, stürzt Ihre App ab, wenn sie startActivity () aufruft. Um zunächst zu überprüfen, ob eine App zum Empfangen der Absicht vorhanden ist, rufen Sie resolveActivity () für Ihr Intent-Objekt auf. Wenn das Ergebnis nicht null ist, gibt es mindestens eine App, die die Absicht verarbeiten kann, und es ist sicher, startActivity () aufzurufen. Wenn das Ergebnis null ist, sollten Sie die Absicht nicht verwenden und wenn möglich die Funktion deaktivieren, die die Absicht aufruft.

Bonus

Sie können beim Erstellen der Intent-Instanz wie folgt in eine Zeile schreiben:

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

In 2.3 hatte ich besseres Glück mit

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

Der Unterschied besteht in der Verwendung von Intent.ACTION_VIEWanstelle des Strings"android.intent.action.VIEW"

Versuche dies:

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

oder wenn Sie möchten, dass der Webbrowser in Ihrer Aktivität geöffnet wird, gehen Sie wie folgt vor:

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

Wenn Sie die Zoomsteuerung in Ihrem Browser verwenden möchten, können Sie Folgendes verwenden:

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

Wenn Sie dem Benutzer einen Dialog mit allen Browserlisten anzeigen möchten, damit er die bevorzugte auswählen kann, finden Sie hier einen Beispielcode:

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

}

Genau wie die Lösungen, die andere geschrieben haben (die gut funktionieren), möchte ich das Gleiche beantworten, aber mit einem Tipp, den die meisten meiner Meinung nach lieber verwenden würden.

Wenn Sie möchten, dass die App, die Sie öffnen, unabhängig von Ihrer eigenen Aufgabe in einer neuen Aufgabe geöffnet wird, anstatt auf demselben Stapel zu bleiben, können Sie diesen Code verwenden:

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

Es gibt auch eine Möglichkeit, die URL in benutzerdefinierten Chrome-Registerkarten zu öffnen . Beispiel 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)
}

andere Option Beim Laden der URL in derselben Anwendung mithilfe von Webview

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

Sie können auch diesen Weg gehen

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

Im Java-Code:

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

 }

}

Vergessen Sie im Manifest nicht, die Internet-Berechtigung hinzuzufügen ...

Mit Webview können Sie die URL in Ihre Anwendung laden. Die URL kann vom Benutzer in der Textansicht angegeben oder fest codiert werden.

Vergessen Sie auch nicht die Internetberechtigungen 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;
    }
}

Eine Kurzcode-Version ...

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


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

Fügen Sie in Ihrem Try-Block den folgenden Code ein. Android Intent verwendet den Link direkt in den URI-Klammern (Uniform Resource Identifier), um den Speicherort Ihres Links zu identifizieren.

Sie können dies versuchen:

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

Einfache und bewährte Methode

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

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

Die Antwort von MarkB ist richtig. In meinem Fall verwende ich Xamarin und der Code für C # und Xamarin lautet:

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

Diese Informationen stammen von: https://developer.xamarin.com/recipes/android/fundamentals/intent/open_a_webpage_in_the_browser_application/

Benutzerdefinierte Chrome-Registerkarten sind jetzt verfügbar:

Der erste Schritt ist das Hinzufügen der Support-Bibliothek für benutzerdefinierte Registerkarten zu Ihrer build.gradle-Datei:

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

Und dann, um eine benutzerdefinierte Chrome-Registerkarte zu öffnen:

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

Für weitere Informationen: https://developer.chrome.com/multidevice/android/customtabs

Basierend auf der Antwort von Mark B und den Kommentaren unten:

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.URLUtilhat die Methode guessUrl(String)perfekt funktioniert (auch mit file://oder data://) seit Api level 1(Android 1.0). Benutzen als:

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

Im Aktivitätsaufruf:

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

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

Überprüfen Sie den vollständigen guessUrlCode für weitere Informationen.

Okay, ich habe jede Antwort überprüft, aber welche App hat eine Verknüpfung mit derselben URL, die der Benutzer verwenden möchte?

Heute habe ich diesen Fall bekommen und die Antwort ist browserIntent.setPackage("browser_package_name");

z.B :

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

Vielen Dank!

Einfache Website-Ansicht über Absicht,

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

Verwenden Sie diesen einfachen Code, um Ihre Website in der Android App anzuzeigen.

Internetberechtigung in Manifestdatei hinzufügen,

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

Dieser Fehler ist aufgrund einer ungültigen URL aufgetreten. Android OS kann keine Aktionsansicht für Ihre Daten finden. Sie müssen also überprüfen, ob die URL gültig ist oder nicht.

Ich denke das ist das Beste

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

Fügen Sie den folgenden Code in die globale Klasse ein

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

Auf diese Weise wird eine Methode verwendet, mit der Sie einen beliebigen String eingeben können, anstatt eine feste Eingabe zu haben. Dies spart einige Codezeilen, wenn sie mehrmals verwendet werden, da Sie nur drei Zeilen benötigen, um die Methode aufzurufen.

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

Mit dieser Methode ist sie universell einsetzbar. Die IT muss nicht in eine bestimmte Aktivität eingeordnet werden, da Sie sie folgendermaßen verwenden können:

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

Wenn Sie es außerhalb einer Aktivität starten möchten, rufen Sie einfach startActivity für die Aktivitätsinstanz auf:

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

Wie in diesen beiden Codeblöcken zu sehen ist, gibt es eine Nullprüfung. Dies ist, da es null zurückgibt, wenn es keine App gibt, die die Absicht handhabt.

Diese Methode verwendet standardmäßig HTTP, wenn kein Protokoll definiert ist, da es Websites gibt, die kein SSL-Zertifikat haben (was Sie für eine HTTPS-Verbindung benötigen), und diese funktionieren nicht mehr, wenn Sie versuchen, HTTPS zu verwenden, und es nicht vorhanden ist . Jede Website kann weiterhin auf HTTPS umsteigen, sodass Sie auf beiden Seiten bei HTTPS landen

Da diese Methode externe Ressourcen zum Anzeigen der Seite verwendet, müssen Sie die INternet-Berechtigung nicht deklarieren. Die App, die die Webseite anzeigt, muss dies tun

// OnClick Listener

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

// Ihre Util-Methode

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

    }

Gehen Sie einfach mit einer kurzen, um Ihre URL im Browser zu öffnen:

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

Die Kotlin-Antwort:

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

Ich habe eine Erweiterung hinzugefügt Uri, um dies noch einfacher zu machen

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

Als Bonus gibt es hier eine einfache Erweiterungsfunktion, mit der Sie einen String sicher in Uri konvertieren können.

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

Ich habe lange danach gesucht, weil alle anderen Antworten die Standard-App für diesen Link öffneten, aber nicht den Standardbrowser, und genau das wollte ich.

Ich habe es endlich geschafft:

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

contextÜbrigens können Sie feststellen, was auch immer, da ich dies für eine statische util-Methode verwendet habe. Wenn Sie dies in einer Aktivität tun, wird es nicht benötigt.

Überprüfen Sie, ob Ihre URL korrekt ist. Für mich gab es einen unerwünschten Platz vor der URL.

Versuchen Sie dies .. Für mich gearbeitet!

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

        }

XML-Code: -

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

--------- ODER------------------

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