Resume the playback.
519380
private void resume() {
        if (mIsPaused) {
            mIsPaused = false;
            mIsPausedAfterAudioFocusChanged = false;
            // Try to gain the audio focus before preparing and starting the media player.
            if (mAudioManager.requestAudioFocus(this, AudioManager.STREAM_MUSIC, AudioManager.AUDIOFOCUS_GAIN)
                    == AudioManager.AUDIOFOCUS_REQUEST_GRANTED) {
                mMediaPlayer.start();

                Intent intent = new Intent(PlaybackListener.ACTION_ON_TRACK_PLAYED);
                intent.putExtra(PlaybackListener.EXTRA_KEY_TRACK,
                        mPlayerPlaylist.getCurrentTrack());
                mLocalBroadcastManager.sendBroadcast(intent);

                updateNotification();
                mMediaSession.setPlaybackState(MediaSessionWrapper.PLAYBACK_STATE_PLAYING);
                resumeTimer();
            }
        }
    }
93562
def _no_mute_on_stop_playback(self):
        
        if self.ctrl_c_pressed:
            return
        if self.isPlaying():
            if self.actual_volume == -1:
                self._get_volume()
                while self.actual_volume == -1:
                    pass
            if self.actual_volume == 0:
                self.actual_volume = int(self.max_volume*0.25)
                self._sendCommand('volume {}\n'.format(self.actual_volume))
                if logger.isEnabledFor(logging.DEBUG):
                    logger.debug('Unmuting VLC on exit: {} (25%)'.format(self.actual_volume))
            elif self.muted:
                if self.actual_volume > 0:
                    self._sendCommand('volume {}\n'.format(self.actual_volume))
                    if logger.isEnabledFor(logging.DEBUG):
                        logger.debug('VLC volume restored on exit: {0} ({1}%)'.format(self.actual_volume, int(100 * self.actual_volume / self.max_volume)))

            self.show_volume = True
355760
def stop(self):
        """"""
        self.prestop()
        if not self._graceful:
            self._graceful = True
        self.stream.stop_stream()
        self.audio.terminate()
        msg = 'Stopped'
        self.verbose_info(msg, log=False)
        # Log 'Stopped' anyway
        if self.log:
            self.logging.info(msg)
        if self.collect:
            if self._data:
                print('Collected result:')
                print('    min: %10d' % self._data['min'])
                print('    max: %10d' % self._data['max'])
                print('    avg: %10d' % int(self._data['avg']))
        self.poststop()
45553
def pause(self):
        """"""
        if self.state == STATE_PLAYING:
            self._player.set_state(Gst.State.PAUSED)
            self.state = STATE_PAUSED
159660
def resume(self):
        """"""
        for client in self._snippet_clients.values():
            # Resume is only applicable if a client is alive and does not have
            # a host port.
            if client.is_alive and client.host_port is None:
                self._device.log.debug('Resuming SnippetClient<%s>.',
                                       client.package)
                client.restore_app_connection()
            else:
                self._device.log.debug('Not resuming SnippetClient<%s>.',
                                       client.package)
1081554
public void pause() {
        new ExecutionChain(mGvrContext).runOnMainThread(new Runnable() {
            @Override
            public void run() {
                if (!mContentSceneViewStack.isEmpty()) {
                    mContentSceneViewStack.peek().hide();
                    WidgetLib.getTouchManager().setFlingHandler(null);
                }
            }
        }).execute();
    }
877421
public function pauseRecv()
    {
        Worker::$globalEvent->del($this->_socket, EventInterface::EV_READ);
        $this->_isPaused = true;
    }
792797
public void resume() {
        switch (status) {
            case PLAYING:
                return;

            case STOPPED:
                play();
                return;

            default:
                status = Status.PLAYING;

                PlayList pl = getPlaylist();
                if (pl.isAutoAdvanceEnabled()) {
                    slideHandler.removeCallbacks(moveToNextSlide);
                    slideHandler.postDelayed(moveToNextSlide, pl.getSlideDuration(pl.getCurrentSlide()));
                }
        }
    }
240677
function restartMediaPlayer () {
        exitingSeek = false;
        pauseOnExitSeek = false;
        var source = mediaPlayer.getSource();
        var mimeType = mediaPlayer.getMimeType();

        reset();
        mediaPlayer.initialiseMedia('video', source, mimeType, playbackElement, setSourceOpts);
        mediaPlayer.beginPlaybackFrom(currentTime + timeCorrection || 0);
      }
120441
function() {
        sound._paused = false;
        sound._seek = seek;
        sound._start = start;
        sound._stop = stop;
        sound._loop = loop;
      }
23453
def play(self):
        """"""
        if self.state == STATE_PAUSED:
            self._player.set_state(Gst.State.PLAYING)
            self.state = STATE_PLAYING
798640
def _resume(self):
        """"""
        try:
            self._cursor.close()
        except PyMongoError:
            pass
        self._cursor = self._create_cursor()
499187
public synchronized final void pause() {
        if (isStop) return ;

        isPause = true;
        mPauseTimeInFuture = mStopTimeInFuture - SystemClock.elapsedRealtime();
        mHandler.removeMessages(MSG);
    }
353151
def pause_resume(self):
        """"""
        if self.is_paused():
            urlopen(self.url + "&mode=resume")
        else:
            urlopen(self.url + "&mode=pause")
205865
public function stop()
    {
        foreach (array_reverse($this->getArrayCopy()) as $playback) {
            /* @var $playback Playback */
            try {
                $this->phparia->playbacks()->stopPlayback($playback->getId());
            } catch (\Exception $ignore) {
                // Don't throw exception if the playback does not exist
            }
        }
    }
1032925
public void pause ()
    {
        if (_state != AL10.AL_PLAYING) {
            log.warning("Tried to pause stream that wasn't playing.");
            return;
        }
        _source.pause();
        _state = AL10.AL_PAUSED;
    }
169856
def resume(self):
        """"""
        with self._wake:
            self._paused = False
            self._wake.notifyAll()