Flutter未知功能探索插件ocarina的使用

Ocarina简介

Ocarina 是一个简单易用的Flutter音频包，旨在支持从本地文件（来自资源或文件系统）播放音频，并且在所有Flutter运行的平台上提供支持。目前，仅支持移动平台（Android和iOS），后续将支持Web和桌面平台（Linux、MacOS和Windows）。

如果你有任何问题或潜在的功能请求想要讨论，可以加入 Blue Fire Discord服务器。

使用方法

使用资源文件

final player = OcarinaPlayer(
  asset: 'assets/Loop-Menu.wav',
  package: 'my_package_name',
  loop: true,
  volume: 0.8,
);

await player.load();

使用设备文件系统中的文件

final player = OcarinaPlayer(
  filePath: '/SomeWhere/On/The/Device/Loop-Menu.wav',
  loop: true,
  volume: 0.8,
);

await player.load();

API文档

以下是OcarinaPlayer实例可用的方法列表：

• play: 开始播放。
• pause: 暂停播放。
• resume: 如果之前暂停，则恢复播放。
• stop: 停止播放，可以通过再次调用play重新开始。
• seek(Duration): 将播放位置移动到指定的Duration。
• position: 获取当前播放位置（以毫秒为单位）。
• updateVolume(double): 更新音量，值应在0到1之间。
• dispose: 清除内存中的加载资源，若需再次使用该实例，则需重新调用load方法。

iOS委托

为了应对iOS中操作系统给VoiceProcessingIO Audio Unit优先级的问题，导致ocarina播放的音频文件音量显著降低，引入了iOS委托功能。此功能与twilio_programmable_video插件共同开发，具体配置请参考官方文档。

音频播放器状态监听器

为了与其他插件（如twilio_programmable_video）协同工作，提供了音频播放器状态监听器功能。开发者可以根据需要添加自定义监听器，监听器签名如下：

• Android: (url: String, isPlaying: Boolean) -> Unit
• iOS: (_ url: String, _ isPlaying: Bool) -> Void

示例代码

以下是一个完整的示例demo，展示了如何使用Ocarina插件进行音频播放：

import 'dart:async';
import 'dart:io';

import 'package:flutter/material.dart';
import 'package:http/http.dart' as http;
import 'package:ocarina/ocarina.dart';
import 'package:path_provider/path_provider.dart';

void main() => runApp(MyApp());

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Demo',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: MyHomePage(title: 'Ocarina Example'),
    );
  }
}

class MyHomePage extends StatefulWidget {
  MyHomePage({required this.title});

  final String title;

  @override
  _MyHomePageState createState() => _MyHomePageState();
}

const staticFileUrl = 'https://luan.xyz/files/audio/ambient_c_motion.mp3';

class _MyHomePageState extends State<MyHomePage> {
  OcarinaPlayer? _player;
  String? _localFilePath;
  bool _loop = true;
  bool _fetchingFile = false;

  Future _loadFile() async {
    final bytes = await http.readBytes(Uri.parse(staticFileUrl));
    final dir = await getApplicationDocumentsDirectory();
    final file = File('${dir.path}/audio.mp3');

    await file.writeAsBytes(bytes);
    if (await file.exists()) {
      setState(() {
        _localFilePath = file.path;
      });
    }
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text(widget.title),
      ),
      body: Center(
        child: (_player != null
            ? PlayerWidget(
                player: _player!,
                onBack: () {
                  setState(() {
                    _localFilePath = null;
                    _fetchingFile = false;
                    _player = null;
                  });
                })
            : Column(
                children: [
                  ElevatedButton(
                      child: Text(_loop ? "Loop mode" : "Single play mode"),
                      onPressed: () async {
                        setState(() {
                          _loop = !_loop;
                        });
                      }),
                  ElevatedButton(
                      child: Text("Play asset audio"),
                      onPressed: () async {
                        final player = OcarinaPlayer(
                            asset: 'assets/Loop-Menu.wav', loop: _loop);

                        setState(() {
                          _player = player;
                        });
                      }),
                  ElevatedButton(
                      child: Text(_fetchingFile
                          ? "Fetching file..."
                          : "Download file to Device, and play it"),
                      onPressed: () async {
                        if (_fetchingFile) return;
                        setState(() {
                          _fetchingFile = true;
                        });
                        await _loadFile();

                        final player = OcarinaPlayer(filePath: _localFilePath);
                        await player.load();

                        setState(() {
                          _player = player;
                        });
                      })
                ],
              )),
      ),
    );
  }
}

class PlayerWidget extends StatelessWidget {
  final OcarinaPlayer player;
  final VoidCallback onBack;

  PlayerWidget({required this.player, required this.onBack});

  @override
  Widget build(_) {
    return FutureBuilder(
        future: player.load(),
        builder: (ctx, snapshot) {
          switch (snapshot.connectionState) {
            case ConnectionState.waiting:
            case ConnectionState.none:
            case ConnectionState.active:
              return Text("Loading player");
            case ConnectionState.done:
              if (snapshot.hasError) {
                return Column(
                  children: [
                    Text("Error loading player"),
                    ElevatedButton(
                      child: Text("Go Back"),
                      onPressed: onBack.call,
                    ),
                  ],
                );
              }
              return Column(
                  mainAxisAlignment: MainAxisAlignment.center,
                  children: <Widget>[
                    ElevatedButton(
                        child: Text("Play"),
                        onPressed: () async {
                          await player.play();
                        }),
                    ElevatedButton(
                        child: Text("Stop"),
                        onPressed: () async {
                          await player.stop();
                        }),
                    ElevatedButton(
                        child: Text("Pause"),
                        onPressed: () async {
                          await player.pause();
                        }),
                    ElevatedButton(
                        child: Text("Resume"),
                        onPressed: () async {
                          await player.resume();
                        }),
                    ElevatedButton(
                        child: Text("Seek to 5 secs"),
                        onPressed: () async {
                          await player.seek(Duration(seconds: 5));
                        }),
                    Row(mainAxisAlignment: MainAxisAlignment.center, children: [
                      Text("Volume"),
                      ElevatedButton(
                          child: Text("0.2"),
                          onPressed: () async {
                            await player.updateVolume(0.2);
                          }),
                      ElevatedButton(
                          child: Text("0.5"),
                          onPressed: () async {
                            await player.updateVolume(0.5);
                          }),
                      ElevatedButton(
                          child: Text("1.0"),
                          onPressed: () async {
                            await player.updateVolume(1.0);
                          }),
                    ]),
                    ElevatedButton(
                        child: Text("Dispose"),
                        onPressed: () async {
                          await player.dispose();
                        }),
                    ElevatedButton(
                      child: Text("Go Back"),
                      onPressed: onBack.call,
                    ),
                  ]);
          }
        });
  }
}

通过上述内容，您可以了解如何在Flutter项目中使用Ocarina插件来实现音频播放功能，并根据需求调整播放模式、音量等参数。希望这对您有所帮助！