我有一个wifi类,有几个广播接收器,可以监听wifi连接状态、wifi rssi级别等的变化…
  
  
   我希望能够将这些数据传递给另一个“引擎”对象,并且仍然保持数据的动态变化。
  
  
   我目前在“引擎”类中创建了一个wifi对象并运行它的方法,然后在日志cat的日志语句中动态地显示数据。
  
  
   我的问题是试图将动态变化的数据传递给引擎,当我试图通过它获取数据时,它会得到第一个值,并在不进行更新的情况下保留它。
  
  
   所以我想知道我的选择是关于如何做到这一点?
  
  
   以下是我当前的代码设置(如果有帮助的话):
  
  
   WiFi类
  
  public Wifi(Context context){
    mainWifi = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
}
public int getCurrentWifiState() {
    return currentWifiState;
}
public void setCurrentWifiState(int currentWifiState) {
    this.currentWifiState = currentWifiState;
}
public String getConnectedSSID() {
    return connectedSSID;
}
public void setConnectedSSID(String connectedSSID) {
    this.connectedSSID = connectedSSID;
}
public int getConnectedLevel() {
    return connectedLevel;
}
public void setConnectedLevel(int connectedLevel) {
    this.connectedLevel = connectedLevel;
}
//method to do a scan and receive info about all access points available
public List<ScanResult> scan(final Context context){
               receiverWifi = new WifiReceiver();
               mainWifi = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
               context.registerReceiver(receiverWifi, new IntentFilter(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION));
               mainWifi.startScan();
               Log.d("WIFI DEBUG","\nStarting Scan...\n"); 
               wifiList = mainWifi.getScanResults();
    return wifiList; 
}
 class WifiReceiver extends BroadcastReceiver {
     public void onReceive(Context c, Intent intent) {
          sb = new StringBuilder();
          wifiList = mainWifi.getScanResults();
          ListIterator<ScanResult> results = wifiList.listIterator();
          while (results.hasNext()) {
              ScanResult info = results.next();
              String wifiInfo = "Name: " + info.SSID + "; capabilities = " + info.capabilities + "; sig str = " + info.level + "dBm";
              Log.v("WiFi", wifiInfo);
              Log.d("Signal Level", "Signal Level : " + mainWifi.calculateSignalLevel(info.level, 5));
          }
     }
 }
 //method to listen for changes in the level of the wifi connection
 public void initializeWiFiListener(Context context){
        Log.d("WIFI", "executing initializeWiFiListener");
        String connectivity_context = Context.WIFI_SERVICE;
        final WifiManager wifi = (WifiManager)context.getSystemService(connectivity_context);
        if(!wifi.isWifiEnabled()){
                if(wifi.getWifiState() != WifiManager.WIFI_STATE_ENABLING){
                        //wifi.setWifiEnabled(true);
                }
        }
        rssiListener = new BroadcastReceiver(){
                @Override
                public void onReceive(Context context, Intent intent) {
                        String action = intent.getAction();
                        if(WifiManager.RSSI_CHANGED_ACTION.equals(action)){
                            WifiInfo data = mainWifi.getConnectionInfo();
                            Log.d("WIFI", "RSSI has changed");
                            if(mainWifi.getConnectionInfo()!=null){
                            setConnectedSSID(data.getSSID());
                            setConnectedLevel(data.getRssi());
                            Log.d("WIFI", "new RSSI = " + data.getSSID()+ " " + data.getRssi() + "dBm");
                            }
                        }      
                }
        };
        //leak here - need to de reg receiver
        context.registerReceiver(rssiListener, new IntentFilter(WifiManager.RSSI_CHANGED_ACTION));
}
 //method to listen for changes in the connection to a wifi access point
 public void changeWiFiListener(Context context){
        Log.d("WIFI", "executing initializeWiFiListener");
        String connectivity_context = Context.WIFI_SERVICE;
        final WifiManager wifi = (WifiManager)context.getSystemService(connectivity_context);
        if(!wifi.isWifiEnabled()){
                if(wifi.getWifiState() != WifiManager.WIFI_STATE_ENABLING){
                        //wifi.setWifiEnabled(true);
                }
        }
        wifiChangeListener = new BroadcastReceiver(){
                @Override
                public void onReceive(Context context, Intent intent) {
                        String action = intent.getAction();
                        if(WifiManager.WIFI_STATE_CHANGED_ACTION.equals(action)){
                            Log.d("WIFI", "WIFI has changed");
                            int wifiState = intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE, -1);
                            Log.d("WIFI", "WIFI State = " + wifiState);
                            setCurrentWifiState(wifiState);
                        }  
                }
        };
        //Leak here - not unregistering receiver
        context.registerReceiver(wifiChangeListener, new IntentFilter(WifiManager.WIFI_STATE_CHANGED_ACTION));
}
public WifiReceiver getReceiverWifi() {
    return receiverWifi;
}
public void setReceiverWifi(WifiReceiver receiverWifi) {
    this.receiverWifi = receiverWifi;
  
   我的发动机代码:
  
  
   公共引擎(上下文上下文上下文){
  
      context = aContext;
    cm = new CallManager(aContext);
    wifiManager = new Wifi(context);
    wifiManager.initializeWiFiListener(context);
    wifiManager.changeWiFiListener(context);    
    clc = new CallLogController();
}
public void controlCalls(){
    int currentWifiState = wifiManager.getCurrentWifiState();
    cm.monitorOutgoingCalls(context, currentWifiState, clc);
}
public void unRegAllRecievers(){
    wifiManager.unregRegisters(context);
    cm.unRegReciever(context);
}
public void doWifiScan(){
    scanTask = new TimerTask() {
        public void run() {
                handler.post(new Runnable() {
                        public void run() {
                            wifiManager.scan(context); 
                            Log.d("TIMER", "Timer set off");
                        }
               });
        }};
    t.schedule(scanTask, 300, 30000); 
}
public void stopScan(){ 
        scanTask.cancel();
        t.cancel();
        //boolean tf = scanTask.cancel();
        //Log.d("TIMER", "Timer True or False? : " + tf);
}
  
   }
  
  
   所以我想知道什么是最好的解决方案,以确保当引擎接收到来自广播接收器的更改时,来自wifi类的数据会不断更新?
  
  
   提前谢谢