Android - Passing changing data from BroadcastReceiver to another Object?

I have a Wifi class that has a couple of broadcast receivers that listen out for changes in Wifi connection state, Wifi Rssi levels etc...

I want to be able to pass this data to another "Engine" Object and still keep the data changing dynamically.

I currently create a Wifi object within the "Engine" class and run its methods, the data is then dynamically displayed fine in Log statements in the log cat.

My problem is trying to get the dynamically changing data to the Engine, when I try to get data over it gets the first value and leaves it at that without ever updating.

So I was wondering what my options are on how to do this?

Below is my current code setup if that is any help:

Wifi Class

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());
     开发者_StackOverflow                       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;

And my Engine Code:

public Engine(Context aContext){

        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);
    }
}

So I'm just wondering what would be the best solution to make sure the data from the Wifi class is constantly updated in the engine when it receives changes from the broadcast receiver?

---

depends if your class, the one that should be notified of the latest state. If it's a class that is not created in an Activity and is static (singletone or Application based) then you should probably have the Reciver update the singletone class.

If it's Activity based, you need stick Broadcasts, and once the broadcast is recieved remove the sticky broadcast.