Android10 音频系统之耳麦插拔

原创 已于 2025-03-12 14:57:50 修改 · 1k 阅读 · 31
标签
#车载系统
于 2024-06-17 23:12:09 首次发布

       对于耳麦的插拔，Android有两种模式，可以使用input子系统，也可以使用state dev(uevent)上报拔插操作。
        输入子系统：上报开关事件(EV_SW)，事件类型包括headset、headPhone、lineOut。对于输入设备都需要指定能产生同步类事件EV_SYN。对于按键事件，输入子系统还需要设置按键值的范围，但是对于开关类事件不需要设置。
        switch class子系统：通过uevent向用户空间发送数据，Android中有个线程专门监听这类事件。使用switch dev子系统时，名字必须要设置为"h2w"，Android系统监听/sys/class/switch/h2w这个虚拟设备。
        具体使用哪种操作 取决于config_useDevInputEventForAudioJack 这个配置值，该值为true时使用input子系统, 为false时使用uevent机制。

1. 驱动程序上报音频拔插事件

xref: /frameworks/native/services/inputflinger/InputReader.cpp

void InputReader::loopOnce() {
    int32_t oldGeneration;
    int32_t timeoutMillis;
    bool inputDevicesChanged = false;
    std::vector<InputDeviceInfo> inputDevices;
    { // acquire lock
        AutoMutex _l(mLock);

        oldGeneration = mGeneration;
        timeoutMillis = -1;

        uint32_t changes = mConfigurationChangesToRefresh;
        if (changes) {
            mConfigurationChangesToRefresh = 0;
            timeoutMillis = 0;
            refreshConfigurationLocked(changes);
        } else if (mNextTimeout != LLONG_MAX) {
            nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
            timeoutMillis = toMillisecondTimeoutDelay(now, mNextTimeout);
        }
    } // release lock

	// 监听耳机插拔事件
    size_t count = mEventHub->getEvents(timeoutMillis, mEventBuffer, EVENT_BUFFER_SIZE);

    { // acquire lock
        AutoMutex _l(mLock);
        mReaderIsAliveCondition.broadcast();

		// 处理插拔事件
        if (count) {
            processEventsLocked(mEventBuffer, count);
        }

        if (mNextTimeout != LLONG_MAX) {
            nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
            if (now >= mNextTimeout) {
#if DEBUG_RAW_EVENTS
                ALOGD("Timeout expired, latency=%0.3fms", (now - mNextTimeout) * 0.000001f);
#endif
                mNextTimeout = LLONG_MAX;
                timeoutExpiredLocked(now);
            }
        }

        if (oldGeneration != mGeneration) {
            inputDevicesChanged = true;
            getInputDevicesLocked(inputDevices);
        }
    } // release lock

    // Send out a message that the describes the changed input devices.
    if (inputDevicesChanged) {
        mPolicy->notifyInputDevicesChanged(inputDevices);
    }

    // Flush queued events out to the listener.
    // This must happen outside of the lock because the listener could potentially call
    // back into the InputReader's methods, such as getScanCodeState, or become blocked
    // on another thread similarly waiting to acquire the InputReader lock thereby
    // resulting in a deadlock.  This situation is actually quite plausible because the
    // listener is actually the input dispatcher, which calls into the window manager,
    // which occasionally calls into the input reader.
    mQueuedListener->flush();
}

        在loopOnce()方法中监听耳机插拔事件，如果监听到耳机插入，则count的值会发生变化。然后调用processEventsLocked方法处理，如果没有耳机插入则休眠。

void InputReader::processEventsLocked(const RawEvent* rawEvents, size_t count) {
    for (const RawEvent* rawEvent = rawEvents; count;) {
        int32_t type = rawEvent->type;
        size_t batchSize = 1;
        if (type < EventHubInterface::FIRST_SYNTHETIC_EVENT) {
            int32_t deviceId = rawEvent->deviceId;
            while (batchSize < count) {
                if (rawEvent[batchSize].type >= EventHubInterface::FIRST_SYNTHETIC_EVENT
                        || rawEvent[batchSize].deviceId != deviceId) {
                    break;
                }
                batchSize += 1;
            }
#if DEBUG_RAW_EVENTS
            ALOGD("BatchSize: %zu Count: %zu", batchSize, count);
#endif
            processEventsForDeviceLocked(deviceId, rawEvent, batchSize);
        } else {
            switch (rawEvent->type) {
            case EventHubInterface::DEVICE_ADDED://设备添加事件
                addDeviceLocked(rawEvent->when, rawEvent->deviceId);
                break;
            case EventHubInterface::DEVICE_REMOVED://设备删除事件
                removeDeviceLocked(rawEvent->when, rawEvent->deviceId);
                break;
            case EventHubInterface::FINISHED_DEVICE_SCAN://设备扫描事件
                handleConfigurationChangedLocked(rawEvent->when);
                break;
            default:
                ALOG_ASSERT(false); // can't happen
                break;
            }
        }
        count -= batchSize;
        rawEvent += batchSize;
    }
}

        这里将设备的各种事件进行分开处理。如果事件type小于FIRST_SYNTHETIC_EVENT，那么此次不是一次设备增加/删除/扫描事件，调用processEventsForDeviceLocked方法处理本次输入事件

void InputReader::processEventsForDeviceLocked(int32_t deviceId,
        const RawEvent* rawEvents, size_t count) {
    ssize_t deviceIndex = mDevices.indexOfKey(deviceId);
    if (deviceIndex < 0) {
        ALOGW("Discarding event for unknown deviceId %d.", deviceId);
        return;
    }

    InputDevice* device = mDevices.valueAt(deviceIndex);
    if (device->isIgnored()) {
        //ALOGD("Discarding event for ignored deviceId %d.", deviceId);
        return;
    }

    device->process(rawEvents, count);
}

        根据deviceIndex从mDevices中获取对应的InputDevice设备对象，然后调用process进行处理rawEvents。此处调用的process是InputDevice::process

        

void InputDevice::process(const RawEvent* rawEvents, size_t count) {
    // Process all of the events in order for each mapper.
    // We cannot simply ask each mapper to process them in bulk because mappers may
    // have side-effects that must be interleaved.  For example, joystick movement events and
    // gamepad button presses are handled by different mappers but they should be dispatched
    // in the order received.
	// for循环依次处理count个rawEvents。
    for (const RawEvent* rawEvent = rawEvents; count != 0; rawEvent++) {
#if DEBUG_RAW_EVENTS
        ALOGD("Input event: device=%d type=0x%04x code=0x%04x value=0x%08x when=%" PRId64,
                rawEvent->deviceId, rawEvent->type, rawEvent->code, rawEvent->value,
                rawEvent->when);
#endif

        if (mDropUntilNextSync) {
            if (rawEvent->type == EV_SYN && rawEvent->code == SYN_REPORT) {
                mDropUntilNextSync = false;
#if DEBUG_RAW_EVENTS
                ALOGD("Recovered from input event buffer overrun.");
#endif
            } else {
#if DEBUG_RAW_EVENTS
                ALOGD("Dropped input event while waiting for next input sync.");
#endif
            }
        } else if (rawEvent->type == EV_SYN && rawEvent->code == SYN_DROPPED) {
            ALOGI("Detected input event buffer overrun for device %s.", getName().c_str());
            mDropUntilNextSync = true;
            reset(rawEvent->when);
        } else {
            for (InputMapper* mapper : mMappers) {
                mapper->process(rawEvent);
            }
        }
        --count;
    }
}

        for循环依次处理count个rawEvents。
mDropUntilNextSync到下一次同步前的都扔掉，收到rawEvent->type == EV_SYN && rawEvent->code == SYN_DROPPED时，该标记会置位。如果底层client的循环buffer出现问题的时候会发送这个code，收到此code，要一直等到下一次的rawEvent->type == EV_SYN && rawEvent->code == SYN_REPORT才能复位。一般都是走最后一个else判断。mapper->process是

void SwitchInputMapper::process(const RawEvent* rawEvent) {
    switch (rawEvent->type) {
    case EV_SW:
        processSwitch(rawEvent->code, rawEvent->value);
        break;

    case EV_SYN:
        if (rawEvent->code == SYN_REPORT) {
            sync(rawEvent->when);
        }
    }
}

        根据上报事件进行处理，EV_SW：开关类事件；EV_SYN：同步类事件

void SwitchInputMapper::processSwitch(int32_t switchCode, int32_t switchValue) {
    if (switchCode >= 0 && switchCode < 32) {
        if (switchValue) {
            mSwitchValues |= 1 << switchCode;
        } else {
            mSwitchValues &= ~(1 << switchCode);
        }
        mUpdatedSwitchMask |= 1 << switchCode;
    }
}

        通过mSwitchValues的值进行状态存储。mSwitchValues |= 1 << switchCode;按下则记录switchCode值。mSwitchValues &= ~(1 << switchCode);松开则清除switchCode值。mUpdatedSwitchMask |= 1 << switchCode;将switchCode记录在mUpdatedSwitchMask里面。

void SwitchInputMapper::sync(nsecs_t when) {
    if (mUpdatedSwitchMask) {
        uint32_t updatedSwitchValues = mSwitchValues & mUpdatedSwitchMask;
        NotifySwitchArgs args(mContext->getNextSequenceNum(), when, 0, updatedSwitchValues,
                mUpdatedSwitchMask);
        getListener()->notifySwitch(&args);

        mUpdatedSwitchMask = 0;
    }
}

        这里的getListener()->notifySwitch(&args)实际上就是InputDispatcher的notifySwitch方法。

void InputDispatcher::notifySwitch(const NotifySwitchArgs* args) {
#if DEBUG_INBOUND_EVENT_DETAILS
    ALOGD("notifySwitch - eventTime=%" PRId64 ", policyFlags=0x%x, switchValues=0x%08x, "
            "switchMask=0x%08x",
            args->eventTime, args->policyFlags, args->switchValues, args->switchMask);
#endif

    uint32_t policyFlags = args->policyFlags;
    policyFlags |= POLICY_FLAG_TRUSTED;
    mPolicy->notifySwitch(args->eventTime,
            args->switchValues, args->switchMask, policyFlags);
}

xref: /frameworks/base/services/core/jni/com_android_server_input_InputManagerService.cpp

void NativeInputManager::notifySwitch(nsecs_t when,
        uint32_t switchValues, uint32_t switchMask, uint32_t /* policyFlags */) {
#if DEBUG_INPUT_DISPATCHER_POLICY
    ALOGD("notifySwitch - when=%lld, switchValues=0x%08x, switchMask=0x%08x, policyFlags=0x%x",
            when, switchValues, switchMask, policyFlags);
#endif
    ATRACE_CALL();

    JNIEnv* env = jniEnv();

    env->CallVoidMethod(mServiceObj, gServiceClassInfo.notifySwitch,
            when, switchValues, switchMask);
    checkAndClearExceptionFromCallback(env, "notifySwitch");
}

         env->CallVoidMethod调用java中的同名函数

xref: /frameworks/base/services/core/java/com/android/server/input/InputManagerService.java

// Native callback.
private void notifySwitch(long whenNanos, int switchValues, int switchMask) {
    if (DEBUG) {
        Slog.d(TAG, "notifySwitch: values=" + Integer.toHexString(switchValues)
                + ", mask=" + Integer.toHexString(switchMask));
    }

    if ((switchMask & SW_LID_BIT) != 0) {
        final boolean lidOpen = ((switchValues & SW_LID_BIT) == 0);
        mWindowManagerCallbacks.notifyLidSwitchChanged(whenNanos, lidOpen);
    }

    if ((switchMask & SW_CAMERA_LENS_COVER_BIT) != 0) {
        final boolean lensCovered = ((switchValues & SW_CAMERA_LENS_COVER_BIT) != 0);
        mWindowManagerCallbacks.notifyCameraLensCoverSwitchChanged(whenNanos, lensCovered);
    }

    if (mUseDevInputEventForAudioJack && (switchMask & SW_JACK_BITS) != 0) {
        mWiredAccessoryCallbacks.notifyWiredAccessoryChanged(whenNanos, switchValues,
                switchMask);
    }

    if ((switchMask & SW_TABLET_MODE_BIT) != 0) {
        SomeArgs args = SomeArgs.obtain();
        args.argi1 = (int) (whenNanos & 0xFFFFFFFF);
        args.argi2 = (int) (whenNanos >> 32);
        args.arg1 = Boolean.valueOf((switchValues & SW_TABLET_MODE_BIT) != 0);
        mHandler.obtainMessage(MSG_DELIVER_TABLET_MODE_CHANGED,
                args).sendToTarget();
    }
}

        调用到mWiredAccessoryCallbacks中的notifyWiredAccessoryChanged。mUseDevInputEventForAudioJack就是来自config.xml文件配置，为true才会选择输入子系统。

xref: /frameworks/base/services/core/java/com/android/server/WiredAccessoryManager.java

@Override
public void notifyWiredAccessoryChanged(long whenNanos, int switchValues, int switchMask) {
    if (LOG) {
        Slog.v(TAG, "notifyWiredAccessoryChanged: when=" + whenNanos
                + " bits=" + switchCodeToString(switchValues, switchMask)
                + " mask=" + Integer.toHexString(switchMask));
    }

    synchronized (mLock) {
        int headset;
        mSwitchValues = (mSwitchValues & ~switchMask) | switchValues;
        switch (mSwitchValues &
                (SW_HEADPHONE_INSERT_BIT | SW_MICROPHONE_INSERT_BIT | SW_LINEOUT_INSERT_BIT)) {
            case 0:
最低0.47元/天 解锁文章
@OuYang
关注
四、MT8168 音频驱动之Microphone
Joon2020的博客
08-10 1676
本章主要讲述MT8168平台麦克风设置。MT8168只是数字麦克风、模拟麦克风、双麦克。下面将详细描述这些类型驱动配置。2.1.1使能如下数字麦克风配置。2.1.2 数字麦克风通路配置。2.2.2 模拟麦克风通路配置。2.2.1 禁止数字麦克风。...
android 耳机连接状态查询
kiba_zwei的博客
04-22 2727
近期有个要监听耳机的需求，本以为挺简单，三五行调用个系统方法就能解决了。结果发现还有点复杂，考虑到这块妥妥是一个模块的东西，自己四处查了一些资料后，去伪存真，最终总算整理出了可以直接使用的内容。记录下来，以资来者。耳机样式分为有线和无线两种，而且需要动态监控当前耳机状态，所以要对察插入时间进行监听，有线耳机的接入是有广播的，而无线耳机就没有了，需要做个简单的轮询处理。
Win10 - 即插即用的external audio device detected问题
袭冷
02-07 4075
问题 有些牌子的笔记本，在win10下每次插入外设耳机，都会跳出带有 external audio device detected 字样的音频输出设备选择框需要选择
【转载】Android音频(7)——项目实战——耳麦插拔
seiyaaa的专栏
03-25 1192
Android音频(7)——项目实战——耳麦插拔 - Hello-World3 - 博客园 一、驱动程序上报耳麦拔插事件 1. 在有些Android版本中并不会在状态栏上显示耳麦图标。切换声道也不在系统中实现，而是在驱动中实现的。 2. headset headPhone lineOut headset：既有听筒又有Mic headPhone：只有听筒，没有Mic lineOut: 就是输出模拟信号到音箱 驱动需要上报三种设备的拔插：headset、headPhone、lineOut。 3. 怎
专题分纲目录 Android Framework 音频子系统
wangdsh的博客
04-13 1万+
专题分纲目录 均为索引，本纲为：Android Framework 音频子系统 系列文章目录 Android Framework 音频子系统（01）音频基础知识 Android Framework 音频子系统（02）音频系统框架 Android Framework 音频子系统（03）AudioPolicyService启动分析 Android Framework 音频子系统（04）Audi...
android耳机插拔的监听
ITxiaobing123的博客
04-25 6018
必须动态注册，否则无效监听 一、主要监听事件 1.监听有线耳机 Intent.ACTION_HEADSET_PLUG android.intent.action.HEADSET_PLUG 2，监听蓝牙耳机 BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED 二、代码实现/** 注册receiver */ public class HeadS
Android音频子系统-耳机插拔
不定时记录分享一些有用没用的东西
07-10 2446
带着以下几个问题，我们着手分析：Android系统在播放音乐的时候，如果插入耳机，系统会发生什么变化？会产生哪些逻辑？音频是如何从扬声器切换到耳机的？插入3.5mm的耳机孔和usb耳机又有什么不同？
Android4.4监听耳机插入处理方法
AnndyPeng的专栏
06-12 2955
Andriod4.4处理耳机插入逻辑 Android系统硬件检测到耳机插入，并告诉底层当前插入的是纯耳机，还是带Mic的耳机。 底层在CallBack中接收到耳机插入消息后，发送广播告诉上层，发送广播的action是 Intent.ACTION_HEADSET_PLUG。 一、Android4.4系统中处理耳机插入，在StatusBar中像手机信号一样的动态显示效果方法如下： 1.f
Android：有线耳机拔出或蓝牙耳机断开连接，暂停播放
指尖流连敲击梦想，代码行行承载远方！
01-05 4124
当我们正在“专注学习”的过程中，如果不小心拔掉了耳机线或者断开蓝牙耳机的连接，突然之间我们APP里正在播放的声音就会打扰到周围的人，如果声音还挺大的话，是不是有些尴尬？所以呢，现在需要实现这么一个功能：在有线耳机拔掉或者蓝牙耳机断开连接时，立刻停止播放。
Android--耳机插拔检测(framework篇)
qq_42364999的博客
10-26 1454
Android 耳机插拔检测
android 实时监测耳机
01-21 745
在应用中，想实时去监测是否耳机处于插入状态，有两种方式。提一句，不是接受广播，只有在插拔的动作时候才会发送广播，注意区别动作和状态。例如，耳机已经插上了，再启动应用，那应用就不能接受广播，这个时候要判断耳机插入状态，就需要我们说的两种方式。 1.API提供的方法。需要使用系统的服务，代码如下： AudioManager audioManager  = (AudioManager) conte
Android audio hal
wan2g的博客
02-07 2674
audio
Android实现耳机插入和拔出状态检测 (附完整源码)
最新发布
希望我的博客，能帮上你解决学习中工作中所遇到的问题
11-16 493
Android实现耳机插入和拔出状态检测 (附完整源码)
android 监听耳机插拔
王振国的专栏
05-13 2221
两种方式 1、在activity里面通过BroadcastReceiver Inter消息来监听耳机插拔  //实现类 private HeadsetReceiver mHeadsetReceiver ; public class HeadsetReceiver extends BroadcastReceiver {   @Override   public void onReceiv
android 耳机监听
dream_sky213的专栏
09-28 1489
1.判断耳机是否插入： AudioManager的isWiredHeadsetOn()方法：
Android耳机插拔状态的监测
guocctjpu的博客
03-11 1641
手机有个很人性化的设计，随着耳机的插拔，媒体的音量会有两种不同的状态。推理，手机中必然有一种机制实现对耳机插拔的实时监测。本文章就对这种机制进行简单描述，只涉及应用层。有两种方法实现对耳机是否插入手机的监测：一种是采用广播方式实现实时监测，一种是调用Android内部接口。下面对两种方法进行详细描述。 1、广播方式 广播是Android中实现系统级消息通知的机制，灵活简单，如果某个软件要判断某...
Android音频子系统（四）------耳机拔插流程
风筝
05-27 4706
你好！这里是风筝的博客， 欢迎和我一起交流。 耳机上报主要有两种方式： 1.UEvent 2.InputEvent 两种模式的切换可以使用配置项来完成，Android 系统默认是使用UEvent的方式。 不过一般厂商会在自己的xml文件里进行配置。 例如我这板子配置： device/softwinner/ceres-spen/overlay/frameworks/base/core/res/res/values/config.xml:140: <bool name="config_useDev
Android音频管理：AudioFlinger分析
热门推荐
u013490411的博客
08-17 1万+
1.Android音频框架概述 Audio是Android平台非常重要的一个组成部分，负责音频数据的输出采集，音频流的控制，音量调节，音频设备的管理等。我们先来简单介绍一下播放一首音乐的流程：首先应用层点击播放音乐的时候应用会通过mediaplayer接口去启动Android系统的播放器NuPlayer。其实mp3或者flac等格式的音频文件就是一个特殊的压缩文件，所以播放一个音频文件首先要做的就是要去解压缩，Nuplayer通过mediaextractor（高通的有自己的解封装模块mmparser）去解封
关于Android 11检测当前是否处于耳机或者蓝牙状态
qq_43684017的博客
01-29 1957
关于Android 11 设备对当前耳机状态以及蓝牙A2DP状态的判别
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值