精华内容
下载资源
问答
  • 手机无法弹出允许usb调试解决方法

    万次阅读 2016-04-11 18:58:54
    正常情况下,手机打开usb调试模式连接电脑会弹出允许usb调试对话框,选允许后就可以进行和调试有关的部署应用等操作.之前用的好好的,因刷机或其他操作有导致usb调试模式连接失败命令行中adb devices提示 daemon not ...
    • 注意: 此文针对以前连接电脑能正常调试,因某些原因导致不能使用调试模式的问题
    • 第一次连接电脑出问题的请另寻搜索

    正常情况下,手机打开usb调试模式连接电脑会弹出允许usb调试对话框,选允许后就可以进行和调试有关的部署应用等操作.

    之前用的好好的,因刷机或其他操作有导致usb调试模式连接失败

    命令行中adb devices提示

    • daemon not running. starting it now on port 5037
    • daemon started successfully
    • List of devices attached
    • XXXXXXXXXXXXXXXXXX unauthorized

    解决方法:

    usb调试模式连接电脑后,信息记录在如下两个文件夹之一.

    区别为是否配置ANDROID_SDK_HOME环境变量

    X:\Users\XXX.android

    X:\XXX\XXX\android-sdk-windows.android

    遇到上面的问题删除.android文件夹下adbkey和adbkey.pub文件

    再次连接手机.

    另外:

    • 因为以上原因,修改.android路径和其父路径也可能导致以上问题
    • 如果上面的方法未解决问题,请回忆自己最近有没有对.android路径有过修改,或者对环境变量有过修改
    展开全文
  • 问题 真机调试,连接USB后,通常会显示如下认证。...在开发者选项中撤销USB调试授权 执行 adb reconnect 重新插拔USB调试线 重新你的手机 尝试关闭,开启一次USB调试 尝试关闭开发者模式,重新打开开发者模式 ...

    问题

    真机调试,连接USB后,通常会显示如下认证。
    在这里插入图片描述
    未认证的设备显示如下
    在这里插入图片描述
    有些机器在某些情况下,可能没有弹出认证窗口,可以通过下面的方式尝试解决。

    解决

    • 执行 adb reconnect
    • 在开发者选项中撤销USB调试授权
      在这里插入图片描述
    • 重新插拔USB调试线
    • 重新你的手机
    • 尝试关闭,开启一次USB调试
    • 尝试关闭开发者模式,重新打开开发者模式

    上述方式没有顺序要求,一般其中一种方式即可解决问题

    展开全文
  • 在 AN 8.0 上,用上述命令adb调试真机时,首次连接会出现 “允许USB调试吗” 的弹窗 在串口调试工具敲命令 dumpsys activity activities | grep mResumedActivity 得知, 这个页面是 ...

    通过 adb 调试直接安装应用到真机上,简单方便。

    adb connect 192.168.1.1
    adb connect 192.168.1.1:5555 //指定端口为 5555

    在 AN 8.0 上,用上述命令adb调试真机时,首次连接会出现 “允许USB调试吗” 的弹窗,这个弹窗怎么出来的,源码一探究竟。
    在这里插入图片描述
    在串口调试工具敲命令 dumpsys activity activities | grep mResumedActivity 得知,
    这个页面是 com.android.systemui/.usb.UsbDebuggingActivity
    源码路径

    frameworks/base/packages/SystemUI/src/com/android/systemui/usb/UsbDebuggingActivity.java

    关注 onClick 方法,调用了 IUsbManagerallowUsbDebugging 方法。

    @Override
        public void onClick(DialogInterface dialog, int which) {
            boolean allow = (which == AlertDialog.BUTTON_POSITIVE);
            boolean alwaysAllow = allow && mAlwaysAllow.isChecked();
            try {
                IBinder b = ServiceManager.getService(USB_SERVICE);
                IUsbManager service = IUsbManager.Stub.asInterface(b);
                if (allow) {
                    service.allowUsbDebugging(alwaysAllow, mKey);
                } else {
                    service.denyUsbDebugging();
                }
            } catch (Exception e) {
                Log.e(TAG, "Unable to notify Usb service", e);
            }
            finish();
        }
    

    相关联的文件为:

    frameworks/base/services/usb/java/com/android/server/usb/UsbService.java
    frameworks/base/core/java/android/hardware/usb/IUsbManager.aidl
    frameworks/base/services/usb/java/com/android/server/usb/UsbDeviceManager.java
    frameworks/base/services/usb/java/com/android/server/usb/UsbDebuggingManager.java

    1 查看 UsbService.java ,实际调用的是 UsbDeviceManager.allowUsbDebugging(alwaysAllow, publicKey)

    private UsbDeviceManager mDeviceManager;
    
    @Override
        public void allowUsbDebugging(boolean alwaysAllow, String publicKey) {
            mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MANAGE_USB, null);
            mDeviceManager.allowUsbDebugging(alwaysAllow, publicKey);
        }
    

    2 查看 frameworks/base/services/usb/java/com/android/server/usb/UsbDeviceManager.java ,实际调用 UsbDebuggingManager.allowUsbDebugging(boolean alwaysAllow, String publicKey)

    private UsbDebuggingManager mDebuggingManager;
    
    public void allowUsbDebugging(boolean alwaysAllow, String publicKey) {
            if (mDebuggingManager != null) {
                mDebuggingManager.allowUsbDebugging(alwaysAllow, publicKey);
            }
        }
    

    3 查看 frameworks/base/services/usb/java/com/android/server/usb/UsbDebuggingManager.java ,发出了 MESSAGE_ADB_ALLOW 消息;

    public void allowUsbDebugging(boolean alwaysAllow, String publicKey) {
            Message msg = mHandler.obtainMessage(UsbDebuggingHandler.MESSAGE_ADB_ALLOW);
            msg.arg1 = alwaysAllow ? 1 : 0;
            msg.obj = publicKey;
            mHandler.sendMessage(msg);
        }
    

    UsbDebuggingHandler 内容如下,启动了 UsbDebuggingThread 以及 Handler 收发消息流程。

    class UsbDebuggingHandler extends Handler {
            private static final int MESSAGE_ADB_ENABLED = 1;
            private static final int MESSAGE_ADB_DISABLED = 2;
            private static final int MESSAGE_ADB_ALLOW = 3;
            private static final int MESSAGE_ADB_DENY = 4;
            private static final int MESSAGE_ADB_CONFIRM = 5;
            private static final int MESSAGE_ADB_CLEAR = 6;
    
            public UsbDebuggingHandler(Looper looper) {
                super(looper);
            }
    
            public void handleMessage(Message msg) {
                switch (msg.what) {
                    case MESSAGE_ADB_ENABLED:
                        if (mAdbEnabled)
                            break;
    
                        mAdbEnabled = true;
    
                        mThread = new UsbDebuggingThread();
                        mThread.start();
    
                        break;
    
                    case MESSAGE_ADB_DISABLED:
                        if (!mAdbEnabled)
                            break;
    
                        mAdbEnabled = false;
    
                        if (mThread != null) {
                            mThread.stopListening();
                            mThread = null;
                        }
    
                        break;
    
                    case MESSAGE_ADB_ALLOW: {
                        String key = (String)msg.obj;
                        String fingerprints = getFingerprints(key);
    
                        if (!fingerprints.equals(mFingerprints)) {
                            Slog.e(TAG, "Fingerprints do not match. Got "
                                    + fingerprints + ", expected " + mFingerprints);
                            break;
                        }
    
                        if (msg.arg1 == 1) {
                            writeKey(key);
                        }
    
                        if (mThread != null) {
                            mThread.sendResponse("OK");
                        }
                        break;
                    }
    
                    case MESSAGE_ADB_DENY:
                        if (mThread != null) {
                            mThread.sendResponse("NO");
                        }
                        break;
    
                    case MESSAGE_ADB_CONFIRM: {
                        if ("trigger_restart_min_framework".equals(
                                SystemProperties.get("vold.decrypt"))) {
                            Slog.d(TAG, "Deferring adb confirmation until after vold decrypt");
                            if (mThread != null) {
                                mThread.sendResponse("NO");
                            }
                            break;
                        }
                        String key = (String)msg.obj;
                        String fingerprints = getFingerprints(key);
                        if ("".equals(fingerprints)) {
                            if (mThread != null) {
                                mThread.sendResponse("NO");
                            }
                            break;
                        }
                        mFingerprints = fingerprints;
                        startConfirmation(key, mFingerprints);
                        break;
                    }
    
                    case MESSAGE_ADB_CLEAR:
                        deleteKeyFile();
                        break;
                }
            }
        }
    

    其中 if (msg.arg1 == 1) { writeKey(key); } 就是如果勾选了 “一律允许这台计算机进行调试” ,则将对应的 key 保存到 data/misc/adb/adb_keys 文件里。

    说到这里,弹窗的逻辑实现就知道了。
    不对啊,还是没说弹窗怎么出来的。别急,继续。

    UsbDebuggingManager.java 的 log 开关打开,

    -    private static final boolean DEBUG = false;
    +    private static final boolean DEBUG = true;
    

    首次执行 adb connect 会出现如下 log :

    07-06 16:34:58.167  1570  2615 D UsbDebuggingManager: Received public key: QAAAAGkQ5x8ngNhLRdKw3vO6i8jRUZeQzah1weiQuMq1z1sjaB8Otto2ISD66X+sxmjxIj4CpTqIlGJxsfmn74yylU0menZepnLE4031e5E4sOT/07MAW+JtVipMTS1JareqAv5PCVof1tTzS5iy2L4iudG7POBMki39r4OCUKmpOlmMdZQBhR1ADpcK/rystSgJm9mpbWv38UN4KcNS+x5w0sKx/bNp3yJ/oY1hLWnWbHJDL0KMVChr7+Fb7hc9VwOUS5G4V1YkNaa7LTM7PHGN6WknevqIp2SxCvkE5J6/1FbtBWk/HGrf3fuPKoQEQmKQdVzm+ysN0ErZ1L6JnKu6mtZofb6wVEAODhVMWrWY3YhFt/IHucDTWkCByXcmERmHpkcLtGk6w8nq+6COpfFkRoX2ZP4IZUyn8aqI5Mm4xf95RwK6vVwNhFsYzp8RctD2qVWq5nL5iCwqp9n2i4etShmjNH/VFIpaoP/H5YXP8bMBnYjPfTU9kUYn0kpRgHHQ8kkiXrLJ5XFwrKFAv0pSK9W0kDJFsaRvkLb2H3EebqJnZdWEeTq0haBAMjoesbUI0lmxtJ9zaE5rsbh/NWXs/SlFHMvY3wH99b7ZH8UqBc4bJGDQd4oi8gKeXHLh574EmGf9G6/I+eV2zKgknL+RJtnhyc8FvS+SV8Suh9o5PjF6OVA4pwEAAQA= @unknown
    

    依据 Received public key 关键字找到 UsbDebuggingManager --> UsbDebuggingThread

    class UsbDebuggingThread extends Thread {
            private boolean mStopped;
            private LocalSocket mSocket;
            private OutputStream mOutputStream;
            private InputStream mInputStream;
    
            UsbDebuggingThread() {
                super(TAG);
            }
    
            @Override
            public void run() {
                if (DEBUG) Slog.d(TAG, "Entering thread");
                while (true) {
                    synchronized (this) {
                        if (mStopped) {
                            if (DEBUG) Slog.d(TAG, "Exiting thread");
                            return;
                        }
                        try {
                            openSocketLocked();
                        } catch (Exception e) {
                            /* Don't loop too fast if adbd dies, before init restarts it */
                            SystemClock.sleep(1000);
                        }
                    }
                    try {
                        listenToSocket();
                    } catch (Exception e) {
                        /* Don't loop too fast if adbd dies, before init restarts it */
                        SystemClock.sleep(1000);
                    }
                }
            }
    
            private void openSocketLocked() throws IOException {
                try {
                    LocalSocketAddress address = new LocalSocketAddress(ADBD_SOCKET,
                            LocalSocketAddress.Namespace.RESERVED);
                    mInputStream = null;
    
                    if (DEBUG) Slog.d(TAG, "Creating socket");
                    mSocket = new LocalSocket();
                    mSocket.connect(address);
    
                    mOutputStream = mSocket.getOutputStream();
                    mInputStream = mSocket.getInputStream();
                } catch (IOException ioe) {
                    closeSocketLocked();
                    throw ioe;
                }
            }
    
            private void listenToSocket() throws IOException {
                try {
                    byte[] buffer = new byte[BUFFER_SIZE];
                    while (true) {
                        int count = mInputStream.read(buffer);
                        if (count < 0) {
                            break;
                        }
    
                        if (buffer[0] == 'P' && buffer[1] == 'K') {
                            String key = new String(Arrays.copyOfRange(buffer, 2, count));
                            Slog.d(TAG, "Received public key: " + key);
                            Message msg = mHandler.obtainMessage(UsbDebuggingHandler.MESSAGE_ADB_CONFIRM);
                            msg.obj = key;
                            mHandler.sendMessage(msg);
                        } else {
                            Slog.e(TAG, "Wrong message: "
                                    + (new String(Arrays.copyOfRange(buffer, 0, 2))));
                            break;
                        }
                    }
                } finally {
                    synchronized (this) {
                        closeSocketLocked();
                    }
                }
            }
    
            private void closeSocketLocked() {
                if (DEBUG) Slog.d(TAG, "Closing socket");
                try {
                    if (mOutputStream != null) {
                        mOutputStream.close();
                        mOutputStream = null;
                    }
                } catch (IOException e) {
                    Slog.e(TAG, "Failed closing output stream: " + e);
                }
    
                try {
                    if (mSocket != null) {
                        mSocket.close();
                        mSocket = null;
                    }
                } catch (IOException ex) {
                    Slog.e(TAG, "Failed closing socket: " + ex);
                }
            }
    
            /** Call to stop listening on the socket and exit the thread. */
            void stopListening() {
                synchronized (this) {
                    mStopped = true;
                    closeSocketLocked();
                }
            }
    
            void sendResponse(String msg) {
                synchronized (this) {
                    if (!mStopped && mOutputStream != null) {
                        try {
                            mOutputStream.write(msg.getBytes());
                        }
                        catch (IOException ex) {
                            Slog.e(TAG, "Failed to write response:", ex);
                        }
                    }
                }
            }
        }
    

    代码流程为 UsbDebuggingThread 通过 openSocketLocked() 开启 Socket 连接并且监听 listenToSocket()
    收到 adb connect 消息后,发出 msg UsbDebuggingHandler.MESSAGE_ADB_CONFIRM ,
    查看 UsbDebuggingHandler 可知,调用了 startConfirmation(key, mFingerprints);

    private void startConfirmation(String key, String fingerprints) {
            int currentUserId = ActivityManager.getCurrentUser();
            UserHandle userHandle =
                    UserManager.get(mContext).getUserInfo(currentUserId).getUserHandle();
            String componentString;
            if (currentUserId == UserHandle.USER_OWNER) {
                componentString = Resources.getSystem().getString(
                        com.android.internal.R.string.config_customAdbPublicKeyConfirmationComponent);
            } else {
                // If the current foreground user is not the primary user we send a different
                // notification specific to secondary users.
                componentString = Resources.getSystem().getString(
                        R.string.config_customAdbPublicKeyConfirmationSecondaryUserComponent);
            }
            ComponentName componentName = ComponentName.unflattenFromString(componentString);
            if (startConfirmationActivity(componentName, userHandle, key, fingerprints)
                    || startConfirmationService(componentName, userHandle, key, fingerprints)) {
                return;
            }
            Slog.e(TAG, "unable to start customAdbPublicKeyConfirmation[SecondaryUser]Component "
                    + componentString + " as an Activity or a Service");
        }
    
    	/**
         * @returns true if the componentName led to an Activity that was started.
         */
        private boolean startConfirmationActivity(ComponentName componentName, UserHandle userHandle,
                String key, String fingerprints) {
            PackageManager packageManager = mContext.getPackageManager();
            Intent intent = createConfirmationIntent(componentName, key, fingerprints);
            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
            if (packageManager.resolveActivity(intent, PackageManager.MATCH_DEFAULT_ONLY) != null) {
                try {
                    mContext.startActivityAsUser(intent, userHandle);
                    return true;
                } catch (ActivityNotFoundException e) {
                    Slog.e(TAG, "unable to start adb whitelist activity: " + componentName, e);
                }
            }
            return false;
        }
    

    其中,com.android.internal.R.string.config_customAdbPublicKeyConfirmationComponent
    文件 frameworks/base/core/res/res/values/config.xml 中,值为

    <!-- Name of the activity or service that prompts the user to reject, accept, or whitelist
             an adb host's public key, when an unwhitelisted host connects to the local adbd.
             Can be customized for other product types -->
        <string name="config_customAdbPublicKeyConfirmationComponent"
                >com.android.systemui/com.android.systemui.usb.UsbDebuggingActivity</string>
    
        <!-- Name of the activity that prompts the secondary user to acknowledge she/he needs to
             switch to the primary user to enable USB debugging.
             Can be customized for other product types -->
        <string name="config_customAdbPublicKeyConfirmationSecondaryUserComponent"
                >com.android.systemui/com.android.systemui.usb.UsbDebuggingSecondaryUserActivity</string>
    

    这样就清楚了,最终根据包名信息 com.android.systemui/com.android.systemui.usb.UsbDebuggingActivity 打开了“允许USB调试吗” 页面。

    总结如下:

    1.开机后启动 UsbService ,UsbDebuggingThread 一直检测 adb 消息;
    2.收到 adb connect 消息后,通过 UsbDebuggingHandler 调起 SystemUI 的 UsbDebuggingActivity 页面。

    展开全文
  • 手机连接新的电脑后会出现一下![图片说明](https://img-ask.csdn.net/upload/202004/29/1588146428_475706.png) 怎么跳过这个,或者连接电脑出现就自动同意 最好是直接自动同意
  • 本人做个4年的android 开发但都是在App...需求:当开发人员用usb调试线连接PC与android设备时弹出一个自定义UI界面,有两个按钮和一个输入框 - 手机号码输入框:输入手机号 - 获取验证码:点击向服务器请求一个手机号

    做了4年的android 开发但都是在App应用层上的,最近公司转型做android智能硬件,碰到一些需求需要修改android源代码在这里做一下记录免得做完就忘了,属于rom开发的新手写的不对还望各位提点。
    需求:当开发人员用usb调试线连接PC与android设备时弹出一个自定义UI界面,有两个按钮和一个输入框
    - 手机号码输入框:输入手机号
    - 获取验证码:点击向服务器请求一个手机号对应的验证码
    - 确定:手机号与验证码如果与服务器一致则允许进入调试

    了解相关原理和框架代码

    android的adb debug调试是通过usb来完成的,首先要了解android设备是如何授权adb调试的还有android的usb相关架构及其代码。
    这方面网上文章很多:
    http://blog.csdn.net/sowhat_ah/article/details/43307907 (adb授权原理)
    http://blog.csdn.net/tianruxishui/article/details/37902959 (usb框架)

    android frameworks层的usb框架在 frameworks/base/services/java下的com.android.server.usb包中,我的源码在这个包下有这么几个文件:
    - UsbDebuggingManager.java
    - UsbDeviceManager.java
    - UsbHostManager.java
    - UsbService.java
    - UsbSettingsManager.java

    其中以UsbService.java(IUsbManager aidl接口实现)为基础来驱动框架的其他类文件,而UsbService.java是在com.android.server包下的ServerThread.java的initAndLoop()函数中被实例化的,以此为入口来了解usb框架的运行机制。(这部分后面再补上)

    实现原理

    修改ro.adb.secure默认值

    android4.4通过一个名为 ro.adb.secure 的常量来控制是否弹出adb debug调试授权的窗口
    在UsbDeviceManager.java构造函数中有这样一段代码:

            boolean secureAdbEnabled = SystemProperties.getBoolean("ro.adb.secure", false);
            boolean dataEncrypted = "1".equals(SystemProperties.get("vold.decrypt"));
    
            if (secureAdbEnabled && !dataEncrypted) {
                mDebuggingManager = new UsbDebuggingManager(context);
            }

    可以看到通过ro.adb.secure这个key拿到的boolean值secureAdbEnabled如果是true并且通过vold.decrypt这个key拿到的值不是”1”, 那么dataEncrypted是false,那么就会实例化一个UsbDebuggingManager对象,而UsbDebuggingManager对象就是弹出adb debug授权窗口的一整套流程的入口,至于vold.decrypt常量暂时还没去研究。
    要注意的是通过ro.adb.secure这个key拿到的boolean值如果是false(有些源码平台默认是false的)那么就不会进入授权认证流程也就是不会弹出 允许USB调试吗? 的窗口直接就可以进行调试了而我这边的需求是要改变这个窗口的样式和按钮逻辑所以必须让它弹出来,如何改变ro.adb.secure的默认值网上也有很多文章:
    http://www.tuicool.com/articles/UBF7ji (开启与关闭adb 的认证机制),解决这个之后或者你开发的源码平台默认就是开启的那么当你插入usb调试线连接PC与android设备的时候就会弹出一个窗口,这个窗口的弹出逻辑就是在UsbDebuggingManager.java中。

    修改UsbDebuggingManager.java

    在UsbDebuggingManager.java的showConfirmationDialog函数中:

        private void showConfirmationDialog(String key, String fingerprints) {
            Intent dialogIntent = new Intent();
    
            dialogIntent.setClassName("com.android.systemui",
                    "com.android.systemui.usb.UsbDebuggingActivity");
            dialogIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
            dialogIntent.putExtra("key", key);
            dialogIntent.putExtra("fingerprints", fingerprints);
            try {
                mContext.startActivity(dialogIntent);
            } catch (ActivityNotFoundException e) {
                Slog.e(TAG, "unable to start UsbDebuggingActivity");
            }
        }

    代码中的UsbDebuggingActivity就是授权弹出窗口的Activity在framewieks/base/packages/SystemUI/src下的com.android.systemui.usb包下。
    实现我的需求有两种方法:
    1.读懂并理解UsbDebuggingActivity的代码复制一个修改下文件名放在同一包下,根据需求修改下UI和逻辑然后在上面说道的showConfirmationDialog函数中启动我们自己的Activity窗口。
    2.在showConfirmationDialog函数中使用AIDL接口与上层App通信通知上层弹出窗口,验证成功或者失败通过aidl回调控制是否允许adb调试,在源码中使用aidl文件需要在Android.mk文件中配置一下这个网上也可以查得到。

    我使用的是第二种方法,这其中有许多细节我这次只是做一下记录,这里就不多写了反正大概思路就是这样,以后有机会再补充吧。

    展开全文
  • Android开发华为荣耀9连接USB调试问题

    千次阅读 2018-08-24 15:22:37
    笔者在最近开发中进行真机调试的时候遇到了荣耀手机无法连接USB调试的问题,现在记录一下: 打开设置,点击关于手机,连续点击版本号直到出现您正处于开发者模式!提示。 返回上一级菜单,打开开发者选项,先选择...
  • 先用数据线把手机连接到电脑上 在手机设置中,寻找开发者选项。...然后返回设置进入“开发人员选项”,再找到并勾选“USB调试”和“仅充电模式下允许ADB调试”。 然后返回设置中找到“安全…”,点击进入,...
  • 然后在开启“USB调试”开关后,一并将“'仅充电'模式下允许ADB调试”选项开关打开。这样,华为手机usb调试打开后,就不会自动关闭了。 03 解决方法二我们打开usb调试一般就是为了将手机连接到电脑上。其次,...
  • Android usb调试无法鉴权的解决方法

    千次阅读 2016-09-30 13:16:25
    注意: 此文针对以前连接电脑能正常调试,因...正常情况下,手机打开usb调试模式连接电脑会弹出允许usb调试对话框,选允许后就可以进行和调试有关的部署应用等操作.之前用的好好的,因刷机或其他操作有导致usb调试模式连接
  • ---作者吴疆,未经允许,严禁转载,违权必究--...功能说明:宇泰UT-890A USB转RS-485/422串口连接线的使用、串口调试助手的使用 运行环境:Windows7 文件下载:驱动程序下载uw6n 一、宇泰UT-890A的使用 该产...
  • 3.在更多设置中选择开发者选项,在开发者选项中同时勾选USB调试和USB安装的开关 对Android Studio 的设置: 1.在工具栏中找到app,点开后选择“Edit configurations” 2.选择其中的Target为 USB Devi
  •  2、手机允许USB调试” 电脑端:  1、打开Android Studio --> 选择“File” --> ‘Settings’    2、勾选Google USB driver  3、查看需要连接的手机的Andriod版本号,还是在这个页面,SDK Platfor
  • adb 通过USB连接手机

    千次阅读 2020-04-24 16:39:07
    会弹出“是否允许USB调试”,点击确定 会再弹出“是否允许USB调试”,点击确定 插曲1:你的开发者选项可能搜索不出来 解决办法: ①设置里搜索关于手机 ②找到版本号,多次点击 ③直到出现“弹出您已处于开发者...
  • 设置 —> 应用程序 —> 开发 , 选择【USB调试】。 设置 —> 应用程序 —> 开发 , 选择【USB调试】。
  • 打开 "开发者选项" >... 勾选:USB调试、“仅充电”模式下允许ADB调试、监控ADB安装应用。如不起作用,可“撤销USB调试授权”再试一次。 原因推测:可能因为未勾选“监控ADB安装应用”造成安全问题而阻塞的。 ...
  • Android Studio使用USB真机调试

    万次阅读 2017-05-11 16:07:40
    以小米4为例,先将手机通过USB连接电脑,在设备管理器中确保驱动安装正确。 对手机的设置 ...2.在更多设置中找到系统安全设置——...3.在更多设置中选择开发者选项,在开发者选项中同时勾选USB调试和USB安装的开关
  • Android ADB调试之无线连接设备

    千次阅读 2019-05-13 12:39:56
    Android无线调试 一、数据线连接手机和电脑(首次设置需数据...1、开发人员选项 2、USB调试 3、监控ADB安装应用 4、仅充电 模式下允许ADB调试 5、选择USB配置 仅充电 三、手机和电脑连接同一个Wi-Fi 四、Android...
  • 1.安装配置Android studio2.2 ...允许USB调试 4.查看手机连接是否连接成功 win+R,打开cmd,输入adb device 如果显示设备,则连接成功,若为空则存在错误。 5.在Android studio中运行项目,选择手机设备...
  • android studio连接华为真机调试

    千次阅读 2020-02-17 17:16:03
    因疫情影响,在家办公,家里没有android...设置-》系统-》关于手机-》多次单击 “版本号”,进入开发者模式,再返回《系统》项-》开发人员选项-》USB调试 打开 -》 “仅充电”模式下允许ADB调试 打开。 发现android...
  • 荣耀9i真机调试--连接

    2018-10-17 15:45:00
    打开设置 ->系统 ->关于手机 ->...有提示框跳出显示打开开发者模式 ...返回上一步到系统页(多出一个开发人员选项) ...然后打开USB调试 ->点击项目工具栏的Run ->选择Debug ‘app’ ...
  • 手机打开USB调试,插上数据线,连接到电脑 如果报adb不是内部命令错误,找到SDK目录下adb.exe通过cmd打开命令行窗口 手机会弹出USB允许调试提示窗口,允许,然后就可以断开USB数据线连接了 打开手机WIFI查看自己的...
  • ②手机打开开发者模式,打开USB调试以及允许ADB的相关权限 步骤: ①数据线连接手机和电脑; ②在命令行里输入adb devices查看连接的设备; ③使用adb tcpip 8888 设置端口号,默认端口号为5555,端口号为4位数; ...
  • 以小米4为例,先将手机通过USB连接电脑,在设备管理器中确保驱动安装正确。...3.在更多设置中选择开发者选项,在开发者选项中同时勾选USB调试和USB安装的开关 对Android Studio 的设置: 1.在工具栏中...
  • uni-app USB连接真机测试

    千次阅读 2019-11-12 16:31:07
    1、连接手机到电脑,允许开发调试 当现在红框的内容就说明连接上了 2、制作自定义基座 3、选择自定义基座 4、运行
  • 3:手机允许这台计算机对手机进行USB调试,自动安装app到手机,成功进行真机调试。 4:题外话:如果手机连接电脑,自动连接window meida player, 在控制面板/程序和功能/左侧-启用或者关闭 windows功能。关闭就...
  • 小米手机连接USB安装应用出错

    千次阅读 2017-02-17 22:53:02
    * adb connect命令连接设备,必需要设备为root。 小米手机使用USB连接安装应用失败...在“开发者选项” 勾选 “USB安装(允许通过USB安装应用)”以及“USB调试(安全设置) (允许电脑通过USB刷机)”及可正常安装应用

空空如也

空空如也

1 2 3 4 5 ... 17
收藏数 323
精华内容 129
关键字:

允许usb调试连接