service/java/com/android/server/wifi/InterfaceConflictManager.java - platform/packages/modules/Wifi - Git at Google

 /*
  * Copyright (C) 2022 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 static com.android.server.wifi.HalDeviceManager.HDM_CREATE_IFACE_AP;
 import static com.android.server.wifi.HalDeviceManager.HDM_CREATE_IFACE_AP_BRIDGE;
 import static com.android.server.wifi.HalDeviceManager.HDM_CREATE_IFACE_NAN;
 import static com.android.server.wifi.HalDeviceManager.HDM_CREATE_IFACE_P2P;
 import static com.android.server.wifi.HalDeviceManager.HDM_CREATE_IFACE_STA;

 import android.annotation.IntDef;
 import android.content.res.Resources;
 import android.net.wifi.WifiContext;
 import android.os.Message;
 import android.os.WorkSource;
 import android.text.TextUtils;
 import android.util.ArraySet;
 import android.util.Log;
 import android.util.Pair;

 import com.android.internal.util.State;
 import com.android.internal.util.StateMachine;
 import com.android.server.wifi.util.WaitingState;
 import com.android.wifi.resources.R;

 import java.io.FileDescriptor;
 import java.io.PrintWriter;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 import java.util.function.Consumer;

 /**
  * Displays dialogs asking the user to approve or reject interface priority decisions.
  */
 public class InterfaceConflictManager {
     private static final String TAG = "InterfaceConflictManager";
     private boolean mVerboseLoggingEnabled = false;

     private final WifiContext mContext;
     private final FrameworkFacade mFrameworkFacade;
     private final HalDeviceManager mHdm;
     private final WifiThreadRunner mThreadRunner;
     private final WifiDialogManager mWifiDialogManager;

     private final Resources mResources;
     private final boolean mUserApprovalNeeded;
     private final Set<String> mUserApprovalExemptedPackages;
     private boolean mUserApprovalNeededOverride = false;
     private boolean mUserApprovalNeededOverrideValue = false;

     private Object mLock = new Object();
     private boolean mUserApprovalPending = false;
     private String mUserApprovalPendingTag = null;
     private boolean mUserJustApproved = false;

     private static final String MESSAGE_BUNDLE_KEY_PENDING_USER = "pending_user_decision";

     public InterfaceConflictManager(WifiContext wifiContext, FrameworkFacade frameworkFacade,
             HalDeviceManager hdm, WifiThreadRunner threadRunner,
             WifiDialogManager wifiDialogManager) {
         mContext = wifiContext;
         mFrameworkFacade = frameworkFacade;
         mHdm = hdm;
         mThreadRunner = threadRunner;
         mWifiDialogManager = wifiDialogManager;

         mResources = mContext.getResources();
         mUserApprovalNeeded = mResources.getBoolean(
                 R.bool.config_wifiUserApprovalRequiredForD2dInterfacePriority);
         String[] packageList = mResources.getStringArray(
                 R.array.config_wifiExcludedFromUserApprovalForD2dInterfacePriority);
         mUserApprovalExemptedPackages =
                 (packageList == null || packageList.length == 0) ? Collections.emptySet()
                         : new ArraySet<>(packageList);
     }

     /**
      * Enable verbose logging.
      */
     public void enableVerboseLogging(boolean verboseEnabled) {
         mVerboseLoggingEnabled = verboseEnabled;
     }

     /**
      * Returns an indication as to whether user approval is needed for this specific request. User
      * approval is controlled by:
      * - A global overlay `config_wifiUserApprovalRequiredForD2dInterfacePriority`
      * - An exemption list overlay `config_wifiExcludedFromUserApprovalForD2dInterfacePriority`
      *   which is a list of packages which are *exempted* from user approval
      * - A shell command which can be used to override
      *
      * @param requestorWs The WorkSource of the requestor - used to determine whether it is exempted
      *                    from user approval. All requesting packages must be exempted for the
      *                    dialog to NOT be displayed.
      */
     private boolean isUserApprovalNeeded(WorkSource requestorWs) {
         if (mUserApprovalNeededOverride) return mUserApprovalNeededOverrideValue;
         if (!mUserApprovalNeeded || mUserApprovalExemptedPackages.isEmpty()) {
             return mUserApprovalNeeded;
         }

         for (int i = 0; i < requestorWs.size(); ++i) {
             if (!mUserApprovalExemptedPackages.contains(requestorWs.getPackageName(i))) {
                 return true;
             }
         }

         return false; // all packages of the requestor are excluded
     }

     /**
      * Override (potentially) the user approval needed device configuration. Intended for debugging
      * via the shell command.
      *
      * @param override      Enable overriding the default.
      * @param overrideValue The actual override value (i.e. disable or enable).
      */
     public void setUserApprovalNeededOverride(boolean override, boolean overrideValue) {
         if (mVerboseLoggingEnabled) {
             Log.d(TAG, "setUserApprovalNeededOverride: override=" + override + ", overrideValue="
                     + overrideValue);
         }
         mUserApprovalNeededOverride = override;
         mUserApprovalNeededOverrideValue = overrideValue;
     }

     /**
      * Return values for {@link #manageInterfaceConflictForStateMachine}
      */

     // Caller should continue and execute command: no need for user approval, or user approval
     // already granted, or command bound to fail so just fail through the normal path
     public static final int ICM_EXECUTE_COMMAND = 0;

     // Caller should skip executing the command for now (do not defer it - already done!). The user
     // was asked for permission and the command will be executed again when we get a response.
     public static final int ICM_SKIP_COMMAND_WAIT_FOR_USER = 1;

     // Caller should abort the command and execute whatever failure code is necessary - this
     // command was rejected by the user or we cannot ask the user since there's a pending user
     // request.
     public static final int ICM_ABORT_COMMAND = 2;

     @Retention(RetentionPolicy.SOURCE)
     @IntDef(prefix = {"ICM_"}, value = {
             ICM_EXECUTE_COMMAND,
             ICM_SKIP_COMMAND_WAIT_FOR_USER,
             ICM_ABORT_COMMAND
     })
     @interface IcmResult {}

     /**
      * Manages interface conflicts for a State Machine based caller. Possible scenarios:
      * - New request:
      *     - ok to proceed inline (i.e. caller can just proceed normally - no conflict)
      *       [nop]
      *     - need to request user approval (there's conflict, caller need to wait for user response)
      *       [msg get tagged + deferred, transition to waiting state]
      * - Previously executed command (i.e. already asked the user)
      *     - user rejected request
      *       [discard request, execute any necessary error callbacks]
      *     - user approved request
      *       [~nop (i.e. proceed)]
      * - Busy asking approval for another request:
      *     - If from another caller: reject
      *     - If from the same caller: defer the caller (possibly will be approved when gets to ask
      *       again).
      *
      * Synchronization:
      * - Multiple threads accessing this method will be blocked until the processing of the other
      *   thread is done. The "processing" is simply the decision making - i.e. not the waiting for
      *   user response.
      * - If a user response is pending then subsequent requests are auto-rejected if they require
      *   user approval. Note that this will result in race condition if this approval changes
      *   the conditions for the user approval request: e.g. it may increase the impact of a user
      *   approval (w/o telling the user) or it may be rejected even if approved by the user (if
      *   the newly allocated interface now has higher priority).
      *
      * @param tag Tag of the caller for logging
      * @param msg The command which needs to be evaluated or executed for user approval
      * @param stateMachine The source state machine
      * @param waitingState The {@link WaitingState} added to the above state machine
      * @param targetState The target state to transition to on user response
      * @param createIfaceType The interface which needs to be created
      * @param requestorWs The requestor WorkSource
      *
      * @return ICM_EXECUTE_COMMAND caller should execute the command,
      * ICM_SKIP_COMMAND_WAIT_FOR_USER caller should skip the command (for now),
      * ICM_ABORT_COMMAND caller should abort this command and execute whatever failure code is
      * necessary.
      */
     public @IcmResult int manageInterfaceConflictForStateMachine(String tag, Message msg,
             StateMachine stateMachine, WaitingState waitingState, State targetState,
             @HalDeviceManager.HdmIfaceTypeForCreation int createIfaceType, WorkSource requestorWs) {
         synchronized (mLock) {
             if (mUserApprovalPending && !TextUtils.equals(tag, mUserApprovalPendingTag)) {
                 Log.w(TAG, tag + ": rejected since there's a pending user approval for "
                         + mUserApprovalPendingTag);
                 return ICM_ABORT_COMMAND; // caller should not proceed with operation
             }

             // is this a command which was waiting for a user decision?
             boolean isReexecutedCommand = msg.getData().getBoolean(
                     MESSAGE_BUNDLE_KEY_PENDING_USER, false);
             if (isReexecutedCommand) {
                 mUserApprovalPending = false;
                 mUserApprovalPendingTag = null;

                 if (mVerboseLoggingEnabled) {
                     Log.d(TAG, tag + ": Re-executing a command with user approval result - "
                             + mUserJustApproved);
                 }
                 return mUserJustApproved ? ICM_EXECUTE_COMMAND : ICM_ABORT_COMMAND;
             }

             if (mUserApprovalPending) {
                 Log.w(TAG, tag
                         + ": trying for another potentially waiting operation - but should be"
                         + " in a waiting state!?");
                 stateMachine.deferMessage(msg);
                 return ICM_SKIP_COMMAND_WAIT_FOR_USER; // same effect
             }

             if (!isUserApprovalNeeded(requestorWs)) return ICM_EXECUTE_COMMAND;

             List<Pair<Integer, WorkSource>> impact = mHdm.reportImpactToCreateIface(createIfaceType,
                     false, requestorWs);
             if (mVerboseLoggingEnabled) {
                 Log.d(TAG, tag + ": Asking user about creating the interface, impact=" + impact);
             }
             if (impact == null || impact.isEmpty()) {
                 Log.d(TAG, tag
                         + ": Either can't create interface or can w/o sid-effects - proceeding");
                 return ICM_EXECUTE_COMMAND;
             }

             displayUserApprovalDialog(createIfaceType, requestorWs, impact,
                     (result) -> {
                         if (mVerboseLoggingEnabled) {
                             Log.d(TAG, tag + ": User response to creating " + getInterfaceName(
                                     createIfaceType) + ": " + result);
                         }
                         mUserJustApproved = result;
                         waitingState.sendTransitionStateCommand(targetState);
                     });
             // defer message to have it executed again automatically when switching
             // states - want to do it now so that it will be at the top of the queue
             // when we switch back. Will need to skip it if the user rejected it!
             msg.getData().putBoolean(MESSAGE_BUNDLE_KEY_PENDING_USER, true);
             stateMachine.deferMessage(msg);
             stateMachine.transitionTo(waitingState);

             mUserApprovalPending = true;
             mUserApprovalPendingTag = tag;

             return ICM_SKIP_COMMAND_WAIT_FOR_USER;
         }
     }

     /**
      * Trigger a dialog which requests user approval to resolve an interface priority confict.
      *
      * @param createIfaceType The interface to be created.
      * @param requestorWs The WorkSource of the requesting application.
      * @param impact The impact of creating this interface (a list of interfaces to be deleted and
      *               their corresponding impacted WorkSources).
      * @param handleResult A Consumer to execute with results.
      */
     private void displayUserApprovalDialog(
             @HalDeviceManager.HdmIfaceTypeForCreation int createIfaceType,
             WorkSource requestorWs,
             List<Pair<Integer, WorkSource>> impact,
             Consumer<Boolean> handleResult) {
         if (mVerboseLoggingEnabled) {
             Log.d(TAG, "displayUserApprovalDialog: createIfaceType=" + createIfaceType
                     + ", requestorWs=" + requestorWs + ", impact=" + impact);
         }

         CharSequence requestorAppName = mFrameworkFacade.getAppName(mContext,
                 requestorWs.getPackageName(0), requestorWs.getUid(0));
         String requestedInterface = getInterfaceName(createIfaceType);
         Set<String> impactedPackagesSet = new HashSet<>();
         for (Pair<Integer, WorkSource> detail : impact) {
             for (int j = 0; j < detail.second.size(); ++j) {
                 impactedPackagesSet.add(
                         mFrameworkFacade.getAppName(mContext, detail.second.getPackageName(j),
                                 detail.second.getUid(j)).toString());
             }
         }
         String impactedPackages = TextUtils.join(", ", impactedPackagesSet);

         mWifiDialogManager.createSimpleDialog(
                 mResources.getString(R.string.wifi_interface_priority_title, requestorAppName),
                 impactedPackagesSet.size() == 1 ? mResources.getString(
                         R.string.wifi_interface_priority_message, requestorAppName,
                         requestedInterface, impactedPackages)
                         : mResources.getString(R.string.wifi_interface_priority_message_plural,
                                 requestorAppName, requestedInterface, impactedPackages),
                 mResources.getString(R.string.wifi_interface_priority_approve),
                 mResources.getString(R.string.wifi_interface_priority_reject),
                 null,
                 new WifiDialogManager.SimpleDialogCallback() {
                     @Override
                     public void onPositiveButtonClicked() {
                         if (mVerboseLoggingEnabled) {
                             Log.d(TAG, "User approved request for " + getInterfaceName(
                                     createIfaceType));
                         }
                         handleResult.accept(true);
                     }

                     @Override
                     public void onNegativeButtonClicked() {
                         if (mVerboseLoggingEnabled) {
                             Log.d(TAG, "User rejected request for " + getInterfaceName(
                                     createIfaceType));
                         }
                         handleResult.accept(false);
                     }

                     @Override
                     public void onNeutralButtonClicked() {
                         onNegativeButtonClicked();
                     }

                     @Override
                     public void onCancelled() {
                         onNegativeButtonClicked();
                     }
                 }, mThreadRunner).launchDialog();
     }

     private String getInterfaceName(@HalDeviceManager.HdmIfaceTypeForCreation int createIfaceType) {
         switch (createIfaceType) {
             case HDM_CREATE_IFACE_STA:
                 return "STA";
             case HDM_CREATE_IFACE_AP:
                 return "AP";
             case HDM_CREATE_IFACE_AP_BRIDGE:
                 return "AP";
             case HDM_CREATE_IFACE_P2P:
                 return "Wi-Fi Direct";
             case HDM_CREATE_IFACE_NAN:
                 return "Wi-Fi Aware";
         }
         return "Unknown";
     }

     /**
      * Dump the internal state of the class.
      */
     public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
         pw.println("dump of " + TAG + ":");
         pw.println("  mUserApprovalNeeded=" + mUserApprovalNeeded);
         pw.println("  mUserApprovalNeededOverride=" + mUserApprovalNeededOverride);
         pw.println("  mUserApprovalNeededOverrideValue=" + mUserApprovalNeededOverrideValue);
         pw.println("  mUserApprovalPending=" + mUserApprovalPending);
         pw.println("  mUserApprovalPendingTag=" + mUserApprovalPendingTag);
         pw.println("  mUserJustApproved=" + mUserJustApproved);
     }
 }
	/*
	* Copyright (C) 2022 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 static com.android.server.wifi.HalDeviceManager.HDM_CREATE_IFACE_AP;
	import static com.android.server.wifi.HalDeviceManager.HDM_CREATE_IFACE_AP_BRIDGE;
	import static com.android.server.wifi.HalDeviceManager.HDM_CREATE_IFACE_NAN;
	import static com.android.server.wifi.HalDeviceManager.HDM_CREATE_IFACE_P2P;
	import static com.android.server.wifi.HalDeviceManager.HDM_CREATE_IFACE_STA;

	import android.annotation.IntDef;
	import android.content.res.Resources;
	import android.net.wifi.WifiContext;
	import android.os.Message;
	import android.os.WorkSource;
	import android.text.TextUtils;
	import android.util.ArraySet;
	import android.util.Log;
	import android.util.Pair;

	import com.android.internal.util.State;
	import com.android.internal.util.StateMachine;
	import com.android.server.wifi.util.WaitingState;
	import com.android.wifi.resources.R;

	import java.io.FileDescriptor;
	import java.io.PrintWriter;
	import java.lang.annotation.Retention;
	import java.lang.annotation.RetentionPolicy;
	import java.util.Collections;
	import java.util.HashSet;
	import java.util.List;
	import java.util.Set;
	import java.util.function.Consumer;

	/**
	* Displays dialogs asking the user to approve or reject interface priority decisions.
	*/
	public class InterfaceConflictManager {
	private static final String TAG = "InterfaceConflictManager";
	private boolean mVerboseLoggingEnabled = false;

	private final WifiContext mContext;
	private final FrameworkFacade mFrameworkFacade;
	private final HalDeviceManager mHdm;
	private final WifiThreadRunner mThreadRunner;
	private final WifiDialogManager mWifiDialogManager;

	private final Resources mResources;
	private final boolean mUserApprovalNeeded;
	private final Set<String> mUserApprovalExemptedPackages;
	private boolean mUserApprovalNeededOverride = false;
	private boolean mUserApprovalNeededOverrideValue = false;

	private Object mLock = new Object();
	private boolean mUserApprovalPending = false;
	private String mUserApprovalPendingTag = null;
	private boolean mUserJustApproved = false;

	private static final String MESSAGE_BUNDLE_KEY_PENDING_USER = "pending_user_decision";

	public InterfaceConflictManager(WifiContext wifiContext, FrameworkFacade frameworkFacade,
	HalDeviceManager hdm, WifiThreadRunner threadRunner,
	WifiDialogManager wifiDialogManager) {
	mContext = wifiContext;
	mFrameworkFacade = frameworkFacade;
	mHdm = hdm;
	mThreadRunner = threadRunner;
	mWifiDialogManager = wifiDialogManager;

	mResources = mContext.getResources();
	mUserApprovalNeeded = mResources.getBoolean(
	R.bool.config_wifiUserApprovalRequiredForD2dInterfacePriority);
	String[] packageList = mResources.getStringArray(
	R.array.config_wifiExcludedFromUserApprovalForD2dInterfacePriority);
	mUserApprovalExemptedPackages =
	(packageList == null \|\| packageList.length == 0) ? Collections.emptySet()
	: new ArraySet<>(packageList);
	}

	/**
	* Enable verbose logging.
	*/
	public void enableVerboseLogging(boolean verboseEnabled) {
	mVerboseLoggingEnabled = verboseEnabled;
	}

	/**
	* Returns an indication as to whether user approval is needed for this specific request. User
	* approval is controlled by:
	* - A global overlay `config_wifiUserApprovalRequiredForD2dInterfacePriority`
	* - An exemption list overlay `config_wifiExcludedFromUserApprovalForD2dInterfacePriority`
	* which is a list of packages which are exempted from user approval
	* - A shell command which can be used to override
	*
	* @param requestorWs The WorkSource of the requestor - used to determine whether it is exempted
	* from user approval. All requesting packages must be exempted for the
	* dialog to NOT be displayed.
	*/
	private boolean isUserApprovalNeeded(WorkSource requestorWs) {
	if (mUserApprovalNeededOverride) return mUserApprovalNeededOverrideValue;
	if (!mUserApprovalNeeded \|\| mUserApprovalExemptedPackages.isEmpty()) {
	return mUserApprovalNeeded;
	}

	for (int i = 0; i < requestorWs.size(); ++i) {
	if (!mUserApprovalExemptedPackages.contains(requestorWs.getPackageName(i))) {
	return true;
	}
	}

	return false; // all packages of the requestor are excluded
	}

	/**
	* Override (potentially) the user approval needed device configuration. Intended for debugging
	* via the shell command.
	*
	* @param override Enable overriding the default.
	* @param overrideValue The actual override value (i.e. disable or enable).
	*/
	public void setUserApprovalNeededOverride(boolean override, boolean overrideValue) {
	if (mVerboseLoggingEnabled) {
	Log.d(TAG, "setUserApprovalNeededOverride: override=" + override + ", overrideValue="
	+ overrideValue);
	}
	mUserApprovalNeededOverride = override;
	mUserApprovalNeededOverrideValue = overrideValue;
	}

	/**
	* Return values for {@link #manageInterfaceConflictForStateMachine}
	*/

	// Caller should continue and execute command: no need for user approval, or user approval
	// already granted, or command bound to fail so just fail through the normal path
	public static final int ICM_EXECUTE_COMMAND = 0;

	// Caller should skip executing the command for now (do not defer it - already done!). The user
	// was asked for permission and the command will be executed again when we get a response.
	public static final int ICM_SKIP_COMMAND_WAIT_FOR_USER = 1;

	// Caller should abort the command and execute whatever failure code is necessary - this
	// command was rejected by the user or we cannot ask the user since there's a pending user
	// request.
	public static final int ICM_ABORT_COMMAND = 2;

	@Retention(RetentionPolicy.SOURCE)
	@IntDef(prefix = {"ICM_"}, value = {
	ICM_EXECUTE_COMMAND,
	ICM_SKIP_COMMAND_WAIT_FOR_USER,
	ICM_ABORT_COMMAND
	})
	@interface IcmResult {}

	/**
	* Manages interface conflicts for a State Machine based caller. Possible scenarios:
	* - New request:
	* - ok to proceed inline (i.e. caller can just proceed normally - no conflict)
	* [nop]
	* - need to request user approval (there's conflict, caller need to wait for user response)
	* [msg get tagged + deferred, transition to waiting state]
	* - Previously executed command (i.e. already asked the user)
	* - user rejected request
	* [discard request, execute any necessary error callbacks]
	* - user approved request
	* [~nop (i.e. proceed)]
	* - Busy asking approval for another request:
	* - If from another caller: reject
	* - If from the same caller: defer the caller (possibly will be approved when gets to ask
	* again).
	*
	* Synchronization:
	* - Multiple threads accessing this method will be blocked until the processing of the other
	* thread is done. The "processing" is simply the decision making - i.e. not the waiting for
	* user response.
	* - If a user response is pending then subsequent requests are auto-rejected if they require
	* user approval. Note that this will result in race condition if this approval changes
	* the conditions for the user approval request: e.g. it may increase the impact of a user
	* approval (w/o telling the user) or it may be rejected even if approved by the user (if
	* the newly allocated interface now has higher priority).
	*
	* @param tag Tag of the caller for logging
	* @param msg The command which needs to be evaluated or executed for user approval
	* @param stateMachine The source state machine
	* @param waitingState The {@link WaitingState} added to the above state machine
	* @param targetState The target state to transition to on user response
	* @param createIfaceType The interface which needs to be created
	* @param requestorWs The requestor WorkSource
	*
	* @return ICM_EXECUTE_COMMAND caller should execute the command,
	* ICM_SKIP_COMMAND_WAIT_FOR_USER caller should skip the command (for now),
	* ICM_ABORT_COMMAND caller should abort this command and execute whatever failure code is
	* necessary.
	*/
	public @IcmResult int manageInterfaceConflictForStateMachine(String tag, Message msg,
	StateMachine stateMachine, WaitingState waitingState, State targetState,
	@HalDeviceManager.HdmIfaceTypeForCreation int createIfaceType, WorkSource requestorWs) {
	synchronized (mLock) {
	if (mUserApprovalPending && !TextUtils.equals(tag, mUserApprovalPendingTag)) {
	Log.w(TAG, tag + ": rejected since there's a pending user approval for "
	+ mUserApprovalPendingTag);
	return ICM_ABORT_COMMAND; // caller should not proceed with operation
	}

	// is this a command which was waiting for a user decision?
	boolean isReexecutedCommand = msg.getData().getBoolean(
	MESSAGE_BUNDLE_KEY_PENDING_USER, false);
	if (isReexecutedCommand) {
	mUserApprovalPending = false;
	mUserApprovalPendingTag = null;

	if (mVerboseLoggingEnabled) {
	Log.d(TAG, tag + ": Re-executing a command with user approval result - "
	+ mUserJustApproved);
	}
	return mUserJustApproved ? ICM_EXECUTE_COMMAND : ICM_ABORT_COMMAND;
	}

	if (mUserApprovalPending) {
	Log.w(TAG, tag
	+ ": trying for another potentially waiting operation - but should be"
	+ " in a waiting state!?");
	stateMachine.deferMessage(msg);
	return ICM_SKIP_COMMAND_WAIT_FOR_USER; // same effect
	}

	if (!isUserApprovalNeeded(requestorWs)) return ICM_EXECUTE_COMMAND;

	List<Pair<Integer, WorkSource>> impact = mHdm.reportImpactToCreateIface(createIfaceType,
	false, requestorWs);
	if (mVerboseLoggingEnabled) {
	Log.d(TAG, tag + ": Asking user about creating the interface, impact=" + impact);
	}
	if (impact == null \|\| impact.isEmpty()) {
	Log.d(TAG, tag
	+ ": Either can't create interface or can w/o sid-effects - proceeding");
	return ICM_EXECUTE_COMMAND;
	}

	displayUserApprovalDialog(createIfaceType, requestorWs, impact,
	(result) -> {
	if (mVerboseLoggingEnabled) {
	Log.d(TAG, tag + ": User response to creating " + getInterfaceName(
	createIfaceType) + ": " + result);
	}
	mUserJustApproved = result;
	waitingState.sendTransitionStateCommand(targetState);
	});
	// defer message to have it executed again automatically when switching
	// states - want to do it now so that it will be at the top of the queue
	// when we switch back. Will need to skip it if the user rejected it!
	msg.getData().putBoolean(MESSAGE_BUNDLE_KEY_PENDING_USER, true);
	stateMachine.deferMessage(msg);
	stateMachine.transitionTo(waitingState);

	mUserApprovalPending = true;
	mUserApprovalPendingTag = tag;

	return ICM_SKIP_COMMAND_WAIT_FOR_USER;
	}
	}

	/**
	* Trigger a dialog which requests user approval to resolve an interface priority confict.
	*
	* @param createIfaceType The interface to be created.
	* @param requestorWs The WorkSource of the requesting application.
	* @param impact The impact of creating this interface (a list of interfaces to be deleted and
	* their corresponding impacted WorkSources).
	* @param handleResult A Consumer to execute with results.
	*/
	private void displayUserApprovalDialog(
	@HalDeviceManager.HdmIfaceTypeForCreation int createIfaceType,
	WorkSource requestorWs,
	List<Pair<Integer, WorkSource>> impact,
	Consumer<Boolean> handleResult) {
	if (mVerboseLoggingEnabled) {
	Log.d(TAG, "displayUserApprovalDialog: createIfaceType=" + createIfaceType
	+ ", requestorWs=" + requestorWs + ", impact=" + impact);
	}

	CharSequence requestorAppName = mFrameworkFacade.getAppName(mContext,
	requestorWs.getPackageName(0), requestorWs.getUid(0));
	String requestedInterface = getInterfaceName(createIfaceType);
	Set<String> impactedPackagesSet = new HashSet<>();
	for (Pair<Integer, WorkSource> detail : impact) {
	for (int j = 0; j < detail.second.size(); ++j) {
	impactedPackagesSet.add(
	mFrameworkFacade.getAppName(mContext, detail.second.getPackageName(j),
	detail.second.getUid(j)).toString());
	}
	}
	String impactedPackages = TextUtils.join(", ", impactedPackagesSet);

	mWifiDialogManager.createSimpleDialog(
	mResources.getString(R.string.wifi_interface_priority_title, requestorAppName),
	impactedPackagesSet.size() == 1 ? mResources.getString(
	R.string.wifi_interface_priority_message, requestorAppName,
	requestedInterface, impactedPackages)
	: mResources.getString(R.string.wifi_interface_priority_message_plural,
	requestorAppName, requestedInterface, impactedPackages),
	mResources.getString(R.string.wifi_interface_priority_approve),
	mResources.getString(R.string.wifi_interface_priority_reject),
	null,
	new WifiDialogManager.SimpleDialogCallback() {
	@Override
	public void onPositiveButtonClicked() {
	if (mVerboseLoggingEnabled) {
	Log.d(TAG, "User approved request for " + getInterfaceName(
	createIfaceType));
	}
	handleResult.accept(true);
	}

	@Override
	public void onNegativeButtonClicked() {
	if (mVerboseLoggingEnabled) {
	Log.d(TAG, "User rejected request for " + getInterfaceName(
	createIfaceType));
	}
	handleResult.accept(false);
	}

	@Override
	public void onNeutralButtonClicked() {
	onNegativeButtonClicked();
	}

	@Override
	public void onCancelled() {
	onNegativeButtonClicked();
	}
	}, mThreadRunner).launchDialog();
	}

	private String getInterfaceName(@HalDeviceManager.HdmIfaceTypeForCreation int createIfaceType) {
	switch (createIfaceType) {
	case HDM_CREATE_IFACE_STA:
	return "STA";
	case HDM_CREATE_IFACE_AP:
	return "AP";
	case HDM_CREATE_IFACE_AP_BRIDGE:
	return "AP";
	case HDM_CREATE_IFACE_P2P:
	return "Wi-Fi Direct";
	case HDM_CREATE_IFACE_NAN:
	return "Wi-Fi Aware";
	}
	return "Unknown";
	}

	/**
	* Dump the internal state of the class.
	*/
	public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
	pw.println("dump of " + TAG + ":");
	pw.println(" mUserApprovalNeeded=" + mUserApprovalNeeded);
	pw.println(" mUserApprovalNeededOverride=" + mUserApprovalNeededOverride);
	pw.println(" mUserApprovalNeededOverrideValue=" + mUserApprovalNeededOverrideValue);
	pw.println(" mUserApprovalPending=" + mUserApprovalPending);
	pw.println(" mUserApprovalPendingTag=" + mUserApprovalPendingTag);
	pw.println(" mUserJustApproved=" + mUserJustApproved);
	}
	}