Android MVP中start()与stop()方法最佳实践及视频裁剪时机咨询

1. What to Put in start()/stop() to Prevent Memory Leaks & Issues #

Great question—let’s start with clarifying the core role of these methods in MVP, then break down the safety steps:

• start(): This is your hook for initializing or resuming operations that depend on an active View. It’s tied to the View’s lifecycle (usually called from the Activity’s onResume()), so you know the UI is ready to receive updates here.
• stop(): This is your critical cleanup step. Use it to halt ongoing work, release resources, and break references that could trap the Activity in memory.

Key Safety Actions for These Methods: #

• Cancel asynchronous tasks: Video trimming is CPU-heavy, so you’ll definitely run it in the background. In stop(), cancel any in-progress trimming to avoid wasting resources and preventing the Activity from being garbage collected.
• Break View references: If your Presenter holds a strong reference to the Activity (like your current code), set it to null in stop() once the View is inactive. Alternatively, use a WeakReference for the View to eliminate accidental leaks entirely.
• Clean up utility classes: If VideoUtility holds file handles, MediaCodec instances, or temporary files, call a custom release() method on it in stop() to free those resources.

2. Where to Call trimVideo() (One-Time Execution) #

You’re right to avoid running this expensive task multiple times. Here’s the best approach, and why other options fall short:

Why Not the Presenter Constructor? #

Calling trimVideo() in the constructor is risky:

• The Activity (View) might not be fully initialized yet, leading to null pointers if you try to update the UI mid-trim.
• If the Presenter is created before the Activity is attached to the window, you’re wasting resources on background work that might not even be needed if the Activity is destroyed quickly.

Best Practice: start() with a Guard Flag #

Add a boolean flag to track if trimming has already completed, then call trimVideo() in start() only if it hasn’t run yet. This aligns with the MVP lifecycle and ensures the View is ready to receive the result.

Modified Code Examples #

Updated VideoEditorContract (Add stop() to Presenter) #

public interface VideoEditorContract {
    interface View extends BaseView<Presenter> {
        void playTrimVideo(String trimmedVideoPath);
        void showTrimmingError(); // Optional: Add error handling for robustness
    }
    interface Presenter extends BasePresenter {
        void stop(); // Add this method to the contract
    }
}

Updated VideoEditorPresenter #

public class VideoEditorPresenter implements VideoEditorContract.Presenter {
    @Nullable private VideoEditorContract.View mVideoEditorView; // Make nullable for cleanup
    @NonNull private String mVideoPath;
    private boolean isTrimmed = false;
    private VideoUtility mVideoUtility; // Your trimming utility class
    private CancellationSignal mTrimCancellation; // For canceling background tasks

    public VideoEditorPresenter(@NonNull String videoPath, @NonNull VideoEditorContract.View videoEditorView) {
        mVideoPath = checkNotNull(videoPath);
        mVideoEditorView = checkNotNull(videoEditorView);
        mVideoEditorView.setPresenter(this);
        mVideoUtility = new VideoUtility();
        mTrimCancellation = new CancellationSignal();
    }

    @Override
    public void start() {
        // Only run trimming if it hasn't been done and the View is active
        if (!isTrimmed && mVideoEditorView != null) {
            trimVideo();
        }
    }

    @Override
    public void stop() {
        // Cancel ongoing trimming to avoid wasting resources
        mTrimCancellation.cancel();
        // Release utility resources
        if (mVideoUtility != null) {
            mVideoUtility.release();
        }
        // Break the View reference to prevent memory leaks
        mVideoEditorView = null;
    }

    private void trimVideo() {
        // Run trimming on a background thread (using coroutines, modern Android approach)
        CoroutineScope(Dispatchers.IO).launch {
            try {
                if (mTrimCancellation.isCanceled()) return@launch;
                String trimmedPath = mVideoUtility.trimVideo(mVideoPath, mTrimCancellation);
                isTrimmed = true;
                // Update the UI on the main thread
                withContext(Dispatchers.Main) {
                    if (mVideoEditorView != null) {
                        mVideoEditorView.playTrimVideo(trimmedPath);
                    }
                }
            } catch (Exception e) {
                // Handle errors gracefully
                withContext(Dispatchers.Main) {
                    if (mVideoEditorView != null) {
                        mVideoEditorView.showTrimmingError();
                    }
                }
            }
        }
    }
}

Updated VideoEditorActivityBase #

public class VideoEditorActivityBase extends AppCompatActivity implements VideoEditorContract.View {
    private VideoEditorContract.Presenter mPresenter;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_video_editor);
        String videoPath = getIntent().getStringExtra(RequestCode.EXTRA_VIDEO_PATH);
        mPresenter = new VideoEditorPresenter(videoPath, this);
    }

    @Override
    public void onResume(){
        super.onResume();
        mPresenter.start();
    }

    @Override
    protected void onPause() {
        super.onPause();
        mPresenter.stop(); // Call stop() when the View becomes inactive
    }

    @Override
    public void playTrimVideo(String trimmedVideoPath) {
        final VideoView vv = findViewById(R.id.act_video_editor_videoView);
        vv.setVideoPath(trimmedVideoPath);
        vv.setOnPreparedListener(mp -> vv.start());
    }

    @Override
    public void showTrimmingError() {
        Toast.makeText(this, "Video trimming failed. Please try again.", Toast.LENGTH_SHORT).show();
    }

    @Override
    public void setPresenter(VideoEditorContract.Presenter presenter) {
        // Keep empty as you already initialize the Presenter in onCreate
    }
}

Additional Tips #

• Configuration Changes: If your Activity might be recreated (e.g., screen rotation), consider pairing MVP with a ViewModel to retain the Presenter or trimming state. This way you won’t re-run the expensive trimming task unnecessarily.
• Weak References: For extra safety, wrap the View in a WeakReference in the Presenter. This ensures the Activity can be garbage collected even if the Presenter is still holding the reference.
• WorkManager: If trimming needs to persist even if the app is closed, use WorkManager instead of coroutines/AsyncTask for background processing.

内容的提问来源于stack exchange，提问作者vxh.viet