USB模式设置流程

最新推荐文章于 2024-06-11 09:42:45 发布
最新推荐文章于 2024-06-11 09:42:45 发布
阅读量4.9k 收藏 2
点赞数
文章标签： USB
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/anqingcheng/article/details/81030850
版权

1.setting中改变USB状态

    在setting中关于改变USB状态的有两个重要的类：UsbSettings和UsbSettingsExts。UsbSettings实际上是一个PreferenceFragment，它负责展示界面；UsbSettingsExts负责保存USB状态的。

UsbSettings.java

 @Override
    public boolean onPreferenceChange(Preference preference, Object newValue) {

        // Don't allow any changes to take effect as the USB host will be disconnected, killing
        // the monkeys
        if (Utils.isMonkeyRunning()) {
            return true;
        }
        // If this user is disallowed from using USB, don't handle their attempts to change the
        // setting.
        UserManager um = (UserManager) getActivity().getSystemService(Context.USER_SERVICE);
        if (um.hasUserRestriction(UserManager.DISALLOW_USB_FILE_TRANSFER)) {
            return true;
        }

        String function = mUsbExts.getFunction(preference);
        boolean makeDefault = mUsbExts.isMakeDefault(preference);
        mUsbManager.setCurrentFunction(function, makeDefault);//改变USB状态
        updateToggles(function);

        mUsbExts.setNeedUpdate(false);
        return true;
    }

UsbSettingsExts.java

    public String getFunction(Preference preference) {
        String function = FUNCTION_NONE;
        if (preference == mMtp && mMtp.isChecked()) {
            function = UsbManager.USB_FUNCTION_MTP;
        } else if (preference == mPtp && mPtp.isChecked()) {
            function = UsbManager.USB_FUNCTION_PTP;
        } else if (preference == mUms && mUms.isChecked()) {
            function = UsbManager.USB_FUNCTION_MASS_STORAGE;
        } else if (preference == mCharge && mCharge.isChecked()) {
            function = UsbManager.USB_FUNCTION_CHARGING_ONLY;
        } else if (preference == mBicr && mBicr.isChecked()) {
            function = UsbManager.USB_FUNCTION_BICR;
        }
        return function;
    }

下面来看下USB的管理类UsbManager.java

    public void setCurrentFunction(String function, boolean makeDefault) {
        try {
            mService.setCurrentFunction(function, makeDefault);//调用usbservice，改变USB状态
        } catch (RemoteException e) {
            Log.e(TAG, "RemoteException in setCurrentFunction", e);
        }
    }

UsbService.java

    @Override
    public void setCurrentFunction(String function, boolean makeDefault) {
        mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MANAGE_USB, null);

        // If attempt to change USB function while file transfer is restricted, ensure that
        // the current function is set to "none", and return.
        UserManager userManager = (UserManager) mContext.getSystemService(Context.USER_SERVICE);
        if (userManager.hasUserRestriction(UserManager.DISALLOW_USB_FILE_TRANSFER)) {
            if (mDeviceManager != null) mDeviceManager.setCurrentFunctions("none", false);
            return;
        }

        if (mDeviceManager != null) {
            mDeviceManager.setCurrentFunctions(function, makeDefault);
        } else {
            throw new IllegalStateException("USB device mode not supported");
        }
    }

UsbDeviceManager.java

    public void setCurrentFunctions(String functions, boolean makeDefault) {
        if (DEBUG) Slog.d(TAG, "setCurrentFunctions(" + functions + ") default: " + makeDefault);
        mHandler.sendMessage(MSG_SET_CURRENT_FUNCTIONS, functions, makeDefault);
    }

case MSG_SET_CURRENT_FUNCTIONS:
                    String functions = (String)msg.obj;
                    boolean makeDefault = (msg.arg1 == 1);

                    mSettingUsbCharging = false;
                    mSettingUsbBicr = false;

                    /* In BICR evo, it's hard to confirm that the current disconnect is caused by switching usb function or unplugging usb cable*/
                    /* So add a flag to know it*/
                    mIsUserSwitch = true;

                    if (functions != null && functions.equals(UsbManager.USB_FUNCTION_CHARGING_ONLY)) {
                        mSettingUsbCharging = true;
                        mCurrentFunctions = removeFunction(mCurrentFunctions, UsbManager.USB_FUNCTION_MTP);
                        mCurrentFunctions = removeFunction(mCurrentFunctions, UsbManager.USB_FUNCTION_PTP);
                        updateUsbState();
                        Slog.d(TAG, "handleMessage - MSG_SET_CURRENT_FUNCTION - CHARGING_ONLY - makeDefault: " + makeDefault);
                    } else if (functions != null && functions.equals(UsbManager.USB_FUNCTION_BICR)) {
                        mSettingUsbBicr = true;
                        Slog.d(TAG, "handleMessage - MSG_SET_CURRENT_FUNCTION - BICR - makeDefault: " + makeDefault);
                    } else if (functions == null && mDefaultFunctions.equals(UsbManager.USB_FUNCTION_CHARGING_ONLY)) {
                        functions = mDefaultFunctions;
                        mSettingUsbCharging = true;
                        makeDefault = true;
                        updateUsbState();
                        Slog.d(TAG, "handleMessage - MSG_SET_CURRENT_FUNCTION - [Tethering Off] USB_FUNCTION_CHARGING_ONLY - makeDefault: " + makeDefault);
                    }

                    setEnabledFunctions(functions, makeDefault);

                    mIsUserSwitch = false;
                    //ALPS00428998
                    if(mMtpAskDisconnect) mMtpAskDisconnect = false;
                    //ALPS00428998

                    Slog.d(TAG, "handleMessage - MSG_SET_CURRENT_FUNCTION - functions: " + functions);
                    break;
 private void setEnabledFunctions(String functions, boolean makeDefault) {
            if (DEBUG) {
                Slog.d(TAG, "setEnabledFunctions - functions: " + functions);
                Slog.d(TAG, "setEnabledFunctions - mDefaultFunctions: " + mDefaultFunctions);
                Slog.d(TAG, "setEnabledFunctions - mCurrentFunctions: " + mCurrentFunctions);
                Slog.d(TAG, "setEnabledFunctions - mSettingFunction: " + mSettingFunction);
            }

            if (mCurrentFunctions.equals(UsbManager.USB_FUNCTION_CHARGING_ONLY)) {
                Slog.d(TAG, "setEnabledFunctions - [Disable USB Charging]");
                SystemProperties.set("sys.usb.charging","no");
            }

            if (containsFunction(mCurrentFunctions, UsbManager.USB_FUNCTION_BICR)) {
                if (mIsUsbBicrEvo) {
                    Slog.w(TAG, "====mIsPcKnowMe:" + mIsPcKnowMe + ", mIsBicrSet:" + mIsBicrSet + ", mHwDisconnected:" + mHwDisconnected);
                    if (mIsBicrSet && mHwDisconnected) {
                        Slog.d(TAG, "Do not set sys.usb.bicr=no again!!!");
                    } else {
                        Slog.d(TAG, "setEnabledFunctions1 - [Disable USB BICR]");
                        SystemProperties.set("sys.usb.bicr","no");//设置为光驱
                    }
                } else {
                    Slog.d(TAG, "setEnabledFunctions2 - [Disable USB BICR]");
                    SystemProperties.set("sys.usb.bicr","no");
                }
            }

            if (mIsUsbBicrEvo && functions != null) {
                if( containsFunction(functions, UsbManager.USB_FUNCTION_RNDIS) || containsFunction(functions, UsbManager.USB_FUNCTION_EEM) ) {
                    mDefaultFunctions = mSettingFunction;
                }
            }
            // Do not update persystent.sys.usb.config if the device is booted up
            // with OEM specific mode.
            if (functions != null && makeDefault && !needsOemUsbOverride() && !mIsUsbBicrEvo) {
                if(bEvdoDtViaSupport == true) {
                    //VIA-START VIA USB
                    if(Settings.Secure.getInt(mContentResolver,
                        Settings.Secure.ADB_ENABLED, 0) > 0){
                        mAdbEnabled = true;
                        updateAdbNotification();
                    }
                    //VIA-END VIA USB
                }

                mSettingFunction = functions;
                if (mAdbEnabled && !mSettingUsbCharging) {
                    functions = addFunction(functions, UsbManager.USB_FUNCTION_ADB);
                } else {
                    functions = removeFunction(functions, UsbManager.USB_FUNCTION_ADB);
                }

                String acm_idx = SystemProperties.get("sys.usb.acm_idx", "");
                Slog.d(TAG, "sys.usb.acm_idx=" + acm_idx + ",mAcmPortIdx=" + mAcmPortIdx);
                if ((mAcmEnabled || ((acm_idx!=null) && !acm_idx.isEmpty()) ||
                                  ((mAcmPortIdx!=null) && !mAcmPortIdx.isEmpty())) &&
                                  !mSettingUsbCharging && !mSettingUsbBicr) {
                    int port_num = 0;
                    String port_str = "";
                    if(!acm_idx.isEmpty()) {
                        port_num = validPortNum(acm_idx);
                        if(port_num > 0 ) {
                            port_str = acm_idx;
                            mAcmPortIdx = acm_idx;
                        }
                    } else if(!mAcmPortIdx.isEmpty()) {
                        port_num = validPortNum(mAcmPortIdx);
                        if(port_num > 0 )
                            port_str = mAcmPortIdx;
                    }

                    Slog.d(TAG, "port_num=" + port_num);
                    if (port_num > 0) {
                        Slog.d(TAG, "Write port_str=" + port_str);
                        writeFile(ACM_PORT_INDEX_PATH, port_str);
                    }

                    /*Add ACM or Dual ACM at the tail. Even with ADB.*/
                    functions = removeFunction(functions, UsbManager.USB_FUNCTION_ACM);
                    functions = removeFunction(functions, UsbManager.USB_FUNCTION_DUAL_ACM);

                    String tmp = ( (port_num == 2) ? UsbManager.USB_FUNCTION_DUAL_ACM : UsbManager.USB_FUNCTION_ACM);
                    functions = addFunction(functions, tmp);

                    //Slog.d(TAG, "set persist.sys.port_index=" + port_str);
                    /*Keep the port info. We need it when reboot.*/
                    //SystemProperties.set("persist.sys.port_index", port_str);

                } else {
                    functions = removeFunction(functions, UsbManager.USB_FUNCTION_ACM);
                    functions = removeFunction(functions, UsbManager.USB_FUNCTION_DUAL_ACM);

                    SystemProperties.set("persist.sys.port_index", "");
                }
                Slog.d(TAG, "setEnabledFunctions - functions: " + functions);
                if (!mDefaultFunctions.equals(functions) || containsFunction(mCurrentFunctions, UsbManager.USB_FUNCTION_BICR) || containsFunction(mCurrentFunctions, UsbManager.USB_FUNCTION_RNDIS)) {
                    if (!setUsbConfig("none")) {
                        Slog.e(TAG, "Failed to disable USB");
                        // revert to previous configuration if we fail
                        setUsbConfig(mCurrentFunctions);
                        return;
                    }
                    // setting this property will also change the current USB state
                    // via a property trigger
                    SystemProperties.set("persist.sys.usb.config", functions);

                    if (mSettingFunction.equals(UsbManager.USB_FUNCTION_CHARGING_ONLY)) {
                        if (mAdbEnabled) {
                            SystemProperties.set("persist.service.adb.enable", "1");
                        } else {
                            SystemProperties.set("persist.service.adb.enable", "0");
                        }
                    } else {
                        SystemProperties.set("persist.service.adb.enable", "");
                    }

                    if (waitForState(functions)) {
                        mCurrentFunctions = functions;
                        mDefaultFunctions = functions;
                    } else {
                        Slog.e(TAG, "Failed to switch persistent USB config to " + functions);
                        // revert to previous configuration if we fail
                        SystemProperties.set("persist.sys.usb.config", mDefaultFunctions);
                    }
                } else {
                    //VIA-START VIA USB
                    if(bEvdoDtViaSupport == true) {
                        if(mDefaultFunctions.equals(functions) &&
                        (mCurrentFunctions.contains(UsbManager.USB_FUNCTION_VIA_CDROM)
                        ||mCurrentFunctions.contains(Bypass.USB_FUNCTION_BYPASS))){
                            Slog.i(TAG, "reset DefaultFunctions!");
                            if (!setUsbConfig("none")) {
                                Slog.e(TAG, "Failed to disable USB");
                                // revert to previous configuration if we fail
                                setUsbConfig(mCurrentFunctions);
                                return;
                            }
                            if (setUsbConfig(functions)) {
                                mCurrentFunctions = functions;
                            } else {
                                Slog.e(TAG, "Failed to switch USB config to " + functions);
                                // revert to previous configuration if we fail
                                setUsbConfig(mCurrentFunctions);
                            }
                        }
                    }
                    //VIA-END VIA USB
                }
            } else {
                if (functions == null) {
                    functions = mDefaultFunctions;
                    if(bEvdoDtViaSupport == true){
                        mUsbSetBypassWithTether=false ;
                    }
                }
                //VIA-START VIA USB
                if(bEvdoDtViaSupport == true) {
                    //adb can't be open with bypass and via cdrom
                    if(Settings.Secure.getInt(mContentResolver,
                        Settings.Secure.ADB_ENABLED, 0) > 0){
                        mAdbEnabled = true;
                        updateAdbNotification();
                    }
                }
                //VIA-END VIA USB
                // Override with bootmode specific usb mode if needed
                functions = processOemUsbOverride(functions);
                mSettingFunction = functions;

                if(bEvdoDtViaSupport == true){
                    if ((containsFunction(functions, UsbManager.USB_FUNCTION_RNDIS) || containsFunction(functions, UsbManager.USB_FUNCTION_EEM)) && mUsbSetBypassWithTether){					
                        functions = addFunction(functions, Bypass.USB_FUNCTION_BYPASS);
                        Slog.d(TAG, "add the bypass functions to tethering : " + functions);
                    }
                }

                if (mIsUsbBicrEvo && !mIsPcKnowMe && !mSettingUsbCharging) {
                    functions = UsbManager.USB_FUNCTION_BICR;
                    mSettingFunction = functions;
                }

                if (mAdbEnabled && !mSettingUsbCharging) {
                    functions = addFunction(functions, UsbManager.USB_FUNCTION_ADB);
                } else {
                    functions = removeFunction(functions, UsbManager.USB_FUNCTION_ADB);
                }

                String acm_idx = SystemProperties.get("sys.usb.acm_idx", "");
                Slog.d(TAG, "sys.usb.acm_idx=" + acm_idx);
                if ((mAcmEnabled || ((acm_idx!=null) && !acm_idx.isEmpty()) ||
                                  ((mAcmPortIdx!=null) && !mAcmPortIdx.isEmpty())) &&
                                  !mSettingUsbCharging && !mSettingUsbBicr) {
                    int port_num = 0;
                    String port_str = "";
                    if(!acm_idx.isEmpty()) {
                        port_num = validPortNum(acm_idx);
                        if(port_num > 0 ) {
                            port_str = acm_idx;
                            mAcmPortIdx = acm_idx;
                        }

                    } else if(!mAcmPortIdx.isEmpty()) {
                        port_num = validPortNum(mAcmPortIdx);
                        if(port_num > 0 )
                            port_str = mAcmPortIdx;
                    }

                    Slog.d(TAG, "port_num=" + port_num);
                    if (port_num > 0) {
                        Slog.d(TAG, "Write port_str=" + port_str);
                        writeFile(ACM_PORT_INDEX_PATH, port_str);
                    }

                    /*Add ACM or Dual ACM at the tail. Even with ADB.*/
                    functions = removeFunction(functions, UsbManager.USB_FUNCTION_ACM);
                    functions = removeFunction(functions, UsbManager.USB_FUNCTION_DUAL_ACM);

                    String tmp = ( (port_num == 2) ? UsbManager.USB_FUNCTION_DUAL_ACM : UsbManager.USB_FUNCTION_ACM);
                    functions = addFunction(functions, tmp);
                } else {
                    functions = removeFunction(functions, UsbManager.USB_FUNCTION_ACM);
                    functions = removeFunction(functions, UsbManager.USB_FUNCTION_DUAL_ACM);
                }

                Slog.d(TAG, "else setEnabledFunctions, functions: " + functions + ", mCurrentFunctions: " + mCurrentFunctions);
                if (!mCurrentFunctions.equals(functions) || containsFunction(mCurrentFunctions, UsbManager.USB_FUNCTION_BICR) || (mIsUsbBicrEvo && !mIsPcKnowMe) || mMtpAskDisconnect) {
                    if (mIsUsbBicrEvo) {
                        Slog.w(TAG, "====mIsPcKnowMe:" + mIsPcKnowMe + ", mIsBicrSet:" + mIsBicrSet + ", mHwDisconnected:" + mHwDisconnected);
                        if (mIsBicrSet && !mIsPcKnowMe && mHwDisconnected && mCurrentFunctions.equals(functions) && containsFunction(mCurrentFunctions, UsbManager.USB_FUNCTION_BICR)) {
                            Slog.e(TAG, "Do not do setUsbConfig() again!!!");
                            return;
                        } else {
                            mIsBicrSet = true;
                        }
                    }
                    if (!setUsbConfig("none")) {
                        Slog.e(TAG, "Failed to disable USB");
                        // revert to previous configuration if we fail
                        setUsbConfig(mCurrentFunctions);
                        return;
                    }
                    if (setUsbConfig(functions)) {
                        mCurrentFunctions = functions;
                    } else {
                        Slog.e(TAG, "Failed to switch USB config to " + functions);
                        // revert to previous configuration if we fail
                        setUsbConfig(mCurrentFunctions);
                    }
                }
            }
			
			/* reset this value after trigger setconfig, i.e. one time JOB */	
			if(bEvdoDtViaSupport == true){
				mUsbSetBypassWithTether=false ;
			}
        }

下面我们来看下init.usb.rc

on property:sys.usb.config=none
    stop adbd
    write /sys/class/android_usb/android0/enable 0
    write /sys/class/android_usb/android0/bDeviceClass 0
    setprop sys.usb.state ${sys.usb.config}

# adb only USB configuration
# This is the fallback configuration if the
# USB manager fails to set a standard configuration
on property:sys.usb.config=adb
    write /sys/class/android_usb/android0/enable 0
    write /sys/class/android_usb/android0/idVendor 18d1
    write /sys/class/android_usb/android0/idProduct 4EE7
    write /sys/class/android_usb/android0/functions ${sys.usb.config}
    write /sys/class/android_usb/android0/enable 1
    start adbd
    setprop sys.usb.state ${sys.usb.config}

# USB accessory configuration
on property:sys.usb.config=accessory
    write /sys/class/android_usb/android0/enable 0
    write /sys/class/android_usb/android0/idVendor 18d1
    write /sys/class/android_usb/android0/idProduct 2d00
    write /sys/class/android_usb/android0/functions ${sys.usb.config}
    write /sys/class/android_usb/android0/enable 1
    setprop sys.usb.state ${sys.usb.config}

# USB accessory configuration, with adb
on property:sys.usb.config=accessory,adb
    write /sys/class/android_usb/android0/enable 0
    write /sys/class/android_usb/android0/idVendor 18d1
    write /sys/class/android_usb/android0/idProduct 2d01
    write /sys/class/android_usb/android0/functions ${sys.usb.config}
    write /sys/class/android_usb/android0/enable 1
    start adbd
    setprop sys.usb.state ${sys.usb.config}

# audio accessory configuration
on property:sys.usb.config=audio_source
    write /sys/class/android_usb/android0/enable 0
    write /sys/class/android_usb/android0/idVendor 18d1
    write /sys/class/android_usb/android0/idProduct 2d02
    write /sys/class/android_usb/android0/functions ${sys.usb.config}
    write /sys/class/android_usb/android0/enable 1
    setprop sys.usb.state ${sys.usb.config}

# audio accessory configuration, with adb
on property:sys.usb.config=audio_source,adb
    write /sys/class/android_usb/android0/enable 0
    write /sys/class/android_usb/android0/idVendor 18d1
    write /sys/class/android_usb/android0/idProduct 2d03
    write /sys/class/android_usb/android0/functions ${sys.usb.config}
    write /sys/class/android_usb/android0/enable 1
    start adbd
    setprop sys.usb.state ${sys.usb.config}

# USB and audio accessory configuration
on property:sys.usb.config=accessory,audio_source
    write /sys/class/android_usb/android0/enable 0
    write /sys/class/android_usb/android0/idVendor 18d1
    write /sys/class/android_usb/android0/idProduct 2d04
    write /sys/class/android_usb/android0/functions ${sys.usb.config}
    write /sys/class/android_usb/android0/enable 1
    setprop sys.usb.state ${sys.usb.config}

# USB and audio accessory configuration, with adb
on property:sys.usb.config=accessory,audio_source,adb
    write /sys/class/android_usb/android0/enable 0
    write /sys/class/android_usb/android0/idVendor 18d1
    write /sys/class/android_usb/android0/idProduct 2d05
    write /sys/class/android_usb/android0/functions ${sys.usb.config}
    write /sys/class/android_usb/android0/enable 1
    start adbd
    setprop sys.usb.state ${sys.usb.config}

# Used to set USB configuration at boot and to switch the configuration
# when changing the default configuration
on property:persist.sys.usb.config=*
    setprop sys.usb.config ${persist.sys.usb.config}

从上面可以看出，设置persist.sys.usb.config后sys.usb,config跟着改变，然后向节点写入数据改变状态




anqingcheng
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
USBService源码分析之Usb权限（二）
Flying snow
01-24 3228
1、背景 前面一篇文章中我们分析了USBService在Android系统中的创建方式等USBService源码分析（一），相信通过上一篇文章的阐述大家对其也有一定的了解了，今天就来和大家来谈谈usb权限的问题。 在用PC连接Android设备，使用adb devices查看手机是否连接时，手机端会弹出权限提醒框，提醒用户赋予权限，接下来我们就来看看Android系统是如何弹出这个选择框的。
USBSetting:一个调用Android系统USB设置活动的小应用
06-06
USB设置 一个调用Android系统USB设置活动的小应用
【高效传输神器】FileTransfer：轻松实现PC与手机文件无障碍互传
最新发布
gitblog_00011的博客
06-11 326
【高效传输神器】FileTransfer：轻松实现PC与手机文件无障碍互传 项目地址:https://gitcode.com/CPPAlien/FileTransfer 在信息化时代，跨设备的文件传输已成为日常需求之一。今天，我们向大家隆重推荐一个开源项目——FileTransfer，它将极大地简化你的生活和工作，让你能够在PC与手机之间自由穿梭任何文件，无需繁琐的设置，一触即达。 项目介绍 F...
驱动程序中USB设备的配置过程（参考Windows XP DDK）
anna的专栏
11-01 1553
驱动程序中USB设备的配置过程（参考Windows XP DDK） DDK驱动程序写得很规范，USB初始化、数据传输的过程写的很清楚。通过阅读DDK驱动程序，我对原来USB驱动程序中许多不理解的地方有了更清楚的理解.下面就参照DDK提供的iso_usb例子对USB设备的配置过程进行总结。 1.驱动程序加载后首先执行DriverEntry入口函数。 该函数设定了对各个IRP进行处理的派遣函数。
sys.usb.config webcam
weixin_34211761的博客
08-02 302
setprop persist.sys.usb.config webcamecho 0 > /sys/devices/virtual/android_usb/android0/enableecho "webcam" > /sys/class/android_usb/android0/functionsecho 1f30 > /sys/devices/virtual/android...
开发者选项关闭时重置USB配置默认为不进行数据传输
weixin_56663189的博客
03-28 5136
大多数android 版本，打开开发者选项后 usb默认配置为不进行数据传输，当选择为文件传输模式后，关闭开发者，usb会记住上一次选中的项，并不会因关闭开发者模式还原回不进行数据传输。 不会还原是正常现象，大多数android平台为了方便用户选择会记住选择的项，方便下一次连接，不用再打开开发者模式选择文件传输。 当然我们的手机或平板插usb就可以选择文件传输，不用打开开发者选项，但这里我们有一个前提是下拉菜单下的usb通知里的选项只保留了仅充电，所以就只能通过开发者选项选择。 去掉通知.
Android O新增的关于usb的三个属性 sys.usb.configfs，sys.usb.ffs.ready，sys.usb.ffs.mtp.ready
编程菜鸟进阶之路
04-19 1万+
1.sys.usb.configfs该属性默认为0，通过判断kernel是否支持configfs，即判断/config/usb_gadget存在设置为1.代码在init.qcom.usb.sh中（高通平台下）。2.sys.usb.ffs.ready当sys.usb.config设置为none时，设置sys.usb.ffs.ready为0.每次设置的属性有adb时，会先start adbd。如sys...
usb 2.0 specification
05-13
4. 热插拔与即插即用：USB 2.0延续了USB标准的热插拔和即插即用特性，用户无需关闭系统即可添加或移除设备，简化了操作流程。 5. 多功能接口：USB接口不仅可以连接各种不同类型的设备，如键盘、鼠标、打印机、扫描...
详解Android USB转串口通信开发基本流程
01-20
`bulkTransfer()`用于批量数据传输，而`controlTransfer()`用于执行USB协议中的控制传输，比如设置设备状态。 8. **关闭设备** 完成通信后，记得使用`releaseInterface()`释放对`UsbInterface`的使用权，并使用`...
Androidusb流程分析.pdf
10-02
本文档主要探讨Android系统中的USB流程，特别是针对UMS（USB Mass Storage）模式的实现。分析从USB设备插入到状态栏弹出提示框，再到用户选择UMS功能的整个过程。由于USB框架在Android系统中的实现较为复杂，涉及到...
Android端USB连接示例
03-17
在Demo_USB1中，开发者可能已经实现了一个完整的USB连接流程，包括设备枚举、权限请求、接口选择、数据传输和关闭连接等步骤。这个示例代码是学习和实践Android USB连接功能的宝贵资源，通过阅读和理解代码，开发者...
android下usb框架系列文章---(5)Usb setting 中tethering 设置流程
u011279649的专栏
12-19 4796
Usbsetting 中tethering 设置流程   一 资源位置及入口文件 USB tethering, usb_tethering_button_text Xml/tether_prefs.xml------usb_tether_settings,布局文件 packages/apps/Settings/AndroidManifest.xml                Te
USB集腋成裘：从Linux PC角度看sys.usb.config为none时的Android设备
jymfist的专栏
01-29 825
当sys.usb.config为none时，android设备的USB接口就完全被锁死，无法使用，当然充电功能还是在的。 使用lsusb查看，会发现没有android设备的踪影。使用usbmon捉取USB BUS的信息，得到 ffff88012cd41e40 284839608 S Ci:2:030:0 s 80 06 0100 0000 0008 8 ffff88012cd41e40
USB 调试开关设置项
朝花夕拾
01-18 6169
打开 “USB 调试” 开关流程 在开发者模式中打开 “USB调试” 开关，程序会调用如下代码： public void onAdbDialogConfirmed() { writeAdbSetting(true); } 其中 writeAdbSetting 在 com.android.settingslib.development.AbstractEnableAdbPreferenceController 类中定义： protected void writeAdb
Android USB 属性设置：ADB、RNDIS、MTP等
热门推荐
ARM-Linux
12-01 3万+
Android手机：三星s4 Android5.0 内核：3.4.5 手机需root，且需要安装busybox和terminal Ubuntu版本：14.04 ------------------------------------------------------------ 1. 命令 设置属性：setprop persist.sys.usb.config 查看属性：get......
【BUG分析】手机启动时，adb打开较晚
编程菜鸟进阶之路
03-18 1778
Android版本：7.1.2内核版本：3.18要求：手机默认不开adb，只有手动打开时，以后每次开机才会打开adb，并且adb在system server启动之前打开。控制adb是否打开和USB功能的主要是两个属性：persist.sys.usb.config 和 sys.usb.config。sys.usb.config是一个临时的属性，每次关机后，都不存在了。但是，该属性主管usb功能，包括...
RK3399 Android7.1修改系统默认USB功能
u011774634的博客
05-05 1554
在device\rockchip\common\device.mk中修改persist.sys.usb.config的值，如下将USB功能默认设置为MTP（去掉ADB）： ifeq ($(strip $(BUILD_WITH_CDROM)),true) PRODUCT_PROPERTY_OVERRIDES += \ ro.factory.hasUMS=cdrom \ ro.factory.cdrom=$(BUILD_WITH...
解剖Android USB MTP 的激活流程
lylianlll的专栏
12-28 1万+
废话少说, 先上两张时序图 , 图片有点大, 建议用新窗口打开或者另存到本地查看 图1: UsbSettings的流程 图2: property属性的触发事件流程 好, 开始分析 从图1开始, 当用户从Setting UI里面点了一下那个MTP的选择框后,引起一系列的操作, 说白了,这里绕那么多个圈, 无非就是想发个消息通知UsbHandler而已, 然后就等待状
USB----调用过程和简单解释
Sindyue的博客
02-02 1534
01）设置包中对mUsbManager的调用   mUsbManager.setCurrentFunction(function, false);    ---> frameworks/base/core/java/android/hardware/usb/UsbManager.java   /** * Sets the current USB function
Androidusb流程分析样本.doc
11-20
Androidusb流程分析样本.doc

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值