क्या कुछ कोड का उपयोग करके डिवाइस का आईपी पता प्राप्त करना संभव है?
क्या कुछ कोड का उपयोग करके डिवाइस का आईपी पता प्राप्त करना संभव है?
जवाबों:
यह आईपी और मैक पते को पढ़ने के लिए मेरा सहायक उपयोग है। कार्यान्वयन शुद्ध-जावा है, लेकिन मेरे पास एक टिप्पणी ब्लॉक है getMACAddress()
जिसमें विशेष लिनक्स (एंड्रॉइड) फ़ाइल से मूल्य पढ़ सकते हैं। मैंने इस कोड को केवल कुछ उपकरणों और एमुलेटर पर चलाया है लेकिन अगर आपको अजीब परिणाम मिलते हैं तो मुझे यहाँ बताएं।
// 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 "";
}
}
अस्वीकरण: इस यूटिल्स वर्ग के लिए विचार और उदाहरण कोड कई एसओ पदों और Google से आए थे। मैंने सभी उदाहरणों को साफ और विलय कर दिया है।
toUpperCase()
। कैचिंग Exception
हमेशा डोज़ी होती है (और हेल्पर तरीकों को वैसे भी फेंक देना चाहिए और कॉलर को अपवाद के साथ सौदा करना चाहिए - हालांकि यह संशोधन नहीं किया है)। स्वरूपण: 80 से अधिक लाइनें नहीं होनी चाहिए। के लिए सशर्त निष्पादन getHardwareAddress()
- पैच: github.com/Utumno/AndroidHelpers/commit/… । क्या आप कहते हैं ?
यह मेरे लिए काम किया:
WifiManager wm = (WifiManager) getSystemService(WIFI_SERVICE);
String ip = Formatter.formatIpAddress(wm.getConnectionInfo().getIpAddress());
getHostAddress()
, जो IPv4 और IPv6 दोनों पतों का समर्थन करता है। यह विधि IPv6 पतों का समर्थन नहीं करती है।
मैंने निम्नलिखित कोड का उपयोग किया: मैंने जिस कारण से हैशकोड का उपयोग किया था, क्योंकि मुझे कुछ कूड़े के मूल्य मिल रहे थे, जब मैंने उपयोग किया था तो आईपी पते पर जोड़ा गया था getHostAddress
। लेकिन hashCode
मेरे लिए वास्तव में अच्छी तरह से काम किया है तो मैं सही स्वरूपण के साथ आईपी पते को प्राप्त करने के लिए फॉर्मैटर का उपयोग कर सकता हूं।
यहाँ उदाहरण आउटपुट है:
1. प्रयोग getHostAddress
:***** IP=fe80::65ca:a13d:ea5a:233d%rmnet_sdio0
2. प्रयोग hashCode
और Formatter
: ***** IP=238.194.77.212
जैसा कि आप देख सकते हैं कि 2 विधियां मुझे वही देती हैं जो मुझे चाहिए।
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;
}
getHostAddress()
आपके द्वारा जोड़े गए फॉर्मेटर सामान के समान होगा।
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;
}
मैंने यह जाँचने के लिए कि क्या यह एक ipv4 पता है, inetAddress
उदाहरण के Inet4Address
लिए जोड़ा है।
हालाँकि इसका एक सही उत्तर है, मैं यहाँ अपना उत्तर साझा करता हूँ और आशा करता हूँ कि इस तरह से अधिक सुविधा होगी।
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));
<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
नीचे दिए गए कोड आपकी मदद कर सकते हैं .. अनुमतियाँ जोड़ने के लिए मत भूलना ..
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;
}
मैनिफ़ेस्ट फ़ाइल में अनुमति के नीचे जोड़ें।
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
खुश कोडिंग !!
अब तक प्रदान किए गए समाधानों के साथ मामला क्या है, आपको अनुमतियों को जोड़ने की आवश्यकता नहीं है। इस वेबसाइट को एक स्ट्रिंग के रूप में डाउनलोड करें:
या
एक वेबसाइट को स्ट्रिंग के रूप में डाउनलोड करना जावा कोड के साथ किया जा सकता है:
http://www.itcuties.com/java/read-url-to-string/
इस तरह JSON वस्तु को पार्स करें:
https://stackoverflow.com/a/18998203/1987258
Json विशेषता "क्वेरी" या "ip" में IP पता होता है।
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;
}
विधि getDeviceIpAddress डिवाइस का IP पता लौटाता है और यदि यह जुड़ा हुआ है तो वाईफाई इंटरफ़ेस पता पसंद करता है।
@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;
}
यह इस उत्तर की एक पुनरावृत्ति है जो अप्रासंगिक जानकारी को स्ट्रिप करता है, सहायक टिप्पणियां जोड़ता है, नामों को अधिक स्पष्ट रूप से जोड़ता है, और तर्क को बेहतर बनाता है।
निम्नलिखित अनुमतियों को शामिल करना न भूलें:
<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);
}
}
इस साइट से आईपी प्राप्त करने के लिए बस वॉली का उपयोग करें
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);
हाल ही में, getLocalIpAddress()
नेटवर्क से डिस्कनेक्ट होने के बावजूद (कोई सेवा संकेतक नहीं) होने पर भी एक आईपी पता वापस कर दिया जाता है। इसका अर्थ है सेटिंग्स में प्रदर्शित IP पता> फ़ोन के बारे में> स्थिति उस एप्लिकेशन से अलग थी जो उसने सोचा था।
मैंने पहले इस कोड को जोड़कर वर्कअराउंड लागू किया है:
ConnectivityManager cm = getConnectivityManager();
NetworkInfo net = cm.getActiveNetworkInfo();
if ((null == net) || !net.isConnectedOrConnecting()) {
return null;
}
क्या वह घंटी किसी को बजती है?
कोटलिन में, बिना फॉर्मेट के
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 ""
}
आपकी गतिविधि में, निम्न फ़ंक्शन getIpAddress(context)
फ़ोन का IP पता लौटाता है:
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();
}
}
यहां @Nilesh और @anargund का kotlin संस्करण है
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
}
एक डिवाइस में कई आईपी पते हो सकते हैं, और किसी विशेष ऐप में उपयोग होने वाला आईपी ऐसा आईपी नहीं हो सकता है जिसे अनुरोध प्राप्त करने वाले सर्वर देखेंगे। दरअसल, कुछ उपयोगकर्ता वीपीएन या प्रॉक्सी का उपयोग करते हैं जैसे कि क्लाउडफ्लेयर ताना ।
यदि आपका उद्देश्य आईपी पता प्राप्त करना है जैसा कि आपके डिवाइस से अनुरोध प्राप्त करने वाले सर्वरों द्वारा दिखाया गया है, तो आईपी जियोलोकेशन सेवा जैसे कि Ipregistry (अस्वीकरण: मैं कंपनी के लिए काम करता हूं) को अपने जावा क्लाइंट के साथ क्वेरी करना सबसे अच्छा है :
https://github.com/ipregistry/ipregistry-java
IpregistryClient client = new IpregistryClient("tryout");
RequesterIpInfo requesterIpInfo = client.lookup();
requesterIpInfo.getIp();
उपयोग करने के लिए वास्तव में सरल होने के अलावा, आपको डिवाइस आईपी के लिए देश, भाषा, मुद्रा, समय क्षेत्र जैसी अतिरिक्त जानकारी मिलती है और आप पहचान सकते हैं कि उपयोगकर्ता प्रॉक्सी का उपयोग कर रहा है या नहीं।
यह इंटरनेट पर मौजूद सबसे आसान और सरल तरीका है ... सबसे पहले, इस अनुमति को अपनी मैनिफ़ेस्ट फ़ाइल में जोड़ें ...
"इंटरनेट"
"ACCESS_NETWORK_STATE"
गतिविधि के onCreate फ़ाइल में इसे जोड़ें ..
getPublicIP();
अब इस फ़ंक्शन को अपने 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();
}
कृपया इस कोड को देखें ... इस कोड का उपयोग करना। हम मोबाइल इंटरनेट से आईपी मिलेगा ...
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();
}
}
}
मैं एंड्रॉइड नहीं करता, लेकिन मैं इससे बिल्कुल अलग तरीके से निपटूंगा।
Google को एक क्वेरी भेजें, जैसे कुछ: https://www.google.com/webhp?sourceid=chrome-instant&ion=1&espv=2&ie=UTF-8#q=my%20ip
और HTML फ़ील्ड को देखें जहां प्रतिक्रिया पोस्ट की गई है। आप सीधे स्रोत से भी प्रश्न कर सकते हैं।
Google आपके एप्लिकेशन से अधिक समय तक वहां रहना पसंद करेगा।
बस याद रखें, यह हो सकता है कि आपके उपयोगकर्ता के पास इस समय इंटरनेट नहीं है, तो आप क्या करना चाहेंगे!
शुभ लाभ
तुम यह केर सकते हो
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);
// @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);
}
}
सभी ईमानदारी में मैं केवल कोड सुरक्षा से थोड़ा परिचित हूं, इसलिए यह हैक-ईश हो सकता है। लेकिन मेरे लिए यह करने का सबसे बहुमुखी तरीका है:
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();
}
} }
WifiManager
एक अच्छे कोटलिन समाधान से वाईफाई आईपी प्राप्त करने के लिए कुछ विचारों का संकलन :
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))
}
}
}
}
वैकल्पिक रूप से आप ip4 लूपबैक उपकरणों के आईपी एड्रेसेस को इसके माध्यम से प्राप्त कर सकते हैं 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()
मैंने जो परीक्षण किया है, उसके आधार पर यह मेरा प्रस्ताव है
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) {}
}
}