Android13 外置USB存储设备权限和用户组配置

已于 2024-09-24 20:31:59 修改
阅读量506 收藏 1
点赞数 16
分类专栏： Android 文章标签： android 经验分享
于 2024-08-29 15:37:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lingzhou0909/article/details/141678500
版权

前言

近期在Android13的项目上碰到需求，要将挂载的外置USB存储设备的权限和用户组对齐Android9.0上的配置，花了些时间调试，遂作记录。Android13与Android9之前相隔几个版本，其中对于Android13设备，有

drwxrwx--- 24 root media_rw 32K 1970-01-01 09:00 FCFC-0F19 //外部存储
rk3399:/mnt/user/0 # ls lh FCFC-0F19/
drwxrwx--- 3 root media_rw 32K 2024-08-05 04:02 Alarms
drwxrwx--- 3 root media_rw 32K 2024-06-18 02:33 Android
drwxrwx--- 2 root media_rw 32K 2024-07-02 17:56 Audiobooks

对于Android9设备，有

drwxrwx-- 26 media_rw media_rw 16K 1970-01-01 09:00 FCFC-0F19 //外部存储
rk3399:/mnt/media_rw # ls lh C2A0-7951/
drwxrwx-- 2 media_rw media_rw 16K 2024-06-17 16:02 20240522
drwxrwx--- 4 media_rw media_rw 16K 2023-07-29 22:22 PATCH
drwxrwx--- 2 media_rw media_rw 16K 2024-08-09 17:18 Alarms

可见，两者之间主要是用户组上有所区别。

修改方法

在Android13中想修改对应目录权限和用户组的话，可以在这里进行修改：

system/vold/model/PublicVolume.cpp

该源码如下：

/*
 * Copyright (C) 2015 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.
 */

#include "PublicVolume.h"

#include "AppFuseUtil.h"
#include "Utils.h"
#include "VolumeManager.h"
#include "fs/Exfat.h"
#include "fs/Vfat.h"
#include "fs/Ext4.h"
#include "fs/F2fs.h"
#include "fs/Ntfs.h"

#include <cutils/properties.h>

#include <android-base/logging.h>
#include <android-base/properties.h>
#include <android-base/stringprintf.h>
#include <cutils/fs.h>
#include <private/android_filesystem_config.h>
#include <utils/Timers.h>

#include <fcntl.h>
#include <stdlib.h>
#include <sys/mount.h>
#include <sys/stat.h>
#include <sys/sysmacros.h>
#include <sys/types.h>
#include <sys/wait.h>

using android::base::GetBoolProperty;
using android::base::StringPrintf;

namespace android {
namespace vold {

static const char* kSdcardFsPath = "/system/bin/sdcard";

static const char* kAsecPath = "/mnt/secure/asec";

PublicVolume::PublicVolume(dev_t device) : VolumeBase(Type::kPublic), mDevice(device) {
    setId(StringPrintf("public:%u,%u", major(device), minor(device)));
    mDevPath = StringPrintf("/dev/block/vold/%s", getId().c_str());
    mFuseMounted = false;
    mUseSdcardFs = IsSdcardfsUsed();
}

PublicVolume::~PublicVolume() {}

status_t PublicVolume::readMetadata() {
    status_t res = ReadMetadataUntrusted(mDevPath, &mFsType, &mFsUuid, &mFsLabel);

    auto listener = getListener();
    if (listener) listener->onVolumeMetadataChanged(getId(), mFsType, mFsUuid, mFsLabel);

    return res;
}

status_t PublicVolume::initAsecStage() {
    std::string legacyPath(mRawPath + "/android_secure");
    std::string securePath(mRawPath + "/.android_secure");

    // Recover legacy secure path
    if (!access(legacyPath.c_str(), R_OK | X_OK) && access(securePath.c_str(), R_OK | X_OK)) {
        if (rename(legacyPath.c_str(), securePath.c_str())) {
            PLOG(WARNING) << getId() << " failed to rename legacy ASEC dir";
        }
    }

    if (TEMP_FAILURE_RETRY(mkdir(securePath.c_str(), 0700))) {
        if (errno != EEXIST) {
            PLOG(WARNING) << getId() << " creating ASEC stage failed";
            return -errno;
        }
    }

    BindMount(securePath, kAsecPath);

    return OK;
}

status_t PublicVolume::doCreate() {
    return CreateDeviceNode(mDevPath, mDevice);
}

status_t PublicVolume::doDestroy() {
    return DestroyDeviceNode(mDevPath);
}

status_t PublicVolume::doMount() {
    bool isVisible = isVisibleForWrite();
    readMetadata();

    if (mFsType == "vfat" && vfat::IsSupported()) {
        if (vfat::Check(mDevPath)) {
            LOG(ERROR) << getId() << " failed filesystem check";
            return -EIO;
        }
    } else if (mFsType == "exfat" && exfat::IsSupported()) {
        if (exfat::Check(mDevPath)) {
            LOG(ERROR) << getId() << " failed filesystem check";
            return -EIO;
        }
    }  else if (mFsType == "ntfs") {
        char value[PROPERTY_VALUE_MAX];
        property_get("ro.factory.storage_suppntfs", value, "");
        if (strcmp("true", value) == 0) {
            int res = ntfs::Check(mDevPath.c_str());
            if (res == 0 || res == 1) {
                LOG(DEBUG) << getId() << " passed filesystem check";
            } else {
                PLOG(ERROR) << getId() << " failed filesystem check";
                return -EIO;
            }
        }
        else
        {
            LOG(DEBUG) << getId() << "Not support Ntfs in BoardConfig";
        }
    }  else if (mFsType == "ext4" && ext4::IsSupported()) {
        int res = ext4::Check(mDevPath, mRawPath);
        if (res == 0 || res == 1) {
            LOG(DEBUG) << getId() << " passed filesystem check";
        } else {
            PLOG(ERROR) << getId() << " failed filesystem check";
            return -EIO;
        }
    }  else if (mFsType == "f2fs" && f2fs::IsSupported()) {
        int res = f2fs::Check(mDevPath);
        if (res == 0) {
            LOG(DEBUG) << getId() << " passed filesystem check";
        } else {
            PLOG(ERROR) << getId() << " failed filesystem check";
            return -EIO;
        }
    } else {
        LOG(ERROR) << getId() << " unsupported filesystem " << mFsType;
        return -EIO;
    }

    // Use UUID as stable name, if available
    std::string stableName = getId();
    if (!mFsUuid.empty()) {
        stableName = mFsUuid;
    }

    mRawPath = StringPrintf("/mnt/media_rw/%s", stableName.c_str());

    mSdcardFsDefault = StringPrintf("/mnt/runtime/default/%s", stableName.c_str());
    mSdcardFsRead = StringPrintf("/mnt/runtime/read/%s", stableName.c_str());
    mSdcardFsWrite = StringPrintf("/mnt/runtime/write/%s", stableName.c_str());
    mSdcardFsFull = StringPrintf("/mnt/runtime/full/%s", stableName.c_str());

    setInternalPath(mRawPath);
    if (isVisible) {
        setPath(StringPrintf("/storage/%s", stableName.c_str()));
    } else {
        setPath(mRawPath);
    }

    if (fs_prepare_dir(mRawPath.c_str(), 0700, AID_ROOT, AID_ROOT)) {
        PLOG(ERROR) << getId() << " failed to create mount points";
        return -errno;
    }

    if (mFsType == "vfat") {
        if (vfat::Mount(mDevPath, mRawPath, false, false, false, AID_ROOT,
                        (isVisible ? AID_MEDIA_RW : AID_EXTERNAL_STORAGE), 0007, true)) {
            PLOG(ERROR) << getId() << " failed to mount " << mDevPath;
            return -EIO;
        }
    } else if (mFsType == "exfat") {
        if (exfat::Mount(mDevPath, mRawPath, AID_ROOT,
                         (isVisible ? AID_MEDIA_RW : AID_EXTERNAL_STORAGE), 0007)) {
            PLOG(ERROR) << getId() << " failed to mount " << mDevPath;
            return -EIO;
        }
    } else if (mFsType == "ntfs") {
        if (ntfs::Mount(mDevPath, mRawPath, false, false, false, AID_ROOT,
                        (isVisible ? AID_MEDIA_RW : AID_EXTERNAL_STORAGE), 0007, true)) {
            PLOG(ERROR) << getId() << " nfts failed to mount " << mDevPath;
            return -EIO;
        }
    } else if (mFsType == "ext4") {
        if (ext4::Mount(mDevPath, mRawPath, false, false, true)) {
            PLOG(ERROR) << getId() << " failed to mount " << mDevPath;
            return -EIO;
        }
    } else if (mFsType == "f2fs") {
        if (f2fs::Mount(mDevPath, mRawPath)) {
            PLOG(ERROR) << getId() << " failed to mount " << mDevPath;
             return -EIO;
        }
    }

    if (getMountFlags() & MountFlags::kPrimary) {
        initAsecStage();
    }

    if (!isVisible) {
        // Not visible to apps, so no need to spin up sdcardfs or FUSE
        return OK;
    }

    if (mUseSdcardFs) {
        if (fs_prepare_dir(mSdcardFsDefault.c_str(), 0700, AID_ROOT, AID_ROOT) ||
            fs_prepare_dir(mSdcardFsRead.c_str(), 0700, AID_ROOT, AID_ROOT) ||
            fs_prepare_dir(mSdcardFsWrite.c_str(), 0700, AID_ROOT, AID_ROOT) ||
            fs_prepare_dir(mSdcardFsFull.c_str(), 0700, AID_ROOT, AID_ROOT)) {
            PLOG(ERROR) << getId() << " failed to create sdcardfs mount points";
            return -errno;
        }

        dev_t before = GetDevice(mSdcardFsFull);

        int sdcardFsPid;
        if (!(sdcardFsPid = fork())) {
            if (getMountFlags() & MountFlags::kPrimary) {
                // clang-format off
                if (execl(kSdcardFsPath, kSdcardFsPath,
                        "-u", "1023", // AID_MEDIA_RW
                        "-g", "1023", // AID_MEDIA_RW
                        "-U", std::to_string(getMountUserId()).c_str(),
                        "-w",
                        mRawPath.c_str(),
                        stableName.c_str(),
                        NULL)) {
                    // clang-format on
                    PLOG(ERROR) << "Failed to exec";
                }
            } else {
                // clang-format off
                if (execl(kSdcardFsPath, kSdcardFsPath,
                        "-u", "1023", // AID_MEDIA_RW
                        "-g", "1023", // AID_MEDIA_RW
                        "-U", std::to_string(getMountUserId()).c_str(),
                        "-w",
                        mRawPath.c_str(),
                        stableName.c_str(),
                        NULL)) {
                    // clang-format on
                    PLOG(ERROR) << "Failed to exec";
                }
            }

            LOG(ERROR) << "sdcardfs exiting";
            _exit(1);
        }

        if (sdcardFsPid == -1) {
            PLOG(ERROR) << getId() << " failed to fork";
            return -errno;
        }

        nsecs_t start = systemTime(SYSTEM_TIME_BOOTTIME);
        while (before == GetDevice(mSdcardFsFull)) {
            LOG(DEBUG) << "Waiting for sdcardfs to spin up...";
            usleep(50000);  // 50ms

            nsecs_t now = systemTime(SYSTEM_TIME_BOOTTIME);
            if (nanoseconds_to_milliseconds(now - start) > 5000) {
                LOG(WARNING) << "Timed out while waiting for sdcardfs to spin up";
                return -ETIMEDOUT;
            }
        }
        /* sdcardfs will have exited already. The filesystem will still be running */
        TEMP_FAILURE_RETRY(waitpid(sdcardFsPid, nullptr, 0));
    }

    // We need to mount FUSE *after* sdcardfs, since the FUSE daemon may depend
    // on sdcardfs being up.
    LOG(INFO) << "Mounting public fuse volume";
    android::base::unique_fd fd;
    int user_id = getMountUserId();
    int result = MountUserFuse(user_id, getInternalPath(), stableName, &fd);

    if (result != 0) {
        LOG(ERROR) << "Failed to mount public fuse volume";
        doUnmount();
        return -result;
    }

    mFuseMounted = true;
    auto callback = getMountCallback();
    if (callback) {
        bool is_ready = false;
        callback->onVolumeChecking(std::move(fd), getPath(), getInternalPath(), &is_ready);
        if (!is_ready) {
            LOG(ERROR) << "Failed to complete public volume mount";
            doUnmount();
            return -EIO;
        }
    }

    ConfigureReadAheadForFuse(GetFuseMountPathForUser(user_id, stableName), 256u);

    // See comment in model/EmulatedVolume.cpp
    ConfigureMaxDirtyRatioForFuse(GetFuseMountPathForUser(user_id, stableName), 40u);

    return OK;
}

status_t PublicVolume::doUnmount() {
    // Unmount the storage before we kill the FUSE process. If we kill
    // the FUSE process first, most file system operations will return
    // ENOTCONN until the unmount completes. This is an exotic and unusual
    // error code and might cause broken behaviour in applications.
    KillProcessesUsingPath(getPath());

    if (mFuseMounted) {
        // Use UUID as stable name, if available
        std::string stableName = getId();
        if (!mFsUuid.empty()) {
            stableName = mFsUuid;
        }

        if (UnmountUserFuse(getMountUserId(), getInternalPath(), stableName) != OK) {
            PLOG(INFO) << "UnmountUserFuse failed on public fuse volume";
            return -errno;
        }

        mFuseMounted = false;
    }

    ForceUnmount(kAsecPath);

    if (mUseSdcardFs) {
        ForceUnmount(mSdcardFsDefault);
        ForceUnmount(mSdcardFsRead);
        ForceUnmount(mSdcardFsWrite);
        ForceUnmount(mSdcardFsFull);

        rmdir(mSdcardFsDefault.c_str());
        rmdir(mSdcardFsRead.c_str());
        rmdir(mSdcardFsWrite.c_str());
        rmdir(mSdcardFsFull.c_str());

        mSdcardFsDefault.clear();
        mSdcardFsRead.clear();
        mSdcardFsWrite.clear();
        mSdcardFsFull.clear();
    }
    ForceUnmount(mRawPath);
    rmdir(mRawPath.c_str());
    mRawPath.clear();

    return OK;
}

status_t PublicVolume::doFormat(const std::string& fsType) {
    bool useVfat = vfat::IsSupported();
    bool useExfat = exfat::IsSupported();
    status_t res = OK;

    // Resolve the target filesystem type
    if (fsType == "auto" && useVfat && useExfat) {
        uint64_t size = 0;

        res = GetBlockDevSize(mDevPath, &size);
        if (res != OK) {
            LOG(ERROR) << "Couldn't get device size " << mDevPath;
            return res;
        }

        // If both vfat & exfat are supported use exfat for SDXC (>~32GiB) cards
        if (size > 32896LL * 1024 * 1024) {
            useVfat = false;
        } else {
            useExfat = false;
        }
    } else if (fsType == "vfat") {
        useExfat = false;
    } else if (fsType == "exfat") {
        useVfat = false;
    }

    if (!useVfat && !useExfat) {
        LOG(ERROR) << "Unsupported filesystem " << fsType;
        return -EINVAL;
    }

    if (WipeBlockDevice(mDevPath) != OK) {
        LOG(WARNING) << getId() << " failed to wipe";
    }

    if (useVfat) {
        res = vfat::Format(mDevPath, 0);
    } else if (useExfat) {
        res = exfat::Format(mDevPath);
    }

    if (res != OK) {
        LOG(ERROR) << getId() << " failed to format";
        res = -errno;
    }

    return res;
}

}  // namespace vold
}  // namespace android

关键的代码段在doMount 方法中，如下：

    if (mFsType == "vfat") {
        if (vfat::Mount(mDevPath, mRawPath, false, false, false, AID_ROOT,
                        (isVisible ? AID_MEDIA_RW : AID_EXTERNAL_STORAGE), 0007, true)) {
            PLOG(ERROR) << getId() << " failed to mount " << mDevPath;
            return -EIO;
        }
    } else if (mFsType == "exfat") {
        if (exfat::Mount(mDevPath, mRawPath, AID_ROOT,
                         (isVisible ? AID_MEDIA_RW : AID_EXTERNAL_STORAGE), 0007)) {
            PLOG(ERROR) << getId() << " failed to mount " << mDevPath;
            return -EIO;
        }
    } else if (mFsType == "ntfs") {
        if (ntfs::Mount(mDevPath, mRawPath, false, false, false, AID_ROOT,
                        (isVisible ? AID_MEDIA_RW : AID_EXTERNAL_STORAGE), 0007, true)) {
            PLOG(ERROR) << getId() << " nfts failed to mount " << mDevPath;
            return -EIO;
        }
    } else if (mFsType == "ext4") {
        if (ext4::Mount(mDevPath, mRawPath, false, false, true)) {
            PLOG(ERROR) << getId() << " failed to mount " << mDevPath;
            return -EIO;
        }
    } else if (mFsType == "f2fs") {
        if (f2fs::Mount(mDevPath, mRawPath)) {
            PLOG(ERROR) << getId() << " failed to mount " << mDevPath;
             return -EIO;
        }
    }

这段代码是一个用于挂载不同文件系统的函数的一部分。它根据不同的文件系统类型（vfat、exfat、ntfs、ext4、f2fs）调用相应的挂载函数，其中 AID_ROOT 和 AID_MEDIA_RW 以及AID_EXTERNAL_STORAGE 代表文件系统权限，其定义可以在下面的文件中找到：

system/core/include/cutils/android_filesystem_config.h

而这里的几个0007则代表权限，这里没有修改的需求，不作变动。

经过修改，最后的代码如下：

    if (mFsType == "vfat") {
        if (vfat::Mount(mDevPath, mRawPath, false, false, false, AID_MEDIA_RW,
                        (isVisible ? AID_MEDIA_RW : AID_EXTERNAL_STORAGE), 0007, true)) {
            PLOG(ERROR) << getId() << " failed to mount " << mDevPath;
            return -EIO;
        }
    } else if (mFsType == "exfat") {
        if (exfat::Mount(mDevPath, mRawPath, AID_MEDIA_RW,
                         (isVisible ? AID_MEDIA_RW : AID_EXTERNAL_STORAGE), 0007)) {
            PLOG(ERROR) << getId() << " failed to mount " << mDevPath;
            return -EIO;
        }
    } else if (mFsType == "ntfs") {
        if (ntfs::Mount(mDevPath, mRawPath, false, false, false, AID_MEDIA_RW,
                        (isVisible ? AID_MEDIA_RW : AID_EXTERNAL_STORAGE), 0007, true)) {
            PLOG(ERROR) << getId() << " nfts failed to mount " << mDevPath;
            return -EIO;
        }
    } else if (mFsType == "ext4") {
        if (ext4::Mount(mDevPath, mRawPath, false, false, true)) {
            PLOG(ERROR) << getId() << " failed to mount " << mDevPath;
            return -EIO;
        }
    } else if (mFsType == "f2fs") {
        if (f2fs::Mount(mDevPath, mRawPath)) {
            PLOG(ERROR) << getId() << " failed to mount " << mDevPath;
             return -EIO;
        }
    }

diff:

     if (mFsType == "vfat") {
-        if (vfat::Mount(mDevPath, mRawPath, false, false, false, AID_ROOT,
+        if (vfat::Mount(mDevPath, mRawPath, false, false, false, AID_MEDIA_RW,
                         (isVisible ? AID_MEDIA_RW : AID_EXTERNAL_STORAGE), 0007, true)) {
             PLOG(ERROR) << getId() << " failed to mount " << mDevPath;
             return -EIO;
         }
     } else if (mFsType == "exfat") {
-        if (exfat::Mount(mDevPath, mRawPath, AID_ROOT,
+        if (exfat::Mount(mDevPath, mRawPath, AID_MEDIA_RW,
                          (isVisible ? AID_MEDIA_RW : AID_EXTERNAL_STORAGE), 0007)) {
             PLOG(ERROR) << getId() << " failed to mount " << mDevPath;
             return -EIO;
         }
     } else if (mFsType == "ntfs") {
-        if (ntfs::Mount(mDevPath, mRawPath, false, false, false, AID_ROOT,
+        if (ntfs::Mount(mDevPath, mRawPath, false, false, false, AID_MEDIA_RW,
                         (isVisible ? AID_MEDIA_RW : AID_EXTERNAL_STORAGE), 0007, true)) {
             PLOG(ERROR) << getId() << " nfts failed to mount " << mDevPath;
             return -EIO;
         }
     } else if (mFsType == "ext4") {

保存，编译后烧录系统，完成需求。

Jose_lz
关注
专栏目录
android 13.0 去掉usb授权提示框 默认给予权限
安卓兼职framework和app工程师的博客
12-04 2600
在13.0的系统rom产品开发中，在进行iot关于插入usb设备的开发过程中,在插入usb设备时会弹出usb授权提示框，也带来一些不便， 这个需要默认授予USB权限，插拔usb都不弹出usb弹窗所以这要从usb授权相关管理页默认给与usb权限，接下来分析下 相关的实现功能流程
Android修改Vold支持PCI-E设备自动挂载
最新发布
AUZKAY的博客
03-19 995
Android架构学习进阶是一条漫长而艰苦的道路，不能靠一时激情，更不是熬几天几夜就能学好的，必须养成平时努力学习的习惯。所以：贵在坚持！上面分享的字节跳动公司2020年的面试真题解析大全，笔者还把一线互联网企业主流面试技术要点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节。详情可以点击我的【Github】如果你熟练掌握【Github】中列出的知识点，相信将会大大增加你通过前两轮技术面试的几率！这些内容都供大家参考，互相学习。
Android 13 默认插入usb时，打开usb偏好设置页面
m0_70676308的博客
01-12 1275
17]+ 已停止 git diff .客户要求，在usb插入的时候，弹出偏好设置页面。
安卓USB通信之权限管理
true100的专栏
07-15 2万+
这篇博客是针对之前的一篇文章Android开发之USB数据通信作的补充。主要是在开发中发现了另外两个不得不面对的问题： USB访问权限处理。 USB设备插拔状态监听。 —USB访问权限处理——- 当我们安卓手机第一次安装我们USB相关功能的APK时，正常情况下，手机会弹出个类似于“XX应用访问USB设备…”的提示框，如果用户不接受的话，那肯定是不能进行USB通信的。
Android USB通信权限
Android
10-22 1159
android的USB开发时 mUsbManager.getDeviceList()获取都为空 1.在/system/etc/permissions下的handheld_core_hardware.xml 1. <feature name="android.hardware.usb.host" /> 修改AndroidManifest.xml文件，添加以下权限（很关键）： 2. <uses-permission android:name="android.hardware.usb.hos
Android 13以上版本读写SD卡权限适配
技术的学习与积累是个技术活
01-29 1998
如题，最近工作上处理的问题，把解决方案简单逻列出来，供有需要的朋友参考之。
【framework】framework中为systemserver添加权限
三言两语
12-23 6288
之前以为在framework中不需要申请权限就可以直接使用，直到最近移植android6.0时，发现原来4.4上的代码移植到6.0上后无法正常使用，排查原因发现是在读写sdcard时因为没有读写权限导致出错，这才直到原来framework中的服务也是需要配置权限相关的东西的，只是方法和app中配置的方法不一样。如下记录该问题解决的方法： 1、测试代码 我在system server中自定义的服
树莓派4外置wifi天线_树莓派打造最强车载娱乐终端（1）音乐和WiFi
weixin_39533432的博客
10-22 1300
开车跑长途的时候总觉得无聊，就会想起飞机上的娱乐终端，那么我们就来自己做一个吧！这一系列文章里，我会按照功能划分，列出需要的软硬件，尽量做到互相独立，方便自由组合。今天我们先来实现最基本的音乐播放和WiFi共享。后续文章CenizaDeTiempo：树莓派打造最强车载娱乐终端（2）视频和游戏​zhuanlan.zhihu.comCenizaDeTiempo：树莓派打造最强车载娱乐终端（3）GPS ...
Android源码剖析之Framwork层后记篇（硬件消息传递、apk管理、输入法框架、编译过程）
劝学
09-01 2771
本文来自http://blog.csdn.net/liuxian13183/，引用必须注明出处！ 既然写到后记篇，就代表本系列到此为止，暂时告一段落；其他一些Manager随后有时间再补，就像源码的一些翻译一样，有时间总会补上的，同时也希望大家一如既往的喜欢，直言不讳的提出宝贵意见。 后记将讲述输入模块和编译系统内容，以及对整个系统的总结。
Android U盘插拔监听以及U盘写入权限解决办法
05-28
Android U盘插拔监听以及U盘写入权限解决办法 https://blog.csdn.net/qq_31939617/article/details/80447276
android对外置U盘进行读取
12-20
android通过otg去读取U盘的内容并进行读写操作.
android 4.0 api project
06-13
9. **USB主机模式**：ICS支持USB主机模式，允许Android设备连接并控制USB设备，如键盘、鼠标或外置存储。 10. **Wi-Fi Direct**：集成Wi-Fi Direct，让设备间可以直接建立高速无线连接，无需通过路由器。 11. **...
Android Studio平台架构
m0_62491877的博客
09-25 568
Android Studio平台架构
PermissionX 1.7发布，全面支持Android 13运行时权限
热门推荐
郭霖的专栏
09-27 4万+
今年的Android 13在运行时权限变更方面变化较大，为此PermissionX在1.7版本也进行了诸多适配，并已全面支持Android 13系统。 如果你想要非常详细地了解Android 13运行时权限具体有哪些变更，可以参考我之前写的这篇文章 Android 13运行时权限变更一览。 本篇文章，我们将聚焦在，如何使用新版的PermissionX来轻松地请求Android
Android 13运行时权限变更一览
郭霖
08-16 2509
要不了多久，Android 13正式版就要发布了。其实就在几个月前，我写了一篇关于Android 13首个开发者体验版的全面介绍，详情可以参考 Android 13 Developer Preview一览。那么相比于首个开发者体验版，目前Android 13已经进入了平台稳定期阶段，也就是说API基本已经固定，不会再有什么大的修改了。于是我又重新回顾了一遍Android 13的重要新特性和行为变...
系统应用--android 10.0去掉系统USB权限弹窗
binbin
09-05 1666
今天收到一个bug， 音乐APP插入USB弹窗有问题，于是需要自己重写一个新的。
Android 获得 usb 权限的两种方式
hdhhd的博客
05-26 4438
0. 前言 在做 USB OTG 通信时，第一步就是要能够获取到 usb 的使用权限，因此特地在此处介绍一下两种我用过的获取 usb 权限方式。 1. 直接在 AndroidManifest.xml 中配置 这种配置方式是在 github 上 usb-serial-for-android 项目中看到的，大家如果有兴趣可以 clone 下来研究一下。 <activity android:name=".DeviceListActivity" androi...
android otg 允许usb权限 默认
01-26
Android OTG（On-The-Go）是一种允许移动设备通过USB接口连接外部设备的技术。当Android设备通过OTG线缆连接到外部USB设备时，默认情况下会授权USB权限。 Android OTG技术的优点在于，它可以使设备像计算机一样连接数码相机、外置存储设备、键盘、鼠标和游戏手柄等外部USB设备。通过连接外部设备，用户可以更加方便地进行文件传输、键盘输入和游戏体验。 在连接外部USB设备时，Android设备会自动检测设备的类型和功能，并根据需要提供适当的权限。这意味着，用户可以立即开始使用外部设备而无需进行额外的设置或配置。 然而，一些USB设备可能需要特殊的驱动程序或应用程序才能与Android设备兼容。在这种情况下，用户可能需要手动安装所需的驱动程序或应用程序。这可以通过从Google Play商店下载相关软件来实现。 总而言之，Android OTG可以让我们的移动设备拥有更多功能和扩展性。当我们连接外部设备时，Android会默认提供USB权限，使我们能够直接使用这些设备的功能。然而，为了确保某些特殊设备的兼容性，可能需要手动安装适当的驱动程序或应用程序。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值