Comment puis-je ouvrir une URL dans le navigateur Web d'Android à partir de mon application?

1346

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
Arutha
la source
6
Je pense que c'est à cause de cela: android-developers.blogspot.com/2009/12/…
Arutha
1
Pourquoi cela ne fonctionne-t-il pas sur certains appareils? même s'il existe un navigateur Web, il passe à ActivityNotFoundException.
Je vois le même problème que @Manu. L'installation de base sur un Nexus 6, a du chrome, mais des liens provoquant une exception.
Brill Pappin

Réponses:

2459

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

Mark B
la source
2
Sauf que votre code et mbaird ne sont pas les mêmes, d'après ce que je peux dire pour ce qui est publié. Assurez-vous que votre URL a le http://schéma - l'exception indiquée suggère que votre URL n'a pas le schéma.
CommonsWare
5
Oui ! Il a manqué le http: //! L'URL est entrée par l'utilisateur, existe-t-il un moyen de formater automatiquement?
Arutha
4
URLUtil est un excellent moyen de vérifier les chaînes "url" entrées par l'utilisateur
Dan
90
if (!url.startsWith("http://") && !url.startsWith("https://"))est une erreur courante qui peut vous conduire à des URL comme file: // et à casser quelques bonnes utilisations. Essayez d'analyser uri avec la classe URI et vérifiez s'il existe un schéma. Si non, ajoutez "http: //";)
tuxSlayer
22
Vous devez vérifier zéro avec resolveCheck. Voir les documents officiels : Attention: S'il n'y a aucune application sur l'appareil qui peut recevoir l'intention implicite, votre application se bloquera lorsqu'elle appellera startActivity (). Pour vérifier d'abord qu'une application existe pour recevoir l'intention, appelez resolverActivity () sur votre objet Intent.
kenju
91

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!

Jorgesys
la source
58

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));
kenju
la source
3
Cela suppose que l'URL fournie contient http .
IgorGanapolsky
57

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"

MikeNereson
la source
1
quelle est la différence?
user1324936
1
Cette réponse m'a énormément aidé. Je ne sais pas quelle était la différence, mais nous avons eu un problème avec 2.3 que cela a résolu. Quelqu'un sait-il quelle est la différence dans la mise en œuvre?
Innova
2
Selon Android Developer: cette réponse - "Créer une intention avec une action donnée. Tous les autres champs (données, type, classe) sont nuls." et la réponse acceptée - "Créer une intention avec une action donnée et pour une URL de données donnée."
Teo Inke
30

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);
nikki
la source
4
Notez que les plugins et autres sont désactivés dans WebView, et que les autorisations INTERNET seraient nécessaires. ( référence )
22

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

}
Dmytro Danylyk
la source
5
s'il y a plusieurs applications qui peuvent gérer l'intention, le système fournira automatiquement un sélecteur, non?
Jeffrey Blattman
@ xmen-wk car l'url peut démarrer l'éther avec httpou https, et en java, c'est une bonne pratique de déclarer des "chaînes magiques" comme constantes.
Dmytro Danylyk
thx, ne savait pas context.startActivity. Très utile lors de l'appel depuis une classe externe
WuerfelDev
18

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)
}
développeur android
la source
Une nouvelle tâche protégera-t-elle l'application source des bogues et des plantages, au cas où le navigateur Web aurait des problèmes?
The Original Android
@TheOriginalAndroid Je ne comprends pas ce que cela a à voir avec les plantages et le navigateur Web. Veuillez expliquer ce que vous essayez de faire.
développeur Android
Merci pour votre réponse. Votre message est intéressant. Quel est l'avantage d'ouvrir une nouvelle tâche en particulier pour un lancement Web?
L'original Android
2
@TheOriginalAndroid Juste pour que l'utilisateur puisse revenir à votre application, puis revenir au navigateur Web. Si vous ouvrez l'écran des tâches récentes, vous verrez 2 tâches ici au lieu d'une. De plus, au lieu de voir une vignette de navigateur Web dans la tâche unique (qui appartient à la tâche de votre application), vous verrez 2: une de votre application et une autre du navigateur Web. Je pense que c'est moins déroutant de cette façon.
développeur Android
FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESETest déconseillé
Pratik Butani
17

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");
Sanket
la source
Notez que les plugins et autres sont désactivés dans WebView, et que les autorisations INTERNET seraient nécessaires. ( référence )
12

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 ...

Aristo Michael
la source
C'est intéressant et différent. Je suppose que de cette façon, l'utilisateur voit un navigateur Web dans mon application. Est-ce correct? Je vote positivement.
The Original Android
9

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;
    }
}
Gorav Sharma
la source
1
Cela a résolu mon problème de vidéo: github.com/CrandellWS/VideoEnabledWebView/blob/master/app/src/…
CrandellWS
6

Une version de code court ...

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


 startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse(strUrl)));
Jorgesys
la source
6

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);
Kanwar_Singh
la source
5

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*/
    }
Umasankar
la source
Utilisez context!!.packageManagerau lieu de getPackageManager()dans un Fragment.
CoolMind
4
String url = "http://www.example.com";
Intent i = new Intent(Intent.ACTION_VIEW);
i.setData(Uri.parse(url));
startActivity(i);
Pradeep Sodhi
la source
3
Intent getWebPage = new Intent(Intent.ACTION_VIEW, Uri.parse(MyLink));          
startActivity(getWebPage);
TheOddAbhi
la source
bienvenue, novice. veuillez compléter la réponse en déclarant des variables qui n'existent pas dans le code d'origine.
tony gil
3

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

francisco_ssb
la source
2

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);
    }
}
divonas
la source
2

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.

IG Pascual
la source
2

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!

Vaibhav Kadam
la source
Bonne réponse. Il explique comment ouvrir une URL d'intention sur un navigateur spécifique (directement) et ne pas se fier au système qui choisit un navigateur.
Mr-IDE
2

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" /> 
stacktry
la source
2
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.

Mayur Sojitra
la source
1

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);
    }
Karthik Sridharan
la source
1

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

Zoé
la source
1

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

    }
Faakhir
la source
Où est défini "isURL"?
Cabuxa.Mapache
1

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

Intent browserIntent = new Intent(Intent.ACTION_VIEW, Uri.parse("YourUrlHere"));
startActivity(browserIntent);
Gaurav Lambole
la source
1

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
}
Gibolt
la source
1

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.

bopol
la source
0

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

Sonia John Kavery
la source
0

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);
Debasish Ghosh
la source
Pour la plupart des applications, l'ajout d'une WebView est un moyen difficile de le faire. Il est plus facile d'ouvrir l'URL dans le navigateur.
Zoe