অ্যান্ড্রয়েড ডিভাইসে ইন্টারনেট সংযোগ রয়েছে কিনা তা সনাক্ত করুন

138

আমার ডিভাইসের ইন্টারনেট সংযোগ আছে কি না তা আমাকে বলতে হবে। আমি অনেক উত্তর পেয়েছি যেমন:

private boolean isNetworkAvailable() {
    ConnectivityManager connectivityManager 
         = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
    NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo();
    return activeNetworkInfo != null;
}

(থেকে নেওয়া সনাক্ত একটি ইন্টারনেট Android এর উপর প্রাপ্তিসাধ্য সংযোগ আছে কিনা ।)

তবে এটি সঠিক নয়, উদাহরণস্বরূপ যদি আমি একটি ওয়্যারলেস নেটওয়ার্কের সাথে সংযুক্ত থাকি যার কাছে ইন্টারনেট অ্যাক্সেস নেই , তবে এই পদ্ধতিটি সত্য হবে ... ডিভাইসটির ইন্টারনেট সংযোগ রয়েছে কিনা তা জানার কোনও উপায় আছে কি না এটি কেবল সংযুক্ত থাকলেই কি না? কিছু আছে?

android  internet-connection  android-internet 
— বুদা গ্যাভ্রিল
সূত্র
আরে আপনি [এটি] [1] পাশাপাশি যেতে পারেন। এটি সাহায্য করতে পারে! [১]: স্ট্যাকওভারফ্লো.com
— অক্ষয়
— Palec
isNetworkConnectedফাংশন ব্লক সব জন্য অসমর্থিত কোড রয়েছে Build.VERSION.SDK_INT >= Build.VERSION_CODES.M। বিষয়টি সম্পর্কে আরও গভীরতর আলোচনা এবং কীভাবে এটি ঠিক করা যায় তা এখানে পাওয়া যাবে stackoverflow.com/questions/53532406/…
— বাস্তি ওয়াগাবন্ড

উত্তর:

182

তুমি ঠিক. কোনও নেটওয়ার্ক সংযোগ থাকলে আপনি যে কোডটি সরবরাহ করেছেন তা কেবলমাত্র চেক করে। একটি সক্রিয় ইন্টারনেট সংযোগ আছে কিনা তা যাচাই করার সর্বোত্তম উপায় হ'ল HTTP- র মাধ্যমে কোনও পরিচিত সার্ভারের সাথে যোগাযোগ করা।

public static boolean hasActiveInternetConnection(Context context) {
    if (isNetworkAvailable(context)) {
        try {
            HttpURLConnection urlc = (HttpURLConnection) (new URL("http://www.google.com").openConnection());
            urlc.setRequestProperty("User-Agent", "Test");
            urlc.setRequestProperty("Connection", "close");
            urlc.setConnectTimeout(1500); 
            urlc.connect();
            return (urlc.getResponseCode() == 200);
        } catch (IOException e) {
            Log.e(LOG_TAG, "Error checking internet connection", e);
        }
    } else {
        Log.d(LOG_TAG, "No network available!");
    }
    return false;
}

অবশ্যই আপনি http://www.google.comসংযুক্ত করতে চান এমন অন্য যে কোনও সার্ভারের জন্য ইউআরএল প্রতিস্থাপন করতে পারেন , বা আপনার পরিচিত কোনও সার্ভারের একটি ভাল আপটাইম রয়েছে।

যেমন টনি চও নীচে এই মন্তব্যে উল্লেখ করেছেন , নিশ্চিত করুন যে আপনি এই কোডটি মূল থ্রেডে না চালাচ্ছেন, অন্যথায় আপনি একটি নেটওয়ার্কঅনমেনথ্রেড ব্যতিক্রম পাবেন (অ্যান্ড্রয়েড 3.0.০ বা তার পরে)। পরিবর্তে একটি অ্যাসিঙ্কটাস্ক বা চলমানযোগ্য ব্যবহার করুন।

আপনি যদি google.com ব্যবহার করতে চান তবে আপনার যিশুরুনের পরিবর্তনের দিকে নজর দেওয়া উচিত। ইন তার উত্তর তিনি আমার কোড মডিফাই এবং এটি একটি বিট আরো দক্ষ প্রণীত। আপনি যদি সংযুক্ত হন

HttpURLConnection urlc = (HttpURLConnection) 
            (new URL("http://clients3.google.com/generate_204")
            .openConnection());

এবং তারপরে 204 এর জন্য প্রতিক্রিয়া কোডটি পরীক্ষা করুন check

return (urlc.getResponseCode() == 204 && urlc.getContentLength() == 0);

তাহলে আপনাকে প্রথমে পুরো গুগল হোম পেজটি আনতে হবে না।

— THelper
সূত্র
9
@varunbhardwaj আপনি শুধু কোনো আলাদা ওয়েবসাইটের (যেমন নিতে পারেন baidu.com যখন চীন মধ্যে আপনার অ্যাপ্লিকেশান মোতায়েন), অথবা আপনি প্রথমটি নিশ্চিত কোন সংযোগ আছে তা নিশ্চিত করুন করতে অসমর্থ হয় একটি দ্বিতীয় সাইটের চেষ্টা করতে পারেন।
— থেল্পার
2
আমি আপনার উত্তরটি +1 করেছি এবং এটি আমার অ্যাপ্লিকেশনটিতে ব্যবহার করে জানি, তবে কিছু ওয়েবসাইটে নির্ভরতার একটি বড় কোণ রয়েছে এবং আমার প্রশ্নটি এখনও উত্তরহীন। যাইহোক দুর্দান্ত workaround থেক্স।
— বরুণ ভরদ্বাজ
2
@ ব্ল্যাকক্রো আপনি / ব্যবহারকারীগণ কতক্ষণ অপেক্ষা করতে ইচ্ছুক তা নির্ভর করে। ব্যক্তিগতভাবে আমি 1000ms কে নিম্ন সীমা হিসাবে বিবেচনা করি, গড় সম্পর্কে প্রায় 6000 মিমি এবং 15000ms দীর্ঘ। তবে যদি চেকটি পটভূমিতে চলছে এবং ব্যবহারকারী এটির জন্য অপেক্ষা না করছে আপনি আরও দীর্ঘ সময়সীমা ব্যবহার করতে পারেন।
— থেল্পার
1
@ ভারুনভর্দ্বাজ এমন কিছু ইউআরআই থাকা উচিত যা আপনি আপনার ওয়েব পরিষেবাদি থেকে হিট করতে পারেন। আমাদের অ্যাপটি শুরু করার সময় আমরা প্রথমে যে অনুরোধটি করি তা হ'ল বুটস্ট্র্যাপ ফাইল যা বিভিন্ন কনফিগারেশন তথ্য ধারণ করে, যা আমাদের বিভিন্ন পরামিতিগুলির সার্ভার-সাইড পরিবর্তন করতে দেয়। এরকম কিছু ব্যবহার করা যেতে পারে।
— স্টিভ
11
এটি একটি পটভূমির থ্রেডেও নীচে থাকা উচিত (যেখানে চেক করার জন্য ConnectivityManagerএটির প্রয়োজন হয় না)। অন্যথায়, অ্যান্ড্রয়েড 4.x + ডিভাইসে আপনি একটি NetworkOnMainThreadব্যতিক্রম পাবেন।
— অ্যান্টনি চুইনার্ড
90

সংযুক্ত ওয়াইফাই নেটওয়ার্কটিতে ইন্টারনেট অ্যাক্সেস আছে কিনা তা যাচাই করতে অ্যান্ড্রয়েড ইতিমধ্যে ব্যবহার করে এমন একটি হ্যাক ব্যবহার করার জন্য আমি থেল্পারের উত্তরটি কিছুটা সংশোধন করেছি। এটি পুরো গুগল হোম পেজ দখল করার চেয়ে অনেক বেশি দক্ষ। দেখুন এখানে এবং এখানে আরও তথ্যের জন্য।

public static boolean hasInternetAccess(Context context) {
    if (isNetworkAvailable(context)) {
        try {
            HttpURLConnection urlc = (HttpURLConnection) 
                (new URL("http://clients3.google.com/generate_204")
                .openConnection());
            urlc.setRequestProperty("User-Agent", "Android");
            urlc.setRequestProperty("Connection", "close");
            urlc.setConnectTimeout(1500); 
            urlc.connect();
            return (urlc.getResponseCode() == 204 &&
                        urlc.getContentLength() == 0);
        } catch (IOException e) {
            Log.e(TAG, "Error checking internet connection", e);
        }
    } else {
        Log.d(TAG, "No network available!");
    }
    return false;
}
— ইসরাইল
সূত্র
1
হ্যালো, বর্তমান অ্যাপ্লিকেশনগুলিতে এই অনুশীলনটি ব্যবহার করা কি ঠিক হবে?
— স্লাভা ফমিন দ্বিতীয়
এটি কি আমাদের বর্তমান অ্যাপ্লিকেশনটিতে কার্যকর করার দক্ষ?
— থ্যালাপ্রশান্ত
5
এটি উপরের উত্তরের পদ্ধতির তুলনায় আরও কার্যকর হবে। গুগলের হোম পেজটি ধরা খুব অদক্ষ, বিশেষত যদি এটিতে ডুডল থাকে।
— যিশুরুন
1
সঠিক প্রতিক্রিয়া হিসাবে যাচাই করা হয়েছে এটি দিয়ে আপডেট করা উচিত কারণ এটি উত্তরটির উন্নতি করে। ভাল কাজ, ধন্যবাদ
— হুগো
3
আপনি যদি চায়নাতেও সংযোগের পরীক্ষা করতে চান তবে ক্লায়েন্ট 3.google.com/generate_204 এর পরিবর্তে আপনি g.cn/generate_204 ব্যবহার করতে চাইতে পারেন
— ব্রিজে
18 
public boolean isInternetWorking() {
    boolean success = false;
    try {
        URL url = new URL("https://google.com");
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.setConnectTimeout(10000);
        connection.connect();
        success = connection.getResponseCode() == 200;
    } catch (IOException e) {
        e.printStackTrace();
    }
    return success;
}

ইন্টারনেট প্রকৃতপক্ষে উপলব্ধ হলে সত্য প্রত্যাবর্তন করুন

আপনার এই দুটি অনুমতি আছে তা নিশ্চিত করুন

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

নতুন অ্যান্ড্রয়েড সুরক্ষার কারণে যদি HTTP এটি কাজ না করে তবে তারা এখন সরল পাঠ্য যোগাযোগের অনুমতি দেয় না। এখনই এটি পাস করার জন্য।

অ্যান্ড্রয়েড usesCleartextTraffic = "সত্য"

— বিলাল শহীদ
সূত্র
এটি সেরা, সবচেয়ে সম্পূর্ণ উত্তর: এটি জিনিসগুলির সবচেয়ে সংক্ষিপ্ততম উপায় (একটি পিং পুরো ওয়েবসাইট অ্যাক্সেস করে না), এটি আপনার যে সংযোগটি থেকে স্বতঃস্ফূর্তভাবে চালিত হয় এবং এটি এটি জিতেছে প্রক্রিয়াতে চলে তাই এটি অ্যান্ড্রয়েড সংস্করণগুলির সাথে দুর্দান্ত খেলে ।
— ম্যাকডি
তোমার মানে কি? এখানে একটি বর্তমান স্নিপেট যা আমি একটি বর্তমান প্রকল্প চেক ইনটারনেট
— বিলাল শহীদ ২
তার মানে কি এই কলটি ইউআইকে ব্লক করবে এবং তার এই কলটি থ্রেডে করা দরকার ??
— অমিত হুদা
2
এটি আমার পক্ষে কাজ করে না ... এর ফলে: android.os.NetworkOnMainThreadException at android.os.StictMode $ AndroidBlockGuardPolicy.onNetwork (স্ট্রাইকডমড.জভা १२:২৩) java.net.InetAddress.lookupHostByName (InetAddress.java:41) এ এ
— মেরিদি পোইপো
@ হাইসোকাপোইপো আপনার মূল থ্রেড এড়ানো উচিত নয়। একটি পৃথক থ্রেড বা অ্যাসিঙ্কটাস্ক ব্যবহার করুন।
— প্রমেশ বাজরাচার্য
14

আপনি যদি ললিপপ বা তার থেকেও বেশি লক্ষ্য করে থাকেন তবে নতুন নেটওয়ার্কক্যাবিলিটি ক্লাসটি ব্যবহার করা সম্ভব, যেমন:

public static boolean hasInternetConnection(final Context context) {
    final ConnectivityManager connectivityManager = (ConnectivityManager)context.
            getSystemService(Context.CONNECTIVITY_SERVICE);

    final Network network = connectivityManager.getActiveNetwork();
    final NetworkCapabilities capabilities = connectivityManager
            .getNetworkCapabilities(network);

    return capabilities != null
            && capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED);
}
— জোহান
সূত্র
1
connectivityManager.getActiveNetwork();এপিআই lvl23 প্রয়োজন যা মার্শমেলো এবং ললিপপ নয়।
— স্যানিক
আমাদের কি দক্ষতা পরীক্ষা করা উচিত? ক্যাপাসিটি (নেটওয়ার্কসাপ্প্যাবিলিটিস। NET_CAPABILITY_INTERNET)?
— অ্যালেক্স
অ্যালেক্স capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)মনে হচ্ছিল আমার জন্য কৌতুক করবে!
— আরএসটোজানো
6

অগত্যা আপনাকে একটি পূর্ণ এইচটিটিপি সংযোগ করার দরকার নেই। আপনি কোনও পরিচিত হোস্টের সাথে কেবলমাত্র একটি টিসিপি সংযোগ খোলার চেষ্টা করতে পারেন এবং এটি সফল হলে আপনার ইন্টারনেট সংযোগ রয়েছে have

public boolean hostAvailable(String host, int port) {
  try (Socket socket = new Socket()) {
    socket.connect(new InetSocketAddress(host, port), 2000);
    return true;
  } catch (IOException e) {
    // Either we have a timeout or unreachable host or failed DNS lookup
    System.out.println(e);
    return false;
  }
}

তারপরে কেবল এটির সাথে পরীক্ষা করুন:

boolean online = hostAvailable("www.google.com", 80);
— চতুর্দশ
সূত্র
80 বন্দরটি কি নিরাপদ পোর্ট ব্যবহার করতে হবে?
— ralphgabb
যতক্ষণ এটি কোনও এইচটিটিপি সার্ভারকে হোস্ট করছে ততক্ষণ এটি পোর্ট ৮০ তে একটি টিসিপি সংযোগ গ্রহণ করা উচিত
— Xiv
এটি কি কোনও এসিঙ্কটাস্কের অভ্যন্তরে ব্যবহার করা উচিত বা উদাহরণস্বরূপ মেইনএ্যাকটিভিটির অনক্রেট পদ্ধতিতে ডাকা উচিত?
— অ্যালেক্সিওয়ে
@ ওয়েভ যে কোনও নেটওয়ার্ক সম্পর্কিত যা মূল / ইউআই থ্রেডে চলবে না। সুতরাং হ্যাঁ, এটি একটিAsyncTask
— উইঙ্কলারের মধ্যে
6

গৃহীত উত্তরের উপর ভিত্তি করে, আমি শ্রোতার সাথে এই ক্লাসটি তৈরি করেছি যাতে আপনি এটি মূল থ্রেডে ব্যবহার করতে পারেন:

প্রথম : ইন্টারেন্টচেক ক্লাস যা পটভূমিতে ইন্টারনেট সংযোগের জন্য পরীক্ষা করে তারপরে ফলাফলের সাথে একটি শ্রোতার পদ্ধতিতে কল করে।

public class InternetCheck extends AsyncTask<Void, Void, Void> {


    private Activity activity;
    private InternetCheckListener listener;

    public InternetCheck(Activity x){

        activity= x;

    }

    @Override
    protected Void doInBackground(Void... params) {


        boolean b = hasInternetAccess();
        listener.onComplete(b);

        return null;
    }


    public void isInternetConnectionAvailable(InternetCheckListener x){
        listener=x;
        execute();
    }

    private boolean isNetworkAvailable() {
        ConnectivityManager connectivityManager = (ConnectivityManager) activity.getSystemService(CONNECTIVITY_SERVICE);
        NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo();
        return activeNetworkInfo != null;
    }
    private boolean hasInternetAccess() {
        if (isNetworkAvailable()) {
            try {
                HttpURLConnection urlc = (HttpURLConnection) (new URL("http://clients3.google.com/generate_204").openConnection());
                urlc.setRequestProperty("User-Agent", "Android");
                urlc.setRequestProperty("Connection", "close");
                urlc.setConnectTimeout(1500);
                urlc.connect();
                return (urlc.getResponseCode() == 204 &&
                        urlc.getContentLength() == 0);
            } catch (IOException e) {
                e.printStackTrace();
            }
        } else {
            Log.d("TAG", "No network available!");
        }
        return false;
    }

    public interface InternetCheckListener{
        void onComplete(boolean connected);
    }

}

দ্বিতীয় : মূল থ্রেডে ক্লাসের একটি উদাহরণ ইনস্ট্যান্ট করুন এবং প্রতিক্রিয়াটির জন্য অপেক্ষা করুন (যদি আপনি অ্যান্ড্রয়েডের জন্য ফায়ারবেস এপি সাথে কাজ করেন তবে এটি আপনার পরিচিত হওয়া উচিত!)।

new InternetCheck(activity).isInternetConnectionAvailable(new InternetCheck.InternetCheckListener() {

        @Override
        public void onComplete(boolean connected) {
           //proceed!
        }
    });

এখন কমপ্লিট মেথডের ভিতরে আপনি ডিভাইসটি ইন্টারনেটের সাথে সংযুক্ত আছে কিনা তা পাবেন।

— Aya
সূত্র
3

আর একবার চেষ্টা কর

public class ConnectionDetector {
    private Context _context;

    public ConnectionDetector(Context context) {
        this._context = context;
    }

    public boolean isConnectingToInternet() {
        if (networkConnectivity()) {
            try {
                HttpURLConnection urlc = (HttpURLConnection) (new URL(
                        "http://www.google.com").openConnection());
                urlc.setRequestProperty("User-Agent", "Test");
                urlc.setRequestProperty("Connection", "close");
                urlc.setConnectTimeout(3000);
                urlc.setReadTimeout(4000);
                urlc.connect();
                // networkcode2 = urlc.getResponseCode();
                return (urlc.getResponseCode() == 200);
            } catch (IOException e) {
                return (false);
            }
        } else
            return false;

    }

    private boolean networkConnectivity() {
        ConnectivityManager cm = (ConnectivityManager) _context
                .getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo networkInfo = cm.getActiveNetworkInfo();
        if (networkInfo != null && networkInfo.isConnected()) {
            return true;
        }
        return false;
    }
}

আপনার প্রকাশিত ফাইলটিতে আপনাকে নিম্নলিখিত অনুমতিটি যুক্ত করতে হবে:

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

তারপরে কল করুন:

if((new ConnectionDetector(MyService.this)).isConnectingToInternet()){
    Log.d("internet status","Internet Access");
}else{
    Log.d("internet status","no Internet Access");
}
— Attaullah
সূত্র
পোস্টটি পরীক্ষা stackoverflow.com/questions/36233507/...
— মিলান Gajera
এই সমকামি ধরার চেষ্টা করে তাই ত্রুটি দেখানো হয়নি দয়া করে প্রথমে ইন্টারনেট অনুমতি যুক্ত করুন তারপর এটি চেষ্টা করুন। এটির কাজটি
— ঠিকঠাক
আমাকে বলি যে আমি কীভাবে আমার ক্রিয়াকলাপে এই পদ্ধতিটি কল করেছি?
— মিলান গাজেরা
আমি আপনাকে পোস্ট করার চেষ্টা করেছি এবং আমার একটি ব্লগটিতে একটি ত্রুটি পোস্ট করার পরে আমি একটি ত্রুটি পেয়েছি
— মিলান গাজেরা
stackoverflow.com/questions/36233507/... এটি পরীক্ষা
— মিলান Gajera
1

আপনি ConnectivityManagerএন্ড্রয়েডের এপিআই ব্যবহার করে এটি করতে পারেন । এটি আপনাকে ইন্টারনেট এবং আপনি যে ধরণের ইন্টারনেট সংযোগে সংযুক্ত আছেন তার সাথে সংযুক্ত কিনা তা যাচাই করার অনুমতি দেয়। মূলত, মিটার বা আন-মিটার।

ইন্টারনেট সংযোগের জন্য পরীক্ষা করতে।

ConnectivityManager cm = (ConnectivityManager)context.getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
boolean isConnected = activeNetwork != null && activeNetwork.isConnectedOrConnecting();

ডকুমেন্টেশনের লিঙ্ক: https://developer.android.com/training/monmitted-device-state/connectivity-status-type

— ফেলিক্স ফেভেন চাইনিমেরেম
সূত্র
মোবাইল ডেটা ফুরিয়েছে কিনা আপনি কীভাবে পরীক্ষা করবেন? মোবাইল ডেটা সংযুক্ত থাকলেও এবং অ্যাকাউন্টে কোনও ডেটা ব্যালেন্স না থাকলেও এটি সত্য returns
— ব্যবহারকারী2672052
0 
private static NetworkUtil mInstance;
private volatile boolean mIsOnline;

private NetworkUtil() {
    ScheduledExecutorService exec = Executors.newSingleThreadScheduledExecutor();
    exec.scheduleAtFixedRate(new Runnable() {
        @Override
        public void run() {
            boolean reachable = false;
            try {
                Process process = java.lang.Runtime.getRuntime().exec("ping -c 1 www.google.com");
                int returnVal = process.waitFor();
                reachable = (returnVal==0);
            } catch (Exception e) {
                e.printStackTrace();
            }
            mIsOnline = reachable;
        }
    }, 0, 5, TimeUnit.SECONDS);
}

public static NetworkUtil getInstance() {
    if (mInstance == null) {
        synchronized (NetworkUtil.class) {
            if (mInstance == null) {
                mInstance = new NetworkUtil();
            }
        }
    }
    return mInstance;
}

public boolean isOnline() {
    return mIsOnline;
}

আশা করি উপরের কোডটি আপনাকে সহায়তা করেছে, আপনার অ্যাপে ইন্টারনেট অনুমতি রয়েছে কিনা তাও নিশ্চিত করুন।

— RaghavPai
সূত্র
0

ডকুমেন্টেশন থেকে এটি করার সর্বশেষতম উপায় হ'ল ConnectivityManagerসক্রিয় নেটওয়ার্কটি জিজ্ঞাসা করার জন্য এটি ব্যবহার করা এবং এটির সাথে ইন্টারনেট সংযোগ রয়েছে কিনা তা নির্ধারণ করা।

public boolean hasInternetConnectivity() {
    ConnectivityManager cm =
        (ConnectivityManager)context.getSystemService(Context.CONNECTIVITY_SERVICE);

    NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
    return (activeNetwork != null &&
                      activeNetwork.isConnectedOrConnecting());
}

আপনার AndroidManLive.xML ফাইলে এই দুটি অনুমতি যুক্ত করুন:

<uses-permission android:name="android.permission.INTERNET"/>
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
— ডিনামো
সূত্র
1
কাজ করছে না :( @ বুডা গ্যাভ্রিল বলেছেন যে, আমি যদি এমন একটি ওয়্যারলেস নেটওয়ার্কের সাথে সংযুক্ত থাকি যার কাছে ইন্টারনেট অ্যাক্সেস নেই, তবে এই পদ্ধতিটি সত্য হয়ে উঠবে। শাওমি ৪, অ্যান্ড্রয়েড
— .0.০.১-এ পরীক্ষা
0

সংযোগ ব্যবস্থাপনায় ওয়াইফাই টাইপ পরীক্ষা করুন:

   //check network connection
    ConnectivityManager cm = (ConnectivityManager) this.getSystemService(Context.CONNECTIVITY_SERVICE);
    NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
    boolean hasNetworkConnection = activeNetwork != null && activeNetwork.isConnectedOrConnecting();
    System.out.println("Connection ? : " + hasNetworkConnection);
    //check wifi
    boolean hasWifiConnection = activeNetwork.getType() == ConnectivityManager.TYPE_WIFI;
    System.out.println("Wifi ? : " + hasWifiConnection);

অ্যান্ড্রয়েড ডকুমেন্টেশন 'TYPE_WIFI' কে 'A WIFI ডেটা সংযোগ হিসাবে বর্ণনা করে। ডিভাইসগুলি একের বেশি সমর্থন করতে পারে। '

— vasmos
সূত্র
0

সক্রিয় নেটওয়ার্কে ইন্টারনেট সংযোগ রয়েছে কিনা তা যাচাই করার একটি দুর্দান্ত সমাধান: 

public boolean isNetworkAvailable(Context context) {
    ConnectivityManager connectivityManager
            = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
    if (connectivityManager != null) {
        Network network = connectivityManager.getActiveNetwork();
        NetworkCapabilities networkCapabilities = connectivityManager.getNetworkCapabilities(network);
        return networkCapabilities != null && networkCapabilities
                .hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET);
    }
    return false;
}
— বিরল সার্বান
সূত্র
0

আপনি কানেক্টিভিটি ম্যানেজার ব্যবহার করতে পারেন। 

val cm = getApplicationContext().getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
            val activeNetwork: NetworkInfo? = cm.activeNetworkInfo
            val dialogBuilder = AlertDialog.Builder(this)

            if (activeNetwork!=null) // Some network is available
            {
                if (activeNetwork.isConnected) { // Network is connected to internet

    }else{ // Network is NOT connected to internet

    }

এটি এবং এই পরীক্ষা করুন

— Zeni
সূত্র
0

সর্বশেষ এপিআই স্তরে আপডেট হওয়া নিম্নলিখিত ক্লাসটি ব্যবহার করুন : 29।

// License: MIT
// http://opensource.org/licenses/MIT
package net.i2p.android.router.util;

import android.content.Context;
import android.net.ConnectivityManager;
import android.net.Network;
import android.net.NetworkCapabilities;
import android.net.NetworkInfo;
import android.os.AsyncTask;
import android.os.Build;
import android.telephony.TelephonyManager;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.concurrent.CancellationException;



/**
 * Check device's network connectivity and speed.
 *
 * @author emil http://stackoverflow.com/users/220710/emil
 * @author str4d
 * @author rodrigo https://stackoverflow.com/users/5520417/rodrigo
 */
public class ConnectivityAndInternetAccessCheck {

    private static ArrayList < String > hosts = new ArrayList < String > () {
        {
            add("google.com");
            add("facebook.com");
            add("apple.com");
            add("amazon.com");
            add("twitter.com");
            add("linkedin.com");
            add("microsoft.com");
        }
    };
    /**
     * Get the network info.
     *
     * @param context the Context.
     * @return the active NetworkInfo.
     */
    private static NetworkInfo getNetworkInfo(Context context) {
        NetworkInfo networkInfo = null;
        ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        if (cm != null) {
            networkInfo = cm.getActiveNetworkInfo();
        }
        return networkInfo;
    }

    /**
     * Gets the info of all networks
     * @param context The context
     * @return an array of @code{{@link NetworkInfo}}
     */
    private static NetworkInfo[] getAllNetworkInfo(Context context) {
        ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        return cm.getAllNetworkInfo();
    }

    /**
     * Gives the connectivity manager
     * @param context The context
     * @return the @code{{@link ConnectivityManager}}
     */
    private static ConnectivityManager getConnectivityManager(Context context) {
        return (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
    }

    /**
     * Check if there is any connectivity at all.
     *
     * @param context the Context.
     * @return true if we are connected to a network, false otherwise.
     */
    public static boolean isConnected(Context context) {
        boolean isConnected = false;
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            ConnectivityManager connectivityManager = ConnectivityAndInternetAccessCheck.getConnectivityManager(context);
            Network[] networks = connectivityManager.getAllNetworks();
            networksloop: for (Network network: networks) {
                if (network == null) {
                    isConnected = false;
                } else {
                    NetworkCapabilities networkCapabilities = connectivityManager.getNetworkCapabilities(network);
                    if(networkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)){
                        isConnected = true;
                        break networksloop;
                    }
                    else {
                        isConnected = false;
                    }
                }
            }

        } else {
            NetworkInfo[] networkInfos = ConnectivityAndInternetAccessCheck.getAllNetworkInfo(context);
            networkinfosloop: for (NetworkInfo info: networkInfos) {
                // Works on emulator and devices.
                // Note the use of isAvailable() - without this, isConnected() can
                // return true when Wifi is disabled.
                // http://stackoverflow.com/a/2937915
                isConnected = info != null && info.isAvailable() && info.isConnected();
                if (isConnected) {
                    break networkinfosloop;
                }
            }

        }
        return isConnected;
    }

    /**
     * Check if there is any connectivity to a Wifi network.
     *
     * @param context the Context.
     * @return true if we are connected to a Wifi network, false otherwise.
     */
    public static boolean isConnectedWifi(Context context) {
        boolean isConnectedWifi = false;
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            ConnectivityManager connectivityManager = ConnectivityAndInternetAccessCheck.getConnectivityManager(context);
            Network[] networks = connectivityManager.getAllNetworks();
            networksloop: for (Network network: networks) {
                if (network == null) {
                    isConnectedWifi = false;
                } else {
                    NetworkCapabilities networkCapabilities = connectivityManager.getNetworkCapabilities(network);
                    if(networkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)){
                        if (networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)) {
                            isConnectedWifi = true;
                            break networksloop;
                        } else {
                            isConnectedWifi = false;
                        }
                    }
                }

            }


        } else {
            NetworkInfo[] networkInfos = ConnectivityAndInternetAccessCheck.getAllNetworkInfo(context);
            networkinfosloop: for (NetworkInfo n: networkInfos) {
                isConnectedWifi = n != null && n.isAvailable() && n.isConnected() && n.getType() == ConnectivityManager.TYPE_WIFI;
                if (isConnectedWifi) {
                    break networkinfosloop;
                }

            }
        }
        return isConnectedWifi;
    }

    /**
     * Check if there is any connectivity to a mobile network.
     *
     * @param context the Context.
     * @return true if we are connected to a mobile network, false otherwise.
     */
    public static boolean isConnectedMobile(Context context) {
        boolean isConnectedMobile = false;
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            ConnectivityManager connectivityManager = ConnectivityAndInternetAccessCheck.getConnectivityManager(context);
            Network[] allNetworks = connectivityManager.getAllNetworks();
            networksloop: for (Network network: allNetworks) {
                if (network == null) {
                    isConnectedMobile = false;
                } else {
                    NetworkCapabilities networkCapabilities = connectivityManager.getNetworkCapabilities(network);
                    if(networkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)){
                        if (networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)) {
                            isConnectedMobile = true;
                            break networksloop;
                        } else {
                            isConnectedMobile = false;
                        }
                    }
                }

            }

        } else {
            NetworkInfo[] networkInfos = ConnectivityAndInternetAccessCheck.getAllNetworkInfo(context);
            networkinfosloop: for (NetworkInfo networkInfo: networkInfos) {
                isConnectedMobile = networkInfo != null && networkInfo.isAvailable() && networkInfo.isConnected() && networkInfo.getType() == ConnectivityManager.TYPE_MOBILE;
                if (isConnectedMobile) {
                    break networkinfosloop;
                }
            }
        }
        return isConnectedMobile;
    }

    /**
     * Check if there is fast connectivity.
     *
     * @param context the Context.
     * @return true if we have "fast" connectivity, false otherwise.
     */
    public static boolean isConnectedFast(Context context) {
        boolean isConnectedFast = false;
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
            NetworkInfo[] networkInfos = ConnectivityAndInternetAccessCheck.getAllNetworkInfo(context);
            networkInfosloop:
            for (NetworkInfo networkInfo: networkInfos) {
                isConnectedFast = networkInfo != null && networkInfo.isAvailable() && networkInfo.isConnected() && isConnectionFast(networkInfo.getType(), networkInfo.getSubtype());
                if (isConnectedFast) {
                    break networkInfosloop;
                }
            }
        } else {
            throw new UnsupportedOperationException();
        }
        return isConnectedFast;
    }

    /**
     * Check if the connection is fast.
     *
     * @param type the network type.
     * @param subType the network subtype.
     * @return true if the provided type/subtype combination is classified as fast.
     */
    private static boolean isConnectionFast(int type, int subType) {
        if (type == ConnectivityManager.TYPE_WIFI) {
            return true;
        } else if (type == ConnectivityManager.TYPE_MOBILE) {
            switch (subType) {
                case TelephonyManager.NETWORK_TYPE_1xRTT:
                    return false; // ~ 50-100 kbps
                case TelephonyManager.NETWORK_TYPE_CDMA:
                    return false; // ~ 14-64 kbps
                case TelephonyManager.NETWORK_TYPE_EDGE:
                    return false; // ~ 50-100 kbps
                case TelephonyManager.NETWORK_TYPE_EVDO_0:
                    return true; // ~ 400-1000 kbps
                case TelephonyManager.NETWORK_TYPE_EVDO_A:
                    return true; // ~ 600-1400 kbps
                case TelephonyManager.NETWORK_TYPE_GPRS:
                    return false; // ~ 100 kbps
                case TelephonyManager.NETWORK_TYPE_HSDPA:
                    return true; // ~ 2-14 Mbps
                case TelephonyManager.NETWORK_TYPE_HSPA:
                    return true; // ~ 700-1700 kbps
                case TelephonyManager.NETWORK_TYPE_HSUPA:
                    return true; // ~ 1-23 Mbps
                case TelephonyManager.NETWORK_TYPE_UMTS:
                    return true; // ~ 400-7000 kbps
                /*
                 * Above API level 7, make sure to set android:targetSdkVersion
                 * to appropriate level to use these
                 */
                case TelephonyManager.NETWORK_TYPE_EHRPD: // API level 11
                    return true; // ~ 1-2 Mbps
                case TelephonyManager.NETWORK_TYPE_EVDO_B: // API level 9
                    return true; // ~ 5 Mbps
                case TelephonyManager.NETWORK_TYPE_HSPAP: // API level 13
                    return true; // ~ 10-20 Mbps
                case TelephonyManager.NETWORK_TYPE_IDEN: // API level 8
                    return false; // ~25 kbps
                case TelephonyManager.NETWORK_TYPE_LTE: // API level 11
                    return true; // ~ 10+ Mbps
                // Unknown
                case TelephonyManager.NETWORK_TYPE_UNKNOWN:
                default:
                    return false;
            }
        } else {
            return false;
        }
    }

    public ArrayList < String > getHosts() {
        return hosts;
    }

    public void setHosts(ArrayList < String > hosts) {
        this.hosts = hosts;
    }
    //TODO Debug on devices
    /**
     * Checks that Internet is available by pinging DNS servers.
     */
    private static class InternetConnectionCheckAsync extends AsyncTask < Void, Void, Boolean > {

        private Context context;

        /**
         * Creates an instance of this class
         * @param context The context
         */
        public InternetConnectionCheckAsync(Context context) {
            this.setContext(context);
        }

        /**
         * Cancels the activity if the device is not connected to a network.
         */
        @Override
        protected void onPreExecute() {
            if (!ConnectivityAndInternetAccessCheck.isConnected(getContext())) {
                cancel(true);
            }
        }

        /**
         * Tells whether there is Internet access
         * @param voids The list of arguments
         * @return True if Internet can be accessed
         */
        @Override
        protected Boolean doInBackground(Void...voids) {
            return isConnectedToInternet(getContext());
        }

        @Override
        protected void onPostExecute(Boolean aBoolean) {
            super.onPostExecute(aBoolean);
        }

        /**
         * The context
         */
        public Context getContext() {
            return context;
        }

        public void setContext(Context context) {
            this.context = context;
        }
    } //network calls shouldn't be called from main thread otherwise it will throw //NetworkOnMainThreadException

    /**
     * Tells whether Internet is reachable
     * @return true if Internet is reachable, false otherwise
     * @param context The context
     */
    public static boolean isInternetReachable(Context context) {
        try {
            return new InternetConnectionCheckAsync(context).execute().get();
        } catch (CancellationException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    /**
     * Tells whether there is Internet connection
     * @param context The context
     * @return @code {true} if there is Internet connection
     */
    private static boolean isConnectedToInternet(Context context) {
        boolean isAvailable = false;
        if (!ConnectivityAndInternetAccessCheck.isConnected(context)) {
            isAvailable = false;
        } else {
            try {
                foreachloop: for (String h: new ConnectivityAndInternetAccessCheck().getHosts()) {
                    if (isHostAvailable(h)) {
                        isAvailable = true;
                        break foreachloop;
                    }
                }
            }
            catch (IOException e) {
                e.printStackTrace();
            }
        }

        return isAvailable;

    }

    /**
     * Checks if the host is available
     * @param hostName
     * @return
     * @throws IOException
     */
    private static boolean isHostAvailable(String hostName) throws IOException {
        try (Socket socket = new Socket()) {
            int port = 80;
            InetSocketAddress socketAddress = new InetSocketAddress(hostName, port);
            socket.connect(socketAddress, 3000);

            return true;
        } catch (UnknownHostException unknownHost) {
            return false;
        }
    }
}
— রডরিগো
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.