Разбираю исходник игры Пакман

package es.eduards.pacman;
import java.util.HashMap;
import java.util.Map;
 
import android.annotation.TargetApi;
import android.content.Context;
import android.media.AudioManager;
import android.media.MediaPlayer;
import android.media.SoundPool;
import android.media.SoundPool.OnLoadCompleteListener;
import android.os.Build;
import android.util.Log;
 
/**
 * The class to create sounds for the game
 */
public class SoundPlayer {
 
    private static final String TAG = "SoundPlayer";//quality parameter
   /*Sounds for Pacman(Player)*/
    private static final int[] SOUND_RESOURCES = {
            R.raw.death,
            R.raw.eating_dot_1,
            R.raw.eating_dot_2,
            R.raw.eating_ghost,
            R.raw.extra_life,
            R.raw.fruit,
 
    };
   private static final int SOUND_CHANNEL_COUNT = 5;//channel number for pacman sound display
    /*Sounds for ghosts*/
    private static final int[] AMBIENT_RESOURCES = {
            R.raw.ambient_1,
            R.raw.ambient_2,
            R.raw.ambient_3,
            R.raw.ambient_4,
            R.raw.ambient_eyes,
            R.raw.ambient_fright,
    };
    private static final int AMBIENT_CHANNEL_COUNT = 1;//channel count for ghost display
    private static final int CUTSCENE_RESOURCE_ID = R.raw.cutscene;//sound for cutscenes
 
    private final Context context;
    private SoundPoolManager soundManager;
    private boolean soundAvailable;
    private SoundPoolManager ambientManager;
    private boolean ambientAvailable;
    private AudioClip cutsceneAudioClip;
    private boolean cutsceneAmbientAvailable;
    private String queuedAmbient;
 
    /**
     * Constructor for class that builds the sound player
     * @param context
     */
    SoundPlayer(Context context) {
        this.context = context;
    }
 
    /**
     * Inits the player for playing cutscene,ambient,and Player sounds
     */
    void init() {
        cutsceneAudioClip = new AudioClip(context);//init constructor for cutscene
        soundManager =new SoundPoolManager( context,SOUND_RESOURCES, SOUND_CHANNEL_COUNT);//init constructor for pacman sounds
        ambientManager=new SoundPoolManager(context,AMBIENT_RESOURCES, AMBIENT_CHANNEL_COUNT);//init constructor for ghosts sound
        cutsceneAmbientAvailable = cutsceneAudioClip.init();//to check the availability for displaying cutscene sound
        if (cutsceneAmbientAvailable) {
            /*To check for availability of Player's sounds*/
            soundManager.init(new SoundPoolManager.AvailabilityNotifier() {
                @Override
                public void notifyAvailability() {
                    soundAvailable = true;
                    if (isAvailable()) {
                        playQueuedAmbient();
                    }
                }
            });
            /*check for the availability of ambient sounds*/
            ambientManager.init(new SoundPoolManager.AvailabilityNotifier() {
                @Override
                public void notifyAvailability() {
                    ambientAvailable = true;
                    if (isAvailable()) {
                        playQueuedAmbient();
                    }
                }
            });
        }
    }
 
    /**
     * Play the sound resources for Pacman
     * Displays sounds of
     * death
     * eating_dot_1
     * eating_dot_2
     * eating_ghost
     * extra_life
     * fruit
     *
     * @param track-one track of the above
     * @param channel-SOUND_CHANNEL_COUNT = 5
     */
   void playTrack(String track, int channel) {
       /*if sound available or not*/
        if (isAvailable()) {
            soundManager.playTrack(track, channel, false);
        }
    }
 
    /**
     * To stop channnel relates to ambient or sound resources
     * @param channel
     */
    void stopChannel(int channel) {
        if (isAvailable()) {
            soundManager.stopChannel(channel);
        }
    }
 
    /**
     * Method to play the ambient sound of ghost
     * when they move
     * ambient_1
     * ambient_2
     * etc.
     * @param track
     */
    void playAmbient(String track) {
        if (isAvailable()) {
            ambientManager.playTrack(track, 0, true);
            queuedAmbient = null;
        } else {
            queuedAmbient = track;
        }
    }
 
    /**
     * To play the next in queue ambient sound
     */
    private void playQueuedAmbient() {
        if (queuedAmbient != null) {
            ambientManager.playTrack(queuedAmbient, 0, true);
            queuedAmbient = null;
        }
    }
 
    /**
     *  Stops ambient sound
     */
    void stopAmbient() {
        queuedAmbient = null;
        if (isAvailable()) {
            ambientManager.stopChannel(0);
        }
    }
 
    /**
     * To play the sound in the animations
     */
 
    void playCutsceneAmbient() {
        if (isAvailable()) {
            try {
                cutsceneAudioClip.loop();
            } catch (IllegalStateException e) {
                Log.e(TAG, "playing cutscene ambient track is failed.");
                cutsceneAmbientAvailable = false;
            }
        }
    }
 
    /**
     * Stop playing sound in the end of cutscene
     */
    void stopCutsceneAmbient() {
        if (isAvailable()) {
            try {
                cutsceneAudioClip.stop();
            } catch (IllegalStateException e) {
                Log.e(TAG, "stopping cutscene ambient track is failed.");
                cutsceneAmbientAvailable = false;
            }
        }
    }
/**checks the sound availability*/
    boolean isAvailable() {
        return soundAvailable
                && ambientAvailable
                && cutsceneAmbientAvailable;
    }
 
    /**
     * Destroy sounds when the application killed
     */
    void destroy() {
        soundManager.destroy();
        ambientManager.destroy();
        cutsceneAudioClip.destroy();
    }
 
    /**
     * The class which load all the sound files  in the start of the application and then it can we
     * use to play sounds in the application as and when required.
     * Play sounds in response of some actions performed by user.
     */
    private static class SoundPoolManager {
        /**
         * Static interface to notify the availability of the sound
         * check if scpecific sound available or not to play it as a queued sound
         */
        private static interface AvailabilityNotifier {
            void notifyAvailability();
        }
 
        private final Context context;
        private final int[] soundResources;
        private final int[] channels;
        private SoundPool soundPool;
        private final Map<String, Integer> soundIds;//hash map that will save an id of each sound that will displayed in required time
 
        /**
         * Constructor that builds the class with an appropriate parameters
         * @param context
         * @param soundResources
         * @param channelCount
         */
        SoundPoolManager(
                Context context,
                int[] soundResources,
                int channelCount) {
            this.context = context;
            this.soundResources = soundResources;
            this.channels = new int[channelCount];
            this.soundIds = new HashMap<String, Integer>();
        }
 
        @TargetApi(Build.VERSION_CODES.FROYO)//to support an appropriate API
        /**
         * Method inits and loads files to the player
         */
        void init(final AvailabilityNotifier notifier) {
            this.soundPool =
                    new SoundPool(
                            channels.length,
                            AudioManager.STREAM_MUSIC,
                            0);
            /*Set the load listener of audio files*/
            soundPool.setOnLoadCompleteListener(new OnLoadCompleteListener() {
                private int count = 0;
                private boolean success = true;
                /*when the loading files completed,onLoadComplete() will be called*/
                @Override
                public void onLoadComplete(
                        SoundPool soundPool,
                        int sampleId,
                        int status) {
                    count++;
                    success = success && (status == 0);
                    if (count == soundResources.length) {
                        if (success) {
                            notifier.notifyAvailability();
                        }
                    }
                }
            });
            /*put all sound id's into the HashMap to know which sound id to display in required time*/
            for (int res : soundResources) {
                soundIds.put(
                        context.getResources().getResourceEntryName(res),
                        Integer.valueOf(soundPool.load(context, res, 1)));
            }
        }
 
        /**
         * To destroy sounds when the application killed
         */
        void destroy() {
            if (soundPool != null) {
                soundPool.release();
                soundPool = null;
            }
 
            soundIds.clear();
            for (int i = 0; i < channels.length; i++) {
                channels[i] = 0;
            }
        }
 
        void playTrack(String track, int channel, boolean repeat) {
            if (soundPool == null) {
                return;
            }
 
            Integer id = soundIds.get(track);
            if (id == null) {
                throw new IllegalArgumentException(
                        "invalid track name. : " + track);
            }
            if (channel >= channels.length) {
                throw new IllegalArgumentException(
                        "channel is too large. : " + channel);
            }
 
            channels[channel] =
                    soundPool.play(
                            id.intValue(),
                            1,
                            1,
                            0,
                            (repeat ? -1 : 0),
                            1);
        }
 
        void stopChannel(int channel) {
            if (soundPool == null) {
                return;
            }
 
            if (channel >= channels.length) {
                throw new IllegalArgumentException(
                        "channel is too large. : " + channel);
            }
 
            int id = channels[channel];
            if (id != 0) {
                soundPool.stop(id);
                channels[channel] = 0;
            }
        }
    }
 
    /**
     * The AudioClip is a static class for playing a sound clip.
     * Multiple AudioClip items can be playing at the same time, and the resulting sound is mixed together to produce a composite.
     */
    private static class AudioClip {
 
        private final Context context;
        private MediaPlayer mPlayer;
        private boolean mPlaying = false;
        private boolean mLoop = false;
 
        AudioClip(Context context) {
            this.context = context;
        }
 
        boolean init() {
            mPlayer = MediaPlayer.create(context, CUTSCENE_RESOURCE_ID);
            if (mPlayer == null) {
                return false;
            }
            /*Register a callback to be invoked when the end of a media source has been reached during playback.
            * Creates overrided method onCompletion(MediaPlayer mp)
            * */
            mPlayer.setOnCompletionListener(new MediaPlayer.OnCompletionListener() {
                /**
                 * Called when the end of a media source is reached during playback
                 * @param mp-the MediaPlayer that reached the end of the file
                 */
                @Override
                public void onCompletion(MediaPlayer mp) {
                    mPlaying = false;
                    if (mLoop) {
                        play();
                    }
                }
            });
            return true;
        }
 
        /**
         * Starts playing this audio clip. Each time this method is called, the clip is restarted from the beginning.
         */
        void play() {
            if (mPlaying) {
                return;
            }
 
            if (mPlayer != null) {
                mPlayer.start();
                mPlaying = true;
            }
        }
 
        /**
         * Stops playing this audio clip.
         */
        void stop() {
            mLoop = false;
            if (mPlaying) {
                if (mPlayer != null) {
                    mPlayer.pause();
                    mPlayer.seekTo(0);
                }
                mPlaying = false;
            }
        }
 
        /**
         * Starts playing this audio clip in a loop.
         */
        void loop() {
            mLoop = true;
            play();
        }
 
        /**
         * Destroys playing this audio clip.
         */
        void destroy() {
            if (mPlayer != null) {
                mPlayer.release();
                mPlayer = null;
            }
        }
    }
 
}