HarmonyOS鸿蒙Next开发者技术支持-监听耳机摘取动作

鸿蒙监听耳机摘取动作

1.1 问题说明

场景背景

在鸿蒙应用开发中，当用户通过蓝牙耳机或有线耳机收听音频/视频时，需要实时感知耳机的插拔状态变化。特别是耳机被意外摘取时，应用需要自动暂停播放，避免音频外放造成隐私泄露或尴尬场景。

具体表现

1. 用户佩戴蓝牙耳机观看视频时突然取下耳机，但视频仍在继续播放
2. 有线耳机在移动过程中被意外拔出，音频转为扬声器播放
3. 耳机状态变化时，应用未能及时响应，用户体验不佳
4. 多应用同时使用音频时，耳机状态监听冲突

1.2 解决方案

方案一：基于AVSession的监听实现

// HeadsetMonitor.ets
import { AVSession, audio } from '@ohos.multimedia.avsession';
import { common } from '@ohos.app.ability.common';

export class HeadsetMonitor {
  private avSession: AVSession | null = null;
  private isMonitoring: boolean = false;
  private lastHeadsetState: boolean = false;
  private debounceTimer: number | null = null;

  // 耳机状态变化回调类型
  public onHeadsetStateChange: (isConnected: boolean) => void = () => {};

  /**
   * 初始化AVSession并开始监听
   */
  async initialize(context: common.UIAbilityContext): Promise<void> {
    try {
      // 创建AVSession
      this.avSession = await this.createAVSession(context);
      
      // 注册耳机监听
      await this.registerHeadsetListener();
      
      // 初始化当前耳机状态
      await this.checkInitialHeadsetState();
      
      this.isMonitoring = true;
      console.info('HeadsetMonitor initialized successfully');
    } catch (error) {
      console.error('Failed to initialize HeadsetMonitor:', error);
    }
  }

  /**
   * 创建AVSession实例
   */
  private async createAVSession(context: common.UIAbilityContext): Promise<AVSession> {
    const sessionType = audio.AVSession.AudioSessionType.AUDIO;
    const sessionTag = 'media_session';
    
    return await AVSession.createAVSession(context, sessionTag, sessionType);
  }

  /**
   * 注册耳机状态监听
   */
  private async registerHeadsetListener(): Promise<void> {
    if (!this.avSession) {
      throw new Error('AVSession not initialized');
    }

    // 监听AVSession状态变化
    this.avSession.on('audioRendererChange', (rendererChange) => {
      this.handleAudioRendererChange(rendererChange);
    });

    // 监听会话激活状态
    this.avSession.on('activate', () => {
      console.info('AVSession activated');
      this.onSessionActivated();
    });

    // 监听会话失效状态
    this.avSession.on('deactivate', () => {
      console.info('AVSession deactivated');
    });

    // 激活AVSession
    await this.avSession.activate();
  }

  /**
   * 处理音频渲染器变化
   */
  private handleAudioRendererChange(rendererChange: any): void {
    // 防抖处理，避免频繁触发
    if (this.debounceTimer) {
      clearTimeout(this.debounceTimer);
    }

    this.debounceTimer = setTimeout(() => {
      this.detectHeadsetStateChange(rendererChange);
    }, 300) as unknown as number;
  }

  /**
   * 检测耳机状态变化
   */
  private async detectHeadsetStateChange(rendererChange: any): Promise<void> {
    try {
      const currentState = await this.getCurrentHeadsetState();
      
      if (currentState !== this.lastHeadsetState) {
        this.lastHeadsetState = currentState;
        
        // 触发回调
        this.onHeadsetStateChange(currentState);
        
        // 根据耳机状态调整播放行为
        this.adjustPlaybackByHeadsetState(currentState);
      }
    } catch (error) {
      console.error('Error detecting headset state:', error);
    }
  }

  /**
   * 获取当前耳机连接状态
   */
  private async getCurrentHeadsetState(): Promise<boolean> {
    try {
      const audioManager = audio.getAudioManager();
      const audioDevices = await audioManager.getDevices(audio.DeviceFlag.ALL_DEVICES_FLAG);
      
      // 检查是否有耳机设备
      const hasHeadset = audioDevices.some(device => {
        return device.deviceType === audio.DeviceType.WIRED_HEADSET ||
               device.deviceType === audio.DeviceType.WIRED_HEADPHONES ||
               device.deviceType === audio.DeviceType.BLUETOOTH_A2DP ||
               device.deviceType === audio.DeviceType.BLUETOOTH_SCO;
      });
      
      return hasHeadset;
    } catch (error) {
      console.warn('Failed to get headset state, using fallback:', error);
      return this.lastHeadsetState;
    }
  }

  /**
   * 根据耳机状态调整播放
   */
  private adjustPlaybackByHeadsetState(isConnected: boolean): void {
    if (!isConnected) {
      // 耳机断开，暂停播放
      this.pausePlayback();
      console.info('Headset disconnected, playback paused');
    } else {
      // 耳机连接，可以恢复播放
      console.info('Headset connected');
    }
  }

  /**
   * 暂停播放逻辑
   */
  private pausePlayback(): void {
    // 这里调用具体的播放控制逻辑
    if (this.avSession) {
      const avController = this.avSession.getController();
      avController.pause().catch(err => {
        console.error('Failed to pause playback:', err);
      });
    }
  }

  /**
   * 检查初始耳机状态
   */
  private async checkInitialHeadsetState(): Promise<void> {
    this.lastHeadsetState = await this.getCurrentHeadsetState();
  }

  /**
   * 会话激活时的处理
   */
  private onSessionActivated(): void {
    // 重新检查耳机状态
    this.checkInitialHeadsetState().catch(console.error);
  }

  /**
   * 停止监听
   */
  async stopMonitoring(): Promise<void> {
    if (this.debounceTimer) {
      clearTimeout(this.debounceTimer);
      this.debounceTimer = null;
    }

    if (this.avSession) {
      try {
        await this.avSession.deactivate();
        await this.avSession.destroy();
      } catch (error) {
        console.warn('Error during AVSession cleanup:', error);
      }
      this.avSession = null;
    }
    
    this.isMonitoring = false;
    console.info('HeadsetMonitor stopped');
  }
}

方案二：使用ServiceExtension实现后台监听

// HeadsetMonitorService.ets
import { ServiceExtensionAbility } from '@ohos.app.ability.ServiceExtensionAbility';
import { audio, AVSessionManager } from '@ohos.multimedia.avsession';

export default class HeadsetMonitorService extends ServiceExtensionAbility {
  private avSessionManager: AVSessionManager | null = null;
  private isHeadsetConnected: boolean = false;

  onCreate(want): void {
    console.info('HeadsetMonitorService onCreate');
    this.initHeadsetMonitoring();
  }

  private async initHeadsetMonitoring(): Promise<void> {
    try {
      // 获取AVSessionManager实例
      this.avSessionManager = await AVSessionManager.getInstance();
      
      // 监听系统音频设备变化
      await this.setupAudioDeviceListener();
      
      // 监听所有AVSession
      await this.setupAVSessionListener();
      
    } catch (error) {
      console.error('Failed to init headset monitoring:', error);
    }
  }

  private async setupAudioDeviceListener(): Promise<void> {
    const audioManager = audio.getAudioManager();
    
    audioManager.on('audioDeviceChange', (deviceChanged) => {
      this.handleAudioDeviceChange(deviceChanged);
    });
  }

  private handleAudioDeviceChange(deviceChanged: any): void {
    const { deviceType, action } = deviceChanged;
    
    // 检查是否是耳机设备
    const isHeadsetDevice = [
      audio.DeviceType.WIRED_HEADSET,
      audio.DeviceType.WIRED_HEADPHONES,
      audio.DeviceType.BLUETOOTH_A2DP,
      audio.DeviceType.BLUETOOTH_SCO
    ].includes(deviceType);

    if (isHeadsetDevice) {
      const isConnected = action === audio.ConnectionState.CONNECTED;
      
      if (this.isHeadsetConnected !== isConnected) {
        this.isHeadsetConnected = isConnected;
        this.notifyHeadsetStateChange(isConnected);
      }
    }
  }

  private async setupAVSessionListener(): Promise<void> {
    if (!this.avSessionManager) return;

    // 监听系统AVSession变化
    this.avSessionManager.on('sessionCreate', (session) => {
      this.monitorSession(session);
    });

    // 获取现有会话
    const sessions = await this.avSessionManager.getAllSessions();
    sessions.forEach(session => {
      this.monitorSession(session);
    });
  }

  private monitorSession(session: any): void {
    session.on('audioRendererChange', (changeInfo) => {
      this.handleSessionAudioChange(session, changeInfo);
    });
  }

  private handleSessionAudioChange(session: any, changeInfo: any): void {
    // 获取会话的音频设备信息
    const audioDevices = changeInfo?.audioRendererInfo?.audioDeviceDescriptors || [];
    
    const hasHeadset = audioDevices.some(device => {
      return device.type === 'WIRED_HEADSET' || 
             device.type === 'BLUETOOTH_A2DP';
    });

    if (!hasHeadset && this.isHeadsetConnected) {
      // 耳机断开，通知对应会话
      this.notifySessionToPause(session);
    }
  }

  private notifyHeadsetStateChange(isConnected: boolean): void {
    // 发送系统事件通知
    const event = {
      event: 'headset_state_changed',
      connected: isConnected,
      timestamp: new Date().getTime()
    };
    
    console.info('Headset state changed:', event);
    
    // 这里可以添加更多通知逻辑，如发送广播
  }

  private notifySessionToPause(session: any): void {
    try {
      const controller = session.getController();
      controller.pause().catch(() => {
        console.warn('Failed to pause session via controller');
      });
    } catch (error) {
      console.error('Error pausing session:', error);
    }
  }

  onDestroy(): void {
    console.info('HeadsetMonitorService onDestroy');
    this.cleanup();
  }

  private cleanup(): void {
    if (this.avSessionManager) {
      // 清理监听器
      this.avSessionManager.off('sessionCreate');
      this.avSessionManager = null;
    }
  }
}

方案三：配置文件与权限设置

module.json5配置：

{
  "module": {
    "abilities": [
      {
        "name": ".HeadsetMonitorService",
        "type": "service",
        "backgroundModes": ["audioPlayback"],
        "visible": true
      }
    ],
    "requestPermissions": [
      {
        "name": "ohos.permission.MANAGE_MEDIA_RESOURCES",
        "reason": "用于监听和管理音频会话",
        "usedScene": {
          "abilities": ["EntryAbility"],
          "when": "always"
        }
      }
    ],
    "extensionAbilities": [
      {
        "name": "HeadsetMonitorService",
        "type": "service",
        "visible": true,
        "srcEntry": "./ets/headsetmonitor/HeadsetMonitorService.ets"
      }
    ]
  }
}

// 在应用主Ability中集成
import { HeadsetMonitor } from './HeadsetMonitor';

export default class EntryAbility extends UIAbility {
  private headsetMonitor: HeadsetMonitor;

  onCreate(want, launchParam) {
    this.headsetMonitor = new HeadsetMonitor();

    // 设置状态变化回调
    this.headsetMonitor.onHeadsetStateChange = (isConnected) => {
      this.handleHeadsetChange(isConnected);
    };

    // 初始化监听
    this.headsetMonitor.initialize(this.context);
  }

  onDestroy() {
    this.headsetMonitor.stopMonitoring();
  }

  private handleHeadsetChange(isConnected: boolean) {
    console.info(`Headset ${isConnected ? 'connected' : 'disconnected'}`);
    // 更新UI状态
    // 保存播放状态
  }
}

1.3 结果展示

最佳实践总结

• 错误处理：网络异常时使用最后一次已知状态
• 状态同步：应用启动时检查当前耳机状态
• 电量优化：应用进入后台时降低检测频率
• 用户提示：耳机断开时提供友好的暂停提示
• 配置可调：提供灵敏度、延迟等可配置参数