src/com/owncloud/android/ui/preview/PreviewMediaFragment.java

   1 /* ownCloud Android client application
   2  *   Copyright (C) 2012-2013 ownCloud Inc.
   3  *
   4  *   This program is free software: you can redistribute it and/or modify
   5  *   it under the terms of the GNU General Public License version 2,
   6  *   as published by the Free Software Foundation.
   7  *
   8  *   This program is distributed in the hope that it will be useful,
   9  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  *   GNU General Public License for more details.
  12  *
  13  *   You should have received a copy of the GNU General Public License
  14  *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
  15  *
  16  */
  17 package com.owncloud.android.ui.preview;
  18
  19 import android.accounts.Account;
  20 import android.app.Activity;
  21 import android.app.AlertDialog;
  22 import android.content.ComponentName;
  23 import android.content.Context;
  24 import android.content.DialogInterface;
  25 import android.content.Intent;
  26 import android.content.ServiceConnection;
  27 import android.content.res.Configuration;
  28 import android.media.MediaPlayer;
  29 import android.media.MediaPlayer.OnCompletionListener;
  30 import android.media.MediaPlayer.OnErrorListener;
  31 import android.media.MediaPlayer.OnPreparedListener;
  32 import android.os.Build;
  33 import android.os.Bundle;
  34 import android.os.IBinder;
  35 import android.view.LayoutInflater;
  36 import android.view.MotionEvent;
  37 import android.view.View;
  38 import android.view.View.OnTouchListener;
  39 import android.view.ViewGroup;
  40 import android.widget.ImageView;
  41 import android.widget.Toast;
  42 import android.widget.VideoView;
  43
  44 import com.actionbarsherlock.view.Menu;
  45 import com.actionbarsherlock.view.MenuInflater;
  46 import com.actionbarsherlock.view.MenuItem;
  47 import com.owncloud.android.R;
  48 import com.owncloud.android.datamodel.OCFile;
  49 import com.owncloud.android.files.FileMenuFilter;
  50 import com.owncloud.android.media.MediaControlView;
  51 import com.owncloud.android.media.MediaService;
  52 import com.owncloud.android.media.MediaServiceBinder;
  53 import com.owncloud.android.ui.activity.FileActivity;
  54 import com.owncloud.android.ui.dialog.ConfirmationDialogFragment;
  55 import com.owncloud.android.ui.dialog.RemoveFileDialogFragment;
  56 import com.owncloud.android.ui.fragment.FileFragment;
  57 import com.owncloud.android.utils.Log_OC;
  58
  59
  60 /**
  61  * This fragment shows a preview of a downloaded media file (audio or video).
  62  *
  63  * Trying to get an instance with NULL {@link OCFile} or ownCloud {@link Account} values will produce an {@link IllegalStateException}.
  64  *
  65  * By now, if the {@link OCFile} passed is not downloaded, an {@link IllegalStateException} is generated on instantiation too.
  66  *
  67  * @author David A. Velasco
  68  */
  69 public class PreviewMediaFragment extends FileFragment implements
  70         OnTouchListener {
  71
  72     public static final String EXTRA_FILE = "FILE";
  73     public static final String EXTRA_ACCOUNT = "ACCOUNT";
  74     private static final String EXTRA_PLAY_POSITION = "PLAY_POSITION";
  75     private static final String EXTRA_PLAYING = "PLAYING";
  76
  77     private View mView;
  78     private Account mAccount;
  79     private ImageView mImagePreview;
  80     private VideoView mVideoPreview;
  81     private int mSavedPlaybackPosition;
  82
  83     private MediaServiceBinder mMediaServiceBinder = null;
  84     private MediaControlView mMediaController = null;
  85     private MediaServiceConnection mMediaServiceConnection = null;
  86     private VideoHelper mVideoHelper;
  87     private boolean mAutoplay;
  88     public boolean mPrepared;
  89
  90     private static final String TAG = PreviewMediaFragment.class.getSimpleName();
  91
  92
  93     /**
  94      * Creates a fragment to preview a file.
  95      *
  96      * When 'fileToDetail' or 'ocAccount' are null
  97      *
  98      * @param fileToDetail      An {@link OCFile} to preview in the fragment
  99      * @param ocAccount         An ownCloud account; needed to start downloads
 100      */
 101     public PreviewMediaFragment(
 102             OCFile fileToDetail,
 103             Account ocAccount,
 104             int startPlaybackPosition,
 105             boolean autoplay) {
 106
 107         super(fileToDetail);
 108         mAccount = ocAccount;
 109         mSavedPlaybackPosition = startPlaybackPosition;
 110         mAutoplay = autoplay;
 111     }
 112
 113
 114     /**
 115      *  Creates an empty fragment for previews.
 116      *
 117      *  MUST BE KEPT: the system uses it when tries to reinstantiate a fragment automatically
 118      *  (for instance, when the device is turned a aside).
 119      *
 120      *  DO NOT CALL IT: an {@link OCFile} and {@link Account} must be provided for a successful
 121      *  construction
 122      */
 123     public PreviewMediaFragment() {
 124         super();
 125         mAccount = null;
 126         mSavedPlaybackPosition = 0;
 127         mAutoplay = true;
 128     }
 129
 130
 131     /**
 132      * {@inheritDoc}
 133      */
 134     @Override
 135     public void onCreate(Bundle savedInstanceState) {
 136         super.onCreate(savedInstanceState);
 137         setHasOptionsMenu(true);
 138     }
 139
 140
 141     /**
 142      * {@inheritDoc}
 143      */
 144     @Override
 145     public View onCreateView(LayoutInflater inflater, ViewGroup container,
 146             Bundle savedInstanceState) {
 147         super.onCreateView(inflater, container, savedInstanceState);
 148         Log_OC.e(TAG, "onCreateView");
 149
 150
 151         mView = inflater.inflate(R.layout.file_preview, container, false);
 152
 153         mImagePreview = (ImageView)mView.findViewById(R.id.image_preview);
 154         mVideoPreview = (VideoView)mView.findViewById(R.id.video_preview);
 155         mVideoPreview.setOnTouchListener(this);
 156
 157         mMediaController = (MediaControlView)mView.findViewById(R.id.media_controller);
 158
 159         return mView;
 160     }
 161
 162
 163     /**
 164      * {@inheritDoc}
 165      */
 166     @Override
 167     public void onActivityCreated(Bundle savedInstanceState) {
 168         super.onActivityCreated(savedInstanceState);
 169         Log_OC.e(TAG, "onActivityCreated");
 170
 171         OCFile file = getFile();
 172         if (savedInstanceState == null) {
 173             if (file == null) {
 174                 throw new IllegalStateException("Instanced with a NULL OCFile");
 175             }
 176             if (mAccount == null) {
 177                 throw new IllegalStateException("Instanced with a NULL ownCloud Account");
 178             }
 179             if (!file.isDown()) {
 180                 throw new IllegalStateException("There is no local file to preview");
 181             }
 182
 183         } else {
 184             file = (OCFile)savedInstanceState.getParcelable(PreviewMediaFragment.EXTRA_FILE);
 185             setFile(file);
 186             mAccount = savedInstanceState.getParcelable(PreviewMediaFragment.EXTRA_ACCOUNT);
 187             mSavedPlaybackPosition =
 188                     savedInstanceState.getInt(PreviewMediaFragment.EXTRA_PLAY_POSITION);
 189             mAutoplay = savedInstanceState.getBoolean(PreviewMediaFragment.EXTRA_PLAYING);
 190
 191         }
 192         if (file != null && file.isDown()) {
 193             if (file.isVideo()) {
 194                 mVideoPreview.setVisibility(View.VISIBLE);
 195                 mImagePreview.setVisibility(View.GONE);
 196                 prepareVideo();
 197
 198             } else {
 199                 mVideoPreview.setVisibility(View.GONE);
 200                 mImagePreview.setVisibility(View.VISIBLE);
 201             }
 202         }
 203
 204     }
 205
 206
 207     /**
 208      * {@inheritDoc}
 209      */
 210     @Override
 211     public void onSaveInstanceState(Bundle outState) {
 212         super.onSaveInstanceState(outState);
 213         Log_OC.e(TAG, "onSaveInstanceState");
 214
 215         outState.putParcelable(PreviewMediaFragment.EXTRA_FILE, getFile());
 216         outState.putParcelable(PreviewMediaFragment.EXTRA_ACCOUNT, mAccount);
 217
 218         if (getFile().isVideo()) {
 219             mSavedPlaybackPosition = mVideoPreview.getCurrentPosition();
 220             mAutoplay = mVideoPreview.isPlaying();
 221             outState.putInt(PreviewMediaFragment.EXTRA_PLAY_POSITION , mSavedPlaybackPosition);
 222             outState.putBoolean(PreviewMediaFragment.EXTRA_PLAYING , mAutoplay);
 223         } else {
 224             outState.putInt(
 225                     PreviewMediaFragment.EXTRA_PLAY_POSITION ,
 226                     mMediaServiceBinder.getCurrentPosition());
 227             outState.putBoolean(
 228                     PreviewMediaFragment.EXTRA_PLAYING , mMediaServiceBinder.isPlaying());
 229         }
 230     }
 231
 232
 233     @Override
 234     public void onStart() {
 235         super.onStart();
 236         Log_OC.e(TAG, "onStart");
 237
 238         OCFile file = getFile();
 239         if (file != null && file.isDown()) {
 240            if (file.isAudio()) {
 241                bindMediaService();
 242
 243            } else if (file.isVideo()) {
 244                stopAudio();
 245                playVideo();
 246            }
 247         }
 248     }
 249
 250
 251     private void stopAudio() {
 252         Intent i = new Intent(getSherlockActivity(), MediaService.class);
 253         i.setAction(MediaService.ACTION_STOP_ALL);
 254         getSherlockActivity().startService(i);
 255     }
 256
 257
 258     /**
 259      * {@inheritDoc}
 260      */
 261     @Override
 262     public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
 263         super.onCreateOptionsMenu(menu, inflater);
 264         inflater.inflate(R.menu.file_actions_menu, menu);
 265     }
 266
 267
 268     /**
 269      * {@inheritDoc}
 270      */
 271     @Override
 272     public void onPrepareOptionsMenu(Menu menu) {
 273         super.onPrepareOptionsMenu(menu);
 274
 275         if (mContainerActivity.getStorageManager() != null) {
 276             FileMenuFilter mf = new FileMenuFilter(
 277                 getFile(),
 278                 mContainerActivity.getStorageManager().getAccount(),
 279                 mContainerActivity,
 280                 getSherlockActivity()
 281             );
 282             mf.filter(menu);
 283         }
 284
 285         // additional restriction for this fragment
 286         // TODO allow renaming in PreviewImageFragment
 287         MenuItem item = menu.findItem(R.id.action_rename_file);
 288         if (item != null) {
 289             item.setVisible(false);
 290             item.setEnabled(false);
 291         }
 292     }
 293
 294
 295     /**
 296      * {@inheritDoc}
 297      */
 298     @Override
 299     public boolean onOptionsItemSelected(MenuItem item) {
 300         switch (item.getItemId()) {
 301             case R.id.action_share_file: {
 302                 stopPreview(false);
 303                 mContainerActivity.getFileOperationsHelper().shareFileWithLink(getFile());
 304                 return true;
 305             }
 306             case R.id.action_unshare_file: {
 307                 stopPreview(false);
 308                 mContainerActivity.getFileOperationsHelper().unshareFileWithLink(getFile());
 309                 return true;
 310             }
 311             case R.id.action_open_file_with: {
 312                 openFile();
 313                 return true;
 314             }
 315             case R.id.action_remove_file: {
 316                 RemoveFileDialogFragment dialog = RemoveFileDialogFragment.newInstance(getFile());
 317                 dialog.show(getFragmentManager(), ConfirmationDialogFragment.FTAG_CONFIRMATION);
 318                 return true;
 319             }
 320             case R.id.action_see_details: {
 321                 seeDetails();
 322                 return true;
 323             }
 324             case R.id.action_send_file: {
 325                 sendFile();
 326                 return true;
 327             }
 328             case R.id.action_sync_file: {
 329                 mContainerActivity.getFileOperationsHelper().syncFile(getFile());
 330                 return true;
 331             }
 332
 333             default:
 334                 return false;
 335         }
 336     }
 337
 338
 339
 340     /**
 341      * Update the file of the fragment with file value
 342      * @param file
 343      */
 344     public void updateFile(OCFile file){
 345         setFile(file);
 346     }
 347
 348     private void sendFile() {
 349         stopPreview(false);
 350         mContainerActivity.getFileOperationsHelper().sendDownloadedFile(getFile());
 351
 352     }
 353
 354     private void seeDetails() {
 355         stopPreview(false);
 356         mContainerActivity.showDetails(getFile());
 357     }
 358
 359
 360     private void prepareVideo() {
 361         // create helper to get more control on the playback
 362         mVideoHelper = new VideoHelper();
 363         mVideoPreview.setOnPreparedListener(mVideoHelper);
 364         mVideoPreview.setOnCompletionListener(mVideoHelper);
 365         mVideoPreview.setOnErrorListener(mVideoHelper);
 366     }
 367
 368     private void playVideo() {
 369         // create and prepare control panel for the user
 370         mMediaController.setMediaPlayer(mVideoPreview);
 371
 372         // load the video file in the video player ;
 373         // when done, VideoHelper#onPrepared() will be called
 374         mVideoPreview.setVideoPath(getFile().getStoragePath());
 375     }
 376
 377
 378     private class VideoHelper implements OnCompletionListener, OnPreparedListener, OnErrorListener {
 379
 380         /**
 381          * Called when the file is ready to be played.
 382          *
 383          * Just starts the playback.
 384          *
 385          * @param   mp    {@link MediaPlayer} instance performing the playback.
 386          */
 387         @Override
 388         public void onPrepared(MediaPlayer vp) {
 389             Log_OC.e(TAG, "onPrepared");
 390             mVideoPreview.seekTo(mSavedPlaybackPosition);
 391             if (mAutoplay) {
 392                 mVideoPreview.start();
 393             }
 394             mMediaController.setEnabled(true);
 395             mMediaController.updatePausePlay();
 396             mPrepared = true;
 397         }
 398
 399
 400         /**
 401          * Called when the file is finished playing.
 402          *
 403          * Finishes the activity.
 404          *
 405          * @param   mp    {@link MediaPlayer} instance performing the playback.
 406          */
 407         @Override
 408         public void onCompletion(MediaPlayer  mp) {
 409             Log_OC.e(TAG, "completed");
 410             if (mp != null) {
 411                 mVideoPreview.seekTo(0);
 412                 // next lines are necessary to work around undesired video loops
 413                 if (Build.VERSION.SDK_INT == Build.VERSION_CODES.GINGERBREAD) {
 414                     mVideoPreview.pause();
 415
 416                 } else if (Build.VERSION.SDK_INT == Build.VERSION_CODES.GINGERBREAD_MR1) {
 417                     // mVideePreview.pause() is not enough
 418
 419                     mMediaController.setEnabled(false);
 420                     mVideoPreview.stopPlayback();
 421                     mAutoplay = false;
 422                     mSavedPlaybackPosition = 0;
 423                     mVideoPreview.setVideoPath(getFile().getStoragePath());
 424                 }
 425             } // else : called from onError()
 426             mMediaController.updatePausePlay();
 427         }
 428
 429
 430         /**
 431          * Called when an error in playback occurs.
 432          *
 433          * @param   mp      {@link MediaPlayer} instance performing the playback.
 434          * @param   what    Type of error
 435          * @param   extra   Extra code specific to the error
 436          */
 437         @Override
 438         public boolean onError(MediaPlayer mp, int what, int extra) {
 439             if (mVideoPreview.getWindowToken() != null) {
 440                 String message = MediaService.getMessageForMediaError(
 441                         getSherlockActivity(), what, extra);
 442                 new AlertDialog.Builder(getSherlockActivity())
 443                         .setMessage(message)
 444                         .setPositiveButton(android.R.string.VideoView_error_button,
 445                                 new DialogInterface.OnClickListener() {
 446                                     public void onClick(DialogInterface dialog, int whichButton) {
 447                                         dialog.dismiss();
 448                                         VideoHelper.this.onCompletion(null);
 449                                     }
 450                                 })
 451                         .setCancelable(false)
 452                         .show();
 453             }
 454             return true;
 455         }
 456
 457     }
 458
 459
 460     @Override
 461     public void onPause() {
 462         Log_OC.e(TAG, "onPause");
 463         super.onPause();
 464     }
 465
 466     @Override
 467     public void onResume() {
 468         super.onResume();
 469         Log_OC.e(TAG, "onResume");
 470     }
 471
 472     @Override
 473     public void onDestroy() {
 474         Log_OC.e(TAG, "onDestroy");
 475         super.onDestroy();
 476     }
 477
 478     @Override
 479     public void onStop() {
 480         Log_OC.e(TAG, "onStop");
 481
 482         mPrepared = false;
 483         if (mMediaServiceConnection != null) {
 484             Log_OC.d(TAG, "Unbinding from MediaService ...");
 485             if (mMediaServiceBinder != null && mMediaController != null) {
 486                 mMediaServiceBinder.unregisterMediaController(mMediaController);
 487             }
 488             getSherlockActivity().unbindService(mMediaServiceConnection);
 489             mMediaServiceConnection = null;
 490             mMediaServiceBinder = null;
 491         }
 492
 493         super.onStop();
 494     }
 495
 496     @Override
 497     public boolean onTouch(View v, MotionEvent event) {
 498         if (event.getAction() == MotionEvent.ACTION_DOWN && v == mVideoPreview) {
 499             startFullScreenVideo();
 500             return true;
 501         }
 502         return false;
 503     }
 504
 505
 506     private void startFullScreenVideo() {
 507         Intent i = new Intent(getSherlockActivity(), PreviewVideoActivity.class);
 508         i.putExtra(FileActivity.EXTRA_ACCOUNT, mAccount);
 509         i.putExtra(FileActivity.EXTRA_FILE, getFile());
 510         i.putExtra(PreviewVideoActivity.EXTRA_AUTOPLAY, mVideoPreview.isPlaying());
 511         mVideoPreview.pause();
 512         i.putExtra(PreviewVideoActivity.EXTRA_START_POSITION, mVideoPreview.getCurrentPosition());
 513         startActivityForResult(i, 0);
 514     }
 515
 516     @Override
 517     public void onConfigurationChanged (Configuration newConfig) {
 518         Log_OC.e(TAG, "onConfigurationChanged " + this);
 519     }
 520
 521     @Override
 522     public void onActivityResult (int requestCode, int resultCode, Intent data) {
 523         Log_OC.e(TAG, "onActivityResult " + this);
 524         super.onActivityResult(requestCode, resultCode, data);
 525         if (resultCode == Activity.RESULT_OK) {
 526             mSavedPlaybackPosition = data.getExtras().getInt(
 527                     PreviewVideoActivity.EXTRA_START_POSITION);
 528             mAutoplay = data.getExtras().getBoolean(PreviewVideoActivity.EXTRA_AUTOPLAY);
 529         }
 530     }
 531
 532
 533     private void playAudio() {
 534         OCFile file = getFile();
 535         if (!mMediaServiceBinder.isPlaying(file)) {
 536             Log_OC.d(TAG, "starting playback of " + file.getStoragePath());
 537             mMediaServiceBinder.start(mAccount, file, mAutoplay, mSavedPlaybackPosition);
 538
 539         } else {
 540             if (!mMediaServiceBinder.isPlaying() && mAutoplay) {
 541                 mMediaServiceBinder.start();
 542                 mMediaController.updatePausePlay();
 543             }
 544         }
 545     }
 546
 547
 548     private void bindMediaService() {
 549         Log_OC.d(TAG, "Binding to MediaService...");
 550         if (mMediaServiceConnection == null) {
 551             mMediaServiceConnection = new MediaServiceConnection();
 552         }
 553         getSherlockActivity().bindService(  new Intent(getSherlockActivity(),
 554                                     MediaService.class),
 555                                     mMediaServiceConnection,
 556                                     Context.BIND_AUTO_CREATE);
 557             // follow the flow in MediaServiceConnection#onServiceConnected(...)
 558     }
 559
 560     /** Defines callbacks for service binding, passed to bindService() */
 561     private class MediaServiceConnection implements ServiceConnection {
 562
 563         @Override
 564         public void onServiceConnected(ComponentName component, IBinder service) {
 565             if (getSherlockActivity() != null) {
 566                 if (component.equals(
 567                         new ComponentName(getSherlockActivity(), MediaService.class))) {
 568                     Log_OC.d(TAG, "Media service connected");
 569                     mMediaServiceBinder = (MediaServiceBinder) service;
 570                     if (mMediaServiceBinder != null) {
 571                         prepareMediaController();
 572                         playAudio();    // do not wait for the touch of nobody to play audio
 573
 574                         Log_OC.d(TAG, "Successfully bound to MediaService, MediaController ready");
 575
 576                     } else {
 577                         Log_OC.e(TAG, "Unexpected response from MediaService while binding");
 578                     }
 579                 }
 580             }
 581         }
 582
 583         private void prepareMediaController() {
 584             mMediaServiceBinder.registerMediaController(mMediaController);
 585             if (mMediaController != null) {
 586                 mMediaController.setMediaPlayer(mMediaServiceBinder);
 587                 mMediaController.setEnabled(true);
 588                 mMediaController.updatePausePlay();
 589             }
 590         }
 591
 592         @Override
 593         public void onServiceDisconnected(ComponentName component) {
 594             if (component.equals(new ComponentName(getSherlockActivity(), MediaService.class))) {
 595                 Log_OC.e(TAG, "Media service suddenly disconnected");
 596                 if (mMediaController != null) {
 597                     mMediaController.setMediaPlayer(null);
 598                 } else {
 599                     Toast.makeText(
 600                             getSherlockActivity(),
 601                             "No media controller to release when disconnected from media service",
 602                             Toast.LENGTH_SHORT).show();
 603                 }
 604                 mMediaServiceBinder = null;
 605                 mMediaServiceConnection = null;
 606             }
 607         }
 608     }
 609
 610
 611
 612     /**
 613      * Opens the previewed file with an external application.
 614      */
 615     private void openFile() {
 616         stopPreview(true);
 617         mContainerActivity.getFileOperationsHelper().openFile(getFile());
 618         finish();
 619     }
 620
 621     /**
 622      * Helper method to test if an {@link OCFile} can be passed to a {@link PreviewMediaFragment}
 623      *  to be previewed.
 624      *
 625      * @param file      File to test if can be previewed.
 626      * @return          'True' if the file can be handled by the fragment.
 627      */
 628     public static boolean canBePreviewed(OCFile file) {
 629         return (file != null && (file.isAudio() || file.isVideo()));
 630     }
 631
 632
 633     public void stopPreview(boolean stopAudio) {
 634         OCFile file = getFile();
 635         if (file.isAudio() && stopAudio) {
 636             mMediaServiceBinder.pause();
 637
 638         } else if (file.isVideo()) {
 639             mVideoPreview.stopPlayback();
 640         }
 641     }
 642
 643
 644
 645     /**
 646      * Finishes the preview
 647      */
 648     private void finish() {
 649         getSherlockActivity().onBackPressed();
 650     }
 651
 652
 653     public int getPosition() {
 654         if (mPrepared) {
 655             mSavedPlaybackPosition = mVideoPreview.getCurrentPosition();
 656         }
 657         Log_OC.e(TAG, "getting position: " + mSavedPlaybackPosition);
 658         return mSavedPlaybackPosition;
 659     }
 660
 661     public boolean isPlaying() {
 662         if (mPrepared) {
 663             mAutoplay = mVideoPreview.isPlaying();
 664         }
 665         return mAutoplay;
 666     }
 667
 668 }