Como pode abrir um URL no navegador da web do Android do meu aplicativo?
Como abrir um URL a partir do código no navegador da Web embutido, e não dentro do meu aplicativo?
Eu tentei isso:
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();
}
mas eu tenho uma exceção:
No activity found to handle Intent{action=Android.intent.action.VIEW data =www.google.com
Tente isto:
Intent browserIntent = new Intent(Intent.ACTION_VIEW, Uri.parse("http://www.google.com"));
startActivity(browserIntent);
Isso funciona bem para mim.
Quanto à falta de "http: //" eu só faria algo assim:
if (!url.startsWith("http://") && !url.startsWith("https://"))
url = "http://" + url;
Eu provavelmente também pré-preencherei seu EditText que o usuário está digitando um URL com "http: //".
uma maneira comum de conseguir isso é com o próximo código:
String url = "http://www.stackoverflow.com";
Intent i = new Intent(Intent.ACTION_VIEW);
i.setData(Uri.parse(url));
startActivity(i);
que poderia ser alterado para uma versão de código curto ...
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);
o mais curto! :
startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse("http://www.stackoverflow.com")));
codificação feliz!
Em 2.3, tive melhor sorte com
final Intent intent = new Intent(Intent.ACTION_VIEW).setData(Uri.parse(url));
activity.startActivity(intent);
A diferença é o uso de Intent.ACTION_VIEW em vez da String "Android.intent.action.VIEW"
Resposta Simples
Você pode ver a amostra oficial do 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);
}
}
Como funciona
Por favor, dê uma olhada no construtor de Intent :
public Intent (String action, Uri uri)
Você pode passar a instância Android.net.Uri para o segundo parâmetro, e uma nova intenção é criada com base na URL de dados fornecida.
E então, simplesmente chame startActivity(Intent intent) para iniciar uma nova Activity, que é empacotada com o Intent com o URL fornecido.
Preciso da instrução de verificação if?
Sim. O docs diz:
Se não houver aplicativos no dispositivo que possam receber a intenção implícita, seu aplicativo falhará quando chamar startActivity (). Para primeiro verificar se existe um aplicativo para receber a intenção, chame resolveActivity () em seu objeto Intent. Se o resultado não for nulo, há pelo menos um aplicativo que pode manipular a intenção e é seguro chamar startActivity (). Se o resultado for nulo, você não deve usar a intenção e, se possível, deve desativar o recurso que chama a intenção.
Bônus
Você pode escrever em uma linha ao criar a instância do Intent como abaixo:
Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(url));
Tente isto:
Uri uri = Uri.parse("https://www.google.com");
startActivity(new Intent(Intent.ACTION_VIEW, uri));
ou se você quiser que o navegador da web abra em sua atividade, faça assim:
WebView webView = (WebView) findViewById(R.id.webView1);
WebSettings settings = webview.getSettings();
settings.setJavaScriptEnabled(true);
webView.loadUrl(URL);
e se você quiser usar o controle de zoom no seu navegador, então você pode usar:
settings.setSupportZoom(true);
settings.setBuiltInZoomControls(true);
Se você quiser mostrar ao usuário um diálogo com toda a lista de navegadores, para que ele possa escolher o preferido, aqui está o código de exemplo:
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 :)
}
outra opção no URL de carga no mesmo aplicativo usando o Webview
webView = (WebView) findViewById(R.id.webView1);
webView.getSettings().setJavaScriptEnabled(true);
webView.loadUrl("http://www.google.com");
Assim como as soluções que outros escreveram (que funcionam bem), gostaria de responder a mesma coisa, mas com uma dica que acho que a maioria preferiria usar.
Caso você deseje que o aplicativo comece a abrir em uma nova tarefa, independente de sua preferência, em vez de ficar na mesma pilha, você pode usar este código:
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);
Existe também uma maneira de abrir o URL em Chrome Custom Tabs . Exemplo em 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)
}
Você também pode ir por esse caminho
Em 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" />
No código 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");
}
}
No Manifesto, não esqueça de adicionar permissão de internet ...
Uma versão de código curto ...
if (!strUrl.startsWith("http://") && !strUrl.startsWith("https://")){
strUrl= "http://" + strUrl;
}
startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse(strUrl)));
Em seu bloco try, cole o código a seguir, o Android Intent usa diretamente o link dentro das chaves URI (Uniform Resource Identifier) para identificar o local do seu link.
Você pode tentar isto:
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);
A resposta de MarkB está certa. No meu caso eu estou usando Xamarin, e o código para usar com C # e Xamarin é:
var uri = Android.Net.Uri.Parse ("http://www.xamarin.com");
var intent = new Intent (Intent.ActionView, uri);
StartActivity (intent);
Esta informação é retirada de: https://developer.xamarin.com/recipes/Android/fundamentals/intent/open_a_webpage_in_the_browser_application/
Agora, as guias personalizadas do Chrome estão disponíveis:
A primeira etapa é adicionar a Biblioteca de Suporte de Guias Personalizadas ao seu arquivo build.gradle:
dependencies {
...
compile 'com.Android.support:customtabs:24.2.0'
}
E depois, para abrir uma guia personalizada do Chrome:
String url = "https://www.google.pt/";
CustomTabsIntent.Builder builder = new CustomTabsIntent.Builder();
CustomTabsIntent customTabsIntent = builder.build();
customTabsIntent.launchUrl(this, Uri.parse(url));
Para mais informações: https://developer.chrome.com/multidevice/Android/customtabs
Simples, visão do site via intenção,
Intent viewIntent = new Intent("Android.intent.action.VIEW", Uri.parse("http://www.yoursite.in"));
startActivity(viewIntent);
use este código simples para visualizar seu website no aplicativo para Android.
Adicione permissão de internet no arquivo de manifesto,
<uses-permission Android:name="Android.permission.INTERNET" />
// OnClick Listener
@Override
public void onClick(View v) {
String webUrl = news.getNewsURL();
if(webUrl!="")
Utils.intentWebURL(mContext, webUrl);
}
// seu método 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);
}
}
Desta forma, usa um método, para permitir que você insira qualquer String em vez de ter uma entrada fixa. Isso salva algumas linhas de código, se usadas repetidas vezes, pois você só precisa de três linhas para chamar o método.
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;
}
Usando este método torna universalmente utilizável. A TI não precisa ser colocada em uma atividade específica, pois você pode usá-la da seguinte maneira:
Intent i = getWebIntent("google.com");
if(i != null)
startActivity();
Ou, se você quiser iniciá-lo fora de uma atividade, basta chamar startActivity na instância da atividade:
Intent i = getWebIntent("google.com");
if(i != null)
activityInstance.startActivity(i);
Como visto em ambos os blocos de código, há uma verificação nula. Isso é quando ele retorna null se não houver um aplicativo para lidar com a intenção.
Esse método é padronizado para HTTP se não houver nenhum protocolo definido, pois há sites que não têm um certificado SSL (o que você precisa para uma conexão HTTPS) e eles deixarão de funcionar se você tentar usar HTTPS e não estiver lá . Qualquer site ainda pode forçar o HTTPS, então esses lados o colocam em HTTPS de qualquer maneira
Como esse método usa recursos externos para exibir a página, não é necessário declarar a permissão da Internet. O aplicativo que exibe a página da Web tem que fazer isso
Eu acho que isso é o melhor
openBrowser(context, "http://www.google.com")
Coloque abaixo o código na classe global
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);
}
Simples e Melhor Prática
Método 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étodo 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*/
}
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;
}
}
Introdução Básica:
https: // está usando aquele no "código" para que ninguém entre possa lê-los. Isso mantém suas informações seguras contra hackers.
http: // está usando apenas o propósito de compartilhamento, não é seguro.
Sobre o seu problema:
Projeto de 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>
Projeto de atividade:
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 permissions:
<uses-permission Android:name="Android.permission.INTERNET"/>
Você enfrenta problemas ao implementar isso:
- obtendo o manifesto permissões
- excesso de espaço entre o url
- Verifique seu url correto ou não
Android.webkit.URLUtil tem o método guessUrl(String) funcionando perfeitamente bem (mesmo com file:// ou data://) desde Api level 1 (Android 1.0). Use como:
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
Na chamada de atividade:
Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(URLUtil.guessUrl(download_link)));
if (intent.resolveActivity(getPackageManager()) != null)
startActivity(intent);
Verifique o código completo guessUrl para mais informações.
Verifique se o seu URL está correto. Para mim, havia um espaço indesejado antes do URL.
Tente isso .. Trabalhou para mim!
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>");
}
código 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);
Ok, eu verifiquei todas as respostas, mas qual aplicativo tem deeplinking com o mesmo URL que o usuário deseja usar?
Hoje recebi este caso e a resposta é browserIntent.setPackage("browser_package_name");
por exemplo. :
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);
Obrigado!
Tente este OmegaIntentBuilder
OmegaIntentBuilder.from(context)
.web("Your url here")
.createIntentHandler()
.failToast("You don't have app for open urls")
.startActivity();