Jak otworzyć adres URL z kodu we wbudowanej przeglądarce internetowej zamiast w mojej aplikacji?

Próbowałem tego:

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

ale mam wyjątek:

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

Spróbuj tego:

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

To mi odpowiada.

Jeśli chodzi o brakujące „http: //”, po prostu zrobiłbym coś takiego:

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

Prawdopodobnie wstępnie wypełniłbym również Twój tekst EditText, w którym użytkownik wpisuje adres URL „http: //”.

powszechnym sposobem osiągnięcia tego jest następny kod:

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

które można zmienić na wersję z krótkim kodem ...

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

lub:

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

najkrótszy! :

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

szczęśliwego kodowania!

Prosta odpowiedź

Możesz zobaczyć oficjalną próbkę od programisty Androida .

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

Jak to działa

Proszę spojrzeć na konstruktora Intent:

public Intent (String action, Uri uri)

Możesz przejść android.net.Uri instancję do drugiego parametru, a nowa intencja zostanie utworzona na podstawie podanego adresu danych.

A potem po prostu zadzwoń startActivity(Intent intent) aby rozpocząć nową Aktywność, która jest powiązana z Zamiarem z danym adresem URL.

Czy potrzebuję if wyciągu czeku?

Tak. W docs mówi:

Jeśli na urządzeniu nie ma żadnych aplikacji, które mogłyby przyjąć ukryte zamiary, aplikacja ulegnie awarii, gdy wywoła startActivity (). Aby najpierw sprawdzić, czy aplikacja istnieje, aby otrzymać zamiar, wywołaj polecenie resolActivity () na obiekcie Intent. Jeśli wynik nie jest równy null, istnieje co najmniej jedna aplikacja, która może obsłużyć zamiar i można bezpiecznie wywołać startActivity (). Jeśli wynik jest zerowy, nie należy używać zamiaru i, jeśli to możliwe, należy wyłączyć funkcję wywołującą zamiar.

Premia

Możesz pisać w jednym wierszu podczas tworzenia instancji Intent, jak poniżej:

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

W 2.3 miałem więcej szczęścia

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

Różnica polega na użyciu Intent.ACTION_VIEWraczej niż ciągu"android.intent.action.VIEW"

Spróbuj tego:

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

lub jeśli chcesz, otwórz przeglądarkę internetową w swojej działalności, wykonaj następujące czynności:

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

a jeśli chcesz użyć sterowania powiększeniem w przeglądarce, możesz użyć:

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

Jeśli chcesz pokazać użytkownikowi dialog ze wszystkimi listami przeglądarki, aby mógł wybrać preferowany, oto przykładowy kod:

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

}

Tak jak rozwiązania napisane przez inne (które działają dobrze), chciałbym odpowiedzieć na to samo, ale wskazówką, którą moim zdaniem wolałby najczęściej używać.

Jeśli chcesz, aby aplikacja zaczęła się otwierać w nowym zadaniu, niezależnie od Twojego, zamiast pozostać na tym samym stosie, możesz użyć tego kodu:

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

Istnieje również sposób otwarcia adresu URL w niestandardowych kartach Chrome . Przykład w 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)
}

inna opcja W Załaduj adres URL w tej samej aplikacji za pomocą Webview

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

Możesz także iść tą drogą

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

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

 }

}

W Manifeście nie zapomnij dodać uprawnienia do Internetu ...

Widoku internetowego można użyć do załadowania adresu URL do aplikacji. Adres URL może zostać podany przez użytkownika w widoku tekstowym lub można go zakodować na stałe.

Nie zapomnij także o uprawnieniach internetowych w 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;
    }
}

Wersja krótkiego kodu ...

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


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

W bloku try wklej następujący kod, Android Intent używa bezpośrednio linku w nawiasach klamrowych URI (Uniform Resource Identifier) ​​w celu identyfikacji lokalizacji twojego linku.

Możesz spróbować:

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

Prosta i najlepsza praktyka

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

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

Odpowiedź MarkB jest słuszna. W moim przypadku używam Xamarin, a kod do użycia z C # i Xamarin to:

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

Te informacje są pobierane z: https://developer.xamarin.com/recipes/android/fundamentals/intent/open_a_webpage_in_the_browser_application/

Niestandardowe karty Chrome są teraz dostępne:

Pierwszym krokiem jest dodanie biblioteki obsługi niestandardowych kart do pliku build.gradle:

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

A następnie, aby otworzyć niestandardową kartę chrome:

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

Aby uzyskać więcej informacji: https://developer.chrome.com/multidevice/android/customtabs

Na podstawie odpowiedzi Marka B i poniższych komentarzy:

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.URLUtilmetoda guessUrl(String)działa idealnie dobrze (nawet z file://lub data://) od Api level 1(Android 1.0). Użyj jako:

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

W wywołaniu aktywności:

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

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

Sprawdź pełny guessUrlkod, aby uzyskać więcej informacji.

OK, sprawdziłem każdą odpowiedź, ale jakiej aplikacji ma linkowanie z tym samym adresem URL, którego użytkownik chce użyć?

Dzisiaj dostałem tę sprawę i odpowiedź brzmi browserIntent.setPackage("browser_package_name");

np .:

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

Dziękuję Ci!

Prosty, przeglądanie strony za pomocą intencji,

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

użyj tego prostego kodu, aby wyświetlić swoją stronę internetową w aplikacji na Androida.

Dodaj pozwolenie internetowe w pliku manifestu,

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

Ten błąd wystąpił z powodu nieprawidłowego adresu URL, system operacyjny Android nie może znaleźć widoku akcji dla danych. Sprawdziłeś więc, czy adres URL jest prawidłowy czy nie.

Myślę, że to jest najlepsze

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

Umieść poniższy kod w klasie globalnej

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

W ten sposób wykorzystuje się metodę, która pozwala na wprowadzenie dowolnego ciągu zamiast stałego wejścia. Powoduje to zaoszczędzenie niektórych wierszy kodu, jeśli są używane wielokrotnie, ponieważ do wywołania metody potrzebne są tylko trzy wiersze.

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

Zastosowanie tej metody sprawia, że ​​jest ona uniwersalnie użyteczna. IT nie musi być umieszczane w konkretnym działaniu, ponieważ możesz go użyć w następujący sposób:

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

Lub jeśli chcesz uruchomić go poza działaniem, wystarczy wywołać startActivity w instancji działania:

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

Jak widać w obu tych blokach kodu, istnieje kontrola zerowa. Dzieje się tak, ponieważ zwraca wartość null, jeśli nie ma aplikacji do obsługi zamiaru.

Domyślną metodą tej metody jest HTTP, jeśli nie zdefiniowano żadnego protokołu, ponieważ istnieją strony internetowe, które nie mają certyfikatu SSL (co jest potrzebne do połączenia HTTPS), a te przestaną działać, jeśli spróbujesz użyć HTTPS i nie ma go . Każda witryna może nadal wymuszać przejście na HTTPS, więc strony te i tak trafią na HTTPS

Ponieważ ta metoda wykorzystuje zasoby zewnętrzne do wyświetlenia strony, nie ma potrzeby deklarowania uprawnień INternet. Musi to zrobić aplikacja wyświetlająca stronę internetową

// Odbiornik OnClick

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

// Twoja metoda użycia

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

    }

Wystarczy otworzyć krótki, aby otworzyć adres URL w przeglądarce:

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

Odpowiedź Kotlina:

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

Dodałem rozszerzenie, Uriaby było to jeszcze łatwiejsze

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

Jako bonus, tutaj jest prosta funkcja rozszerzenia, aby bezpiecznie przekonwertować ciąg na Uri.

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

Szukałem tego przez długi czas, ponieważ wszystkie inne odpowiedzi otwierały domyślną aplikację dla tego linku, ale nie domyślną przeglądarkę i tego właśnie chciałem.

W końcu udało mi się to zrobić:

// 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, możesz zauważyć. contextCokolwiek, ponieważ użyłem tego do statycznej metody użycia, jeśli robisz to w działaniu, nie jest to konieczne.

Sprawdź, czy Twój adres URL jest poprawny. Dla mnie była niechciana przestrzeń przed adresem URL.

Spróbuj tego .. Pracował dla mnie!

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

        }

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

--------- LUB ------------------

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