lib/android/audio.nit

   1 # This file is part of NIT ( http://www.nitlanguage.org ).
   2 #
   3 # Copyright 2014 Romain Chanoir <romain.chanoir@viacesi.fr>
   4 #
   5 # Licensed under the Apache License, Version 2.0 (the "License");
   6 # you may not use this file except in compliance with the License.
   7 # You may obtain a copy of the License at
   8 #
   9 #     http://www.apache.org/licenses/LICENSE-2.0
  10 #
  11 # Unless required by applicable law or agreed to in writing, software
  12 # distributed under the License is distributed on an "AS IS" BASIS,
  13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 # See the License for the specific language governing permissions and
  15 # limitations under the License.
  16
  17 # Android audio services, wraps a part of android audio API
  18 # This module modifies the default behaviour of the audio loading:
  19 # It is first loaded from the `res/raw` folder.
  20 # The file extension is not needed for the `res/raw` loading part.
  21 # If it didn't work, it is loaded from the `assets` folder.
  22 # The file extension is needed for the `assets` loading part.
  23 #
  24 # `assets` contains the portable version of sounds, since the `res` folder exsists only in android projects.
  25 #
  26 # For this example, the sounds "test_sound" and "test_music" are located in the "assets/sounds" folder,
  27 # they both have ".ogg" extension. "test_sound" is a short sound and "test_music" a music track
  28 #
  29 # ~~~nitish
  30 # # Note that you need to specify the path from "assets" folder and the extension
  31 # var s = app.load_sound("sounds/test_sound.ogg")
  32 # var m = app.load_music("sounds/test_music.ogg")
  33 # s.play
  34 # m.play
  35 # ~~~
  36 #
  37 # Now, the sounds are in "res/raw"
  38 # ~~~nitish
  39 # s = app.load_sound_from_res("test_sound")
  40 # m = app.load_music_from_res("test_sound")
  41 # s.play
  42 # m.play
  43 # ~~~
  44 #
  45 # See http://developer.android.com/reference/android/media/package-summary.html for more infos
  46 module audio
  47
  48 import java
  49 import java::io
  50 intrude import assets_and_resources
  51 import activities
  52 import app::audio
  53
  54 in "Java" `{
  55         import android.media.MediaPlayer;
  56         import android.media.SoundPool;
  57         import java.io.IOException;
  58         import android.media.AudioManager;
  59         import android.media.AudioManager.OnAudioFocusChangeListener;
  60         import android.content.Context;
  61         import android.util.Log;
  62 `}
  63
  64 # FIXME: This listener is not working at the moment, but is needed to gain or give up the audio focus
  65 # of the application
  66 in "Java inner" `{
  67         static OnAudioFocusChangeListener afChangeListener = new OnAudioFocusChangeListener() {
  68                 public void onAudioFocusChange(int focusChange) {
  69                         if(focusChange == AudioManager.AUDIOFOCUS_LOSS_TRANSIENT) {
  70                         }else if (focusChange == AudioManager.AUDIOFOCUS_GAIN) {
  71                         }else if (focusChange == AudioManager.AUDIOFOCUS_LOSS) {
  72                         }
  73                 }
  74         };
  75 `}
  76
  77 # AudioManager of the application, used to manage the audio mode
  78 private extern class NativeAudioManager in "Java" `{ android.media.AudioManager `}
  79         super JavaObject
  80
  81         # Current audio mode.
  82         # ( MODE_NORMAL = 0, MODE_RINGTONE = 1, MODE_IN_CALL = 2 or MODE_IN_COMMUNICATION = 3 )
  83         fun mode: Int in "Java" `{ return self.getMode(); `}
  84
  85         # Sets the audio mode.
  86         # ( MODE_NORMAL = 0, MODE_RINGTONE = 1, MODE_IN_CALL = 2 or MODE_IN_COMMUNICATION = 3 )
  87         fun mode=(i: Int) in "Java" `{ self.setMode((int)i); `}
  88
  89         # Sends a request to obtain audio focus
  90         fun request_audio_focus: Int in "Java" `{
  91                 return self.requestAudioFocus(afChangeListener, AudioManager.STREAM_MUSIC, AudioManager.AUDIOFOCUS_GAIN);
  92         `}
  93
  94         # Gives up audio focus
  95         fun abandon_audio_focus: Int in "Java" `{ return self.abandonAudioFocus(afChangeListener); `}
  96 end
  97
  98 # Media Player from Java, used to play long sounds or musics, not simultaneously
  99 # This is a low-level class, use `MediaPlater` instead
 100 private extern class NativeMediaPlayer in "Java" `{ android.media.MediaPlayer `}
 101         super JavaObject
 102
 103         new in "Java" `{
 104                 MediaPlayer mp = new MediaPlayer();
 105                 mp.setAudioStreamType(AudioManager.STREAM_MUSIC);
 106                 return mp;
 107         `}
 108         fun start in "Java" `{ self.start(); `}
 109         fun prepare in "Java" `{
 110                 try {
 111                         self.prepare();
 112                 }catch(Exception e) {
 113                         Log.e("Error preparing the Media Player", e.getMessage());
 114                         e.printStackTrace();
 115                 }
 116         `}
 117
 118         fun create(context: NativeActivity, id: Int): NativeMediaPlayer in "Java" `{
 119                 try {
 120                         return self.create(context, (int)id);
 121                 }catch(Exception e) {
 122                         return null;
 123                 }
 124         `}
 125
 126         fun pause in "Java" `{ self.pause(); `}
 127         fun stop in "Java" `{ self.stop(); `}
 128         fun playing: Bool in "Java" `{ return self.isPlaying(); `}
 129         fun release in "Java" `{ self.release(); `}
 130         fun duration: Int in "Java" `{ return self.getDuration(); `}
 131         fun looping: Bool in "Java" `{ return self.isLooping(); `}
 132         fun looping=(b: Bool) in "Java" `{ self.setLooping(b); `}
 133         fun volume=(vol: Float) in "Java" `{ self.setVolume((float)vol, (float)vol); `}
 134         fun both_volume(left_volume, right_volume: Float) in "Java" `{ self.setVolume((float)left_volume, (float)right_volume); `}
 135         fun stream_type=(stream_type: Int) in "Java" `{ self.setAudioStreamType((int)stream_type); `}
 136         fun data_source_fd(fd: NativeFileDescriptor, start_offset, length: Int): Int in "Java"  `{
 137                 try {
 138                         self.setDataSource(fd, start_offset, length);
 139                         return 1;
 140                 }catch(Exception e) {
 141                         return 0;
 142                 }
 143         `}
 144         fun data_source_path(path: JavaString): Int in "Java" `{
 145                 try {
 146                         self.setDataSource(path);
 147                         return 1;
 148                 }catch(Exception e) {
 149                         Log.e("Error loading the Media Player", e.getMessage());
 150                         return 0;
 151                 }
 152         `}
 153         fun reset in "Java" `{ self.reset(); `}
 154 end
 155
 156 # Sound Pool from Java, used to play sounds simultaneously
 157 # This is a low-level class, use `SoundPool`instead
 158 private extern class NativeSoundPool in "Java" `{ android.media.SoundPool `}
 159         super JavaObject
 160
 161         new(max_streams, stream_type, src_quality: Int) in "Java" `{
 162                 return new SoundPool((int)max_streams, (int)stream_type, (int)src_quality);
 163         `}
 164         fun load_asset_fd(afd: NativeAssetFileDescriptor, priority: Int): Int in "Java" `{
 165                 try {
 166                         int id =  self.load(afd, (int)priority);
 167                         return id;
 168                 }catch(Exception e){
 169                         return -1;
 170                 }
 171         `}
 172
 173         fun load_id(context: NativeActivity, resid, priority: Int): Int in "Java" `{
 174                 try {
 175                         int id =  self.load(context, (int)resid, (int)priority);
 176                         return id;
 177                 }catch(Exception e){
 178                         return -1;
 179                 }
 180         `}
 181
 182         fun load_path(path: JavaString, priority: Int): Int in "Java" `{
 183                 try {
 184                         int id =  self.load(path, (int)priority);
 185                         return id;
 186                 }catch(Exception e){
 187                         return -1;
 188                 }
 189         `}
 190
 191         fun play(sound_id: Int, left_volume, right_volume: Float, priority, l: Int, rate: Float): Int in "Java" `{
 192                 return self.play((int)sound_id, (float)left_volume, (float)right_volume, (int)priority, (int)l, (float)rate);
 193         `}
 194         fun pause(stream_id: Int) in "Java" `{ self.pause((int)stream_id); `}
 195         fun auto_pause in "Java" `{ self.autoPause(); `}
 196         fun auto_resume in "Java" `{ self.autoResume(); `}
 197         fun resume(stream_id: Int) in "Java" `{ self.resume((int)stream_id); `}
 198         fun set_loop(stream_id, l: Int) in "Java" `{ self.setLoop((int)stream_id, (int)l); `}
 199         fun set_priority(stream_id, priority: Int) in "Java" `{ self.setPriority((int)stream_id, (int)priority); `}
 200         fun set_rate(stream_id: Int, rate: Float) in "Java" `{ self.setRate((int)stream_id, (float)rate); `}
 201         fun set_volume(stream_id: Int, left_volume, right_volume: Float) in "Java" `{ self.setVolume((int)stream_id, (float)left_volume, (float)right_volume); `}
 202         fun stop(stream_id: Int) in "Java" `{ self.stop((int)stream_id); `}
 203         fun unload(sound_id: Int): Bool in "Java" `{ return self.unload((int)sound_id); `}
 204         fun release in "Java" `{ self.release(); `}
 205 end
 206
 207
 208 # Used to play sound, best suited for sounds effects in apps or games
 209 class SoundPool
 210
 211         # Latest error on this sound pool
 212         var error: nullable Error = null
 213
 214         private var nsoundpool: NativeSoundPool is noinit
 215
 216         # The maximum number of simultaneous streams for this SoundPool
 217         var max_streams = 10 is writable
 218
 219         # The audio stream type, 3 is STREAM_MUSIC, default for game application
 220         var stream_type = 3 is writable
 221
 222         # The sample-rate converter quality, currently has no effect
 223         var src_quality = 0 is writable
 224
 225         # Left volume value, range 0.0 to 1.0
 226         var left_volume = 1.0 is writable
 227
 228         # Right volume value, range 0.0 to 1.0
 229         var right_volume = 1.0 is writable
 230
 231         # Playback rate, 1.0 = normal playback, range 0.5 to 2.0
 232         var rate = 1.0 is writable
 233
 234         # Loop mode, 0 = no loop, -1 = loop forever
 235         var looping = 0 is writable
 236
 237         # Stream priority
 238         private var priority = 1
 239
 240         init do self.nsoundpool = new NativeSoundPool(max_streams, stream_type, src_quality)
 241
 242         # Load the sound from an asset file descriptor
 243         # this function is for advanced use
 244         private fun load_asset_fd(afd: NativeAssetFileDescriptor): Sound do
 245                 var resval = nsoundpool.load_asset_fd(afd, self.priority)
 246                 if  resval == -1 then
 247                         self.error = new Error("Unable to load sound from assets")
 248                         return new Sound.priv_init(null, -1, self, self.error)
 249                 else
 250                         return new Sound.priv_init(null, resval, self, null)
 251                 end
 252         end
 253
 254         # Returns only the id corresponding to the soundpool where the sound is loaded.
 255         # Needed by `load` of `Sound`.
 256         private fun load_asset_fd_rid(afd: NativeAssetFileDescriptor): Int do
 257                 return nsoundpool.load_asset_fd(afd, self.priority)
 258         end
 259
 260         # Load the sound from its resource id
 261         fun load_id(context: NativeActivity, id:Int): Sound do
 262                 var resval = nsoundpool.load_id(context, id, priority)
 263                         if  resval == -1 then
 264                         self.error = new Error("Unable to load sound from assets")
 265                         return new Sound.priv_init(null, -1, self, self.error)
 266                 else
 267                         return new Sound.priv_init(null, resval, self, null)
 268                 end
 269         end
 270
 271         # Returns only the id corresponding to the soundpool where the sound is loaded.
 272         private fun load_id_rid(context: NativeActivity, id: Int): Int do
 273                 return nsoundpool.load_id(context, id, priority)
 274         end
 275
 276         # Load the sound from the specified path
 277         fun load_path(path: String): Sound do
 278                 sys.jni_env.push_local_frame(1)
 279                 var resval = nsoundpool.load_path(path.to_java_string, priority)
 280                 sys.jni_env.pop_local_frame
 281                 if  resval == -1 then
 282                         self.error = new Error("Unable to load sound from path : " + path)
 283                         return new Sound.priv_init(null, -1, self, self.error)
 284                 else
 285                         return new Sound.priv_init(null, resval, self, null)
 286                 end
 287         end
 288
 289         # Play a sound from a sound ID
 290         # return non-zero streamID if successful, zero if failed
 291         fun play(id: Int): Int do
 292                 return nsoundpool.play(id, left_volume, right_volume, priority, looping, rate)
 293         end
 294
 295         # Load a sound by its name in the resources, the sound must be in the `res/raw` folder
 296         fun load_name(resource_manager: ResourcesManager, context: NativeActivity, sound: String): Sound do
 297                 var id = resource_manager.raw_id(sound)
 298                 var resval = nsoundpool.load_id(context, id, priority)
 299                 if  resval == -1 then
 300                         self.error = new Error("Unable to load sound from resources : " + sound)
 301                         return new Sound.priv_init(null, -1, self, self.error)
 302                 else
 303                         return new Sound.priv_init(null, resval, self, null)
 304                 end
 305         end
 306
 307         # Returns only the id corresponding to the soundpool where the sound is loaded.
 308         private fun load_name_rid(resource_manager: ResourcesManager, context: NativeActivity, sound: String): Int do
 309                 var id = resource_manager.raw_id(sound)
 310                 return nsoundpool.load_id(context, id, priority)
 311         end
 312
 313         # Pause a playback stream
 314         fun pause_stream(stream_id: Int) do nsoundpool.pause(stream_id)
 315
 316         # Pause all active_streams
 317         fun auto_pause do nsoundpool.auto_pause
 318
 319         # Resume all previously active streams
 320         fun auto_resume do nsoundpool.auto_resume
 321
 322         # Resume a playback stream
 323         fun resume(stream_id: Int) do nsoundpool.resume(stream_id)
 324
 325         # Set loop mode on a stream
 326         fun stream_loop=(stream_id, looping: Int) do nsoundpool.set_loop(stream_id, looping)
 327
 328         # Change stream priority
 329         fun stream_priority=(stream_id, priority: Int) do nsoundpool.set_priority(stream_id, priority)
 330
 331         # Change playback rate
 332         fun stream_rate=(stream_id: Int, rate: Float) do nsoundpool.set_rate(stream_id, rate)
 333
 334         # Set stream volume
 335         fun stream_volume(stream_id: Int, left_volume, right_volume: Float) do
 336                 nsoundpool.set_volume(stream_id, left_volume, right_volume)
 337         end
 338
 339         # Stop a playback stream
 340         fun stop_stream(stream_id: Int) do nsoundpool.stop(stream_id)
 341
 342         # Unload a sound from a sound ID
 343         fun unload(sound: Sound): Bool do return nsoundpool.unload(sound.soundpool_id)
 344
 345         # Destroys the object
 346         fun destroy do nsoundpool.release
 347 end
 348
 349 # Used to play sounds, designed to use with medium sized sounds or streams
 350 # The Android MediaPlayer has a complex state diagram that you'll need to
 351 # respect if you want your MediaPlayer to work fine, see the android doc
 352 class MediaPlayer
 353         private var nmedia_player: NativeMediaPlayer is noinit
 354
 355         # Used to control the state of the mediaplayer
 356         private var is_prepared = false is writable
 357
 358         # The sound associated with this mediaplayer
 359         var sound: nullable Music = null is writable
 360
 361         # Error gestion
 362         var error: nullable Error = null
 363
 364         # Create a new MediaPlayer, but no sound is attached, you'll need
 365         # to use `load_sound` before using it
 366         init do self.nmedia_player = new NativeMediaPlayer
 367
 368         # Init the mediaplayer with a sound resource id
 369         init from_id(context: NativeActivity, id: Int) do
 370                 self.nmedia_player = new NativeMediaPlayer
 371                 self.nmedia_player = nmedia_player.create(context, id)
 372                 if self.nmedia_player.is_java_null then
 373                         self.error = new Error("Failed to create the MediaPlayer")
 374                         self.sound = new Music.priv_init(id, self, self.error)
 375                 end
 376                 self.sound = new Music.priv_init(id, self, null)
 377         end
 378
 379         # Load a sound for a given resource id
 380         fun load_sound(id: Int, context: NativeActivity): Music do
 381                 # FIXME: maybe find a better way to handle this situation
 382                 # If two different music are loaded with the same `MediaPlayer`,
 383                 # a new `NativeMediaPlayer` will be created for the secondd music
 384                 # and the nit program will loose the handle to the previous one
 385                 # If the previous music is playing, we need to stop it
 386                 if playing then
 387                         stop
 388                         reset
 389                         destroy
 390                 end
 391                 self.nmedia_player = self.nmedia_player.create(context, id)
 392                 if self.nmedia_player.is_java_null then
 393                         self.error = new Error("Failed to load a sound")
 394                         self.sound = new Music.priv_init(id, self, new Error("Sound loading failed"))
 395                         return self.sound.as(not null)
 396                 else
 397                         if self.error != null then self.error = null
 398                         self.sound = new Music.priv_init(id, self, null)
 399                         self.is_prepared = true
 400                         return self.sound.as(not null)
 401                 end
 402         end
 403
 404         # Starts or resumes playback
 405         # REQUIRE `self.sound != null`
 406         fun start do
 407                 if self.error != null then return
 408                 if not is_prepared then prepare
 409                 nmedia_player.start
 410         end
 411
 412         # Stops playback after playback has been stopped or paused
 413         # REQUIRE `self.sound != null`
 414         fun stop do
 415                 if self.error != null then return
 416                 is_prepared = false
 417                 nmedia_player.stop
 418         end
 419
 420         # Prepares the player for playback, synchronously
 421         # REQUIRE `self.sound != null`
 422         fun prepare do
 423                 if self.error != null then return
 424                 assert sound != null
 425                 nmedia_player.prepare
 426                 is_prepared = true
 427         end
 428
 429         # Pauses playback
 430         # REQUIRE `self.sound != null`
 431         fun pause do
 432                 if self.error != null then return
 433                 assert sound != null
 434                 nmedia_player.pause
 435         end
 436
 437         # Checks whether the mediaplayer is playing
 438         fun playing: Bool do return nmedia_player.playing
 439
 440         # Releases the resources associated with this MediaPlayer
 441         fun destroy do
 442                 nmedia_player.release
 443                 self.sound = null
 444         end
 445
 446         # Reset MediaPlayer to its initial state
 447         fun reset do nmedia_player.reset
 448
 449         # Sets the datasource (file-path or http/rtsp URL) to use
 450         fun data_source(path: String): Music do
 451                 sys.jni_env.push_local_frame(1)
 452                 var retval = nmedia_player.data_source_path(path.to_java_string)
 453                 sys.jni_env.pop_local_frame
 454                 if retval == 0 then
 455                         self.error = new Error("could not load the sound " + path)
 456                         self.sound = new Music.priv_init(null, self, self.error)
 457
 458                 else
 459                         self.sound = new Music.priv_init(null, self, null)
 460                 end
 461                 return self.sound.as(not null)
 462         end
 463         # Sets the data source (NativeFileDescriptor) to use
 464         fun data_source_fd(fd: NativeAssetFileDescriptor): Music do
 465                 if not fd.is_java_null then
 466                         if nmedia_player.data_source_fd(fd.file_descriptor, fd.start_offset, fd.length) == 0 then
 467                                 self.error = new Error("could not load the sound")
 468                                 self.sound = new Music.priv_init(null, self, self.error)
 469                         else
 470                                 self.sound = new Music.priv_init(null, self, null)
 471                         end
 472                         return self.sound.as(not null)
 473                 else
 474                         var error = new Error("could not load the sound")
 475                         return new Music.priv_init(null, self, error)
 476                 end
 477         end
 478
 479         # Checks whether the MediaPlayer is looping or non-looping
 480         fun looping: Bool do return nmedia_player.looping
 481
 482         # Sets the player to be looping or non-looping
 483         fun looping=(b: Bool) do nmedia_player.looping = b
 484
 485         # Sets the volume on this player
 486         fun volume=(volume: Float) do nmedia_player.volume = volume
 487
 488         # Sets the left volume and the right volume of this player
 489         fun both_volume(left_volume, right_volume: Float) do nmedia_player.both_volume(left_volume, right_volume)
 490
 491         # Sets the audio stream type for this media player
 492         fun stream_type=(stream_type: Int) do nmedia_player.stream_type = stream_type
 493 end
 494
 495 redef class PlayableAudio
 496         # Flag to know if the user paused the sound
 497         # Used when the app pause all sounds or resume all sounds
 498         var paused: Bool = false
 499
 500         redef init do add_to_sounds(self)
 501 end
 502
 503 redef class Sound
 504
 505         # Resource ID of this sound
 506         var id: nullable Int is noinit
 507
 508         # The SoundPool who loaded this sound
 509         var soundpool: SoundPool is noinit
 510
 511         # The SoundID of this sound in his SoundPool
 512         var soundpool_id: Int is noinit
 513
 514         private init priv_init(id: nullable Int, soundpool_id: Int, soundpool: SoundPool, error: nullable Error) is nosuper do
 515                 self.id = id
 516                 self.soundpool_id = soundpool_id
 517                 self.soundpool = soundpool
 518                 if error != null then
 519                         self.error = error
 520                 else
 521                         self.is_loaded = true
 522                 end
 523         end
 524
 525         redef fun load do
 526                 if is_loaded then return
 527                 var retval_resources = app.default_soundpool.load_name_rid(app.resource_manager, app.native_activity, self.name.strip_extension)
 528                 if retval_resources == -1 then
 529                         self.error = new Error("failed to load" + self.name)
 530                         var nam = app.asset_manager.open_fd(self.name)
 531                         if nam.is_java_null then
 532                                 self.error = new Error("Failed to get file descriptor for " + self.name)
 533                         else
 534                                 var retval_assets = app.default_soundpool.load_asset_fd_rid(nam)
 535                                 if retval_assets == -1 then
 536                                         self.error = new Error("Failed to load" + self.name)
 537                                 else
 538                                         self.soundpool_id = retval_assets
 539                                         self.soundpool = app.default_soundpool
 540                                         self.error = null
 541                                         self.soundpool.error = null
 542                                 end
 543                         end
 544                 else
 545                         self.soundpool_id = retval_resources
 546                         self.soundpool = app.default_soundpool
 547                         self.error = null
 548                         self.soundpool.error = null
 549                 end
 550                 is_loaded = true
 551         end
 552
 553         redef fun play do
 554                 if not is_loaded then load
 555                 if self.error != null then return
 556                 soundpool.play(soundpool_id)
 557         end
 558
 559         redef fun pause do
 560                 if self.error != null or not self.is_loaded then return
 561                 soundpool.pause_stream(soundpool_id)
 562                 paused = true
 563         end
 564
 565         redef fun resume do
 566                 if self.error != null or not self.is_loaded then return
 567                 soundpool.resume(soundpool_id)
 568                 paused = false
 569         end
 570
 571 end
 572
 573 redef class Music
 574
 575         # Resource ID of this sound
 576         var id: nullable Int is noinit
 577
 578         # The MediaPlayer who loaded this sound
 579         var media_player: MediaPlayer is noinit
 580
 581         private init priv_init(id: nullable Int, media_player: MediaPlayer, error: nullable Error) is nosuper do
 582                 self.id = id
 583                 self.media_player = media_player
 584                 if error != null then
 585                         self.error = error
 586                 else
 587                         self.is_loaded = true
 588                 end
 589         end
 590
 591         redef fun load do
 592                 if is_loaded then return
 593                 var mp_sound_resources = app.default_mediaplayer.load_sound(app.resource_manager.raw_id(self.name.strip_extension), app.native_activity)
 594                 if mp_sound_resources.error != null then
 595                         self.error = mp_sound_resources.error
 596                         var nam = app.asset_manager.open_fd(self.name)
 597                         if nam.is_java_null then
 598                                 self.error = new Error("Failed to get file descriptor for " + self.name)
 599                         else
 600                                 var mp_sound_assets = app.default_mediaplayer.data_source_fd(nam)
 601                                 if mp_sound_assets.error != null then
 602                                         self.error = mp_sound_assets.error
 603                                 else
 604                                         self.media_player = app.default_mediaplayer
 605                                         self.error = null
 606                                         self.media_player.error = null
 607                                 end
 608                         end
 609                 else
 610                         self.media_player = app.default_mediaplayer
 611                         self.error = null
 612                         self.media_player.error = null
 613                 end
 614                 is_loaded = true
 615         end
 616
 617         redef fun play do
 618                 if not is_loaded then load
 619                 if self.error != null then return
 620                 media_player.start
 621         end
 622
 623         redef fun pause do
 624                 if self.error != null or not self.is_loaded then return
 625                 media_player.pause
 626                 paused = true
 627         end
 628
 629         redef fun resume do
 630                 if self.error != null or not self.is_loaded then return
 631                 play
 632                 paused = false
 633         end
 634 end
 635
 636 redef class App
 637
 638
 639         # Returns the default MediaPlayer of the application.
 640         # When you load a music, it goes in this MediaPlayer.
 641         # Use it for advanced sound management
 642         var default_mediaplayer: MediaPlayer is lazy do return new MediaPlayer
 643
 644         # Returns the default MediaPlayer of the application.
 645         # When you load a short sound (not a music), it's added to this soundpool.
 646         # Use it for advanced sound management.
 647         var default_soundpool: SoundPool is lazy do return new SoundPool
 648
 649         # Get the native audio manager
 650         private fun audio_manager: NativeAudioManager import native_activity in "Java" `{
 651                 return (AudioManager)App_native_activity(self).getSystemService(Context.AUDIO_SERVICE);
 652         `}
 653
 654         # Sets the stream of the app to STREAM_MUSIC.
 655         # STREAM_MUSIC is the default stream used by android apps.
 656         private fun manage_audio_stream import native_activity in "Java" `{
 657                 App_native_activity(self).setVolumeControlStream(AudioManager.STREAM_MUSIC);
 658         `}
 659
 660         # Retrieves a sound with a soundpool in the `assets` folder using its name.
 661         # Used to play short songs, can play multiple sounds simultaneously
 662         redef fun load_sound(path) do
 663                 var fd = asset_manager.open_fd(path)
 664                 if not fd.is_java_null then
 665                         return add_to_sounds(default_soundpool.load_asset_fd(fd)).as(Sound)
 666                 else
 667                         var error = new Error("Failed to load Sound {path}")
 668                         return new Sound.priv_init(null, -1, default_soundpool, error)
 669                 end
 670         end
 671
 672         # Retrieves a music with a media player in the `assets` folder using its name.
 673         # Used to play long sounds or musics, can't play multiple sounds simultaneously
 674         redef fun load_music(path) do
 675                 var fd = asset_manager.open_fd(path)
 676                 if not fd.is_java_null then
 677                         return add_to_sounds(default_mediaplayer.data_source_fd(fd)).as(Music)
 678                 else
 679                         var error = new Error("Failed to load music {path}")
 680                         return new Music.priv_init(null, default_mediaplayer, error)
 681                 end
 682         end
 683
 684         # Same as `load_sound` but load the sound from the `res/raw` folder
 685         fun load_sound_from_res(sound_name: String): Sound do
 686                 return add_to_sounds(default_soundpool.load_name(resource_manager,self.native_activity, sound_name)).as(Sound)
 687         end
 688
 689         # Same as `load_music` but load the sound from the `res/raw` folder
 690         fun load_music_from_res(music: String): Music do
 691                 return add_to_sounds(default_mediaplayer.load_sound(resource_manager.raw_id(music), self.native_activity)).as(Music)
 692         end
 693
 694         redef fun on_pause do
 695                 super
 696                 for s in sounds do
 697                         # Pausing sounds that are not already paused by user
 698                         # `s.paused` is set to false because `pause` set it to true
 699                         # and we want to know which sound has been paused by the user
 700                         # and which one has been paused by the app
 701                         if not s.paused then
 702                                 s.pause
 703                                 s.paused = false
 704                         end
 705                 end
 706                 audio_manager.abandon_audio_focus
 707         end
 708
 709         redef fun on_create do
 710                 super
 711                 audio_manager.request_audio_focus
 712                 manage_audio_stream
 713         end
 714
 715         redef fun on_resume do
 716                 super
 717                 audio_manager.request_audio_focus
 718                 for s in sounds do
 719                         # Resumes only the sounds paused by the App
 720                         if not s.paused then s.resume
 721                 end
 722         end
 723 end
 724
 725 redef class Sys
 726
 727         # Sounds handled by the application, when you load a sound, it's added to this list.
 728         # This array is used in `pause` and `resume`
 729         private var sounds = new Array[PlayableAudio]
 730
 731         # Factorizes `sounds.add` to use it in `load_music`, `load_sound`, `load_music_from_res` and `load_sound_from_res`
 732         private fun add_to_sounds(sound: PlayableAudio): PlayableAudio do
 733                 sounds.add(sound)
 734                 return sound
 735         end
 736 end