Come verificare se l'URL è valido in Android

C'è un buon modo per evitare l'errore "host non risolto" che blocca un'app? Qualche modo per provare a connettersi a un host (come un URL) e vedere se è valido?

Usa URLUtil per convalidare l'URL come di seguito.

 URLUtil.isValidUrl(url)

Restituirà True se l'URL è valido e falso se l'URL non è valido .

URLUtil.isValidUrl(url);

Se questo non funziona puoi usare:

Patterns.WEB_URL.matcher(url).matches();

Userei una combinazione di metodi menzionati qui e in altri thread Stackoverflow:

private boolean isValid(String urlString) {
    try {
        URL url = new URL(urlString);
        return URLUtil.isValidUrl(url) && Patterns.WEB_URL.matcher(url).matches();
    } catch (MalformedURLException e) {

    }

    return false;
}

Avvolgi l'operazione in una prova / cattura. Ci sono molti modi in cui un URL può essere ben formato ma non recuperabile. Inoltre, test come vedere se il nome host esiste non garantisce nulla perché l'host potrebbe diventare irraggiungibile subito dopo il controllo. Fondamentalmente, nessuna quantità di controllo preliminare può garantire che il recupero non fallisca e generi un'eccezione, quindi è meglio pianificare la gestione delle eccezioni.

Ho provato molti metodi e ho scoperto che nessuno funziona bene con questo URL:

Ora uso quanto segue e tutto va bene.

public static boolean checkURL(CharSequence input) {
    if (TextUtils.isEmpty(input)) {
        return false;
    }
    Pattern URL_PATTERN = Patterns.WEB_URL;
    boolean isURL = URL_PATTERN.matcher(input).matches();
    if (!isURL) {
        String urlString = input + "";
        if (URLUtil.isNetworkUrl(urlString)) {
            try {
                new URL(urlString);
                isURL = true;
            } catch (Exception e) {
            }
        }
    }
    return isURL;
}

import okhttp3.HttpUrl;
import android.util.Patterns;
import android.webkit.URLUtil;

            if (!Patterns.WEB_URL.matcher(url).matches()) {
                error.setText(R.string.wrong_server_address);
                return;
            }

            if (HttpUrl.parse(url) == null) {
                error.setText(R.string.wrong_server_address);
                return;
            }

            if (!URLUtil.isValidUrl(url)) {
                error.setText(R.string.wrong_server_address);
                return;
            }

            if (!url.substring(0,7).contains("http://") & !url.substring(0,8).contains("https://")) {
                error.setText(R.string.wrong_server_address);
                return;
            }

Nel mio caso Patterns.WEB_URL.matcher(url).matches()non funziona correttamente nel caso in cui digitoString digito simile a "first.secondword" (la mia app controlla l'input dell'utente). Questo metodo restituisce true.

URLUtil.isValidUrl(url)funziona correttamente per me. Forse sarebbe utile a qualcun altro

Se stai usando from kotlinpuoi creare String.kte scrivere il codice qui sotto:

fun String.isValidUrl(): Boolean = Patterns.WEB_URL.matcher(this).matches()

Poi:

String url = "www.yourUrl.com"
if (!url.isValidUrl()) {
    //some code
}else{
   //some code
}

Puoi convalidare l'URL seguendo:

Patterns.WEB_URL.matcher(potentialUrl).matches()

public static boolean isURL(String text) {
    String tempString = text;

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

    try {
        new URL(tempString).toURI();
        return Patterns.WEB_URL.matcher(tempString).matches();
    } catch (MalformedURLException | URISyntaxException e) {
        e.printStackTrace();
        return false;
    }
}

Questa è la soluzione corretta che sto usando. L'aggiunta di https://testo prima dell'originale impedisce che il testo come "www.cats.com" venga considerato come URL. Se ha new URL()successo, se controlli il pattern per escludere testi semplici come " https: // cats " da considerare URL.

Basta aggiungere questa riga di codice:

Boolean isValid = URLUtil.isValidUrl(url) && Patterns.WEB_URL.matcher(url).matches();       

new java.net.URL(String) throws MalformedURLException