src/com/owncloud/android/media/MediaService.java

   1 /**
   2  *   ownCloud Android client application
   3  *
   4  *   @author David A. Velasco
   5  *   Copyright (C) 2015 ownCloud Inc.
   6  *
   7  *   This program is free software: you can redistribute it and/or modify
   8  *   it under the terms of the GNU General Public License version 2,
   9  *   as published by the Free Software Foundation.
  10  *
  11  *   This program is distributed in the hope that it will be useful,
  12  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *   GNU General Public License for more details.
  15  *
  16  *   You should have received a copy of the GNU General Public License
  17  *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  *
  19  */
  20
  21 package com.owncloud.android.media;
  22
  23 import android.accounts.Account;
  24 import android.app.Activity;
  25 import android.app.Notification;
  26 import android.app.NotificationManager;
  27 import android.app.PendingIntent;
  28 import android.app.Service;
  29 import android.content.Context;
  30 import android.content.DialogInterface;
  31 import android.content.Intent;
  32 import android.media.AudioManager;
  33 import android.media.MediaPlayer;
  34 import android.media.MediaPlayer.OnCompletionListener;
  35 import android.media.MediaPlayer.OnErrorListener;
  36 import android.media.MediaPlayer.OnPreparedListener;
  37 import android.net.Uri;
  38 import android.net.wifi.WifiManager;
  39 import android.net.wifi.WifiManager.WifiLock;
  40 import android.os.IBinder;
  41 import android.os.PowerManager;
  42 import android.support.v7.app.AlertDialog;
  43 import android.widget.Toast;
  44
  45 import java.io.IOException;
  46
  47 import com.owncloud.android.R;
  48 import com.owncloud.android.datamodel.OCFile;
  49 import com.owncloud.android.lib.common.accounts.AccountUtils;
  50 import com.owncloud.android.lib.common.utils.Log_OC;
  51 import com.owncloud.android.ui.activity.FileActivity;
  52 import com.owncloud.android.ui.activity.FileDisplayActivity;
  53
  54
  55 /**
  56  * Service that handles media playback, both audio and video.
  57  *
  58  * Waits for Intents which signal the service to perform specific operations: Play, Pause,
  59  * Rewind, etc.
  60  */
  61 public class MediaService extends Service implements OnCompletionListener, OnPreparedListener,
  62                 OnErrorListener, AudioManager.OnAudioFocusChangeListener {
  63
  64     private static final String TAG = MediaService.class.getSimpleName();
  65
  66     private static final String MY_PACKAGE = MediaService.class.getPackage() != null ? MediaService.class.getPackage().getName() : "com.owncloud.android.media";
  67
  68     /// Intent actions that we are prepared to handle
  69     public static final String ACTION_PLAY_FILE = MY_PACKAGE + ".action.PLAY_FILE";
  70     public static final String ACTION_STOP_ALL = MY_PACKAGE + ".action.STOP_ALL";
  71
  72     /// Keys to add extras to the action
  73     public static final String EXTRA_FILE = MY_PACKAGE + ".extra.FILE";
  74     public static final String EXTRA_ACCOUNT = MY_PACKAGE + ".extra.ACCOUNT";
  75     public static String EXTRA_START_POSITION = MY_PACKAGE + ".extra.START_POSITION";
  76     public static final String EXTRA_PLAY_ON_LOAD = MY_PACKAGE + ".extra.PLAY_ON_LOAD";
  77
  78
  79     /** Error code for specific messages - see regular error codes at {@link MediaPlayer} */
  80     public static final int OC_MEDIA_ERROR = 0;
  81
  82     /** Time To keep the control panel visible when the user does not use it */
  83     public static final int MEDIA_CONTROL_SHORT_LIFE = 4000;
  84
  85     /** Time To keep the control panel visible when the user does not use it */
  86     public static final int MEDIA_CONTROL_PERMANENT = 0;
  87
  88     /** Volume to set when audio focus is lost and ducking is allowed */
  89     private static final float DUCK_VOLUME = 0.1f;
  90
  91     /** Media player instance */
  92     private MediaPlayer mPlayer = null;
  93
  94     /** Reference to the system AudioManager */
  95     private AudioManager mAudioManager = null;
  96
  97
  98     /** Values to indicate the state of the service */
  99     enum State {
 100         STOPPED,
 101         PREPARING,
 102         PLAYING,
 103         PAUSED
 104     };
 105
 106
 107     /** Current state */
 108     private State mState = State.STOPPED;
 109
 110     /** Possible focus values */
 111     enum AudioFocus {
 112         NO_FOCUS,
 113         NO_FOCUS_CAN_DUCK,
 114         FOCUS
 115     }
 116
 117     /** Current focus state */
 118     private AudioFocus mAudioFocus = AudioFocus.NO_FOCUS;
 119
 120
 121     /** 'True' when the current song is streaming from the network */
 122     private boolean mIsStreaming = false;
 123
 124     /** Wifi lock kept to prevents the device from shutting off the radio when streaming a file. */
 125     private WifiLock mWifiLock;
 126
 127     private static final String MEDIA_WIFI_LOCK_TAG = MY_PACKAGE + ".WIFI_LOCK";
 128
 129     /** Notification to keep in the notification bar while a song is playing */
 130     private NotificationManager mNotificationManager;
 131     private Notification mNotification = null;
 132
 133     /** File being played */
 134     private OCFile mFile;
 135
 136     /** Account holding the file being played */
 137     private Account mAccount;
 138
 139     /** Flag signaling if the audio should be played immediately when the file is prepared */
 140     protected boolean mPlayOnPrepared;
 141
 142     /** Position, in miliseconds, where the audio should be started */
 143     private int mStartPosition;
 144
 145     /** Interface to access the service through binding */
 146     private IBinder mBinder;
 147
 148     /** Control panel shown to the user to control the playback, to register through binding */
 149     private MediaControlView mMediaController;
 150
 151
 152
 153     /**
 154      * Helper method to get an error message suitable to show to users for errors occurred in media playback,
 155      *
 156      * @param context   A context to access string resources.
 157      * @param what      See {@link MediaPlayer.OnErrorListener#onError(MediaPlayer, int, int)
 158      * @param extra     See {@link MediaPlayer.OnErrorListener#onError(MediaPlayer, int, int)
 159      * @return          Message suitable to users.
 160      */
 161     public static String getMessageForMediaError(Context context, int what, int extra) {
 162         int messageId;
 163
 164         if (what == OC_MEDIA_ERROR) {
 165             messageId = extra;
 166
 167         } else if (extra == MediaPlayer.MEDIA_ERROR_UNSUPPORTED) {
 168             /*  Added in API level 17
 169                 Bitstream is conforming to the related coding standard or file spec, but the media framework does not support the feature.
 170                 Constant Value: -1010 (0xfffffc0e)
 171              */
 172             messageId = R.string.media_err_unsupported;
 173
 174         } else if (extra == MediaPlayer.MEDIA_ERROR_IO) {
 175             /*  Added in API level 17
 176                 File or network related operation errors.
 177                 Constant Value: -1004 (0xfffffc14)
 178              */
 179             messageId = R.string.media_err_io;
 180
 181         } else if (extra == MediaPlayer.MEDIA_ERROR_MALFORMED) {
 182             /*  Added in API level 17
 183                 Bitstream is not conforming to the related coding standard or file spec.
 184                 Constant Value: -1007 (0xfffffc11)
 185              */
 186             messageId = R.string.media_err_malformed;
 187
 188         } else if (extra == MediaPlayer.MEDIA_ERROR_TIMED_OUT) {
 189             /*  Added in API level 17
 190                 Some operation takes too long to complete, usually more than 3-5 seconds.
 191                 Constant Value: -110 (0xffffff92)
 192             */
 193             messageId = R.string.media_err_timeout;
 194
 195         } else if (what == MediaPlayer.MEDIA_ERROR_NOT_VALID_FOR_PROGRESSIVE_PLAYBACK) {
 196             /*  Added in API level 3
 197                 The video is streamed and its container is not valid for progressive playback i.e the video's index (e.g moov atom) is not at the start of the file.
 198                 Constant Value: 200 (0x000000c8)
 199             */
 200             messageId = R.string.media_err_invalid_progressive_playback;
 201
 202         } else {
 203             /*  MediaPlayer.MEDIA_ERROR_UNKNOWN
 204                 Added in API level 1
 205                 Unspecified media player error.
 206                 Constant Value: 1 (0x00000001)
 207             */
 208             /*  MediaPlayer.MEDIA_ERROR_SERVER_DIED)
 209                 Added in API level 1
 210                 Media server died. In this case, the application must release the MediaPlayer object and instantiate a new one.
 211                 Constant Value: 100 (0x00000064)
 212              */
 213             messageId = R.string.media_err_unknown;
 214         }
 215         return context.getString(messageId);
 216     }
 217
 218     public static AlertDialog.Builder streamWithExternalApp(final String uri, final Activity activity){
 219         AlertDialog.Builder builder = new AlertDialog.Builder(activity);
 220         builder.setMessage(activity.getString(R.string.stream_expose_password))
 221                 .setPositiveButton(activity.getString(R.string.common_yes),
 222                                    new DialogInterface.OnClickListener() {
 223                                         public void onClick(DialogInterface dialog, int id) {
 224                                             Intent i = new Intent(Intent.ACTION_VIEW);
 225                                             i.setData(Uri.parse(uri));
 226                                             activity.startActivity(i);
 227                                         }
 228                                     })
 229                 .setNegativeButton(activity.getString(R.string.common_no), new DialogInterface.OnClickListener() {
 230                     public void onClick(DialogInterface dialog, int id) {
 231                         // User cancelled the dialog
 232                     }
 233                 });
 234         return builder;
 235     }
 236
 237
 238
 239     /**
 240      * Initialize a service instance
 241      *
 242      * {@inheritDoc}
 243      */
 244     @Override
 245     public void onCreate() {
 246         super.onCreate();
 247         Log_OC.d(TAG, "Creating ownCloud media service");
 248
 249         mWifiLock = ((WifiManager) getSystemService(Context.WIFI_SERVICE)).
 250                 createWifiLock(WifiManager.WIFI_MODE_FULL, MEDIA_WIFI_LOCK_TAG);
 251
 252         mNotificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
 253         mAudioManager = (AudioManager) getSystemService(AUDIO_SERVICE);
 254         mBinder = new MediaServiceBinder(this);
 255     }
 256
 257
 258     /**
 259      * Entry point for Intents requesting actions, sent here via startService.
 260      *
 261      * {@inheritDoc}
 262      */
 263     @Override
 264     public int onStartCommand(Intent intent, int flags, int startId) {
 265         String action = intent.getAction();
 266         if (action.equals(ACTION_PLAY_FILE)) {
 267             processPlayFileRequest(intent);
 268
 269         } else if (action.equals(ACTION_STOP_ALL)) {
 270             processStopRequest(true);
 271         }
 272
 273         return START_NOT_STICKY; // don't want it to restart in case it's killed.
 274     }
 275
 276
 277     /**
 278      * Processes a request to play a media file received as a parameter
 279      *
 280      * TODO If a new request is received when a file is being prepared, it is ignored. Is this what we want?
 281      *
 282      * @param intent    Intent received in the request with the data to identify the file to play.
 283      */
 284     private void processPlayFileRequest(Intent intent) {
 285         if (mState != State.PREPARING) {
 286             mFile = intent.getExtras().getParcelable(EXTRA_FILE);
 287             mAccount = intent.getExtras().getParcelable(EXTRA_ACCOUNT);
 288             mPlayOnPrepared = intent.getExtras().getBoolean(EXTRA_PLAY_ON_LOAD, false);
 289             mStartPosition = intent.getExtras().getInt(EXTRA_START_POSITION, 0);
 290             tryToGetAudioFocus();
 291             playMedia();
 292         }
 293     }
 294
 295
 296     /**
 297      * Processes a request to play a media file.
 298      */
 299     protected void processPlayRequest() {
 300         // request audio focus
 301         tryToGetAudioFocus();
 302
 303         // actually play the song
 304         if (mState == State.STOPPED) {
 305             // (re)start playback
 306             playMedia();
 307
 308         } else if (mState == State.PAUSED) {
 309             // continue playback
 310             mState = State.PLAYING;
 311             setUpAsForeground(String.format(getString(R.string.media_state_playing), mFile.getFileName()));
 312             configAndStartMediaPlayer();
 313
 314         }
 315     }
 316
 317
 318     /**
 319      * Makes sure the media player exists and has been reset. This will create the media player
 320      * if needed. reset the existing media player if one already exists.
 321      */
 322     protected void createMediaPlayerIfNeeded() {
 323         if (mPlayer == null) {
 324             mPlayer = new MediaPlayer();
 325
 326             // make sure the CPU won't go to sleep while media is playing
 327             mPlayer.setWakeMode(getApplicationContext(), PowerManager.PARTIAL_WAKE_LOCK);
 328
 329             // the media player will notify the service when it's ready preparing, and when it's done playing
 330             mPlayer.setOnPreparedListener(this);
 331             mPlayer.setOnCompletionListener(this);
 332             mPlayer.setOnErrorListener(this);
 333
 334         } else {
 335             mPlayer.reset();
 336         }
 337     }
 338
 339     /**
 340      * Processes a request to pause the current playback
 341      */
 342     protected void processPauseRequest() {
 343         if (mState == State.PLAYING) {
 344             mState = State.PAUSED;
 345             mPlayer.pause();
 346             releaseResources(false); // retain media player in pause
 347             // TODO polite audio focus, instead of keep it owned; or not?
 348         }
 349     }
 350
 351
 352     /**
 353      * Processes a request to stop the playback.
 354      *
 355      * @param   force       When 'true', the playback is stopped no matter the value of mState
 356      */
 357     protected void processStopRequest(boolean force) {
 358         if (mState != State.PREPARING || force) {
 359             mState = State.STOPPED;
 360             mFile = null;
 361             mAccount = null;
 362             releaseResources(true);
 363             giveUpAudioFocus();
 364             stopSelf();     // service is no longer necessary
 365         }
 366     }
 367
 368
 369     /**
 370      * Releases resources used by the service for playback. This includes the "foreground service"
 371      * status and notification, the wake locks and possibly the MediaPlayer.
 372      *
 373      * @param releaseMediaPlayer    Indicates whether the Media Player should also be released or not
 374      */
 375     protected void releaseResources(boolean releaseMediaPlayer) {
 376         // stop being a foreground service
 377         stopForeground(true);
 378
 379         // stop and release the Media Player, if it's available
 380         if (releaseMediaPlayer && mPlayer != null) {
 381             mPlayer.reset();
 382             mPlayer.release();
 383             mPlayer = null;
 384         }
 385
 386         // release the Wifi lock, if holding it
 387         if (mWifiLock.isHeld()) {
 388             mWifiLock.release();
 389         }
 390     }
 391
 392
 393     /**
 394      * Fully releases the audio focus.
 395      */
 396     private void giveUpAudioFocus() {
 397         if (mAudioFocus == AudioFocus.FOCUS
 398                 && mAudioManager != null
 399                 && AudioManager.AUDIOFOCUS_REQUEST_GRANTED == mAudioManager.abandonAudioFocus(this))  {
 400
 401             mAudioFocus = AudioFocus.NO_FOCUS;
 402         }
 403     }
 404
 405
 406     /**
 407      * Reconfigures MediaPlayer according to audio focus settings and starts/restarts it.
 408      */
 409     protected void configAndStartMediaPlayer() {
 410         if (mPlayer == null) {
 411             throw new IllegalStateException("mPlayer is NULL");
 412         }
 413
 414         if (mAudioFocus == AudioFocus.NO_FOCUS) {
 415             if (mPlayer.isPlaying()) {
 416                 mPlayer.pause();        // have to be polite; but mState is not changed, to resume when focus is received again
 417             }
 418
 419         }  else {
 420             if (mAudioFocus == AudioFocus.NO_FOCUS_CAN_DUCK) {
 421                 mPlayer.setVolume(DUCK_VOLUME, DUCK_VOLUME);
 422
 423             } else {
 424                 mPlayer.setVolume(1.0f, 1.0f); // full volume
 425             }
 426
 427             if (!mPlayer.isPlaying()) {
 428                 mPlayer.start();
 429             }
 430         }
 431     }
 432
 433
 434     /**
 435      * Requests the audio focus to the Audio Manager
 436      */
 437     private void tryToGetAudioFocus() {
 438         if (mAudioFocus != AudioFocus.FOCUS
 439                 && mAudioManager != null
 440                 && (AudioManager.AUDIOFOCUS_REQUEST_GRANTED == mAudioManager.requestAudioFocus( this,
 441                                                                                                 AudioManager.STREAM_MUSIC,
 442                                                                                                 AudioManager.AUDIOFOCUS_GAIN))
 443                 ) {
 444             mAudioFocus = AudioFocus.FOCUS;
 445         }
 446     }
 447
 448
 449     /**
 450      * Starts playing the current media file.
 451      */
 452     protected void playMedia() {
 453         mState = State.STOPPED;
 454         releaseResources(false); // release everything except MediaPlayer
 455
 456         try {
 457             if (mAccount == null) {
 458                 Toast.makeText(this, R.string.media_err_not_in_owncloud, Toast.LENGTH_LONG).show();
 459                 processStopRequest(true);
 460                 return;
 461             }
 462
 463             createMediaPlayerIfNeeded();
 464             mPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
 465             String url = mFile.getStoragePath();
 466
 467             if (url == null || url.length() <= 0) {
 468                 url = AccountUtils.constructFullURLForAccount(this, mAccount) + mFile.getRemotePath();
 469             }
 470             mIsStreaming = url.startsWith("http:") || url.startsWith("https:");
 471
 472             mIsStreaming = false;
 473
 474             mPlayer.setDataSource(url);
 475
 476             mState = State.PREPARING;
 477             setUpAsForeground(String.format(getString(R.string.media_state_loading), mFile.getFileName()));
 478
 479             // starts preparing the media player in background
 480             mPlayer.prepareAsync();
 481
 482             // prevent the Wifi from going to sleep when streaming
 483             if (mIsStreaming) {
 484                 mWifiLock.acquire();
 485             } else if (mWifiLock.isHeld()) {
 486                 mWifiLock.release();
 487             }
 488
 489         } catch (SecurityException e) {
 490             Log_OC.e(TAG, "SecurityException playing " + mAccount.name + mFile.getRemotePath(), e);
 491             Toast.makeText(this, String.format(getString(R.string.media_err_security_ex), mFile.getFileName()), Toast.LENGTH_LONG).show();
 492             processStopRequest(true);
 493
 494         } catch (IOException e) {
 495             Log_OC.e(TAG, "IOException playing " + mAccount.name + mFile.getRemotePath(), e);
 496             Toast.makeText(this, String.format(getString(R.string.media_err_io_ex), mFile.getFileName()), Toast.LENGTH_LONG).show();
 497             processStopRequest(true);
 498
 499         } catch (IllegalStateException e) {
 500             Log_OC.e(TAG, "IllegalStateException " + mAccount.name + mFile.getRemotePath(), e);
 501             Toast.makeText(this, String.format(getString(R.string.media_err_unexpected), mFile.getFileName()), Toast.LENGTH_LONG).show();
 502             processStopRequest(true);
 503
 504         } catch (IllegalArgumentException e) {
 505             Log_OC.e(TAG, "IllegalArgumentException " + mAccount.name + mFile.getRemotePath(), e);
 506             Toast.makeText(this, String.format(getString(R.string.media_err_unexpected), mFile.getFileName()), Toast.LENGTH_LONG).show();
 507             processStopRequest(true);
 508         } catch (AccountUtils.AccountNotFoundException e) {
 509             e.printStackTrace();
 510         }
 511     }
 512
 513
 514     /** Called when media player is done playing current song. */
 515     public void onCompletion(MediaPlayer player) {
 516         Toast.makeText(this, String.format(getString(R.string.media_event_done, mFile.getFileName())), Toast.LENGTH_LONG).show();
 517         if (mMediaController != null) {
 518             // somebody is still bound to the service
 519             player.seekTo(0);
 520             processPauseRequest();
 521             mMediaController.updatePausePlay();
 522         } else {
 523             // nobody is bound
 524             processStopRequest(true);
 525         }
 526         return;
 527     }
 528
 529
 530     /**
 531      * Called when media player is done preparing.
 532      *
 533      * Time to start.
 534      */
 535     public void onPrepared(MediaPlayer player) {
 536         mState = State.PLAYING;
 537         updateNotification(String.format(getString(R.string.media_state_playing), mFile.getFileName()));
 538         if (mMediaController != null) {
 539             mMediaController.setEnabled(true);
 540         }
 541         player.seekTo(mStartPosition);
 542         configAndStartMediaPlayer();
 543         if (!mPlayOnPrepared) {
 544             processPauseRequest();
 545         }
 546
 547         if (mMediaController != null) {
 548             mMediaController.updatePausePlay();
 549         }
 550     }
 551
 552
 553     /**
 554      * Updates the status notification
 555      */
 556     @SuppressWarnings("deprecation")
 557     private void updateNotification(String content) {
 558         // TODO check if updating the Intent is really necessary
 559         Intent showDetailsIntent = new Intent(this, FileDisplayActivity.class);
 560         showDetailsIntent.putExtra(FileActivity.EXTRA_FILE, mFile);
 561         showDetailsIntent.putExtra(FileActivity.EXTRA_ACCOUNT, mAccount);
 562         showDetailsIntent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
 563         mNotification.contentIntent = PendingIntent.getActivity(getApplicationContext(),
 564                                                                 (int)System.currentTimeMillis(),
 565                                                                 showDetailsIntent,
 566                                                                 PendingIntent.FLAG_UPDATE_CURRENT);
 567         mNotification.when = System.currentTimeMillis();
 568         //mNotification.contentView.setTextViewText(R.id.status_text, content);
 569         String ticker = String.format(getString(R.string.media_notif_ticker), getString(R.string.app_name));
 570         mNotification.setLatestEventInfo(getApplicationContext(), ticker, content, mNotification.contentIntent);
 571         mNotificationManager.notify(R.string.media_notif_ticker, mNotification);
 572     }
 573
 574
 575     /**
 576      * Configures the service as a foreground service.
 577      *
 578      * The system will avoid finishing the service as much as possible when resources as low.
 579      *
 580      * A notification must be created to keep the user aware of the existance of the service.
 581      */
 582     @SuppressWarnings("deprecation")
 583     private void setUpAsForeground(String content) {
 584         /// creates status notification
 585         // TODO put a progress bar to follow the playback progress
 586         mNotification = new Notification();
 587         mNotification.icon = android.R.drawable.ic_media_play;
 588         //mNotification.tickerText = text;
 589         mNotification.when = System.currentTimeMillis();
 590         mNotification.flags |= Notification.FLAG_ONGOING_EVENT;
 591         //mNotification.contentView.setTextViewText(R.id.status_text, "ownCloud Music Player");     // NULL POINTER
 592         //mNotification.contentView.setTextViewText(R.id.status_text, getString(R.string.downloader_download_in_progress_content));
 593
 594
 595         /// includes a pending intent in the notification showing the details view of the file
 596         Intent showDetailsIntent = new Intent(this, FileDisplayActivity.class);
 597         showDetailsIntent.putExtra(FileActivity.EXTRA_FILE, mFile);
 598         showDetailsIntent.putExtra(FileActivity.EXTRA_ACCOUNT, mAccount);
 599         showDetailsIntent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
 600         mNotification.contentIntent = PendingIntent.getActivity(getApplicationContext(),
 601                                                                 (int)System.currentTimeMillis(),
 602                                                                 showDetailsIntent,
 603                                                                 PendingIntent.FLAG_UPDATE_CURRENT);
 604
 605
 606         //mNotificationManager.notify(R.string.downloader_download_in_progress_ticker, mNotification);
 607         String ticker = String.format(getString(R.string.media_notif_ticker), getString(R.string.app_name));
 608         mNotification.setLatestEventInfo(getApplicationContext(), ticker, content, mNotification.contentIntent);
 609         startForeground(R.string.media_notif_ticker, mNotification);
 610
 611     }
 612
 613     /**
 614      * Called when there's an error playing media.
 615      *
 616      * Warns the user about the error and resets the media player.
 617      */
 618     public boolean onError(MediaPlayer mp, int what, int extra) {
 619         Log_OC.e(TAG, "Error in audio playback, what = " + what + ", extra = " + extra);
 620
 621         String message = getMessageForMediaError(this, what, extra);
 622         Toast.makeText(getApplicationContext(), message, Toast.LENGTH_SHORT).show();
 623
 624         processStopRequest(true);
 625         return true;
 626     }
 627
 628     /**
 629      * Called by the system when another app tries to play some sound.
 630      *
 631      * {@inheritDoc}
 632      */
 633     @Override
 634     public void onAudioFocusChange(int focusChange) {
 635         if (focusChange > 0) {
 636             // focus gain; check AudioManager.AUDIOFOCUS_* values
 637             mAudioFocus = AudioFocus.FOCUS;
 638             // restart media player with new focus settings
 639             if (mState == State.PLAYING)
 640                 configAndStartMediaPlayer();
 641
 642         } else if (focusChange < 0) {
 643             // focus loss; check AudioManager.AUDIOFOCUS_* values
 644             boolean canDuck = AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK == focusChange;
 645                 mAudioFocus = canDuck ? AudioFocus.NO_FOCUS_CAN_DUCK : AudioFocus.NO_FOCUS;
 646                 // start/restart/pause media player with new focus settings
 647                 if (mPlayer != null && mPlayer.isPlaying())
 648                     configAndStartMediaPlayer();
 649         }
 650
 651     }
 652
 653     /**
 654      * Called when the service is finished for final clean-up.
 655      *
 656      * {@inheritDoc}
 657      */
 658     @Override
 659     public void onDestroy() {
 660         mState = State.STOPPED;
 661         releaseResources(true);
 662         giveUpAudioFocus();
 663         super.onDestroy();
 664     }
 665
 666
 667     /**
 668      * Provides a binder object that clients can use to perform operations on the MediaPlayer managed by the MediaService.
 669      */
 670     @Override
 671     public IBinder onBind(Intent arg) {
 672         return mBinder;
 673     }
 674
 675
 676     /**
 677      * Called when ALL the bound clients were onbound.
 678      *
 679      * The service is destroyed if playback stopped or paused
 680      */
 681     @Override
 682     public boolean onUnbind(Intent intent) {
 683         if (mState == State.PAUSED || mState == State.STOPPED)  {
 684             processStopRequest(false);
 685         }
 686         return false;   // not accepting rebinding (default behaviour)
 687     }
 688
 689
 690     /**
 691      * Accesses the current MediaPlayer instance in the service.
 692      *
 693      * To be handled carefully. Visibility is protected to be accessed only
 694      *
 695      * @return Current MediaPlayer instance handled by MediaService.
 696      */
 697     protected MediaPlayer getPlayer() {
 698         return mPlayer;
 699     }
 700
 701
 702     /**
 703      * Accesses the current OCFile loaded in the service.
 704      *
 705      * @return  The current OCFile loaded in the service.
 706      */
 707     protected OCFile getCurrentFile() {
 708         return mFile;
 709     }
 710
 711
 712     /**
 713      * Accesses the current {@link State} of the MediaService.
 714      *
 715      * @return  The current {@link State} of the MediaService.
 716      */
 717     protected State getState() {
 718         return mState;
 719     }
 720
 721
 722     protected void setMediaContoller(MediaControlView mediaController) {
 723         mMediaController = mediaController;
 724     }
 725
 726     protected MediaControlView getMediaController() {
 727         return mMediaController;
 728     }
 729
 730 }