Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit bcb5373c authored by Sundeep Ghuman's avatar Sundeep Ghuman
Browse files

Delete the WorkHandler class. 

All work is still performed on the given workThread, just without the
need for a custom Handler class.

Bug: 68030053
Test: runtest --path
    frameworks/base/packages/SettingsLib/tests/integ/src/com/android/settingslib/wifi/WifiTrackerTest.java

Change-Id: Id4509821e51a1a8e1b171710b33b83212f2a506a
parent cf114b60

packages/SettingsLib/src/com/android/settingslib/wifi/WifiTracker.java

+61 −104
Original line number Diff line number Diff line
@@ -113,7 +113,7 @@ public class WifiTracker implements LifecycleObserver, OnStart, OnStop, OnDestro 
    private final NetworkRequest mNetworkRequest;

    private final AtomicBoolean mConnected = new AtomicBoolean(false);

    private final WifiListener mListener;

    @VisibleForTesting WorkHandler mWorkHandler;

    @VisibleForTesting Handler mWorkHandler;

    private HandlerThread mWorkThread;



    private WifiTrackerNetworkCallback mNetworkCallback;
@@ -236,7 +236,7 @@ public class WifiTracker implements LifecycleObserver, OnStart, OnStop, OnDestro 
    // during construction

    void setWorkThread(HandlerThread workThread) {

        mWorkThread = workThread;

        mWorkHandler = new WorkHandler(workThread.getLooper());

        mWorkHandler = new Handler(workThread.getLooper());

        mScoreCache = new WifiNetworkScoreCache(mContext, new CacheListener(mWorkHandler) {

            @Override

            public void networkCacheUpdated(List<ScoredNetwork> networks) {
@@ -261,7 +261,6 @@ public class WifiTracker implements LifecycleObserver, OnStart, OnStop, OnDestro 
    @MainThread

    public void forceUpdate() {

        synchronized (mLock) {

            mWorkHandler.removeMessages(WorkHandler.MSG_UPDATE_ACCESS_POINTS);

            mLastInfo = mWifiManager.getConnectionInfo();

            mLastNetworkInfo = mConnectivityManager.getNetworkInfo(mWifiManager.getCurrentNetwork());
@@ -301,7 +300,6 @@ public class WifiTracker implements LifecycleObserver, OnStart, OnStop, OnDestro 
            mScanner = new Scanner();

        }



        mWorkHandler.sendEmptyMessage(WorkHandler.MSG_RESUME);

        if (mWifiManager.isWifiEnabled()) {

            mScanner.resume();

        }
@@ -332,7 +330,7 @@ public class WifiTracker implements LifecycleObserver, OnStart, OnStop, OnDestro 


            resumeScanning();

            if (!mRegistered) {

                mContext.registerReceiver(mReceiver, mFilter);

                mContext.registerReceiver(mReceiver, mFilter, null /* permission */, mWorkHandler);

                // NetworkCallback objects cannot be reused. http://b/20701525 .

                mNetworkCallback = new WifiTrackerNetworkCallback();

                mConnectivityManager.registerNetworkCallback(mNetworkRequest, mNetworkCallback);
@@ -382,7 +380,7 @@ public class WifiTracker implements LifecycleObserver, OnStart, OnStop, OnDestro 
            unregisterScoreCache();

            pauseScanning(); // and set mStaleScanResults



            mWorkHandler.removePendingMessages();

            mWorkHandler.removeCallbacksAndMessages(null /* remove all */);

        }

    }
@@ -752,96 +750,47 @@ public class WifiTracker implements LifecycleObserver, OnStart, OnStop, OnDestro 
        }

    }



    /**

     *  Receiver for handling broadcasts.

     *

     *  This receiver is registered on the WorkHandler.

     */

    @VisibleForTesting

    final BroadcastReceiver mReceiver = new BroadcastReceiver() {

        @Override

        public void onReceive(Context context, Intent intent) {

            // No work should be performed in this Receiver, instead all operations should be passed

            // off to the WorkHandler to avoid concurrent modification exceptions.



            String action = intent.getAction();



            // TODO(sghuman): Improve efficiency of synchronization by synchonizing on individual

            // methods and only use lock when iterating/modifying collections

            synchronized (mLock) {

                if (WifiManager.WIFI_STATE_CHANGED_ACTION.equals(action)) {

                mWorkHandler.obtainMessage(

                        WorkHandler.MSG_UPDATE_WIFI_STATE,

                    updateWifiState(

                            intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE,

                            WifiManager.WIFI_STATE_UNKNOWN),

                        0).sendToTarget();

                                    WifiManager.WIFI_STATE_UNKNOWN));

                } else if (WifiManager.SCAN_RESULTS_AVAILABLE_ACTION.equals(action)) {

                mWorkHandler

                        .obtainMessage(

                            WorkHandler.MSG_UPDATE_ACCESS_POINTS,

                            WorkHandler.CLEAR_STALE_SCAN_RESULTS,

                            0)

                        .sendToTarget();

                    mStaleScanResults = false;



                    updateAccessPoints();

                } else if (WifiManager.CONFIGURED_NETWORKS_CHANGED_ACTION.equals(action)

                        || WifiManager.LINK_CONFIGURATION_CHANGED_ACTION.equals(action)) {

                mWorkHandler.sendEmptyMessage(WorkHandler.MSG_UPDATE_ACCESS_POINTS);

                    updateAccessPoints();

                } else if (WifiManager.NETWORK_STATE_CHANGED_ACTION.equals(action)) {

                    NetworkInfo info = intent.getParcelableExtra(WifiManager.EXTRA_NETWORK_INFO);

                mWorkHandler.obtainMessage(WorkHandler.MSG_UPDATE_NETWORK_INFO, info)

                        .sendToTarget();

                mWorkHandler.sendEmptyMessage(WorkHandler.MSG_UPDATE_ACCESS_POINTS);

                    updateNetworkInfo(info);

                    updateAccessPoints();

                } else if (WifiManager.RSSI_CHANGED_ACTION.equals(action)) {

                    NetworkInfo info =

                            mConnectivityManager.getNetworkInfo(mWifiManager.getCurrentNetwork());

                mWorkHandler.obtainMessage(WorkHandler.MSG_UPDATE_NETWORK_INFO, info)

                        .sendToTarget();

            }

        }

    };



    private final class WifiTrackerNetworkCallback extends ConnectivityManager.NetworkCallback {

        public void onCapabilitiesChanged(Network network, NetworkCapabilities nc) {

            if (network.equals(mWifiManager.getCurrentNetwork())) {

                // We don't send a NetworkInfo object along with this message, because even if we

                // fetch one from ConnectivityManager, it might be older than the most recent

                // NetworkInfo message we got via a WIFI_STATE_CHANGED broadcast.

                mWorkHandler.sendEmptyMessage(WorkHandler.MSG_UPDATE_NETWORK_INFO);

            }

        }

    }



    @VisibleForTesting

    final class WorkHandler extends Handler {

        @VisibleForTesting static final int MSG_UPDATE_ACCESS_POINTS = 0;

        private static final int MSG_UPDATE_NETWORK_INFO = 1;

        private static final int MSG_RESUME = 2;

        private static final int MSG_UPDATE_WIFI_STATE = 3;



        private static final int CLEAR_STALE_SCAN_RESULTS = 1;



        public WorkHandler(Looper looper) {

            super(looper);

                    updateNetworkInfo(info);

                }



        @Override

        public void handleMessage(Message msg) {

            // TODO(sghuman): Clean up synchronization to only be used when modifying collections

            // exposed to the MainThread (through onStart, onStop, forceUpdate).

            synchronized (mLock) {

                processMessage(msg);

            }

        }

    };



        private void processMessage(Message msg) {

            if (!mRegistered) return;



            switch (msg.what) {

                case MSG_UPDATE_ACCESS_POINTS:

                    if (msg.arg1 == CLEAR_STALE_SCAN_RESULTS) {

                        mStaleScanResults = false;

                    }

                    updateAccessPoints();

                    break;

                case MSG_UPDATE_NETWORK_INFO:

                    updateNetworkInfo((NetworkInfo) msg.obj);

                    break;

                case MSG_RESUME:

                    handleResume();

                    break;

                case MSG_UPDATE_WIFI_STATE:

                    if (msg.arg1 == WifiManager.WIFI_STATE_ENABLED) {

    /** Handles updates to WifiState. */

    private void updateWifiState(int state) {

        if (state == WifiManager.WIFI_STATE_ENABLED) {

            if (mScanner != null) {

                // We only need to resume if mScanner isn't null because

                // that means we want to be scanning.
@@ -858,16 +807,24 @@ public class WifiTracker implements LifecycleObserver, OnStart, OnStop, OnDestro 
                mStaleScanResults = true;

            }

        }

                    mListener.onWifiStateChanged(msg.arg1);

                    break;

            }

        mListener.onWifiStateChanged(state);

    }



        private void removePendingMessages() {

            removeMessages(MSG_UPDATE_ACCESS_POINTS);

            removeMessages(MSG_UPDATE_NETWORK_INFO);

            removeMessages(MSG_RESUME);

            removeMessages(MSG_UPDATE_WIFI_STATE);

    private final class WifiTrackerNetworkCallback extends ConnectivityManager.NetworkCallback {

        public void onCapabilitiesChanged(Network network, NetworkCapabilities nc) {

            if (network.equals(mWifiManager.getCurrentNetwork())) {

                // TODO(sghuman): Investigate whether this comment still holds true and if it makes

                // more sense fetch the latest network info here:



                // We don't send a NetworkInfo object along with this message, because even if we

                // fetch one from ConnectivityManager, it might be older than the most recent

                // NetworkInfo message we got via a WIFI_STATE_CHANGED broadcast.

                mWorkHandler.post(() -> {

                    synchronized (mLock) {

                        updateNetworkInfo(null);

                    }

                });

            }

        }

    }

packages/SettingsLib/tests/integ/src/com/android/settingslib/wifi/WifiTrackerTest.java

+10 −10
Original line number Diff line number Diff line
@@ -26,10 +26,8 @@ import static org.mockito.Mockito.anyInt; 
import static org.mockito.Mockito.atMost;

import static org.mockito.Mockito.doAnswer;

import static org.mockito.Mockito.doNothing;

import static org.mockito.Mockito.doThrow;

import static org.mockito.Mockito.mock;

import static org.mockito.Mockito.never;

import static org.mockito.Mockito.reset;

import static org.mockito.Mockito.times;

import static org.mockito.Mockito.verify;

import static org.mockito.Mockito.verifyNoMoreInteractions;
@@ -76,12 +74,11 @@ import org.mockito.stubbing.Answer; 


import java.util.ArrayList;

import java.util.Arrays;

import java.util.BitSet;

import java.util.Collections;

import java.util.List;

import java.util.Map;

import java.util.concurrent.CountDownLatch;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.atomic.AtomicBoolean;

import java.util.concurrent.atomic.AtomicInteger;



// TODO(sghuman): Change these to robolectric tests b/35766684.
@@ -725,7 +722,7 @@ public class WifiTrackerTest { 
    }



    @Test

    public void stopTrackingShouldRemoveWifiListenerCallbacks() throws Exception {

    public void stopTrackingShouldRemoveAllPendingWork() throws Exception {

        WifiTracker tracker = createMockedWifiTracker();

        startTracking(tracker);
@@ -743,13 +740,16 @@ public class WifiTrackerTest { 
        });



        // Enqueue messages

        tracker.mWorkHandler.sendEmptyMessage(WifiTracker.WorkHandler.MSG_UPDATE_ACCESS_POINTS);

        final AtomicBoolean executed = new AtomicBoolean(false);

        tracker.mWorkHandler.post(() -> executed.set(true));



        try {

            ready.await(); // Make sure we have entered the first message handler

        } catch (InterruptedException e) {}

        tracker.onStop();



        // TODO(sghuman): Delete these in a following CL, no longer necessary (should be

        // invoked 0 times)

        verify(mockWifiListener, atMost(1)).onAccessPointsChanged();

        verify(mockWifiListener, atMost(1)).onConnectedChanged();

        verify(mockWifiListener, atMost(1)).onWifiStateChanged(anyInt());
@@ -757,11 +757,11 @@ public class WifiTrackerTest { 
        lock.countDown();

        assertTrue("Latch timed out", latch.await(LATCH_TIMEOUT, TimeUnit.MILLISECONDS));



        assertThat(tracker.mWorkHandler.hasMessages(

                WifiTracker.WorkHandler.MSG_UPDATE_ACCESS_POINTS)).isFalse();

        assertThat(tracker.mWorkHandler.hasMessagesOrCallbacks()).isFalse();

        // In case the method was already executing

        waitForHandlersToProcessCurrentlyEnqueuedMessages(tracker);



        verifyNoMoreInteractions(mockWifiListener);

        assertThat(executed.get()).isFalse();

    }



    @Test