Oncompletionlistener media player

public void play[] { try { final MediaPlayer mediaPlayer = new MediaPlayer[]; mediaPlayer.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { mediaPlayer.release[]; } }]; mediaPlayer.setDataSource[file.toString[]]; mediaPlayer.prepare[]; mediaPlayer.start[]; } catch [Exception e] { Log.e["carcast", "Recording.play", e]; } }

private void initPlayer[] throws Exception { streamer = new HttpMediaStreamer[mFileName, mMimeType]; Uri uri = streamer.getUri[]; mediaPlayer = new MediaPlayer[]; mediaPlayer.setAudioStreamType[AudioManager.STREAM_MUSIC]; mediaPlayer.setOnPreparedListener[new OnPreparedListener[] { @Override public void onPrepared[MediaPlayer mp] { mediaPlayer.start[]; } }]; mediaPlayer.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { killPlayer[]; } }]; mediaPlayer.setDataSource[mContext, uri]; mediaPlayer.prepareAsync[]; }

@Override protected void onCreate[Bundle savedInstanceState] { requestWindowFeature[Window.FEATURE_NO_TITLE]; getWindow[].setFlags[WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN]; setRequestedOrientation[ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE]; getWindow[].addFlags[WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON]; setContentView[R.layout.ageing_layout]; super.onCreate[savedInstanceState]; videoView = [VideoView] this.findViewById[R.id.videoView]; // MediaController mc = new MediaController[this]; // videoView.setMediaController[mc]; //Uri uri = Uri.parse["/mnt/sdcard2/video.mp4"]; //Uri uri = Uri.parse["/mnt/sdcard2/video.mp4"]; //videoView.setVideoURI[uri]; videoView.setVideoPath["android.resource://" + getPackageName[] + "/" + R.raw.video]; videoView.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { mp.start[]; } }]; // videoView.setOnErrorListener[new OnErrorListener[] { // // @Override // public boolean onError[MediaPlayer mp, int what, int extra] { // // TODO Auto-generated method stub // return true; // } // }]; videoView.requestFocus[]; videoView.start[]; // changeImage[]; this.getWindow[].setBackgroundDrawable[getResources[].getDrawable[R.drawable.water_logo]]; }

/** * This method used to play audio. * * @param url * represented audio path */ public void playAudio[String url] { if [ijoomerAudioPlayer != null] { ijoomerAudioPlayer.stopAudio[]; ijoomerAudioPlayer = null; } ijoomerAudioPlayer = this; audioPlayer = new MediaPlayer[]; audioPlayer.setOnErrorListener[new OnErrorListener[] { @Override public boolean onError[MediaPlayer mp, int what, int extra] { if [audioListener != null] { audioListener.onComplete[]; } return false; } }]; audioPlayer.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { if [audioListener != null] { audioListener.onComplete[]; } } }]; audioPlayer.setOnPreparedListener[new OnPreparedListener[] { @Override public void onPrepared[MediaPlayer mp] { audioPlayer.start[]; if [audioListener != null] { audioListener.onPrepared[]; } } }]; try { audioPlayer.setDataSource[url]; audioPlayer.prepareAsync[]; } catch [IOException e] { if [audioListener != null] { audioListener.onComplete[]; } e.printStackTrace[]; } }

@Override public void onCreate[Bundle savedInstanceState] { super.onCreate[savedInstanceState]; setContentView[R.layout.video]; final Context ctx = this; final Uri video = Uri.parse["android.resource://" + Config.release_project_name + "/raw/hockfield_150"]; videoPlayer = [VideoView] findViewById[R.id.videoView]; mediaCtrl = new MediaController[this]; mediaCtrl.setAnchorView[videoPlayer]; videoPlayer.setMediaController[mediaCtrl]; videoPlayer.setVideoURI[video]; videoPlayer.setOnErrorListener[new OnErrorListener[] { @Override public boolean onError[MediaPlayer mp, int what, int extra] { // #1 int pos = mp.getCurrentPosition[]; mp.reset[]; try { mp.setDataSource[ctx, video]; mp.prepare[]; mp.start[]; } catch [IllegalArgumentException e] { e.printStackTrace[]; } catch [SecurityException e] { e.printStackTrace[]; } catch [IllegalStateException e] { e.printStackTrace[]; } catch [IOException e] { e.printStackTrace[]; } mp.seekTo[pos]; // false causes OnCompletion return true; } }]; videoPlayer.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { // needed to avoid Froyo hang bug? mediaCtrl.setEnabled[false]; finish[]; } }]; videoPlayer.setOnPreparedListener[new OnPreparedListener[] { @Override public void onPrepared[MediaPlayer mp] { // also need to wait before starting to avoid hanging bug... mp.start[]; } }]; // maybe needed to avoid hanging? [according to one forum post] videoPlayer.setFocusable[false]; videoPlayer.setClickable[false]; }

/** * Use Media Player to play a given audio file * * @param soundFile * @throws IOException * @throws IllegalStateException */ public void play[File soundFile] { // Stop any previous playbacks stop[]; try { if [// check if the file really exists soundFile != null && soundFile.exists[]] { // Get a media player instance: mediaPlayer = MediaPlayer.create[context, Uri.fromFile[soundFile]]; // Play the sound mediaPlayer.start[]; mediaPlayer.setAudioStreamType[AudioManager.STREAM_MUSIC]; mediaPlayer.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mediaPlayer] { mediaPlayer.release[]; } }]; } } catch [Exception e] { Log.e[TAG, "Error upon playing sound file.", e]; } }

@Override protected void onCreate[Bundle savedInstanceState] { super.onCreate[savedInstanceState]; setContentView[R.layout.activity_main]; seekBar = [SeekBar] findViewById[R.id.seekBar]; seekBar.setOnSeekBarChangeListener[new OnSeekBarChangeListener[] { @Override public void onStopTrackingTouch[SeekBar seekBar] { } @Override public void onStartTrackingTouch[SeekBar seekBar] { } @Override public void onProgressChanged[SeekBar seekBar, int progress, boolean fromUser] { mediaPlayer.seekTo[progress]; } }]; mediaPlayer = MediaPlayer.create[this, R.raw.kalimba]; mediaPlayer.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { } }]; mediaPlayer.setOnErrorListener[new OnErrorListener[] { @Override public boolean onError[MediaPlayer mp, int what, int extra] { return false; } }]; mediaPlayer.setOnPreparedListener[new OnPreparedListener[] { @Override public void onPrepared[MediaPlayer mp] { seekBar.setMax[mp.getDuration[]]; mp.start[]; } }]; }

public void playVoice[byte[] mData, int playLength, int dataLength, final AudioPlayListener nowAudioPlayListener] { try { mediaPlayer.reset[]; if [lastPlayListener != null] { lastPlayListener.onAudioStop[]; } lastPlayListener = nowAudioPlayListener; nowAudioPlayListener.onAudioStart[]; File audioFile = writeAudio[mData]; mediaPlayer.setDataSource[audioFile.getAbsolutePath[]]; mediaPlayer.setOnPreparedListener[new MediaPlayer.OnPreparedListener[] { @Override public void onPrepared[MediaPlayer mp] { } }]; mediaPlayer.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { // TODO Auto-generated method stub nowAudioPlayListener.onAudioStop[]; } }]; mediaPlayer.prepare[]; mediaPlayer.start[]; } catch [Exception exception] { Log.e["play audio error", "" + exception]; } }

public MediaPlayer createPlayer[final Context ctx, File f, final Listener l] { MediaPlayer mp = MediaPlayer.create[ctx, Uri.fromFile[f]]; mp.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { try { mp.reset[]; mp.release[]; } catch [Exception e] { Log.e[TAG, "error while playing mp3", e]; } finally { if [null != l] { l.onComplete[mp, 0, 0]; } } } }]; mp.setOnErrorListener[new OnErrorListener[] { @Override public boolean onError[MediaPlayer mp, int what, int extra] { try { mp.reset[]; mp.release[]; } catch [Exception e] { Log.e[TAG, "error while playing mp3: " + what + ", " + extra, e]; } finally { if [null != l] { l.onComplete[mp, what, extra]; } } Toast.makeText[ctx, R.string.msg_error_to_play, Toast.LENGTH_SHORT].show[]; return false; } }]; return mp; }

private void playMusic[String path] { try { /* ÖØÖÃMediaPlayer */ mMediaPlayer.reset[]; /* ÉèÖÃÒª²¥·ÅµÄÎļþµÄ·¾¶ */ mMediaPlayer.setDataSource[path]; /* ×¼±¸²¥·Å */ mMediaPlayer.prepare[]; /* ¿ªÊ¼²¥·Å */ mMediaPlayer.start[]; mMediaPlayer.setOnCompletionListener[new OnCompletionListener[] { public void onCompletion[MediaPlayer arg0] { //²¥·ÅÍê³ÉÒ»Ê×Ö®ºó½øÐÐÏÂÒ»Ê× nextMusic[]; } }]; } catch [IOException e] { } }

@Override public void onCreate[] { super.onCreate[]; // Set up the Media Player mPlayer = MediaPlayer.create[this, R.raw.badnews]; if [null != mPlayer] { mPlayer.setLooping[false]; // Stop Service when music has finished playing mPlayer.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { // stop Service if it was started with this ID // Otherwise let other start commands proceed stopSelf[mStartID]; } }]; } // Create a notification area notification so the user // can get back to the MusicServiceClient final Intent notificationIntent = new Intent[getApplicationContext[], MusicServiceClient.class]; final PendingIntent pendingIntent = PendingIntent.getActivity[this, 0, notificationIntent, 0]; final Notification notification = new Notification.Builder[getApplicationContext[]].setSmallIcon[android.R.drawable.ic_media_play].setOngoing[true].setContentTitle["Music Playing"].setContentText["Click to Access Music Player"].setContentIntent[pendingIntent].build[]; // Put this Service in a foreground state, so it won't // readily be killed by the system startForeground[NOTIFICATION_ID, notification]; }

@Override public void onClick[View v] { if [URI == null] { // No audio file specified Log.e[t, "No audio file was specified"]; Toast.makeText[getContext[], getContext[].getString[R.string.audio_file_error], Toast.LENGTH_LONG].show[]; return; } String audioFilename = ""; try { audioFilename = ReferenceManager._[].DeriveReference[URI].getLocalURI[]; } catch [InvalidReferenceException e] { Log.e[t, "Invalid reference exception"]; e.printStackTrace[]; } File audioFile = new File[audioFilename]; if [!audioFile.exists[]] { // We should have an audio clip, but the file doesn't exist. String errorMsg = getContext[].getString[R.string.file_missing, audioFile]; Log.e[t, errorMsg]; Toast.makeText[getContext[], errorMsg, Toast.LENGTH_LONG].show[]; return; } // In case we're currently playing sounds. stopPlaying[]; player = new MediaPlayer[]; try { player.setDataSource[audioFilename]; player.prepare[]; player.start[]; player.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mediaPlayer] { mediaPlayer.release[]; } }]; } catch [IOException e] { String errorMsg = getContext[].getString[R.string.audio_file_invalid]; Log.e[t, errorMsg]; Toast.makeText[getContext[], errorMsg, Toast.LENGTH_LONG].show[]; e.printStackTrace[]; } }

@Override public void onClick[View v] { if [URI == null] { // No audio file specified Log.e[t, "No audio file was specified"]; Toast.makeText[getContext[], getContext[].getString[R.string.audio_file_error], Toast.LENGTH_LONG].show[]; return; } String audioFilename = ""; try { audioFilename = ReferenceManager._[].DeriveReference[URI].getLocalURI[]; } catch [InvalidReferenceException e] { Log.e[t, "Invalid reference exception"]; e.printStackTrace[]; } File audioFile = new File[audioFilename]; if [!audioFile.exists[]] { // We should have an audio clip, but the file doesn't exist. String errorMsg = getContext[].getString[R.string.file_missing, audioFile]; Log.e[t, errorMsg]; Toast.makeText[getContext[], errorMsg, Toast.LENGTH_LONG].show[]; return; } // In case we're currently playing sounds. stopPlaying[]; player = new MediaPlayer[]; try { player.setDataSource[audioFilename]; player.prepare[]; player.start[]; player.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mediaPlayer] { mediaPlayer.release[]; } }]; } catch [IOException e] { String errorMsg = getContext[].getString[R.string.audio_file_invalid]; Log.e[t, errorMsg]; Toast.makeText[getContext[], errorMsg, Toast.LENGTH_LONG].show[]; e.printStackTrace[]; } }

private void init[] { mPlaybackState = PlaybackState.STOPPED; mMediaController = new MediaController[getContext[]]; mMediaController.setAnchorView[this]; enablePlaybackControls[]; // Set OnCompletionListener to notify our callbacks when the video is completed. super.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mediaPlayer] { // Reset the MediaPlayer. // This prevents a race condition which occasionally results in the media // player crashing when switching between videos. disablePlaybackControls[]; mediaPlayer.reset[]; mediaPlayer.setDisplay[getHolder[]]; enablePlaybackControls[]; mPlaybackState = PlaybackState.STOPPED; for [PlayerCallback callback : mVideoPlayerCallbacks] { callback.onCompleted[]; } } }]; // Set OnErrorListener to notify our callbacks if the video errors. super.setOnErrorListener[new OnErrorListener[] { @Override public boolean onError[MediaPlayer mp, int what, int extra] { mPlaybackState = PlaybackState.STOPPED; for [PlayerCallback callback : mVideoPlayerCallbacks] { callback.onError[]; } // prevent the completion handler from being called. return true; } }]; }

@Override public void play[final String fileName, boolean resumeIfPlaying] { try { if [resumeIfPlaying && mediaPlayer != null && playing != null && playing.equals[fileName]] { if [!mediaPlayer.isPlaying[]] mediaPlayer.start[]; } else { if [mediaPlayer == null] { mediaPlayer = new MediaPlayer[]; } mediaPlayer.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { mediaPlayer.setOnCompletionListener[null]; prepare[fileName + "_main.mp3", true]; } }]; prepare[fileName + "_intro.mp3", false]; } } catch [Exception e] { Modules.LOG.error[TAG, e.toString[]]; } }

@Override public void onCreate[] { super.onCreate[]; // Set up the Media Player mPlayer = MediaPlayer.create[this, R.raw.badnews]; if [null != mPlayer] { mPlayer.setLooping[false]; // Stop Service when music has finished playing mPlayer.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { // stop Service if it was started with this ID // Otherwise let other start commands proceed stopSelf[mStartID]; } }]; } // Create a notification area notification so the user // can get back to the MusicServiceClient final Intent notificationIntent = new Intent[getApplicationContext[], MusicServiceClient.class]; final PendingIntent pendingIntent = PendingIntent.getActivity[this, 0, notificationIntent, 0]; final Notification notification = new Notification.Builder[getApplicationContext[]].setSmallIcon[android.R.drawable.ic_media_play].setOngoing[true].setContentTitle["Music Playing"].setContentText["Click to Access Music Player"].setContentIntent[pendingIntent].build[]; // Put this Service in a foreground state, so it won't // readily be killed by the system startForeground[NOTIFICATION_ID, notification]; }

@Override public void onClick[View v] { if [URI == null] { // No audio file specified Log.e[t, "No audio file was specified"]; Toast.makeText[getContext[], getContext[].getString[R.string.audio_file_error], Toast.LENGTH_LONG].show[]; return; } String audioFilename = ""; try { audioFilename = ReferenceManager._[].DeriveReference[URI].getLocalURI[]; } catch [InvalidReferenceException e] { Log.e[t, "Invalid reference exception"]; e.printStackTrace[]; } File audioFile = new File[audioFilename]; if [!audioFile.exists[]] { // We should have an audio clip, but the file doesn't exist. String errorMsg = getContext[].getString[R.string.file_missing, audioFile]; Log.e[t, errorMsg]; Toast.makeText[getContext[], errorMsg, Toast.LENGTH_LONG].show[]; return; } // In case we're currently playing sounds. stopPlaying[]; player = new MediaPlayer[]; try { player.setDataSource[audioFilename]; player.prepare[]; player.start[]; player.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mediaPlayer] { mediaPlayer.release[]; } }]; } catch [IOException e] { String errorMsg = getContext[].getString[R.string.audio_file_invalid]; Log.e[t, errorMsg]; Toast.makeText[getContext[], errorMsg, Toast.LENGTH_LONG].show[]; e.printStackTrace[]; } }

@Override public void onClick[View v] { Collect.getInstance[].getActivityLogger[].logInstanceAction[this, "onClick", "playAudioPrompt" + selectionDesignator, index]; if [URI == null] { // No audio file specified Log.e[t, "No audio file was specified"]; Toast.makeText[getContext[], getContext[].getString[R.string.audio_file_error], Toast.LENGTH_LONG].show[]; return; } String audioFilename = ""; try { audioFilename = ReferenceManager._[].DeriveReference[URI].getLocalURI[]; } catch [InvalidReferenceException e] { Log.e[t, "Invalid reference exception"]; e.printStackTrace[]; } File audioFile = new File[audioFilename]; if [!audioFile.exists[]] { // We should have an audio clip, but the file doesn't exist. String errorMsg = getContext[].getString[R.string.file_missing, audioFile]; Log.e[t, errorMsg]; Toast.makeText[getContext[], errorMsg, Toast.LENGTH_LONG].show[]; return; } // In case we're currently playing sounds. stopPlaying[]; player = new MediaPlayer[]; try { player.setDataSource[audioFilename]; player.prepare[]; player.start[]; player.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mediaPlayer] { mediaPlayer.release[]; } }]; } catch [IOException e] { String errorMsg = getContext[].getString[R.string.audio_file_invalid]; Log.e[t, errorMsg]; Toast.makeText[getContext[], errorMsg, Toast.LENGTH_LONG].show[]; e.printStackTrace[]; } }

public synchronized MediaPlayer get[final int soundResId] { final ArrayList existingPool = this.mPools.get[soundResId]; if [existingPool != null && existingPool.size[] > 0] { /* If there is one found, get it by removing it from the pool. * At this point, the player already got the completion listener set, * which makes it return to the pool. */ return existingPool.remove[0]; } else { /* Create a new MediaPlayer, which later will return to the pool. */ final MediaPlayer mp = MediaPlayer.create[getContext[], soundResId]; mp.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[final MediaPlayer mp] { mp.seekTo[0]; returnToPool[soundResId, mp]; completed[soundResId]; } }]; return mp; } }

private void playMedia[MediaPlayer mp, String fileName] throws IOException { File f = new File[fileName]; if [!f.canRead[]] { Toast.makeText[this, "CANNOT READ " + fileName, Toast.LENGTH_SHORT].show[]; return; } mp.setDataSource[fileName]; mp.prepare[]; Toast.makeText[this, "Start play", Toast.LENGTH_SHORT].show[]; mp.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { Toast.makeText[Main.this, "Media Play Complete", Toast.LENGTH_SHORT].show[]; } }]; mp.start[]; Toast.makeText[this, "Started OK", Toast.LENGTH_SHORT].show[]; }

/** * µ÷Ó÷½Ê½:play["across.mp3",getResources[].getAssets[]]; * @param filename Òª²¥·ÅµÄÒôƵÎļþÃû * @param asm AssetManager * @throws IOException */ public static final void play[String filename, AssetManager asm] throws IOException { //AssetManager asm = getResources[].getAssets[]; AssetFileDescriptor afd = asm.openFd[filename]; player = new MediaPlayer[]; player.setDataSource[afd.getFileDescriptor[], afd.getStartOffset[], afd.getLength[]]; player.prepare[]; player.start[]; player.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { mp.release[]; } }]; }

public void playUrl[String videoUrl] { try { mediaPlayer.reset[]; mediaPlayer.setDataSource[videoUrl]; //prepareä¹å?ŽèªåŠ¨æ­æ¾ mediaPlayer.prepare[]; mediaPlayer.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer arg0] { // TODO Auto-generated method stub skbProgress.setEnabled[true]; skbProgress.setText[totalTimes + "S"]; Toast.makeText[context, "æ­æ¾å®Œæˆ?", Toast.LENGTH_LONG].show[]; } }]; //mediaPlayer.start[]; } catch [IllegalArgumentException e] { e.printStackTrace[]; } catch [IllegalStateException e] { e.printStackTrace[]; } catch [IOException e] { e.printStackTrace[]; } }

@Override public void onCreate[Bundle icicle] { super.onCreate[icicle]; strVideoPath = this.getIntent[].getStringExtra["videoPath"]; //去æŽå¤´ä¿¡æ?¯ this.CurrentActivity = this; requestWindowFeature[Window.FEATURE_NO_TITLE]; getWindow[].setFlags[WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN]; Bundle bundle = this.getIntent[].getExtras[]; //判æ­æ机å±?å¹çšæ¹å? DisplayMetrics dm = new DisplayMetrics[]; getWindowManager[].getDefaultDisplay[].getMetrics[dm]; width = dm.widthPixels; heigh = dm.heightPixels; setContentView[R.layout.curtain]; //横å±? mVideoView = [VideoView] findViewById[R.id.videoView1]; // mVideoView.setBackgroundDrawable[getWallpaper[]]; mVideoView.setVideoPath[strVideoPath]; MediaController controller = new MediaController[this]; mVideoView.setMediaController[controller]; mVideoView.requestFocus[]; mVideoView.setOnPreparedListener[new OnPreparedListener[] { // å¼å§æ­æ¾ @Override public void onPrepared[MediaPlayer mp] { mVideoView.setBackgroundColor[Color.argb[0, 0, 255, 0]]; } }]; //æ­æ¾å®Œæ¯ mVideoView.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { } }]; }

@Override public void onCreate[Bundle savedInstanceState] { super.onCreate[savedInstanceState]; Bundle extras = getIntent[].getExtras[]; String videoUrl = extras.getString[VIDEO_URL]; boolean isOffline = extras.getBoolean[IS_OFFLINE]; requestWindowFeature[[int] Window.FEATURE_NO_TITLE]; getWindow[].setFlags[WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN]; setContentView[R.layout.video_view]; mVideoView = [VideoView] findViewById[R.id.video_view]; MediaController mc = new MediaController[this]; mVideoView.setMediaController[mc]; if [isOffline] { mVideoView.setVideoPath[ApiSyncAdapter.getOfflineMediaPath[videoUrl]]; } else { mVideoView.setVideoURI[Uri.parse[videoUrl]]; } mProgressDialog = ProgressDialog.show[this, getString[R.string.video_activity_progress_title], getString[R.string.video_activity_progress_body], true]; mVideoView.setOnPreparedListener[new OnPreparedListener[] { public void onPrepared[MediaPlayer mp] { if [mProgressDialog != null] mProgressDialog.dismiss[]; mVideoView.requestFocus[]; mp.start[]; } }]; mVideoView.setOnCompletionListener[new OnCompletionListener[] { MediaPlayer mMediaPlayer; @Override public void onCompletion[MediaPlayer mp] { mMediaPlayer = mp; AlertDialog.Builder restartDialog = new AlertDialog.Builder[VideoViewActivity.this]; restartDialog.setTitle[getString[R.string.restart_video]]; restartDialog.setMessage[getString[R.string.restart_video_message]].setCancelable[true].setPositiveButton[R.string.yes, new DialogInterface.OnClickListener[] { public void onClick[DialogInterface dialog, int id] { // Reset the video player and restart the clip mMediaPlayer.seekTo[0]; mMediaPlayer.start[]; } }].setNegativeButton[R.string.no, new DialogInterface.OnClickListener[] { public void onClick[DialogInterface dialog, int id] { // close the dialog box and go back to the guide step dialog.cancel[]; finish[]; } }]; restartDialog.create[].show[]; } }]; }

private void playMedia[MediaPlayer mp, String fileName] throws IOException { File f = new File[fileName]; if [!f.canRead[]] { Toast.makeText[this, "CANNOT READ " + fileName, Toast.LENGTH_SHORT].show[]; return; } mp.setDataSource[fileName]; mp.prepare[]; Toast.makeText[this, "Start play", Toast.LENGTH_SHORT].show[]; mp.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { Toast.makeText[Main.this, "Media Play Complete", Toast.LENGTH_SHORT].show[]; } }]; mp.start[]; Toast.makeText[this, "Started OK", Toast.LENGTH_SHORT].show[]; }

@Override protected void onPostExecute[String xml] { if [this.config.disconnect] { return; } super.onPostExecute[xml]; if [this.exception != null] { MainActivity.error[this.exception.getMessage[], this.exception, this.activity]; return; } try { MainActivity.conversation = this.response.conversation; final ChatActivity activity = [ChatActivity] this.activity; ImageView imageView = [ImageView] activity.findViewById[R.id.imageView]; final VideoView videoView = [VideoView] activity.findViewById[R.id.videoView]; View videoLayout = activity.findViewById[R.id.videoLayout]; if [MainActivity.sound && this.response.avatarActionAudio != null && this.response.avatarActionAudio.length[] > 0] { // Action audio activity.playAudio[this.response.avatarActionAudio, false, true, true]; } if [MainActivity.sound && this.response.avatarAudio != null && this.response.avatarAudio.length[] > 0] { // Background audio if [!this.response.avatarAudio.equals[activity.currentAudio]] { if [activity.audioPlayer != null] { activity.audioPlayer.stop[]; activity.audioPlayer.release[]; } activity.audioPlayer = activity.playAudio[this.response.avatarAudio, true, true, true]; } } else if [activity.audioPlayer != null] { activity.audioPlayer.stop[]; activity.audioPlayer.release[]; activity.audioPlayer = null; } if [!MainActivity.disableVideo && !activity.videoError && this.response.isVideo[]] { // Video avatar if [imageView.getVisibility[] != View.GONE || videoLayout.getVisibility[] != View.GONE] { if [imageView.getVisibility[] == View.VISIBLE] { imageView.setVisibility[View.GONE]; } if [videoLayout.getVisibility[] == View.GONE] { videoLayout.setVisibility[View.VISIBLE]; } } if [this.response.avatarAction != null && this.response.avatarAction.length[] > 0] { // Action video videoView.setOnPreparedListener[new OnPreparedListener[] { @Override public void onPrepared[MediaPlayer mp] { mp.setLooping[false]; } }]; videoView.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { activity.resetVideoErrorListener[]; videoView.setOnCompletionListener[null]; activity.playVideo[response.avatar, true]; activity.response[response]; } }]; videoView.setOnErrorListener[new OnErrorListener[] { @Override public boolean onError[MediaPlayer mp, int what, int extra] { activity.resetVideoErrorListener[]; activity.playVideo[response.avatar, true]; activity.response[response]; return true; } }]; activity.playVideo[this.response.avatarAction, false]; return; } else { activity.playVideo[this.response.avatar, true]; } } else { // Image avatar if [imageView.getVisibility[] != View.GONE || videoLayout.getVisibility[] != View.GONE] { if [imageView.getVisibility[] == View.GONE] { imageView.setVisibility[View.VISIBLE]; } if [videoLayout.getVisibility[] == View.VISIBLE] { videoLayout.setVisibility[View.GONE]; } } if [response.isVideo[]] { HttpGetImageAction.fetchImage[this.activity, MainActivity.instance.avatar, imageView]; } else { HttpGetImageAction.fetchImage[this.activity, this.response.avatar, imageView]; } } activity.response[this.response]; } catch [Exception error] { this.exception = error; MainActivity.error[this.exception.getMessage[], this.exception, this.activity]; return; } }

@Override public boolean startPlayback[String fileName] { if [TextUtils.isEmpty[fileName] || fileName.equals["null"]] { fileName = getAudioTmpFilesPath[]; } // if [!fileName.startsWith["file://"]] { // fileName = "file://" + fileName; // } log["startPlayback, fileName:" + fileName]; // if [recorderMode == ASRSession.RECORDER_MODE_JUST_ASR] { // playbackComplete[]; // releaseMediaPlayer[]; // // return true; // } mediaPlayer = createMediaPlayer[]; float volume = AppPreference.getInstance[MyApplication.getContext[]].getVolume[]; volume = volume / 100f; //0.0f-1.0f mediaPlayer.setVolume[volume, volume]; mediaPlayer.setOnErrorListener[new MediaPlayer.OnErrorListener[] { @Override public boolean onError[MediaPlayer mp, int what, int extra] { log["onError,what=" + what + ",extra=" + extra]; playerStatus = PlayerConstants.STATUS_ERROR; return false; } }]; mediaPlayer.setOnPreparedListener[new OnPreparedListener[] { @Override public void onPrepared[MediaPlayer mp] { playerStatus = PlayerConstants.STATUS_PREPARED; mediaPlayer.start[]; } }]; mediaPlayer.setAudioStreamType[AudioManager.STREAM_MUSIC]; mediaPlayer.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { playbackComplete[]; releaseMediaPlayer[]; } }]; try { String path = "file://" + getAudioTmpFilesPath[]; path = fileName; log["startPlayback,path=" + path]; mediaPlayer.setDataSource[context, Uri.parse[path]]; playerStatus = PlayerConstants.STATUS_INITIALIZED; mediaPlayer.prepareAsync[]; } catch [IllegalArgumentException e] { e.printStackTrace[]; } catch [SecurityException e] { e.printStackTrace[]; } catch [IllegalStateException e] { e.printStackTrace[]; } catch [IOException e] { e.printStackTrace[]; } return true; }

public void playTrack[final int resId, final boolean loop] { MediaPlayer mediaPlayer = MediaPlayer.create[mContext, resId]; // Not all devices support audio [i.e. watches] if [mediaPlayer != null] { mStreams.put[resId, mediaPlayer]; mediaPlayer.setLooping[loop]; mediaPlayer.setOnPreparedListener[new OnPreparedListener[] { public void onPrepared[MediaPlayer mp] { startMedia[mp]; } }]; mediaPlayer.setOnCompletionListener[new OnCompletionListener[] { public void onCompletion[MediaPlayer mp] { if [!mp.isLooping[]] { mp.release[]; mStreams.remove[resId]; } } }]; } }

public synchronized void startAudio[] { if [!mIsPlaying && [mAudioUri != null]] { mMediaPlayer = MediaPlayer.create[mContext, mAudioUri]; if [mMediaPlayer != null] { mMediaPlayer.setAudioStreamType[AudioManager.STREAM_MUSIC]; mMediaPlayer.setOnCompletionListener[new OnCompletionListener[] { public void onCompletion[MediaPlayer mp] { stopAudio[]; } }]; mMediaPlayer.setOnErrorListener[new OnErrorListener[] { public boolean onError[MediaPlayer mp, int what, int extra] { onPlaybackError[]; return true; } }]; mIsPlaying = true; mMediaPlayer.start[]; } } }

public void playMp3[int id] { if [isPlaying] return; switch[id] { case 0: audio_play = MediaPlayer.create[getBaseContext[], Uri.parse[sampleMp3]]; audio_play.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { isPlaying = false; } }]; if [!audio_play.isPlaying[]] { setDuratinSeekBar[audio_play.getDuration[]]; audio_play.start[]; isPlaying = true; } break; case 1: AssetFileDescriptor afd; audio_play = new MediaPlayer[]; audio_play.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { isPlaying = false; } }]; try { afd = getAssets[].openFd["number_song.mp3"]; audio_play.setDataSource[afd.getFileDescriptor[], afd.getStartOffset[], afd.getLength[]]; audio_play.prepare[]; setDuratinSeekBar[audio_play.getDuration[]]; audio_play.start[]; isPlaying = true; afd.close[]; } catch [IOException e] { e.printStackTrace[]; } break; case 2: audio_play = MediaPlayer.create[getBaseContext[], R.raw.three_bears]; audio_play.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { isPlaying = false; } }]; Log.d[TAG, "duration: " + audio_play.getDuration[]]; setDuratinSeekBar[audio_play.getDuration[]]; audio_play.start[]; isPlaying = true; break; } }

public synchronized void startAudio[] { if [!mIsPlaying && [mAudioUri != null]] { mMediaPlayer = MediaPlayer.create[mContext, mAudioUri]; if [mMediaPlayer != null] { mMediaPlayer.setAudioStreamType[AudioManager.STREAM_MUSIC]; mMediaPlayer.setOnCompletionListener[new OnCompletionListener[] { public void onCompletion[MediaPlayer mp] { stopAudio[]; } }]; mMediaPlayer.setOnErrorListener[new OnErrorListener[] { public boolean onError[MediaPlayer mp, int what, int extra] { onPlaybackError[]; return true; } }]; mIsPlaying = true; mMediaPlayer.start[]; } } }

/** * * @param Filename Filename * @param completion completion */ // public void startPlaying[String Filename, OnCompletionListener completion] { if [!playState] { if [mPlayer == null] { mPlayer = new MediaPlayer[]; } try { mPlayer.setDataSource[Filename]; mPlayer.prepare[]; playState = true; mPlayer.start[]; mPlayer.setOnCompletionListener[completion]; } catch [IllegalArgumentException e] { e.printStackTrace[]; } catch [SecurityException e] { e.printStackTrace[]; } catch [IllegalStateException e] { e.printStackTrace[]; } catch [IOException e] { e.printStackTrace[]; } } else { if [mPlayer.isPlaying[]] { mPlayer.stop[]; playState = false; // startPlaying[Filename]; } else { playState = false; } } }

/** * * @param Filename Filename * @param completion completion */ // public void startPlaying[String Filename, OnCompletionListener completion] { if [!playState] { if [mPlayer == null] { mPlayer = new MediaPlayer[]; } try { mPlayer.setDataSource[Filename]; mPlayer.prepare[]; playState = true; mPlayer.start[]; mPlayer.setOnCompletionListener[completion]; } catch [IllegalArgumentException e] { e.printStackTrace[]; } catch [SecurityException e] { e.printStackTrace[]; } catch [IllegalStateException e] { e.printStackTrace[]; } catch [IOException e] { e.printStackTrace[]; } } else { if [mPlayer.isPlaying[]] { mPlayer.stop[]; playState = false; // startPlaying[Filename]; } else { playState = false; } } }

public synchronized void startAudio[] { if [!mIsPlaying && [mAudioUri != null]] { mMediaPlayer = MediaPlayer.create[mContext, mAudioUri]; if [mMediaPlayer != null] { mMediaPlayer.setAudioStreamType[AudioManager.STREAM_MUSIC]; mMediaPlayer.setOnCompletionListener[new OnCompletionListener[] { public void onCompletion[MediaPlayer mp] { stopAudio[]; } }]; mMediaPlayer.setOnErrorListener[new OnErrorListener[] { public boolean onError[MediaPlayer mp, int what, int extra] { onPlaybackError[]; return true; } }]; mIsPlaying = true; mMediaPlayer.start[]; } } }

private void startPlaying[] { mPlayer = new MediaPlayer[]; mPlayer.setOnCompletionListener[new OnCompletionListener[] { public void onCompletion[MediaPlayer mp] { mStartPlaying = !mStartPlaying; stopPlaying[]; mPlayButton.setChecked[false]; mRecordButton.setEnabled[true]; mSaveButton.setEnabled[true]; } }]; try { mPlayer.setDataSource[mFileName]; mPlayer.prepare[]; mPlayer.start[]; } catch [IOException e] { Log.e[TAG, "prepare[] failed when trying to play recorded audio"]; } }

public MediaPlayer playAudio[String audio, boolean loop, boolean cache, boolean start] { try { Uri audioUri = null; if [cache] { audioUri = HttpGetVideoAction.fetchVideo[this, audio]; } if [audioUri == null] { audioUri = Uri.parse[MainActivity.connection.fetchImage[audio].toURI[].toString[]]; } final MediaPlayer audioPlayer = new MediaPlayer[]; audioPlayer.setDataSource[getApplicationContext[], audioUri]; audioPlayer.setOnErrorListener[new OnErrorListener[] { @Override public boolean onError[MediaPlayer mp, int what, int extra] { Log.wtf["Audio error", "what:" + what + " extra:" + extra]; audioPlayer.stop[]; audioPlayer.release[]; return true; } }]; audioPlayer.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { audioPlayer.release[]; } }]; audioPlayer.prepare[]; audioPlayer.setLooping[loop]; if [start] { audioPlayer.start[]; } return audioPlayer; } catch [Exception exception] { Log.wtf[exception.toString[], exception]; return null; } }

public void playAudio[Context c] { Collect.getInstance[].getActivityLogger[].logInstanceAction[this, "onClick.playAudioPrompt", selectionDesignator, index]; if [URI == null] { // No audio file specified Log.e[t, "No audio file was specified"]; Toast.makeText[c, c.getString[R.string.audio_file_error], Toast.LENGTH_LONG].show[]; return; } String audioFilename = ""; try { audioFilename = ReferenceManager._[].DeriveReference[URI].getLocalURI[]; } catch [InvalidReferenceException e] { Log.e[t, "Invalid reference exception"]; e.printStackTrace[]; } File audioFile = new File[audioFilename]; if [!audioFile.exists[]] { // We should have an audio clip, but the file doesn't exist. String errorMsg = c.getString[R.string.file_missing, audioFile]; Log.e[t, errorMsg]; Toast.makeText[c, errorMsg, Toast.LENGTH_LONG].show[]; return; } // In case we're currently playing sounds. stopPlaying[]; player = new MediaPlayer[]; try { player.setDataSource[audioFilename]; player.prepare[]; player.start[]; player.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mediaPlayer] { mediaPlayer.release[]; } }]; } catch [IOException e] { String errorMsg = c.getString[R.string.audio_file_invalid]; Log.e[t, errorMsg]; Toast.makeText[c, errorMsg, Toast.LENGTH_LONG].show[]; e.printStackTrace[]; } }

private void recoverRecorder[] { //e Log.d[TAG, "recoverRecorder"]; if [mediaPlayer != null] mediaPlayer.release[]; mediaPlayer = new MediaPlayer[]; mediaPlayer.setLooping[false]; mediaPlayer.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mediaPlayer] { Log.d[TAG, "onCompletion"]; if [onCompletionListener != null] { OnCompletionListener listener = onCompletionListener.get[]; if [listener != null] { listener.onCompletion[mediaPlayer]; } } stop[]; } }]; mediaPlayer.setOnErrorListener[new OnErrorListener[] { @Override public boolean onError[MediaPlayer mp, int what, int extra] { Log.d[TAG, "onError"]; if [onErrorListener != null] { OnErrorListener listener = onErrorListener.get[]; if [listener != null] { listener.onError[mp, what, extra]; } } recoverRecorder[]; return false; } }]; }

public void defaultPlayer[String url] { setContentView[R.layout.player]; final VideoView videoView = [VideoView] findViewById[R.id.video_view]; final ProgressBar progressBar = [ProgressBar] findViewById[R.id.progress_bar]; progressBar.setVisibility[View.VISIBLE]; videoView.setOnPreparedListener[new android.media.MediaPlayer.OnPreparedListener[] { @Override public void onPrepared[android.media.MediaPlayer mp] { progressBar.setVisibility[View.INVISIBLE]; videoView.start[]; } }]; videoView.setOnErrorListener[new android.media.MediaPlayer.OnErrorListener[] { @Override public boolean onError[android.media.MediaPlayer mp, int what, int extra] { Log.d[TAG, "onError"]; if [retry >= 2] { video = null; switch[cartoon.service] { case "youtube": playYouTube[]; break; case "dailymotion": playDailyMotion[]; break; case "vimeo": playVimeo[]; break; } } else { Log.d[TAG, "retry " + String.valueOf[retry]]; new ExtractTask[].execute[cartoon.service, cartoon.id]; } return true; } }]; videoView.setOnCompletionListener[new android.media.MediaPlayer.OnCompletionListener[] { @Override public void onCompletion[android.media.MediaPlayer mediaPlayer] { onBackPressed[]; } }]; MediaController mediaController = new MediaController[this]; mediaController.setAnchorView[videoView]; mediaController.setMediaPlayer[videoView]; videoView.setKeepScreenOn[true]; videoView.setMediaController[mediaController]; videoView.setVideoURI[Uri.parse[url]]; videoView.requestFocus[]; }

@Override protected Void doInBackground[Void... params] { try { final MediaPlayer mPlayer = new MediaPlayer[]; mPlayer.setDataSource[file.getAbsolutePath[]]; mPlayer.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { mPlayer.release[]; } }]; mPlayer.prepare[]; mPlayer.start[]; } catch [IOException ioe] { Log.w[LOG_TAG, "failed to play audio file:" + file]; } return null; }

/** Called when the activity is first created. */ @Override public void onCreate[Bundle savedInstanceState] { super.onCreate[savedInstanceState]; vv = new VideoView[this]; setContentView[vv]; progressDialog = ProgressDialog.show[this, "åŠè½½æ°æ?®...", "请è?心ç­å¾...", true, false]; vv.setOnErrorListener[new OnErrorListener[] { @Override public boolean onError[MediaPlayer mp, int what, int extra] { vv.stopPlayback[]; new AlertDialog.Builder[VideoPlayerActivity.this].setTitle["对ä¸?èµ·"].setMessage["æ¨ææ­çšè§é¢æ¼å¼?ä¸?正确，æ­æ¾å·²å?œæ­¢ã"].setPositiveButton["知é?äº", new AlertDialog.OnClickListener[] { @Override public void onClick[DialogInterface dialog, int which] { vv.stopPlayback[]; } }].setCancelable[false].show[]; return false; } }]; vv.setOnPreparedListener[new OnPreparedListener[] { @Override public void onPrepared[MediaPlayer mp] { handler.sendEmptyMessage[0]; } }]; vv.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { CommunalData.is_vedio = true; finish[]; } }]; vv.setMySizeChangeLinstener[new MySizeChangeLinstener[] { @Override public void doMyThings[] { // TODO Auto-generated method stub setVideoScale[SCREEN_FULL]; } }]; getScreenSize[]; System.out.println["å¼å§åŠè½½"]; String s = "//forum.ea3w.com/coll_ea3w/attach/2008_10/12237832415.3gp"; vv.setVideoURI[Uri.parse[s]]; }

/** * æ­æ¾æŠ¥è­¦éŸ³ä¹? * * @param context */ private void playAlarm[Context context] { final AudioManager mAudioManager = [AudioManager] context.getSystemService[Context.AUDIO_SERVICE]; final int currentVolume = mAudioManager.getStreamVolume[AudioManager.STREAM_MUSIC]; mAudioManager.setStreamVolume[AudioManager.STREAM_MUSIC, mAudioManager.getStreamMaxVolume[AudioManager.STREAM_MUSIC], AudioManager.FLAG_PLAY_SOUND]; Logger.i[TAG, "æ­æ¾æŠ¥è­¦éŸ³ä¹?"]; MediaPlayer player = MediaPlayer.create[context, R.raw.alarm]; player.setLooping[false]; player.start[]; player.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { mAudioManager.setStreamVolume[AudioManager.STREAM_MUSIC, currentVolume, AudioManager.FLAG_PLAY_SOUND]; } }]; }

private void start[String url] throws IOException { Log.d[TAG, "start : enter"]; Log.i[TAG, "start : url=" + url]; mp.reset[]; mp.setDataSource[url]; mp.prepare[]; mp.start[]; mp.setOnCompletionListener[new OnCompletionListener[] { public void onCompletion[MediaPlayer arg0] { clearNotification[]; // 1 second handler.postDelayed[// 1 second sendUpdatesToUI, // 1 second 1000]; } }]; Log.d[TAG, "start : exit"]; }

private void initView[] { mVideoView.setMediaController[new MediaController[this]]; // height to calculate the ratio if [!isLandScape[this]] { mVideoView.setRealHeight[[int] DenstyUtil.convertDpToPixel[240, VideoViewActivity.this]]; } mVideoView.setVideoPath[path]; // pb.setVisibility[View.VISIBLE]; mVideoView.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { // mVideoView.setVideoPath["mnt/sdcard/1.mp4"]; // pb.setVisibility[View.VISIBLE]; } }]; // mVideoView.setOnPreparedListener[new OnPreparedListener[] { // // @Override // public void onPrepared[MediaPlayer mp] { // pb.setVisibility[View.GONE]; // } // }]; mVideoView.setOnStateChangeListener[new OnStateChangeListener[] { @Override public void stateChange[State state] { if [state == State.STATE_PREPARING] { showLoadingView[]; } else if [state == State.STATE_PREPARED] { hideLoadingView[]; } else if [state == State.STATE_ERROR] { hideLoadingView[]; } } }]; }

public Music play[Context context, List list, int position] { // å¦æžœæœæ­£åœ¨æ­æ¾çšæ­Œæ²ï¼Œå°å®ƒå?œæ­¢ if [playing == Config.PLAYING_PLAY] { media.reset[]; } media = MediaPlayer.create[context, Uri.parse["file://" + list.get[position].getPath[]]]; try { media.start[]; this.list = list; this.position = position; this.context = context; media.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { Player.this.context.sendBroadcast[new Intent[Config.RECEIVER_MUSIC_CHANGE]]; completion[Player.this.context, Player.this.list, Player.this.position]; } }]; playing = Config.PLAYING_PLAY; context.sendBroadcast[new Intent[Config.RECEIVER_MUSIC_CHANGE]]; } catch [NullPointerException e] { ViewInject.toast["亲，æ¾ä¸?到歌æ²äºï¼Œå­˜å¨å?¡ææŽäºå?？"]; } return list.get[position]; }

/** * Sets a callback to be called upon completion of playing the episode. */ void setOnCompletionCallback[final Callback callback] { mediaPlayer.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { // set the play state to "finished" as well before we call the callback if [episode != null] { episode.setPlayState[PlayState.FINISHED]; episode.setSeekLocation[mediaPlayer.getCurrentPosition[]]; } prepared = false; callback.call[null]; } }]; }

public void playAudio[Context c] { Collect.getInstance[].getActivityLogger[].logInstanceAction[this, "onClick.playAudioPrompt", selectionDesignator, index]; if [URI == null] { // No audio file specified Log.e[t, "No audio file was specified"]; Toast.makeText[c, c.getString[R.string.audio_file_error], Toast.LENGTH_LONG].show[]; return; } String audioFilename = ""; try { audioFilename = ReferenceManager._[].DeriveReference[URI].getLocalURI[]; } catch [InvalidReferenceException e] { Log.e[t, "Invalid reference exception"]; e.printStackTrace[]; } File audioFile = new File[audioFilename]; if [!audioFile.exists[]] { // We should have an audio clip, but the file doesn't exist. String errorMsg = c.getString[R.string.file_missing, audioFile]; Log.e[t, errorMsg]; Toast.makeText[c, errorMsg, Toast.LENGTH_LONG].show[]; return; } // In case we're currently playing sounds. stopPlaying[]; player = new MediaPlayer[]; try { player.setDataSource[audioFilename]; player.prepare[]; player.start[]; player.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mediaPlayer] { mediaPlayer.release[]; } }]; } catch [IOException e] { String errorMsg = c.getString[R.string.audio_file_invalid]; Log.e[t, errorMsg]; Toast.makeText[c, errorMsg, Toast.LENGTH_LONG].show[]; e.printStackTrace[]; } }

/** * * @param Filename Filename * @param completion completion */ // public void startPlaying[String Filename, OnCompletionListener completion] { if [!playState] { if [mPlayer == null] { mPlayer = new MediaPlayer[]; } try { mPlayer.setDataSource[Filename]; mPlayer.prepare[]; playState = true; mPlayer.start[]; mPlayer.setOnCompletionListener[completion]; } catch [IllegalArgumentException e] { e.printStackTrace[]; } catch [SecurityException e] { e.printStackTrace[]; } catch [IllegalStateException e] { e.printStackTrace[]; } catch [IOException e] { e.printStackTrace[]; } } else { if [mPlayer.isPlaying[]] { mPlayer.stop[]; playState = false; // startPlaying[Filename]; } else { playState = false; } } }

@Override protected void initialiseView[Bundle savedInstanceState] { setContentView[R.layout.audio_video_viewer]; // guaranteed to exist and not to be null File mediaFile = getCurrentMediaFile[]; // can't play from private data directory, and can't use file descriptors like we do for narratives; instead, // copy to temp before playback [this will take a *long* time] File publicFile = mediaFile; if [IOUtilities.isInternalPath[mediaFile.getAbsolutePath[]]] { try { if [MediaTablet.DIRECTORY_TEMP != null] { publicFile = new File[MediaTablet.DIRECTORY_TEMP, mediaFile.getName[]]; IOUtilities.copyFile[mediaFile, publicFile]; IOUtilities.setFullyPublic[publicFile]; } else { throw new IOException[]; } } catch [IOException e] { UIUtilities.showToast[AudioVideoViewerActivity.this, R.string.error_loading_media]; finish[]; return; } } mControllerPrepared = false; mMediaPrepared = false; mVideoAudioPlayer = [VideoView] findViewById[R.id.media_audio_video]; mVideoAudioPlayer.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { if [mControllerPrepared] { mMediaController.show[0]; } } }]; mVideoAudioPlayer.setOnPreparedListener[new OnPreparedListener[] { @Override public void onPrepared[MediaPlayer mp] { mMediaPrepared = true; startPlayer[]; } }]; mVideoAudioPlayer.setVideoURI[Uri.fromFile[publicFile]]; mMediaController = new CustomMediaController[this]; RelativeLayout parentLayout = [RelativeLayout] findViewById[R.id.audio_video_view_parent]; RelativeLayout.LayoutParams controllerLayout = new RelativeLayout.LayoutParams[RelativeLayout.LayoutParams.MATCH_PARENT, RelativeLayout.LayoutParams.WRAP_CONTENT]; controllerLayout.addRule[RelativeLayout.ALIGN_PARENT_BOTTOM]; parentLayout.addView[mMediaController, controllerLayout]; if [getCurrentMediaType[] == MediaTabletProvider.TYPE_AUDIO] { View audioBackground = findViewById[R.id.media_audio_image]; audioBackground.setVisibility[View.VISIBLE]; mMediaController.setAnchorView[audioBackground]; } else { mMediaController.setAnchorView[findViewById[R.id.media_audio_video]]; } mControllerPrepared = true; }

public void playAudio[Context c] { Collect.getInstance[].getActivityLogger[].logInstanceAction[this, "onClick.playAudioPrompt", selectionDesignator, index]; if [URI == null] { // No audio file specified Log.e[t, "No audio file was specified"]; Toast.makeText[c, c.getString[R.string.audio_file_error], Toast.LENGTH_LONG].show[]; return; } String audioFilename = ""; try { audioFilename = ReferenceManager._[].DeriveReference[URI].getLocalURI[]; } catch [InvalidReferenceException e] { Log.e[t, "Invalid reference exception"]; e.printStackTrace[]; } File audioFile = new File[audioFilename]; if [!audioFile.exists[]] { // We should have an audio clip, but the file doesn't exist. String errorMsg = c.getString[R.string.file_missing, audioFile]; Log.e[t, errorMsg]; Toast.makeText[c, errorMsg, Toast.LENGTH_LONG].show[]; return; } // In case we're currently playing sounds. stopPlaying[]; player = new MediaPlayer[]; try { player.setDataSource[audioFilename]; player.prepare[]; player.start[]; player.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mediaPlayer] { mediaPlayer.release[]; } }]; } catch [IOException e] { String errorMsg = c.getString[R.string.audio_file_invalid]; Log.e[t, errorMsg]; Toast.makeText[c, errorMsg, Toast.LENGTH_LONG].show[]; e.printStackTrace[]; } }

public synchronized void playBeepSoundAndVibrate[OnCompletionListener listener] { if [playBeep && mediaPlayer != null] { mediaPlayer.start[]; mediaPlayer.setOnCompletionListener[listener]; } if [vibrate] { Vibrator vibrator = [Vibrator] activity.getSystemService[Context.VIBRATOR_SERVICE]; vibrator.vibrate[VIBRATE_DURATION]; } }

public synchronized void startAudio[] { if [!mIsPlaying && [mAudioUri != null]] { mMediaPlayer = MediaPlayer.create[mContext, mAudioUri]; if [mMediaPlayer != null] { mMediaPlayer.setAudioStreamType[AudioManager.STREAM_MUSIC]; mMediaPlayer.setOnCompletionListener[new OnCompletionListener[] { public void onCompletion[MediaPlayer mp] { stopAudio[]; } }]; mMediaPlayer.setOnErrorListener[new OnErrorListener[] { public boolean onError[MediaPlayer mp, int what, int extra] { onPlaybackError[]; return true; } }]; mIsPlaying = true; mMediaPlayer.start[]; } } }

public synchronized void startAudio[] { if [!mIsPlaying && [mAudioUri != null]] { mMediaPlayer = MediaPlayer.create[mContext, mAudioUri]; if [mMediaPlayer != null] { mMediaPlayer.setAudioStreamType[AudioManager.STREAM_MUSIC]; mMediaPlayer.setOnCompletionListener[new OnCompletionListener[] { public void onCompletion[MediaPlayer mp] { stopAudio[]; } }]; mMediaPlayer.setOnErrorListener[new OnErrorListener[] { public boolean onError[MediaPlayer mp, int what, int extra] { onPlaybackError[]; return true; } }]; mIsPlaying = true; mMediaPlayer.start[]; } } }

public synchronized void startAudio[] { if [!mIsPlaying && [mAudioUri != null]] { mMediaPlayer = MediaPlayer.create[mContext, mAudioUri]; if [mMediaPlayer != null] { mMediaPlayer.setAudioStreamType[AudioManager.STREAM_MUSIC]; mMediaPlayer.setOnCompletionListener[new OnCompletionListener[] { public void onCompletion[MediaPlayer mp] { stopAudio[]; } }]; mMediaPlayer.setOnErrorListener[new OnErrorListener[] { public boolean onError[MediaPlayer mp, int what, int extra] { onPlaybackError[]; return true; } }]; mIsPlaying = true; mMediaPlayer.start[]; } } }

private void startPlaying[] { mPlayer = new MediaPlayer[]; try { mPlayer.setDataSource[mCurrentCryPath]; mPlayer.prepare[]; mPlayer.start[]; mPlayer.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer arg0] { stopPlaying[]; } }]; vPlay.setImageBitmap[bStop]; isPlaying = true; } catch [IOException e] { Log.e["", "prepare[] failed"]; } }

public synchronized void startAudio[] { if [!mIsPlaying && [mAudioUri != null]] { mMediaPlayer = MediaPlayer.create[mContext, mAudioUri]; if [mMediaPlayer != null] { mMediaPlayer.setAudioStreamType[AudioManager.STREAM_MUSIC]; mMediaPlayer.setOnCompletionListener[new OnCompletionListener[] { public void onCompletion[MediaPlayer mp] { stopAudio[]; } }]; mMediaPlayer.setOnErrorListener[new OnErrorListener[] { public boolean onError[MediaPlayer mp, int what, int extra] { onPlaybackError[]; return true; } }]; mIsPlaying = true; mMediaPlayer.start[]; } } }

@Override public void onShowCustomView[View view, CustomViewCallback callback] { super.onShowCustomView[view, callback]; if [view instanceof FrameLayout] { FrameLayout frame = [FrameLayout] view; if [frame.getFocusedChild[] instanceof VideoView] { VideoView video = [VideoView] frame.getFocusedChild[]; video.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { mp.stop[]; } }]; frame.removeView[video]; /* * a.setContentView[video]; * video.setOnCompletionListener[this]; * video.setOnErrorListener[this]; video.start[]; */ } } }

/** * Make the device ring. */ public static void ring[Context context] throws ActionExecutionFailedException, InterruptedException { final Uri ringtoneUri = RingtoneManager.getActualDefaultRingtoneUri[context, RingtoneManager.TYPE_RINGTONE]; final MediaPlayer player = new MediaPlayer[]; player.setAudioStreamType[AudioManager.STREAM_RING]; try { player.setDataSource[context, ringtoneUri]; } catch [IOException e] { throw new ActionExecutionFailedException["Failed to initialize MediaPlayer for " + ringtoneUri, e]; } try { player.prepare[]; } catch [IOException e] { throw new ActionExecutionFailedException["Failed to prepare MediaPlayer for " + ringtoneUri, e]; } final CountDownLatch barrier = new CountDownLatch[1]; player.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { barrier.countDown[]; } }]; try { player.start[]; barrier.await[]; } finally { barrier.countDown[]; player.release[]; } }

public void playAudio[Context c] { Collect.getInstance[].getActivityLogger[].logInstanceAction[this, "onClick.playAudioPrompt", selectionDesignator, index]; if [URI == null] { // No audio file specified Log.e[t, "No audio file was specified"]; Toast.makeText[c, c.getString[R.string.audio_file_error], Toast.LENGTH_LONG].show[]; return; } String audioFilename = ""; try { audioFilename = ReferenceManager._[].DeriveReference[URI].getLocalURI[]; } catch [InvalidReferenceException e] { Log.e[t, "Invalid reference exception"]; e.printStackTrace[]; } File audioFile = new File[audioFilename]; if [!audioFile.exists[]] { // We should have an audio clip, but the file doesn't exist. String errorMsg = c.getString[R.string.file_missing, audioFile]; Log.e[t, errorMsg]; Toast.makeText[c, errorMsg, Toast.LENGTH_LONG].show[]; return; } // In case we're currently playing sounds. stopPlaying[]; player = new MediaPlayer[]; try { player.setDataSource[audioFilename]; player.prepare[]; player.start[]; player.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mediaPlayer] { mediaPlayer.release[]; } }]; } catch [IOException e] { String errorMsg = c.getString[R.string.audio_file_invalid]; Log.e[t, errorMsg]; Toast.makeText[c, errorMsg, Toast.LENGTH_LONG].show[]; e.printStackTrace[]; } }

public synchronized void startAudio[] { if [!mIsPlaying && [mAudioUri != null]] { mMediaPlayer = MediaPlayer.create[mContext, mAudioUri]; if [mMediaPlayer != null] { mMediaPlayer.setAudioStreamType[AudioManager.STREAM_MUSIC]; mMediaPlayer.setOnCompletionListener[new OnCompletionListener[] { public void onCompletion[MediaPlayer mp] { stopAudio[]; } }]; mMediaPlayer.setOnErrorListener[new OnErrorListener[] { public boolean onError[MediaPlayer mp, int what, int extra] { onPlaybackError[]; return true; } }]; mIsPlaying = true; mMediaPlayer.start[]; } } }

public synchronized void startAudio[] { if [!mIsPlaying && [mAudioUri != null]] { mMediaPlayer = MediaPlayer.create[this.getContext[], mAudioUri]; if [mMediaPlayer != null] { mMediaPlayer.setAudioStreamType[AudioManager.STREAM_MUSIC]; mMediaPlayer.setOnCompletionListener[new OnCompletionListener[] { public void onCompletion[MediaPlayer mp] { stopAudio[]; } }]; mMediaPlayer.setOnErrorListener[new OnErrorListener[] { public boolean onError[MediaPlayer mp, int what, int extra] { onPlaybackError[]; return true; } }]; mIsPlaying = true; mMediaPlayer.start[]; } } }

public void setPlayerSourcceAndPrepare[MediaPlayer player, Uri source, final boolean playAtBeginning] throws IllegalArgumentException, SecurityException, IllegalStateException, IOException { this.mediaPlayer = player; Log.d[TAG, "setPlayerSourcceAndPrepare: " + source]; mediaPlayer = new MediaPlayer[]; //@bruce add for fix some devices will prepare error File file = new File[source.getPath[]]; FileInputStream fis = new FileInputStream[file]; mediaPlayer.setDataSource[fis.getFD[]]; // mediaPlayer.setDataSource[getContext[], source]; mediaPlayer.prepare[]; mediaPlayer.setOnPreparedListener[new OnPreparedListener[] { @Override public void onPrepared[MediaPlayer mp] { isPrepared = true; setDuration[mp.getDuration[]]; if [playAtBeginning] { mp.start[]; setPlayingState[true]; } } }]; mediaPlayer.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { stopTimeUpdate[]; setDurationText[durationText]; setPlayingState[false]; } }]; mediaPlayer.setOnErrorListener[new MediaPlayer.OnErrorListener[] { @Override public boolean onError[MediaPlayer mp, int what, int extra] { Log.d[TAG, "mediaPlayer onError what: " + what]; return false; } }]; }

public void initPlayer[] throws Exception { info.guardianproject.iocipher.File fileStream = new info.guardianproject.iocipher.File[mFileName]; if [mediaPlayer != null] { if [mediaPlayer.isPlaying[]] mediaPlayer.stop[]; mediaPlayer.release[]; mediaPlayer = null; } mediaPlayer = new MediaPlayer[]; mediaPlayer.setAudioStreamType[AudioManager.STREAM_MUSIC]; if [fileStream.exists[]] { streamer = new HttpMediaStreamer[fileStream, mMimeType]; Uri uri = streamer.getUri[]; mediaPlayer.setDataSource[mContext, uri]; } else { mediaPlayer.setDataSource[mFileName]; } mediaPlayer.setOnErrorListener[new MediaPlayer.OnErrorListener[] { @Override public boolean onError[MediaPlayer mediaPlayer, int i, int i1] { Log.d["AudioPlayer", "there was an error loading music: " + i + " " + i1]; return true; } }]; mediaPlayer.setOnPreparedListener[new OnPreparedListener[] { @Override public void onPrepared[MediaPlayer mp] { mPrepared = true; mDuration = mediaPlayer.getDuration[]; mInfoView.setText[[getDuration[] / 1000] + "secs"]; if [mPlayOnPrepare] play[]; } }]; mediaPlayer.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { if [mVisualizer != null] mVisualizer.setEnabled[false]; } }]; mediaPlayer.prepareAsync[]; }

private void setupControlsCallbacks[] { mVideoView.setOnErrorListener[new OnErrorListener[] { @Override public boolean onError[MediaPlayer mp, int what, int extra] { mVideoView.stopPlayback[]; mPlaybackState = PlaybackState.IDLE; return false; } }]; mVideoView.setOnPreparedListener[new OnPreparedListener[] { @Override public void onPrepared[MediaPlayer mp] { mDuration = mp.getDuration[]; mEndText.setText[Utils.formatMillis[mDuration]]; mSeekbar.setMax[mDuration]; restartSeekBarTimer[]; } }]; mVideoView.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { stopSeekBarTimer[]; mPlaybackState = PlaybackState.IDLE; updatePlayButton[PlaybackState.IDLE]; mControllersTimer = new Timer[]; mControllersTimer.schedule[new BackToDetailTask[], getResources[].getInteger[R.integer.time_to_hide_controller]]; } }]; }

private void setupControlsCallbacks[] { mVideoView.setOnErrorListener[new OnErrorListener[] { @Override public boolean onError[MediaPlayer mp, int what, int extra] { mVideoView.stopPlayback[]; mPlaybackState = PlaybackState.IDLE; return false; } }]; mVideoView.setOnPreparedListener[new OnPreparedListener[] { @Override public void onPrepared[MediaPlayer mp] { mDuration = mp.getDuration[]; mEndText.setText[Utils.formatMillis[mDuration]]; mSeekbar.setMax[mDuration]; restartSeekBarTimer[]; } }]; mVideoView.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { stopSeekBarTimer[]; mPlaybackState = PlaybackState.IDLE; updatePlayButton[PlaybackState.IDLE]; mControllersTimer = new Timer[]; mControllersTimer.schedule[new BackToDetailTask[], getResources[].getInteger[R.integer.time_to_hide_controller]]; } }]; }

public void run[] { myLabel.setText[data]; System.out.println["" + data.length[]]; char c = data.charAt[0]; switch[c] { case 'a': System.out.println[c]; mpHiHat.start[]; tvHiHat.setTextColor[Color.YELLOW]; tvBass.setTextColor[Color.WHITE]; tvCrash.setTextColor[Color.WHITE]; tvRide.setTextColor[Color.WHITE]; tvSnare.setTextColor[Color.WHITE]; tvTomMid.setTextColor[Color.WHITE]; mpHiHat.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { // TODO Auto-generated method stub tvHiHat.setTextColor[Color.WHITE]; } }]; break; case 'b': System.out.println[c]; mpBass.start[]; tvBass.setTextColor[Color.YELLOW]; tvHiHat.setTextColor[Color.WHITE]; tvCrash.setTextColor[Color.WHITE]; tvRide.setTextColor[Color.WHITE]; tvSnare.setTextColor[Color.WHITE]; tvTomMid.setTextColor[Color.WHITE]; mpBass.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { // TODO Auto-generated method stub tvBass.setTextColor[Color.WHITE]; } }]; break; case 'q': System.out.println[c]; mpTomMid.start[]; tvTomMid.setTextColor[Color.YELLOW]; tvBass.setTextColor[Color.WHITE]; tvCrash.setTextColor[Color.WHITE]; tvRide.setTextColor[Color.WHITE]; tvSnare.setTextColor[Color.WHITE]; tvHiHat.setTextColor[Color.WHITE]; mpTomMid.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { // TODO Auto-generated method stub tvTomMid.setTextColor[Color.WHITE]; } }]; break; } }

@Override protected void onResume[] { surfaceView = [SurfaceView] this.findViewById[R.id.surface]; surfaceView.setOnTouchListener[new OnTouchListener[] { @Override public boolean onTouch[View v, MotionEvent event] { // å¤ç?å?Œå»äºä»¶ gd.onTouchEvent[event]; return true; } }]; mediaPlayer = new MediaPlayer[]; SurfaceHolder holder = surfaceView.getHolder[]; height = getWindowManager[].getDefaultDisplay[].getHeight[]; holder.addCallback[new SurfaceCallback[]]; surfaceView.setFocusable[true]; surfaceView.requestFocus[]; mediaPlayer.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { next[]; } }]; videobar.setOnSeekBarChangeListener[new OnSeekBarChangeListener[] { @Override public void onProgressChanged[SeekBar seekBar, int progress, boolean fromUser] { pos.setText[StringUtils.TimeFormat[progress]]; } @Override public void onStartTrackingTouch[SeekBar seekBar] { // TODO Auto-generated method stub } @Override public void onStopTrackingTouch[SeekBar seekBar] { mediaPlayer.seekTo[seekBar.getProgress[]]; } }]; super.onResume[]; }

public void init[java.io.File recordingFile, final OnCompletionListener ocl] { this.recordingFile = recordingFile; mr.setOutputFile[recordingFile.getAbsolutePath[]]; mp = new MediaPlayer[]; mp.setOnInfoListener[this]; h.post[new Runnable[] { @Override public void run[] { if [isPlaying] { if [mp.getCurrentPosition[] >= mp.getDuration[]] { pause[]; mp.seekTo[0]; return; } setProgress[mp.getCurrentPosition[] / 1000]; } h.postDelayed[this, 1000L]; } }]; if [ocl != null] { mp.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { if [hasPlayedOnce] { ocl.onCompletion[mp]; } } }]; } }

public void handlePlaySoundButton[View v] { final int position = [Integer] v.getTag[]; final SoundInfo soundInfo = soundInfoList.get[position]; stopSound[soundInfo]; startSound[soundInfo]; mediaPlayer.setOnCompletionListener[new OnCompletionListener[] { public void onCompletion[MediaPlayer mp] { soundInfo.isPlaying = false; soundInfo.isPaused = false; [[SoundAdapter] getListAdapter[]].notifyDataSetChanged[]; } }]; [[SoundAdapter] getListAdapter[]].notifyDataSetChanged[]; }

public void playNextSelectItem[] { if [!this.isShown[]] { return; } // if there's more, set up to play the next item if [playcounter < playList.size[]] { player.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mediaPlayer] { resetQuestionTextColor[]; mediaPlayer.reset[]; playNextSelectItem[]; } }]; // play the current item playList.get[playcounter].playAudio[]; playcounter++; } else { playcounter = 0; player.setOnCompletionListener[null]; player.reset[]; } }

@Override public void onClick[View v] { String audioFilename = preprocessClick[]; if ["".equals[audioFilename]] return; switch[currentState] { case Ready: MediaPlayer player = new MediaPlayer[]; try { player.setDataSource[audioFilename]; player.prepare[]; player.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mediaPlayer] { endPlaying[]; } }]; controller.setCurrent[new MediaEntity[URI, player, residingViewId, currentState], this]; startPlaying[]; } catch [IOException e] { String errorMsg = getContext[].getString[R.string.audio_file_invalid]; Log.e[t, errorMsg]; Toast.makeText[getContext[], errorMsg, Toast.LENGTH_LONG].show[]; e.printStackTrace[]; } break; case PausedForRenewal: case Paused: startPlaying[]; break; case Playing: pausePlaying[]; break; } }

protected void palyAudio[] { // æ­æ¾å½éŸ³ if [recorderPath == null] { T.show[context, "æ¾ä¸?到å½éŸ³æ件"]; return; } if [player == null] player = new MediaPlayer[]; player.reset[]; try { player.setDataSource[recorderPath]; player.prepare[]; player.seekTo[curPosition]; player.start[]; pb.setMax[player.getDuration[]]; // ç§++ if [timer_play == null] timer_play = new Timer[]; timer_play.schedule[new TimerTask[] { @Override public void run[] { [[Activity] context].runOnUiThread[new Runnable[] { public void run[] { Log.e[" timer_play.schedule", curPosition + ""]; if [tv_time == null] L.e["tv_time空空空空"]; tv_time.setText[[player.getCurrentPosition[] / 1000] + "ç§"]; pb.setProgress[player.getCurrentPosition[]]; } }]; } }, new Date[], 1000]; } catch [Exception e] { e.printStackTrace[]; T.show[context, "æ­æ¾åºé"]; } player.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { Log.i["player", "OnCompletionListener"]; if [timer_play != null] { timer_play.cancel[]; timer_play = null; } ib_play.setImageResource[R.drawable.play_audio]; ib_play.setTag["play"]; pb.setProgress[0]; curPosition = 0; } }]; }

public void handlePlaySoundButton[View v] { final int position = [Integer] v.getTag[]; final SoundInfo soundInfo = soundInfoList.get[position]; stopSound[soundInfo]; startSound[soundInfo]; mediaPlayer.setOnCompletionListener[new OnCompletionListener[] { public void onCompletion[MediaPlayer mp] { soundInfo.isPlaying = false; soundInfo.isPaused = false; [[SoundAdapter] getListAdapter[]].notifyDataSetChanged[]; } }]; [[SoundAdapter] getListAdapter[]].notifyDataSetChanged[]; }

@Override public void run[] { Log.w["PlayAllAudioAction", objData.optString["feedName"]]; byte bytes[] = Base64.decode[objData.optString[VoiceObj.DATA], Base64.DEFAULT]; File file = new File[getTempFilename[]]; try { OutputStream os = new FileOutputStream[file]; BufferedOutputStream bos = new BufferedOutputStream[os]; bos.write[bytes, 0, bytes.length]; bos.flush[]; bos.close[]; copyWaveFile[getTempFilename[], getFilename[]]; deleteTempFile[]; mp = new MediaPlayer[]; mp.setDataSource[getFilename[]]; mp.setOnCompletionListener[new OnCompletionListener[] { public void onCompletion[MediaPlayer m] { Log.w["PlayAllAudioAction", "finished"]; c.moveToNext[]; playNextSong[]; } }]; mp.prepare[]; mp.start[]; } catch [Exception e] { e.printStackTrace[]; } }

@Override protected void loadAppLevelData[Activity activity, AppLevelData data] { item = [AudioLevelDataItem] data.findByNextLevel[nextLevel]; audioBar = [SeekBar] activity.findViewById[R.id.seekBarAudio]; playPause = [ImageButton] activity.findViewById[R.id.playPauseButton]; prev = [ImageButton] activity.findViewById[R.id.prevButton]; next = [ImageButton] activity.findViewById[R.id.nextButton]; mp = new MediaPlayer[]; handler = new Handler[]; this.activity = activity; initializeHeader[activity, item]; //Create Banner CreateMenus c = [CreateMenus] activity; c.createBanner[]; //Audio Image ImageView audioImage = [ImageView] activity.findViewById[R.id.imageAudio]; if [item.getImage[] != null] { try { audioImage.setImageDrawable[ImagesUtils.getDrawable[activity, item.getImage[]]]; } catch [InvalidFileException e1] { e1.printStackTrace[]; } } //Lyrics if [item.getLyrics[] != null] { TextView lyrics = [TextView] activity.findViewById[R.id.lyrics]; lyrics.setText[item.getLyrics[]]; } //Media Player mp.setOnBufferingUpdateListener[new OnBufferingUpdateListener[] { @Override public void onBufferingUpdate[MediaPlayer mp, int percent] { audioBar.setSecondaryProgress[percent]; } }]; mp.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { playPause.setImageResource[R.drawable.ic_media_play]; } }]; mp.setOnPreparedListener[new OnPreparedListener[] { @Override public void onPrepared[MediaPlayer mp] { play[]; } }]; //Button Play/Pause playPause.setImageResource[R.drawable.ic_media_play]; playPause.setOnClickListener[new View.OnClickListener[] { @Override public void onClick[View v] { playPause[]; } }]; //Button next next.setOnClickListener[new View.OnClickListener[] { @Override public void onClick[View v] { // TODO Auto-generated method stub } }]; //Button prev prev.setOnClickListener[new View.OnClickListener[] { @Override public void onClick[View v] { mp.seekTo[0]; audioBar.setProgress[0]; } }]; //Audio Bar audioBar.setMax[99]; audioBar.setOnTouchListener[new OnTouchListener[] { @Override public boolean onTouch[View v, MotionEvent event] { if [v.getId[] == R.id.seekBarAudio] { SeekBar sb = [SeekBar] v; int playPositionInMillisecconds = [mp.getDuration[] / 100] * sb.getProgress[]; mp.seekTo[playPositionInMillisecconds]; } return false; } }]; }

public static void playSound[String soundPath, boolean playAll] { if [soundPath.substring[0, 3].equals["tts"]] { ReadText.textToSpeech[soundPath.substring[4, soundPath.length[]], Integer.parseInt[soundPath.substring[3, 4]]]; } else if [sSoundPaths.contains[soundPath]] { sMediaPlayer = new MediaPlayer[]; try { // soundPath is usually an URI, but Media player requires a path not url encoded URI soundURI = new URI[soundPath]; soundPath = new File[soundURI].getAbsolutePath[]; sMediaPlayer.setDataSource[soundPath]; sMediaPlayer.setVolume[AudioManager.STREAM_MUSIC, AudioManager.STREAM_MUSIC]; sMediaPlayer.prepare[]; if [playAll] { sMediaPlayer.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { releaseSound[]; sNumSoundsPlayed++; // If there is still more sounds to play for the current card, play the next one if [sNumSoundsPlayed < sSoundPaths.size[]] { playSound[sNumSoundsPlayed]; } } }]; } sMediaPlayer.start[]; } catch [Exception e] { log.error["playSounds - Error reproducing sound " + soundPath + " = " + e.getMessage[]]; releaseSound[]; } } }

@Override protected void onCreate[Bundle savedInstanceState] { super.onCreate[savedInstanceState]; requestWindowFeature[Window.FEATURE_NO_TITLE]; getWindow[].setFlags[0, WindowManager.LayoutParams.FLAG_FULLSCREEN]; setContentView[R.layout.play_video_activity]; VideoView videoView = [VideoView] findViewById[R.id.videoView1]; MediaController mediaController = new MediaController[this]; mediaController.setAnchorView[videoView]; videoView.setMediaController[mediaController]; videoView.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { onVideoFinished[]; } }]; String path = getIntent[].getStringExtra[EXTRA_PATH]; String url = getIntent[].getStringExtra[EXTRA_URL]; long seekTo = getIntent[].getLongExtra[EXTRA_SEEK_TO, 0]; mEnclosureId = getIntent[].getLongExtra[EXTRA_ENCLOSURE_ID, 0]; mItemId = getIntent[].getLongExtra[EXTRA_ITEM_ID, 0]; if [Globals.LOGGING] Log.e[Globals.LOG_TAG, "PlayVideoActivity - path '" + path + "' url: '" + url + "' seekTo: " + seekTo]; boolean playing = true; if [savedInstanceState != null] { seekTo = savedInstanceState.getLong[EXTRA_SEEK_TO, seekTo]; playing = savedInstanceState.getBoolean[EXTRA_PLAYING, playing]; } if [path != null] { videoView.setVideoURI[Uri.fromFile[new File[path]]]; } else if [url != null] { videoView.setVideoURI[android.net.Uri.parse[url]]; } if [seekTo != 0] { videoView.seekTo[[int] seekTo]; } if [playing] { videoView.start[]; } mSeekTo = [int] seekTo; mPlaying = playing; mFullscreen = false; }

public void init[java.io.File recordingFile, final OnCompletionListener ocl] { this.recordingFile = recordingFile; mr.setOutputFile[recordingFile.getAbsolutePath[]]; mp = new MediaPlayer[]; mp.setOnInfoListener[this]; h.post[new Runnable[] { @Override public void run[] { if [isPlaying] { if [mp.getCurrentPosition[] >= mp.getDuration[]] { pause[]; mp.seekTo[0]; return; } setProgress[mp.getCurrentPosition[] / 1000]; } h.postDelayed[this, 1000L]; } }]; if [ocl != null] { mp.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { if [hasPlayedOnce] { ocl.onCompletion[mp]; } } }]; } }

public void init[java.io.File recordingFile, final OnCompletionListener ocl] { this.recordingFile = recordingFile; mr.setOutputFile[recordingFile.getAbsolutePath[]]; mp = new MediaPlayer[]; mp.setOnInfoListener[this]; h.post[new Runnable[] { @Override public void run[] { if [isPlaying] { if [mp.getCurrentPosition[] >= mp.getDuration[]] { pause[]; mp.seekTo[0]; return; } setProgress[mp.getCurrentPosition[] / 1000]; } h.postDelayed[this, 1000L]; } }]; if [ocl != null] { mp.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { if [hasPlayedOnce] { ocl.onCompletion[mp]; } } }]; } }

@Override public void onClick[View view] { switch[view.getId[]] { case R.id.btnPlay: DebugLog.logd["Button Play click"]; if [!mPlayer.isPlaying[]] { mPlayer.start[]; mPlayer.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { btnPlay.setCompoundDrawablesWithIntrinsicBounds[R.drawable.play_icon, 0, 0, 0]; btnPlay.setText[R.string.play_recording]; mPlayer.reset[]; mPlayer.release[]; mPlayer = new MediaPlayer[]; try { mPlayer.setDataSource[filePath]; mPlayer.prepare[]; } catch [IllegalArgumentException e] { e.printStackTrace[]; } catch [IllegalStateException e] { e.printStackTrace[]; } catch [IOException e] { e.printStackTrace[]; } } }]; btnPlay.setCompoundDrawablesWithIntrinsicBounds[R.drawable.stop_icon, 0, 0, 0]; btnPlay.setText[R.string.stop]; } else { mPlayer.stop[]; mPlayer.reset[]; mPlayer.release[]; mPlayer = new MediaPlayer[]; try { mPlayer.setDataSource[filePath]; mPlayer.prepare[]; } catch [IllegalArgumentException e] { e.printStackTrace[]; } catch [IllegalStateException e] { e.printStackTrace[]; } catch [IOException e] { e.printStackTrace[]; } btnPlay.setCompoundDrawablesWithIntrinsicBounds[R.drawable.play_icon, 0, 0, 0]; btnPlay.setText[R.string.play_recording]; } break; case R.id.btn_Re_Record: DebugLog.logd["Button Re-Recording click"]; if [!isClickReCording] { isClickReCording = true; try { if [mPlayer.isPlaying[]] { mPlayer.pause[]; mPlayer.release[]; } else { mPlayer.release[]; } } catch [Exception e] { DebugLog.loge[e.getMessage[]]; } Intent intent = new Intent[this, AudioRecordingActivity.class]; startActivity[intent]; finish[]; } break; } }

private void playMusic[int id] { // /////////////////////// ³õʼ»¯¸è´ÊÅäÖà /////////////////////// // mLrcProcess = new LrcProcess[]; // ¶ÁÈ¡¸è´ÊÎļþ mLrcProcess.readLRC[lists.get[_id].getUrl[]]; // ´«»Ø´¦ÀíºóµÄ¸è´ÊÎļþ lrcList = mLrcProcess.getLrcContent[]; MusicActivity.lrc_view.setSentenceEntities[lrcList]; // Çл»´ø¶¯»­ÏÔʾ¸è´Ê MusicActivity.lrc_view.setAnimation[AnimationUtils.loadAnimation[MusicService.this, R.anim.alpha_z]]; // Æô¶¯Ïß³Ì mHandler.post[mRunnable]; if [null != player] { player.release[]; player = null; } if [id >= lists.size[] - 1] { _id = lists.size[] - 1; } else if [id 0] { mHandler.postDelayed[new Runnable[] { @Override public void run[] { onPrepared[mp2]; } }, delay]; } else { onPrepared[mp2]; } } }]; }

@Override public void onRecorderEventRecogFinsh[RecorderEvent recorderEvent, AsrRecogResult arg1] { long endTime = System.currentTimeMillis[]; long usedTime = endTime - startTime; Log.v[TAG, "recog used time = " + usedTime + "ms"]; if [recorderEvent == RecorderEvent.RECORDER_EVENT_RECOGNIZE_COMPLETE] { String sState = "ʶ±ð״̬£ºÊ¶±ð½áÊø"; Message m = mUIHandler.obtainMessage[RECORD_STATE, sState]; mUIHandler.sendMessage[m]; } if [arg1 != null] { String sResult = " "; if [arg1.getRecogItemList[].size[] > 0] { String result = arg1.getRecogItemList[].get[0].getRecogResult[]; int score = arg1.getRecogItemList[].get[0].getScore[]; int shreshold = mActivity.getShreshold[]; if [score >= shreshold] { sResult = result + "\n·ÖÖµ£º" + score; MediaPlayer mp = MediaPlayer.create[mContext, R.raw.alert]; mp.start[]; mp.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { mp.release[]; mp = null; } }]; } } else { sResult = "δÄÜÕýȷʶ±ð,ÇëÖØÐÂÊäÈë"; } Message m = mUIHandler.obtainMessage[RECORD_RESULT, sResult]; mUIHandler.sendMessage[m]; } }

@Override public void onCreate[] { mNM = [NotificationManager] getSystemService[NOTIFICATION_SERVICE]; mMediaPlayer = new MediaPlayer[]; mMediaPlayer.setAudioStreamType[AudioTrack.MODE_STREAM]; mMediaPlayer.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { if [mMediaPlayer.isPlaying[]] { mp.stop[]; } mp.reset[]; if [onCompletionListener != null] { onCompletionListener.run[]; } } }]; mMediaPlayer.setOnPreparedListener[new OnPreparedListener[] { @Override public void onPrepared[MediaPlayer mp] { if [onPreparedListener != null] { onPreparedListener.run[]; mp.start[]; } else { mp.start[]; } } }]; mMediaPlayer.setOnErrorListener[new OnErrorListener[] { @Override public boolean onError[MediaPlayer mp, int what, int extra] { if [onErrorListener != null] { onErrorListener.run[]; return true; } else { return false; } } }]; mMediaPlayer.setOnBufferingUpdateListener[new OnBufferingUpdateListener[] { @Override public void onBufferingUpdate[MediaPlayer mp, int percent] { if [onBufferingUpdateListener != null] { onBufferingUpdateListener.run[]; } } }]; mMediaPlayer.setOnInfoListener[new OnInfoListener[] { @Override public boolean onInfo[MediaPlayer mp, int what, int extra] { if [onInfoListener != null] { onInfoListener.run[]; return true; } else { return false; } } }]; mMediaPlayer.setOnSeekCompleteListener[new OnSeekCompleteListener[] { @Override public void onSeekComplete[MediaPlayer mp] { if [onSeekCompleteListener != null] { onSeekCompleteListener.run[]; } } }]; phoneListener = new TelephoneCallStateListener[]; telephonyManager = [TelephonyManager] getSystemService[Context.TELEPHONY_SERVICE]; telephonyManager.listen[phoneListener, PhoneStateListener.LISTEN_CALL_STATE]; //Notification notification = new Notification[R.drawable.stat_sample, "Media Player Service has been killed", System.currentTimeMillis[]]; //startForeground[R.string.local_service_stopped, notification]; }

public synchronized void startAudio[] { if [!mIsPlaying && [mAudioUri != null]] { mMediaPlayer = MediaPlayer.create[mContext, mAudioUri]; if [mMediaPlayer != null] { mMediaPlayer.setAudioStreamType[AudioManager.STREAM_MUSIC]; mMediaPlayer.setOnCompletionListener[new OnCompletionListener[] { public void onCompletion[MediaPlayer mp] { stopAudio[]; } }]; mMediaPlayer.setOnErrorListener[new OnErrorListener[] { public boolean onError[MediaPlayer mp, int what, int extra] { onPlaybackError[]; return true; } }]; mIsPlaying = true; mMediaPlayer.start[]; } } }

static boolean CanSeekAccurately[SharedPreferences prefs] { Log.i["Ringdroid", "Running CanSeekAccurately"]; boolean result = false; result = prefs.getBoolean[PREF_SEEK_TEST_RESULT, false]; long testDate = prefs.getLong[PREF_SEEK_TEST_DATE, 0]; long now = [new Date[]].getTime[]; long oneWeekMS = 1000 * 60 * 60 * 24 * 7; if [now - testDate < oneWeekMS] { Log.i["Ringdroid", "Fast MP3 seek result cached: " + result]; return result; } String filename = "/sdcard/silence" + new Random[].nextLong[] + ".mp3"; File file = new File[filename]; boolean ok = false; try { RandomAccessFile f = new RandomAccessFile[file, "r"]; } catch [Exception e] { ok = true; } if [!ok] { Log.i["Ringdroid", "Couldn't find temporary filename"]; return false; } Log.i["Ringdroid", "Writing " + filename]; try { file.createNewFile[]; } catch [Exception e] { Log.i["Ringdroid", "Couldn't output for writing"]; return false; } try { FileOutputStream out = new FileOutputStream[file]; for [int i = 0; i < 80; i++] { out.write[SILENCE_MP3_FRAME, 0, SILENCE_MP3_FRAME.length]; } } catch [Exception e] { Log.i["Ringdroid", "Couldn't write temp silence file"]; try { file.delete[]; } catch [Exception e2] { } return false; } try { Log.i["Ringdroid", "File written, starting to play"]; MediaPlayer player = new MediaPlayer[]; player.setAudioStreamType[AudioManager.STREAM_MUSIC]; FileInputStream subsetInputStream = new FileInputStream[filename]; long start = 70 * SILENCE_MP3_FRAME.length; long len = 10 * SILENCE_MP3_FRAME.length; player.setDataSource[subsetInputStream.getFD[], start, len]; Log.i["Ringdroid", "Preparing"]; player.prepare[]; before = 0; after = 0; player.setOnCompletionListener[new OnCompletionListener[] { public synchronized void onCompletion[MediaPlayer arg0] { Log.i["Ringdroid", "Got callback"]; after = System.currentTimeMillis[]; } }]; Log.i["Ringdroid", "Starting"]; player.start[]; for [int i = 0; i < 200 && before == 0; i++] { if [player.getCurrentPosition[] > 0] { Log.i["Ringdroid", "Started playing after " + [i * 10] + " ms"]; before = System.currentTimeMillis[]; } Thread.sleep[10]; } if [before == 0] { Log.i["Ringdroid", "Never started playing."]; Log.i["Ringdroid", "Fast MP3 seek disabled by default"]; try { file.delete[]; } catch [Exception e2] { } SharedPreferences.Editor prefsEditor = prefs.edit[]; prefsEditor.putLong[PREF_SEEK_TEST_DATE, now]; prefsEditor.putBoolean[PREF_SEEK_TEST_RESULT, result]; prefsEditor.commit[]; return false; } Log.i["Ringdroid", "Sleeping"]; for [int i = 0; i < 300 && after == 0; i++] { Log.i["Ringdroid", "Pos: " + player.getCurrentPosition[]]; Thread.sleep[10]; } Log.i["Ringdroid", "Result: " + before + ", " + after]; if [after > before && after < before + 2000] { long delta = after > before ? after - before : -1; Log.i["Ringdroid", "Fast MP3 seek enabled: " + delta]; result = true; } else { Log.i["Ringdroid", "Fast MP3 seek disabled"]; } } catch [Exception e] { e.printStackTrace[]; Log.i["Ringdroid", "Couldn't play: " + e.toString[]]; Log.i["Ringdroid", "Fast MP3 seek disabled by default"]; try { file.delete[]; } catch [Exception e2] { } SharedPreferences.Editor prefsEditor = prefs.edit[]; prefsEditor.putLong[PREF_SEEK_TEST_DATE, now]; prefsEditor.putBoolean[PREF_SEEK_TEST_RESULT, result]; prefsEditor.commit[]; return false; } SharedPreferences.Editor prefsEditor = prefs.edit[]; prefsEditor.putLong[PREF_SEEK_TEST_DATE, now]; prefsEditor.putBoolean[PREF_SEEK_TEST_RESULT, result]; prefsEditor.commit[]; try { file.delete[]; } catch [Exception e] { } return result; }

public void closeAudioMediaPlayer[] { if [mMediaPlayerAudio == null] { return; } if [mMediaPlayerAudio.isPlaying[]] { mMediaPlayerAudio.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { mMediaPlayerAudio.reset[]; mMediaPlayerAudio.release[]; mMediaPlayerAudio = null; } }]; } else { mMediaPlayerAudio.release[]; mMediaPlayerAudio = null; } }

@Override protected void onPostExecute[Void unused] { myDialog.dismiss[]; try { mp = new MediaPlayer[]; if [mp.isPlaying[]] mp.reset[]; mp.setDataSource[file.getAbsolutePath[]]; mp.prepare[]; } catch [Exception e] { e.printStackTrace[]; } mp.start[]; mp.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { // TODO Auto-generated method stub mp.release[]; } }]; }

public static void playSound[Activity activity] { int randomInt = new Random[].nextInt[4]; String fileName = "groot/groot" + randomInt + ".mp3"; // XposedBridge.log[TAG + ": " + fileName]; try { File mp3File = new File[Environment.getExternalStorageDirectory[], fileName]; Uri mp3Uri = Uri.fromFile[mp3File]; MediaPlayer mediaPlayer = MediaPlayer.create[activity, mp3Uri]; mediaPlayer.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { mp.release[]; } }]; mediaPlayer.start[]; } catch [Exception e] { } }

static boolean CanSeekAccurately[SharedPreferences prefs] { Log.i["Ringdroid", "Running CanSeekAccurately"]; boolean result = false; result = prefs.getBoolean[PREF_SEEK_TEST_RESULT, false]; long testDate = prefs.getLong[PREF_SEEK_TEST_DATE, 0]; long now = [new Date[]].getTime[]; long oneWeekMS = 1000 * 60 * 60 * 24 * 7; if [now - testDate < oneWeekMS] { Log.i["Ringdroid", "Fast MP3 seek result cached: " + result]; return result; } String filename = "/sdcard/silence" + new Random[].nextLong[] + ".mp3"; File file = new File[filename]; boolean ok = false; try { RandomAccessFile f = new RandomAccessFile[file, "r"]; } catch [Exception e] { ok = true; } if [!ok] { Log.i["Ringdroid", "Couldn't find temporary filename"]; return false; } Log.i["Ringdroid", "Writing " + filename]; try { file.createNewFile[]; } catch [Exception e] { Log.i["Ringdroid", "Couldn't output for writing"]; return false; } try { FileOutputStream out = new FileOutputStream[file]; for [int i = 0; i < 80; i++] { out.write[SILENCE_MP3_FRAME, 0, SILENCE_MP3_FRAME.length]; } } catch [Exception e] { Log.i["Ringdroid", "Couldn't write temp silence file"]; try { file.delete[]; } catch [Exception e2] { } return false; } try { Log.i["Ringdroid", "File written, starting to play"]; MediaPlayer player = new MediaPlayer[]; player.setAudioStreamType[AudioManager.STREAM_MUSIC]; FileInputStream subsetInputStream = new FileInputStream[filename]; long start = 70 * SILENCE_MP3_FRAME.length; long len = 10 * SILENCE_MP3_FRAME.length; player.setDataSource[subsetInputStream.getFD[], start, len]; Log.i["Ringdroid", "Preparing"]; player.prepare[]; before = 0; after = 0; player.setOnCompletionListener[new OnCompletionListener[] { public synchronized void onCompletion[MediaPlayer arg0] { Log.i["Ringdroid", "Got callback"]; after = System.currentTimeMillis[]; } }]; Log.i["Ringdroid", "Starting"]; player.start[]; for [int i = 0; i < 200 && before == 0; i++] { if [player.getCurrentPosition[] > 0] { Log.i["Ringdroid", "Started playing after " + [i * 10] + " ms"]; before = System.currentTimeMillis[]; } Thread.sleep[10]; } if [before == 0] { Log.i["Ringdroid", "Never started playing."]; Log.i["Ringdroid", "Fast MP3 seek disabled by default"]; try { file.delete[]; } catch [Exception e2] { } SharedPreferences.Editor prefsEditor = prefs.edit[]; prefsEditor.putLong[PREF_SEEK_TEST_DATE, now]; prefsEditor.putBoolean[PREF_SEEK_TEST_RESULT, result]; prefsEditor.commit[]; return false; } Log.i["Ringdroid", "Sleeping"]; for [int i = 0; i < 300 && after == 0; i++] { Log.i["Ringdroid", "Pos: " + player.getCurrentPosition[]]; Thread.sleep[10]; } Log.i["Ringdroid", "Result: " + before + ", " + after]; if [after > before && after < before + 2000] { long delta = after > before ? after - before : -1; Log.i["Ringdroid", "Fast MP3 seek enabled: " + delta]; result = true; } else { Log.i["Ringdroid", "Fast MP3 seek disabled"]; } } catch [Exception e] { e.printStackTrace[]; Log.i["Ringdroid", "Couldn't play: " + e.toString[]]; Log.i["Ringdroid", "Fast MP3 seek disabled by default"]; try { file.delete[]; } catch [Exception e2] { } SharedPreferences.Editor prefsEditor = prefs.edit[]; prefsEditor.putLong[PREF_SEEK_TEST_DATE, now]; prefsEditor.putBoolean[PREF_SEEK_TEST_RESULT, result]; prefsEditor.commit[]; return false; } SharedPreferences.Editor prefsEditor = prefs.edit[]; prefsEditor.putLong[PREF_SEEK_TEST_DATE, now]; prefsEditor.putBoolean[PREF_SEEK_TEST_RESULT, result]; prefsEditor.commit[]; try { file.delete[]; } catch [Exception e] { } return result; }

private void playVideo[] { mVideo.setVideoPath[videoUrl]; mVideo.requestFocus[]; mVideo.setOnPreparedListener[new OnPreparedListener[] { @Override public void onPrepared[MediaPlayer mp] { mVideo.setVideoWidth[mp.getVideoWidth[]]; mVideo.setVideoHeight[mp.getVideoHeight[]]; mVideo.start[]; if [playTime != 0] { mVideo.seekTo[playTime]; } mHandler.removeCallbacks[hideRunnable]; mHandler.postDelayed[hideRunnable, HIDE_TIME]; mDurationTime.setText[formatTime[mVideo.getDuration[]]]; Timer timer = new Timer[]; timer.schedule[new TimerTask[] { @Override public void run[] { mHandler.sendEmptyMessage[1]; } }, 0, 1000]; } }]; mVideo.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { mPlay.setImageResource[R.drawable.video_btn_down]; mPlayTime.setText["00:00"]; mSeekBar.setProgress[0]; } }]; mVideo.setOnTouchListener[mTouchListener]; }

private InternalMediaPlayer build[Playlist playlistEntry] { final InternalMediaPlayer mediaPlayer = new InternalMediaPlayer[]; // try to setup local path String path = MyApplication.getInstance[].getDownloadInterface[].getTrackPath[playlistEntry]; if [path == null] // fallback to remote one path = playlistEntry.getTrack[].getStream[]; // some albums happen to contain empty stream url, notify of error, abort playback if [path.length[] == 0] { if [mPlayerEngineListener != null] { mPlayerEngineListener.onTrackStreamError[]; mPlayerEngineListener.onTrackChanged[mPlaylist.getSelectedTrack[]]; } stop[]; return null; } try { mediaPlayer.setDataSource[path]; mediaPlayer.playlistEntry = playlistEntry; //mediaPlayer.setScreenOnWhilePlaying[true]; mediaPlayer.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { next[]; } }]; mediaPlayer.setOnPreparedListener[new OnPreparedListener[] { @Override public void onPrepared[MediaPlayer mp] { mediaPlayer.preparing = false; // we may start playing if [mPlaylist.getSelectedTrack[] == mediaPlayer.playlistEntry && mediaPlayer.playAfterPrepare] { mediaPlayer.playAfterPrepare = false; play[]; } } }]; mediaPlayer.setOnBufferingUpdateListener[new OnBufferingUpdateListener[] { @Override public void onBufferingUpdate[MediaPlayer mp, int percent] { if [mPlayerEngineListener != null] { mPlayerEngineListener.onTrackBuffering[percent]; } } }]; mediaPlayer.setOnErrorListener[new OnErrorListener[] { @Override public boolean onError[MediaPlayer mp, int what, int extra] { Log.w[MyApplication.TAG, "PlayerEngineImpl fail, what [" + what + "] extra [" + extra + "]"]; if [what == MediaPlayer.MEDIA_ERROR_UNKNOWN] { // we probably lack network if [mPlayerEngineListener != null] { mPlayerEngineListener.onTrackStreamError[]; } stop[]; return true; } // further playback if [what == -1] { long failTime = System.currentTimeMillis[]; if [failTime - mLastFailTime > FAIL_TIME_FRAME] { // outside time frame mTimesFailed = 1; mLastFailTime = failTime; Log.w[MyApplication.TAG, "PlayerEngineImpl " + mTimesFailed + " fail within FAIL_TIME_FRAME"]; } else { // inside time frame mTimesFailed++; if [mTimesFailed > ACCEPTABLE_FAIL_NUMBER] { Log.w[MyApplication.TAG, "PlayerEngineImpl too many fails, aborting playback"]; if [mPlayerEngineListener != null] { mPlayerEngineListener.onTrackStreamError[]; } stop[]; return true; } } } return false; } }]; // start preparing Log.i[MyApplication.TAG, "Player [buffering] " + mediaPlayer.playlistEntry.getTrack[].getName[]]; mediaPlayer.preparing = true; mediaPlayer.prepareAsync[]; // this is a new track, so notify the listener if [mPlayerEngineListener != null] { mPlayerEngineListener.onTrackChanged[mPlaylist.getSelectedTrack[]]; } return mediaPlayer; } catch [IllegalArgumentException e] { e.printStackTrace[]; } catch [IllegalStateException e] { e.printStackTrace[]; } catch [IOException e] { e.printStackTrace[]; } return null; }

@Override public void onClick[View v] { if [mAudioPath == null] { return; } switch[mStatus] { case IDLE: try { mPlayer = new MediaPlayer[]; mPlayer.setDataSource[getAudioPath[]]; mPlayer.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { mStatus = Status.STOPPED; mPlayer.stop[]; notifyStop[]; } }]; mPlayer.prepare[]; mPlayer.start[]; setImageResource[mResPauseImage]; mStatus = Status.PLAYING; notifyPlay[]; } catch [Exception e] { Timber.e[e.getMessage[]]; showToast[gtxt[R.string.multimedia_editor_audio_view_playing_failed]]; mStatus = Status.IDLE; } break; case PAUSED: // -> Play, continue playing mStatus = Status.PLAYING; setImageResource[mResPauseImage]; mPlayer.start[]; notifyPlay[]; break; case STOPPED: // -> Play, start from beginning mStatus = Status.PLAYING; setImageResource[mResPauseImage]; try { mPlayer.prepare[]; mPlayer.seekTo[0]; } catch [Exception e] { Timber.e[e.getMessage[]]; } mPlayer.start[]; notifyPlay[]; break; case PLAYING: setImageResource[mResPlayImage]; mPlayer.pause[]; mStatus = Status.PAUSED; notifyPause[]; break; case RECORDING: // this button should be disabled break; default: break; } }

public void notifyNewPost[ArrayList cm] { // Let's see... if [!sharedPreferences.getBoolean["battlelog_chat_sound", true]] { return; } // Init! boolean hasNewResponse = false; boolean isFirstRun = true; // Iterate for [int curr = cm.size[] - 1, min = [[curr > 5] ? curr - 5 : 0]; curr > min; curr--] { // Let's see what happens. ChatMessage m = cm.get[curr]; if [m.getSender[].equals[profileData.getAccountName[]]] { // Ooh, ooh, is it fresh? if [m.getTimestamp[] > latestChatResponseTimestamp] { hasNewResponse = true; isFirstRun = [latestChatResponseTimestamp == 0]; latestChatResponseTimestamp = m.getTimestamp[]; break; } } } // So, did we have a new response? if [hasNewResponse && !isFirstRun] { MediaPlayer mediaPlayer = MediaPlayer.create[this, R.raw.notification]; mediaPlayer.start[]; mediaPlayer.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer arg0] { arg0.release[]; } }]; } else if [isFirstRun] { // Scroll down to the bottom listView.post[new Runnable[] { @Override public void run[] { listView.setSelection[listView.getAdapter[].getCount[] - 1]; } }]; } return; }

@Override public void onReceive[Context context, Intent pintent] { Log.v[TAG, "ALARM: received alarm"]; NotificationManager mNM = [NotificationManager] context.getSystemService[Context.NOTIFICATION_SERVICE]; if [player != null] { Log.v[TAG, "Releasing media player..."]; try { player.release[]; player = null; } catch [Exception e] { e.printStackTrace[]; player = null; } finally { // do nothing } } // Cancel notification and return... if [CANCEL_NOTIFICATION.equals[pintent.getAction[]]] { Log.v[TAG, "Cancelling notification..."]; mNM.cancelAll[]; return; } // ...or display a new one Log.v[TAG, "Showing notification..."]; player = new MediaPlayer[]; int setTime = pintent.getIntExtra["SetTime", 0]; String setTimeStr = TimerUtils.time2humanStr[context, setTime]; Log.v[TAG, "Time: " + setTime]; CharSequence text = context.getText[R.string.Notification]; CharSequence textLatest = String.format[context.getString[R.string.timer_for_x], setTimeStr]; // Load the settings SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences[context]; boolean led = prefs.getBoolean["LED", true]; boolean vibrate = prefs.getBoolean["Vibrate", true]; String notificationUri = ""; boolean useAdvTime = prefs.getBoolean["useAdvTime", false]; String advTimeString = prefs.getString["advTimeString", ""]; String[] advTime = null; int advTimeIndex = 1; if [useAdvTime && advTimeString.length[] > 0] { advTime = advTimeString.split["\\^"]; advTimeIndex = prefs.getInt["advTimeIndex", 1]; // will be of format timeInMs#pathToSound String[] thisAdvTime = advTime[advTimeIndex - 1].split["#"]; if [thisAdvTime.length == 3] notificationUri = thisAdvTime[1]; if [notificationUri.equals["sys_def"]] notificationUri = prefs.getString["NotificationUri", "android.resource://org.yuttadhammo.BodhiTimer/" + R.raw.bell]; } else notificationUri = prefs.getString["NotificationUri", "android.resource://org.yuttadhammo.BodhiTimer/" + R.raw.bell]; Log.v[TAG, "notification uri: " + notificationUri]; if [notificationUri.equals["system"]] notificationUri = prefs.getString["SystemUri", ""]; else if [notificationUri.equals["file"]] notificationUri = prefs.getString["FileUri", ""]; else if [notificationUri.equals["tts"]] { notificationUri = ""; final String ttsString = prefs.getString["tts_string", context.getString[R.string.timer_done]]; Intent ttsIntent = new Intent[context, TTSService.class]; ttsIntent.putExtra["spoken_text", ttsString]; context.startService[ttsIntent]; } NotificationCompat.Builder mBuilder = new NotificationCompat.Builder[context.getApplicationContext[]].setSmallIcon[R.drawable.notification].setContentTitle[text].setContentText[textLatest]; Uri uri = null; // Play a sound! if [!notificationUri.equals[""]] uri = Uri.parse[notificationUri]; // Vibrate if [vibrate && uri == null] { mBuilder.setDefaults[Notification.DEFAULT_VIBRATE]; } // Have a light if [led] { mBuilder.setLights[0xff00ff00, 300, 1000]; } mBuilder.setAutoCancel[true]; // Creates an explicit intent for an Activity in your app Intent resultIntent = new Intent[context, TimerActivity.class]; // The stack builder object will contain an artificial back stack for the // started Activity. // This ensures that navigating backward from the Activity leads out of // your application to the Home screen. TaskStackBuilder stackBuilder = TaskStackBuilder.create[context]; // Adds the back stack for the Intent [but not the Intent itself] stackBuilder.addParentStack[TimerActivity.class]; // Adds the Intent that starts the Activity to the top of the stack stackBuilder.addNextIntent[resultIntent]; PendingIntent resultPendingIntent = stackBuilder.getPendingIntent[0, PendingIntent.FLAG_UPDATE_CURRENT]; mBuilder.setContentIntent[resultPendingIntent]; NotificationManager mNotificationManager = [NotificationManager] context.getSystemService[Context.NOTIFICATION_SERVICE]; // Create intent for cancelling the notification Context appContext = context.getApplicationContext[]; Intent intent = new Intent[appContext, TimerReceiver.class]; intent.setAction[CANCEL_NOTIFICATION]; // Cancel the pending cancellation and create a new one PendingIntent pendingCancelIntent = PendingIntent.getBroadcast[appContext, 0, intent, PendingIntent.FLAG_CANCEL_CURRENT]; if [uri != null] { //remove notification sound mBuilder.setSound[null]; try { if [player != null && player.isPlaying[]] { player.release[]; player = new MediaPlayer[]; } int currVolume = prefs.getInt["tone_volume", 0]; if [currVolume != 0] { float log1 = [float] [Math.log[100 - currVolume] / Math.log[100]]; player.setVolume[1 - log1, 1 - log1]; } player.setDataSource[context, uri]; player.prepare[]; player.setLooping[false]; player.setOnCompletionListener[new OnCompletionListener[] { @Override public void onCompletion[MediaPlayer mp] { // TODO Auto-generated method stub mp.release[]; } }]; player.start[]; if [vibrate] { Vibrator vibrator = [Vibrator] context.getSystemService[Context.VIBRATOR_SERVICE]; vibrator.vibrate[1000]; } } catch [IOException e] { e.printStackTrace[]; } } if [prefs.getBoolean["AutoClear", false]] { // Determine duration of notification sound int duration = 5000; if [uri != null] { MediaPlayer cancelPlayer = new MediaPlayer[]; try { cancelPlayer.setDataSource[context, uri]; cancelPlayer.prepare[]; duration = Math.max[duration, cancelPlayer.getDuration[] + 2000]; } catch [java.io.IOException ex] { Log.e[TAG, "Cannot get sound duration: " + ex]; duration = 30000; } finally { cancelPlayer.release[]; } cancelPlayer.release[]; } Log.v[TAG, "Notification duration: " + duration + " ms"]; // Schedule cancellation AlarmManager alarmMgr = [AlarmManager] context.getSystemService[Context.ALARM_SERVICE]; alarmMgr.set[AlarmManager.ELAPSED_REALTIME, SystemClock.elapsedRealtime[] + duration, pendingCancelIntent]; } if [useAdvTime && advTimeString.length[] > 0] { Intent broadcast = new Intent[]; SharedPreferences.Editor editor = prefs.edit[]; if [advTimeIndex < advTime.length] { editor.putInt["advTimeIndex", advTimeIndex + 1]; // will be of format timeInMs#pathToSound String[] thisAdvTime = advTime[advTimeIndex].split["#"]; int time = Integer.parseInt[thisAdvTime[0]]; broadcast.putExtra["time", time]; // Save new time editor.putLong["TimeStamp", new Date[].getTime[] + time]; editor.putInt["LastTime", time]; // editor.putString["NotificationUri", thisAdvTime[1]]; mNM.cancelAll[]; Log.v[TAG, "Starting next iteration of the timer service ..."]; Intent rintent = new Intent[context, TimerReceiver.class]; rintent.putExtra["SetTime", time]; PendingIntent mPendingIntent = PendingIntent.getBroadcast[context, 0, rintent, PendingIntent.FLAG_UPDATE_CURRENT]; AlarmManager mAlarmMgr = [AlarmManager] context.getSystemService[Context.ALARM_SERVICE]; mAlarmMgr.set[AlarmManager.RTC_WAKEUP, System.currentTimeMillis[] + time, mPendingIntent]; } else { broadcast.putExtra["stop", true]; editor.putInt["advTimeIndex", 1]; } broadcast.setAction[BROADCAST_RESET]; context.sendBroadcast[broadcast]; editor.apply[]; } else if [prefs.getBoolean["AutoRestart", false]] { int time = pintent.getIntExtra["SetTime", 0]; if [time != 0] { mNM.cancel[0]; Log.v[TAG, "Restarting the timer service ..."]; Intent rintent = new Intent[context, TimerReceiver.class]; rintent.putExtra["SetTime", time]; PendingIntent mPendingIntent = PendingIntent.getBroadcast[context, 0, rintent, PendingIntent.FLAG_UPDATE_CURRENT]; AlarmManager mAlarmMgr = [AlarmManager] context.getSystemService[Context.ALARM_SERVICE]; mAlarmMgr.set[AlarmManager.RTC_WAKEUP, System.currentTimeMillis[] + time, mPendingIntent]; // Save new time SharedPreferences.Editor editor = prefs.edit[]; editor.putLong["TimeStamp", new Date[].getTime[] + time]; editor.putInt["LastTime", time]; editor.apply[]; Intent broadcast = new Intent[]; broadcast.putExtra["time", time]; broadcast.setAction[BROADCAST_RESET]; context.sendBroadcast[broadcast]; } } mNotificationManager.notify[0, mBuilder.build[]]; Log.d[TAG, "ALARM: alarm finished"]; }