Update SoundEffectPlayer to use the SoundPool API

packages/flutter/pubspec.yaml

@@ -7,8 +7,8 @@ dependencies:
   collection: '>=1.1.3 <2.0.0'
   intl: '>=0.12.4+2 <0.13.0'
   material_design_icons: '>=0.0.3 <0.1.0'
-  sky_engine: 0.0.71
-  sky_services: 0.0.71
+  sky_engine: 0.0.72
+  sky_services: 0.0.72
   vector_math: '>=1.4.3 <2.0.0'
 
   # To pin the transitive dependency through mojo_sdk.

packages/flutter_sprites/lib/src/sound.dart

 part of flutter_sprites;
 
-// TODO: The sound effects should probably use Android's SoundPool instead of
-// MediaPlayer as it is more efficient and flexible for playing back sound effects
-
-typedef void SoundEffectStreamCallback(SoundEffectStream stream);
-
+/// An audio asset loaded by the SoundEffectPlayer.
 class SoundEffect {
-  SoundEffect(this._pipeFuture);
-
-  // TODO: Remove load method from SoundEffect
-  Future load() async {
-    _data = await _pipeFuture;
-  }
+  SoundEffect(this._soundId);
 
-  Future<MojoDataPipeConsumer> _pipeFuture;
-  MojoDataPipeConsumer _data;
+  int _soundId;
 }
 
+/// A sound being played by the SoundEffectPlayer.
 class SoundEffectStream {
-  SoundEffectStream(
-    this.sound,
-    this.loop,
-    this.volume,
-    this.pitch,
-    this.pan,
-    this.onSoundComplete
-  );
-
-  // TODO: Make these properties work
-  SoundEffect sound;
-  bool playing = false;
-  bool loop = false;
-  double volume = 1.0;
-  double pitch = 1.0;
-  double pan = 0.0;
-
-  // TODO: Implement completion callback. On completion, sounds should
-  // also be removed from the list of playing sounds.
-  SoundEffectStreamCallback onSoundComplete;
+  SoundEffectStream(SoundEffectPlayer player, int streamId, {
+    double leftVolume,
+    double rightVolume,
+    double pitch
+  }) {
+    _player = player;
+    _streamId = streamId;
+    _paused = false;
+    _leftVolume = leftVolume;
+    _rightVolume = rightVolume;
+    _pitch = pitch;
+  }
 
-  MediaPlayerProxy _player;
-}
+  SoundEffectPlayer _player;
+  int _streamId;
 
-SoundEffectPlayer _sharedSoundEffectPlayer;
+  SoundPoolProxy get _soundPool => _player._soundPool;
 
-class SoundEffectPlayer {
+  void stop() {
+    _soundPool.ptr.stop(_streamId);
+  }
 
-  static SoundEffectPlayer sharedInstance() {
-    if (_sharedSoundEffectPlayer == null) {
-      _sharedSoundEffectPlayer = new SoundEffectPlayer();
+  bool get paused => _paused;
+  bool _paused;
+  void set paused(bool value) {
+    _paused = value;
+    if (_paused) {
+      _soundPool.ptr.pause(_streamId);
+    } else {
+      _soundPool.ptr.resume(_streamId);
     }
-    return _sharedSoundEffectPlayer;
   }
 
-  SoundEffectPlayer() {
-    _mediaService = new MediaServiceProxy.unbound();
-    shell.connectToService(null, _mediaService);
+  double get leftVolume => _leftVolume;
+  double _leftVolume;
+  void set leftVolume(double value) {
+    _leftVolume = value;
+    _soundPool.ptr.setVolume(_streamId, <double>[_leftVolume, _rightVolume]);
   }
 
-  MediaServiceProxy _mediaService;
-  List<SoundEffectStream> _soundEffectStreams = <SoundEffectStream>[];
+  double get rightVolume => _rightVolume;
+  double _rightVolume;
+  void set rightVolume(double value) {
+    _rightVolume = value;
+    _soundPool.ptr.setVolume(_streamId, <double>[_leftVolume, _rightVolume]);
+  }
 
-  // TODO: This should no longer be needed when moving to SoundPool backing
-  Map<SoundEffect,MediaPlayerProxy> _mediaPlayers = <SoundEffect, MediaPlayerProxy>{};
+  double get pitch => _pitch;
+  double _pitch;
+  void set pitch(double value) {
+    _pitch = value;
+    _soundPool.ptr.setRate(_streamId, _pitch);
+  }
+}
 
-  Future _prepare(SoundEffectStream playingSound) async {
-    await playingSound._player.ptr.prepare(playingSound.sound._data);
+class SoundEffectPlayer {
+  SoundEffectPlayer(int maxStreams) {
+    MediaServiceProxy mediaService = new MediaServiceProxy.unbound();
+    shell.connectToService(null, mediaService);
+    _soundPool = new SoundPoolProxy.unbound();
+    mediaService.ptr.createSoundPool(_soundPool, maxStreams);
   }
 
-  // TODO: Move sound loading here
-  // TODO: Support loading sounds from bundles
-  // Future<SoundEffect> load(url) async {
-  //   ...
-  // }
+  SoundPoolProxy _soundPool;
+  bool _paused;
+  int _nextStreamId = 0;
 
-  // TODO: Add sound unloader
-  // unload(SoundEffect effect) {
-  //   ...
-  // }
+  Future<SoundEffect> load(MojoDataPipeConsumer data) async {
+    SoundPoolLoadResponseParams result = await _soundPool.ptr.load(data);
+    if (result.success)
+      return new SoundEffect(result.soundId);
 
-  // TODO: Add paused property (should pause playback of all sounds)
-  bool paused;
+    throw new Exception('Unable to load sound');
+  }
 
-  SoundEffectStream play(
-    SoundEffect sound,
-    [bool loop = false,
-      double volume = 1.0,
-      double pitch = 1.0,
-      double pan = 0.0,
-      SoundEffectStreamCallback callback = null]) {
-
-    // Create new PlayingSound object
-    SoundEffectStream playingSound = new SoundEffectStream(
-      sound,
-      loop,
-      volume,
-      pitch,
-      pan,
-      callback
+  Future<SoundEffectStream> play(SoundEffect sound, {
+    double leftVolume: 1.0,
+    double rightVolume: 1.0,
+    bool loop: false,
+    double pitch: 1.0
+  }) async {
+    int streamId = _nextStreamId++;
+    SoundPoolPlayResponseParams result = await _soundPool.ptr.play(
+      sound._soundId, streamId, <double>[leftVolume, rightVolume], loop, pitch
     );
 
-    // TODO: Replace this with calls to SoundPool
-    if (_mediaPlayers[sound] == null) {
-      // Create player
-      playingSound._player = new MediaPlayerProxy.unbound();
-      _mediaService.ptr.createPlayer(playingSound._player);
-
-      // Prepare sound, then play it
-      _prepare(playingSound).then((_) {
-        playingSound._player.ptr.seekTo(0);
-        playingSound._player.ptr.start();
-      });
-
-      _soundEffectStreams.add(playingSound);
-      _mediaPlayers[sound] = playingSound._player;
-    } else {
-      // Reuse player
-      playingSound._player = _mediaPlayers[sound];
-      playingSound._player.ptr.seekTo(0);
-      playingSound._player.ptr.start();
+    if (result.success) {
+      return new SoundEffectStream(this, streamId,
+        leftVolume: leftVolume,
+        rightVolume: rightVolume,
+        pitch: pitch
+      );
     }
 
-    return playingSound;
+    throw new Exception('Unable to play sound');
   }
 
-  void stop(SoundEffectStream stream) {
-    stream._player.ptr.pause();
-    _soundEffectStreams.remove(stream);
-  }
+  bool get paused => _paused;
 
-  void stopAll() {
-    for (SoundEffectStream playingSound in _soundEffectStreams) {
-      playingSound._player.ptr.pause();
+  void set paused(bool value) {
+    _paused = value;
+    if (_paused) {
+      _soundPool.ptr.pauseAll();
+    } else {
+      _soundPool.ptr.resumeAll();
     }
-    _soundEffectStreams = <SoundEffectStream>[];
   }
 }