Comment vérifier si l'URL est valide dans Android

Existe-t-il un bon moyen d'éviter l'erreur «l'hôte n'est pas résolu» qui plante une application? Une sorte de moyen d'essayer de se connecter à un hôte (comme une URL) et de voir si c'est même valide?

Utilisez URLUtil pour valider l'URL comme ci-dessous.

 URLUtil.isValidUrl(url)

Il retournera True si l'URL est valide et False si l'URL n'est pas valide .

URLUtil.isValidUrl(url);

Si cela ne fonctionne pas, vous pouvez utiliser:

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

J'utiliserais une combinaison de méthodes mentionnées ici et dans d'autres threads 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;
}

Enveloppez l'opération dans un try / catch. Il existe de nombreuses façons dont une URL peut être bien formée mais pas récupérable. De plus, des tests comme voir si le nom d'hôte existe ne garantissent rien car l'hôte peut devenir inaccessible juste après la vérification. Fondamentalement, aucune quantité de pré-vérification ne peut garantir que la récupération n'échouera pas et ne lèvera pas d'exception.

J'ai essayé beaucoup de méthodes et je trouve que personne ne fonctionne correctement avec cette URL:

Maintenant, j'utilise ce qui suit et tout se passe bien.

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

Dans mon cas Patterns.WEB_URL.matcher(url).matches()ne fonctionne pas correctement dans le cas où je tapeString similaire à "first.secondword" (Mon application vérifie l'entrée de l'utilisateur). Cette méthode renvoie true.

URLUtil.isValidUrl(url)fonctionne correctement pour moi. Peut-être que ce serait utile à quelqu'un d'autre

Si vous utilisez de, kotlinvous pouvez créer un String.ktcode et écrire ci-dessous:

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

Ensuite:

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

Vous pouvez valider l'URL en suivant:

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

C'est la solution correcte que j'utilise. L'ajout https://avant le texte original empêche le texte comme "www.cats.com" d'être considéré comme URL. Si vous new URL()réussissez, alors si vous cochez simplement le modèle pour exclure les textes simples comme " https: // chats " à prendre en compte URL.

Ajoutez simplement cette ligne de code:

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

new java.net.URL(String) throws MalformedURLException