RingTone的使用

RingTone 提供了一个快速的方法，播放铃声，提示音，或其他类似类型的声音。

使用案例：

 

import android.content.Context;
import android.media.AudioAttributes;
import android.media.AudioManager;
import android.media.Ringtone;
import android.media.RingtoneManager;
import android.net.Uri;
import android.os.Bundle;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Message;
import android.os.Vibrator;
import android.telephony.TelephonyManager;
import android.util.Log;
import android.content.ContentResolver;

import com.android.deskclock.R;

import java.lang.reflect.Method;
import java.io.IOException;

 

/*
* Managers playing ringtone and vibrating the device for timer.
* */
public class TimerKlaxon {
    private final String TAG = "TimerKlaxon";
    private final Context mContext;
    private static final int EVENT_PALY = 1;
    private static final int EVENT_STOP = 2;
    private Handler mDedicatedHandler;
    private static final String RINGTONE_URI_KEY = "RINGTONE_URI_KEY";
    //Volume suggested by media team for in-call alarms
    private static final float IN_CALL_VOLUME = 0.125F;
    private TimerRingtonePlayback mTimerRingtonePlayback;
    private Vibrator mVibrator;
    private static final long[] VIBRATOR_PATTERN = {500, 500};
    private static boolean isStarted = false;

    public TimerKlaxon(Context context){
        mContext = context;
    }

    public void play(){
        Uri timerRing = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_ALARM);
        postMessage(EVENT_PALY, timerRing);

        isStarted = true;
    }

    public void stop(){
        if (isStarted) {
            postMessage(EVENT_STOP, null);
        }
    }

    public void postMessage(int msgCode, Uri ringtoneUri){
        synchronized(this){
            if (mDedicatedHandler == null) {
                mDedicatedHandler = getDedicatedHandler();
            }

            final Message message = mDedicatedHandler.obtainMessage(msgCode);
            if (ringtoneUri != null) {
                final Bundle bundle = new Bundle();
                bundle.putParcelable(RINGTONE_URI_KEY, ringtoneUri);
                message.setData(bundle);
            }
            mDedicatedHandler.sendMessage(message);
        }
    }

    private Handler getDedicatedHandler(){
        final HandlerThread hThread = new HandlerThread("ringtone-play");
        hThread.start();

        return new Handler(hThread.getLooper()) {
            @Override
            public void handleMessage(Message msg){
                switch (msg.what) {
                    case EVENT_PALY:
                        final Bundle data = msg.getData();
                        final Uri ringtoneUri = data.getParcelable(RINGTONE_URI_KEY);
                        getTimerRingtonePlayback().play(mContext,ringtoneUri);
                        break;
                    case EVENT_STOP:
                        getTimerRingtonePlayback().stop(mContext);
                        break;
                }
            }
        };
    }

    private static boolean isInTelephoneCall(Context context){
        final TelephonyManager tm = (TelephonyManager)
                context.getSystemService(Context.TELEPHONY_SERVICE);
        return tm.getCallState() != TelephonyManager.CALL_STATE_IDLE;
    }

    private TimerRingtonePlayback getTimerRingtonePlayback() {
        if (mTimerRingtonePlayback == null) {
            mTimerRingtonePlayback = new TimerRingtonePlayback();
        }

        return mTimerRingtonePlayback;
    }

    private Vibrator getVibrator(){
        if (mVibrator == null) {
            mVibrator = (Vibrator)mContext.getSystemService(Context.VIBRATOR_SERVICE);
        }
        return mVibrator;
    }

    private Uri getResourceUri(Context context, int resourceId) {
        return new Uri.Builder()
                .scheme(ContentResolver.SCHEME_ANDROID_RESOURCE)
                .authority(context.getPackageName())
                .path(String.valueOf(resourceId))
                .build();
    }

    private class TimerRingtonePlayback{
        private AudioManager mAudioManager;
        private Ringtone mRingtone;
        private Method mSetVolumeMethod;
        private Method mSetLoopingMethod;

        private TimerRingtonePlayback(){
            try {
                mSetVolumeMethod = Ringtone.class.getDeclaredMethod("setVolume", float.class);
            }catch (NoSuchMethodException e) {
                Log.e(TAG,"unable to locate method :Ringtone.setVolume(float)." + e);
            }

            try {
                mSetLoopingMethod = Ringtone.class.getDeclaredMethod("setLooping", boolean.class);
            }catch (NoSuchMethodException e) {
                Log.e(TAG,"unable to locate method :Ringtone.setLooping(boolean)." + e);
            }
        }

        //play the same ringtone as the alarm.
        public void play(Context context, Uri ringtoneUri){
            if (mAudioManager == null) {
                mAudioManager = (AudioManager)context.getSystemService(Context.AUDIO_SERVICE);
            }

            if (!mAudioManager.isSilentMode()) {
                final boolean inTelephonyCall = isInTelephoneCall(context);
                if (inTelephonyCall) {
                    ringtoneUri = getResourceUri(context, R.raw.in_call_alarm);
                }
                //fetch the specified ringtone
                mRingtone = RingtoneManager.getRingtone(context, ringtoneUri);
                //fall back to system default ringtone.
                if (mRingtone == null) {
                    ringtoneUri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_ALARM);
                    mRingtone = RingtoneManager.getRingtone(context, ringtoneUri);
                }

                try {
                    mSetLoopingMethod.invoke(mRingtone,true);
                }catch (Exception e){
                    Log.d(TAG,"unable to turn looping." + e);
                    mRingtone = null;
                }

                if (mRingtone == null) {
                    ringtoneUri =  getResourceUri(context, R.raw.fallbackring);
                    mRingtone = RingtoneManager.getRingtone(context, ringtoneUri);
                }

                try {
                    mRingtone.setAudioAttributes(new AudioAttributes.Builder()
                        .setUsage(AudioAttributes.USAGE_ALARM)
                        .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
                        .build());
                    if (inTelephonyCall) {
                        mSetVolumeMethod.invoke(mRingtone, IN_CALL_VOLUME);
                    }
                    mAudioManager.requestAudioFocus(null, AudioManager.STREAM_ALARM, AudioManager.AUDIOFOCUS_GAIN_TRANSIENT);

                    mRingtone.play();
                }catch (Exception e) {
                    Log.e(TAG,"ringtone play fail." + e);
                }
            }

            getVibrator().vibrate(VIBRATOR_PATTERN, 0, new AudioAttributes.Builder()
                    .setUsage(AudioAttributes.USAGE_ALARM)
                    .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
                    .build());
        }

        public void stop(Context context){
            if (isStarted) {
                if (mRingtone != null && mRingtone.isPlaying()) {
                    mRingtone.stop();
                }
                mRingtone = null;

                if (mAudioManager != null) {
                    mAudioManager.abandonAudioFocusRequest(null);
                }

                getVibrator().cancel();
            }

            isStarted = false;
        }

    }
}