Merge "Replace WifiChannelHelper with ChannelHelper implementations" into mm-wireless-dev

7 files changed, 129 insertions, 290 deletions

diff --git a/service/java/com/android/server/wifi/HalWifiScannerImpl.java b/service/java/com/android/server/wifi/HalWifiScannerImpl.java
index b10f5faa6..b892f2d54 100644
--- a/service/java/com/android/server/wifi/HalWifiScannerImpl.java
+++ b/service/java/com/android/server/wifi/HalWifiScannerImpl.java
@@ -23,10 +23,12 @@ import android.os.Looper;
 import android.os.Message;
 import android.util.Log;
 
-import com.android.server.wifi.WifiNative;
+import com.android.server.wifi.scanner.ChannelHelper;
+import com.android.server.wifi.scanner.ChannelHelper.ChannelCollection;
+import com.android.server.wifi.scanner.KnownBandsChannelHelper;
+import com.android.server.wifi.scanner.NoBandChannelHelper;
 
 import java.util.Arrays;
-import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 
@@ -41,6 +43,7 @@ public class HalWifiScannerImpl extends WifiScannerImpl implements Handler.Callb
 
     private final WifiNative mWifiNative;
     private final Handler mEventHandler;
+    private final ChannelHelper mChannelHelper;
     private boolean mReportSingleScanFullResults = false;
     private WifiNative.ScanEventHandler mSingleScanEventHandler = null;
     private WifiScanner.ScanData mLatestSingleScanResult =
@@ -50,6 +53,33 @@ public class HalWifiScannerImpl extends WifiScannerImpl implements Handler.Callb
         mWifiNative = wifiNative;
         mEventHandler = new Handler(looper, this);
 
+        // TODO(b/27324226) Remove this retry loop
+        // Sometimes angler returns an empty channel list the first time the channel list is queried
+        int[] channels24G = new int[0];
+        int[] channels5G = new int[0];
+        int[] channelsDfs = new int[0];
+        ChannelHelper channelHelper = null;
+        for (int i = 0; i < 4; ++i) {
+            channels24G = mWifiNative.getChannelsForBand(WifiScanner.WIFI_BAND_24_GHZ);
+            if (channels24G == null) Log.e(TAG, "Failed to get channels for 2.4GHz band");
+            channels5G = mWifiNative.getChannelsForBand(WifiScanner.WIFI_BAND_5_GHZ);
+            if (channels5G == null) Log.e(TAG, "Failed to get channels for 5GHz band");
+            channelsDfs = mWifiNative.getChannelsForBand(WifiScanner.WIFI_BAND_5_GHZ_DFS_ONLY);
+            if (channelsDfs == null) Log.e(TAG, "Failed to get channels for 5GHz DFS only band");
+            if (channels24G == null || channels5G == null || channelsDfs == null) {
+                Log.e(TAG, "Falling back to NoBandChannelHelper");
+                channelHelper = new NoBandChannelHelper();
+                break;
+            } else if (channels24G.length > 0 || channels5G.length > 0 || channelsDfs.length > 0) {
+                channelHelper = new KnownBandsChannelHelper(channels24G, channels5G, channelsDfs);
+            }
+            try { Thread.sleep(50); } catch (Exception e) {}
+        }
+        if (channelHelper == null) {
+            channelHelper = new KnownBandsChannelHelper(channels24G, channels5G, channelsDfs);
+        }
+        mChannelHelper = channelHelper;
+
         // We can't enable these until WifiStateMachine switches to using WifiScanner because
         //   WifiMonitor only supports sending results to one listener
         // TODO Enable these
@@ -95,7 +125,8 @@ public class HalWifiScannerImpl extends WifiScannerImpl implements Handler.Callb
             Log.w(TAG, "A single scan is already running");
             return false;
         }
-        Set<Integer> freqs = new HashSet<>();
+
+        ChannelCollection scanChannels = mChannelHelper.createChannelCollection();
         mReportSingleScanFullResults = false;
         for (int i = 0; i < settings.num_buckets; ++i) {
             WifiNative.BucketSettings bucketSettings = settings.buckets[i];
@@ -103,21 +134,11 @@ public class HalWifiScannerImpl extends WifiScannerImpl implements Handler.Callb
                             & WifiScanner.REPORT_EVENT_FULL_SCAN_RESULT) != 0) {
                 mReportSingleScanFullResults = true;
             }
-            if (bucketSettings.band == WifiScanner.WIFI_BAND_UNSPECIFIED) {
-                for (int j = 0; j < bucketSettings.num_channels; ++j) {
-                    WifiNative.ChannelSettings channel = bucketSettings.channels[j];
-                    freqs.add(channel.frequency);
-                }
-            } else {
-                WifiScanner.ChannelSpec[] channels =
-                    WifiChannelHelper.getChannelsForBand(bucketSettings.band);
-                for (WifiScanner.ChannelSpec channel : channels) {
-                    freqs.add(channel.frequency);
-                }
-            }
+            scanChannels.addChannels(bucketSettings);
         }
 
         mSingleScanEventHandler = eventHandler;
+        Set<Integer> freqs = scanChannels.getSupplicantScanFreqs();
         if (!mWifiNative.scan(freqs)) {
             Log.e(TAG, "Failed to start scan, freqs=" + freqs);
             // indicate scan failure async
@@ -169,6 +190,11 @@ public class HalWifiScannerImpl extends WifiScannerImpl implements Handler.Callb
     }
 
     @Override
+    public ChannelHelper getChannelHelper() {
+        return mChannelHelper;
+    }
+
+    @Override
     public boolean startBatchedScan(WifiNative.ScanSettings settings,
             WifiNative.ScanEventHandler eventHandler) {
         if (settings == null || eventHandler == null) {
diff --git a/service/java/com/android/server/wifi/MultiClientScheduler.java b/service/java/com/android/server/wifi/MultiClientScheduler.java
index 6c23b892d..2e05197bc 100644
--- a/service/java/com/android/server/wifi/MultiClientScheduler.java
+++ b/service/java/com/android/server/wifi/MultiClientScheduler.java
@@ -20,13 +20,14 @@ import android.annotation.NonNull;
 import android.annotation.Nullable;
 import android.net.wifi.ScanResult;
 import android.net.wifi.WifiScanner;
-import android.net.wifi.WifiScanner.ChannelSpec;
 import android.net.wifi.WifiScanner.ScanData;
 import android.net.wifi.WifiScanner.ScanSettings;
-import android.util.ArraySet;
 import android.util.Rational;
 import android.util.Slog;
 
+import com.android.server.wifi.scanner.ChannelHelper;
+import com.android.server.wifi.scanner.ChannelHelper.ChannelCollection;
+
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
@@ -107,7 +108,7 @@ public class MultiClientScheduler extends WifiScanningScheduler {
     /**
      * this class is an intermediate representation for scheduling
      */
-    private static class Bucket {
+    private class Bucket {
         public int period;
         public final List<ScanSettings> settings = new ArrayList<>();
 
@@ -118,7 +119,7 @@ public class MultiClientScheduler extends WifiScanningScheduler {
         /**
          * convert ChannelSpec to native representation
          */
-        private static WifiNative.ChannelSettings createChannelSettings(int frequency) {
+        private WifiNative.ChannelSettings createChannelSettings(int frequency) {
             WifiNative.ChannelSettings channelSettings = new WifiNative.ChannelSettings();
             channelSettings.frequency = frequency;
             return channelSettings;
@@ -132,11 +133,10 @@ public class MultiClientScheduler extends WifiScanningScheduler {
             int reportEvents = WifiScanner.REPORT_EVENT_NO_BATCH;
             int maxPeriodInMs = 0;
             int stepCount = 0;
-            ArraySet<Integer> channels = new ArraySet<Integer>();
-            int exactBands = 0;
-            int allBands = 0;
             int bucketIndex = 0;
 
+            mChannelCollection.clear();
+
             for (int i = 0; i < settings.size(); ++i) {
                 WifiScanner.ScanSettings setting = settings.get(i);
                 int requestedReportEvents = setting.reportEvents;
@@ -150,16 +150,7 @@ public class MultiClientScheduler extends WifiScanningScheduler {
                     reportEvents |= WifiScanner.REPORT_EVENT_FULL_SCAN_RESULT;
                 }
 
-                WifiScanner.ChannelSpec[] settingChannels =
-                        WifiChannelHelper.getChannelsForScanSettings(setting);
-                for (int j = 0; j < settingChannels.length; ++j) {
-                    channels.add(settingChannels[j].frequency);
-                    allBands |=
-                            WifiChannelHelper.getBandFromChannel(settingChannels[j].frequency);
-                }
-                if (setting.band != WifiScanner.WIFI_BAND_UNSPECIFIED) {
-                    exactBands |= setting.band;
-                }
+                mChannelCollection.addChannels(setting);
 
                 // For the bucket allocated to exponential back off scan, the values of
                 // the exponential back off scan related parameters from the very first
@@ -187,19 +178,7 @@ public class MultiClientScheduler extends WifiScanningScheduler {
             bucketSettings.period_ms = period;
             bucketSettings.max_period_ms = maxPeriodInMs;
             bucketSettings.step_count = stepCount;
-            if (channels.size() > maxChannels || allBands == exactBands) {
-                bucketSettings.band = allBands;
-                bucketSettings.num_channels = 0;
-                bucketSettings.channels = null;
-            } else {
-                bucketSettings.band = WifiScanner.WIFI_BAND_UNSPECIFIED;
-                bucketSettings.num_channels = channels.size();
-                bucketSettings.channels = new WifiNative.ChannelSettings[channels.size()];
-                for (int i = 0; i < channels.size(); ++i) {
-                    bucketSettings.channels[i] = createChannelSettings(channels.valueAt(i));
-                }
-            }
-
+            mChannelCollection.fillBucketSettings(bucketSettings, maxChannels);
             return bucketSettings;
         }
     }
@@ -207,7 +186,7 @@ public class MultiClientScheduler extends WifiScanningScheduler {
     /**
      * Maintains a list of buckets and the number that are active (non-null)
      */
-    private static class BucketList {
+    private class BucketList {
         private final Bucket[] mBuckets;
         private int mActiveBucketCount = 0;
 
@@ -262,9 +241,13 @@ public class MultiClientScheduler extends WifiScanningScheduler {
     }
 
     private final BucketList mBuckets = new BucketList();
+    private final ChannelHelper mChannelHelper;
+    private final ChannelCollection mChannelCollection;
     private WifiNative.ScanSettings mSchedule;
 
-    public MultiClientScheduler() {
+    public MultiClientScheduler(ChannelHelper channelHelper) {
+        mChannelHelper = channelHelper;
+        mChannelCollection = mChannelHelper.createChannelCollection();
         mSchedule = createSchedule(Collections.<ScanSettings>emptyList());
     }
 
@@ -289,30 +272,19 @@ public class MultiClientScheduler extends WifiScanningScheduler {
     @Override
     public boolean shouldReportFullScanResultForSettings(@NonNull ScanResult result,
             @NonNull ScanSettings settings) {
-        ChannelSpec desiredChannels[] = WifiChannelHelper.getChannelsForScanSettings(settings);
-        for (ChannelSpec channelSpec : desiredChannels) {
-            if (channelSpec.frequency == result.frequency) {
-                return true;
-            }
-        }
-        return false;
+        return mChannelHelper.settingsContainChannel(settings, result.frequency);
     }
 
     @Override
     public @Nullable ScanData[] filterResultsForSettings(@NonNull ScanData[] scanDatas,
             @NonNull ScanSettings settings) {
-        ChannelSpec desiredChannels[] = WifiChannelHelper.getChannelsForScanSettings(settings);
-
         ArrayList<ScanData> filteredScanDatas = new ArrayList<>(scanDatas.length);
         ArrayList<ScanResult> filteredResults = new ArrayList<>();
         for (ScanData scanData : scanDatas) {
             filteredResults.clear();
             for (ScanResult scanResult : scanData.getResults()) {
-                for (ChannelSpec channelSpec : desiredChannels) {
-                    if (channelSpec.frequency == scanResult.frequency) {
-                        filteredResults.add(scanResult);
-                        break;
-                    }
+                if (mChannelHelper.settingsContainChannel(settings, scanResult.frequency)) {
+                    filteredResults.add(scanResult);
                 }
                 if (settings.numBssidsPerScan > 0
                         && filteredResults.size() >= settings.numBssidsPerScan) {
diff --git a/service/java/com/android/server/wifi/SupplicantWifiScannerImpl.java b/service/java/com/android/server/wifi/SupplicantWifiScannerImpl.java
index 8afc19d56..c30dd17ee 100644
--- a/service/java/com/android/server/wifi/SupplicantWifiScannerImpl.java
+++ b/service/java/com/android/server/wifi/SupplicantWifiScannerImpl.java
@@ -26,11 +26,14 @@ import android.os.Message;
 import android.os.SystemClock;
 import android.util.Log;
 
+import com.android.server.wifi.scanner.ChannelHelper;
+import com.android.server.wifi.scanner.ChannelHelper.ChannelCollection;
+import com.android.server.wifi.scanner.NoBandChannelHelper;
+
 import java.util.ArrayDeque;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
-import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 
@@ -53,6 +56,7 @@ public class SupplicantWifiScannerImpl extends WifiScannerImpl implements Handle
     private final WifiNative mWifiNative;
     private final AlarmManager mAlarmManager;
     private final Handler mEventHandler;
+    private final ChannelHelper mChannelHelper;
 
     private Object mSettingsLock = new Object();
 
@@ -95,6 +99,9 @@ public class SupplicantWifiScannerImpl extends WifiScannerImpl implements Handle
         mAlarmManager = (AlarmManager) mContext.getSystemService(Context.ALARM_SERVICE);
         mEventHandler = new Handler(looper, this);
 
+        // TODO figure out how to get channel information from supplicant
+        mChannelHelper = new NoBandChannelHelper();
+
         // We can't enable these until WifiStateMachine switches to using WifiScanner because
         //   WifiMonitor only supports sending results to one listener
         // TODO Enable these
@@ -119,6 +126,11 @@ public class SupplicantWifiScannerImpl extends WifiScannerImpl implements Handle
     }
 
     @Override
+    public ChannelHelper getChannelHelper() {
+        return mChannelHelper;
+    }
+
+    @Override
     public boolean startSingleScan(WifiNative.ScanSettings settings,
             WifiNative.ScanEventHandler eventHandler) {
         if (eventHandler == null || settings == null) {
@@ -254,7 +266,7 @@ public class SupplicantWifiScannerImpl extends WifiScannerImpl implements Handle
                 return;
             }
 
-            Set<Integer> freqs = new HashSet<>();
+            ChannelCollection allFreqs = mChannelHelper.createChannelCollection();
             final LastScanSettings newScanSettings =
                     new LastScanSettings(SystemClock.elapsedRealtime());
 
@@ -271,7 +283,6 @@ public class SupplicantWifiScannerImpl extends WifiScannerImpl implements Handle
                 if (mBackgroundScanPeriodPending) {
                     if (mBackgroundScanSettings != null) {
                         int reportEvents = WifiScanner.REPORT_EVENT_NO_BATCH; // default to no batch
-                        boolean haveBackgroundScanChannels = false;
                         for (int bucket_id = 0; bucket_id < mBackgroundScanSettings.num_buckets;
                                 ++bucket_id) {
                             WifiNative.BucketSettings bucket =
@@ -292,25 +303,10 @@ public class SupplicantWifiScannerImpl extends WifiScannerImpl implements Handle
                                     reportEvents &= ~WifiScanner.REPORT_EVENT_NO_BATCH;
                                 }
 
-                                if (bucket.band != WifiScanner.WIFI_BAND_UNSPECIFIED) {
-                                    WifiScanner.ChannelSpec[] channels =
-                                            WifiChannelHelper.getChannelsForBand(bucket.band);
-                                    for (WifiScanner.ChannelSpec channel : channels) {
-                                        freqs.add(channel.frequency);
-                                        haveBackgroundScanChannels = true;
-                                    }
-                                } else {
-                                    for (int channel_id = 0; channel_id < bucket.num_channels;
-                                            ++channel_id) {
-                                        WifiNative.ChannelSettings channel =
-                                                bucket.channels[channel_id];
-                                        freqs.add(channel.frequency);
-                                        haveBackgroundScanChannels = true;
-                                    }
-                                }
+                                allFreqs.addChannels(bucket);
                             }
                         }
-                        if (haveBackgroundScanChannels) {
+                        if (!allFreqs.isEmpty()) {
                             newScanSettings.setBackgroundScan(mNextBackgroundScanId++,
                                     mBackgroundScanSettings.max_ap_per_scan, reportEvents,
                                     mBackgroundScanSettings.report_threshold_num_scans,
@@ -329,7 +325,7 @@ public class SupplicantWifiScannerImpl extends WifiScannerImpl implements Handle
 
             if (mPendingSingleScanSettings != null) {
                 boolean reportFullResults = false;
-                Set<Integer> singleScanFreqs = new HashSet<>();
+                ChannelCollection singleScanFreqs = mChannelHelper.createChannelCollection();
                 for (int i = 0; i < mPendingSingleScanSettings.num_buckets; ++i) {
                     WifiNative.BucketSettings bucketSettings =
                             mPendingSingleScanSettings.buckets[i];
@@ -337,20 +333,9 @@ public class SupplicantWifiScannerImpl extends WifiScannerImpl implements Handle
                                     & WifiScanner.REPORT_EVENT_FULL_SCAN_RESULT) != 0) {
                         reportFullResults = true;
                     }
-                    if (bucketSettings.band == WifiScanner.WIFI_BAND_UNSPECIFIED) {
-                        for (int j = 0; j < bucketSettings.num_channels; ++j) {
-                            WifiNative.ChannelSettings channel = bucketSettings.channels[j];
-                            singleScanFreqs.add(channel.frequency);
-                        }
-                    } else {
-                        WifiScanner.ChannelSpec[] channels =
-                                WifiChannelHelper.getChannelsForBand(bucketSettings.band);
-                        for (WifiScanner.ChannelSpec channel : channels) {
-                            singleScanFreqs.add(channel.frequency);
-                        }
-                    }
+                    singleScanFreqs.addChannels(bucketSettings);
+                    allFreqs.addChannels(bucketSettings);
                 }
-                freqs.addAll(singleScanFreqs);
                 newScanSettings.setSingleScan(reportFullResults, singleScanFreqs,
                         mPendingSingleScanEventHandler);
 
@@ -358,7 +343,8 @@ public class SupplicantWifiScannerImpl extends WifiScannerImpl implements Handle
                 mPendingSingleScanEventHandler = null;
             }
 
-            if (freqs.size() > 0) {
+            if (!allFreqs.isEmpty()) {
+                Set<Integer> freqs = allFreqs.getSupplicantScanFreqs();
                 boolean success = mWifiNative.scan(freqs);
                 if (success) {
                     // TODO handle scan timeout
@@ -424,7 +410,8 @@ public class SupplicantWifiScannerImpl extends WifiScannerImpl implements Handle
                         backgroundScanResults.add(result);
                     }
                     if (mLastScanSettings.singleScanActive
-                            && mLastScanSettings.singleScanFreqs.contains(result.frequency)) {
+                            && mLastScanSettings.singleScanFreqs.containsChannel(
+                                    result.frequency)) {
                         singleScanResults.add(result);
                     }
                 } else {
@@ -578,11 +565,12 @@ public class SupplicantWifiScannerImpl extends WifiScannerImpl implements Handle
         // Single scan settings
         public boolean singleScanActive = false;
         public boolean reportSingleScanFullResults;
-        public Set<Integer> singleScanFreqs;
+        public ChannelCollection singleScanFreqs;
         public WifiNative.ScanEventHandler singleScanEventHandler;
 
         public void setSingleScan(boolean reportSingleScanFullResults,
-                Set<Integer> singleScanFreqs, WifiNative.ScanEventHandler singleScanEventHandler) {
+                ChannelCollection singleScanFreqs,
+                WifiNative.ScanEventHandler singleScanEventHandler) {
             singleScanActive = true;
             this.reportSingleScanFullResults = reportSingleScanFullResults;
             this.singleScanFreqs = singleScanFreqs;
diff --git a/service/java/com/android/server/wifi/WifiChannelHelper.java b/service/java/com/android/server/wifi/WifiChannelHelper.java
deleted file mode 100644
index e59451978..000000000
--- a/service/java/com/android/server/wifi/WifiChannelHelper.java
+++ /dev/null
@@ -1,170 +0,0 @@
-/*
- * Copyright (C) 2015 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License
- */
-
-package com.android.server.wifi;
-
-import android.net.wifi.WifiScanner;
-import android.util.Slog;
-
-public final class WifiChannelHelper {
-
-    private static final String TAG = "WifiChannelHelper";
-
-    private static final WifiScanner.ChannelSpec NO_CHANNELS[] = new WifiScanner.ChannelSpec[0];
-    private static volatile WifiScanner.ChannelSpec sChannels[][];
-
-    private static void copyChannels(
-            WifiScanner.ChannelSpec channelSpec[], int offset, int channels[]) {
-        for (int i = 0; i < channels.length; i++) {
-            channelSpec[offset +i] = new WifiScanner.ChannelSpec(channels[i]);
-        }
-    }
-
-    private static synchronized void initChannels() {
-        if (sChannels != null) {
-            return;
-        }
-
-        WifiNative wifiNative = WifiNative.getWlanNativeInterface();
-        int channels24[] = wifiNative.getChannelsForBand(WifiScanner.WIFI_BAND_24_GHZ);
-        if (channels24 == null) {
-            return;
-        }
-
-        int channels5[] = wifiNative.getChannelsForBand(WifiScanner.WIFI_BAND_5_GHZ);
-        if (channels5 == null) {
-            return;
-        }
-
-        int channelsDfs[] = wifiNative.getChannelsForBand(WifiScanner.WIFI_BAND_5_GHZ_DFS_ONLY);
-        if (channelsDfs == null) {
-            return;
-        }
-
-        sChannels = new WifiScanner.ChannelSpec[8][];
-
-        sChannels[0] = NO_CHANNELS;
-
-        sChannels[1] = new WifiScanner.ChannelSpec[channels24.length];
-        copyChannels(sChannels[1], 0, channels24);
-
-        sChannels[2] = new WifiScanner.ChannelSpec[channels5.length];
-        copyChannels(sChannels[2], 0, channels5);
-
-        sChannels[3] = new WifiScanner.ChannelSpec[channels24.length + channels5.length];
-        copyChannels(sChannels[3], 0, channels24);
-        copyChannels(sChannels[3], channels24.length, channels5);
-
-        sChannels[4] = new WifiScanner.ChannelSpec[channelsDfs.length];
-        copyChannels(sChannels[4], 0, channelsDfs);
-
-        sChannels[5] = new WifiScanner.ChannelSpec[channels24.length + channelsDfs.length];
-        copyChannels(sChannels[5], 0, channels24);
-        copyChannels(sChannels[5], channels24.length, channelsDfs);
-
-        sChannels[6] = new WifiScanner.ChannelSpec[channels5.length + channelsDfs.length];
-        copyChannels(sChannels[6], 0, channels5);
-        copyChannels(sChannels[6], channels5.length, channelsDfs);
-
-        sChannels[7] = new WifiScanner.ChannelSpec[
-                channels24.length + channels5.length + channelsDfs.length];
-        copyChannels(sChannels[7], 0, channels24);
-        copyChannels(sChannels[7], channels24.length, channels5);
-        copyChannels(sChannels[7], channels24.length + channels5.length, channelsDfs);
-    }
-
-    public static void clearChannelCache() {
-        sChannels = null;
-    }
-
-    public static WifiScanner.ChannelSpec[] getChannelsForBand(int band) {
-        if (sChannels == null) {
-            initChannels();
-        }
-
-        if (sChannels == null) {
-            Slog.e(TAG, "Wifi HAL failed on channel initialization");
-            return NO_CHANNELS;
-        }
-
-        if (band < WifiScanner.WIFI_BAND_24_GHZ || band > WifiScanner.WIFI_BAND_BOTH_WITH_DFS)
-            // invalid value for band
-            return NO_CHANNELS;
-        else
-            return sChannels[band];
-    }
-
-    public static WifiScanner.ChannelSpec[] getChannelsForScanSettings(
-            WifiScanner.ScanSettings settings) {
-        if (settings.band == WifiScanner.WIFI_BAND_UNSPECIFIED) {
-            if(settings.channels != null) {
-                return settings.channels;
-            }
-            else {
-                return NO_CHANNELS;
-            }
-        } else {
-            return getChannelsForBand(settings.band);
-        }
-    }
-
-    public static boolean isDfsChannel(int channel) {
-        if (sChannels == null) {
-            initChannels();
-        }
-        if (sChannels == null) {
-            Slog.e(TAG, "Wifi HAL failed on channel initialization");
-            return false;
-        }
-        for (WifiScanner.ChannelSpec dfsChannel : sChannels[WifiScanner.WIFI_BAND_5_GHZ_DFS_ONLY]) {
-            if (channel == dfsChannel.frequency) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    public static int getBandFromChannel(int frequency) {
-        if (2400 <= frequency && frequency < 2500) {
-            return WifiScanner.WIFI_BAND_24_GHZ;
-        } else if (isDfsChannel(frequency)) {
-            return WifiScanner.WIFI_BAND_5_GHZ_DFS_ONLY;
-        } else if (5100 <= frequency && frequency < 6000) {
-            return WifiScanner.WIFI_BAND_5_GHZ;
-        }
-        return WifiScanner.WIFI_BAND_UNSPECIFIED;
-    }
-
-    public static int getBandFromChannels(WifiNative.ChannelSettings[] channels, int numChannels) {
-        int band = WifiScanner.WIFI_BAND_UNSPECIFIED;
-        for (int c = 0; c < numChannels; c++) {
-            band |= getBandFromChannel(channels[c].frequency);
-        }
-        return band;
-    }
-
-    public static int getBandFromChannels(WifiScanner.ChannelSpec[] channels) {
-        int band = WifiScanner.WIFI_BAND_UNSPECIFIED;
-        for (WifiScanner.ChannelSpec channel : channels) {
-            band |= getBandFromChannel(channel.frequency);
-        }
-        return band;
-    }
-
-    private WifiChannelHelper() {
-        // don't allow initialization
-    }
-}
diff --git a/service/java/com/android/server/wifi/WifiScannerImpl.java b/service/java/com/android/server/wifi/WifiScannerImpl.java
index c2826b195..d425f623f 100644
--- a/service/java/com/android/server/wifi/WifiScannerImpl.java
+++ b/service/java/com/android/server/wifi/WifiScannerImpl.java
@@ -21,7 +21,7 @@ import android.net.wifi.ScanResult;
 import android.net.wifi.WifiScanner;
 import android.os.Looper;
 
-import com.android.server.wifi.WifiNative;
+import com.android.server.wifi.scanner.ChannelHelper;
 
 import java.util.Comparator;
 
@@ -62,10 +62,20 @@ public abstract class WifiScannerImpl {
         }
     };
 
-
+    /**
+     * Get the supported scan capabilities.
+     *
+     * @param capabilities Object that will be filled with the supported capabilities if successful
+     * @return true if the scan capabilities were retrieved successfully
+     */
     public abstract boolean getScanCapabilities(WifiNative.ScanCapabilities capabilities);
 
     /**
+     * Get a ChannelHelper that can be used to perform operations on scan channels
+     */
+    public abstract ChannelHelper getChannelHelper();
+
+    /**
      * Start a one time scan. This method should only be called when there is no scan going on
      * (after a callback indicating that the previous scan succeeded/failed).
      * @return if the scan paramaters are valid
diff --git a/service/java/com/android/server/wifi/WifiScanningServiceImpl.java b/service/java/com/android/server/wifi/WifiScanningServiceImpl.java
index 92207c382..efc64e86c 100644
--- a/service/java/com/android/server/wifi/WifiScanningServiceImpl.java
+++ b/service/java/com/android/server/wifi/WifiScanningServiceImpl.java
@@ -99,7 +99,7 @@ public class WifiScanningServiceImpl extends IWifiScanner.Stub {
 
     @Override
     public Bundle getAvailableChannels(int band) {
-        ChannelSpec[] channelSpecs = WifiChannelHelper.getChannelsForBand(band);
+        ChannelSpec[] channelSpecs = mChannelHelper.getAvailableScanChannels(band);
         ArrayList<Integer> list = new ArrayList<Integer>(channelSpecs.length);
         for (ChannelSpec channelSpec : channelSpecs) {
             list.add(channelSpec.frequency);
@@ -222,7 +222,8 @@ public class WifiScanningServiceImpl extends IWifiScanner.Stub {
     private final WifiScannerImpl.WifiScannerImplFactory mScannerImplFactory;
     private final ArrayMap<Messenger, ClientInfo> mClients;
 
-    private final WifiScanningScheduler mScheduler;
+    private ChannelHelper mChannelHelper;
+    private WifiScanningScheduler mScheduler;
     private WifiNative.ScanSettings mPreviousSchedule;
 
     private WifiScanningStateMachine mStateMachine;
@@ -237,7 +238,6 @@ public class WifiScanningServiceImpl extends IWifiScanner.Stub {
         mBatteryStats = batteryStats;
         mClients = new ArrayMap<>();
 
-        mScheduler = new MultiClientScheduler();
         mPreviousSchedule = null;
     }
 
@@ -358,6 +358,8 @@ public class WifiScanningServiceImpl extends IWifiScanner.Stub {
                             return HANDLED;
                         }
 
+                        mChannelHelper = mScannerImpl.getChannelHelper();
+                        mScheduler = new MultiClientScheduler(mChannelHelper);
                         mScheduler.setMaxBuckets(capabilities.max_scan_buckets);
                         mScheduler.setMaxApPerScan(capabilities.max_ap_cache_per_scan);
 
@@ -571,16 +573,17 @@ public class WifiScanningServiceImpl extends IWifiScanner.Stub {
             }
         }
 
+        // TODO migrate batterystats to accept scan duration per hour instead of csph
         int getCsph() {
-            int csph = 0;
+            int totalScanDurationPerHour = 0;
             for (ScanSettings settings : getScanSettings()) {
-                int num_channels = WifiChannelHelper.getChannelsForScanSettings(settings).length;
+                int scanDurationMs = mChannelHelper.estimateScanDuration(settings);
                 int scans_per_Hour = settings.periodInMs == 0 ? 1 : (3600 * 1000) /
                         settings.periodInMs;
-                csph += num_channels * scans_per_Hour;
+                totalScanDurationPerHour += scanDurationMs * scans_per_Hour;
             }
 
-            return csph;
+            return totalScanDurationPerHour / ChannelHelper.SCAN_PERIOD_PER_CHANNEL_MS;
         }
 
         void reportScanWorkUpdate() {
@@ -915,19 +918,24 @@ public class WifiScanningServiceImpl extends IWifiScanner.Stub {
             return false;
         }
         if (settings.periodInMs < WifiScanner.MIN_SCAN_PERIOD_MS) {
-            localLog("Failing scan request because periodInMs is " + settings.periodInMs);
+            loge("Failing scan request because periodInMs is " + settings.periodInMs
+                    + ", min scan period is: " + WifiScanner.MIN_SCAN_PERIOD_MS);
             return false;
         }
 
-        int channelCount = WifiChannelHelper.getChannelsForScanSettings(settings).length;
-        if (channelCount == 0) {
+        if (settings.band == WifiScanner.WIFI_BAND_UNSPECIFIED && settings.channels == null) {
+            loge("Channels was null with unspecified band");
+            return false;
+        }
+
+        if (settings.band == WifiScanner.WIFI_BAND_UNSPECIFIED && settings.channels.length == 0) {
             loge("No channels specified");
             return false;
         }
-        int minSupportedPeriodMs = channelCount * MIN_PERIOD_PER_CHANNEL_MS;
 
+        int minSupportedPeriodMs = mChannelHelper.estimateScanDuration(settings);
         if (settings.periodInMs < minSupportedPeriodMs) {
-            localLog("Failing scan request because minSupportedPeriodMs is "
+            loge("Failing scan request because minSupportedPeriodMs is "
                     + minSupportedPeriodMs + " but the request wants " + settings.periodInMs);
             return false;
         }
@@ -935,18 +943,18 @@ public class WifiScanningServiceImpl extends IWifiScanner.Stub {
         // check truncated binary exponential back off scan settings
         if (settings.maxPeriodInMs != 0 && settings.maxPeriodInMs != settings.periodInMs) {
             if (settings.maxPeriodInMs < settings.periodInMs) {
-                localLog("Failing scan request because maxPeriodInMs is " + settings.maxPeriodInMs
+                loge("Failing scan request because maxPeriodInMs is " + settings.maxPeriodInMs
                         + " but less than periodInMs " + settings.periodInMs);
                 return false;
             }
             if (settings.maxPeriodInMs > WifiScanner.MAX_SCAN_PERIOD_MS) {
-                localLog("Failing scan request because maxSupportedPeriodMs is "
-                    + WifiScanner.MAX_SCAN_PERIOD_MS + " but the request wants "
-                    + settings.maxPeriodInMs);
+                loge("Failing scan request because maxSupportedPeriodMs is "
+                        + WifiScanner.MAX_SCAN_PERIOD_MS + " but the request wants "
+                        + settings.maxPeriodInMs);
                 return false;
             }
             if (settings.stepCount < 1) {
-                localLog("Failing scan request because stepCount is " + settings.stepCount
+                loge("Failing scan request because stepCount is " + settings.stepCount
                         + " which is less than 1");
                 return false;
             }
diff --git a/service/java/com/android/server/wifi/scanner/KnownBandsChannelHelper.java b/service/java/com/android/server/wifi/scanner/KnownBandsChannelHelper.java
index 2b6cb6a34..96dbeeaa6 100644
--- a/service/java/com/android/server/wifi/scanner/KnownBandsChannelHelper.java
+++ b/service/java/com/android/server/wifi/scanner/KnownBandsChannelHelper.java
@@ -205,16 +205,21 @@ public class KnownBandsChannelHelper extends ChannelHelper {
 
         @Override
         public Set<Integer> getSupplicantScanFreqs() {
-            if (mAllBands == mExactBands && mExactBands == WifiScanner.WIFI_BAND_BOTH_WITH_DFS) {
+            if (mExactBands == WifiScanner.WIFI_BAND_BOTH_WITH_DFS) {
                 return null;
             } else {
                 return new ArraySet<Integer>(mChannels);
             }
         }
+
+        public Set<Integer> getAllChannels() {
+            return new ArraySet<Integer>(mChannels);
+        }
     }
 
     @Override
-    public ChannelCollection createChannelCollection() {
+
+    public KnownBandsChannelCollection createChannelCollection() {
         return new KnownBandsChannelCollection();
     }
 }