Comment ouvrir une URL à partir du code dans le navigateur Web intégré plutôt que dans mon application?

J'ai essayé ceci:

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

mais j'ai une exception:

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

Essaye ça:

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

Cela fonctionne bien pour moi.

Quant au "http: //" manquant, je ferais juste quelque chose comme ceci:

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

Je voudrais également pré-remplir votre EditText dans lequel l'utilisateur tape une URL avec "http: //".

une façon courante d'y parvenir est avec le code suivant:

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

qui pourrait être changé en une version de code court ...

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

le plus court! :

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

codage heureux!

Réponse simple

Vous pouvez voir l'exemple officiel du développeur 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);
    }
}

Comment ça fonctionne

Veuillez consulter le constructeur de Intent:

public Intent (String action, Uri uri)

Vous pouvez passer l' android.net.Uriinstance au 2e paramètre et une nouvelle intention est créée en fonction de l'url de données donnée.

Et puis, appelez simplement startActivity(Intent intent)pour démarrer une nouvelle activité, qui est groupée avec l'intention avec l'URL donnée.

Ai-je besoin du ifrelevé de contrôle?

Oui. La documentation dit:

S'il n'y a aucune application sur l'appareil qui peut recevoir l'intention implicite, votre application se bloque lorsqu'elle appelle startActivity (). Pour vérifier d'abord qu'une application existe pour recevoir l'intention, appelez resolverActivity () sur votre objet Intent. Si le résultat n'est pas nul, il existe au moins une application qui peut gérer l'intention et il est sûr d'appeler startActivity (). Si le résultat est nul, vous ne devez pas utiliser l'intention et, si possible, vous devez désactiver la fonctionnalité qui invoque l'intention.

Prime

Vous pouvez écrire sur une ligne lors de la création de l'instance Intent comme ci-dessous:

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

En 2.3, j'ai eu plus de chance avec

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

La différence étant l'utilisation de Intent.ACTION_VIEWplutôt que la chaîne"android.intent.action.VIEW"

Essaye ça:

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

ou si vous voulez que le navigateur Web soit ouvert dans votre activité, faites comme ceci:

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

et si vous souhaitez utiliser le contrôle du zoom dans votre navigateur, vous pouvez utiliser:

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

Si vous souhaitez montrer à l'utilisateur un dialogue avec toutes les listes de navigateurs, afin qu'il puisse choisir celui que vous préférez, voici un exemple de code:

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

}

Tout comme les solutions que d'autres ont écrites (qui fonctionnent bien), je voudrais répondre à la même chose, mais avec un conseil que je pense que la plupart préféreraient utiliser.

Si vous souhaitez que l'application que vous commencez à ouvrir dans une nouvelle tâche, indépendante de la vôtre, au lieu de rester sur la même pile, vous pouvez utiliser ce code:

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

Il existe également un moyen d'ouvrir l'URL dans les onglets personnalisés de Chrome . Exemple à 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)
}

autre option In Load Url in Same Application using Webview

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

Vous pouvez également suivre cette voie

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

 }

}

Dans Manifest, n'oubliez pas d'ajouter une autorisation Internet ...

Webview peut être utilisé pour charger l'URL dans votre application. L'URL peut être fournie par l'utilisateur en mode texte ou vous pouvez la coder en dur.

N'oubliez pas non plus les autorisations Internet dans 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;
    }
}

Une version de code court ...

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


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

Dans votre bloc d'essai, collez le code suivant, Android Intent utilise directement le lien entre les accolades URI (Uniform Resource Identifier) ​​afin d'identifier l'emplacement de votre lien.

Vous pouvez essayer ceci:

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

Simple et meilleure pratique

Méthode 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éthode 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 réponse de MarkB est juste. Dans mon cas, j'utilise Xamarin, et le code à utiliser avec C # et Xamarin est:

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

Ces informations sont extraites de: https://developer.xamarin.com/recipes/android/fundamentals/intent/open_a_webpage_in_the_browser_application/

Les onglets personnalisés de Chrome sont désormais disponibles:

La première étape consiste à ajouter la bibliothèque de prise en charge des onglets personnalisés à votre fichier build.gradle:

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

Et puis, pour ouvrir un onglet personnalisé Chrome:

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

Pour plus d'informations: https://developer.chrome.com/multidevice/android/customtabs

Sur la base de la réponse de Mark B et des commentaires ci-dessous:

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.URLUtila la méthode guessUrl(String)fonctionne parfaitement bien (même avec file://ou data://) depuis Api level 1(Android 1.0). Utilisé comme:

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

Dans l'appel d'activité:

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

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

Consultez le guessUrlcode complet pour plus d'informations.

D'accord, j'ai vérifié toutes les réponses, mais quelle application a un lien profond avec la même URL que l'utilisateur veut utiliser?

Aujourd'hui, j'ai ce cas et la réponse est browserIntent.setPackage("browser_package_name");

par exemple :

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

Je vous remercie!

Affichage simple du site Web via l'intention,

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

utilisez ce code simple pour visualiser votre site Web dans l'application Android.

Ajouter une autorisation Internet dans le fichier manifeste,

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

Cette erreur s'est produite en raison d'une URL non valide, Android OS ne peut pas trouver la vue d'action pour vos données. Vous avez donc validé que l'URL est valide ou non.

Je pense que c'est le meilleur

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

Mettre le code ci-dessous en 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);
    }

Cette méthode utilise une méthode pour vous permettre de saisir n'importe quelle chaîne au lieu d'avoir une entrée fixe. Cela enregistre certaines lignes de code si elles sont utilisées plusieurs fois, car vous n'avez besoin que de trois lignes pour appeler la méthode.

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'utilisation de cette méthode la rend universellement utilisable. L'informatique ne doit pas être placée dans une activité spécifique, car vous pouvez l'utiliser comme ceci:

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

Ou si vous souhaitez le démarrer en dehors d'une activité, vous appelez simplement startActivity sur l'instance d'activité:

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

Comme on le voit dans ces deux blocs de code, il y a une vérification nulle. C'est comme s'il renvoie null s'il n'y a pas d'application pour gérer l'intention.

Cette méthode est par défaut HTTP si aucun protocole n'est défini, car il existe des sites Web qui n'ont pas de certificat SSL (ce dont vous avez besoin pour une connexion HTTPS) et ceux-ci cesseront de fonctionner si vous essayez d'utiliser HTTPS et il n'est pas là . Tout site Web peut toujours forcer HTTPS, donc ces côtés vous amènent à HTTPS de toute façon

Étant donné que cette méthode utilise des ressources externes pour afficher la page, vous n'avez pas besoin de déclarer l'autorisation INternet. L'application qui affiche la page Web doit le faire

// Écouteur OnClick

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

// Votre méthode d'utilisation

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

    }

Allez simplement avec un court pour ouvrir votre URL dans le navigateur:

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

La réponse de Kotlin:

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

J'ai ajouté une extension Uripour rendre cela encore plus facile

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

En bonus, voici une fonction d'extension simple pour convertir en toute sécurité une chaîne en Uri.

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

J'ai donc cherché cela depuis longtemps parce que toutes les autres réponses ouvraient l'application par défaut pour ce lien, mais pas le navigateur par défaut et c'est ce que je voulais.

J'ai finalement réussi à le faire:

// 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, vous pouvez remarquer contextn'importe quoi, parce que je l'ai utilisé pour une méthode d'utilisation statique, si vous faites cela dans une activité, ce n'est pas nécessaire.

Vérifiez si votre URL est correcte. Pour moi, il y avait un espace indésirable avant l'URL.

Essayez ceci .. travaillé pour moi!

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

        }

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