/**
* Opens a stream to the givne URI, also providing the MIME type & length.
*
* @return Never returns null.
* @throws Throws an InvalidArgumentException for relative URIs. Relative URIs should be resolved
* before being passed into this function.
* @throws Throws an IOException if the URI cannot be opened.
* @throws Throws an IllegalStateException if called on a foreground thread and skipThreadCheck is
* false.
*/
public OpenForReadResult openForRead(Uri uri, boolean skipThreadCheck) throws IOException {
if (!skipThreadCheck) {
assertBackgroundThread();
}
switch (getUriType(uri)) {
case URI_TYPE_FILE:
{
FileInputStream inputStream = new FileInputStream(uri.getPath());
String mimeType = FileHelper.getMimeTypeForExtension(uri.getPath());
long length = inputStream.getChannel().size();
return new OpenForReadResult(uri, inputStream, mimeType, length, null);
}
case URI_TYPE_ASSET:
{
String assetPath = uri.getPath().substring(15);
AssetFileDescriptor assetFd = null;
InputStream inputStream;
long length = -1;
try {
assetFd = assetManager.openFd(assetPath);
inputStream = assetFd.createInputStream();
length = assetFd.getLength();
} catch (FileNotFoundException e) {
// Will occur if the file is compressed.
inputStream = assetManager.open(assetPath);
}
String mimeType = FileHelper.getMimeTypeForExtension(assetPath);
return new OpenForReadResult(uri, inputStream, mimeType, length, assetFd);
}
case URI_TYPE_CONTENT:
case URI_TYPE_RESOURCE:
{
String mimeType = contentResolver.getType(uri);
AssetFileDescriptor assetFd = contentResolver.openAssetFileDescriptor(uri, "r");
InputStream inputStream = assetFd.createInputStream();
long length = assetFd.getLength();
return new OpenForReadResult(uri, inputStream, mimeType, length, assetFd);
}
case URI_TYPE_DATA:
{
OpenForReadResult ret = readDataUri(uri);
if (ret == null) {
break;
}
return ret;
}
case URI_TYPE_HTTP:
case URI_TYPE_HTTPS:
{
HttpURLConnection conn = httpClient.open(new URL(uri.toString()));
conn.setDoInput(true);
String mimeType = conn.getHeaderField("Content-Type");
int length = conn.getContentLength();
InputStream inputStream = conn.getInputStream();
return new OpenForReadResult(uri, inputStream, mimeType, length, null);
}
}
throw new FileNotFoundException("URI not supported by CordovaResourceApi: " + uri);
}
public static MediaPlayer create(Context context, int resid) {
try {
AssetFileDescriptor afd = context.getResources().openRawResourceFd(resid);
if (afd == null) return null;
MediaPlayer mp = new MediaPlayer();
mp.setDataSource(afd.getFileDescriptor(), afd.getStartOffset(), afd.getLength());
afd.close();
mp.prepare();
return mp;
} catch (IOException ex) {
Log.d(TAG, "create failed:", ex);
// fall through
} catch (IllegalArgumentException ex) {
Log.d(TAG, "create failed:", ex);
// fall through
} catch (SecurityException ex) {
Log.d(TAG, "create failed:", ex);
// fall through
} catch (Exception ex) {
Log.d(TAG, "create failed:", ex);
// fall through
}
return null;
}
/**
* create mediaplayer for music
*
* @param pPath the pPath relative to assets
* @return
*/
private MediaPlayer createMediaplayer(final String path) {
MediaPlayer mediaPlayer = new MediaPlayer();
try {
if (CocosPlayClient.isEnabled() && !CocosPlayClient.isDemo()) {
CocosPlayClient.updateAssets(path);
}
CocosPlayClient.notifyFileLoaded(path);
if (path.startsWith("/")) {
final FileInputStream fis = new FileInputStream(path);
mediaPlayer.setDataSource(fis.getFD());
fis.close();
} else {
final AssetFileDescriptor assetFileDescritor = this.mContext.getAssets().openFd(path);
mediaPlayer.setDataSource(
assetFileDescritor.getFileDescriptor(),
assetFileDescritor.getStartOffset(),
assetFileDescritor.getLength());
}
mediaPlayer.prepare();
mediaPlayer.setVolume(this.mLeftVolume, this.mRightVolume);
} catch (final Exception e) {
mediaPlayer = null;
Log.e(Cocos2dxMusic.TAG, "error: " + e.getMessage(), e);
}
return mediaPlayer;
}
private static boolean hasCodecsForResourceCombo(
Context context, int resourceId, int track, String mimePrefix) {
try {
AssetFileDescriptor afd = null;
MediaExtractor ex = null;
try {
afd = context.getResources().openRawResourceFd(resourceId);
ex = new MediaExtractor();
ex.setDataSource(afd.getFileDescriptor(), afd.getStartOffset(), afd.getLength());
if (mimePrefix != null) {
return hasCodecForMediaAndDomain(ex, mimePrefix);
} else if (track == ALL_AV_TRACKS) {
return hasCodecsForMedia(ex);
} else {
return hasCodecForTrack(ex, track);
}
} finally {
if (ex != null) {
ex.release();
}
if (afd != null) {
afd.close();
}
}
} catch (IOException e) {
Log.i(TAG, "could not open resource");
}
return false;
}
private void setDataSourceFromResource(Resources resources, MediaPlayer player, int res)
throws java.io.IOException {
AssetFileDescriptor afd = resources.openRawResourceFd(res);
if (afd != null) {
player.setDataSource(afd.getFileDescriptor(), afd.getStartOffset(), afd.getLength());
afd.close();
}
}
public synchronized long BackgroundMusicCreateFromFile(String fileName, int[] error) {
if (fileName.equals("")) {
error[0] = GAUDIO_CANNOT_OPEN_FILE;
return 0;
}
AssetFileDescriptor fd = null;
if (fileName.startsWith("/")) {
File file = new File(fileName);
if (!file.isFile()) {
error[0] = GAUDIO_CANNOT_OPEN_FILE;
return 0;
}
} else {
if (patchFile_ != null) fd = patchFile_.getAssetFileDescriptor(fileName);
if (fd == null && mainFile_ != null) fd = mainFile_.getAssetFileDescriptor(fileName);
if (fd == null)
try {
fd = WeakActivityHolder.get().getAssets().openFd("assets/" + fileName);
} catch (IOException e) {
}
if (fd == null) {
error[0] = GAUDIO_CANNOT_OPEN_FILE;
return 0;
}
}
MediaPlayer player = new MediaPlayer();
int duration = 0;
try {
if (fd != null) {
player.setDataSource(fd.getFileDescriptor(), fd.getStartOffset(), fd.getLength());
fd.close();
} else {
player.setDataSource(fileName);
}
player.prepare();
duration = player.getDuration();
player.release();
player = null;
} catch (Exception e) {
error[0] = GAUDIO_UNRECOGNIZED_FORMAT;
return 0;
}
long gid = nextgid();
sounds_.put(gid, new Sound(fileName, duration));
return gid;
}
private void openVideo() {
if (mUri == null || mSurfaceHolder == null) {
// not ready for playback just yet, will try again later
return;
}
// Tell the music playback service to pause
// TODO: these constants need to be published somewhere in the framework.
Intent i = new Intent("com.android.music.musicservicecommand");
i.putExtra("command", "pause");
getContext().sendBroadcast(i);
if (mMediaPlayer != null) {
mMediaPlayer.reset();
mMediaPlayer.release();
mMediaPlayer = null;
}
try {
mMediaPlayer = new MediaPlayer();
mMediaPlayer.setOnPreparedListener(mPreparedListener);
mMediaPlayer.setOnVideoSizeChangedListener(mSizeChangedListener);
mIsPrepared = false;
Log.v(TAG, "reset duration to -1 in openVideo");
mDuration = -1;
mMediaPlayer.setOnCompletionListener(mCompletionListener);
mMediaPlayer.setOnErrorListener(mErrorListener);
mMediaPlayer.setOnBufferingUpdateListener(mBufferingUpdateListener);
mCurrentBufferPercentage = 0;
if (URLUtil.isAssetUrl(mUri.toString())) { // DST: 20090606 detect asset url
AssetFileDescriptor afd = null;
try {
String path = mUri.toString().substring("file:///android_asset/".length());
afd = getContext().getAssets().openFd(path);
mMediaPlayer.setDataSource(
afd.getFileDescriptor(), afd.getStartOffset(), afd.getLength());
} finally {
if (afd != null) {
afd.close();
}
}
} else {
setDataSource();
}
mMediaPlayer.setDisplay(mSurfaceHolder);
mMediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
mMediaPlayer.setScreenOnWhilePlaying(true);
mMediaPlayer.prepareAsync();
attachMediaController();
} catch (IOException ex) {
Log.w(TAG, "Unable to open content: " + mUri, ex);
return;
} catch (IllegalArgumentException ex) {
Log.w(TAG, "Unable to open content: " + mUri, ex);
return;
}
}
public synchronized long BackgroundMusicPlay(long backgroundMusic, boolean paused, long data) {
Sound sound2 = sounds_.get(backgroundMusic);
if (sound2 == null) return 0;
String fileName = sound2.fileName;
AssetFileDescriptor fd = null;
if (fileName.startsWith("/")) {
File file = new File(fileName);
if (!file.isFile()) return 0;
} else {
if (patchFile_ != null) fd = patchFile_.getAssetFileDescriptor(fileName);
if (fd == null && mainFile_ != null) fd = mainFile_.getAssetFileDescriptor(fileName);
if (fd == null)
try {
fd = WeakActivityHolder.get().getAssets().openFd("assets/" + fileName);
} catch (IOException e) {
}
if (fd == null) return 0;
}
MediaPlayer player = new MediaPlayer();
try {
if (fd != null) {
player.setDataSource(fd.getFileDescriptor(), fd.getStartOffset(), fd.getLength());
fd.close();
} else {
player.setDataSource(fileName);
}
player.prepare();
} catch (Exception e) {
return 0;
}
long gid = nextgid();
player.setOnCompletionListener(new OnCompletionListener(this, gid));
Channel channel = new Channel(gid, player, sound2, data);
sound2.channels.add(channel);
channels_.put(gid, channel);
channel.paused = paused;
if (!paused) channel.player.start();
return gid;
}
/** Prepares given media asset (path from assets directory) for playback. */
public void prepare(final String asset) {
reset();
try {
AssetFileDescriptor fd =
GUI.getInstance().getContext().getResources().getAssets().openFd(asset);
setDataSource(fd.getFileDescriptor(), fd.getStartOffset(), fd.getLength());
fd.close();
prepare();
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public int getContentLength() {
try {
AssetFileDescriptor fd = this.resolver.openAssetFileDescriptor(uri, "r");
long length = fd.getLength();
if (length <= 0 && length <= Integer.MAX_VALUE) {
return (int) length;
}
} catch (IOException e) {
}
return -1;
}
@Override
public void onCompletion(MediaPlayer mp) {
// IF RAMADAN PLAY PRAYER, IF PRAYER ALREADY PLAYED, STOP
if (mSettings.getBoolean(AppSettings.Key.USE_ADHAN)
&& mSettings.getBoolean(AppSettings.Key.IS_RAMADAN)) {
mMediaPlayer.stop();
mMediaPlayer.release();
mMediaPlayer = null;
AssetFileDescriptor assetFileDescriptor = null;
if (mPrayerNameString.equalsIgnoreCase(getString(R.string.fajr))) {
assetFileDescriptor = getResources().openRawResourceFd(R.raw.dua_sehri);
} else if (mPrayerNameString.equalsIgnoreCase(getString(R.string.maghrib))) {
assetFileDescriptor = getResources().openRawResourceFd(R.raw.dua_iftar);
}
if (assetFileDescriptor == null) {
stopAlarm();
return;
}
try {
mMediaPlayer = new MediaPlayer();
mMediaPlayer.setDataSource(
assetFileDescriptor.getFileDescriptor(),
assetFileDescriptor.getStartOffset(),
assetFileDescriptor.getLength());
mMediaPlayer.setAudioStreamType(mAudioStream);
mMediaPlayer.setOnCompletionListener(
new MediaPlayer.OnCompletionListener() {
@Override
public void onCompletion(MediaPlayer mp) {
stopAlarm();
}
});
mMediaPlayer.setLooping(false);
mMediaPlayer.prepare();
mAlarmOff.postDelayed(
mStartDua =
new Runnable() {
@Override
public void run() {
mMediaPlayer.start();
}
},
3000);
} catch (Exception e) {
Log.e("RingAlarmActivity", e.getMessage(), e);
}
}
}
public void setLevelMusic(String fileName) {
String soundtrack = "sounds/" + fileName;
if (soundtrack.equals(currentSoundtrack)) return;
try {
mediaPlayer.stop();
mediaPlayer.reset();
AssetFileDescriptor afd = context.getAssets().openFd(soundtrack);
currentSoundtrack = soundtrack;
mediaPlayer.setDataSource(afd.getFileDescriptor(), afd.getStartOffset(), afd.getLength());
} catch (Exception e) {
Log.e("SNAPPERS", e.getMessage(), e);
return;
}
}
public AndroidMusic(AssetFileDescriptor assetDescriptor) {
mediaPlayer = new MediaPlayer();
try {
mediaPlayer.setDataSource(
assetDescriptor.getFileDescriptor(),
assetDescriptor.getStartOffset(),
assetDescriptor.getLength());
mediaPlayer.prepare();
isPrepared = true;
mediaPlayer.setOnCompletionListener(this);
} catch (Exception e) {
throw new RuntimeException("Couldn't load music");
}
}
private long sizeInternal() {
try {
AssetFileDescriptor descriptor = myApplication.getAssets().openFd(getPath());
// for some files (archives, crt) descriptor cannot be opened
if (descriptor == null) {
return sizeSlow();
}
long length = descriptor.getLength();
descriptor.close();
return length;
} catch (IOException e) {
return sizeSlow();
}
}
protected void initialize() throws IOException {
try {
mp = new MediaPlayer();
String url = TiConvert.toString(proxy.getProperty(TiC.PROPERTY_URL));
if (URLUtil.isAssetUrl(url)) {
Context context = proxy.getTiContext().getTiApp();
String path = url.substring(TiConvert.ASSET_URL.length());
AssetFileDescriptor afd = null;
try {
afd = context.getAssets().openFd(path);
// Why mp.setDataSource(afd) doesn't work is a problem for another day.
// http://groups.google.com/group/android-developers/browse_thread/thread/225c4c150be92416
mp.setDataSource(afd.getFileDescriptor(), afd.getStartOffset(), afd.getLength());
} catch (IOException e) {
Log.e(LCAT, "Error setting file descriptor: ", e);
} finally {
if (afd != null) {
afd.close();
}
}
} else {
Uri uri = Uri.parse(url);
if (uri.getScheme().equals(TiC.PROPERTY_FILE)) {
mp.setDataSource(uri.getPath());
} else {
remote = true;
mp.setDataSource(url);
}
}
mp.setLooping(looping);
mp.setOnCompletionListener(this);
mp.setOnErrorListener(this);
mp.setOnInfoListener(this);
mp.setOnBufferingUpdateListener(this);
mp.prepare(); // Probably need to allow for Async
setState(STATE_INITIALIZED);
setVolume(volume);
if (proxy.hasProperty(TiC.PROPERTY_TIME)) {
setTime(TiConvert.toInt(proxy.getProperty(TiC.PROPERTY_TIME)));
}
} catch (Throwable t) {
Log.w(LCAT, "Issue while initializing : ", t);
release();
setState(STATE_STOPPED);
}
}
public void LoadMusic(String file) {
try {
AssetFileDescriptor assetDesc = assets.openFd(file);
if (isMusicPlaying()) Music.stop();
Music.reset();
Music.setDataSource(
assetDesc.getFileDescriptor(), assetDesc.getStartOffset(), assetDesc.getLength());
// Don't block the main thread.
Music.prepare();
Music.setVolume(GameVolume, GameVolume);
Music.start();
} catch (Exception e) {
}
}
public void playMedia(String path) {
try {
AssetFileDescriptor desc = getAssets().openFd(path);
long start = desc.getStartOffset();
long end = desc.getLength();
MediaPlayer mm = new MediaPlayer();
mm.setDataSource(desc.getFileDescriptor(), start, end);
mm.prepare();
mm.setVolume(100, 100);
mm.start();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
Toast.makeText(getApplicationContext(), "Failed", Toast.LENGTH_SHORT).show();
}
}
/** 初始化声音 */
private void initBeepSound() {
if (playBeep && mediaPlayer == null) {
setVolumeControlStream(AudioManager.STREAM_MUSIC);
mediaPlayer = new MediaPlayer();
mediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
mediaPlayer.setOnCompletionListener(beepListener);
AssetFileDescriptor file = getResources().openRawResourceFd(R.raw.beep);
try {
mediaPlayer.setDataSource(
file.getFileDescriptor(), file.getStartOffset(), file.getLength());
file.close();
mediaPlayer.setVolume(BEEP_VOLUME, BEEP_VOLUME);
mediaPlayer.prepare();
} catch (IOException e) {
mediaPlayer = null;
}
}
}
private MediaPlayer buildMediaPlayer(Context activity) {
MediaPlayer mediaPlayer = new MediaPlayer();
mediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
mediaPlayer.setOnCompletionListener(this);
mediaPlayer.setOnErrorListener(this);
AssetFileDescriptor file = activity.getResources().openRawResourceFd(R.raw.beep);
try {
mediaPlayer.setDataSource(file.getFileDescriptor(), file.getStartOffset(), file.getLength());
file.close();
mediaPlayer.setVolume(BEEP_VOLUME, BEEP_VOLUME);
mediaPlayer.prepare();
} catch (IOException ioe) {
Log.w(TAG, ioe);
mediaPlayer = null;
}
return mediaPlayer;
}
public static void playNotifycationMusic(Context context, String voicePath) throws IOException {
// paly music ...
AssetFileDescriptor fileDescriptor = context.getAssets().openFd(voicePath);
if (mediaPlayer == null) {
mediaPlayer = new MediaPlayer();
}
if (mediaPlayer.isPlaying()) {
mediaPlayer.stop();
}
mediaPlayer.reset();
mediaPlayer.setDataSource(
fileDescriptor.getFileDescriptor(),
fileDescriptor.getStartOffset(),
fileDescriptor.getLength());
mediaPlayer.prepare();
mediaPlayer.setLooping(false);
mediaPlayer.start();
}
private void a() {
this.doCleanUp();
try {
this.s = new MediaPlayer();
if (this.i) {
this.s.setDataSource(this.c, Uri.parse(this.f));
} else if (this.k != 0L) {
final FileInputStream fileInputStream = new FileInputStream(this.f);
this.s.setDataSource(fileInputStream.getFD(), this.j, this.k);
fileInputStream.close();
} else {
final AssetManager assets = this.getResources().getAssets();
try {
final AssetFileDescriptor openFd = assets.openFd(this.f);
this.s.setDataSource(
openFd.getFileDescriptor(), openFd.getStartOffset(), openFd.getLength());
openFd.close();
} catch (IOException ex2) {
final FileInputStream fileInputStream2 = new FileInputStream(this.f);
this.s.setDataSource(fileInputStream2.getFD());
fileInputStream2.close();
}
}
this.s.setDisplay(this.e);
this.s.setOnBufferingUpdateListener((MediaPlayer.OnBufferingUpdateListener) this);
this.s.setOnCompletionListener((MediaPlayer.OnCompletionListener) this);
this.s.setOnPreparedListener((MediaPlayer.OnPreparedListener) this);
this.s.setOnVideoSizeChangedListener((MediaPlayer.OnVideoSizeChangedListener) this);
this.s.setAudioStreamType(3);
this.s.prepare();
if (this.g == 0 || this.g == 1) {
(this.t = new MediaController(this.c))
.setMediaPlayer((MediaController.MediaPlayerControl) this);
this.t.setAnchorView((View) this.d);
this.t.setEnabled(true);
this.t.show();
}
} catch (Exception ex) {
if (com.unity3d.player.q.a) {
a("error: " + ex.getMessage() + ex);
}
this.onDestroy();
}
}
/**
* to play audio from assets
*
* @param audioPath
* @param context
* @param leftVolume
* @param rightVolume
*/
public static void playAudio(
String audioPath, Context context, float leftVolume, float rightVolume) {
final MediaPlayer myAudio = new MediaPlayer();
myAudio.setOnCompletionListener(
new MediaPlayer.OnCompletionListener() {
@Override
public void onCompletion(MediaPlayer mp) {
Log.d("myDebug", "myAudio.release()");
if (myAudio != null) {
myAudio.release();
}
}
});
AssetFileDescriptor afd;
try {
afd = context.getAssets().openFd(audioPath);
try {
myAudio.setDataSource(afd.getFileDescriptor(), afd.getStartOffset(), afd.getLength());
} catch (IllegalArgumentException e) {
Log.d("myDebug", "ERROR: myAudio.setDataSource()");
} catch (IllegalStateException e) {
Log.d("myDebug", "ERROR: myAudio.setDataSource()");
} catch (IOException e) {
Log.d("myDebug", "ERROR: myAudio.setDataSource()");
}
} catch (IOException e) {
Log.d("myDebug", "ERROR: afd = getAssets().openFd(audioPath)");
}
try {
myAudio.prepare();
} catch (IllegalStateException e) {
Log.d("myDebug", "ERROR: myAudio.prepare()");
} catch (IOException e) {
Log.d("myDebug", "ERROR: myAudio.prepare()");
}
myAudio.setLooping(false);
myAudio.start();
myAudio.setVolume(leftVolume, rightVolume);
}
public void playSound(Sound sound) {
int resource = sound.getResourceId();
if (mPlayer != null) {
if (mPlayer.isPlaying()) mPlayer.stop();
mPlayer.reset();
try {
AssetFileDescriptor afd = mContext.getResources().openRawResourceFd(resource);
if (afd == null) return;
mPlayer.setDataSource(afd.getFileDescriptor(), afd.getStartOffset(), afd.getLength());
afd.close();
mPlayer.prepare();
} catch (IOException | IllegalArgumentException | SecurityException e) {
Log.e(TAG, e.getMessage());
}
} else {
mPlayer = MediaPlayer.create(mContext, resource);
}
mPlayer.start();
}
public MyPlayer(AssetFileDescriptor url) {
try {
mediaPlayer.setDataSource(url.getFileDescriptor(), url.getStartOffset(), url.getLength());
mediaPlayer.prepare();
mediaPlayer.start();
System.out.println("------------------------>playing");
mediaPlayer.setOnCompletionListener(
new OnCompletionListener() {
@Override
public void onCompletion(MediaPlayer mp) {
// TODO Auto-generated method stub
mediaPlayer.stop();
mediaPlayer.release();
System.out.println("------------------------>released");
}
});
} catch (Exception e) {
// TODO: handle exception
}
}
@Override
public boolean shouldOverrideResourceLoading(MediaPlayer mediaPlayer, Context context, Uri uri) {
String scheme = uri.getScheme();
if (scheme == null) return false;
if (scheme.equals(AndroidProtocolHandler.APP_SCHEME)) {
uri = AndroidProtocolHandler.appUriToFileUri(uri);
}
scheme = uri.getScheme();
if (!scheme.equals(AndroidProtocolHandler.FILE_SCHEME)) return false;
try {
AssetFileDescriptor afd =
context.getAssets().openFd(AndroidProtocolHandler.getAssetPath(uri));
mediaPlayer.setDataSource(afd.getFileDescriptor(), afd.getStartOffset(), afd.getLength());
return true;
} catch (Exception e) {
return false;
}
}
private static AudioTrack createProgressTone(Context context) throws IOException {
AssetFileDescriptor fd = context.getResources().openRawResourceFd(R.raw.progress_tone);
int length = (int) fd.getLength();
AudioTrack audioTrack =
new AudioTrack(
AudioManager.STREAM_VOICE_CALL,
SAMPLE_RATE,
AudioFormat.CHANNEL_OUT_MONO,
AudioFormat.ENCODING_PCM_16BIT,
length,
AudioTrack.MODE_STATIC);
byte[] data = new byte[length];
readFileToBytes(fd, data);
audioTrack.write(data, 0, data.length);
audioTrack.setLoopPoints(0, data.length / 2, 30);
return audioTrack;
}
/**
* Creates the beep MediaPlayer in advance so that the sound can be triggered with the least
* latency possible.
*/
private void initBeepSound() {
if (playBeep && mediaPlayer == null) {
// The volume on STREAM_SYSTEM is not adjustable, and users found it too loud,
// so we now play on the music stream.
setVolumeControlStream(AudioManager.STREAM_MUSIC);
mediaPlayer = new MediaPlayer();
mediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
mediaPlayer.setOnCompletionListener(beepListener);
AssetFileDescriptor file = getResources().openRawResourceFd(R.raw.beep);
try {
mediaPlayer.setDataSource(
file.getFileDescriptor(), file.getStartOffset(), file.getLength());
file.close();
mediaPlayer.setVolume(BEEP_VOLUME, BEEP_VOLUME);
mediaPlayer.prepare();
} catch (IOException e) {
mediaPlayer = null;
}
}
}
@Override
public void onCreate() {
if (mp.isPlaying()) {
mp.stop();
mp.reset();
}
try {
AssetFileDescriptor afd;
afd = getAssets().openFd("BMare.mp3");
mp.setDataSource(afd.getFileDescriptor(), afd.getStartOffset(), afd.getLength());
mp.prepare();
mp.start();
} catch (IllegalStateException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
mp.setLooping(false); // Set looping
}
public static void playIntro(Context context) {
try {
if (mediaPlayer != null && mediaPlayer.isPlaying()) {
mediaPlayer.stop();
mediaPlayer.release();
}
mediaPlayer = new MediaPlayer();
AssetFileDescriptor descriptor = context.getAssets().openFd("intro.mp3");
mediaPlayer.setDataSource(
descriptor.getFileDescriptor(), descriptor.getStartOffset(), descriptor.getLength());
mediaPlayer.setAudioStreamType(AudioManager.STREAM_NOTIFICATION);
mediaPlayer.setLooping(false);
mediaPlayer.prepare();
mediaPlayer.start();
descriptor.close();
} catch (Exception e) {
e.printStackTrace();
}
}
private void initBeepSound() {
AssetFileDescriptor localAssetFileDescriptor;
if ((this.playBeep) && (this.mediaPlayer == null)) {
setVolumeControlStream(3);
this.mediaPlayer = new MediaPlayer();
this.mediaPlayer.setAudioStreamType(3);
this.mediaPlayer.setOnCompletionListener(this.beepListener);
localAssetFileDescriptor = getResources().openRawResourceFd(2131099648);
}
try {
this.mediaPlayer.setDataSource(
localAssetFileDescriptor.getFileDescriptor(),
localAssetFileDescriptor.getStartOffset(),
localAssetFileDescriptor.getLength());
localAssetFileDescriptor.close();
this.mediaPlayer.setVolume(0.1F, 0.1F);
this.mediaPlayer.prepare();
return;
} catch (IOException localIOException) {
while (true) this.mediaPlayer = null;
}
}
