介紹：
通過 extends Service 創(chuàng)建自定義的服務(wù)。
通過 oncreate 中init 實例化參數(shù)。
首先檢測網(wǎng)絡(luò)是否連接，通過 wifi和有線連接兩種檢測。
檢測到有網(wǎng)絡(luò)，不管哪種，然后開始 ping 服務(wù)器或IP。

implements Runnable 中實現(xiàn)調(diào)用ping的方法，
Thread 來開始Runnable 運行。
Runnable 中通過無限循環(huán)實現(xiàn)連續(xù)ping，通過檢測變量resOK，來停止runtime。

ping 過程中，連續(xù)記錄ping 10次，
獲取到的類似結(jié)構(gòu)字符，
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();
        }
    }
}

}