记录:Service中 检测网络连接和 ping 网络测试

介绍：
通过 extends Service 创建自定义的服务。
通过 oncreate 中init 实例化参数。
首先检测网络是否连接，通过 wifi和有线连接两种检测。
检测到有网络，不管哪种，然后开始 ping 服务器或IP。

implements Runnable 中实现调用ping的方法，
Thread 来开始Runnable 运行。
Runnable 中通过无限循环实现连续ping，通过检测变量resOK，来停止runtime。

ping 过程中，连续记录ping 10次，
获取到的类似结构字符，
64 bytes from 14.215.177.38: icmp_seq=3 ttl=56 time=7.72 ms
检测该样式的字符判断成功与否。

package com.androidtest;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

import android.app.Service;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.net.wifi.WifiManager;
import android.os.AsyncTask;
import android.os.Handler;
import android.os.Message;
import android.os.HandlerThread;
import android.os.IBinder;
import android.os.SystemClock;
import android.provider.Settings;
import android.util.Log;
 
import java.io.BufferedWriter;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.File; 
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class MyService extends Service {
  private static final String TAG = "MyService";
  private boolean flashdebug =true;
  private HandlerThread requestTimeThread;
  private Handler mHandler;
  private boolean register = false;

  private ConnectivityManager mConnectivityManager;

  private final int No_Ethernet=0;
  private final int No_Wifinet=1;
  private final int Network_Changed=2;
  private final int Flashing=3;
  private final int StopFlash=4;

  private boolean resOK = false;
  private int test_OK = 1;
  private int test_ERROE = 0;
  private Context mContext;
  private ServiceRunnableProcess serProcess;
  private Thread thProcess;

@Override
public void onCreate() {
    super.onCreate();
    Log.d(TAG,"MyService--onCreate()");
    if ( requestTimeThread == null ) {
        init();
    }
}

@Override
public void onDestroy() {
    Log.d(TAG,"MyService--onDestroy()");
    super.onDestroy();
}

@Override
public IBinder onBind(Intent intent) {
    // TODO: Return the communication channel to the service.
    Log.d(TAG,"MyService--onBind()");
    throw new UnsupportedOperationException("Not yet implemented");
}

@Override
public int onStartCommand(Intent intent, int flags, int startId) {
    Log.d(TAG,"MyService--onStartCommand()");
    return super.onStartCommand(intent, flags, startId);
}

private void init() {
    mContext = MyService.this;
    mConnectivityManager = (ConnectivityManager) this.getSystemService(Context.CONNECTIVITY_SERVICE);
    requestTimeThread = new HandlerThread("MyService");
    requestTimeThread.start();
    mHandler = new Handler(requestTimeThread.getLooper());
    serProcess = new ServiceRunnableProcess();


    IntentFilter filter = new IntentFilter();
    filter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
    filter.addAction(ConnectivityManager.ACTION_TETHER_STATE_CHANGED);
    filter.addAction(WifiManager.RSSI_CHANGED_ACTION);
    filter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION);
    filter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);
    //filter.addAction(Intent.ACTION_BOOT_COMPLETED);
    this.registerReceiver(mReceiver, filter);

    if(!getWifiState() && !getEthernetState()){
        mHandler.removeCallbacks(mSyncRunnable);
        mHandler.post(mSyncRunnable);
    }else{
        mHandler.removeCallbacks(mSyncRunnable);
    }

}

private BroadcastReceiver mReceiver = new BroadcastReceiver() {
    @Override
    public void onReceive(Context context, Intent intent) {
        String action = intent.getAction();
        Log.d(TAG,"LedService--onReceive="+action);
        if(intent.getAction().equals(ConnectivityManager.CONNECTIVITY_ACTION)
        || intent.getAction().equals(WifiManager.WIFI_STATE_CHANGED_ACTION)) {
            msgHandler.removeMessages(Network_Changed);
            msgHandler.sendEmptyMessageDelayed(Network_Changed,2000);
        }
    }
};

Handler msgHandler = new Handler() {
    @Override
    public void handleMessage(Message msg) {
        super.handleMessage(msg);
        int what = msg.what;
        if(what == Network_Changed){
            msgHandler.removeMessages(Network_Changed);
            if(!getEthernetState() && !getWifiState()){
                msgHandler.sendEmptyMessage(Flashing);
            }else{
                Log.d(TAG,"need ping service");
                resOK = false;
                if(thProcess==null){
                    thProcess = new Thread(serProcess);
                    thProcess.start();
                }
            }
        }
        if(what == StopFlash){
            Log.e(TAG, "StopFlash" );
            if(thProcess !=null) {
                thProcess.interrupt();
                thProcess=null;
                Log.e(TAG, "stop thProcess" );
            }
            mHandler.removeCallbacks(mSyncRunnable);
        }
        if(what == Flashing){
            Log.e(TAG, "Flashing" );
            if(!mHandler.hasCallbacks(mSyncRunnable)){
                mHandler.post(mSyncRunnable);
            }
        }

    }
};

private Runnable mSyncRunnable = new Runnable(){
    @Override
    public void run() {
        //xxxxxx
        Log.e(TAG, "mSyncRunnable do something" );
        mHandler.postDelayed(this,800);
    }
};

private boolean getWifiState(){
    NetworkInfo mWiFiNetworkInfo = mConnectivityManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
    if (mWiFiNetworkInfo != null && mWiFiNetworkInfo.isConnected()) {
        if(flashdebug)Log.d(TAG,"wifi Connected");
        return mWiFiNetworkInfo.isAvailable();
    }else{
        if(flashdebug)Log.d(TAG,"wifi Not Connected");
        return false;
    }
}

private boolean getEthernetState(){
    NetworkInfo mNetworkInfo = mConnectivityManager.getNetworkInfo(ConnectivityManager.TYPE_ETHERNET);
    if (mNetworkInfo != null && mNetworkInfo.isConnected()) {
        if(flashdebug)Log.d(TAG,"Ethernet Connected");
        return mNetworkInfo.isAvailable();
    }else{
        if(flashdebug)Log.d(TAG,"Ethernet not Connected");
        return false;
    }
}

class ServiceRunnableProcess implements Runnable{
    @Override
    public void run() {
        Log.e(TAG, "ServiceRunnableProcess resOK:"+resOK);
        while (!resOK) {
            pingCustomerServer();
        }
    }
}

private void pingCustomerServer(){
    String line = null;
    BufferedReader buf = null;
    Process pro = null;
    Runtime runtime = null;
    int count=0;

    Log.e(TAG, "pingCustomerServer resOK:"+resOK);
    try {
        runtime = Runtime.getRuntime();
        pro = runtime.exec("ping www.baidu.com");
        buf = new BufferedReader(new InputStreamReader(pro.getInputStream()));
        while ((line = buf.readLine()) != null) {
            if (flashdebug) Log.e(TAG, "count="+ count +" line=" + line);

            if(count >=10){
                if(line.contains("icmp_seq=") && line.contains("ttl=")){
                    Log.e(TAG, "find string runtime stop" );
                    msgHandler.sendEmptyMessage(StopFlash);
                    resOK = true;
                    break;
                }else{
                    msgHandler.sendEmptyMessage(Flashing);
                    resOK = false;
                    break;
                }
            }
            count ++ ;
        }
        if(((line = buf.readLine()) == null)){
            Log.e(TAG, "unable to connect" );
            resOK = false;
            msgHandler.sendEmptyMessage(Flashing);
        }
    }catch (Exception e){
        Log.d(TAG,"find error:"+e.toString());
        resOK = false;
    }finally {
        try {
            buf.close();
            pro.destroy();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

}