android/media/SoundPool.java

/*
 * Copyright (C) 2007 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package android.media;

import java.io.File;
import java.io.FileDescriptor;
import java.lang.ref.WeakReference;

import android.app.ActivityThread;
import android.app.AppOpsManager;
import android.content.Context;
import android.content.res.AssetFileDescriptor;
import android.os.Handler;
import android.os.IBinder;
import android.os.Looper;
import android.os.Message;
import android.os.ParcelFileDescriptor;
import android.os.Process;
import android.os.RemoteException;
import android.os.ServiceManager;
import android.os.SystemProperties;
import android.util.AndroidRuntimeException;
import android.util.Log;

import com.android.internal.app.IAppOpsService;


/**
 * The SoundPool class manages and plays audio resources for applications.
 *
 * <p>A SoundPool is a collection of samples that can be loaded into memory
 * from a resource inside the APK or from a file in the file system. The
 * SoundPool library uses the MediaPlayer service to decode the audio
 * into a raw 16-bit PCM mono or stereo stream. This allows applications
 * to ship with compressed streams without having to suffer the CPU load
 * and latency of decompressing during playback.</p>
 *
 * <p>In addition to low-latency playback, SoundPool can also manage the number
 * of audio streams being rendered at once. When the SoundPool object is
 * constructed, the maxStreams parameter sets the maximum number of streams
 * that can be played at a time from this single SoundPool. SoundPool tracks
 * the number of active streams. If the maximum number of streams is exceeded,
 * SoundPool will automatically stop a previously playing stream based first
 * on priority and then by age within that priority. Limiting the maximum
 * number of streams helps to cap CPU loading and reducing the likelihood that
 * audio mixing will impact visuals or UI performance.</p>
 *
 * <p>Sounds can be looped by setting a non-zero loop value. A value of -1
 * causes the sound to loop forever. In this case, the application must
 * explicitly call the stop() function to stop the sound. Any other non-zero
 * value will cause the sound to repeat the specified number of times, e.g.
 * a value of 3 causes the sound to play a total of 4 times.</p>
 *
 * <p>The playback rate can also be changed. A playback rate of 1.0 causes
 * the sound to play at its original frequency (resampled, if necessary,
 * to the hardware output frequency). A playback rate of 2.0 causes the
 * sound to play at twice its original frequency, and a playback rate of
 * 0.5 causes it to play at half its original frequency. The playback
 * rate range is 0.5 to 2.0.</p>
 *
 * <p>Priority runs low to high, i.e. higher numbers are higher priority.
 * Priority is used when a call to play() would cause the number of active
 * streams to exceed the value established by the maxStreams parameter when
 * the SoundPool was created. In this case, the stream allocator will stop
 * the lowest priority stream. If there are multiple streams with the same
 * low priority, it will choose the oldest stream to stop. In the case
 * where the priority of the new stream is lower than all the active
 * streams, the new sound will not play and the play() function will return
 * a streamID of zero.</p>
 *
 * <p>Let's examine a typical use case: A game consists of several levels of
 * play. For each level, there is a set of unique sounds that are used only
 * by that level. In this case, the game logic should create a new SoundPool
 * object when the first level is loaded. The level data itself might contain
 * the list of sounds to be used by this level. The loading logic iterates
 * through the list of sounds calling the appropriate SoundPool.load()
 * function. This should typically be done early in the process to allow time
 * for decompressing the audio to raw PCM format before they are needed for
 * playback.</p>
 *
 * <p>Once the sounds are loaded and play has started, the application can
 * trigger sounds by calling SoundPool.play(). Playing streams can be
 * paused or resumed, and the application can also alter the pitch by
 * adjusting the playback rate in real-time for doppler or synthesis
 * effects.</p>
 *
 * <p>Note that since streams can be stopped due to resource constraints, the
 * streamID is a reference to a particular instance of a stream. If the stream
 * is stopped to allow a higher priority stream to play, the stream is no
 * longer be valid. However, the application is allowed to call methods on
 * the streamID without error. This may help simplify program logic since
 * the application need not concern itself with the stream lifecycle.</p>
 *
 * <p>In our example, when the player has completed the level, the game
 * logic should call SoundPool.release() to release all the native resources
 * in use and then set the SoundPool reference to null. If the player starts
 * another level, a new SoundPool is created, sounds are loaded, and play
 * resumes.</p>
 */
public class SoundPool {
    private final SoundPoolDelegate mImpl;

    /**
     * Constructor. Constructs a SoundPool object with the following
     * characteristics:
     *
     * @param maxStreams the maximum number of simultaneous streams for this
     *                   SoundPool object
     * @param streamType the audio stream type as described in AudioManager
     *                   For example, game applications will normally use
     *                   {@link AudioManager#STREAM_MUSIC}.
     * @param srcQuality the sample-rate converter quality. Currently has no
     *                   effect. Use 0 for the default.
     * @return a SoundPool object, or null if creation failed
     * @deprecated use {@link SoundPool.Builder} instead to create and configure a
     *     SoundPool instance
     */
    public SoundPool(int maxStreams, int streamType, int srcQuality) {
        this(maxStreams,
                new AudioAttributes.Builder().setInternalLegacyStreamType(streamType).build());
    }

    private SoundPool(int maxStreams, AudioAttributes attributes) {
        if (SystemProperties.getBoolean("config.disable_media", false)) {
            mImpl = new SoundPoolStub();
        } else {
            mImpl = new SoundPoolImpl(this, maxStreams, attributes);
        }
    }

    /**
     * Builder class for {@link SoundPool} objects.
     */
    public static class Builder {
        private int mMaxStreams = 1;
        private AudioAttributes mAudioAttributes;

        /**
         * Constructs a new Builder with the defaults format values.
         * If not provided, the maximum number of streams is 1 (see {@link #setMaxStreams(int)} to
         * change it), and the audio attributes have a usage value of
         * {@link AudioAttributes#USAGE_MEDIA} (see {@link #setAudioAttributes(AudioAttributes)} to
         * change them).
         */
        public Builder() {
        }

        /**
         * Sets the maximum of number of simultaneous streams that can be played simultaneously.
         * @param maxStreams a value equal to 1 or greater.
         * @return the same Builder instance
         * @throws IllegalArgumentException
         */
        public Builder setMaxStreams(int maxStreams) throws IllegalArgumentException {
            if (maxStreams <= 0) {
                throw new IllegalArgumentException(
                        "Strictly positive value required for the maximum number of streams");
            }
            mMaxStreams = maxStreams;
            return this;
        }

        /**
         * Sets the {@link AudioAttributes}. For examples, game applications will use attributes
         * built with usage information set to {@link AudioAttributes#USAGE_GAME}.
         * @param attributes a non-null
         * @return
         */
        public Builder setAudioAttributes(AudioAttributes attributes)
                throws IllegalArgumentException {
            if (attributes == null) {
                throw new IllegalArgumentException("Invalid null AudioAttributes");
            }
            mAudioAttributes = attributes;
            return this;
        }

        public SoundPool build() {
            if (mAudioAttributes == null) {
                mAudioAttributes = new AudioAttributes.Builder()
                        .setUsage(AudioAttributes.USAGE_MEDIA).build();
            }
            return new SoundPool(mMaxStreams, mAudioAttributes);
        }
    }

    /**
     * Load the sound from the specified path.
     *
     * @param path the path to the audio file
     * @param priority the priority of the sound. Currently has no effect. Use
     *                 a value of 1 for future compatibility.
     * @return a sound ID. This value can be used to play or unload the sound.
     */
    public int load(String path, int priority) {
        return mImpl.load(path, priority);
    }

    /**
     * Load the sound from the specified APK resource.
     *
     * Note that the extension is dropped. For example, if you want to load
     * a sound from the raw resource file "explosion.mp3", you would specify
     * "R.raw.explosion" as the resource ID. Note that this means you cannot
     * have both an "explosion.wav" and an "explosion.mp3" in the res/raw
     * directory.
     *
     * @param context the application context
     * @param resId the resource ID
     * @param priority the priority of the sound. Currently has no effect. Use
     *                 a value of 1 for future compatibility.
     * @return a sound ID. This value can be used to play or unload the sound.
     */
    public int load(Context context, int resId, int priority) {
        return mImpl.load(context, resId, priority);
    }

    /**
     * Load the sound from an asset file descriptor.
     *
     * @param afd an asset file descriptor
     * @param priority the priority of the sound. Currently has no effect. Use
     *                 a value of 1 for future compatibility.
     * @return a sound ID. This value can be used to play or unload the sound.
     */
    public int load(AssetFileDescriptor afd, int priority) {
        return mImpl.load(afd, priority);
    }

    /**
     * Load the sound from a FileDescriptor.
     *
     * This version is useful if you store multiple sounds in a single
     * binary. The offset specifies the offset from the start of the file
     * and the length specifies the length of the sound within the file.
     *
     * @param fd a FileDescriptor object
     * @param offset offset to the start of the sound
     * @param length length of the sound
     * @param priority the priority of the sound. Currently has no effect. Use
     *                 a value of 1 for future compatibility.
     * @return a sound ID. This value can be used to play or unload the sound.
     */
    public int load(FileDescriptor fd, long offset, long length, int priority) {
        return mImpl.load(fd, offset, length, priority);
    }

    /**
     * Unload a sound from a sound ID.
     *
     * Unloads the sound specified by the soundID. This is the value
     * returned by the load() function. Returns true if the sound is
     * successfully unloaded, false if the sound was already unloaded.
     *
     * @param soundID a soundID returned by the load() function
     * @return true if just unloaded, false if previously unloaded
     */
    public final boolean unload(int soundID) {
        return mImpl.unload(soundID);
    }

    /**
     * Play a sound from a sound ID.
     *
     * Play the sound specified by the soundID. This is the value
     * returned by the load() function. Returns a non-zero streamID
     * if successful, zero if it fails. The streamID can be used to
     * further control playback. Note that calling play() may cause
     * another sound to stop playing if the maximum number of active
     * streams is exceeded. A loop value of -1 means loop forever,
     * a value of 0 means don't loop, other values indicate the
     * number of repeats, e.g. a value of 1 plays the audio twice.
     * The playback rate allows the application to vary the playback
     * rate (pitch) of the sound. A value of 1.0 means play back at
     * the original frequency. A value of 2.0 means play back twice
     * as fast, and a value of 0.5 means playback at half speed.
     *
     * @param soundID a soundID returned by the load() function
     * @param leftVolume left volume value (range = 0.0 to 1.0)
     * @param rightVolume right volume value (range = 0.0 to 1.0)
     * @param priority stream priority (0 = lowest priority)
     * @param loop loop mode (0 = no loop, -1 = loop forever)
     * @param rate playback rate (1.0 = normal playback, range 0.5 to 2.0)
     * @return non-zero streamID if successful, zero if failed
     */
    public final int play(int soundID, float leftVolume, float rightVolume,
            int priority, int loop, float rate) {
        return mImpl.play(
            soundID, leftVolume, rightVolume, priority, loop, rate);
    }

    /**
     * Pause a playback stream.
     *
     * Pause the stream specified by the streamID. This is the
     * value returned by the play() function. If the stream is
     * playing, it will be paused. If the stream is not playing
     * (e.g. is stopped or was previously paused), calling this
     * function will have no effect.
     *
     * @param streamID a streamID returned by the play() function
     */
    public final void pause(int streamID) {
        mImpl.pause(streamID);
    }

    /**
     * Resume a playback stream.
     *
     * Resume the stream specified by the streamID. This
     * is the value returned by the play() function. If the stream
     * is paused, this will resume playback. If the stream was not
     * previously paused, calling this function will have no effect.
     *
     * @param streamID a streamID returned by the play() function
     */
    public final void resume(int streamID) {
        mImpl.resume(streamID);
    }

    /**
     * Pause all active streams.
     *
     * Pause all streams that are currently playing. This function
     * iterates through all the active streams and pauses any that
     * are playing. It also sets a flag so that any streams that
     * are playing can be resumed by calling autoResume().
     */
    public final void autoPause() {
        mImpl.autoPause();
    }

    /**
     * Resume all previously active streams.
     *
     * Automatically resumes all streams that were paused in previous
     * calls to autoPause().
     */
    public final void autoResume() {
        mImpl.autoResume();
    }

    /**
     * Stop a playback stream.
     *
     * Stop the stream specified by the streamID. This
     * is the value returned by the play() function. If the stream
     * is playing, it will be stopped. It also releases any native
     * resources associated with this stream. If the stream is not
     * playing, it will have no effect.
     *
     * @param streamID a streamID returned by the play() function
     */
    public final void stop(int streamID) {
        mImpl.stop(streamID);
    }

    /**
     * Set stream volume.
     *
     * Sets the volume on the stream specified by the streamID.
     * This is the value returned by the play() function. The
     * value must be in the range of 0.0 to 1.0. If the stream does
     * not exist, it will have no effect.
     *
     * @param streamID a streamID returned by the play() function
     * @param leftVolume left volume value (range = 0.0 to 1.0)
     * @param rightVolume right volume value (range = 0.0 to 1.0)
     */
    public final void setVolume(int streamID,
            float leftVolume, float rightVolume) {
        mImpl.setVolume(streamID, leftVolume, rightVolume);
    }

    /**
     * Similar, except set volume of all channels to same value.
     * @hide
     */
    public void setVolume(int streamID, float volume) {
        setVolume(streamID, volume, volume);
    }

    /**
     * Change stream priority.
     *
     * Change the priority of the stream specified by the streamID.
     * This is the value returned by the play() function. Affects the
     * order in which streams are re-used to play new sounds. If the
     * stream does not exist, it will have no effect.
     *
     * @param streamID a streamID returned by the play() function
     */
    public final void setPriority(int streamID, int priority) {
        mImpl.setPriority(streamID, priority);
    }

    /**
     * Set loop mode.
     *
     * Change the loop mode. A loop value of -1 means loop forever,
     * a value of 0 means don't loop, other values indicate the
     * number of repeats, e.g. a value of 1 plays the audio twice.
     * If the stream does not exist, it will have no effect.
     *
     * @param streamID a streamID returned by the play() function
     * @param loop loop mode (0 = no loop, -1 = loop forever)
     */
    public final void setLoop(int streamID, int loop) {
        mImpl.setLoop(streamID, loop);
    }

    /**
     * Change playback rate.
     *
     * The playback rate allows the application to vary the playback
     * rate (pitch) of the sound. A value of 1.0 means playback at
     * the original frequency. A value of 2.0 means playback twice
     * as fast, and a value of 0.5 means playback at half speed.
     * If the stream does not exist, it will have no effect.
     *
     * @param streamID a streamID returned by the play() function
     * @param rate playback rate (1.0 = normal playback, range 0.5 to 2.0)
     */
    public final void setRate(int streamID, float rate) {
        mImpl.setRate(streamID, rate);
    }

    public interface OnLoadCompleteListener {
        /**
         * Called when a sound has completed loading.
         *
         * @param soundPool SoundPool object from the load() method
         * @param sampleId the sample ID of the sound loaded.
         * @param status the status of the load operation (0 = success)
         */
        public void onLoadComplete(SoundPool soundPool, int sampleId, int status);
    }

    /**
     * Sets the callback hook for the OnLoadCompleteListener.
     */
    public void setOnLoadCompleteListener(OnLoadCompleteListener listener) {
        mImpl.setOnLoadCompleteListener(listener);
    }

    /**
     * Release the SoundPool resources.
     *
     * Release all memory and native resources used by the SoundPool
     * object. The SoundPool can no longer be used and the reference
     * should be set to null.
     */
    public final void release() {
        mImpl.release();
    }

    /**
     * Interface for SoundPool implementations.
     * SoundPool is statically referenced and unconditionally called from all
     * over the framework, so we can't simply omit the class or make it throw
     * runtime exceptions, as doing so would break the framework. Instead we
     * now select either a real or no-op impl object based on whether media is
     * enabled.
     *
     * @hide
     */
    /* package */ interface SoundPoolDelegate {
        public int load(String path, int priority);
        public int load(Context context, int resId, int priority);
        public int load(AssetFileDescriptor afd, int priority);
        public int load(
                FileDescriptor fd, long offset, long length, int priority);
        public boolean unload(int soundID);
        public int play(
                int soundID, float leftVolume, float rightVolume,
                int priority, int loop, float rate);
        public void pause(int streamID);
        public void resume(int streamID);
        public void autoPause();
        public void autoResume();
        public void stop(int streamID);
        public void setVolume(int streamID, float leftVolume, float rightVolume);
        public void setVolume(int streamID, float volume);
        public void setPriority(int streamID, int priority);
        public void setLoop(int streamID, int loop);
        public void setRate(int streamID, float rate);
        public void setOnLoadCompleteListener(OnLoadCompleteListener listener);
        public void release();
    }


    /**
     * Real implementation of the delegate interface. This was formerly the
     * body of SoundPool itself.
     */
    /* package */ static class SoundPoolImpl implements SoundPoolDelegate {
        static { System.loadLibrary("soundpool"); }

        private final static String TAG = "SoundPool";
        private final static boolean DEBUG = false;

        private long mNativeContext; // accessed by native methods

        private EventHandler mEventHandler;
        private SoundPool.OnLoadCompleteListener mOnLoadCompleteListener;
        private SoundPool mProxy;

        private final Object mLock;
        private final AudioAttributes mAttributes;
        private final IAppOpsService mAppOps;

        // SoundPool messages
        //
        // must match SoundPool.h
        private static final int SAMPLE_LOADED = 1;

        public SoundPoolImpl(SoundPool proxy, int maxStreams, AudioAttributes attr) {

            // do native setup
            if (native_setup(new WeakReference(this), maxStreams, attr) != 0) {
                throw new RuntimeException("Native setup failed");
            }
            mLock = new Object();
            mProxy = proxy;
            mAttributes = attr;
            IBinder b = ServiceManager.getService(Context.APP_OPS_SERVICE);
            mAppOps = IAppOpsService.Stub.asInterface(b);
        }

        public int load(String path, int priority)
        {
            // pass network streams to player
            if (path.startsWith("http:"))
                return _load(path, priority);

            // try local path
            int id = 0;
            try {
                File f = new File(path);
                ParcelFileDescriptor fd = ParcelFileDescriptor.open(f, ParcelFileDescriptor.MODE_READ_ONLY);
                if (fd != null) {
                    id = _load(fd.getFileDescriptor(), 0, f.length(), priority);
                    fd.close();
                }
            } catch (java.io.IOException e) {
                Log.e(TAG, "error loading " + path);
            }
            return id;
        }

        public int load(Context context, int resId, int priority) {
            AssetFileDescriptor afd = context.getResources().openRawResourceFd(resId);
            int id = 0;
            if (afd != null) {
                id = _load(afd.getFileDescriptor(), afd.getStartOffset(), afd.getLength(), priority);
                try {
                    afd.close();
                } catch (java.io.IOException ex) {
                    //Log.d(TAG, "close failed:", ex);
                }
            }
            return id;
        }

        public int load(AssetFileDescriptor afd, int priority) {
            if (afd != null) {
                long len = afd.getLength();
                if (len < 0) {
                    throw new AndroidRuntimeException("no length for fd");
                }
                return _load(afd.getFileDescriptor(), afd.getStartOffset(), len, priority);
            } else {
                return 0;
            }
        }

        public int load(FileDescriptor fd, long offset, long length, int priority) {
            return _load(fd, offset, length, priority);
        }

        private native final int _load(String uri, int priority);

        private native final int _load(FileDescriptor fd, long offset, long length, int priority);

        public native final boolean unload(int soundID);

        public final int play(int soundID, float leftVolume, float rightVolume,
                int priority, int loop, float rate) {
            if (isRestricted()) {
                leftVolume = rightVolume = 0;
            }
            return _play(soundID, leftVolume, rightVolume, priority, loop, rate);
        }

        public native final int _play(int soundID, float leftVolume, float rightVolume,
                int priority, int loop, float rate);

        private boolean isRestricted() {
            try {
                final int mode = mAppOps.checkAudioOperation(AppOpsManager.OP_PLAY_AUDIO,
                        mAttributes.getUsage(),
                        Process.myUid(), ActivityThread.currentPackageName());
                return mode != AppOpsManager.MODE_ALLOWED;
            } catch (RemoteException e) {
                return false;
            }
        }

        public native final void pause(int streamID);

        public native final void resume(int streamID);

        public native final void autoPause();

        public native final void autoResume();

        public native final void stop(int streamID);

        public final void setVolume(int streamID, float leftVolume, float rightVolume) {
            if (isRestricted()) {
                return;
            }
            _setVolume(streamID, leftVolume, rightVolume);
        }

        private native final void _setVolume(int streamID, float leftVolume, float rightVolume);

        public void setVolume(int streamID, float volume) {
            setVolume(streamID, volume, volume);
        }

        public native final void setPriority(int streamID, int priority);

        public native final void setLoop(int streamID, int loop);

        public native final void setRate(int streamID, float rate);

        public void setOnLoadCompleteListener(SoundPool.OnLoadCompleteListener listener)
        {
            synchronized(mLock) {
                if (listener != null) {
                    // setup message handler
                    Looper looper;
                    if ((looper = Looper.myLooper()) != null) {
                        mEventHandler = new EventHandler(mProxy, looper);
                    } else if ((looper = Looper.getMainLooper()) != null) {
                        mEventHandler = new EventHandler(mProxy, looper);
                    } else {
                        mEventHandler = null;
                    }
                } else {
                    mEventHandler = null;
                }
                mOnLoadCompleteListener = listener;
            }
        }

        private class EventHandler extends Handler
        {
            private SoundPool mSoundPool;

            public EventHandler(SoundPool soundPool, Looper looper) {
                super(looper);
                mSoundPool = soundPool;
            }

            @Override
            public void handleMessage(Message msg) {
                switch(msg.what) {
                case SAMPLE_LOADED:
                    if (DEBUG) Log.d(TAG, "Sample " + msg.arg1 + " loaded");
                    synchronized(mLock) {
                        if (mOnLoadCompleteListener != null) {
                            mOnLoadCompleteListener.onLoadComplete(mSoundPool, msg.arg1, msg.arg2);
                        }
                    }
                    break;
                default:
                    Log.e(TAG, "Unknown message type " + msg.what);
                    return;
                }
            }
        }

        // post event from native code to message handler
        private static void postEventFromNative(Object weakRef, int msg, int arg1, int arg2, Object obj)
        {
            SoundPoolImpl soundPoolImpl = (SoundPoolImpl)((WeakReference)weakRef).get();
            if (soundPoolImpl == null)
                return;

            if (soundPoolImpl.mEventHandler != null) {
                Message m = soundPoolImpl.mEventHandler.obtainMessage(msg, arg1, arg2, obj);
                soundPoolImpl.mEventHandler.sendMessage(m);
            }
        }

        public native final void release();

        private native final int native_setup(Object weakRef, int maxStreams,
                Object/*AudioAttributes*/ attributes);

        protected void finalize() { release(); }
    }

    /**
     * No-op implementation of SoundPool.
     * Used when media is disabled by the system.
     * @hide
     */
    /* package */ static class SoundPoolStub implements SoundPoolDelegate {
        public SoundPoolStub() { }

        public int load(String path, int priority) {
            return 0;
        }

        public int load(Context context, int resId, int priority) {
            return 0;
        }

        public int load(AssetFileDescriptor afd, int priority) {
            return 0;
        }

        public int load(FileDescriptor fd, long offset, long length, int priority) {
            return 0;
        }

        public final boolean unload(int soundID) {
            return true;
        }

        public final int play(int soundID, float leftVolume, float rightVolume,
                int priority, int loop, float rate) {
            return 0;
        }

        public final void pause(int streamID) { }

        public final void resume(int streamID) { }

        public final void autoPause() { }

        public final void autoResume() { }

        public final void stop(int streamID) { }

        public final void setVolume(int streamID,
                float leftVolume, float rightVolume) { }

        public void setVolume(int streamID, float volume) {
        }

        public final void setPriority(int streamID, int priority) { }

        public final void setLoop(int streamID, int loop) { }

        public final void setRate(int streamID, float rate) { }

        public void setOnLoadCompleteListener(SoundPool.OnLoadCompleteListener listener) {
        }

        public final void release() { }
    }
}