@Override
  public boolean dispatchKeyEvent(KeyEvent event) {
    int keyCode = event.getKeyCode();
    if (event.getRepeatCount() == 0
        && event.isDown()
        && (keyCode == KeyEvent.KEYCODE_HEADSETHOOK
            || keyCode == KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE
            || keyCode == KeyEvent.KEYCODE_SPACE)) {
      doPauseResume();
      show(sDefaultTimeout);
      if (mPauseButton != null) {
        mPauseButton.requestFocus();
      }
      return true;
    } else if (keyCode == KeyEvent.KEYCODE_MEDIA_STOP) {
      if (mPlayer.isPlaying()) {
        mPlayer.pause();
        updatePausePlay();
      }
      return true;
    } else if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN || keyCode == KeyEvent.KEYCODE_VOLUME_UP) {
      // don't show the controls for volume adjustment
      return super.dispatchKeyEvent(event);
    } else if (keyCode == KeyEvent.KEYCODE_BACK || keyCode == KeyEvent.KEYCODE_MENU) {
      hide();

      return true;
    } else {
      show(sDefaultTimeout);
    }
    return super.dispatchKeyEvent(event);
  }
Beispiel #2
0
        public void onPrepared(MediaPlayer mp) {
          mCurrentState = STATE_PREPARED;
          // modify by lxj
          // Get the capabilities of the player for this stream
          //            Metadata data = mp.getMetadata(MediaPlayer.METADATA_ALL,
          //                                      MediaPlayer.BYPASS_METADATA_FILTER);
          //
          //            if (data != null) {
          //                mCanPause = !data.has(Metadata.PAUSE_AVAILABLE)
          //                        || data.getBoolean(Metadata.PAUSE_AVAILABLE);
          //                mCanSeekBack = !data.has(Metadata.SEEK_BACKWARD_AVAILABLE)
          //                        || data.getBoolean(Metadata.SEEK_BACKWARD_AVAILABLE);
          //                mCanSeekForward = !data.has(Metadata.SEEK_FORWARD_AVAILABLE)
          //                        || data.getBoolean(Metadata.SEEK_FORWARD_AVAILABLE);
          //            } else {
          //                mCanPause = mCanSeekBack = mCanSeekForward = true;
          //            }
          mCanPause = mCanSeekBack = mCanSeekForward = true;

          if (mOnPreparedListener != null) {
            mOnPreparedListener.onPrepared(mMediaPlayer);
          }
          if (mMediaController != null) {
            mMediaController.setEnabled(true);
          }
          mVideoWidth = mp.getVideoWidth();
          mVideoHeight = mp.getVideoHeight();

          int seekToPosition =
              mSeekWhenPrepared; // mSeekWhenPrepared may be changed after seekTo() call
          if (seekToPosition != 0) {
            seekTo(seekToPosition);
          }
          if (mVideoWidth != 0 && mVideoHeight != 0) {
            // Log.i("@@@@", "video size: " + mVideoWidth +"/"+ mVideoHeight);
            getHolder().setFixedSize(mVideoWidth, mVideoHeight);
            if (mSurfaceWidth == mVideoWidth && mSurfaceHeight == mVideoHeight) {
              // We didn't actually change the size (it was already at the size
              // we need), so we won't get a "surface changed" callback, so
              // start the video here instead of in the callback.
              if (mTargetState == STATE_PLAYING) {
                start();
                if (mMediaController != null) {
                  mMediaController.show();
                }
              } else if (!isPlaying() && (seekToPosition != 0 || getCurrentPosition() > 0)) {
                if (mMediaController != null) {
                  // Show the media controls when we're paused into a video and make 'em stick.
                  mMediaController.show(0);
                }
              }
            }
          } else {
            // We don't know the video size yet, but should start anyway.
            // The video size might be reported to us later.
            if (mTargetState == STATE_PLAYING) {
              start();
            }
          }
        }
  @Override
  public boolean onKeyDown(int keyCode, KeyEvent event) {
    if (mIsPrepared
        && keyCode != KeyEvent.KEYCODE_BACK
        && keyCode != KeyEvent.KEYCODE_VOLUME_UP
        && keyCode != KeyEvent.KEYCODE_VOLUME_DOWN
        && keyCode != KeyEvent.KEYCODE_MENU
        && keyCode != KeyEvent.KEYCODE_CALL
        && keyCode != KeyEvent.KEYCODE_ENDCALL
        && mMediaPlayer != null
        && mMediaController != null) {
      if (keyCode == KeyEvent.KEYCODE_HEADSETHOOK || keyCode == KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE) {
        if (mMediaPlayer.isPlaying()) {
          pause();
          mMediaController.show();
        } else {
          start();
          mMediaController.hide();
        }
        return true;
      } else if (keyCode == KeyEvent.KEYCODE_MEDIA_STOP && mMediaPlayer.isPlaying()) {
        pause();
        mMediaController.show();
      } else {
        toggleMediaControlsVisiblity();
      }
    }

    return super.onKeyDown(keyCode, event);
  }
Beispiel #4
0
 public void onPrepared(MediaPlayer mp) {
   // briefly show the mediacontroller
   mIsPrepared = true;
   if (mOnPreparedListener != null) {
     mOnPreparedListener.onPrepared(mMediaPlayer);
   }
   if (mMediaController != null) {
     mMediaController.setEnabled(true);
   }
   mVideoWidth = mp.getVideoWidth();
   mVideoHeight = mp.getVideoHeight();
   if (mVideoWidth != 0 && mVideoHeight != 0) {
     // Log.i("@@@@", "video size: " + mVideoWidth +"/"+
     // mVideoHeight);
     getHolder().setFixedSize(mVideoWidth, mVideoHeight);
     if (mSurfaceWidth == mVideoWidth && mSurfaceHeight == mVideoHeight) {
       // We didn't actually change the size (it was already at the
       // size
       // we need), so we won't get a "surface changed" callback,
       // so
       // start the video here instead of in the callback.
       if (mSeekWhenPrepared != 0) {
         mMediaPlayer.seekTo(mSeekWhenPrepared);
         mSeekWhenPrepared = 0;
       }
       if (mStartWhenPrepared) {
         mMediaPlayer.start();
         mStartWhenPrepared = false;
         if (mMediaController != null) {
           mMediaController.show();
         }
       } else if (!isPlaying() && (mSeekWhenPrepared != 0 || getCurrentPosition() > 0)) {
         if (mMediaController != null) {
           // Show the media controls when we're paused into a
           // video and make 'em stick.
           mMediaController.show(0);
         }
       }
     }
   } else {
     // We don't know the video size yet, but should start anyway.
     // The video size might be reported to us later.
     if (mSeekWhenPrepared != 0) {
       mMediaPlayer.seekTo(mSeekWhenPrepared);
       mSeekWhenPrepared = 0;
     }
     if (mStartWhenPrepared) {
       mMediaPlayer.start();
       mStartWhenPrepared = false;
     }
   }
 }
Beispiel #5
0
 @Override
 public void show() {
   mMediaController.show();
   if (mVideoView != null) {
     mVideoView.setSystemUiVisibility(View.SYSTEM_UI_FLAG_VISIBLE);
   }
 }
 @Override
 public boolean onTouchEvent(MotionEvent event) {
   if (mIsMediaReadyToBePlayed) {
     mMediaController.show();
   }
   return false;
 }
Beispiel #7
0
 private void toggleMediaControlsVisiblity() {
   if (mMediaController.isShowing()) {
     mMediaController.hide();
   } else {
     mMediaController.show();
   }
 }
  @Override
  public boolean dispatchKeyEvent(KeyEvent event) {
    int keyCode = event.getKeyCode();
    final boolean uniqueDown =
        event.getRepeatCount() == 0 && event.getAction() == KeyEvent.ACTION_DOWN;
    if (keyCode == KeyEvent.KEYCODE_HEADSETHOOK
        || keyCode == KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE
        || keyCode == KeyEvent.KEYCODE_SPACE) {
      if (uniqueDown) {
        doPauseResume();
        show(sDefaultTimeout);
        if (mPauseButton != null) {
          mPauseButton.requestFocus();
        }
      }
      return true;
    } else if (keyCode == KeyEvent.KEYCODE_MEDIA_PLAY) {
      if (uniqueDown && !mPlayer.isPlaying()) {
        mPlayer.start();
        updatePausePlay();
        show(sDefaultTimeout);
      }
      return true;
    } else if (keyCode == KeyEvent.KEYCODE_MEDIA_STOP || keyCode == KeyEvent.KEYCODE_MEDIA_PAUSE) {
      if (uniqueDown && mPlayer.isPlaying()) {
        mPlayer.pause();
        updatePausePlay();
        show(sDefaultTimeout);
      }
      return true;
    } else if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN
        || keyCode == KeyEvent.KEYCODE_VOLUME_UP
        || keyCode == KeyEvent.KEYCODE_VOLUME_MUTE
        || keyCode == KeyEvent.KEYCODE_CAMERA) {
      // don't show the controls for volume adjustment
      return super.dispatchKeyEvent(event);
    } else if (keyCode == KeyEvent.KEYCODE_BACK || keyCode == KeyEvent.KEYCODE_MENU) {
      if (uniqueDown) {
        hide();
      }
      return true;
    }

    show(sDefaultTimeout);
    return super.dispatchKeyEvent(event);
  }
 @Override
 public boolean onTouchEvent(MotionEvent event) {
   switch (event.getAction()) {
     case MotionEvent.ACTION_DOWN:
       show(0); // show until hide is called
       break;
     case MotionEvent.ACTION_UP:
       show(sDefaultTimeout); // start timeout
       break;
     case MotionEvent.ACTION_CANCEL:
       hide();
       break;
     default:
       break;
   }
   return true;
 }
  @Override
  public void onPrepared(MediaPlayer mp) {
    mediaPlayer.start();
    mediacontroller.setMediaPlayer(this);
    mediacontroller.setAnchorView(findViewById(R.id.surfaceView));

    mediacontroller.show();
  }
Beispiel #11
0
 public void onPrepared(MediaPlayer mp) {
   // briefly show the mediacontroller
   mIsPrepared = true;
   if (mOnPreparedListener != null) {
     mOnPreparedListener.onPrepared(mMediaPlayer);
   }
   if (mMediaController != null) {
     mMediaController.setEnabled(true);
   }
   mVideoWidth = mp.getVideoWidth();
   mVideoHeight = mp.getVideoHeight();
   if (mVideoWidth != 0 && mVideoHeight != 0) {
     // Log.i("@@@@", "video size: " + mVideoWidth +"/"+ mVideoHeight);
     getHolder().setFixedSize(mVideoWidth, mVideoHeight);
     if (mSurfaceWidth == mVideoWidth && mSurfaceHeight == mVideoHeight) {
       // We didn't actually change the size (it was already at the size
       // we need), so we won't get a "surface changed" callback, so
       // start the video here instead of in the callback.
       if (mSeekWhenPrepared != 0) {
         mMediaPlayer.seekTo(mSeekWhenPrepared);
       }
       if (mStartWhenPrepared) {
         mMediaPlayer.start();
         if (mMediaController != null) {
           mMediaController.show();
         }
       } else if (!isPlaying() && (mSeekWhenPrepared != 0 || getCurrentPosition() > 0)) {
         if (mMediaController != null) {
           mMediaController.show(
               0); // show the media controls when we're paused into a video and make 'em
           // stick.
         }
       }
     }
   } else {
     Log.d(
         "VideoView",
         "Couldn't get video size after prepare(): " + mVideoWidth + "/" + mVideoHeight);
     // The file was probably truncated or corrupt. Start anyway, so
     // that we play whatever short snippet is there and then get
     // the "playback completed" event.
     if (mStartWhenPrepared) {
       mMediaPlayer.start();
     }
   }
 }
        public void onClick(View v) {
          int pos = mPlayer.getCurrentPosition();
          pos += 15000; // milliseconds
          mPlayer.seekTo(pos);
          setProgress();

          show(sDefaultTimeout);
        }
 @Override
 public void onPlayerStateChanged(boolean playWhenReady, int playbackState) {
   Log.d(TAG, "player state " + playbackState);
   if (playbackState == ExoPlayer.STATE_READY) {
     shutterView.setVisibility(View.GONE);
     mediaController.show(0);
   }
 }
 @Override
 public void run() {
   if (DEBUG) {
     Log.d(TAG, "Show video controller");
   }
   if (controller != null) {
     controller.show();
   }
 }
 public void onPrepared(MediaPlayer mediaplayer) {
   Log.d(TAG, "onPrepared called");
   mIsMediaReadyToBePlayed = true;
   if (mMediaPlayer != null && mIsMediaReadyToBePlayed) {
     start();
     if (mMediaController != null) mMediaController.show();
     mProgressBar.setVisibility(View.GONE);
   }
 }
 @Override
 public boolean onTouchEvent(MotionEvent event) {
   /*
    * the MediaController will hide after 3 seconds - tap the screen to
    * make it appear again
    */
   mediacontroller.show();
   return false;
 }
Beispiel #17
0
        public void onPrepared(MediaPlayer mp) {
          mCurrentState = STATE_PREPARED;

          if (mOnPreparedListener != null) {
            mOnPreparedListener.onPrepared(mMediaPlayer);
          }
          if (mMediaController != null) {
            mMediaController.setEnabled(true);
          }
          mVideoWidth = mp.getVideoWidth();
          mVideoHeight = mp.getVideoHeight();

          int seekToPosition =
              mSeekWhenPrepared; // mSeekWhenPrepared may be changed after seekTo() call
          if (seekToPosition != 0) {
            seekTo(seekToPosition);
          }
          if (mVideoWidth != 0 && mVideoHeight != 0) {
            // Log.i("@@@@", "video size: " + mVideoWidth +"/"+ mVideoHeight);
            getHolder().setFixedSize(mVideoWidth, mVideoHeight);
            if (mSurfaceWidth == mVideoWidth && mSurfaceHeight == mVideoHeight) {
              // We didn't actually change the size (it was already at the size
              // we need), so we won't get a "surface changed" callback, so
              // start the video here instead of in the callback.
              if (mTargetState == STATE_PLAYING) {
                start();
                if (mMediaController != null) {
                  mMediaController.show();
                }
              } else if (!isPlaying() && (seekToPosition != 0 || getCurrentPosition() > 0)) {
                if (mMediaController != null) {
                  // Show the media controls when we're paused into a video and make 'em stick.
                  mMediaController.show(0);
                }
              }
            }
          } else {
            // We don't know the video size yet, but should start anyway.
            // The video size might be reported to us later.
            if (mTargetState == STATE_PLAYING) {
              start();
            }
          }
        }
        public void onStopTrackingTouch(SeekBar bar) {
          mDragging = false;
          setProgress();
          updatePausePlay();
          show(sDefaultTimeout);

          // Ensure that progress is properly updated in the future,
          // the call to show() does not guarantee this because it is a
          // no-op if we are already showing.
          mHandler.sendEmptyMessage(SHOW_PROGRESS);
        }
    @Override
    protected void onPostExecute(Uri pResult) {
      super.onPostExecute(pResult);

      try {
        if (isCancelled()) return;

        if (pResult == null) {
          throw new RuntimeException("Invalid NULL Url.");
        }

        mVideoView.setVideoURI(pResult);

        if (isCancelled()) return;

        // TODO:  add listeners for finish of video
        mVideoView.setOnCompletionListener(
            new OnCompletionListener() {

              public void onCompletion(MediaPlayer pMp) {
                if (isCancelled()) return;
                OpenYouTubePlayerActivity.this.finish();
              }
            });

        if (isCancelled()) return;

        final MediaController lMediaController =
            new MediaController(OpenYouTubePlayerActivity.this);
        mVideoView.setMediaController(lMediaController);
        lMediaController.show(0);
        // mVideoView.setKeepScreenOn(true);
        mVideoView.setOnPreparedListener(
            new MediaPlayer.OnPreparedListener() {

              public void onPrepared(MediaPlayer pMp) {
                if (isCancelled()) return;
                OpenYouTubePlayerActivity.this.mProgressBar.setVisibility(View.GONE);
                OpenYouTubePlayerActivity.this.mProgressMessage.setVisibility(View.GONE);
              }
            });

        if (isCancelled()) return;

        mVideoView.requestFocus();
        mVideoView.start();
      } catch (Exception e) {
        Log.e(this.getClass().getSimpleName(), "Error playing video!" + pResult, e);

        if (!mShowedError) {
          showErrorAlert();
        }
      }
    }
        public void onStartTrackingTouch(SeekBar bar) {
          show(3600000);

          mDragging = true;

          // By removing these pending progress messages we make sure
          // that a) we won't update the progress while the user adjusts
          // the seekbar and b) once the user is done dragging the thumb
          // we will post one of these messages to the queue again and
          // this ensures that there will be exactly one message queued up.
          mHandler.removeMessages(SHOW_PROGRESS);
        }
 @Override
 public boolean dispatchKeyEvent(KeyEvent event) {
   int keyCode = event.getKeyCode();
   if (event.getRepeatCount() == 0
       && event.isDown()
       && (keyCode == KeyEvent.KEYCODE_HEADSETHOOK
           || keyCode == KeyEvent.KEYCODE_PLAYPAUSE
           || keyCode == KeyEvent.KEYCODE_SPACE)) {
     doPauseResume();
     show(sDefaultTimeout);
     return true;
   } else if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN || keyCode == KeyEvent.KEYCODE_VOLUME_UP) {
     // don't show the controls for volume adjustment
     return super.dispatchKeyEvent(event);
   } else if (keyCode == KeyEvent.KEYCODE_BACK || keyCode == KeyEvent.KEYCODE_MENU) {
     hide();
   } else {
     show(sDefaultTimeout);
   }
   return super.dispatchKeyEvent(event);
 }
Beispiel #22
0
 public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {
   mSurfaceWidth = w;
   mSurfaceHeight = h;
   if (mMediaPlayer != null && mIsPrepared && mVideoWidth == w && mVideoHeight == h) {
     if (mSeekWhenPrepared != 0) {
       mMediaPlayer.seekTo(mSeekWhenPrepared);
       mSeekWhenPrepared = 0;
     }
     mMediaPlayer.start();
     if (mMediaController != null) {
       mMediaController.show();
     }
   }
 }
Beispiel #23
0
 @Override
 // POINT: 컨트롤러를 다시 보여 준다.
 public boolean onTouchEvent(MotionEvent ev) {
   if (ev.getAction() == MotionEvent.ACTION_DOWN) {
     if (controller.isShowing()) {
       controller.hide();
       // surfaceView.setLayoutParams(new FrameLayout.LayoutParams(
       // videoWidth, videoHeight));
     } else {
       controller.show();
       // surfaceView.setLayoutParams(new FrameLayout.LayoutParams(
       // videoWidth, videoHeight - 75));
     }
   }
   return false;
 }
Beispiel #24
0
 @Override
 public void onClick(View v) {
   switch (v.getId()) {
     case R.id.menuButton:
       if (((ScrollView) mVideoList.getParent()).getVisibility() == View.INVISIBLE) {
         ((ScrollView) mVideoList.getParent()).setVisibility(View.VISIBLE);
         ((ScrollView) mVideoList.getParent()).bringToFront();
         controller.show();
       } else ((ScrollView) mVideoList.getParent()).setVisibility(View.INVISIBLE);
       Log.e("TAG", "menu Button");
       break;
     case R.id.videoList:
       break;
     default:
       break;
   }
 }
Beispiel #25
0
  public void onPrepared(MediaPlayer mp) {
    Log.v(LOGTAG, "onPrepared Called");
    videoWidth = mp.getVideoWidth();
    videoHeight = mp.getVideoHeight();

    // 스크린 사이즈 구하기
    DisplayMetrics metrics = new DisplayMetrics();
    getWindowManager().getDefaultDisplay().getMetrics(metrics);
    int screenWidth = metrics.widthPixels;
    int screenHeight = metrics.heightPixels;

    if (videoWidth > screenWidth || videoHeight > screenHeight) {
      float heightRatio = (float) videoHeight / (float) screenHeight;
      float widthRatio = (float) videoWidth / (float) screenWidth;

      if (heightRatio > 1 || widthRatio > 1) {
        if (heightRatio > widthRatio) {
          videoHeight = (int) Math.ceil((float) videoHeight / (float) heightRatio);
          videoWidth = (int) Math.ceil((float) videoWidth / (float) heightRatio);
        } else {
          videoHeight = (int) Math.ceil((float) videoHeight / (float) widthRatio);
          videoWidth = (int) Math.ceil((float) videoWidth / (float) widthRatio);
        }
      }
    } else {
      videoHeight = screenHeight;
      videoWidth = screenWidth;
    }

    // surfaceView.setLayoutParams(new FrameLayout.LayoutParams(videoWidth,
    // videoHeight - 75));
    mp.start();

    // 미디어 플레이어의 컨트롤러를 설정하고 보이기
    controller.setMediaPlayer(this);
    controller.setAnchorView(this.findViewById(R.id.controllerView));
    controller.setEnabled(true);
    controller.show();
  }
 @Override
 public void onDrawnToSurface(Surface surface) {
   shutterView.setVisibility(View.GONE);
   mediaController.show(0);
 }
 public void onClick(View v) {
   doPauseResume();
   show(sDefaultTimeout);
 }
 private void showControls() {
   mediaController.show(0);
   // debugRootView.setVisibility(View.VISIBLE);
 }
 private void f()
 {
   if ((a()) && (o.getVisibility() != 0)) {
     p.show();
   }
 }
Beispiel #30
0
 @Override
 public void show(int timeout_ms) {
   mMediaController.show(timeout_ms);
 }