feat(note-editor): add split-pane previewer on xlarge screens

- Introduce two-pane NoteEditor layout (editor + previewer) for xlarge screens
- Add NoteEditorFragmentDelegate to notify host activity of editor events
  (ready, text changes, save, type change) so preview can stay in sync
- Implement previewer loading in NoteEditorActivity using TemplatePreviewerFragment
  with tab navigation for multiple card templates
- Retains tab position on text change
- Rename allowSaveAndPreview():
  - allowSaveAction() – controls when note can be saved
  - allowPreviewAction() – controls when preview menu item is shown
  (disabled in split mode since previewer is always visible)
- Added method to update existing card being previewer updateContent() without full fragment reloading and while retaining currently selected card
- Added method to get safe ord for Cloze card refresh

Author: Haz3-jolt

AnkiDroid/src/main/java/com/ichi2/anki/NoteEditorActivity.kt

@@ -19,19 +19,31 @@ package com.ichi2.anki
 import android.content.Context
 import android.content.Intent
 import android.os.Bundle
+import androidx.core.view.isVisible
 import androidx.fragment.app.Fragment
+import androidx.fragment.app.FragmentContainerView
 import androidx.fragment.app.commit
 import com.ichi2.anki.NoteEditorActivity.Companion.FRAGMENT_ARGS_EXTRA
 import com.ichi2.anki.NoteEditorActivity.Companion.FRAGMENT_NAME_EXTRA
 import com.ichi2.anki.android.input.ShortcutGroup
 import com.ichi2.anki.android.input.ShortcutGroupProvider
+import com.ichi2.anki.databinding.NoteEditorBinding
 import com.ichi2.anki.libanki.Collection
+import com.ichi2.anki.noteeditor.NoteEditorFragmentDelegate
 import com.ichi2.anki.noteeditor.NoteEditorLauncher
+import com.ichi2.anki.previewer.TemplatePreviewerArguments
+import com.ichi2.anki.previewer.TemplatePreviewerFragment
+import com.ichi2.anki.settings.Prefs
 import com.ichi2.anki.snackbar.BaseSnackbarBuilderProvider
 import com.ichi2.anki.snackbar.SnackbarBuilder
+import com.ichi2.anki.ui.ResizablePaneManager
+import com.ichi2.themes.Themes
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.delay
 import timber.log.Timber
 import kotlin.reflect.KClass
 import kotlin.reflect.jvm.jvmName
+import kotlin.time.Duration.Companion.milliseconds
 
 /**
  * To find the actual note Editor, @see [NoteEditorFragment]
@@ -44,14 +56,37 @@ class NoteEditorActivity :
     AnkiActivity(),
     BaseSnackbarBuilderProvider,
     DispatchKeyEventListener,
-    ShortcutGroupProvider {
+    ShortcutGroupProvider,
+    NoteEditorFragmentDelegate {
     override val baseSnackbarBuilder: SnackbarBuilder = { }
 
     lateinit var noteEditorFragment: NoteEditorFragment
 
     private val mainToolbar: androidx.appcompat.widget.Toolbar
         get() = findViewById(R.id.toolbar)
 
+    /**
+     * Reference to the previewer container that exists only on larger screens.
+     * Non-null if and only if the layout is x-large and includes the previewer frame
+     *
+     * Unlike lateinit variables, this will remain null throughout the activity
+     * lifecycle on smaller screens that don't include the previewer frame.
+     *
+     * Fragmentation is determined by this view's visibility after inflation.
+     */
+    private var previewerFrame: FragmentContainerView? = null
+
+    /**
+     * Job for managing delayed previewer refresh operations.
+     * Automatically cancelled when the lifecycle scope is destroyed, preventing memory leaks.
+     */
+    private var refreshPreviewerJob: Job? = null
+
+    val fragmented: Boolean
+        get() = previewerFrame?.isVisible == true
+
+    private lateinit var binding: NoteEditorBinding
+
     override fun onCreate(savedInstanceState: Bundle?) {
         if (showedActivityFailedScreen(savedInstanceState)) {
             return
@@ -61,7 +96,11 @@ class NoteEditorActivity :
             return
         }
 
-        setContentView(R.layout.note_editor)
+        binding = NoteEditorBinding.inflate(layoutInflater)
+        setContentView(binding.root)
+
+        previewerFrame = binding.previewerFrame
+        Timber.i("Note Editor is in %s mode", if (fragmented) "split" else "single-pane")
 
         val launcher = NoteIntentParser.parse(intent)
 
@@ -78,10 +117,12 @@ class NoteEditorActivity :
                  */
                 runOnCommit {
                     noteEditorFragment = supportFragmentManager.findFragmentByTag(FRAGMENT_TAG) as NoteEditorFragment
+                    noteEditorFragment.setDelegate(this@NoteEditorActivity)
                 }
             }
         } else {
             noteEditorFragment = existingFragment as NoteEditorFragment
+            noteEditorFragment.setDelegate(this)
         }
 
         enableToolbar()
@@ -93,9 +134,153 @@ class NoteEditorActivity :
             onBackPressedDispatcher.onBackPressed()
         }
 
+        if (fragmented) {
+            // Defer previewer loading to avoid blocking onCreate
+            binding.previewerFrame!!.post {
+                loadNoteEditorPreviewer(true)
+            }
+            val parentLayout = binding.noteEditorXlView!!
+            val divider = binding.noteEditorResizingDivider!!
+            val noteEditorPane = binding.noteEditorFragmentFrame
+            val previewerPane = binding.previewerFrameLayout!!
+            ResizablePaneManager(
+                parentLayout = parentLayout,
+                divider = divider,
+                leftPane = noteEditorPane,
+                rightPane = previewerPane,
+                sharedPrefs = Prefs.getUiConfig(this),
+                leftPaneWeightKey = PREF_NOTE_EDITOR_PANE_WEIGHT,
+                rightPaneWeightKey = PREF_PREVIEWER_PANE_WEIGHT,
+            )
+        }
+
         startLoadingCollection()
     }
 
+    /**
+     * Loads and configures the note editor previewer.
+     *
+     * This method orchestrates the entire preview process including:
+     * - Processing the current note fields and tags
+     * - Setting up the previewer fragment with the appropriate configuration
+     * - Configuring the tab layout for card template navigation
+     *
+     * The preview will reflect the current state of the note being edited,
+     * allowing users to see how their cards will appear during review.
+     *
+     * BUG: Fragment replacement loses user state
+     * - Scroll position is reset when user has scrolled through long card content
+     *
+     * Ideally, we should:
+     * Preserve scroll position when possible
+     *
+     * State preservation behavior:
+     * - Regular templates: Content-only updates preserve tab selection and front/back state
+     * - Cloze notes: Fragment recreation with preserved tab selection to handle dynamic cloze changes
+     */
+    fun loadNoteEditorPreviewer(forceReplace: Boolean) {
+        if (!fragmented) {
+            return
+        }
+
+        // Check if noteEditorFragment is initialized before proceeding
+        if (!::noteEditorFragment.isInitialized) {
+            Timber.w("loadNoteEditorPreviewer called before noteEditorFragment was initialized")
+            return
+        }
+
+        // Check if editorNote is available before proceeding
+        val note =
+            noteEditorFragment.editorNote ?: run {
+                Timber.w("loadNoteEditorPreviewer called before editorNote was available")
+                return
+            }
+
+        launchCatchingTask {
+            try {
+                val fields = noteEditorFragment.prepareNoteFields()
+                val tags = noteEditorFragment.selectedTags ?: mutableListOf()
+
+                fun updatePreviewerFragment(ord: Int) {
+                    val previewerFragment = createPreviewerFragment(fields, tags, ord)
+                    supportFragmentManager.commit {
+                        replace(R.id.previewer_frame, previewerFragment)
+                        runOnCommit {
+                            configurePreviewerTabs(previewerFragment)
+                        }
+                    }
+                }
+
+                val existingPreviewer = supportFragmentManager.findFragmentById(R.id.previewer_frame)
+
+                when {
+                    forceReplace -> {
+                        updatePreviewerFragment(ord = noteEditorFragment.determineCardOrdinal(fields))
+                    }
+                    existingPreviewer is TemplatePreviewerFragment -> {
+                        if (note.notetype.isCloze) {
+                            // For cloze notes, force recreation to handle dynamic cloze changes
+                            // but preserve the user's selected tab
+                            updatePreviewerFragment(ord = existingPreviewer.getSafeClozeOrd())
+                        } else {
+                            // For regular templates, just update content
+                            existingPreviewer.updateContent(fields, tags)
+                        }
+                    }
+                }
+            } catch (e: Exception) {
+                Timber.w(e, "Failed to load note editor previewer")
+            }
+        }
+    }
+
+    /**
+     * Creates and configures the template previewer fragment.
+     *
+     * @param fields The processed note fields
+     * @param tags The selected tags for the note
+     * @param ord The ordinal (position) of the card template to display
+     * @return The configured previewer fragment
+     */
+    private fun createPreviewerFragment(
+        fields: List<String>,
+        tags: List<String>,
+        ord: Int,
+    ): TemplatePreviewerFragment {
+        val args =
+            TemplatePreviewerArguments(
+                notetypeFile =
+                    NotetypeFile(
+                        this@NoteEditorActivity,
+                        noteEditorFragment.editorNote!!.notetype,
+                    ),
+                fields = fields,
+                tags = tags,
+                id = noteEditorFragment.editorNote!!.id,
+                ord = ord,
+                fillEmpty = false,
+            )
+
+        val backgroundColor = Themes.getColorFromAttr(this@NoteEditorActivity, R.attr.alternativeBackgroundColor)
+        val previewerFragment = TemplatePreviewerFragment.newInstance(args, backgroundColor)
+        return previewerFragment
+    }
+
+    /**
+     * Configures the tab layout for the previewer with appropriate tabs for each card template.
+     * Delegates the tab setup responsibility to the TemplatePreviewerFragment
+     *
+     * @param previewerFragment The previewer fragment that will manage the tabs
+     */
+    private fun configurePreviewerTabs(previewerFragment: TemplatePreviewerFragment) {
+        // Post to ensure the fragment is attached before accessing its viewModel
+        binding.previewerFrame?.post {
+            if (!previewerFragment.isAdded) return@post
+            val previewerTabLayout = binding.previewerTabLayout!!
+            previewerFragment.setupTabs(previewerTabLayout)
+        }
+    }
+
     override fun onCollectionLoaded(col: Collection) {
         super.onCollectionLoaded(col)
         Timber.d("onCollectionLoaded()")
@@ -108,11 +293,58 @@ class NoteEditorActivity :
     override val shortcuts: ShortcutGroup
         get() = noteEditorFragment.shortcuts
 
+    override fun onResume() {
+        super.onResume()
+        // Refresh the previewer when activity resumes, if needed
+        if (fragmented) {
+            loadNoteEditorPreviewer(false)
+        }
+    }
+
+    //region NoteEditorFragmentDelegate Protocol Methods
+
+    override fun onNoteEditorReady() {
+        // Load the if fragmented, else does nothing
+        if (!fragmented) return
+
+        loadNoteEditorPreviewer(false)
+    }
+
+    override fun onNoteTextChanged() {
+        if (!fragmented) return
+
+        refreshPreviewerJob?.cancel()
+        refreshPreviewerJob =
+            launchCatchingTask {
+                delay(REFRESH_NOTE_EDITOR_PREVIEW_DELAY)
+                loadNoteEditorPreviewer(false)
+            }
+    }
+
+    override fun onNoteSaved() {
+        if (!fragmented) return
+
+        loadNoteEditorPreviewer(true)
+    }
+
+    override fun onNoteTypeChanged() {
+        if (!fragmented) return
+
+        loadNoteEditorPreviewer(true)
+    }
+    //endregion
+
     companion object {
         const val FRAGMENT_ARGS_EXTRA = "fragmentArgs"
         const val FRAGMENT_NAME_EXTRA = "fragmentName"
         const val FRAGMENT_TAG = "NoteEditorFragmentTag"
 
+        // Keys for saving pane weights in SharedPreferences
+        private const val PREF_NOTE_EDITOR_PANE_WEIGHT = "noteEditorPaneWeight"
+        private const val PREF_PREVIEWER_PANE_WEIGHT = "previewerPaneWeight"
+
+        private val REFRESH_NOTE_EDITOR_PREVIEW_DELAY = 100.milliseconds
+
         /**
          * Creates an Intent to launch the NoteEditor activity with a specific fragment class and arguments.
          *