Comment puis-je ouvrir une URL dans un navigateur Web Android à partir de mon application?
Comment ouvrir une URL à partir de 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 eu 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.
En ce qui concerne le "http: //" manquant, je ferais juste quelque chose comme ceci:
if (!url.startsWith("http://") && !url.startsWith("https://"))
url = "http://" + url;
Je voudrais aussi probablement pré-remplir votre EditText que l'utilisateur est en train de taper une URL avec "http: //".
un moyen courant d'y parvenir est d'utiliser le code suivant:
String url = "http://www.stackoverflow.com";
Intent i = new Intent(Intent.ACTION_VIEW);
i.setData(Uri.parse(url));
startActivity(i);
cela 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!
En 2.3, j'avais 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_VIEW plutôt que de la chaîne "Android.intent.action.VIEW"
Réponse simple
Vous pouvez voir l’échantillon officiel de 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);
}
}
Comment ça fonctionne
S'il vous plaît jeter un oeil sur le constructeur de Intent :
public Intent (String action, Uri uri)
Vous pouvez passer l'instance Android.net.Uri au deuxième paramètre et créer une nouvelle intention en fonction de l'URL de données indiquée.
Ensuite, appelez simplement startActivity(Intent intent) pour démarrer une nouvelle activité, qui est fournie avec l’intention avec l’URL donnée.
Ai-je besoin de l'instruction if check?
Oui. Le docs dit:
Si aucune application sur l'appareil ne 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 resolActivity () sur votre objet Intent. Si le résultat est non nul, il existe au moins une application capable de gérer l'intention. Vous pouvez également appeler startActivity () en toute sécurité. Si le résultat est null, vous ne devez pas utiliser l'intention et, si possible, vous devez désactiver la fonctionnalité qui appelle l'intention.
Prime
Vous pouvez écrire sur une ligne lors de la création de l'instance d'intention, comme ci-dessous:
Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(url));
Essaye ça:
Uri uri = Uri.parse("https://www.google.com");
startActivity(new Intent(Intent.ACTION_VIEW, uri));
ou si vous voulez alors le navigateur Web ouvert dans votre activité alors 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 la liste de tous les navigateurs, afin qu'il puisse choisir préféré, 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), j'aimerais répondre à la même chose, mais avec un conseil 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 Onglets personnalisés 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 Dans l'URL de chargement dans la même application à l'aide de Webview
webView = (WebView) findViewById(R.id.webView1);
webView.getSettings().setJavaScriptEnabled(true);
webView.loadUrl("http://www.google.com");
Vous pouvez aussi aller de cette façon
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 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");
}
}
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 fourni par l'utilisateur en mode texte ou vous pouvez le 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 en code court ...
if (!strUrl.startsWith("http://") && !strUrl.startsWith("https://")){
strUrl= "http://" + strUrl;
}
startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse(strUrl)));
Dans votre bloc try, 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);
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 correcte. Dans mon cas, j'utilise Xamarin et le code à utiliser avec C # et Xamarin est le suivant:
var uri = Android.Net.Uri.Parse ("http://www.xamarin.com");
var intent = new Intent (Intent.ActionView, uri);
StartActivity (intent);
Ces informations proviennent de: https://developer.xamarin.com/recipes/Android/fundamentals/intent/open_a_webpage_in_the_browser_application/
Les onglets personnalisés Chrome sont maintenant disponibles:
La première étape consiste à ajouter la bibliothèque de support des onglets personnalisés à votre fichier build.gradle:
dependencies {
...
compile 'com.Android.support:customtabs:24.2.0'
}
Et ensuite, 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
Simple and Best Practice
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*/
}
Simple, vue 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 afficher votre site Web dans l'application Android.
Ajouter une autorisation Internet dans le fichier manifeste,
<uses-permission Android:name="Android.permission.INTERNET" />
Basé sur la réponse de Mark B et les 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);
}
}
// OnClick Listener
@Override
public void onClick(View v) {
String webUrl = news.getNewsURL();
if(webUrl!="")
Utils.intentWebURL(mContext, webUrl);
}
// Votre méthode util
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);
}
}
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 Le système d’exploitation ne trouve pas la vue Action pour vos données. Donc, vous avez validé que l'URL est valide ou non.
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 économise certaines lignes de code si vous l'utilisez 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. Il n'est pas nécessaire que l'informatique soit 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 voulez le démarrer en dehors d'une activité, 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. Cela revient à renvoyer null s'il n'y a pas d'application pour gérer l'intention.
Par défaut, cette méthode est HTTP s'il n'y a pas de protocole défini, car certains sites Web ne possèdent 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 qu'il n'y en a pas. . N'importe quel site Web peut toujours forcer HTTPS, donc ces côtés vous atterrissent à HTTPS de toute façon
Etant 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
Android.webkit.URLUtil a la méthode guessUrl(String) fonctionne parfaitement (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);
Vérifiez le complet guessUrl code pour plus d'informations.
Je pense que c'est le meilleur
openBrowser(context, "http://www.google.com")
Mettez le code ci-dessous dans la 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);
}
dataWebView.setWebViewClient(new VbLinksWebClient() {
@Override
public void onPageFinished(WebView webView, String url) {
super.onPageFinished(webView, url);
}
});
public class VbLinksWebClient extends WebViewClient
{
@Override
public boolean shouldOverrideUrlLoading(WebView view, String url)
{
view.getContext().startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse(url.trim())));
return true;
}
}
Introduction de base:
https: // utilise celui-ci dans le "code" afin que personne entre les deux ne puisse les lire. Cela protège vos informations des pirates informatiques.
http: // utilise uniquement un objectif de partage, il n'est pas sécurisé.
à propos de votre problème:
conception XML:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:Android="http://schemas.Android.com/apk/res/Android"
xmlns:tools="http://schemas.Android.com/tools"
Android:layout_width="match_parent"
Android:layout_height="match_parent"
Android:orientation="vertical"
tools:context="com.example.sridhar.sharedpreferencesstackoverflow.MainActivity">
<LinearLayout
Android:orientation="horizontal"
Android:background="#228b22"
Android:layout_weight="1"
Android:layout_width="match_parent"
Android:layout_height="0dp">
<Button
Android:id="@+id/normal_search"
Android:text="secure Search"
Android:onClick="secure"
Android:layout_weight="1"
Android:layout_width="0dp"
Android:layout_height="wrap_content" />
<Button
Android:id="@+id/secure_search"
Android:text="Normal Search"
Android:onClick="normal"
Android:layout_weight="1"
Android:layout_width="0dp"
Android:layout_height="wrap_content" />
</LinearLayout>
<LinearLayout
Android:layout_weight="9"
Android:id="@+id/button_container"
Android:layout_width="match_parent"
Android:layout_height="0dp"
Android:orientation="horizontal">
<WebView
Android:id="@+id/webView1"
Android:layout_width="match_parent"
Android:layout_height="match_parent" />
</LinearLayout>
</LinearLayout>
Conception de l'activité:
public class MainActivity extends Activity {
//securely open the browser
public String Url_secure="https://www.stackoverflow.com";
//normal purpouse
public String Url_normal="https://www.stackoverflow.com";
WebView webView;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
webView=(WebView)findViewById(R.id.webView1);
}
public void secure(View view){
webView.setWebViewClient(new SecureSearch());
webView.getSettings().setLoadsImagesAutomatically(true);
webView.getSettings().setJavaScriptEnabled(true);
webView.setScrollBarStyle(View.SCROLLBARS_INSIDE_OVERLAY);
webView.loadUrl(Url_secure);
}
public void normal(View view){
webView.setWebViewClient(new NormalSearch());
webView.getSettings().setLoadsImagesAutomatically(true);
webView.getSettings().setJavaScriptEnabled(true);
webView.setScrollBarStyle(View.SCROLLBARS_INSIDE_OVERLAY);
webView.loadUrl(Url_normal);
}
public class SecureSearch extends WebViewClient{
@Override
public boolean shouldOverrideUrlLoading(WebView view, String Url_secure) {
view.loadUrl(Url_secure);
return true;
}
}
public class NormalSearch extends WebViewClient{
@Override
public boolean shouldOverrideUrlLoading(WebView view, String Url_normal) {
view.loadUrl(Url_normal);
return true;
}
}
}
Android Manifest.Xml autorisations:
<uses-permission Android:name="Android.permission.INTERNET"/>
Vous rencontrez des problèmes lorsque vous implémentez ceci:
- obtenir les permissions Manifest
- l'excès d'espace est entre url
- Vérifiez votre RL correct ou pas
Vérifiez si votre URL est correcte. Pour moi, il y avait un espace indésirable avant 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);
D'accord, j'ai vérifié chaque réponse, mais quelle application a des liens profonds 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");
e. :
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!
Essayez celui-ci OmegaIntentBuilder
OmegaIntentBuilder.from(context)
.web("Your url here")
.createIntentHandler()
.failToast("You don't have app for open urls")
.startActivity();