Android 使用videoview按home（主页）按钮后重新启动应用程序状态

我有一个视频播放器，当我启动它并按下launcher图标，然后再次启动应用程序时，视频将从原来的位置开始播放。当我暂停视频并按下launcher图标，然后再次启动应用程序时。视频未处于暂停状态。再次从最后一个位置开始。提前感谢

public class VideoFullscreenActivity extends Activity {


    private static boolean startFromZero = false;
    VideoView videoView;

    private  static  boolean isplaying = false;

    ProgressDialog pDialog;
    SharedPreferences.Editor editor;

    SharedPreferences prefs;
    int restoredPosition;

    public static boolean isStartFromZero() {
        return startFromZero;
    }


    public static void setStartFromZero(boolean startFromZero) {
        VideoFullscreenActivity.startFromZero = startFromZero;
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_video_fullscreen);
        videoView = (VideoView) findViewById(R.id.videoview);
        editor = getSharedPreferences("VIDEO_POSITION", MODE_PRIVATE).edit();

        prefs = getSharedPreferences("VIDEO_POSITION", MODE_PRIVATE);


        if (startFromZero) {
            editor.putInt("CURRENT_POSITION", 0);//stopPosition is an int
            editor.commit();
        } else {
            setStartFromZero(false);
        }

        restoredPosition = prefs.getInt("CURRENT_POSITION", 0);

        if (Utilities.checkInternetConnection(this)) {


            Intent intent = getIntent();

            pDialog = new ProgressDialog(this);
            // Set progressbar message
            pDialog.setMessage("Buffering...");
            pDialog.setIndeterminate(false);
            pDialog.setCancelable(true);
            // Show progressbar
            pDialog.show();

            MediaController mediaController = new
                    MediaController(this);
            mediaController.setAnchorView(videoView);
            videoView.setMediaController(mediaController);

            if(intent.getStringExtra(Constants.URL)!= null)
            {
                Uri videoUri = Uri.parse(intent.getStringExtra(Constants.URL));
                videoView.setVideoURI(videoUri);

            } else if (intent.getStringExtra("VideoUrl") != null)
            {
                Map<String, String> headers = new HashMap();
                headers.put(APP_KEY, APPKEY_VALUE);
                headers.put(SESSION_ID, SharedInstance.getInstance().getLoginDetails().getSessionId());

                Uri uri = Uri.parse(intent.getStringExtra("VideoUrl"));
                Method setVideoURIMethod = null;
                try {
                    setVideoURIMethod = videoView.getClass().getMethod("setVideoURI", Uri.class, Map.class);
                    setVideoURIMethod.invoke(videoView, uri,headers);
                } catch (NoSuchMethodException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
                //videoView.setVideoURI(uri,headers);
            }
            videoView.setOnPreparedListener(new MediaPlayer.OnPreparedListener() {
                // Close the progress bar and play the video
                public void onPrepared(MediaPlayer mp) {
                    pDialog.dismiss();
                    videoView.start();
                }
            });

            if (prefs != null) {
                restoredPosition = prefs.getInt("CURRENT_POSITION", 0); //0 is the default value.
            }
            videoView.seekTo(restoredPosition);
            videoView.start();
            Log.i("positionPlayback", "onCreate " + restoredPosition);

        } else {
            Utilities.showAlertLoginDialog(this, "", getResources().getString(R.string.internet_unavailable_msg));
        }
        videoView.setOnCompletionListener(new MediaPlayer.OnCompletionListener() {
            @Override
            public void onCompletion(MediaPlayer mediaPlayer) {
                onBackPressed();
            }
        });

//---------------------------------------------------------------//

        videoView.setOnPreparedListener(new MediaPlayer.OnPreparedListener() {
            @Override
            public void onPrepared(MediaPlayer mediaPlayer) {
                this.onPrepared(mediaPlayer);
            }
        });
    }

    @Override
    public void onPause() {
        super.onPause();
        Log.i("positionPlayback", "onPause " + restoredPosition);
        if (videoView != null && videoView.isPlaying()) {
            videoView.pause();

        }
        restoredPosition = videoView.getCurrentPosition();

        editor.putInt("CURRENT_POSITION", restoredPosition);//stopPosition is an int
        Utilities.hideKeybord(VideoFullscreenActivity.this);

    }

    @Override
    public void onResume() {
        super.onResume();
        checkForCrashes();
        startFromZero = false;
        if (Utilities.checkInternetConnection(this)) {
            Log.i("positionPlayback", "onResume " + restoredPosition);
            pDialog.show();
            videoView.setOnPreparedListener(new MediaPlayer.OnPreparedListener() {
                // Close the progress bar and play the video
                public void onPrepared(MediaPlayer mp) {
                    pDialog.dismiss();
                    restoredPosition = prefs.getInt("CURRENT_POSITION", 0);
                    videoView.seekTo(restoredPosition);
                    videoView.start();

                }
            });
        } else {
            Utilities.showAlertLoginDialog(this, "", getResources().getString(R.string.internet_unavailable_msg));
        }
    }

    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
    }

    private void checkForCrashes() {
        CrashManager.register(this, BuildConfig.hockeyAppId);
    }

    @Override
    protected void onStart() {
        super.onStart();
        if (prefs != null) {
            SharedPreferences prefs = getSharedPreferences("VIDEO_POSITION", MODE_PRIVATE);
            restoredPosition = prefs.getInt("CURRENT_POSITION", 0); //0 is the default value.
        }
        videoView.seekTo(restoredPosition);
        videoView.start();
        Log.i("positionPlayback", "onStart " + restoredPosition);
    }

    @Override
    protected void onStop() {
        super.onStop();
        Log.i("positionPlayback", "onStop 1 " + restoredPosition);
        if (videoView != null && videoView.isPlaying()) {
            videoView.pause();
        }
        editor.putInt("CURRENT_POSITION", restoredPosition);//stopPosition is an int
        editor.commit();
        Log.i("positionPlayback", "onStop " + restoredPosition);
    }

    @Override
    protected void onDestroy() {
        editor.putInt("CURRENT_POSITION", restoredPosition);
        editor.commit();
        Log.i("positionPlayback", "onDestroy " + restoredPosition);
        super.onDestroy();

    }

    @Override
    protected void onRestart() {
        super.onRestart();
        SharedPreferences prefs = getSharedPreferences("VIDEO_POSITION", MODE_PRIVATE);
        restoredPosition = prefs.getInt("CURRENT_POSITION", 0);
        Log.i("positionPlayback", "onRestart " + restoredPosition);
    }

    @Override
    public void onConfigurationChanged(Configuration newConfig) {
        super.onConfigurationChanged(newConfig);
    }

    @Override
    public void onBackPressed() {
        editor.putInt("CURRENT_POSITION", 0);
        editor.commit();
        finish();
    }
}

公共类VideoFullscreenActivity扩展活动{
私有静态布尔startFromZero=false；
视频视图；
私有静态布尔显示=false；
ProgressDialog；
SharedReferences.Editor；
共享引用优先权；
int恢复位置；
公共静态布尔值isStartFromZero（）{
从零开始返回STARTFROM；
}
公共静态void setStartFromZero（boolean startFromZero）{
VideoFullscreenActivity.startFromZero=startFromZero；
}
@凌驾
创建时受保护的void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.activity\u video\u全屏）；
videoView=（videoView）findviewbyd（R.id.videoView）；
editor=getSharedReferences（“视频位置”，模式为私有）。edit（）；
prefs=GetSharedReferences（“视频位置”，模式为私有）；
如果（从零开始）{
editor.putInt（“当前位置”，0）；//stopPosition是一个int
commit（）；
}否则{
设置从零开始（假）；
}
restoredPosition=prefs.getInt（“当前位置”，0）；
if（实用程序。检查Internet连接（此））{
Intent=getIntent（）；
pDialog=新建进度对话框（此对话框）；
//设置进度条消息
设置消息（“缓冲…”）；
pDialog.setUndeterminate（假）；
pDialog.setCancelable（真）；
//显示进度条
pDialog.show（）；
MediaController MediaController=new
媒体控制器（本）；
mediaController.setAnchorView（视频视图）；
videoView.setMediaController（mediaController）；
if（intent.getStringExtra（Constants.URL）！=null）
{
urivideouri=Uri.parse（intent.getStringExtra（Constants.URL））；
setVideoURI（videoUri）；
}else if（intent.getStringExtra（“VideoUrl”）！=null）
{
Map headers=newhashmap（）；
headers.put（应用程序密钥、应用程序密钥值）；
headers.put（会话ID，SharedInstance.getInstance（）.getLoginDetails（）.getSessionId（））；
Uri=Uri.parse（intent.getStringExtra（“VideoUrl”）；
方法setVideoURIMethod=null；
试一试{
setVideoURIMethod=videoView.getClass（）.getMethod（“setVideoURI”，Uri.class，Map.class）；
调用（videoView、uri、头文件）；
}捕获（无此方法例外）{
e、 printStackTrace（）；
}捕获（调用TargetException e）{
e、 printStackTrace（）；
}捕获（非法访问例外e）{
e、 printStackTrace（）；
}
//setVideoURI（uri，标题）；
}
videoView.setOnPreparedListener（新的MediaPlayer.OnPreparedListener（）{
//关闭进度条并播放视频
已准备好公开作废（MediaPlayer mp）{
pDialog.disclose（）；
videoView.start（）；
}
});
if（prefs！=null）{
restoredPosition=prefs.getInt（“当前位置”，0）；//0是默认值。
}
videoView.seekTo（恢复位置）；
videoView.start（）；
Log.i（“positionPlayback”、“onCreate”+restoredPosition）；
}否则{
Utilities.showAlertLoginDialog（this，“，getResources（）.getString（R.string.internet\u unavailable\u msg））；
}
videoView.setOnCompletionListener（新的MediaPlayer.OnCompletionListener（）{
@凌驾
完成时的公共作废（MediaPlayer MediaPlayer）{
onBackPressed（）；
}
});
//---------------------------------------------------------------//
videoView.setOnPreparedListener（新的MediaPlayer.OnPreparedListener（）{
@凌驾
已准备好公开作废（MediaPlayer MediaPlayer）{
这个.onPrepared（mediaPlayer）；
}
});
}
@凌驾
公共无效暂停（）{
super.onPause（）；
Log.i（“位置回放”、“暂停”+恢复位置）；
if（videoView！=null&&videoView.isPlaying（））{
videoView.pause（）；
}
restoredPosition=videoView.getCurrentPosition（）；
editor.putInt（“当前位置”，restoredPosition）；//stopPosition是一个int
实用程序.hideKeybord（VideoFullscreenActivity.this）；
}
@凌驾
恢复时公开作废（）{
super.onResume（）；
checkforcrasks（）；
startFromZero=错误；
if（实用程序。检查Internet连接（此））{
Log.i（“位置回放”、“恢复”+恢复位置）；
pDialog.show（）；
videoView.setOnPreparedListener（新的MediaPlayer.OnPreparedListener（）{
//关闭进度条并播放视频
已准备好公开作废（MediaPlayer mp）{
pDialog.disclose（）；
restoredPosition=prefs.getInt（“当前位置”，0）；
videoView.seekTo（恢复位置）；
videoView.start（）；
}
});
}否则{
Utilities.showAlertLoginDialog（this，“，getResources（）.getString（R.string.internet\u unavailable\u msg））；
}
}
@凌驾
SaveInstanceState上受保护的无效（束超出状态）{
super.onSaveInstanceState(
boolean manual_pause = false;

@Override
public void onPause() {
    super.onPause();
    Log.i("positionPlayback", "onPause " + restoredPosition);
    if (videoView != null && videoView.isPlaying()) {
        videoView.pause();
        manual_pause = false;
    } else if(videoView != null){
        manual_pause = true;
    }
    restoredPosition = videoView.getCurrentPosition();

    editor.putInt("CURRENT_POSITION", restoredPosition);//stopPosition is an int
    Utilities.hideKeybord(VideoFullscreenActivity.this);

}

@Override
public void onResume() {
    super.onResume();
    checkForCrashes();
    startFromZero = false;
    if (Utilities.checkInternetConnection(this)) {
        Log.i("positionPlayback", "onResume " + restoredPosition);
        pDialog.show();
        videoView.setOnPreparedListener(new MediaPlayer.OnPreparedListener() {
            // Close the progress bar and play the video
            public void onPrepared(MediaPlayer mp) {
                pDialog.dismiss();
                restoredPosition = prefs.getInt("CURRENT_POSITION", 0);
                videoView.seekTo(restoredPosition);
                if(manual_pause) {
                    videoView.pause();
                    manual_pause = false;
                }else{
                    videoView.start();
                }
            }
        });
    } else {
        Utilities.showAlertLoginDialog(this, "", getResources().getString(R.string.internet_unavailable_msg));
    }
}