Comment obtenir l'adresse IP de l'appareil à partir du code?

384

Est-il possible d'obtenir l'adresse IP de l'appareil à l'aide d'un code?

Nilesh Tupe
la source
5
N'oubliez pas qu'il s'agit d'une collection de taille N, et vous ne pouvez pas supposer que N == (0 || 1). En d'autres termes, ne présumez pas qu'un périphérique n'a qu'une seule façon de parler à un réseau et ne supposez pas qu'il a une quelconque façon de parler à un réseau.
James Moore
Connexe: stackoverflow.com/questions/9481865/…
AlikElzin-kilaka
2
version non programmatique android.stackexchange.com/questions/2984/…
Ciro Santilli 郝海东 冠状 病 六四 事件 法轮功
Vous devriez l'obtenir d'un service externe ipof.in/txt est un de ces services
vivekv
est-il possible de l'obtenir par programme dans Android?
Tanmay Sahoo

Réponses:

434

Ceci est mon aide pour lire les adresses IP et MAC. L'implémentation est pure-java, mais j'ai un bloc de commentaires dans getMACAddress()lequel pourrait lire la valeur du fichier spécial Linux (Android). J'ai exécuté ce code uniquement sur quelques appareils et émulateur, mais faites-moi savoir ici si vous trouvez des résultats étranges.

// AndroidManifest.xml permissions
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

// test functions
Utils.getMACAddress("wlan0");
Utils.getMACAddress("eth0");
Utils.getIPAddress(true); // IPv4
Utils.getIPAddress(false); // IPv6 

Utils.java

import java.io.*;
import java.net.*;
import java.util.*;   
//import org.apache.http.conn.util.InetAddressUtils;

public class Utils {

    /**
     * Convert byte array to hex string
     * @param bytes toConvert
     * @return hexValue
     */
    public static String bytesToHex(byte[] bytes) {
        StringBuilder sbuf = new StringBuilder();
        for(int idx=0; idx < bytes.length; idx++) {
            int intVal = bytes[idx] & 0xff;
            if (intVal < 0x10) sbuf.append("0");
            sbuf.append(Integer.toHexString(intVal).toUpperCase());
        }
        return sbuf.toString();
    }

    /**
     * Get utf8 byte array.
     * @param str which to be converted
     * @return  array of NULL if error was found
     */
    public static byte[] getUTF8Bytes(String str) {
        try { return str.getBytes("UTF-8"); } catch (Exception ex) { return null; }
    }

    /**
     * Load UTF8withBOM or any ansi text file.
     * @param filename which to be converted to string
     * @return String value of File
     * @throws java.io.IOException if error occurs
     */
    public static String loadFileAsString(String filename) throws java.io.IOException {
        final int BUFLEN=1024;
        BufferedInputStream is = new BufferedInputStream(new FileInputStream(filename), BUFLEN);
        try {
            ByteArrayOutputStream baos = new ByteArrayOutputStream(BUFLEN);
            byte[] bytes = new byte[BUFLEN];
            boolean isUTF8=false;
            int read,count=0;           
            while((read=is.read(bytes)) != -1) {
                if (count==0 && bytes[0]==(byte)0xEF && bytes[1]==(byte)0xBB && bytes[2]==(byte)0xBF ) {
                    isUTF8=true;
                    baos.write(bytes, 3, read-3); // drop UTF8 bom marker
                } else {
                    baos.write(bytes, 0, read);
                }
                count+=read;
            }
            return isUTF8 ? new String(baos.toByteArray(), "UTF-8") : new String(baos.toByteArray());
        } finally {
            try{ is.close(); } catch(Exception ignored){} 
        }
    }

    /**
     * Returns MAC address of the given interface name.
     * @param interfaceName eth0, wlan0 or NULL=use first interface 
     * @return  mac address or empty string
     */
    public static String getMACAddress(String interfaceName) {
        try {
            List<NetworkInterface> interfaces = Collections.list(NetworkInterface.getNetworkInterfaces());
            for (NetworkInterface intf : interfaces) {
                if (interfaceName != null) {
                    if (!intf.getName().equalsIgnoreCase(interfaceName)) continue;
                }
                byte[] mac = intf.getHardwareAddress();
                if (mac==null) return "";
                StringBuilder buf = new StringBuilder();
                for (byte aMac : mac) buf.append(String.format("%02X:",aMac));  
                if (buf.length()>0) buf.deleteCharAt(buf.length()-1);
                return buf.toString();
            }
        } catch (Exception ignored) { } // for now eat exceptions
        return "";
        /*try {
            // this is so Linux hack
            return loadFileAsString("/sys/class/net/" +interfaceName + "/address").toUpperCase().trim();
        } catch (IOException ex) {
            return null;
        }*/
    }

    /**
     * Get IP address from first non-localhost interface
     * @param useIPv4   true=return ipv4, false=return ipv6
     * @return  address or empty string
     */
    public static String getIPAddress(boolean useIPv4) {
        try {
            List<NetworkInterface> interfaces = Collections.list(NetworkInterface.getNetworkInterfaces());
            for (NetworkInterface intf : interfaces) {
                List<InetAddress> addrs = Collections.list(intf.getInetAddresses());
                for (InetAddress addr : addrs) {
                    if (!addr.isLoopbackAddress()) {
                        String sAddr = addr.getHostAddress();
                        //boolean isIPv4 = InetAddressUtils.isIPv4Address(sAddr);
                        boolean isIPv4 = sAddr.indexOf(':')<0;

                        if (useIPv4) {
                            if (isIPv4) 
                                return sAddr;
                        } else {
                            if (!isIPv4) {
                                int delim = sAddr.indexOf('%'); // drop ip6 zone suffix
                                return delim<0 ? sAddr.toUpperCase() : sAddr.substring(0, delim).toUpperCase();
                            }
                        }
                    }
                }
            }
        } catch (Exception ignored) { } // for now eat exceptions
        return "";
    }

}

Avertissement: les idées et les exemples de code de cette classe Utils proviennent de plusieurs publications SO et de Google. J'ai nettoyé et fusionné tous les exemples.

Qui
la source
17
Cela nécessite l'API de niveau 9 et supérieur en raison de getHardwareAddress ().
Calvin
2
Problèmes - avertissements sur les peluches activés toUpperCase(). La capture Exceptionest toujours douteuse (et les méthodes d'assistance devraient de toute façon lancer et laisser l'appelant gérer l'exception - n'a pas modifié cela cependant). Formatage: ne doit pas dépasser 80 lignes. Exécution conditionnelle pour getHardwareAddress()- patch: github.com/Utumno/AndroidHelpers/commit/… . Ce que tu dis ?
Mr_and_Mrs_D
5
Si vous êtes sur un réseau local (par exemple Wifi ou émulateur), vous obtiendrez une adresse IP privée. Vous pouvez obtenir l'adresse IP du proxy via une demande à un site Web spécifique qui vous donne l'adresse proxy, par exemple whatismyip.akamai.com
Julien Kronegg
1
Cela fonctionne parfaitement pour moi avec un véritable appareil utilisant le Wifi. Merci beaucoup, frère
M. Neo
5
J'obtiens de mauvais résultats sur un Nexus 6 lorsque j'essaie d'obtenir une adresse IP. J'ai une NetworkInterface avec le nom "name: dummy0 (dummy0)" qui donne une adresse au format "/ XX :: XXXX: XXXX: XXXX: XXXX% dummy0", il existe également une véritable interface réseau qui correspond à wlan0, mais puisque le "mannequin" arrive en premier, j'ai toujours cette adresse fictive
Julian Suarez
201

Cela a fonctionné pour moi:

WifiManager wm = (WifiManager) getSystemService(WIFI_SERVICE);
String ip = Formatter.formatIpAddress(wm.getConnectionInfo().getIpAddress());
Nilesh Tupe
la source
10
celui-ci fonctionne pour moi. cependant, il a besoin de la permission "ACCESS_WIFI_STATE" et comme "Umair" l'a écrit, l'utilisation de la liste n'est pas nécessaire.
développeur Android
13
formatIpAddress est obsolète pour une raison quelconque. Que faut-il utiliser à la place?
développeur Android
8
Depuis la documentation: Use getHostAddress(), qui prend en charge les adresses IPv4 et IPv6. Cette méthode ne prend pas en charge les adresses IPv6.
Ryan R
7
comment utiliser getHostAddress () pour obtenir l'adresse IP du serveur et du client @RyanR?
gumuruh
42
cela fonctionnera-t-il toujours même si l'utilisateur utilise des données au lieu du wifi?
PinoyCoder
65

J'ai utilisé le code suivant: La raison pour laquelle j'ai utilisé hashCode était parce que j'obtenais des valeurs de poubelle ajoutées à l'adresse IP lorsque j'utilisais getHostAddress. Mais cela hashCodea très bien fonctionné pour moi car je peux alors utiliser Formatter pour obtenir l'adresse IP avec un formatage correct.

Voici l'exemple de sortie:

1. en utilisant getHostAddress:***** IP=fe80::65ca:a13d:ea5a:233d%rmnet_sdio0

2. utiliser hashCodeet Formatter: ***** IP=238.194.77.212

Comme vous pouvez le voir, la 2e méthode me donne exactement ce dont j'ai besoin.

public String getLocalIpAddress() {
    try {
        for (Enumeration<NetworkInterface> en = NetworkInterface.getNetworkInterfaces(); en.hasMoreElements();) {
            NetworkInterface intf = en.nextElement();
            for (Enumeration<InetAddress> enumIpAddr = intf.getInetAddresses(); enumIpAddr.hasMoreElements();) {
                InetAddress inetAddress = enumIpAddr.nextElement();
                if (!inetAddress.isLoopbackAddress()) {
                    String ip = Formatter.formatIpAddress(inetAddress.hashCode());
                    Log.i(TAG, "***** IP="+ ip);
                    return ip;
                }
            }
        }
    } catch (SocketException ex) {
        Log.e(TAG, ex.toString());
    }
    return null;
}
anargund
la source
1
getHostAddress()fera la même chose que le truc du formateur que vous avez ajouté.
Phil
10
Utiliser hashCode est tout à fait faux et renvoie un non-sens. Utilisez plutôt InetAddress.getHostAddress ().
Pointer Null
changez cette partie: if (! inetAddress.isLoopbackAddress ()) {String ip = Formatter.formatIpAddress (inetAddress.hashCode ()); Log.i (TAG, "***** IP =" + ip); retour ip; } avec ceci: if (! inetAddress.isLoopbackAddress () && InetAddressUtils.isIPv4Address (inetAddress.getHostAddress ())) {return inetAddress .getHostAddress (). toString (); } cela vous donnera le bon format ip
Chuy47
Le code ne renvoie que la première IP, un téléphone peut avoir une adresse celluar, WIFI et BT en même temps
reker
@ Chuy47, il est dit que InetAddressUtils est introuvable
FabioR
61
public static String getLocalIpAddress() {
    try {
        for (Enumeration<NetworkInterface> en = NetworkInterface.getNetworkInterfaces(); en.hasMoreElements();) {
            NetworkInterface intf = en.nextElement();
            for (Enumeration<InetAddress> enumIpAddr = intf.getInetAddresses(); enumIpAddr.hasMoreElements();) {
                InetAddress inetAddress = enumIpAddr.nextElement();
                if (!inetAddress.isLoopbackAddress() && inetAddress instanceof Inet4Address) {
                    return inetAddress.getHostAddress();
                }
            }
        }
    } catch (SocketException ex) {
        ex.printStackTrace();
    }
    return null;
}

J'ai ajouté inetAddressinstanceof Inet4Addresspour vérifier s'il s'agit d'une adresse ipv4.

evertvandenbruel
la source
sauvé ma journée! Merci. C'est le seul code qui fonctionne sur Samsung S7 Edge
Dhananjay Sarsonia
Ceci est une vraie réponse, au lieu de ci-dessus qui ne dispose que d'une interface WiFi.
nyconing le
Cela devrait vraiment être la bonne réponse, cela fonctionne à la fois pour le WiFi et le réseau mobile, et utilise "getHostAddress" au lieu du formatage personnalisé.
Balázs Gerlei
Cependant, il obtient mon adresse IP locale, j'ai besoin de mon adresse IP publique (car je pense que OP a également besoin)
FabioR
53

Bien qu'il y ait une bonne réponse, je partage ma réponse ici et j'espère que cette méthode sera plus pratique.

WifiManager wifiMan = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
WifiInfo wifiInf = wifiMan.getConnectionInfo();
int ipAddress = wifiInf.getIpAddress();
String ip = String.format("%d.%d.%d.%d", (ipAddress & 0xff),(ipAddress >> 8 & 0xff),(ipAddress >> 16 & 0xff),(ipAddress >> 24 & 0xff));
CYB
la source
4
Merci! Le formateur est obsolète, et je n'avais vraiment pas envie d'écrire une logique de bits simple.
William Morrison
4
Fonctionne très bien, mais nécessite l'autorisation WIFI_STATE:<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
Brent Faust
1
J'utilise le formaater mais ça ne marche pas. C'est super! Vraiment apprécié. Pourriez-vous expliquer ce qui se fait à la dernière ligne. Je connais% d.% D.% D.% D mais d'autres? Merci
Günay Gültekin
1
Nah cela ne répond pas directement à OP. Parce que tous les appareils Android n'utilisent pas le WiFi pour se connecter à Internet. Il peut avoir un LAN NAT sur Ethernet, ou BT et pas une connexion WAN NAT, etc.
nyconing
31

Le code ci-dessous pourrait vous aider .. N'oubliez pas d'ajouter des autorisations ..

public String getLocalIpAddress(){
   try {
       for (Enumeration<NetworkInterface> en = NetworkInterface.getNetworkInterfaces();  
       en.hasMoreElements();) {
       NetworkInterface intf = en.nextElement();
           for (Enumeration<InetAddress> enumIpAddr = intf.getInetAddresses(); enumIpAddr.hasMoreElements();) {
           InetAddress inetAddress = enumIpAddr.nextElement();
                if (!inetAddress.isLoopbackAddress()) {
                return inetAddress.getHostAddress();
                }
           }
       }
       } catch (Exception ex) {
          Log.e("IP Address", ex.toString());
      }
      return null;
}

Ajoutez l'autorisation ci-dessous dans le fichier manifeste.

 <uses-permission android:name="android.permission.INTERNET" />
 <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

codage heureux !!

Satyam
la source
6
Hé, cela renvoie une valeur incorrecte comme: "fe80 :: f225: b7ff: fe8c: d357% wlan0"
Jorgesys
@Jorgesys vérifie la réponse de evertvandenbruel où il a ajouté une instance inetAddress d'Inet4Address
temirbek
3
changer si une condition comme celle-ci pour obtenir une adresse IP correcte: if (! inetAddress.isLoopbackAddress () && inetAddress instanceof Inet4Address)
Rajesh.k
Le code ne renvoie que la première IP, un téléphone peut avoir une adresse celluar, WIFI et BT en même temps
reker
Si vous avez un hotspot, vous pouvez obtenir plus d'une
Harsha
16

Vous n'avez pas besoin d'ajouter des autorisations comme c'est le cas avec les solutions fournies jusqu'à présent. Téléchargez ce site Web sous forme de chaîne:

http://www.ip-api.com/json

ou

http://www.telize.com/geoip

Le téléchargement d'un site Web sous forme de chaîne peut se faire avec du code java:

http://www.itcuties.com/java/read-url-to-string/

Analysez l'objet JSON comme ceci:

https://stackoverflow.com/a/18998203/1987258

L'attribut json "query" ou "ip" contient l'adresse IP.

Daan
la source
2
cela nécessite une connexion Internet. Gros problème
David
4
Pourquoi est-ce un gros problème? Bien sûr, vous avez besoin d'une connexion Internet car une adresse IP est techniquement liée à une telle connexion. Si vous quittez votre maison et allez dans un restaurant, vous utiliserez une autre connexion Internet et donc une autre adresse IP. Vous n'avez pas besoin d'ajouter quelque chose comme ACCESS_NETWORK_STATE ou ACCESS_WIFI_STATE. Une connexion Internet est la seule autorisation dont vous avez besoin pour la solution fournie par moi.
Daan
2
Quel domaine? Si ip-api.com ne fonctionne pas, vous pouvez utiliser telize.com comme solution de rechange. Sinon, vous pouvez utiliser api.ipify.org . Il est également disponible ici (pas json): ip.jsontest.com/?callback=showIP . De nombreuses applications utilisent des domaines garantis pour rester en ligne; c'est normal. Cependant, si vous utilisez des solutions de repli, il devient très peu probable qu'il y ait un problème.
Daan
3
Le point d'origine de David tient toujours. Et si vous êtes sur un réseau interne qui n'a pas accès à Internet.
hiandbaii
2
Je n'y ai jamais pensé parce que je ne connais aucun objectif pratique d'une application qui a vraiment besoin d'un réseau mais devrait fonctionner sans Internet (peut-être qu'il y en a mais je ne le vois pas pour les appareils mobiles).
Daan
9
private InetAddress getLocalAddress()throws IOException {

            try {
                for (Enumeration<NetworkInterface> en = NetworkInterface.getNetworkInterfaces(); en.hasMoreElements();) {
                    NetworkInterface intf = en.nextElement();
                    for (Enumeration<InetAddress> enumIpAddr = intf.getInetAddresses(); enumIpAddr.hasMoreElements();) {
                        InetAddress inetAddress = enumIpAddr.nextElement();
                        if (!inetAddress.isLoopbackAddress()) {
                            //return inetAddress.getHostAddress().toString();
                            return inetAddress;
                        }
                    }
                }
            } catch (SocketException ex) {
                Log.e("SALMAN", ex.toString());
            }
            return null;
        }
salman khalid
la source
1
est-il possible que cela renvoie l'IP du réseau privé à partir de l'interface wifi, comme 192.168.0.x? ou retournera-t-elle toujours l'adresse IP externe, qui serait utilisée sur Internet?
Ben H
9

La méthode getDeviceIpAddress renvoie l'adresse IP de l'appareil et préfère l'adresse de l'interface wifi s'il est connecté.

  @NonNull
    private String getDeviceIpAddress() {
        String actualConnectedToNetwork = null;
        ConnectivityManager connManager = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
        if (connManager != null) {
            NetworkInfo mWifi = connManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
            if (mWifi.isConnected()) {
                actualConnectedToNetwork = getWifiIp();
            }
        }
        if (TextUtils.isEmpty(actualConnectedToNetwork)) {
            actualConnectedToNetwork = getNetworkInterfaceIpAddress();
        }
        if (TextUtils.isEmpty(actualConnectedToNetwork)) {
            actualConnectedToNetwork = "127.0.0.1";
        }
        return actualConnectedToNetwork;
    }

    @Nullable
    private String getWifiIp() {
        final WifiManager mWifiManager = (WifiManager) getApplicationContext().getSystemService(Context.WIFI_SERVICE);
        if (mWifiManager != null && mWifiManager.isWifiEnabled()) {
            int ip = mWifiManager.getConnectionInfo().getIpAddress();
            return (ip & 0xFF) + "." + ((ip >> 8) & 0xFF) + "." + ((ip >> 16) & 0xFF) + "."
                    + ((ip >> 24) & 0xFF);
        }
        return null;
    }


    @Nullable
    public String getNetworkInterfaceIpAddress() {
        try {
            for (Enumeration<NetworkInterface> en = NetworkInterface.getNetworkInterfaces(); en.hasMoreElements(); ) {
                NetworkInterface networkInterface = en.nextElement();
                for (Enumeration<InetAddress> enumIpAddr = networkInterface.getInetAddresses(); enumIpAddr.hasMoreElements(); ) {
                    InetAddress inetAddress = enumIpAddr.nextElement();
                    if (!inetAddress.isLoopbackAddress() && inetAddress instanceof Inet4Address) {
                        String host = inetAddress.getHostAddress();
                        if (!TextUtils.isEmpty(host)) {
                            return host;
                        }
                    }
                }

            }
        } catch (Exception ex) {
            Log.e("IP Address", "getLocalIpAddress", ex);
        }
        return null;
    }
Ruslan Podurets
la source
4

Il s'agit d'une refonte de cette réponse qui supprime les informations non pertinentes, ajoute des commentaires utiles, nomme les variables plus clairement et améliore la logique.

N'oubliez pas d'inclure les autorisations suivantes:

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

InternetHelper.java:

public class InternetHelper {

    /**
     * Get IP address from first non-localhost interface
     *
     * @param useIPv4 true=return ipv4, false=return ipv6
     * @return address or empty string
     */
    public static String getIPAddress(boolean useIPv4) {
        try {
            List<NetworkInterface> interfaces =
                    Collections.list(NetworkInterface.getNetworkInterfaces());

            for (NetworkInterface interface_ : interfaces) {

                for (InetAddress inetAddress :
                        Collections.list(interface_.getInetAddresses())) {

                    /* a loopback address would be something like 127.0.0.1 (the device
                       itself). we want to return the first non-loopback address. */
                    if (!inetAddress.isLoopbackAddress()) {
                        String ipAddr = inetAddress.getHostAddress();
                        boolean isIPv4 = ipAddr.indexOf(':') < 0;

                        if (isIPv4 && !useIPv4) {
                            continue;
                        }
                        if (useIPv4 && !isIPv4) {
                            int delim = ipAddr.indexOf('%'); // drop ip6 zone suffix
                            ipAddr = delim < 0 ? ipAddr.toUpperCase() :
                                    ipAddr.substring(0, delim).toUpperCase();
                        }
                        return ipAddr;
                    }
                }

            }
        } catch (Exception ignored) { } // if we can't connect, just return empty string
        return "";
    }

    /**
     * Get IPv4 address from first non-localhost interface
     *
     * @return address or empty string
     */
    public static String getIPAddress() {
        return getIPAddress(true);
    }

}
Jon McClung
la source
4

version minimaliste kotlin

fun getIpv4HostAddress(): String {
    NetworkInterface.getNetworkInterfaces()?.toList()?.map { networkInterface ->
        networkInterface.inetAddresses?.toList()?.find {
            !it.isLoopbackAddress && it is Inet4Address
        }?.let { return it.hostAddress }
    }
    return ""
}
Raphael C
la source
3
WifiManager wm = (WifiManager) getSystemService(WIFI_SERVICE);
String ipAddress = BigInteger.valueOf(wm.getDhcpInfo().netmask).toString();
mridul
la source
3

Utilisez simplement Volley pour obtenir l'ip de ce site

RequestQueue queue = Volley.newRequestQueue(this);    
String urlip = "http://checkip.amazonaws.com/";

    StringRequest stringRequest = new StringRequest(Request.Method.GET, urlip, new Response.Listener<String>() {
        @Override
        public void onResponse(String response) {
            txtIP.setText(response);

        }
    }, new Response.ErrorListener() {
        @Override
        public void onErrorResponse(VolleyError error) {
            txtIP.setText("didnt work");
        }
    });

    queue.add(stringRequest);
Sohel Mahmud
la source
2

Récemment, une adresse IP est toujours retournée getLocalIpAddress()malgré sa déconnexion du réseau (pas d'indicateur de service). Cela signifie que l'adresse IP affichée dans Paramètres> À propos du téléphone> État était différente de ce que pensait l'application.

J'ai implémenté une solution de contournement en ajoutant ce code avant:

ConnectivityManager cm = getConnectivityManager();
NetworkInfo net = cm.getActiveNetworkInfo();
if ((null == net) || !net.isConnectedOrConnecting()) {
    return null;
}

Est-ce que cela vous dit quelque chose?

slash33
la source
2

à Kotlin, sans formateur

private fun getIPAddress(useIPv4 : Boolean): String {
    try {
        var interfaces = Collections.list(NetworkInterface.getNetworkInterfaces())
        for (intf in interfaces) {
            var addrs = Collections.list(intf.getInetAddresses());
            for (addr in addrs) {
                if (!addr.isLoopbackAddress()) {
                    var sAddr = addr.getHostAddress();
                    var isIPv4: Boolean
                    isIPv4 = sAddr.indexOf(':')<0
                    if (useIPv4) {
                        if (isIPv4)
                            return sAddr;
                    } else {
                        if (!isIPv4) {
                            var delim = sAddr.indexOf('%') // drop ip6 zone suffix
                            if (delim < 0) {
                                return sAddr.toUpperCase()
                            }
                            else {
                                return sAddr.substring(0, delim).toUpperCase()
                            }
                        }
                    }
                }
            }
        }
    } catch (e: java.lang.Exception) { }
    return ""
}
Zeina
la source
2

Dans votre activité, la fonction suivante getIpAddress(context)renvoie l'adresse IP du téléphone:

public static String getIpAddress(Context context) {
    WifiManager wifiManager = (WifiManager) context.getApplicationContext()
                .getSystemService(WIFI_SERVICE);

    String ipAddress = intToInetAddress(wifiManager.getDhcpInfo().ipAddress).toString();

    ipAddress = ipAddress.substring(1);

    return ipAddress;
}

public static InetAddress intToInetAddress(int hostAddress) {
    byte[] addressBytes = { (byte)(0xff & hostAddress),
                (byte)(0xff & (hostAddress >> 8)),
                (byte)(0xff & (hostAddress >> 16)),
                (byte)(0xff & (hostAddress >> 24)) };

    try {
        return InetAddress.getByAddress(addressBytes);
    } catch (UnknownHostException e) {
        throw new AssertionError();
    }
}
matdev
la source
Je reçois 0.0.0.0
natsumiyu
Votre téléphone est-il connecté à un réseau wifi? Quelle valeur est renvoyée si vous appelez wifiManager.getConnectionInfo (). GetSSID ()?
matdev
Cela fonctionnera-t-il pour les appareils connectés aux données mobiles, pas pour le WiFi?
Sergey
Non, cette méthode ne fonctionne que si l'appareil est connecté au WiFi
matdev
1

Voici la version kotlin de @Nilesh et @anargund

  fun getIpAddress(): String {
    var ip = ""
    try {
        val wm = applicationContext.getSystemService(WIFI_SERVICE) as WifiManager
        ip = Formatter.formatIpAddress(wm.connectionInfo.ipAddress)
    } catch (e: java.lang.Exception) {

    }

    if (ip.isEmpty()) {
        try {
            val en = NetworkInterface.getNetworkInterfaces()
            while (en.hasMoreElements()) {
                val networkInterface = en.nextElement()
                val enumIpAddr = networkInterface.inetAddresses
                while (enumIpAddr.hasMoreElements()) {
                    val inetAddress = enumIpAddr.nextElement()
                    if (!inetAddress.isLoopbackAddress && inetAddress is Inet4Address) {
                        val host = inetAddress.getHostAddress()
                        if (host.isNotEmpty()) {
                            ip =  host
                            break;
                        }
                    }
                }

            }
        } catch (e: java.lang.Exception) {

        }
    }

   if (ip.isEmpty())
      ip = "127.0.0.1"
    return ip
}
Sumit
la source
1
Si c'est votre style de code dans des projets réels, je vous suggère de lire "code propre" par robert martin
Ahmed Adel Ismail
1

Un appareil peut avoir plusieurs adresses IP, et celle utilisée dans une application particulière peut ne pas être l'adresse IP que les serveurs recevant la demande verront. En effet, certains utilisateurs utilisent un VPN ou un proxy tel que Cloudflare Warp .

Si votre objectif est d'obtenir l'adresse IP comme indiqué par les serveurs qui reçoivent des demandes de votre appareil, le mieux est d'interroger un service de géolocalisation IP tel que Ipregistry (avertissement: je travaille pour l'entreprise) avec son client Java:

https://github.com/ipregistry/ipregistry-java

IpregistryClient client = new IpregistryClient("tryout");
RequesterIpInfo requesterIpInfo = client.lookup();
requesterIpInfo.getIp();

En plus d'être vraiment simple à utiliser, vous obtenez des informations supplémentaires telles que le pays, la langue, la devise, le fuseau horaire de l'IP de l'appareil et vous pouvez identifier si l'utilisateur utilise un proxy.

Laurent
la source
1

C'est le moyen le plus simple et le plus simple qui ait jamais existé sur Internet ... Tout d'abord, ajoutez cette autorisation à votre fichier manifeste ...

  1. "L'INTERNET"

  2. "ACCESS_NETWORK_STATE"

ajoutez ceci dans le fichier onCreate of Activity.

    getPublicIP();

Ajoutez maintenant cette fonction à votre MainActivity.class.

    private void getPublicIP() {
ArrayList<String> urls=new ArrayList<String>(); //to read each line

        new Thread(new Runnable(){
            public void run(){
                //TextView t; //to show the result, please declare and find it inside onCreate()

                try {
                    // Create a URL for the desired page
                    URL url = new URL("https://api.ipify.org/"); //My text file location
                    //First open the connection
                    HttpURLConnection conn=(HttpURLConnection) url.openConnection();
                    conn.setConnectTimeout(60000); // timing out in a minute

                    BufferedReader in = new BufferedReader(new InputStreamReader(conn.getInputStream()));

                    //t=(TextView)findViewById(R.id.TextView1); // ideally do this in onCreate()
                    String str;
                    while ((str = in.readLine()) != null) {
                        urls.add(str);
                    }
                    in.close();
                } catch (Exception e) {
                    Log.d("MyTag",e.toString());
                }

                //since we are in background thread, to post results we have to go back to ui thread. do the following for that

                PermissionsActivity.this.runOnUiThread(new Runnable(){
                    public void run(){
                        try {
                            Toast.makeText(PermissionsActivity.this, "Public IP:"+urls.get(0), Toast.LENGTH_SHORT).show();
                        }
                        catch (Exception e){
                            Toast.makeText(PermissionsActivity.this, "TurnOn wiffi to get public ip", Toast.LENGTH_SHORT).show();
                        }
                    }
                });

            }
        }).start();

    }

Zia Muhammad
la source
urls.get (0) contient votre adresse IP publique.
Zia Muhammad
Vous devez déclarer dans votre fichier d'activité comme ceci: ArrayList <String> urls = new ArrayList <String> (); // pour lire chaque ligne
Zia Muhammad
0

Si vous avez un obus; ifconfig eth0 fonctionnait également pour les périphériques x86

RzR
la source
0

Veuillez vérifier ce code ... Utilisation de ce code. nous obtiendrons ip de l'Internet mobile ...

for (Enumeration<NetworkInterface> en = NetworkInterface.getNetworkInterfaces(); en.hasMoreElements(); ) {
                NetworkInterface intf = en.nextElement();
                for (Enumeration<InetAddress> enumIpAddr = intf.getInetAddresses(); enumIpAddr.hasMoreElements(); ) {
                    InetAddress inetAddress = enumIpAddr.nextElement();
                    if (!inetAddress.isLoopbackAddress()) {
                        return inetAddress.getHostAddress().toString();
                    }
                }
            }
venkat
la source
0

Je ne fais pas Android, mais j'aborderais cela d'une manière totalement différente.

Envoyez une requête à Google, quelque chose comme: https://www.google.com/webhp?sourceid=chrome-instant&ion=1&espv=2&ie=UTF-8#q=my%20ip

Et reportez-vous au champ HTML où la réponse est publiée. Vous pouvez également interroger directement la source.

Google préfère être là plus longtemps que votre application.

N'oubliez pas, il se peut que votre utilisateur ne dispose pas d'Internet pour le moment, qu'aimeriez-vous qu'il se passe!

Bonne chance

Makab
la source
Intéressant! Et je parie que Google a une sorte d'appel API qui retournera votre IP, qui sera plus stable que la numérisation HTML.
Scott Biggs
0

Tu peux le faire

String stringUrl = "https://ipinfo.io/ip";
//String stringUrl = "http://whatismyip.akamai.com/";
// Instantiate the RequestQueue.
RequestQueue queue = Volley.newRequestQueue(MainActivity.instance);
//String url ="http://www.google.com";

// Request a string response from the provided URL.
StringRequest stringRequest = new StringRequest(Request.Method.GET, stringUrl,
        new Response.Listener<String>() {
            @Override
            public void onResponse(String response) {
                // Display the first 500 characters of the response string.
                Log.e(MGLogTag, "GET IP : " + response);

            }
        }, new Response.ErrorListener() {
    @Override
    public void onErrorResponse(VolleyError error) {
        IP = "That didn't work!";
    }
});

// Add the request to the RequestQueue.
queue.add(stringRequest);
Raphaël Maguet
la source
0
 //    @NonNull
    public static String getIPAddress() {
        if (TextUtils.isEmpty(deviceIpAddress))
            new PublicIPAddress().execute();
        return deviceIpAddress;
    }

    public static String deviceIpAddress = "";

    public static class PublicIPAddress extends AsyncTask<String, Void, String> {
        InetAddress localhost = null;

        protected String doInBackground(String... urls) {
            try {
                localhost = InetAddress.getLocalHost();
                URL url_name = new URL("http://bot.whatismyipaddress.com");
                BufferedReader sc = new BufferedReader(new InputStreamReader(url_name.openStream()));
                deviceIpAddress = sc.readLine().trim();
            } catch (Exception e) {
                deviceIpAddress = "";
            }
            return deviceIpAddress;
        }

        protected void onPostExecute(String string) {
            Lg.d("deviceIpAddress", string);
        }
    }
Ashish Kumar
la source
0

En toute honnêteté, je ne suis qu'un peu familier avec la sécurité du code, donc cela peut être hack-ish. Mais pour moi, c'est la façon la plus polyvalente de le faire:

package com.my_objects.ip;

import java.net.InetAddress;
import java.net.UnknownHostException;

public class MyIpByHost 
{
  public static void main(String a[])
  {
   try 
    {
      InetAddress host = InetAddress.getByName("nameOfDevice or webAddress");
      System.out.println(host.getHostAddress());
    } 
   catch (UnknownHostException e) 
    {
      e.printStackTrace();
    }
} }
Tyler Depies-Bobrowitz
la source
0

Compiler certaines des idées pour obtenir l'ip wifi de la WifiManagerdans une meilleure solution kotlin:

private fun getWifiIp(context: Context): String? {
  return context.getSystemService<WifiManager>().let {
     when {
      it == null -> "No wifi available"
      !it.isWifiEnabled -> "Wifi is disabled"
      it.connectionInfo == null -> "Wifi not connected"
      else -> {
        val ip = it.connectionInfo.ipAddress
        ((ip and 0xFF).toString() + "." + (ip shr 8 and 0xFF) + "." + (ip shr 16 and 0xFF) + "." + (ip shr 24 and 0xFF))
      }
    }
  }
}

Alternativement, vous pouvez obtenir les adresses IP des périphériques de bouclage ip4 via NetworkInterface:

fun getNetworkIp4LoopbackIps(): Map<String, String> = try {
  NetworkInterface.getNetworkInterfaces()
    .asSequence()
    .associate { it.displayName to it.ip4LoopbackIps() }
    .filterValues { it.isNotEmpty() }
} catch (ex: Exception) {
  emptyMap()
}

private fun NetworkInterface.ip4LoopbackIps() =
  inetAddresses.asSequence()
    .filter { !it.isLoopbackAddress && it is Inet4Address }
    .map { it.hostAddress }
    .filter { it.isNotEmpty() }
    .joinToString()
Moritz
la source
-2

Sur la base de ce que j'ai testé, voici ma proposition

import java.net.*;
import java.util.*;

public class hostUtil
{
   public static String HOST_NAME = null;
   public static String HOST_IPADDRESS = null;

   public static String getThisHostName ()
   {
      if (HOST_NAME == null) obtainHostInfo ();
      return HOST_NAME;
   }

   public static String getThisIpAddress ()
   {
      if (HOST_IPADDRESS == null) obtainHostInfo ();
      return HOST_IPADDRESS;
   }

   protected static void obtainHostInfo ()
   {
      HOST_IPADDRESS = "127.0.0.1";
      HOST_NAME = "localhost";

      try
      {
         InetAddress primera = InetAddress.getLocalHost();
         String hostname = InetAddress.getLocalHost().getHostName ();

         if (!primera.isLoopbackAddress () &&
             !hostname.equalsIgnoreCase ("localhost") &&
              primera.getHostAddress ().indexOf (':') == -1)
         {
            // Got it without delay!!
            HOST_IPADDRESS = primera.getHostAddress ();
            HOST_NAME = hostname;
            //System.out.println ("First try! " + HOST_NAME + " IP " + HOST_IPADDRESS);
            return;
         }
         for (Enumeration<NetworkInterface> netArr = NetworkInterface.getNetworkInterfaces(); netArr.hasMoreElements();)
         {
            NetworkInterface netInte = netArr.nextElement ();
            for (Enumeration<InetAddress> addArr = netInte.getInetAddresses (); addArr.hasMoreElements ();)
            {
               InetAddress laAdd = addArr.nextElement ();
               String ipstring = laAdd.getHostAddress ();
               String hostName = laAdd.getHostName ();

               if (laAdd.isLoopbackAddress()) continue;
               if (hostName.equalsIgnoreCase ("localhost")) continue;
               if (ipstring.indexOf (':') >= 0) continue;

               HOST_IPADDRESS = ipstring;
               HOST_NAME = hostName;
               break;
            }
         }
      } catch (Exception ex) {}
   }
}
elxala
la source