Android10 USB devices mode 分析

USB

platform/build / tools/post_process_props.py在此设置默认的usb配置,在编译的时候makefile会将其编译到系统中

将默认的配置保存在UsbDeviceManagerPrefs.xml中(路径没找到)

usb中重要的属性persist.sys.usb.config和 sys.usb.config,

system/core/rootdir/init.usb.rc中会将 persist.sys.usb.config赋值给sys.usb.config

def mangle_default_prop(prop):

pass

# If ro.debuggable is 1, then enable adb on USB by default

# (this is for userdebug builds)

if prop.get("ro.debuggable") == "1":

val = prop.get("persist.sys.usb.config")

if "adb" not in val:

if val == "":

val = "adb"

else:

val = val + ",adb"

prop.put("persist.sys.usb.config", val)

# UsbDeviceManager expects a value here. If it doesn't get it, it will

# default to "adb". That might not the right policy there, but it's better

# to be explicit.

if not prop.get("persist.sys.usb.config"):

prop.put("persist.sys.usb.config", "none");

 

开机:

启动framework/base/services/.../usbService.java

 

@Override

public void onStart() {

mUsbService = new UsbService(getContext());

publishBinderService(Context.USB_SERVICE, mUsbService);

}

 

public UsbService(Context context) {

mContext = context;

 

mUserManager = context.getSystemService(UserManager.class);

mSettingsManager = new UsbSettingsManager(context);

mAlsaManager = new UsbAlsaManager(context);

 

final PackageManager pm = mContext.getPackageManager();

//主机模式

if (pm.hasSystemFeature(PackageManager.FEATURE_USB_HOST)) {

mHostManager = new UsbHostManager(context, mAlsaManager, mSettingsManager);

}

// 从设备模式,主要UsbDeviceManager

if (new File("/sys/class/android_usb").exists()) {

mDeviceManager = new UsbDeviceManager(context, mAlsaManager, mSettingsManager);

}

// USB端口管理

if (mHostManager != null || mDeviceManager != null) {

mPortManager = new UsbPortManager(context);

}

 

onSwitchUser(UserHandle.USER_SYSTEM);//切换到系统用户

 

//注册设别管理

BroadcastReceiver receiver = new BroadcastReceiver() {

@Override

public void onReceive(Context context, Intent intent) {

final String action = intent.getAction();

if (DevicePolicyManager.ACTION_DEVICE_POLICY_MANAGER_STATE_CHANGED

.equals(action)) {

if (mDeviceManager != null) {

mDeviceManager.updateUserRestrictions();

}

}

}

};

 

final IntentFilter filter = new IntentFilter();

filter.setPriority(IntentFilter.SYSTEM_HIGH_PRIORITY);

filter.addAction(DevicePolicyManager.ACTION_DEVICE_POLICY_MANAGER_STATE_CHANGED);

mContext.registerReceiver(receiver, filter, null, null);

}

 

public UsbDeviceManager(Context context, UsbAlsaManager alsaManager,

UsbSettingsManager settingsManager) {

mContext = context;

mContentResolver = context.getContentResolver();

PackageManager pm = mContext.getPackageManager();

mHasUsbAccessory = pm.hasSystemFeature(PackageManager.FEATURE_USB_ACCESSORY);

initRndisAddress();

 

boolean halNotPresent = false;

try {

IUsbGadget.getService(true);

} catch (RemoteException e) {

Slog.e(TAG, "USB GADGET HAL present but exception thrown", e);

} catch (NoSuchElementException e) {

halNotPresent = true;

Slog.i(TAG, "USB GADGET HAL not present in the device", e);

}

 

mControlFds = new HashMap<>();

FileDescriptor mtpFd = nativeOpenControl(UsbManager.USB_FUNCTION_MTP);

if (mtpFd == null) {

Slog.e(TAG, "Failed to open control for mtp");

}

mControlFds.put(UsbManager.FUNCTION_MTP, mtpFd);

FileDescriptor ptpFd = nativeOpenControl(UsbManager.USB_FUNCTION_PTP);

if (ptpFd == null) {

Slog.e(TAG, "Failed to open control for ptp");

}

mControlFds.put(UsbManager.FUNCTION_PTP, ptpFd);

 

if (halNotPresent) {

/**

* Initialze the legacy UsbHandler ->getPinnedSharedPrefs获取默认的端口.

*/

mHandler = new UsbHandlerLegacy(FgThread.get().getLooper(), mContext, this,

alsaManager, settingsManager);

} else {

/**

* Initialize HAL based UsbHandler

*/

mHandler = new UsbHandlerHal(FgThread.get().getLooper(), mContext, this,

alsaManager, settingsManager);

}

 

if (nativeIsStartRequested()) {

if (DEBUG) Slog.d(TAG, "accessory attached at boot");

startAccessoryMode();

}

 

BroadcastReceiver portReceiver = new BroadcastReceiver() {

@Override

public void onReceive(Context context, Intent intent) {

ParcelableUsbPort port = intent.getParcelableExtra(UsbManager.EXTRA_PORT);

UsbPortStatus status = intent.getParcelableExtra(UsbManager.EXTRA_PORT_STATUS);

mHandler.updateHostState(

port.getUsbPort(context.getSystemService(UsbManager.class)), status);

}

};

 

BroadcastReceiver chargingReceiver = new BroadcastReceiver() {

@Override

public void onReceive(Context context, Intent intent) {

int chargePlug = intent.getIntExtra(BatteryManager.EXTRA_PLUGGED, -1);

boolean usbCharging = chargePlug == BatteryManager.BATTERY_PLUGGED_USB;

mHandler.sendMessage(MSG_UPDATE_CHARGING_STATE, usbCharging);

}

};

 

BroadcastReceiver hostReceiver = new BroadcastReceiver() {

@Override

public void onReceive(Context context, Intent intent) {

Iterator devices = ((UsbManager) context.getSystemService(Context.USB_SERVICE))

.getDeviceList().entrySet().iterator();

if (intent.getAction().equals(UsbManager.ACTION_USB_DEVICE_ATTACHED)) {

mHandler.sendMessage(MSG_UPDATE_HOST_STATE, devices, true);

} else {

mHandler.sendMessage(MSG_UPDATE_HOST_STATE, devices, false);

}

}

};

 

BroadcastReceiver languageChangedReceiver = new BroadcastReceiver() {

@Override

public void onReceive(Context context, Intent intent) {

mHandler.sendEmptyMessage(MSG_LOCALE_CHANGED);

}

};

 

mContext.registerReceiver(portReceiver,

new IntentFilter(UsbManager.ACTION_USB_PORT_CHANGED));

mContext.registerReceiver(chargingReceiver,

new IntentFilter(Intent.ACTION_BATTERY_CHANGED));

 

IntentFilter filter =

new IntentFilter(UsbManager.ACTION_USB_DEVICE_ATTACHED);

filter.addAction(UsbManager.ACTION_USB_DEVICE_DETACHED);

mContext.registerReceiver(hostReceiver, filter);

 

mContext.registerReceiver(languageChangedReceiver,

new IntentFilter(Intent.ACTION_LOCALE_CHANGED));

 

// Watch for USB configuration changes

mUEventObserver = new UsbUEventObserver();

mUEventObserver.startObserving(USB_STATE_MATCH);

mUEventObserver.startObserving(USB_STATE_MATCH_SEC);

mUEventObserver.startObserving(ACCESSORY_START_MATCH);

}

 

@Override

public void onBootPhase(int phase) {

if (phase == SystemService.PHASE_ACTIVITY_MANAGER_READY) {

mUsbService.systemReady();

} else if (phase == SystemService.PHASE_BOOT_COMPLETED) {

mUsbService.bootCompleted();

}

}

 

public void systemReady() {

mAlsaManager.systemReady();

 

if (mDeviceManager != null) {

mDeviceManager.systemReady();

}

if (mHostManager != null) {

mHostManager.systemReady();

}

if (mPortManager != null) {

mPortManager.systemReady();

}

}

 

UsbDeviceManager.java

public void systemReady() {

if (DEBUG) Slog.d(TAG, "systemReady");

 

LocalServices.getService(ActivityTaskManagerInternal.class).registerScreenObserver(this);

 

mHandler.sendEmptyMessage(MSG_SYSTEM_READY);

}

 

case MSG_SYSTEM_READY:

mNotificationManager = (NotificationManager)

mContext.getSystemService(Context.NOTIFICATION_SERVICE);

 

LocalServices.getService(

AdbManagerInternal.class).registerTransport(new AdbTransport(this));

 

// Ensure that the notification channels are set up

if (isTv()) {

// TV-specific notification channel

mNotificationManager.createNotificationChannel(

new NotificationChannel(ADB_NOTIFICATION_CHANNEL_ID_TV,

mContext.getString(

com.android.internal.R.string

.adb_debugging_notification_channel_tv),

NotificationManager.IMPORTANCE_HIGH));

}

mSystemReady = true;

finishBoot();

break;

 

protected void finishBoot() {

if (mBootCompleted && mCurrentUsbFunctionsReceived && mSystemReady) {

if (mPendingBootBroadcast) {

updateUsbStateBroadcastIfNeeded(getAppliedFunctions(mCurrentFunctions));

mPendingBootBroadcast = false;

}

if (!mScreenLocked

&& mScreenUnlockedFunctions != UsbManager.FUNCTION_NONE) {

setScreenUnlockedFunctions();

} else {

setEnabledFunctions(UsbManager.FUNCTION_NONE, false);

}

if (mCurrentAccessory != null) {

mUsbDeviceManager.getCurrentSettings().accessoryAttached(mCurrentAccessory);

}

 

updateUsbNotification(false);

updateAdbNotification(false);

updateUsbFunctions();

}

}

 

@Override

public void handleMessage(Message msg) {

case MSG_UPDATE_STATE:

public void updateState(String state)

case MSG_UPDATE_PORT_STATE:

case MSG_UPDATE_CHARGING_STATE:

case MSG_UPDATE_HOST_STATE:

// case MSG_ENABLE_ADB:

case MSG_SET_CURRENT_FUNCTIONS:

public void setCurrentFunctions(long functions)

setEnabledFunctions

case MSG_SET_SCREEN_UNLOCKED_FUNCTIONS:

case MSG_UPDATE_SCREEN_LOCK:

case MSG_UPDATE_USER_RESTRICTIONS:

case MSG_SYSTEM_READY:

case MSG_LOCALE_CHANGED:

case MSG_BOOT_COMPLETED:

case MSG_USER_SWITCHED:

case MSG_ACCESSORY_MODE_ENTER_TIMEOUT:

}