问连续检查Android网络
EN

Stack Overflow用户

提问于 2013-11-13 21:50:58

回答 2查看 3.3K关注 0票数 0

我想用这种方式不断地验证Android系统的网络，但是我认为这种形式是不正确的，如果wifi或其他网络上的连接可用，我的服务应该更新。

public class ObjService extends Service{

    private final static int NOTIFICATION=1;
    public static boolean process;
    private NotificationManager state;
    private NotificationCompat.Builder objBuilder;

    public void onCreate(){
     process=true;
    state=(NotificationManager)getSystemService(NOTIFICATION_SERVICE);    
    objBuilder = new NotificationCompat.Builder(this)
            .setContentTitle("Title")
            .setLargeIcon(BitmapFactory.decodeResource(getResources(), R.drawable.launchimg))
            .setSmallIcon(R.drawable.notification_img);



  Thread checker=new Thread(){//1
    public void run(){//2
    while (process){//3
    if (verifyConnection()){//4
      updateNotificationService("Service is available");
    }else{
     updateNotificationService("Service is not available");
    }//4
     try{
       Thread.sleep(6000);
     }catch(InterruptedException e){
      //..printLog..
     }
    }//3
   };//2

};//1
checker.start();
.
.
.

我的函数verifyConnection()是：

public boolean verifyConnection() {

        boolean flag = true;

      ConnectivityManager connec = (ConnectivityManager)this.getSystemService(Context.CONNECTIVITY_SERVICE);

       NetworkInfo[] net = connec.getAllNetworkInfo();

       if (!net[0].isAvailable() && !net[1].isAvailable())
       {
           flag = false;

       }
       return flag;  

    }

updateNotificationService()是：

public void updateNotificacionService(String arg){

objBuilder.setContentText(arg)
.setWhen(System.currentTimeMillis());

state.notify(NOTIFICATION, objBuilder.build());
}

android

networking

回答 2

Stack Overflow用户

回答已采纳

发布于 2013-11-13 22:30:32

尝试下面的代码来侦听连接是否存在，如果连接状态发生变化，则通知更改，

public class NetworkStateReceiver extends BroadcastReceiver {
public void onReceive(Context context, Intent intent) {
 super.onReceive(context, intent);
 Log.d("app","Network connectivity change");
 if(intent.getExtras()!=null) {
    NetworkInfo ni=(NetworkInfo) intent.getExtras().get(ConnectivityManager.EXTRA_NETWORK_INFO);
    if(ni!=null && ni.getState()==NetworkInfo.State.CONNECTED) {
        Log.i("app","Network "+ni.getTypeName()+" connected");
    }
 }
 if(intent.getExtras().getBoolean(ConnectivityManager.EXTRA_NO_CONNECTIVITY,Boolean.FALSE)) {
        Log.d("app","There's no network connectivity");
 }
}
}

然后作为清单，

<receiver android:name=".NetworkStateReceiver">
   <intent-filter>
      <action android:name="android.net.conn.CONNECTIVITY_CHANGE" />
   </intent-filter>
</receiver>
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

参考资料：Internet侦听器Android示例

票数 4

Stack Overflow用户

发布于 2020-03-12 09:55:21

Android7.0(APILevel24)对广播设置了限制，如背景优化中所述。Android8.0(APILevel26)使这些限制更加严格。应用程序可以在运行时使用Context.registerReceiver()注册任何广播的接收器，无论是隐式广播还是显式广播。

文档参考文献。

因此，下面是一个实用工具类，它利用上下文注册的BroadcastReceiver和LifeCycleObserver来实现单一责任原则

class ConnectionUtil implements LifecycleObserver {

    private ConnectivityManager mConnectivityMgr;
    private Context mContext;
    private NetworkStateReceiver mNetworkStateReceiver;

    interface ConnectionStateListener {
        void onAvailable(boolean isAvailable);
    }

    ConnectionUtil(Context context) {
        mContext = context;
        mConnectivityMgr = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        ((AppCompatActivity) mContext).getLifecycle().addObserver(this);
    }


    void onInternetStateListener(ConnectionStateListener listener) {
        mNetworkStateReceiver = new NetworkStateReceiver(listener);
        IntentFilter intentFilter = new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION);
        // Registering the Context Registered Receiver
        mContext.registerReceiver(mNetworkStateReceiver, intentFilter);
    }


    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    public void onDestroy() {

        // Removing lifecycler owner observer
        ((AppCompatActivity) mContext).getLifecycle().removeObserver(this);

        // Unregistering the Context Registered Receiver
        if (mNetworkStateReceiver != null)
            mContext.unregisterReceiver(mNetworkStateReceiver);

    }


    public class NetworkStateReceiver extends BroadcastReceiver {

        ConnectionStateListener mListener;

        public NetworkStateReceiver(ConnectionStateListener listener) {
            mListener = listener;
        }

        @Override
        public void onReceive(Context context, Intent intent) {
            if (intent.getExtras() != null) {
                NetworkInfo activeNetworkInfo = mConnectivityMgr.getActiveNetworkInfo();

                if (activeNetworkInfo != null && activeNetworkInfo.getState() == NetworkInfo.State.CONNECTED) {
                    // Connected to the internet
                    mListener.onAvailable(true);

                } else if (intent.getBooleanExtra(ConnectivityManager.EXTRA_NO_CONNECTIVITY, Boolean.FALSE)) {
                    // Not connected to the internet
                    mListener.onAvailable(false);
                }
            }
        }
    }

}

宣言许可

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

使用：

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        ConnectionUtil mConnectionMonitor = new ConnectionUtil(this);
        mConnectionMonitor.onInternetStateListener(new ConnectionUtil.ConnectionStateListener() {
            @Override
            public void onAvailable(boolean isAvailable) {
                if(isAvailable)
                    Toast.makeText(MainActivity.this, "Connected", Toast.LENGTH_SHORT).show();
                else
                    Toast.makeText(MainActivity.this, "Disconnected", Toast.LENGTH_SHORT).show();
            }
        });
    }
}

注意:从API 29开始就不再推荐NetworkInfo了，您可以使用ConnectivityManager.NetworkCallback及其onAvailable() & onLost()回调来实现相同的目的，而不是使用BroadcastReceiver。这个答案可以指导实现这一目的。