687 lines
27 KiB
Java
687 lines
27 KiB
Java
|
/*
|
||
|
|
* 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 android.app.ActivityOptions;
|
||
|
|
import android.content.Intent;
|
||
|
|
import android.net.wifi.WifiContext;
|
||
|
|
import android.net.wifi.WifiManager;
|
||
|
|
import android.os.UserHandle;
|
||
|
|
import android.util.ArraySet;
|
||
|
|
import android.util.Log;
|
||
|
|
import android.util.SparseArray;
|
||
|
|
import android.view.Display;
|
||
|
|
|
||
|
|
import androidx.annotation.AnyThread;
|
||
|
|
import androidx.annotation.NonNull;
|
||
|
|
import androidx.annotation.Nullable;
|
||
|
|
import androidx.annotation.VisibleForTesting;
|
||
|
|
|
||
|
|
import com.android.modules.utils.build.SdkLevel;
|
||
|
|
|
||
|
|
import java.util.Set;
|
||
|
|
|
||
|
|
import javax.annotation.concurrent.ThreadSafe;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Class to manage launching dialogs via WifiDialog and returning the user reply.
|
||
|
|
* All methods run on the main Wi-Fi thread runner except those annotated with @AnyThread, which can
|
||
|
|
* run on any thread.
|
||
|
|
*/
|
||
|
|
public class WifiDialogManager {
|
||
|
|
private static final String TAG = "WifiDialogManager";
|
||
|
|
@VisibleForTesting
|
||
|
|
static final String WIFI_DIALOG_ACTIVITY_CLASSNAME =
|
||
|
|
"com.android.wifi.dialog.WifiDialogActivity";
|
||
|
|
|
||
|
|
private boolean mVerboseLoggingEnabled;
|
||
|
|
|
||
|
|
private int mNextDialogId = 0;
|
||
|
|
private final Set<Integer> mActiveDialogIds = new ArraySet<>();
|
||
|
|
private final @NonNull SparseArray<DialogHandleInternal> mActiveDialogHandles =
|
||
|
|
new SparseArray<>();
|
||
|
|
|
||
|
|
private final @NonNull WifiContext mContext;
|
||
|
|
private final @NonNull WifiThreadRunner mWifiThreadRunner;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Constructs a WifiDialogManager
|
||
|
|
*
|
||
|
|
* @param context Main Wi-Fi context.
|
||
|
|
* @param wifiThreadRunner Main Wi-Fi thread runner.
|
||
|
|
*/
|
||
|
|
public WifiDialogManager(
|
||
|
|
@NonNull WifiContext context,
|
||
|
|
@NonNull WifiThreadRunner wifiThreadRunner) {
|
||
|
|
mContext = context;
|
||
|
|
mWifiThreadRunner = wifiThreadRunner;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Enables verbose logging.
|
||
|
|
*/
|
||
|
|
public void enableVerboseLogging(boolean enabled) {
|
||
|
|
mVerboseLoggingEnabled = enabled;
|
||
|
|
}
|
||
|
|
|
||
|
|
private int getNextDialogId() {
|
||
|
|
if (mActiveDialogIds.isEmpty() || mNextDialogId == WifiManager.INVALID_DIALOG_ID) {
|
||
|
|
mNextDialogId = 0;
|
||
|
|
}
|
||
|
|
return mNextDialogId++;
|
||
|
|
}
|
||
|
|
|
||
|
|
private @Nullable Intent getBaseLaunchIntent(@WifiManager.DialogType int dialogType) {
|
||
|
|
Intent intent = new Intent(WifiManager.ACTION_LAUNCH_DIALOG)
|
||
|
|
.putExtra(WifiManager.EXTRA_DIALOG_TYPE, dialogType)
|
||
|
|
.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
|
||
|
|
String wifiDialogApkPkgName = mContext.getWifiDialogApkPkgName();
|
||
|
|
if (wifiDialogApkPkgName == null) {
|
||
|
|
Log.w(TAG, "Could not get WifiDialog APK package name!");
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
intent.setClassName(wifiDialogApkPkgName, WIFI_DIALOG_ACTIVITY_CLASSNAME);
|
||
|
|
return intent;
|
||
|
|
}
|
||
|
|
|
||
|
|
private @Nullable Intent getDismissIntent(int dialogId) {
|
||
|
|
Intent intent = new Intent(WifiManager.ACTION_DISMISS_DIALOG);
|
||
|
|
intent.putExtra(WifiManager.EXTRA_DIALOG_ID, dialogId);
|
||
|
|
String wifiDialogApkPkgName = mContext.getWifiDialogApkPkgName();
|
||
|
|
if (wifiDialogApkPkgName == null) {
|
||
|
|
Log.w(TAG, "Could not get WifiDialog APK package name!");
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
intent.setClassName(wifiDialogApkPkgName, WIFI_DIALOG_ACTIVITY_CLASSNAME);
|
||
|
|
return intent;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Handle for launching and dismissing a dialog from any thread.
|
||
|
|
*/
|
||
|
|
@ThreadSafe
|
||
|
|
public class DialogHandle {
|
||
|
|
DialogHandleInternal mInternalHandle;
|
||
|
|
private DialogHandle(DialogHandleInternal internalHandle) {
|
||
|
|
mInternalHandle = internalHandle;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Launches the dialog.
|
||
|
|
*/
|
||
|
|
@AnyThread
|
||
|
|
public void launchDialog() {
|
||
|
|
mWifiThreadRunner.post(() -> mInternalHandle.launchDialog(0));
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Launches the dialog with a timeout before it is auto-cancelled.
|
||
|
|
* @param timeoutMs timeout in milliseconds before the dialog is auto-cancelled. A value <=0
|
||
|
|
* indicates no timeout.
|
||
|
|
*/
|
||
|
|
@AnyThread
|
||
|
|
public void launchDialog(long timeoutMs) {
|
||
|
|
mWifiThreadRunner.post(() -> mInternalHandle.launchDialog(timeoutMs));
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Dismisses the dialog. Dialogs will automatically be dismissed once the user replies, but
|
||
|
|
* this method may be used to dismiss unanswered dialogs that are no longer needed.
|
||
|
|
*/
|
||
|
|
@AnyThread
|
||
|
|
public void dismissDialog() {
|
||
|
|
mWifiThreadRunner.post(() -> mInternalHandle.dismissDialog());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Internal handle for launching and dismissing a dialog on the main Wi-Fi thread runner.
|
||
|
|
* @see {@link DialogHandle}
|
||
|
|
*/
|
||
|
|
private class DialogHandleInternal {
|
||
|
|
private int mDialogId = WifiManager.INVALID_DIALOG_ID;
|
||
|
|
private final @NonNull Intent mIntent;
|
||
|
|
private Runnable mTimeoutRunnable;
|
||
|
|
private final int mDisplayId;
|
||
|
|
|
||
|
|
DialogHandleInternal(@NonNull Intent intent, int displayId)
|
||
|
|
throws IllegalArgumentException {
|
||
|
|
if (intent == null) {
|
||
|
|
throw new IllegalArgumentException("Intent cannot be null!");
|
||
|
|
}
|
||
|
|
mDisplayId = displayId;
|
||
|
|
mIntent = intent;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @see {@link DialogHandle#launchDialog(long)}
|
||
|
|
*/
|
||
|
|
void launchDialog(long timeoutMs) {
|
||
|
|
if (mDialogId != WifiManager.INVALID_DIALOG_ID) {
|
||
|
|
// Dialog is already active, ignore.
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
registerDialog();
|
||
|
|
mIntent.putExtra(WifiManager.EXTRA_DIALOG_ID, mDialogId);
|
||
|
|
boolean launched = false;
|
||
|
|
if (SdkLevel.isAtLeastT() && mDisplayId != Display.DEFAULT_DISPLAY) {
|
||
|
|
try {
|
||
|
|
mContext.startActivityAsUser(mIntent,
|
||
|
|
ActivityOptions.makeBasic().setLaunchDisplayId(mDisplayId).toBundle(),
|
||
|
|
UserHandle.CURRENT);
|
||
|
|
launched = true;
|
||
|
|
} catch (Exception e) {
|
||
|
|
Log.e(TAG, "Error startActivityAsUser - " + e);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (!launched) {
|
||
|
|
mContext.startActivityAsUser(mIntent, UserHandle.CURRENT);
|
||
|
|
}
|
||
|
|
if (mVerboseLoggingEnabled) {
|
||
|
|
Log.v(TAG, "Launching dialog with id=" + mDialogId);
|
||
|
|
}
|
||
|
|
if (timeoutMs > 0) {
|
||
|
|
mTimeoutRunnable = () -> onTimeout();
|
||
|
|
mWifiThreadRunner.postDelayed(mTimeoutRunnable, timeoutMs);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Callback to run when the dialog times out.
|
||
|
|
*/
|
||
|
|
void onTimeout() {
|
||
|
|
dismissDialog();
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @see {@link DialogHandle#dismissDialog()}
|
||
|
|
*/
|
||
|
|
void dismissDialog() {
|
||
|
|
if (mDialogId == WifiManager.INVALID_DIALOG_ID) {
|
||
|
|
// Dialog is not active, ignore.
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
Intent dismissIntent = getDismissIntent(mDialogId);
|
||
|
|
if (dismissIntent == null) {
|
||
|
|
Log.e(TAG, "Could not create intent for dismissing dialog with id: "
|
||
|
|
+ mDialogId);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
mContext.startActivityAsUser(dismissIntent, UserHandle.CURRENT);
|
||
|
|
if (mVerboseLoggingEnabled) {
|
||
|
|
Log.v(TAG, "Dismissing dialog with id=" + mDialogId);
|
||
|
|
}
|
||
|
|
unregisterDialog();
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Assigns a dialog id to the dialog and registers it as an active dialog.
|
||
|
|
*/
|
||
|
|
void registerDialog() {
|
||
|
|
if (mDialogId != WifiManager.INVALID_DIALOG_ID) {
|
||
|
|
// Already registered.
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
mDialogId = getNextDialogId();
|
||
|
|
mActiveDialogIds.add(mDialogId);
|
||
|
|
mActiveDialogHandles.put(mDialogId, this);
|
||
|
|
if (mVerboseLoggingEnabled) {
|
||
|
|
Log.v(TAG, "Registered dialog with id=" + mDialogId);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Unregisters the dialog as an active dialog and removes its dialog id.
|
||
|
|
* This should be called after a dialog is replied to or dismissed.
|
||
|
|
*/
|
||
|
|
void unregisterDialog() {
|
||
|
|
if (mDialogId == WifiManager.INVALID_DIALOG_ID) {
|
||
|
|
// Already unregistered.
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (mTimeoutRunnable != null) {
|
||
|
|
mWifiThreadRunner.removeCallbacks(mTimeoutRunnable);
|
||
|
|
}
|
||
|
|
mTimeoutRunnable = null;
|
||
|
|
mActiveDialogIds.remove(mDialogId);
|
||
|
|
mActiveDialogHandles.remove(mDialogId);
|
||
|
|
mDialogId = WifiManager.INVALID_DIALOG_ID;
|
||
|
|
if (mVerboseLoggingEnabled) {
|
||
|
|
Log.v(TAG, "Unregistered dialog with id=" + mDialogId);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private class SimpleDialogHandle extends DialogHandleInternal {
|
||
|
|
private @NonNull SimpleDialogCallback mCallback;
|
||
|
|
private @NonNull WifiThreadRunner mCallbackThreadRunner;
|
||
|
|
|
||
|
|
SimpleDialogHandle(
|
||
|
|
final String title,
|
||
|
|
final String message,
|
||
|
|
final String messageUrl,
|
||
|
|
final int messageUrlStart,
|
||
|
|
final int messageUrlEnd,
|
||
|
|
final String positiveButtonText,
|
||
|
|
final String negativeButtonText,
|
||
|
|
final String neutralButtonText,
|
||
|
|
@NonNull SimpleDialogCallback callback,
|
||
|
|
@NonNull WifiThreadRunner callbackThreadRunner) throws IllegalArgumentException {
|
||
|
|
super(getBaseLaunchIntent(WifiManager.DIALOG_TYPE_SIMPLE)
|
||
|
|
.putExtra(WifiManager.EXTRA_DIALOG_TITLE, title)
|
||
|
|
.putExtra(WifiManager.EXTRA_DIALOG_MESSAGE, message)
|
||
|
|
.putExtra(WifiManager.EXTRA_DIALOG_MESSAGE_URL, messageUrl)
|
||
|
|
.putExtra(WifiManager.EXTRA_DIALOG_MESSAGE_URL_START, messageUrlStart)
|
||
|
|
.putExtra(WifiManager.EXTRA_DIALOG_MESSAGE_URL_END, messageUrlEnd)
|
||
|
|
.putExtra(WifiManager.EXTRA_DIALOG_POSITIVE_BUTTON_TEXT, positiveButtonText)
|
||
|
|
.putExtra(WifiManager.EXTRA_DIALOG_NEGATIVE_BUTTON_TEXT, negativeButtonText)
|
||
|
|
.putExtra(WifiManager.EXTRA_DIALOG_NEUTRAL_BUTTON_TEXT, neutralButtonText),
|
||
|
|
Display.DEFAULT_DISPLAY);
|
||
|
|
if (messageUrl != null) {
|
||
|
|
if (message == null) {
|
||
|
|
throw new IllegalArgumentException("Cannot set span for null message!");
|
||
|
|
}
|
||
|
|
if (messageUrlStart < 0) {
|
||
|
|
throw new IllegalArgumentException("Span start cannot be less than 0!");
|
||
|
|
}
|
||
|
|
if (messageUrlEnd > message.length()) {
|
||
|
|
throw new IllegalArgumentException("Span end index " + messageUrlEnd
|
||
|
|
+ " cannot be greater than message length " + message.length() + "!");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (callback == null) {
|
||
|
|
throw new IllegalArgumentException("Callback cannot be null!");
|
||
|
|
}
|
||
|
|
if (callbackThreadRunner == null) {
|
||
|
|
throw new IllegalArgumentException("Callback thread runner cannot be null!");
|
||
|
|
}
|
||
|
|
mCallback = callback;
|
||
|
|
mCallbackThreadRunner = callbackThreadRunner;
|
||
|
|
}
|
||
|
|
|
||
|
|
void notifyOnPositiveButtonClicked() {
|
||
|
|
mCallbackThreadRunner.post(() -> mCallback.onPositiveButtonClicked());
|
||
|
|
unregisterDialog();
|
||
|
|
}
|
||
|
|
|
||
|
|
void notifyOnNegativeButtonClicked() {
|
||
|
|
mCallbackThreadRunner.post(() -> mCallback.onNegativeButtonClicked());
|
||
|
|
unregisterDialog();
|
||
|
|
}
|
||
|
|
|
||
|
|
void notifyOnNeutralButtonClicked() {
|
||
|
|
mCallbackThreadRunner.post(() -> mCallback.onNeutralButtonClicked());
|
||
|
|
unregisterDialog();
|
||
|
|
}
|
||
|
|
|
||
|
|
void notifyOnCancelled() {
|
||
|
|
mCallbackThreadRunner.post(() -> mCallback.onCancelled());
|
||
|
|
unregisterDialog();
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
void onTimeout() {
|
||
|
|
dismissDialog();
|
||
|
|
notifyOnCancelled();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Callback for receiving simple dialog responses.
|
||
|
|
*/
|
||
|
|
public interface SimpleDialogCallback {
|
||
|
|
/**
|
||
|
|
* The positive button was clicked.
|
||
|
|
*/
|
||
|
|
void onPositiveButtonClicked();
|
||
|
|
|
||
|
|
/**
|
||
|
|
* The negative button was clicked.
|
||
|
|
*/
|
||
|
|
void onNegativeButtonClicked();
|
||
|
|
|
||
|
|
/**
|
||
|
|
* The neutral button was clicked.
|
||
|
|
*/
|
||
|
|
void onNeutralButtonClicked();
|
||
|
|
|
||
|
|
/**
|
||
|
|
* The dialog was cancelled (back button or home button or timeout).
|
||
|
|
*/
|
||
|
|
void onCancelled();
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Creates a simple dialog with optional title, message, and positive/negative/neutral buttons.
|
||
|
|
*
|
||
|
|
* @param title Title of the dialog.
|
||
|
|
* @param message Message of the dialog.
|
||
|
|
* @param positiveButtonText Text of the positive button or {@code null} for no button.
|
||
|
|
* @param negativeButtonText Text of the negative button or {@code null} for no button.
|
||
|
|
* @param neutralButtonText Text of the neutral button or {@code null} for no button.
|
||
|
|
* @param callback Callback to receive the dialog response.
|
||
|
|
* @param callbackThreadRunner WifiThreadRunner to run the callback on.
|
||
|
|
* @return DialogHandle Handle for the dialog, or {@code null} if no dialog could
|
||
|
|
* be created.
|
||
|
|
*/
|
||
|
|
@AnyThread
|
||
|
|
@Nullable
|
||
|
|
public DialogHandle createSimpleDialog(
|
||
|
|
@Nullable String title,
|
||
|
|
@Nullable String message,
|
||
|
|
@Nullable String positiveButtonText,
|
||
|
|
@Nullable String negativeButtonText,
|
||
|
|
@Nullable String neutralButtonText,
|
||
|
|
@NonNull SimpleDialogCallback callback,
|
||
|
|
@NonNull WifiThreadRunner callbackThreadRunner) {
|
||
|
|
try {
|
||
|
|
return new DialogHandle(
|
||
|
|
new SimpleDialogHandle(
|
||
|
|
title,
|
||
|
|
message,
|
||
|
|
null /* messageUrl */,
|
||
|
|
0 /* messageUrlStart */,
|
||
|
|
0 /* messageUrlEnd */,
|
||
|
|
positiveButtonText,
|
||
|
|
negativeButtonText,
|
||
|
|
neutralButtonText,
|
||
|
|
callback,
|
||
|
|
callbackThreadRunner)
|
||
|
|
);
|
||
|
|
} catch (IllegalArgumentException e) {
|
||
|
|
Log.e(TAG, "Could not create DialogHandle for simple dialog: " + e);
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Creates a simple dialog with a URL embedded in the message.
|
||
|
|
*
|
||
|
|
* @param title Title of the dialog.
|
||
|
|
* @param message Message of the dialog.
|
||
|
|
* @param messageUrl URL to embed in the message. If non-null, then message must also
|
||
|
|
* be non-null.
|
||
|
|
* @param messageUrlStart Start index (inclusive) of the URL in the message. Must be
|
||
|
|
* non-negative.
|
||
|
|
* @param messageUrlEnd End index (exclusive) of the URL in the message. Must be less
|
||
|
|
* than the length of message.
|
||
|
|
* @param positiveButtonText Text of the positive button or {@code null} for no button.
|
||
|
|
* @param negativeButtonText Text of the negative button or {@code null} for no button.
|
||
|
|
* @param neutralButtonText Text of the neutral button or {@code null} for no button.
|
||
|
|
* @param callback Callback to receive the dialog response.
|
||
|
|
* @param callbackThreadRunner WifiThreadRunner to run the callback on.
|
||
|
|
* @return DialogHandle Handle for the dialog, or {@code null} if no dialog could
|
||
|
|
* be created.
|
||
|
|
*/
|
||
|
|
@AnyThread
|
||
|
|
@Nullable
|
||
|
|
public DialogHandle createSimpleDialogWithUrl(
|
||
|
|
@Nullable String title,
|
||
|
|
@Nullable String message,
|
||
|
|
@Nullable String messageUrl,
|
||
|
|
int messageUrlStart,
|
||
|
|
int messageUrlEnd,
|
||
|
|
@Nullable String positiveButtonText,
|
||
|
|
@Nullable String negativeButtonText,
|
||
|
|
@Nullable String neutralButtonText,
|
||
|
|
@NonNull SimpleDialogCallback callback,
|
||
|
|
@NonNull WifiThreadRunner callbackThreadRunner) {
|
||
|
|
try {
|
||
|
|
return new DialogHandle(
|
||
|
|
new SimpleDialogHandle(
|
||
|
|
title,
|
||
|
|
message,
|
||
|
|
messageUrl,
|
||
|
|
messageUrlStart,
|
||
|
|
messageUrlEnd,
|
||
|
|
positiveButtonText,
|
||
|
|
negativeButtonText,
|
||
|
|
neutralButtonText,
|
||
|
|
callback,
|
||
|
|
callbackThreadRunner)
|
||
|
|
);
|
||
|
|
} catch (IllegalArgumentException e) {
|
||
|
|
Log.e(TAG, "Could not create DialogHandle for simple dialog: " + e);
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns the reply to a simple dialog to the callback of matching dialogId.
|
||
|
|
* @param dialogId id of the replying dialog.
|
||
|
|
* @param reply reply of the dialog.
|
||
|
|
*/
|
||
|
|
public void replyToSimpleDialog(int dialogId, @WifiManager.DialogReply int reply) {
|
||
|
|
if (mVerboseLoggingEnabled) {
|
||
|
|
Log.i(TAG, "Response received for simple dialog. id=" + dialogId + " reply=" + reply);
|
||
|
|
}
|
||
|
|
DialogHandleInternal internalHandle = mActiveDialogHandles.get(dialogId);
|
||
|
|
if (internalHandle == null) {
|
||
|
|
if (mVerboseLoggingEnabled) {
|
||
|
|
Log.w(TAG, "No matching dialog handle for simple dialog id=" + dialogId);
|
||
|
|
}
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (!(internalHandle instanceof SimpleDialogHandle)) {
|
||
|
|
if (mVerboseLoggingEnabled) {
|
||
|
|
Log.w(TAG, "Dialog handle with id " + dialogId + " is not for a simple dialog.");
|
||
|
|
}
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
switch (reply) {
|
||
|
|
case WifiManager.DIALOG_REPLY_POSITIVE:
|
||
|
|
((SimpleDialogHandle) internalHandle).notifyOnPositiveButtonClicked();
|
||
|
|
break;
|
||
|
|
case WifiManager.DIALOG_REPLY_NEGATIVE:
|
||
|
|
((SimpleDialogHandle) internalHandle).notifyOnNegativeButtonClicked();
|
||
|
|
break;
|
||
|
|
case WifiManager.DIALOG_REPLY_NEUTRAL:
|
||
|
|
((SimpleDialogHandle) internalHandle).notifyOnNeutralButtonClicked();
|
||
|
|
break;
|
||
|
|
case WifiManager.DIALOG_REPLY_CANCELLED:
|
||
|
|
((SimpleDialogHandle) internalHandle).notifyOnCancelled();
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
if (mVerboseLoggingEnabled) {
|
||
|
|
Log.w(TAG, "Received invalid reply=" + reply);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private class P2pInvitationReceivedDialogHandle extends DialogHandleInternal {
|
||
|
|
private @NonNull P2pInvitationReceivedDialogCallback mCallback;
|
||
|
|
private @NonNull WifiThreadRunner mCallbackThreadRunner;
|
||
|
|
|
||
|
|
P2pInvitationReceivedDialogHandle(
|
||
|
|
final @NonNull String deviceName,
|
||
|
|
final boolean isPinRequested,
|
||
|
|
@Nullable String displayPin,
|
||
|
|
int displayId,
|
||
|
|
@NonNull P2pInvitationReceivedDialogCallback callback,
|
||
|
|
@NonNull WifiThreadRunner callbackThreadRunner) throws IllegalArgumentException {
|
||
|
|
super(getBaseLaunchIntent(WifiManager.DIALOG_TYPE_P2P_INVITATION_RECEIVED)
|
||
|
|
.putExtra(WifiManager.EXTRA_P2P_DEVICE_NAME, deviceName)
|
||
|
|
.putExtra(WifiManager.EXTRA_P2P_PIN_REQUESTED, isPinRequested)
|
||
|
|
.putExtra(WifiManager.EXTRA_P2P_DISPLAY_PIN, displayPin), displayId);
|
||
|
|
if (deviceName == null) {
|
||
|
|
throw new IllegalArgumentException("Device name cannot be null!");
|
||
|
|
}
|
||
|
|
if (callback == null) {
|
||
|
|
throw new IllegalArgumentException("Callback cannot be null!");
|
||
|
|
}
|
||
|
|
if (callbackThreadRunner == null) {
|
||
|
|
throw new IllegalArgumentException("Callback thread runner cannot be null!");
|
||
|
|
}
|
||
|
|
mCallback = callback;
|
||
|
|
mCallbackThreadRunner = callbackThreadRunner;
|
||
|
|
}
|
||
|
|
|
||
|
|
void notifyOnAccepted(@Nullable String optionalPin) {
|
||
|
|
mCallbackThreadRunner.post(() -> mCallback.onAccepted(optionalPin));
|
||
|
|
unregisterDialog();
|
||
|
|
}
|
||
|
|
|
||
|
|
void notifyOnDeclined() {
|
||
|
|
mCallbackThreadRunner.post(() -> mCallback.onDeclined());
|
||
|
|
unregisterDialog();
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
void onTimeout() {
|
||
|
|
dismissDialog();
|
||
|
|
notifyOnDeclined();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Callback for receiving P2P Invitation Received dialog responses.
|
||
|
|
*/
|
||
|
|
public interface P2pInvitationReceivedDialogCallback {
|
||
|
|
/**
|
||
|
|
* Invitation was accepted.
|
||
|
|
*
|
||
|
|
* @param optionalPin Optional PIN if a PIN was requested, or {@code null} otherwise.
|
||
|
|
*/
|
||
|
|
void onAccepted(@Nullable String optionalPin);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Invitation was declined or cancelled (back button or home button or timeout).
|
||
|
|
*/
|
||
|
|
void onDeclined();
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Creates a P2P Invitation Received dialog.
|
||
|
|
*
|
||
|
|
* @param deviceName Name of the device sending the invitation.
|
||
|
|
* @param isPinRequested True if a PIN was requested and a PIN input UI should be shown.
|
||
|
|
* @param displayPin Display PIN, or {@code null} if no PIN should be displayed
|
||
|
|
* @param displayId The ID of the Display on which to place the dialog
|
||
|
|
* (Display.DEFAULT_DISPLAY
|
||
|
|
* refers to the default display)
|
||
|
|
* @param callback Callback to receive the dialog response.
|
||
|
|
* @param callbackThreadRunner WifiThreadRunner to run the callback on.
|
||
|
|
* @return DialogHandle Handle for the dialog, or {@code null} if no dialog could
|
||
|
|
* be created.
|
||
|
|
*/
|
||
|
|
@AnyThread
|
||
|
|
public DialogHandle createP2pInvitationReceivedDialog(
|
||
|
|
@NonNull String deviceName,
|
||
|
|
boolean isPinRequested,
|
||
|
|
@Nullable String displayPin,
|
||
|
|
int displayId,
|
||
|
|
@NonNull P2pInvitationReceivedDialogCallback callback,
|
||
|
|
@NonNull WifiThreadRunner callbackThreadRunner) {
|
||
|
|
try {
|
||
|
|
return new DialogHandle(
|
||
|
|
new P2pInvitationReceivedDialogHandle(
|
||
|
|
deviceName,
|
||
|
|
isPinRequested,
|
||
|
|
displayPin,
|
||
|
|
displayId,
|
||
|
|
callback,
|
||
|
|
callbackThreadRunner)
|
||
|
|
);
|
||
|
|
} catch (IllegalArgumentException e) {
|
||
|
|
Log.e(TAG, "Could not create DialogHandle for P2P Invitation Received dialog: " + e);
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns the reply to a P2P Invitation Received dialog to the callback of matching dialogId.
|
||
|
|
* Note: Must be invoked only from the main Wi-Fi thread.
|
||
|
|
*
|
||
|
|
* @param dialogId id of the replying dialog.
|
||
|
|
* @param accepted Whether the invitation was accepted.
|
||
|
|
* @param optionalPin PIN of the reply, or {@code null} if none was supplied.
|
||
|
|
*/
|
||
|
|
public void replyToP2pInvitationReceivedDialog(
|
||
|
|
int dialogId,
|
||
|
|
boolean accepted,
|
||
|
|
@Nullable String optionalPin) {
|
||
|
|
if (mVerboseLoggingEnabled) {
|
||
|
|
Log.i(TAG, "Response received for P2P Invitation Received dialog."
|
||
|
|
+ " id=" + dialogId
|
||
|
|
+ " accepted=" + accepted
|
||
|
|
+ " pin=" + optionalPin);
|
||
|
|
}
|
||
|
|
DialogHandleInternal internalHandle = mActiveDialogHandles.get(dialogId);
|
||
|
|
if (internalHandle == null) {
|
||
|
|
if (mVerboseLoggingEnabled) {
|
||
|
|
Log.w(TAG, "No matching dialog handle for P2P Invitation Received dialog"
|
||
|
|
+ " id=" + dialogId);
|
||
|
|
}
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (!(internalHandle instanceof P2pInvitationReceivedDialogHandle)) {
|
||
|
|
if (mVerboseLoggingEnabled) {
|
||
|
|
Log.w(TAG, "Dialog handle with id " + dialogId
|
||
|
|
+ " is not for a P2P Invitation Received dialog.");
|
||
|
|
}
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (accepted) {
|
||
|
|
((P2pInvitationReceivedDialogHandle) internalHandle).notifyOnAccepted(optionalPin);
|
||
|
|
} else {
|
||
|
|
((P2pInvitationReceivedDialogHandle) internalHandle).notifyOnDeclined();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private class P2pInvitationSentDialogHandle extends DialogHandleInternal {
|
||
|
|
P2pInvitationSentDialogHandle(
|
||
|
|
final @NonNull String deviceName,
|
||
|
|
final @NonNull String displayPin,
|
||
|
|
int displayId) throws IllegalArgumentException {
|
||
|
|
super(getBaseLaunchIntent(WifiManager.DIALOG_TYPE_P2P_INVITATION_SENT)
|
||
|
|
.putExtra(WifiManager.EXTRA_P2P_DEVICE_NAME, deviceName)
|
||
|
|
.putExtra(WifiManager.EXTRA_P2P_DISPLAY_PIN, displayPin),
|
||
|
|
displayId);
|
||
|
|
if (deviceName == null) {
|
||
|
|
throw new IllegalArgumentException("Device name cannot be null!");
|
||
|
|
}
|
||
|
|
if (displayPin == null) {
|
||
|
|
throw new IllegalArgumentException("Display PIN cannot be null!");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Creates a P2P Invitation Sent dialog.
|
||
|
|
*
|
||
|
|
* @param deviceName Name of the device the invitation was sent to.
|
||
|
|
* @param displayPin display PIN
|
||
|
|
* @param displayId display ID
|
||
|
|
* @return DialogHandle Handle for the dialog, or {@code null} if no dialog could
|
||
|
|
* be created.
|
||
|
|
*/
|
||
|
|
@AnyThread
|
||
|
|
public DialogHandle createP2pInvitationSentDialog(
|
||
|
|
@NonNull String deviceName,
|
||
|
|
@Nullable String displayPin,
|
||
|
|
int displayId) {
|
||
|
|
try {
|
||
|
|
return new DialogHandle(new P2pInvitationSentDialogHandle(deviceName, displayPin,
|
||
|
|
displayId));
|
||
|
|
} catch (IllegalArgumentException e) {
|
||
|
|
Log.e(TAG, "Could not create DialogHandle for P2P Invitation Sent dialog: " + e);
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|