src.com.android.systemui.usb.UsbDialogHelper Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of android-all Show documentation
Show all versions of android-all Show documentation
A library jar that provides APIs for Applications written for the Google Android Platform.
/*
* Copyright (C) 2021 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.systemui.usb;
import static android.Manifest.permission.RECORD_AUDIO;
import android.app.Activity;
import android.app.PendingIntent;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.PermissionChecker;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
import android.content.pm.ResolveInfo;
import android.hardware.usb.IUsbManager;
import android.hardware.usb.UsbAccessory;
import android.hardware.usb.UsbDevice;
import android.hardware.usb.UsbManager;
import android.os.IBinder;
import android.os.RemoteException;
import android.os.ServiceManager;
import android.os.UserHandle;
import android.util.Log;
/**
* Helper class to separate model and view for USB permission and confirm dialogs.
*/
public class UsbDialogHelper {
private static final String TAG = UsbDialogHelper.class.getSimpleName();
private static final String EXTRA_RESOLVE_INFO = "rinfo";
private final UsbDevice mDevice;
private final UsbAccessory mAccessory;
private final ResolveInfo mResolveInfo;
private final String mPackageName;
private final CharSequence mAppName;
private final Context mContext;
private final PendingIntent mPendingIntent;
private final IUsbManager mUsbService;
private final int mUid;
private final boolean mCanBeDefault;
private UsbDisconnectedReceiver mDisconnectedReceiver;
private boolean mIsUsbDevice;
private boolean mResponseSent;
/**
* @param context The Context of the caller.
* @param intent The intent of the caller.
* @throws IllegalStateException Thrown if both UsbDevice and UsbAccessory are null or if the
* query for the matching ApplicationInfo is unsuccessful.
*/
public UsbDialogHelper(Context context, Intent intent) throws IllegalStateException {
mContext = context;
mDevice = intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);
mAccessory = intent.getParcelableExtra(UsbManager.EXTRA_ACCESSORY);
mCanBeDefault = intent.getBooleanExtra(UsbManager.EXTRA_CAN_BE_DEFAULT, false);
if (mDevice == null && mAccessory == null) {
throw new IllegalStateException("Device and accessory are both null.");
}
if (mDevice != null) {
mIsUsbDevice = true;
}
mResolveInfo = intent.getParcelableExtra(EXTRA_RESOLVE_INFO);
PackageManager packageManager = mContext.getPackageManager();
if (mResolveInfo != null) {
// If a ResolveInfo is provided it will be used to determine the activity to start
mUid = mResolveInfo.activityInfo.applicationInfo.uid;
mPackageName = mResolveInfo.activityInfo.packageName;
mPendingIntent = null;
} else {
mUid = intent.getIntExtra(Intent.EXTRA_UID, -1);
mPackageName = intent.getStringExtra(UsbManager.EXTRA_PACKAGE);
mPendingIntent = intent.getParcelableExtra(Intent.EXTRA_INTENT);
}
try {
ApplicationInfo aInfo = packageManager.getApplicationInfo(mPackageName, 0);
mAppName = aInfo.loadLabel(packageManager);
} catch (PackageManager.NameNotFoundException e) {
throw new IllegalStateException("unable to look up package name", e);
}
IBinder b = ServiceManager.getService(Context.USB_SERVICE);
mUsbService = IUsbManager.Stub.asInterface(b);
}
/**
* Registers UsbDisconnectedReceiver to dismiss dialog automatically when device or accessory
* gets disconnected
* @param activity The activity to finish when device / accessory gets disconnected.
*/
public void registerUsbDisconnectedReceiver(Activity activity) {
if (mIsUsbDevice) {
mDisconnectedReceiver = new UsbDisconnectedReceiver(activity, mDevice);
} else {
mDisconnectedReceiver = new UsbDisconnectedReceiver(activity, mAccessory);
}
}
/**
* Unregisters the UsbDisconnectedReceiver. To be called when the activity is destroyed.
* @param activity The activity registered to finish when device / accessory gets disconnected.
*/
public void unregisterUsbDisconnectedReceiver(Activity activity) {
if (mDisconnectedReceiver != null) {
try {
activity.unregisterReceiver(mDisconnectedReceiver);
} catch (Exception e) {
// pass
}
mDisconnectedReceiver = null;
}
}
/**
* @return True if the intent contains a UsbDevice which can capture audio.
*/
public boolean deviceHasAudioCapture() {
return mDevice != null && mDevice.getHasAudioCapture();
}
/**
* @return True if the intent contains a UsbDevice which can play audio.
*/
public boolean deviceHasAudioPlayback() {
return mDevice != null && mDevice.getHasAudioPlayback();
}
/**
* @return True if the package has RECORD_AUDIO permission specified in its manifest.
*/
public boolean packageHasAudioRecordingPermission() {
return PermissionChecker.checkPermissionForPreflight(mContext, RECORD_AUDIO,
PermissionChecker.PID_UNKNOWN, mUid, mPackageName)
== android.content.pm.PackageManager.PERMISSION_GRANTED;
}
/**
* @return True if the intent contains a UsbDevice.
*/
public boolean isUsbDevice() {
return mIsUsbDevice;
}
/**
* @return True if the intent contains a UsbAccessory.
*/
public boolean isUsbAccessory() {
return !mIsUsbDevice;
}
/**
* Grants USB permission to the device / accessory to the calling uid.
*/
public void grantUidAccessPermission() {
try {
if (mIsUsbDevice) {
mUsbService.grantDevicePermission(mDevice, mUid);
} else {
mUsbService.grantAccessoryPermission(mAccessory, mUid);
}
} catch (RemoteException e) {
Log.e(TAG, "IUsbService connection failed", e);
}
}
/**
* Sets the package as default for the device / accessory.
*/
public void setDefaultPackage() {
final int userId = UserHandle.myUserId();
try {
if (mIsUsbDevice) {
mUsbService.setDevicePackage(mDevice, mPackageName, userId);
} else {
mUsbService.setAccessoryPackage(mAccessory, mPackageName, userId);
}
} catch (RemoteException e) {
Log.e(TAG, "IUsbService connection failed", e);
}
}
/**
* Clears the default package of the device / accessory.
*/
public void clearDefaultPackage() {
final int userId = UserHandle.myUserId();
try {
if (mIsUsbDevice) {
mUsbService.setDevicePackage(mDevice, null, userId);
} else {
mUsbService.setAccessoryPackage(mAccessory, null, userId);
}
} catch (RemoteException e) {
Log.e(TAG, "IUsbService connection failed", e);
}
}
/**
* Starts the activity which was selected to handle the device / accessory.
*/
public void confirmDialogStartActivity() {
final int userId = UserHandle.myUserId();
Intent intent;
if (mIsUsbDevice) {
intent = new Intent(UsbManager.ACTION_USB_DEVICE_ATTACHED);
intent.putExtra(UsbManager.EXTRA_DEVICE, mDevice);
} else {
intent = new Intent(UsbManager.ACTION_USB_ACCESSORY_ATTACHED);
intent.putExtra(UsbManager.EXTRA_ACCESSORY, mAccessory);
}
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
intent.setComponent(
new ComponentName(mResolveInfo.activityInfo.packageName,
mResolveInfo.activityInfo.name));
try {
mContext.startActivityAsUser(intent, new UserHandle(userId));
} catch (Exception e) {
Log.e(TAG, "Unable to start activity", e);
}
}
/**
* Sends the result of the permission dialog via the provided PendingIntent.
*
* @param permissionGranted True if the user pressed ok in the permission dialog.
*/
public void sendPermissionDialogResponse(boolean permissionGranted) {
if (!mResponseSent) {
// send response via pending intent
Intent intent = new Intent();
if (mIsUsbDevice) {
intent.putExtra(UsbManager.EXTRA_DEVICE, mDevice);
} else {
intent.putExtra(UsbManager.EXTRA_ACCESSORY, mAccessory);
}
intent.putExtra(UsbManager.EXTRA_PERMISSION_GRANTED, permissionGranted);
try {
mPendingIntent.send(mContext, 0, intent);
mResponseSent = true;
} catch (PendingIntent.CanceledException e) {
Log.w(TAG, "PendingIntent was cancelled");
}
}
}
/**
* @return A description of the device / accessory
*/
public String getDeviceDescription() {
String desc;
if (mIsUsbDevice) {
desc = mDevice.getProductName();
if (desc == null) {
desc = mDevice.getDeviceName();
}
} else {
// UsbAccessory
desc = mAccessory.getDescription();
if (desc == null) {
desc = String.format("%s %s", mAccessory.getManufacturer(), mAccessory.getModel());
}
}
return desc;
}
/**
* Whether the calling package can set as default handler of the USB device or accessory.
* In case of a UsbAccessory this is the case if the calling package has an intent filter for
* {@link UsbManager#ACTION_USB_ACCESSORY_ATTACHED} with a usb-accessory filter matching the
* attached accessory. In case of a UsbDevice this is the case if the calling package has an
* intent filter for {@link UsbManager#ACTION_USB_DEVICE_ATTACHED} with a usb-device filter
* matching the attached device.
*
* @return True if the package can be default for the USB device.
*/
public boolean canBeDefault() {
return mCanBeDefault;
}
/**
* @return The name of the app which requested permission or the name of the app which will be
* opened if the user allows it to handle the USB device.
*/
public CharSequence getAppName() {
return mAppName;
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy