src/com/android/networkrecommendation/notify/WifiNotificationController.java - platform/packages/services/NetworkRecommendation - Git at Google

 /*
  * Copyright (C) 2017 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.networkrecommendation.notify;

 import static com.android.networkrecommendation.Constants.TAG;

 import android.app.Notification;
 import android.app.NotificationManager;
 import android.content.BroadcastReceiver;
 import android.content.ContentResolver;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
 import android.database.ContentObserver;
 import android.net.NetworkInfo;
 import android.net.NetworkScoreManager;
 import android.net.RecommendationRequest;
 import android.net.RecommendationResult;
 import android.net.wifi.ScanResult;
 import android.net.wifi.WifiConfiguration;
 import android.net.wifi.WifiManager;
 import android.os.Handler;
 import android.os.UserManager;
 import android.provider.Settings;
 import android.support.annotation.IntDef;
 import android.support.annotation.Nullable;
 import com.android.networkrecommendation.R;
 import com.android.networkrecommendation.SynchronousNetworkRecommendationProvider;
 import com.android.networkrecommendation.util.Blog;
 import com.android.networkrecommendation.util.RoboCompatUtil;
 import com.android.networkrecommendation.util.ScanResultUtil;
 import java.io.FileDescriptor;
 import java.io.PrintWriter;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;

 /** Takes care of handling the "open wi-fi network available" notification */
 public class WifiNotificationController {
     /** The unique ID of the Notification given to the NotificationManager. */
     private static final int NOTIFICATION_ID = R.string.wifi_available_title;

     /** When a notification is shown, we wait this amount before possibly showing it again. */
     private final long mNotificationRepeatDelayMs;

     /** Whether the user has set the setting to show the 'available networks' notification. */
     private boolean mNotificationEnabled;

     /** Whether the user has {@link UserManager#DISALLOW_CONFIG_WIFI} restriction. */
     private boolean mWifiConfigRestricted;

     /** Observes the user setting to keep {@link #mNotificationEnabled} in sync. */
     private final NotificationEnabledSettingObserver mNotificationEnabledSettingObserver;

     /**
      * The {@link System#currentTimeMillis()} must be at least this value for us to show the
      * notification again.
      */
     private long mNotificationRepeatTime;

     /** These are all of the possible states for the open networks available notification. */
     @IntDef({
         State.NO_RECOMMENDATION,
         State.SHOWING_RECOMMENDATION_NOTIFICATION,
         State.CONNECTING_IN_NOTIFICATION,
         State.CONNECTING_IN_WIFI_PICKER,
         State.CONNECTED,
         State.CONNECT_FAILED
     })
     @Retention(RetentionPolicy.SOURCE)
     public @interface State {
         int NO_RECOMMENDATION = 0;
         int SHOWING_RECOMMENDATION_NOTIFICATION = 1;
         int CONNECTING_IN_NOTIFICATION = 2;
         int CONNECTING_IN_WIFI_PICKER = 3;
         int CONNECTED = 4;
         int CONNECT_FAILED = 5;
     }

     /**
      * The {@link System#currentTimeMillis()} must be at least this value to log that open networks
      * are available.
      */
     private long mOpenNetworksLoggingRepeatTime;

     /** Current state of the notification. */
     @State private int mState = State.NO_RECOMMENDATION;

     /**
      * The number of continuous scans that must occur before consider the supplicant in a scanning
      * state. This allows supplicant to associate with remembered networks that are in the scan
      * results.
      */
     private static final int NUM_SCANS_BEFORE_ACTUALLY_SCANNING = 3;

     /**
      * The number of scans since the last network state change. When this exceeds {@link
      * #NUM_SCANS_BEFORE_ACTUALLY_SCANNING}, we consider the supplicant to actually be scanning.
      * When the network state changes to something other than scanning, we reset this to 0.
      */
     private int mNumScansSinceNetworkStateChange;

     /** Time in milliseconds to display the Connecting notification. */
     private static final int TIME_TO_SHOW_CONNECTING_MILLIS = 10000;

     /** Time in milliseconds to display the Connected notification. */
     private static final int TIME_TO_SHOW_CONNECTED_MILLIS = 5000;

     /** Time in milliseconds to display the Failed To Connect notification. */
     private static final int TIME_TO_SHOW_FAILED_MILLIS = 5000;

     /** Try to connect to the recommended WifiConfiguration and also open the wifi picker. */
     static final String ACTION_CONNECT_TO_RECOMMENDED_NETWORK_AND_OPEN_SETTINGS =
             "com.android.networkrecommendation.notify.CONNECT_TO_RECOMMENDED_NETWORK_AND_OPEN_SETTINGS";

     /** Try to connect to the recommended WifiConfiguration. */
     static final String ACTION_CONNECT_TO_RECOMMENDED_NETWORK =
             "com.android.networkrecommendation.notify.CONNECT_TO_RECOMMENDED_NETWORK";

     /** Open wifi picker to see all available networks. */
     static final String ACTION_PICK_WIFI_NETWORK =
             "com.android.networkrecommendation.notify.ACTION_PICK_WIFI_NETWORK";

     /** Open wifi picker to see all networks after connect to the recommended network failed. */
     static final String ACTION_PICK_WIFI_NETWORK_AFTER_CONNECT_FAILURE =
             "com.android.networkrecommendation.notify.ACTION_PICK_WIFI_NETWORK_AFTER_CONNECT_FAILURE";

     /** Handles behavior when notification is deleted. */
     static final String ACTION_NOTIFICATION_DELETED =
             "com.android.networkrecommendation.notify.NOTIFICATION_DELETED";

     /** Network recommended by {@link NetworkScoreManager#requestRecommendation}. */
     private WifiConfiguration mRecommendedNetwork;

     /** Whether {@link WifiNotificationController} has been started. */
     private final AtomicBoolean mStarted;

     private static final String NOTIFICATION_TAG = "WifiNotification";

     private final Context mContext;
     private final Handler mHandler;
     private final ContentResolver mContentResolver;
     private final SynchronousNetworkRecommendationProvider mNetworkRecommendationProvider;
     private final WifiManager mWifiManager;
     private final NotificationManager mNotificationManager;
     private final UserManager mUserManager;
     private final WifiNotificationHelper mWifiNotificationHelper;
     private NetworkInfo mNetworkInfo;
     private NetworkInfo.DetailedState mDetailedState;
     private volatile int mWifiState;

     public WifiNotificationController(
             Context context,
             ContentResolver contentResolver,
             Handler handler,
             SynchronousNetworkRecommendationProvider networkRecommendationProvider,
             WifiManager wifiManager,
             NotificationManager notificationManager,
             UserManager userManager,
             WifiNotificationHelper helper) {
         mContext = context;
         mContentResolver = contentResolver;
         mNetworkRecommendationProvider = networkRecommendationProvider;
         mWifiManager = wifiManager;
         mNotificationManager = notificationManager;
         mUserManager = userManager;
         mHandler = handler;
         mWifiNotificationHelper = helper;
         mStarted = new AtomicBoolean(false);

         // Setting is in seconds
         mNotificationRepeatDelayMs =
                 TimeUnit.SECONDS.toMillis(
                         Settings.Global.getInt(
                                 contentResolver,
                                 Settings.Global.WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY,
                                 900));
         mNotificationEnabledSettingObserver = new NotificationEnabledSettingObserver(mHandler);
     }

     /** Starts {@link WifiNotificationController}. */
     public void start() {
         if (!mStarted.compareAndSet(false, true)) {
             return;
         }

         mWifiState = mWifiManager.getWifiState();
         mDetailedState = NetworkInfo.DetailedState.IDLE;

         IntentFilter filter = new IntentFilter();
         filter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION);
         filter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);
         filter.addAction(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION);
         filter.addAction(RoboCompatUtil.ACTION_USER_RESTRICTIONS_CHANGED);
         filter.addAction(ACTION_CONNECT_TO_RECOMMENDED_NETWORK_AND_OPEN_SETTINGS);
         filter.addAction(ACTION_CONNECT_TO_RECOMMENDED_NETWORK);
         filter.addAction(ACTION_NOTIFICATION_DELETED);
         filter.addAction(ACTION_PICK_WIFI_NETWORK);
         filter.addAction(ACTION_PICK_WIFI_NETWORK_AFTER_CONNECT_FAILURE);

         mContext.registerReceiver(
                 mBroadcastReceiver, filter, null /* broadcastPermission */, mHandler);
         mNotificationEnabledSettingObserver.register();

         handleUserRestrictionsChanged();
     }

     /** Stops {@link WifiNotificationController}. */
     public void stop() {
         if (!mStarted.compareAndSet(true, false)) {
             return;
         }
         mContext.unregisterReceiver(mBroadcastReceiver);
         mNotificationEnabledSettingObserver.unregister();
     }

     private final BroadcastReceiver mBroadcastReceiver =
             new BroadcastReceiver() {
                 @Override
                 public void onReceive(Context context, Intent intent) {
                     try {
                         switch (intent.getAction()) {
                             case WifiManager.WIFI_STATE_CHANGED_ACTION:
                                 mWifiState = mWifiManager.getWifiState();
                                 resetNotification();
                                 break;
                             case WifiManager.NETWORK_STATE_CHANGED_ACTION:
                                 handleNetworkStateChange(intent);
                                 break;
                             case WifiManager.SCAN_RESULTS_AVAILABLE_ACTION:
                                 checkAndSetNotification(mNetworkInfo);
                                 break;
                             case RoboCompatUtil.ACTION_USER_RESTRICTIONS_CHANGED:
                                 handleUserRestrictionsChanged();
                                 break;
                             case ACTION_CONNECT_TO_RECOMMENDED_NETWORK_AND_OPEN_SETTINGS:
                                 connectToRecommendedNetwork();
                                 openWifiPicker();
                                 updateOnConnecting(false /* showNotification*/);
                                 break;
                             case ACTION_CONNECT_TO_RECOMMENDED_NETWORK:
                                 connectToRecommendedNetwork();
                                 updateOnConnecting(true /* showNotification*/);
                                 break;
                             case ACTION_NOTIFICATION_DELETED:
                                 handleNotificationDeleted();
                                 break;
                             case ACTION_PICK_WIFI_NETWORK:
                                 openWifiPicker();
                                 break;
                             case ACTION_PICK_WIFI_NETWORK_AFTER_CONNECT_FAILURE:
                                 openWifiPicker();
                                 break;
                             default:
                                 Blog.e(
                                         TAG,
                                         "Unexpected broadcast. [action=%s]",
                                         intent.getAction());
                         }

                     } catch (RuntimeException re) {
                         // TODO(b/35044022) Remove try/catch after a couple of releases when we are confident
                         // this is not going to throw.
                         Blog.e(TAG, re, "RuntimeException in broadcast receiver.");
                     }
                 }
             };

     private void handleNetworkStateChange(Intent intent) {
         mNetworkInfo = intent.getParcelableExtra(WifiManager.EXTRA_NETWORK_INFO);
         NetworkInfo.DetailedState detailedState = mNetworkInfo.getDetailedState();
         if (detailedState != NetworkInfo.DetailedState.SCANNING
                 && detailedState != mDetailedState) {
             mDetailedState = detailedState;
             switch (mDetailedState) {
                 case CONNECTED:
                     updateOnConnect();
                     break;
                 case DISCONNECTED:
                 case CAPTIVE_PORTAL_CHECK:
                     resetNotification();
                     break;

                     // TODO: figure out if these are failure cases when connecting
                 case IDLE:
                 case SCANNING:
                 case CONNECTING:
                 case DISCONNECTING:
                 case AUTHENTICATING:
                 case OBTAINING_IPADDR:
                 case SUSPENDED:
                 case FAILED:
                 case BLOCKED:
                 case VERIFYING_POOR_LINK:
                     break;
             }
         }
     }

     private void handleUserRestrictionsChanged() {
         mWifiConfigRestricted = mUserManager.hasUserRestriction(UserManager.DISALLOW_CONFIG_WIFI);
         Blog.v(TAG, "handleUserRestrictionsChanged: %b", mWifiConfigRestricted);
     }

     private void checkAndSetNotification(NetworkInfo networkInfo) {
         // TODO: unregister broadcast so we do not have to check here
         // If we shouldn't place a notification on available networks, then
         // don't bother doing any of the following
         if (!mNotificationEnabled
                 || mWifiConfigRestricted
                 || mWifiState != WifiManager.WIFI_STATE_ENABLED
                 || mState > State.SHOWING_RECOMMENDATION_NOTIFICATION) {
             return;
         }

         NetworkInfo.State state = NetworkInfo.State.DISCONNECTED;
         if (networkInfo != null) {
             state = networkInfo.getState();
         }

         if (state == NetworkInfo.State.DISCONNECTED || state == NetworkInfo.State.UNKNOWN) {
             maybeLogOpenNetworksAvailable();
             RecommendationResult result = getOpenNetworkRecommendation();
             if (result != null && result.getWifiConfiguration() != null) {
                 mRecommendedNetwork = result.getWifiConfiguration();

                 if (++mNumScansSinceNetworkStateChange >= NUM_SCANS_BEFORE_ACTUALLY_SCANNING) {
                     /*
                      * We have scanned continuously at least
                      * NUM_SCANS_BEFORE_NOTIFICATION times. The user
                      * probably does not have a remembered network in range,
                      * since otherwise supplicant would have tried to
                      * associate and thus resetting this counter.
                      */
                     displayNotification();
                 }
                 return;
             }
         }

         // No open networks in range, remove the notification
         removeNotification();
     }

     private void maybeLogOpenNetworksAvailable() {
         long now = System.currentTimeMillis();
         if (now < mOpenNetworksLoggingRepeatTime) {
             return;
         }
         mOpenNetworksLoggingRepeatTime = now + mNotificationRepeatDelayMs;
     }

     /**
      * Uses {@link NetworkScoreManager} to choose a qualified network out of the list of {@link
      * ScanResult}s.
      *
      * @return returns the best qualified open networks, if any.
      */
     @Nullable
     private RecommendationResult getOpenNetworkRecommendation() {
         List<ScanResult> scanResults = mWifiManager.getScanResults();
         if (scanResults == null || scanResults.isEmpty()) {
             return null;
         }

         ArrayList<ScanResult> openNetworks = new ArrayList<>();
         List<WifiConfiguration> configuredNetworks = mWifiManager.getConfiguredNetworks();
         for (ScanResult scanResult : scanResults) {
             //A capability of [ESS] represents an open access point
             //that is available for an STA to connect
             //TODO: potentially handle this within NetworkRecommendationProvider instead.
             if ("[ESS]".equals(scanResult.capabilities)) {
                 if (isSavedNetwork(scanResult, configuredNetworks)) {
                     continue;
                 }
                 openNetworks.add(scanResult);
             }
         }

         Blog.d(TAG, "Sending RecommendationRequest. [num_open_networks=%d]", openNetworks.size());
         RecommendationRequest request =
                 new RecommendationRequest.Builder()
                         .setScanResults(openNetworks.toArray(new ScanResult[openNetworks.size()]))
                         .build();
         return mNetworkRecommendationProvider.requestRecommendation(request);
     }

     /** Returns true if scanResult matches the list of saved networks */
     private boolean isSavedNetwork(ScanResult scanResult, List<WifiConfiguration> savedNetworks) {
         if (savedNetworks == null) {
             return false;
         }
         for (int i = 0; i < savedNetworks.size(); i++) {
             if (ScanResultUtil.doesScanResultMatchWithNetwork(scanResult, savedNetworks.get(i))) {
                 return true;
             }
         }
         return false;
     }

     /** Display's a notification that there are open Wi-Fi networks. */
     private void displayNotification() {
         // Since we use auto cancel on the notification, when the
         // mNetworksAvailableNotificationShown is true, the notification may
         // have actually been canceled.  However, when it is false we know
         // for sure that it is not being shown (it will not be shown any other
         // place than here)

         // Not enough time has passed to show the notification again
         if (mState == State.NO_RECOMMENDATION
                 && System.currentTimeMillis() < mNotificationRepeatTime) {
             return;
         }
         Notification notification =
                 mWifiNotificationHelper.createMainNotification(mRecommendedNetwork);
         mNotificationRepeatTime = System.currentTimeMillis() + mNotificationRepeatDelayMs;
         postNotification(notification);
         if (mState != State.SHOWING_RECOMMENDATION_NOTIFICATION) {
             mState = State.SHOWING_RECOMMENDATION_NOTIFICATION;
         }
     }

     /** Opens activity to allow the user to select a wifi network. */
     private void openWifiPicker() {
         // Close notification drawer before opening the picker.
         mContext.sendBroadcast(new Intent(Intent.ACTION_CLOSE_SYSTEM_DIALOGS));
         mContext.startActivity(
                 new Intent(WifiManager.ACTION_PICK_WIFI_NETWORK)
                         .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK));
         removeNotification();
     }

     /** Attempts to connect to recommended network the recommended network. */
     private void connectToRecommendedNetwork() {
         if (mRecommendedNetwork == null) {
             return;
         }
         mRecommendedNetwork.BSSID = null;

         // Attempts to connect to recommended network.
         RoboCompatUtil.getInstance().connectToWifi(mWifiManager, mRecommendedNetwork);
     }

     private void updateOnConnecting(boolean showNotification) {
         if (showNotification) {
             // Update notification to connecting status.
             Notification notification =
                     mWifiNotificationHelper.createConnectingNotification(mRecommendedNetwork);
             postNotification(notification);
             mState = State.CONNECTING_IN_NOTIFICATION;
         } else {
             mState = State.CONNECTING_IN_WIFI_PICKER;
         }
         mHandler.postDelayed(
                 () -> {
                     updateOnFailedToConnect();
                 },
                 TIME_TO_SHOW_CONNECTING_MILLIS);
     }

     /**
      * When detailed state changes to CONNECTED, show connected notification or reset notification.
      */
     private void updateOnConnect() {
         if (mState == State.CONNECTING_IN_NOTIFICATION) {
             Notification notification =
                     mWifiNotificationHelper.createConnectedNotification(mRecommendedNetwork);
             postNotification(notification);
             mState = State.CONNECTED;
             mHandler.postDelayed(
                     () -> {
                         if (mState == State.CONNECTED) {
                             removeNotification();
                         }
                     },
                     TIME_TO_SHOW_CONNECTED_MILLIS);
         } else if (mState == State.CONNECTING_IN_WIFI_PICKER) {
             removeNotification();
         }
     }

     /**
      * Displays the Failed To Connect notification after the Connecting notification is shown for
      * {@link #TIME_TO_SHOW_CONNECTING_MILLIS} duration.
      */
     private void updateOnFailedToConnect() {
         if (mState == State.CONNECTING_IN_NOTIFICATION) {
             Notification notification = mWifiNotificationHelper.createFailedToConnectNotification();
             postNotification(notification);
             mState = State.CONNECT_FAILED;
             mHandler.postDelayed(
                     () -> {
                         if (mState == State.CONNECT_FAILED) {
                             removeNotification();
                         }
                     },
                     TIME_TO_SHOW_FAILED_MILLIS);
         } else if (mState == State.CONNECTING_IN_WIFI_PICKER) {
             removeNotification();
         }
     }

     /** Handles behavior when notification is dismissed. */
     private void handleNotificationDeleted() {
         mState = State.NO_RECOMMENDATION;
         mRecommendedNetwork = null;
     }

     private void postNotification(Notification notification) {
         mNotificationManager.notify(NOTIFICATION_TAG, NOTIFICATION_ID, notification);
     }

     /**
      * Clears variables related to tracking whether a notification has been shown recently and
      * clears the current notification.
      */
     private void resetNotification() {
         if (mState != State.NO_RECOMMENDATION) {
             removeNotification();
         }
         mRecommendedNetwork = null;
         mNotificationRepeatTime = 0;
         mNumScansSinceNetworkStateChange = 0;
         mOpenNetworksLoggingRepeatTime = 0;
     }

     private void removeNotification() {
         mNotificationManager.cancel(NOTIFICATION_TAG, NOTIFICATION_ID);
         mState = State.NO_RECOMMENDATION;
         mRecommendedNetwork = null;
     }

     public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
         pw.println("mNotificationEnabled " + mNotificationEnabled);
         pw.println("mNotificationRepeatTime " + mNotificationRepeatTime);
         pw.println("mState " + mState);
         pw.println("mNumScansSinceNetworkStateChange " + mNumScansSinceNetworkStateChange);
     }

     private class NotificationEnabledSettingObserver extends ContentObserver {
         NotificationEnabledSettingObserver(Handler handler) {
             super(handler);
         }

         public void register() {
             mContentResolver.registerContentObserver(
                     Settings.Global.getUriFor(
                             Settings.Global.WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON),
                     true,
                     this);
             mNotificationEnabled = getValue();
         }

         public void unregister() {
             mContentResolver.unregisterContentObserver(this);
         }

         @Override
         public void onChange(boolean selfChange) {
             super.onChange(selfChange);

             mNotificationEnabled = getValue();
             resetNotification();
         }

         private boolean getValue() {
             return Settings.Global.getInt(
                             mContentResolver,
                             Settings.Global.WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON,
                             0)
                     == 1;
         }
     }
 }
	/*
	* Copyright (C) 2017 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.networkrecommendation.notify;

	import static com.android.networkrecommendation.Constants.TAG;

	import android.app.Notification;
	import android.app.NotificationManager;
	import android.content.BroadcastReceiver;
	import android.content.ContentResolver;
	import android.content.Context;
	import android.content.Intent;
	import android.content.IntentFilter;
	import android.database.ContentObserver;
	import android.net.NetworkInfo;
	import android.net.NetworkScoreManager;
	import android.net.RecommendationRequest;
	import android.net.RecommendationResult;
	import android.net.wifi.ScanResult;
	import android.net.wifi.WifiConfiguration;
	import android.net.wifi.WifiManager;
	import android.os.Handler;
	import android.os.UserManager;
	import android.provider.Settings;
	import android.support.annotation.IntDef;
	import android.support.annotation.Nullable;
	import com.android.networkrecommendation.R;
	import com.android.networkrecommendation.SynchronousNetworkRecommendationProvider;
	import com.android.networkrecommendation.util.Blog;
	import com.android.networkrecommendation.util.RoboCompatUtil;
	import com.android.networkrecommendation.util.ScanResultUtil;
	import java.io.FileDescriptor;
	import java.io.PrintWriter;
	import java.lang.annotation.Retention;
	import java.lang.annotation.RetentionPolicy;
	import java.util.ArrayList;
	import java.util.List;
	import java.util.concurrent.TimeUnit;
	import java.util.concurrent.atomic.AtomicBoolean;

	/** Takes care of handling the "open wi-fi network available" notification */
	public class WifiNotificationController {
	/** The unique ID of the Notification given to the NotificationManager. */
	private static final int NOTIFICATION_ID = R.string.wifi_available_title;

	/** When a notification is shown, we wait this amount before possibly showing it again. */
	private final long mNotificationRepeatDelayMs;

	/** Whether the user has set the setting to show the 'available networks' notification. */
	private boolean mNotificationEnabled;

	/** Whether the user has {@link UserManager#DISALLOW_CONFIG_WIFI} restriction. */
	private boolean mWifiConfigRestricted;

	/** Observes the user setting to keep {@link #mNotificationEnabled} in sync. */
	private final NotificationEnabledSettingObserver mNotificationEnabledSettingObserver;

	/**
	* The {@link System#currentTimeMillis()} must be at least this value for us to show the
	* notification again.
	*/
	private long mNotificationRepeatTime;

	/** These are all of the possible states for the open networks available notification. */
	@IntDef({
	State.NO_RECOMMENDATION,
	State.SHOWING_RECOMMENDATION_NOTIFICATION,
	State.CONNECTING_IN_NOTIFICATION,
	State.CONNECTING_IN_WIFI_PICKER,
	State.CONNECTED,
	State.CONNECT_FAILED
	})
	@Retention(RetentionPolicy.SOURCE)
	public @interface State {
	int NO_RECOMMENDATION = 0;
	int SHOWING_RECOMMENDATION_NOTIFICATION = 1;
	int CONNECTING_IN_NOTIFICATION = 2;
	int CONNECTING_IN_WIFI_PICKER = 3;
	int CONNECTED = 4;
	int CONNECT_FAILED = 5;
	}

	/**
	* The {@link System#currentTimeMillis()} must be at least this value to log that open networks
	* are available.
	*/
	private long mOpenNetworksLoggingRepeatTime;

	/** Current state of the notification. */
	@State private int mState = State.NO_RECOMMENDATION;

	/**
	* The number of continuous scans that must occur before consider the supplicant in a scanning
	* state. This allows supplicant to associate with remembered networks that are in the scan
	* results.
	*/
	private static final int NUM_SCANS_BEFORE_ACTUALLY_SCANNING = 3;

	/**
	* The number of scans since the last network state change. When this exceeds {@link
	* #NUM_SCANS_BEFORE_ACTUALLY_SCANNING}, we consider the supplicant to actually be scanning.
	* When the network state changes to something other than scanning, we reset this to 0.
	*/
	private int mNumScansSinceNetworkStateChange;

	/** Time in milliseconds to display the Connecting notification. */
	private static final int TIME_TO_SHOW_CONNECTING_MILLIS = 10000;

	/** Time in milliseconds to display the Connected notification. */
	private static final int TIME_TO_SHOW_CONNECTED_MILLIS = 5000;

	/** Time in milliseconds to display the Failed To Connect notification. */
	private static final int TIME_TO_SHOW_FAILED_MILLIS = 5000;

	/** Try to connect to the recommended WifiConfiguration and also open the wifi picker. */
	static final String ACTION_CONNECT_TO_RECOMMENDED_NETWORK_AND_OPEN_SETTINGS =
	"com.android.networkrecommendation.notify.CONNECT_TO_RECOMMENDED_NETWORK_AND_OPEN_SETTINGS";

	/** Try to connect to the recommended WifiConfiguration. */
	static final String ACTION_CONNECT_TO_RECOMMENDED_NETWORK =
	"com.android.networkrecommendation.notify.CONNECT_TO_RECOMMENDED_NETWORK";

	/** Open wifi picker to see all available networks. */
	static final String ACTION_PICK_WIFI_NETWORK =
	"com.android.networkrecommendation.notify.ACTION_PICK_WIFI_NETWORK";

	/** Open wifi picker to see all networks after connect to the recommended network failed. */
	static final String ACTION_PICK_WIFI_NETWORK_AFTER_CONNECT_FAILURE =
	"com.android.networkrecommendation.notify.ACTION_PICK_WIFI_NETWORK_AFTER_CONNECT_FAILURE";

	/** Handles behavior when notification is deleted. */
	static final String ACTION_NOTIFICATION_DELETED =
	"com.android.networkrecommendation.notify.NOTIFICATION_DELETED";

	/** Network recommended by {@link NetworkScoreManager#requestRecommendation}. */
	private WifiConfiguration mRecommendedNetwork;

	/** Whether {@link WifiNotificationController} has been started. */
	private final AtomicBoolean mStarted;

	private static final String NOTIFICATION_TAG = "WifiNotification";

	private final Context mContext;
	private final Handler mHandler;
	private final ContentResolver mContentResolver;
	private final SynchronousNetworkRecommendationProvider mNetworkRecommendationProvider;
	private final WifiManager mWifiManager;
	private final NotificationManager mNotificationManager;
	private final UserManager mUserManager;
	private final WifiNotificationHelper mWifiNotificationHelper;
	private NetworkInfo mNetworkInfo;
	private NetworkInfo.DetailedState mDetailedState;
	private volatile int mWifiState;

	public WifiNotificationController(
	Context context,
	ContentResolver contentResolver,
	Handler handler,
	SynchronousNetworkRecommendationProvider networkRecommendationProvider,
	WifiManager wifiManager,
	NotificationManager notificationManager,
	UserManager userManager,
	WifiNotificationHelper helper) {
	mContext = context;
	mContentResolver = contentResolver;
	mNetworkRecommendationProvider = networkRecommendationProvider;
	mWifiManager = wifiManager;
	mNotificationManager = notificationManager;
	mUserManager = userManager;
	mHandler = handler;
	mWifiNotificationHelper = helper;
	mStarted = new AtomicBoolean(false);

	// Setting is in seconds
	mNotificationRepeatDelayMs =
	TimeUnit.SECONDS.toMillis(
	Settings.Global.getInt(
	contentResolver,
	Settings.Global.WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY,
	900));
	mNotificationEnabledSettingObserver = new NotificationEnabledSettingObserver(mHandler);
	}

	/** Starts {@link WifiNotificationController}. */
	public void start() {
	if (!mStarted.compareAndSet(false, true)) {
	return;
	}

	mWifiState = mWifiManager.getWifiState();
	mDetailedState = NetworkInfo.DetailedState.IDLE;

	IntentFilter filter = new IntentFilter();
	filter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION);
	filter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);
	filter.addAction(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION);
	filter.addAction(RoboCompatUtil.ACTION_USER_RESTRICTIONS_CHANGED);
	filter.addAction(ACTION_CONNECT_TO_RECOMMENDED_NETWORK_AND_OPEN_SETTINGS);
	filter.addAction(ACTION_CONNECT_TO_RECOMMENDED_NETWORK);
	filter.addAction(ACTION_NOTIFICATION_DELETED);
	filter.addAction(ACTION_PICK_WIFI_NETWORK);
	filter.addAction(ACTION_PICK_WIFI_NETWORK_AFTER_CONNECT_FAILURE);

	mContext.registerReceiver(
	mBroadcastReceiver, filter, null /* broadcastPermission */, mHandler);
	mNotificationEnabledSettingObserver.register();

	handleUserRestrictionsChanged();
	}

	/** Stops {@link WifiNotificationController}. */
	public void stop() {
	if (!mStarted.compareAndSet(true, false)) {
	return;
	}
	mContext.unregisterReceiver(mBroadcastReceiver);
	mNotificationEnabledSettingObserver.unregister();
	}

	private final BroadcastReceiver mBroadcastReceiver =
	new BroadcastReceiver() {
	@Override
	public void onReceive(Context context, Intent intent) {
	try {
	switch (intent.getAction()) {
	case WifiManager.WIFI_STATE_CHANGED_ACTION:
	mWifiState = mWifiManager.getWifiState();
	resetNotification();
	break;
	case WifiManager.NETWORK_STATE_CHANGED_ACTION:
	handleNetworkStateChange(intent);
	break;
	case WifiManager.SCAN_RESULTS_AVAILABLE_ACTION:
	checkAndSetNotification(mNetworkInfo);
	break;
	case RoboCompatUtil.ACTION_USER_RESTRICTIONS_CHANGED:
	handleUserRestrictionsChanged();
	break;
	case ACTION_CONNECT_TO_RECOMMENDED_NETWORK_AND_OPEN_SETTINGS:
	connectToRecommendedNetwork();
	openWifiPicker();
	updateOnConnecting(false /* showNotification*/);
	break;
	case ACTION_CONNECT_TO_RECOMMENDED_NETWORK:
	connectToRecommendedNetwork();
	updateOnConnecting(true /* showNotification*/);
	break;
	case ACTION_NOTIFICATION_DELETED:
	handleNotificationDeleted();
	break;
	case ACTION_PICK_WIFI_NETWORK:
	openWifiPicker();
	break;
	case ACTION_PICK_WIFI_NETWORK_AFTER_CONNECT_FAILURE:
	openWifiPicker();
	break;
	default:
	Blog.e(
	TAG,
	"Unexpected broadcast. [action=%s]",
	intent.getAction());
	}

	} catch (RuntimeException re) {
	// TODO(b/35044022) Remove try/catch after a couple of releases when we are confident
	// this is not going to throw.
	Blog.e(TAG, re, "RuntimeException in broadcast receiver.");
	}
	}
	};

	private void handleNetworkStateChange(Intent intent) {
	mNetworkInfo = intent.getParcelableExtra(WifiManager.EXTRA_NETWORK_INFO);
	NetworkInfo.DetailedState detailedState = mNetworkInfo.getDetailedState();
	if (detailedState != NetworkInfo.DetailedState.SCANNING
	&& detailedState != mDetailedState) {
	mDetailedState = detailedState;
	switch (mDetailedState) {
	case CONNECTED:
	updateOnConnect();
	break;
	case DISCONNECTED:
	case CAPTIVE_PORTAL_CHECK:
	resetNotification();
	break;

	// TODO: figure out if these are failure cases when connecting
	case IDLE:
	case SCANNING:
	case CONNECTING:
	case DISCONNECTING:
	case AUTHENTICATING:
	case OBTAINING_IPADDR:
	case SUSPENDED:
	case FAILED:
	case BLOCKED:
	case VERIFYING_POOR_LINK:
	break;
	}
	}
	}

	private void handleUserRestrictionsChanged() {
	mWifiConfigRestricted = mUserManager.hasUserRestriction(UserManager.DISALLOW_CONFIG_WIFI);
	Blog.v(TAG, "handleUserRestrictionsChanged: %b", mWifiConfigRestricted);
	}

	private void checkAndSetNotification(NetworkInfo networkInfo) {
	// TODO: unregister broadcast so we do not have to check here
	// If we shouldn't place a notification on available networks, then
	// don't bother doing any of the following
	if (!mNotificationEnabled
	\|\| mWifiConfigRestricted
	\|\| mWifiState != WifiManager.WIFI_STATE_ENABLED
	\|\| mState > State.SHOWING_RECOMMENDATION_NOTIFICATION) {
	return;
	}

	NetworkInfo.State state = NetworkInfo.State.DISCONNECTED;
	if (networkInfo != null) {
	state = networkInfo.getState();
	}

	if (state == NetworkInfo.State.DISCONNECTED \|\| state == NetworkInfo.State.UNKNOWN) {
	maybeLogOpenNetworksAvailable();
	RecommendationResult result = getOpenNetworkRecommendation();
	if (result != null && result.getWifiConfiguration() != null) {
	mRecommendedNetwork = result.getWifiConfiguration();

	if (++mNumScansSinceNetworkStateChange >= NUM_SCANS_BEFORE_ACTUALLY_SCANNING) {
	/*
	* We have scanned continuously at least
	* NUM_SCANS_BEFORE_NOTIFICATION times. The user
	* probably does not have a remembered network in range,
	* since otherwise supplicant would have tried to
	* associate and thus resetting this counter.
	*/
	displayNotification();
	}
	return;
	}
	}

	// No open networks in range, remove the notification
	removeNotification();
	}

	private void maybeLogOpenNetworksAvailable() {
	long now = System.currentTimeMillis();
	if (now < mOpenNetworksLoggingRepeatTime) {
	return;
	}
	mOpenNetworksLoggingRepeatTime = now + mNotificationRepeatDelayMs;
	}

	/**
	* Uses {@link NetworkScoreManager} to choose a qualified network out of the list of {@link
	* ScanResult}s.
	*
	* @return returns the best qualified open networks, if any.
	*/
	@Nullable
	private RecommendationResult getOpenNetworkRecommendation() {
	List<ScanResult> scanResults = mWifiManager.getScanResults();
	if (scanResults == null \|\| scanResults.isEmpty()) {
	return null;
	}

	ArrayList<ScanResult> openNetworks = new ArrayList<>();
	List<WifiConfiguration> configuredNetworks = mWifiManager.getConfiguredNetworks();
	for (ScanResult scanResult : scanResults) {
	//A capability of [ESS] represents an open access point
	//that is available for an STA to connect
	//TODO: potentially handle this within NetworkRecommendationProvider instead.
	if ("[ESS]".equals(scanResult.capabilities)) {
	if (isSavedNetwork(scanResult, configuredNetworks)) {
	continue;
	}
	openNetworks.add(scanResult);
	}
	}

	Blog.d(TAG, "Sending RecommendationRequest. [num_open_networks=%d]", openNetworks.size());
	RecommendationRequest request =
	new RecommendationRequest.Builder()
	.setScanResults(openNetworks.toArray(new ScanResult[openNetworks.size()]))
	.build();
	return mNetworkRecommendationProvider.requestRecommendation(request);
	}

	/** Returns true if scanResult matches the list of saved networks */
	private boolean isSavedNetwork(ScanResult scanResult, List<WifiConfiguration> savedNetworks) {
	if (savedNetworks == null) {
	return false;
	}
	for (int i = 0; i < savedNetworks.size(); i++) {
	if (ScanResultUtil.doesScanResultMatchWithNetwork(scanResult, savedNetworks.get(i))) {
	return true;
	}
	}
	return false;
	}

	/** Display's a notification that there are open Wi-Fi networks. */
	private void displayNotification() {
	// Since we use auto cancel on the notification, when the
	// mNetworksAvailableNotificationShown is true, the notification may
	// have actually been canceled. However, when it is false we know
	// for sure that it is not being shown (it will not be shown any other
	// place than here)

	// Not enough time has passed to show the notification again
	if (mState == State.NO_RECOMMENDATION
	&& System.currentTimeMillis() < mNotificationRepeatTime) {
	return;
	}
	Notification notification =
	mWifiNotificationHelper.createMainNotification(mRecommendedNetwork);
	mNotificationRepeatTime = System.currentTimeMillis() + mNotificationRepeatDelayMs;
	postNotification(notification);
	if (mState != State.SHOWING_RECOMMENDATION_NOTIFICATION) {
	mState = State.SHOWING_RECOMMENDATION_NOTIFICATION;
	}
	}

	/** Opens activity to allow the user to select a wifi network. */
	private void openWifiPicker() {
	// Close notification drawer before opening the picker.
	mContext.sendBroadcast(new Intent(Intent.ACTION_CLOSE_SYSTEM_DIALOGS));
	mContext.startActivity(
	new Intent(WifiManager.ACTION_PICK_WIFI_NETWORK)
	.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK));
	removeNotification();
	}

	/** Attempts to connect to recommended network the recommended network. */
	private void connectToRecommendedNetwork() {
	if (mRecommendedNetwork == null) {
	return;
	}
	mRecommendedNetwork.BSSID = null;

	// Attempts to connect to recommended network.
	RoboCompatUtil.getInstance().connectToWifi(mWifiManager, mRecommendedNetwork);
	}

	private void updateOnConnecting(boolean showNotification) {
	if (showNotification) {
	// Update notification to connecting status.
	Notification notification =
	mWifiNotificationHelper.createConnectingNotification(mRecommendedNetwork);
	postNotification(notification);
	mState = State.CONNECTING_IN_NOTIFICATION;
	} else {
	mState = State.CONNECTING_IN_WIFI_PICKER;
	}
	mHandler.postDelayed(
	() -> {
	updateOnFailedToConnect();
	},
	TIME_TO_SHOW_CONNECTING_MILLIS);
	}

	/**
	* When detailed state changes to CONNECTED, show connected notification or reset notification.
	*/
	private void updateOnConnect() {
	if (mState == State.CONNECTING_IN_NOTIFICATION) {
	Notification notification =
	mWifiNotificationHelper.createConnectedNotification(mRecommendedNetwork);
	postNotification(notification);
	mState = State.CONNECTED;
	mHandler.postDelayed(
	() -> {
	if (mState == State.CONNECTED) {
	removeNotification();
	}
	},
	TIME_TO_SHOW_CONNECTED_MILLIS);
	} else if (mState == State.CONNECTING_IN_WIFI_PICKER) {
	removeNotification();
	}
	}

	/**
	* Displays the Failed To Connect notification after the Connecting notification is shown for
	* {@link #TIME_TO_SHOW_CONNECTING_MILLIS} duration.
	*/
	private void updateOnFailedToConnect() {
	if (mState == State.CONNECTING_IN_NOTIFICATION) {
	Notification notification = mWifiNotificationHelper.createFailedToConnectNotification();
	postNotification(notification);
	mState = State.CONNECT_FAILED;
	mHandler.postDelayed(
	() -> {
	if (mState == State.CONNECT_FAILED) {
	removeNotification();
	}
	},
	TIME_TO_SHOW_FAILED_MILLIS);
	} else if (mState == State.CONNECTING_IN_WIFI_PICKER) {
	removeNotification();
	}
	}

	/** Handles behavior when notification is dismissed. */
	private void handleNotificationDeleted() {
	mState = State.NO_RECOMMENDATION;
	mRecommendedNetwork = null;
	}

	private void postNotification(Notification notification) {
	mNotificationManager.notify(NOTIFICATION_TAG, NOTIFICATION_ID, notification);
	}

	/**
	* Clears variables related to tracking whether a notification has been shown recently and
	* clears the current notification.
	*/
	private void resetNotification() {
	if (mState != State.NO_RECOMMENDATION) {
	removeNotification();
	}
	mRecommendedNetwork = null;
	mNotificationRepeatTime = 0;
	mNumScansSinceNetworkStateChange = 0;
	mOpenNetworksLoggingRepeatTime = 0;
	}

	private void removeNotification() {
	mNotificationManager.cancel(NOTIFICATION_TAG, NOTIFICATION_ID);
	mState = State.NO_RECOMMENDATION;
	mRecommendedNetwork = null;
	}

	public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
	pw.println("mNotificationEnabled " + mNotificationEnabled);
	pw.println("mNotificationRepeatTime " + mNotificationRepeatTime);
	pw.println("mState " + mState);
	pw.println("mNumScansSinceNetworkStateChange " + mNumScansSinceNetworkStateChange);
	}

	private class NotificationEnabledSettingObserver extends ContentObserver {
	NotificationEnabledSettingObserver(Handler handler) {
	super(handler);
	}

	public void register() {
	mContentResolver.registerContentObserver(
	Settings.Global.getUriFor(
	Settings.Global.WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON),
	true,
	this);
	mNotificationEnabled = getValue();
	}

	public void unregister() {
	mContentResolver.unregisterContentObserver(this);
	}

	@Override
	public void onChange(boolean selfChange) {
	super.onChange(selfChange);

	mNotificationEnabled = getValue();
	resetNotification();
	}

	private boolean getValue() {
	return Settings.Global.getInt(
	mContentResolver,
	Settings.Global.WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON,
	0)
	== 1;
	}
	}
	}