代码之家  ›  专栏  ›  技术社区  ›  Donal Rafferty

Android-将更改的数据从BroadcastReceiver传递到另一个对象?

  •  0
  • Donal Rafferty  · 技术社区  · 15 年前

    我有一个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类的数据会不断更新?

    提前谢谢

    1 回复  |  直到 14 年前
        1
  •  0
  •   codeScriber    14 年前

    取决于你的班级,应该被通知最新状态的班级。 如果它不是在活动中创建的类,并且是静态的(单音或基于应用程序),那么您应该让接收者更新单音类。

    如果它是基于活动的,那么您需要粘贴广播,一旦接收到广播,就删除粘性广播。