多场景音乐播放系统开发：从音频处理到后台播放优化

在实际开发音乐类应用或音视频处理项目时，背景音乐、冥想音乐、放松音乐、睡眠音乐、助眠音乐和深度睡眠音乐是常见的功能需求。这些音乐类型虽然听起来相似，但在技术实现上涉及音频文件管理、播放控制、音效处理、循环策略和用户体验等多个层面。很多开发者只关注了播放器的基本功能，却忽略了不同场景下音乐切换的逻辑、音频资源的加载优化、后台播放的稳定性以及如何通过技术手段真正实现“助眠”或“深度放松”的效果。

本文将从一个全栈开发者的视角，解析如何为应用集成一套完整的多场景音乐播放系统。我们会从音频资源的选择与处理开始，逐步实现一个可配置、可扩展的音乐播放模块，并重点解决后台播放、无缝切换、内存管理和睡眠计时等实际工程问题。无论你是开发独立的冥想App、健康类应用，还是为现有项目增加背景音乐功能，都能从中获得可直接复用的代码和配置方案。

1. 理解不同场景音乐的技术差异与选型要点

背景音乐、冥想音乐、放松音乐、睡眠音乐、助眠音乐和深度睡眠音乐，在用户体验目标上各有侧重，这些差异会直接影响技术实现方案的选择。

1.1 六类音乐的功能定位与技术特征

在实际项目中，这六类音乐需要不同的技术处理：

• 背景音乐 ：通常循环播放，音量较低，不能干扰主操作。技术重点是无缝循环和音量淡化处理。
• 冥想音乐 ：需要保持稳定的节奏和音调，避免突然的音量变化。技术重点是音频质量保证和防中断。
• 放松音乐 ：旋律舒缓，可能需要配合自然音效。技术重点是音效混合和渐变过渡。
• 睡眠音乐 ：播放时间较长，需要考虑省电和后台播放稳定性。
• 助眠音乐 ：通常有特定的频率或声波设计，可能需要实时音频处理。
• 深度睡眠音乐 ：播放时间最长，对内存管理和电池消耗有更高要求。

从技术实现角度看，这些音乐类型可以归为三类处理方案：

1.2 音频格式选择与性能考量

选择合适的音频格式是项目成功的基础。不同平台和场景下，格式选择需要权衡文件大小、解码效率和兼容性。

# 查看音频文件信息的FFmpeg命令示例
ffmpeg -i background_music.mp3

常见的音频格式对比：

• MP3 ：兼容性最好，但文件较大。适合短时背景音乐。
• AAC ：同等质量下文件更小，iOS平台首选。
• OGG ：开源格式，Android支持较好。
• WAV ：无损质量，文件巨大，适合短音效。
• FLAC ：无损压缩，适合高质量冥想音乐。

在实际项目中，建议根据目标平台和音乐时长选择格式：

// Android音频格式配置示例
public class AudioFormatConfig {
    // 短背景音乐使用AAC
    public static final String BACKGROUND_FORMAT = "aac";
    // 长时睡眠音乐使用低码率MP3
    public static final String SLEEP_FORMAT = "mp3";
    public static final int SLEEP_BITRATE = 64; // kbps
}

1.3 音频质量与文件大小的平衡

长时播放的音乐需要特别关注文件大小和网络流量。对于睡眠音乐等长时间内容，可以采用以下优化策略：

• 使用单声道而非立体声（文件大小减少约50%）
• 降低采样率（22050Hz代替44100Hz）
• 使用更低的比特率（64kbps代替128kbps）

# Python音频处理示例：优化睡眠音乐文件大小
import ffmpeg

def optimize_audio_for_sleep(input_file, output_file):
    ffmpeg.input(input_file).output(
        output_file,
        ac=1,           # 单声道
        ar=22050,       # 22050Hz采样率
        ab='64k'        # 64kbps比特率
    ).run()

2. 构建可配置的音乐播放系统架构

一个健壮的音乐播放系统需要清晰的分层架构，便于维护和扩展。我们将系统分为资源层、控制层、播放层和UI层。

2.1 项目结构与依赖配置

首先创建标准的项目结构，确保各模块职责清晰：

music-player/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/example/musicplayer/
│   │   │       ├── model/
│   │   │       │   ├── MusicItem.java
│   │   │       │   └── Playlist.java
│   │   │       ├── service/
│   │   │       │   ├── MusicService.java
│   │   │       │   └── AudioFocusManager.java
│   │   │       ├── player/
│   │   │       │   ├── BasePlayer.java
│   │   │       │   └── ExoPlayerWrapper.java
│   │   │       └── ui/
│   │   │           ├── MainActivity.java
│   │   │           └── MusicController.java
│   │   └── res/
│   │       ├── raw/           # 本地音频资源
│   │       │   ├── background_music.mp3
│   │       │   ├── meditation_music.aac
│   │       │   └── sleep_music.mp3
│   │       └── xml/
│   │           └── music_config.xml

对于Android项目，需要在 build.gradle 中添加必要的依赖：

dependencies {
    implementation 'androidx.media:media:1.6.0'
    implementation 'com.google.android.exoplayer:exoplayer:2.19.1'
    implementation 'com.google.android.exoplayer:exoplayer-core:2.19.1'
    implementation 'com.google.android.exoplayer:exoplayer-ui:2.19.1'
    
    // 音频处理相关
    implementation 'com.arthenica:mobile-ffmpeg-full:4.4.LTS'
}

2.2 音乐数据模型设计

设计合理的数据模型是系统可扩展的关键。我们需要区分音乐类型、播放模式和用户偏好。

public class MusicItem {
    private String id;
    private String title;
    private MusicType type; // 枚举：BACKGROUND, MEDITATION, SLEEP等
    private String audioUrl; // 本地路径或网络URL
    private int duration; // 时长（秒）
    private int volume; // 默认音量（0-100）
    private boolean loop; // 是否循环
    private Map<String, Object> effects; // 音效参数
    
    public enum MusicType {
        BACKGROUND,     // 背景音乐
        MEDITATION,     // 冥想音乐  
        RELAXATION,     // 放松音乐
        SLEEP,          // 睡眠音乐
        SLEEP_AID,      // 助眠音乐
        DEEP_SLEEP      // 深度睡眠音乐
    }
}

播放列表配置使用XML便于管理：

<!-- res/xml/music_config.xml -->
<music-config>
    <category name="background">
        <music 
            id="bg1" 
            title="轻柔背景" 
            src="@raw/background_music"
            volume="30"
            loop="true"/>
    </category>
    
    <category name="sleep">
        <music
            id="sleep1"
            title="深度睡眠"
            src="@raw/sleep_music" 
            volume="20"
            loop="true"
            fadeIn="5000"/> <!-- 5秒淡入 -->
    </category>
</music-config>

2.3 核心播放服务实现

音乐播放服务需要处理音频焦点、后台播放和生命周期管理：

public class MusicService extends Service implements AudioManager.OnAudioFocusChangeListener {
    private ExoPlayerWrapper player;
    private AudioFocusManager audioFocusManager;
    private MusicItem currentMusic;
    private boolean isPausedByTransientFocusLoss = false;
    
    @Override
    public void onCreate() {
        super.onCreate();
        player = new ExoPlayerWrapper(this);
        audioFocusManager = new AudioFocusManager(this);
        
        // 配置播放器参数
        player.setWakeMode(C.POWER_MODE_NETWORK); // 保持设备唤醒
        player.setHandleAudioBecomingNoisy(true); // 处理音频设备变化
    }
    
    public void playMusic(MusicItem music) {
        // 请求音频焦点
        int result = audioFocusManager.requestAudioFocus();
        if (result == AudioManager.AUDIOFOCUS_REQUEST_GRANTED) {
            currentMusic = music;
            player.setVolume(music.getVolume() / 100f);
            player.setLooping(music.isLoop());
            player.play(music.getAudioUrl());
            
            // 根据音乐类型设置不同的播放策略
            applyMusicTypeStrategy(music.getType());
        }
    }
    
    private void applyMusicTypeStrategy(MusicItem.MusicType type) {
        switch (type) {
            case SLEEP:
            case DEEP_SLEEP:
                // 睡眠音乐：降低功耗，忽略音频焦点短暂丢失
                player.setPowerMode(C.POWER_MODE_LOW);
                break;
            case MEDITATION:
                // 冥想音乐：保证播放质量，防止中断
                player.setPowerMode(C.POWER_MODE_HIGH);
                break;
            default:
                player.setPowerMode(C.POWER_MODE_MEDIUM);
        }
    }
    
    @Override
    public void onAudioFocusChange(int focusChange) {
        switch (focusChange) {
            case AudioManager.AUDIOFOCUS_LOSS:
                // 长时间失去焦点，停止播放
                pauseMusic();
                break;
            case AudioManager.AUDIOFOCUS_LOSS_TRANSIENT:
                // 短暂失去焦点，暂停播放
                if (player.isPlaying()) {
                    pauseMusic();
                    isPausedByTransientFocusLoss = true;
                }
                break;
            case AudioManager.AUDIOFOCUS_GAIN:
                // 重新获得焦点，恢复播放
                if (isPausedByTransientFocusLoss) {
                    playMusic(currentMusic);
                    isPausedByTransientFocusLoss = false;
                }
                break;
        }
    }
}

3. 实现场景化音乐播放策略

不同场景的音乐需要特定的播放策略，包括音量控制、过渡效果和循环逻辑。

3.1 音量淡化与平滑过渡

abrupt的音量变化会影响用户体验，特别是睡眠和冥想场景。实现平滑的音量过渡：

public class VolumeFadeController {
    private static final int FADE_DURATION = 3000; // 3秒过渡
    
    public static void fadeIn(ExoPlayer player, int targetVolume) {
        ValueAnimator animator = ValueAnimator.ofFloat(0f, targetVolume / 100f);
        animator.setDuration(FADE_DURATION);
        animator.addUpdateListener(animation -> {
            float volume = (float) animation.getAnimatedValue();
            player.setVolume(volume);
        });
        animator.start();
    }
    
    public static void fadeOut(ExoPlayer player, Runnable onComplete) {
        float currentVolume = player.getVolume();
        ValueAnimator animator = ValueAnimator.ofFloat(currentVolume, 0f);
        animator.setDuration(FADE_DURATION);
        animator.addUpdateListener(animation -> {
            float volume = (float) animation.getAnimatedValue();
            player.setVolume(volume);
        });
        animator.addListener(new AnimatorListenerAdapter() {
            @Override
            public void onAnimationEnd(Animator animation) {
                if (onComplete != null) onComplete.run();
            }
        });
        animator.start();
    }
}

3.2 智能循环与播放队列管理

对于长时间播放的音乐，需要智能的循环策略来避免重复感：

public class SmartPlaylistManager {
    private List<MusicItem> currentPlaylist;
    private int currentIndex;
    private PlayMode playMode = PlayMode.SEQUENTIAL;
    
    public enum PlayMode {
        SEQUENTIAL,     // 顺序播放
        LOOP,          // 单曲循环
        SHUFFLE        // 随机播放
    }
    
    public MusicItem getNextMusic() {
        switch (playMode) {
            case LOOP:
                return currentPlaylist.get(currentIndex);
            case SHUFFLE:
                int randomIndex = new Random().nextInt(currentPlaylist.size());
                currentIndex = randomIndex;
                return currentPlaylist.get(randomIndex);
            case SEQUENTIAL:
            default:
                currentIndex = (currentIndex + 1) % currentPlaylist.size();
                return currentPlaylist.get(currentIndex);
        }
    }
    
    // 为睡眠音乐创建专用播放列表
    public List<MusicItem> createSleepPlaylist() {
        List<MusicItem> sleepMusic = musicRepository.getByType(MusicItem.MusicType.SLEEP);
        List<MusicItem> deepSleepMusic = musicRepository.getByType(MusicItem.MusicType.DEEP_SLEEP);
        
        // 混合两种类型，避免单一音乐重复
        List<MusicItem> playlist = new ArrayList<>();
        playlist.addAll(sleepMusic);
        playlist.addAll(deepSleepMusic);
        Collections.shuffle(playlist);
        
        return playlist;
    }
}

3.3 后台播放与省电优化

睡眠音乐通常需要整夜播放，必须优化电池使用：

public class PowerOptimizationManager {
    private WakeLock wakeLock;
    private WifiLock wifiLock;
    
    public void acquireLocks() {
        // 获取部分唤醒锁，保持CPU运行但允许屏幕关闭
        PowerManager powerManager = (PowerManager) context.getSystemService(Context.POWER_SERVICE);
        wakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "MusicPlayer:WakeLock");
        wakeLock.acquire(10 * 60 * 1000L /*10分钟*/); // 设置超时避免忘记释放
        
        // 保持WIFI连接，防止网络音乐中断
        WifiManager wifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
        wifiLock = wifiManager.createWifiLock(WifiManager.WIFI_MODE_FULL, "MusicPlayer:WifiLock");
        wifiLock.acquire();
    }
    
    public void releaseLocks() {
        if (wakeLock != null && wakeLock.isHeld()) {
            wakeLock.release();
        }
        if (wifiLock != null && wifiLock.isHeld()) {
            wifiLock.release();
        }
    }
    
    // 优化播放器功耗配置
    public void configureLowPowerMode(ExoPlayer player) {
        // 降低缓冲大小和超时时间
        DefaultLoadControl loadControl = new DefaultLoadControl.Builder()
                .setBufferDurationsMs(
                    1000,  // 最小缓冲时间
                    5000,  // 最大缓冲时间  
                    500,   // 播放开始前缓冲
                    500    // 播放后继续缓冲
                )
                .build();
        
        player.setLoadControl(loadControl);
    }
}

4. 音频处理与音效增强

对于助眠和深度睡眠音乐，可以通过音频处理技术增强效果。

4.1 双声道平衡与频率调整

某些助眠音乐利用双声道差异或特定频率来诱导放松状态：

public class AudioEffectProcessor {
    // 创建双声道平衡效果
    public void applyStereoBalance(AudioTrack audioTrack, float balance) {
        // balance: -1.0（完全左声道）到 1.0（完全右声道）
        StereoBalanceEffect stereoBalance = new StereoBalanceEffect();
        stereoBalance.setBalance(balance);
        audioTrack.attachAuxEffect(stereoBalance.getId());
    }
    
    // 应用低频增强（用于放松效果）
    public void applyBassBoost(AudioTrack audioTrack, int strength) {
        // strength: 0-1000
        BassBoost bassBoost = new BassBoost(0, audioTrack.getAudioSessionId());
        bassBoost.setStrength((short) strength);
        audioTrack.attachAuxEffect(bassBoost.getId());
    }
    
    // 生成白噪音或粉噪音（助眠常用）
    public short[] generateWhiteNoise(int durationMs, int sampleRate) {
        int sampleCount = durationMs * sampleRate / 1000;
        short[] noise = new short[sampleCount];
        Random random = new Random();
        
        for (int i = 0; i < sampleCount; i++) {
            noise[i] = (short) (random.nextInt(65536) - 32768);
        }
        return noise;
    }
}

4.2 实时音频流处理

对于需要动态调整的音频内容，可以使用实时处理：

# Python实时音频处理示例（可用于服务器端生成）
import numpy as np
import pyaudio

class SleepAudioGenerator:
    def __init__(self, sample_rate=44100):
        self.sample_rate = sample_rate
        self.phase = 0
        
    def generate_binaural_beats(self, base_freq, delta_freq, duration):
        """生成双耳节拍音效，常用于助眠"""
        t = np.linspace(0, duration, int(self.sample_rate * duration))
        
        # 左右声道略有频率差异
        left_channel = np.sin(2 * np.pi * base_freq * t + self.phase)
        right_channel = np.sin(2 * np.pi * (base_freq + delta_freq) * t + self.phase)
        
        # 合并为立体声
        stereo_signal = np.column_stack((left_channel, right_channel))
        return stereo_signal.astype(np.float32)

5. 完整实现与集成测试

现在我们将各个模块整合，实现一个完整的音乐播放器，并确保不同场景下的稳定性。

5.1 主控制器与UI集成

创建统一的音乐控制器，管理所有播放逻辑：

public class MusicController {
    private MusicService musicService;
    private SmartPlaylistManager playlistManager;
    private PowerOptimizationManager powerManager;
    private MusicItem.MusicType currentMode = MusicItem.MusicType.BACKGROUND;
    
    public void setMusicMode(MusicItem.MusicType mode) {
        this.currentMode = mode;
        applyModeSpecificSettings(mode);
    }
    
    private void applyModeSpecificSettings(MusicItem.MusicType mode) {
        switch (mode) {
            case SLEEP:
            case DEEP_SLEEP:
                powerManager.acquireLocks();
                playlistManager.setPlayMode(SmartPlaylistManager.PlayMode.LOOP);
                // 睡眠模式：自动设置定时停止
                setupSleepTimer(8 * 60 * 60 * 1000); // 8小时
                break;
            case MEDITATION:
                playlistManager.setPlayMode(SmartPlaylistManager.PlayMode.SEQUENTIAL);
                // 冥想模式：不自动停止，等待用户操作
                cancelSleepTimer();
                break;
            case BACKGROUND:
                powerManager.releaseLocks();
                playlistManager.setPlayMode(SmartPlaylistManager.PlayMode.SHUFFLE);
                cancelSleepTimer();
                break;
        }
    }
    
    public void playNext() {
        MusicItem nextMusic = playlistManager.getNextMusic();
        musicService.playMusic(nextMusic);
        
        // 应用音量淡化效果
        VolumeFadeController.fadeIn(musicService.getPlayer(), nextMusic.getVolume());
    }
}

5.2 睡眠计时器与智能停止

睡眠音乐需要可靠的自动停止机制：

public class SleepTimerManager {
    private Handler handler;
    private Runnable stopRunnable;
    private long stopTimeMillis;
    
    public void setSleepTimer(long durationMillis) {
        cancelExistingTimer();
        
        stopTimeMillis = System.currentTimeMillis() + durationMillis;
        stopRunnable = () -> {
            // 淡出音量后停止播放
            VolumeFadeController.fadeOut(musicService.getPlayer(), () -> {
                musicService.stopMusic();
                powerManager.releaseLocks();
            });
        };
        
        handler.postDelayed(stopRunnable, durationMillis);
    }
    
    public void cancelSleepTimer() {
        if (handler != null && stopRunnable != null) {
            handler.removeCallbacks(stopRunnable);
        }
    }
    
    public String getRemainingTime() {
        long remaining = stopTimeMillis - System.currentTimeMillis();
        if (remaining <= 0) return "00:00";
        
        long hours = remaining / (1000 * 60 * 60);
        long minutes = (remaining % (1000 * 60 * 60)) / (1000 * 60);
        return String.format("%02d:%02d", hours, minutes);
    }
}

5.3 性能测试与内存管理

长时间播放必须监控资源使用情况：

public class PerformanceMonitor {
    private static final long CHECK_INTERVAL = 60000; // 1分钟检查一次
    
    public void startMonitoring() {
        Timer timer = new Timer();
        timer.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                checkMemoryUsage();
                checkBatteryUsage();
                checkNetworkUsage();
            }
        }, CHECK_INTERVAL, CHECK_INTERVAL);
    }
    
    private void checkMemoryUsage() {
        Runtime runtime = Runtime.getRuntime();
        long usedMemory = runtime.totalMemory() - runtime.freeMemory();
        long maxMemory = runtime.maxMemory();
        double usagePercent = (double) usedMemory / maxMemory * 100;
        
        if (usagePercent > 80) {
            // 内存使用过高，清理缓存
            clearImageCache();
            reduceAudioBuffer();
        }
    }
    
    private void checkBatteryUsage() {
        BatteryManager batteryManager = (BatteryManager) context.getSystemService(Context.BATTERY_SERVICE);
        int batteryLevel = batteryManager.getIntProperty(BatteryManager.BATTERY_PROPERTY_CAPACITY);
        
        if (batteryLevel < 15) {
            // 电量过低，切换到省电模式
            powerManager.configureLowPowerMode(musicService.getPlayer());
        }
    }
}

6. 常见问题排查与优化建议

在实际部署中，音乐播放功能会遇到各种问题。以下是典型问题的排查路径。

6.1 音频播放问题排查表

6.2 后台播放稳定性保障

确保音乐在后台长时间稳定播放：

public class MusicForegroundService extends Service {
    private static final int NOTIFICATION_ID = 1;
    private static final String CHANNEL_ID = "music_channel";
    
    @Override
    public void onCreate() {
        super.onCreate();
        createNotificationChannel();
    }
    
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        startForeground(NOTIFICATION_ID, buildNotification());
        return START_STICKY; // 被系统杀死后自动重启
    }
    
    private Notification buildNotification() {
        Intent intent = new Intent(this, MainActivity.class);
        PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, intent, 0);
        
        return new NotificationCompat.Builder(this, CHANNEL_ID)
                .setContentTitle("音乐播放中")
                .setContentText("当前播放: " + currentMusic.getTitle())
                .setSmallIcon(R.drawable.ic_music_note)
                .setContentIntent(pendingIntent)
                .setSilent(true) // 不要发出通知声音
                .build();
    }
    
    // 处理系统内存不足时的行为
    @Override
    public void onTrimMemory(int level) {
        super.onTrimMemory(level);
        if (level >= ComponentCallbacks2.TRIM_MEMORY_MODERATE) {
            // 内存紧张时释放非核心资源
            releaseNonEssentialResources();
        }
    }
}

6.3 跨版本兼容性处理

不同Android版本对后台播放的限制不同，需要针对性处理：

public class CompatibilityHelper {
    public static boolean isBackgroundRestricted() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
            ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
            return activityManager.isBackgroundRestricted();
        }
        return false;
    }
    
    public static void handleBackgroundRestrictions() {
        if (isBackgroundRestricted()) {
            // Android 9+ 后台限制，需要引导用户设置
            showBackgroundWhitelistDialog();
        }
        
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
            // Android 12+ 精确闹钟权限
            requestExactAlarmPermission();
        }
    }
    
    public static boolean canScheduleExactAlarms() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
            AlarmManager alarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
            return alarmManager.canScheduleExactAlarms();
        }
        return true;
    }
}

7. 生产环境部署与监控

将音乐播放功能部署到生产环境时，还需要考虑监控、统计和故障恢复。

7.1 播放质量监控

收集播放数据用于优化用户体验：

public class PlaybackAnalytics {
    public void logPlaybackStart(MusicItem music) {
        Map<String, String> params = new HashMap<>();
        params.put("music_id", music.getId());
        params.put("music_type", music.getType().name());
        params.put("timestamp", String.valueOf(System.currentTimeMillis()));
        
        analytics.logEvent("playback_start", params);
    }
    
    public void logPlaybackError(String errorCode, String details) {
        Map<String, String> params = new HashMap<>();
        params.put("error_code", errorCode);
        params.put("error_details", details);
        params.put("device_info", getDeviceInfo());
        
        analytics.logEvent("playback_error", params);
    }
    
    public void logBatteryImpact(long playbackDuration, int batteryDrain) {
        // 监控播放时长对电池的影响
        Map<String, String> params = new HashMap<>();
        params.put("duration", String.valueOf(playbackDuration));
        params.put("battery_drain", String.valueOf(batteryDrain));
        params.put("efficiency", String.valueOf(playbackDuration / Math.max(1, batteryDrain)));
        
        analytics.logEvent("battery_impact", params);
    }
}

7.2 自适应码率与网络优化

根据网络状况动态调整音频质量：

public class AdaptiveBitrateManager {
    private NetworkInfo networkInfo;
    private int currentBitrate = 128; // 默认128kbps
    
    public int getOptimalBitrate() {
        if (networkInfo == null) return currentBitrate;
        
        switch (networkInfo.getType()) {
            case ConnectivityManager.TYPE_WIFI:
                return 256; // 高质量
            case ConnectivityManager.TYPE_ETHERNET:
                return 256;
            case ConnectivityManager.TYPE_MOBILE:
                switch (networkInfo.getSubtype()) {
                    case TelephonyManager.NETWORK_TYPE_LTE:
                    case TelephonyManager.NETWORK_TYPE_NR:
                        return 192; // 中等质量
                    default:
                        return 96;  // 低质量
                }
            default:
                return 128;
        }
    }
    
    public void adjustBitrateBasedOnNetwork() {
        int optimalBitrate = getOptimalBitrate();
        if (optimalBitrate != currentBitrate) {
            currentBitrate = optimalBitrate;
            musicService.adjustBitrate(optimalBitrate);
        }
    }
}

7.3 灾难恢复与数据备份

确保用户音乐偏好和播放记录不会丢失：

public class BackupManager {
    private static final String BACKUP_KEY = "music_preferences_backup";
    
    public void backupUserPreferences(UserPreferences prefs) {
        String json = new Gson().toJson(prefs);
        SharedPreferences sharedPrefs = PreferenceManager.getDefaultSharedPreferences(context);
        sharedPrefs.edit().putString(BACKUP_KEY, json).apply();
        
        // 可选：备份到云存储
        backupToCloud(json);
    }
    
    public UserPreferences restoreUserPreferences() {
        SharedPreferences sharedPrefs = PreferenceManager.getDefaultSharedPreferences(context);
        String json = sharedPrefs.getString(BACKUP_KEY, null);
        
        if (json != null) {
            return new Gson().fromJson(json, UserPreferences.class);
        } else {
            // 从云存储恢复
            return restoreFromCloud();
        }
    }
    
    private void backupToCloud(String data) {
        // 实现云备份逻辑
        // 注意：需要用户授权和网络连接处理
    }
}

实现完整的音乐播放系统需要综合考虑音频处理、播放控制、资源管理和用户体验等多个方面。从技术选型到生产部署，每个环节都需要针对不同的音乐场景进行优化。特别是对于睡眠、冥想等长时间播放场景，稳定性、功耗和用户体验的平衡尤为重要。

在实际项目中，建议先实现核心播放功能，然后逐步添加场景化特性，并通过充分的测试确保各种边界情况的处理。监控和数据分析可以帮助持续优化播放质量和资源使用效率，最终为用户提供真正有价值的音乐体验。