refactor(app): remove the legacy PasswordStore list

The Compose list replaces it. The autofill inline suggestion's
attribution intent now opens LaunchActivity, behind the biometric gate.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

8 files changed, 9 insertions, 1259 deletions

diff --git a/app/src/main/java/app/passwordstore/ui/dialogs/FolderCreationDialogFragment.kt b/app/src/main/java/app/passwordstore/ui/dialogs/FolderCreationDialogFragment.kt
deleted file mode 100644
index 669e126e..00000000
--- a/app/src/main/java/app/passwordstore/ui/dialogs/FolderCreationDialogFragment.kt
+++ /dev/null
@@ -1,77 +0,0 @@
-/*
- * Copyright © 2014-2024 The Android Password Store Authors. All Rights Reserved.
- * SPDX-License-Identifier: GPL-3.0-only
- */
-package app.passwordstore.ui.dialogs
-
-import android.app.Dialog
-import android.os.Bundle
-import android.view.WindowManager
-import androidx.appcompat.app.AlertDialog
-import androidx.core.os.bundleOf
-import androidx.fragment.app.DialogFragment
-import app.passwordstore.R
-import app.passwordstore.ui.passwords.PasswordStore
-import com.google.android.material.dialog.MaterialAlertDialogBuilder
-import com.google.android.material.textfield.TextInputEditText
-import com.google.android.material.textfield.TextInputLayout
-import java.io.File
-
-class FolderCreationDialogFragment : DialogFragment() {
-
-  private lateinit var newFolder: File
-
-  override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
-    val alertDialogBuilder = MaterialAlertDialogBuilder(requireContext())
-    alertDialogBuilder.setTitle(R.string.title_create_folder)
-    alertDialogBuilder.setView(R.layout.folder_dialog_fragment)
-    alertDialogBuilder.setPositiveButton(getString(R.string.button_create), null)
-    alertDialogBuilder.setNegativeButton(getString(android.R.string.cancel)) { _, _ -> dismiss() }
-    val dialog = alertDialogBuilder.create()
-    dialog.window?.setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE)
-    dialog.setOnShowListener {
-      dialog.getButton(AlertDialog.BUTTON_POSITIVE).setOnClickListener {
-        createDirectory(requireArguments().getString(CURRENT_DIR_EXTRA)!!)
-      }
-    }
-    return dialog
-  }
-
-  private fun createDirectory(currentDir: String) {
-    val dialog = requireDialog()
-    val folderNameView = dialog.findViewById<TextInputEditText>(R.id.folder_name_text)
-    val folderNameViewContainer = dialog.findViewById<TextInputLayout>(R.id.folder_name_container)
-    newFolder = File("$currentDir/${folderNameView.text}")
-    folderNameViewContainer.error =
-      when {
-        newFolder.isFile -> getString(R.string.folder_creation_err_file_exists)
-        newFolder.isDirectory -> getString(R.string.folder_creation_err_folder_exists)
-        else -> null
-      }
-    if (folderNameViewContainer.error != null) return
-    newFolder.mkdirs()
-    (requireActivity() as PasswordStore).refreshPasswordList(newFolder)
-    // TODO(msfjarvis): Restore this functionality
-    /*
-        if (dialog.findViewById<MaterialCheckBox>(R.id.set_gpg_key).isChecked) {
-          keySelectAction.launch(Intent(requireContext(), GetKeyIdsActivity::class.java))
-          return
-        } else {
-          dismiss()
-        }
-    */
-    dismiss()
-  }
-
-  companion object {
-
-    private const val CURRENT_DIR_EXTRA = "CURRENT_DIRECTORY"
-
-    fun newInstance(startingDirectory: String): FolderCreationDialogFragment {
-      val extras = bundleOf(CURRENT_DIR_EXTRA to startingDirectory)
-      val fragment = FolderCreationDialogFragment()
-      fragment.arguments = extras
-      return fragment
-    }
-  }
-}
diff --git a/app/src/main/java/app/passwordstore/ui/dialogs/ItemCreationBottomSheet.kt b/app/src/main/java/app/passwordstore/ui/dialogs/ItemCreationBottomSheet.kt
deleted file mode 100644
index 0304b16c..00000000
--- a/app/src/main/java/app/passwordstore/ui/dialogs/ItemCreationBottomSheet.kt
+++ /dev/null
@@ -1,77 +0,0 @@
-/*
- * Copyright © 2014-2024 The Android Password Store Authors. All Rights Reserved.
- * SPDX-License-Identifier: GPL-3.0-only
- */
-package app.passwordstore.ui.dialogs
-
-import android.os.Bundle
-import android.view.LayoutInflater
-import android.view.View
-import android.view.ViewGroup
-import android.view.ViewTreeObserver
-import android.widget.FrameLayout
-import androidx.core.os.bundleOf
-import androidx.fragment.app.setFragmentResult
-import app.passwordstore.R
-import app.passwordstore.ui.passwords.PasswordFragment.Companion.ACTION_FOLDER
-import app.passwordstore.ui.passwords.PasswordFragment.Companion.ACTION_KEY
-import app.passwordstore.ui.passwords.PasswordFragment.Companion.ACTION_PASSWORD
-import app.passwordstore.ui.passwords.PasswordFragment.Companion.ITEM_CREATION_REQUEST_KEY
-import com.google.android.material.bottomsheet.BottomSheetBehavior
-import com.google.android.material.bottomsheet.BottomSheetDialog
-import com.google.android.material.bottomsheet.BottomSheetDialogFragment
-
-class ItemCreationBottomSheet : BottomSheetDialogFragment() {
-
-  private var behavior: BottomSheetBehavior<FrameLayout>? = null
-  private val bottomSheetCallback =
-    object : BottomSheetBehavior.BottomSheetCallback() {
-      override fun onSlide(bottomSheet: View, slideOffset: Float) {}
-
-      override fun onStateChanged(bottomSheet: View, newState: Int) {
-        if (newState == BottomSheetBehavior.STATE_COLLAPSED) {
-          dismiss()
-        }
-      }
-    }
-
-  override fun onCreateView(
-    inflater: LayoutInflater,
-    container: ViewGroup?,
-    savedInstanceState: Bundle?,
-  ): View? {
-    if (savedInstanceState != null) dismiss()
-    return inflater.inflate(R.layout.item_create_sheet, container, false)
-  }
-
-  override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
-    super.onViewCreated(view, savedInstanceState)
-    view.viewTreeObserver.addOnGlobalLayoutListener(
-      object : ViewTreeObserver.OnGlobalLayoutListener {
-        override fun onGlobalLayout() {
-          view.viewTreeObserver.removeOnGlobalLayoutListener(this)
-          val dialog = dialog as BottomSheetDialog? ?: return
-          behavior = dialog.behavior
-          behavior?.apply {
-            state = BottomSheetBehavior.STATE_EXPANDED
-            peekHeight = 0
-            addBottomSheetCallback(bottomSheetCallback)
-          }
-          dialog.findViewById<View>(R.id.create_folder)?.setOnClickListener {
-            setFragmentResult(ITEM_CREATION_REQUEST_KEY, bundleOf(ACTION_KEY to ACTION_FOLDER))
-            dismiss()
-          }
-          dialog.findViewById<View>(R.id.create_password)?.setOnClickListener {
-            setFragmentResult(ITEM_CREATION_REQUEST_KEY, bundleOf(ACTION_KEY to ACTION_PASSWORD))
-            dismiss()
-          }
-        }
-      }
-    )
-  }
-
-  override fun dismiss() {
-    super.dismiss()
-    behavior?.removeBottomSheetCallback(bottomSheetCallback)
-  }
-}
diff --git a/app/src/main/java/app/passwordstore/ui/folderselect/SelectFolderActivity.kt b/app/src/main/java/app/passwordstore/ui/folderselect/SelectFolderActivity.kt
index cfeb6206..2139d7d2 100644
--- a/app/src/main/java/app/passwordstore/ui/folderselect/SelectFolderActivity.kt
+++ b/app/src/main/java/app/passwordstore/ui/folderselect/SelectFolderActivity.kt
@@ -11,9 +11,6 @@ import androidx.appcompat.app.AppCompatActivity
 import androidx.fragment.app.FragmentManager
 import androidx.fragment.app.commit
 import app.passwordstore.R
-import app.passwordstore.data.repo.PasswordRepository
-import app.passwordstore.ui.passwords.PASSWORD_FRAGMENT_TAG
-import app.passwordstore.ui.passwords.PasswordStore
 import dagger.hilt.android.AndroidEntryPoint
 
 @AndroidEntryPoint
@@ -23,23 +20,10 @@ class SelectFolderActivity : AppCompatActivity(R.layout.select_folder_layout) {
 
   override fun onCreate(savedInstanceState: Bundle?) {
     super.onCreate(savedInstanceState)
-
     passwordList = SelectFolderFragment()
-    val args = Bundle()
-    args.putString(
-      PasswordStore.REQUEST_ARG_PATH,
-      PasswordRepository.getRepositoryDirectory().absolutePath,
-    )
-
-    passwordList.arguments = args
-
     supportActionBar?.show()
-
     supportFragmentManager.popBackStack(null, FragmentManager.POP_BACK_STACK_INCLUSIVE)
-
-    supportFragmentManager.commit {
-      replace(R.id.pgp_handler_linearlayout, passwordList, PASSWORD_FRAGMENT_TAG)
-    }
+    supportFragmentManager.commit { replace(R.id.pgp_handler_linearlayout, passwordList) }
   }
 
   override fun onCreateOptionsMenu(menu: Menu): Boolean {
diff --git a/app/src/main/java/app/passwordstore/ui/folderselect/SelectFolderFragment.kt b/app/src/main/java/app/passwordstore/ui/folderselect/SelectFolderFragment.kt
index 3cf12fdd..acf4b56d 100644
--- a/app/src/main/java/app/passwordstore/ui/folderselect/SelectFolderFragment.kt
+++ b/app/src/main/java/app/passwordstore/ui/folderselect/SelectFolderFragment.kt
@@ -15,9 +15,9 @@ import androidx.lifecycle.lifecycleScope
 import androidx.recyclerview.widget.LinearLayoutManager
 import app.passwordstore.R
 import app.passwordstore.data.password.PasswordItem
+import app.passwordstore.data.repo.PasswordRepository
 import app.passwordstore.databinding.PasswordRecyclerViewBinding
 import app.passwordstore.ui.adapters.PasswordItemRecyclerAdapter
-import app.passwordstore.ui.passwords.PasswordStore
 import app.passwordstore.util.coroutines.DispatcherProvider
 import app.passwordstore.util.extensions.viewBinding
 import app.passwordstore.util.viewmodel.ListMode
@@ -56,11 +56,11 @@ class SelectFolderFragment : Fragment(R.layout.password_recycler_view) {
     FastScrollerBuilder(binding.passRecycler).build()
     registerForContextMenu(binding.passRecycler)
 
-    val path =
-      requireNotNull(requireArguments().getString(PasswordStore.REQUEST_ARG_PATH)) {
-        "Cannot navigate if ${PasswordStore.REQUEST_ARG_PATH} is not provided"
-      }
-    model.navigateTo(File(path), listMode = ListMode.DirectoriesOnly, pushPreviousLocation = false)
+    model.navigateTo(
+      PasswordRepository.getRepositoryDirectory(),
+      listMode = ListMode.DirectoriesOnly,
+      pushPreviousLocation = false,
+    )
     lifecycleScope.launch {
       model.searchResult.flowWithLifecycle(lifecycle).collect { result ->
         recyclerAdapter.submitList(result.passwordItems)
diff --git a/app/src/main/java/app/passwordstore/ui/passwords/PasswordFragment.kt b/app/src/main/java/app/passwordstore/ui/passwords/PasswordFragment.kt
deleted file mode 100644
index 917bb91c..00000000
--- a/app/src/main/java/app/passwordstore/ui/passwords/PasswordFragment.kt
+++ /dev/null
@@ -1,388 +0,0 @@
-/*
- * Copyright © 2014-2024 The Android Password Store Authors. All Rights Reserved.
- * SPDX-License-Identifier: GPL-3.0-only
- */
-package app.passwordstore.ui.passwords
-
-import android.content.Context
-import android.content.SharedPreferences
-import android.os.Bundle
-import android.os.Parcelable
-import android.view.Menu
-import android.view.MenuItem
-import android.view.View
-import android.view.animation.Animation
-import android.view.animation.AnimationUtils
-import androidx.activity.result.contract.ActivityResultContracts.StartActivityForResult
-import androidx.appcompat.view.ActionMode
-import androidx.core.content.edit
-import androidx.fragment.app.Fragment
-import androidx.fragment.app.activityViewModels
-import androidx.lifecycle.flowWithLifecycle
-import androidx.lifecycle.lifecycleScope
-import androidx.recyclerview.widget.DividerItemDecoration
-import androidx.recyclerview.widget.LinearLayoutManager
-import app.passwordstore.R
-import app.passwordstore.data.password.PasswordItem
-import app.passwordstore.data.repo.PasswordRepository
-import app.passwordstore.databinding.PasswordRecyclerViewBinding
-import app.passwordstore.injection.prefs.SettingsPreferences
-import app.passwordstore.ui.adapters.PasswordItemRecyclerAdapter
-import app.passwordstore.ui.dialogs.BasicBottomSheet
-import app.passwordstore.ui.dialogs.ItemCreationBottomSheet
-import app.passwordstore.ui.git.base.BaseGitActivity
-import app.passwordstore.ui.git.config.GitServerConfigActivity
-import app.passwordstore.ui.util.OnOffItemAnimator
-import app.passwordstore.util.coroutines.DispatcherProvider
-import app.passwordstore.util.extensions.base64
-import app.passwordstore.util.extensions.getString
-import app.passwordstore.util.extensions.sharedPrefs
-import app.passwordstore.util.extensions.viewBinding
-import app.passwordstore.util.settings.AuthMode
-import app.passwordstore.util.settings.GitSettings
-import app.passwordstore.util.settings.PasswordSortOrder
-import app.passwordstore.util.settings.PreferenceKeys
-import app.passwordstore.util.shortcuts.ShortcutHandler
-import app.passwordstore.util.viewmodel.SearchableRepositoryViewModel
-import com.github.michaelbull.result.fold
-import com.github.michaelbull.result.onFailure
-import com.github.michaelbull.result.runCatching
-import dagger.hilt.android.AndroidEntryPoint
-import java.io.File
-import javax.inject.Inject
-import kotlinx.coroutines.launch
-import me.zhanghai.android.fastscroll.FastScrollerBuilder
-
-@AndroidEntryPoint
-class PasswordFragment : Fragment(R.layout.password_recycler_view) {
-
-  @Inject lateinit var gitSettings: GitSettings
-  @Inject lateinit var shortcutHandler: ShortcutHandler
-  @Inject lateinit var dispatcherProvider: DispatcherProvider
-  @Inject @SettingsPreferences lateinit var prefs: SharedPreferences
-  private lateinit var recyclerAdapter: PasswordItemRecyclerAdapter
-  private lateinit var listener: OnFragmentInteractionListener
-  private lateinit var settings: SharedPreferences
-
-  private var recyclerViewStateToRestore: Parcelable? = null
-  private var actionMode: ActionMode? = null
-  private var scrollTarget: File? = null
-
-  private val model: SearchableRepositoryViewModel by activityViewModels()
-  private val binding by viewBinding(PasswordRecyclerViewBinding::bind)
-  private val swipeResult =
-    registerForActivityResult(StartActivityForResult()) {
-      binding.swipeRefresher.isRefreshing = false
-      requireStore().refreshPasswordList()
-    }
-
-  val currentDir: File
-    get() = model.currentDir.value
-
-  override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
-    super.onViewCreated(view, savedInstanceState)
-    settings = requireContext().sharedPrefs
-    initializePasswordList()
-    binding.fab.setOnClickListener {
-      ItemCreationBottomSheet().show(childFragmentManager, "BOTTOM_SHEET")
-    }
-    childFragmentManager.setFragmentResultListener(ITEM_CREATION_REQUEST_KEY, viewLifecycleOwner) {
-      _,
-      bundle ->
-      when (bundle.getString(ACTION_KEY)) {
-        ACTION_FOLDER -> requireStore().createFolder()
-        ACTION_PASSWORD -> requireStore().createPassword()
-      }
-    }
-  }
-
-  private fun initializePasswordList() {
-    val gitDir = File(PasswordRepository.getRepositoryDirectory(), ".git")
-    val hasGitDir =
-      gitDir.exists() && gitDir.isDirectory && (gitDir.listFiles()?.isNotEmpty() == true)
-    binding.swipeRefresher.setOnRefreshListener {
-      if (!hasGitDir) {
-        requireStore().refreshPasswordList()
-        binding.swipeRefresher.isRefreshing = false
-      } else if (!PasswordRepository.isGitRepo()) {
-        BasicBottomSheet.Builder(requireContext())
-          .setMessageRes(R.string.clone_git_repo)
-          .setPositiveButtonClickListener(getString(R.string.clone_button)) {
-            swipeResult.launch(GitServerConfigActivity.createCloneIntent(requireContext()))
-          }
-          .build()
-          .show(requireActivity().supportFragmentManager, "NOT_A_GIT_REPO")
-        binding.swipeRefresher.isRefreshing = false
-      } else {
-        // When authentication is set to AuthMode.None then the only git operation we can
-        // run is a pull, so automatically fallback to that.
-        val operationId =
-          when (gitSettings.authMode) {
-            AuthMode.None -> BaseGitActivity.GitOp.PULL
-            else -> BaseGitActivity.GitOp.SYNC
-          }
-        requireStore().apply {
-          lifecycleScope.launch {
-            launchGitOperation(operationId)
-              .fold(
-                success = {
-                  binding.swipeRefresher.isRefreshing = false
-                  refreshPasswordList()
-                },
-                failure = { err ->
-                  promptOnErrorHandler(err) { binding.swipeRefresher.isRefreshing = false }
-                },
-              )
-          }
-        }
-      }
-    }
-
-    recyclerAdapter =
-      PasswordItemRecyclerAdapter(lifecycleScope, dispatcherProvider)
-        .onItemClicked { _, item -> listener.onFragmentInteraction(item) }
-        .onSelectionChanged { selection ->
-          // In order to not interfere with drag selection, we disable the
-          // SwipeRefreshLayout
-          // once an item is selected.
-          binding.swipeRefresher.isEnabled = selection.isEmpty
-
-          if (actionMode == null)
-            actionMode =
-              requireStore().startSupportActionMode(actionModeCallback) ?: return@onSelectionChanged
-
-          if (!selection.isEmpty) {
-            actionMode!!.title =
-              resources.getQuantityString(
-                R.plurals.delete_title,
-                selection.size(),
-                selection.size(),
-              )
-            actionMode!!.invalidate()
-          } else {
-            actionMode!!.finish()
-          }
-        }
-    val recyclerView = binding.passRecycler
-    recyclerView.apply {
-      addItemDecoration(DividerItemDecoration(requireContext(), LinearLayoutManager.VERTICAL))
-      layoutManager = LinearLayoutManager(requireContext())
-      itemAnimator = OnOffItemAnimator()
-      adapter = recyclerAdapter
-    }
-
-    FastScrollerBuilder(recyclerView).build()
-    recyclerAdapter.makeSelectable(recyclerView)
-    registerForContextMenu(recyclerView)
-
-    val path =
-      requireNotNull(requireArguments().getString(PasswordStore.REQUEST_ARG_PATH)) {
-        "Cannot navigate if ${PasswordStore.REQUEST_ARG_PATH} is not provided"
-      }
-    model.navigateTo(File(path), pushPreviousLocation = false)
-    lifecycleScope.launch {
-      model.searchResult.flowWithLifecycle(lifecycle).collect { result ->
-        // Only run animations when the new list is filtered, i.e., the user submitted a search,
-        // and not on folder navigation since the latter leads to too many removal animations.
-        (recyclerView.itemAnimator as OnOffItemAnimator).isEnabled = result.isFiltered
-        recyclerAdapter.submitList(result.passwordItems) {
-          when {
-            result.isFiltered -> {
-              // When the result is filtered, we always scroll to the top since that is
-              // where the best fuzzy match appears.
-              recyclerView.scrollToPosition(0)
-            }
-            scrollTarget != null -> {
-              scrollTarget?.let {
-                recyclerView.scrollToPosition(recyclerAdapter.getPositionForFile(it))
-              }
-              scrollTarget = null
-            }
-            else -> {
-              // When the result is not filtered and there is a saved scroll position for
-              // it, we try to restore it.
-              recyclerViewStateToRestore?.let {
-                recyclerView.layoutManager!!.onRestoreInstanceState(it)
-              }
-              recyclerViewStateToRestore = null
-            }
-          }
-        }
-      }
-    }
-  }
-
-  private val actionModeCallback =
-    object : ActionMode.Callback {
-      // Called when the action mode is created; startActionMode() was called
-      override fun onCreateActionMode(mode: ActionMode, menu: Menu): Boolean {
-        // Inflate a menu resource providing context menu items
-        mode.menuInflater.inflate(R.menu.context_pass, menu)
-        // hide the fab
-        animateFab(false)
-        return true
-      }
-
-      // Called each time the action mode is shown. Always called after onCreateActionMode,
-      // but may be called multiple times if the mode is invalidated.
-      override fun onPrepareActionMode(mode: ActionMode, menu: Menu): Boolean {
-        val selectedItems = recyclerAdapter.getSelectedItems()
-        menu.findItem(R.id.menu_edit_password).isVisible =
-          selectedItems.all { it.type == PasswordItem.TYPE_CATEGORY }
-        menu.findItem(R.id.menu_pin_password).isVisible =
-          selectedItems.size == 1 && selectedItems[0].type == PasswordItem.TYPE_PASSWORD
-        return true
-      }
-
-      // Called when the user selects a contextual menu item
-      override fun onActionItemClicked(mode: ActionMode, item: MenuItem): Boolean {
-        return when (item.itemId) {
-          R.id.menu_delete_password -> {
-            requireStore().deletePasswords(recyclerAdapter.getSelectedItems())
-            // Action picked, so close the CAB
-            mode.finish()
-            true
-          }
-          R.id.menu_move_password -> {
-            requireStore().movePasswords(recyclerAdapter.getSelectedItems())
-            false
-          }
-          R.id.menu_edit_password -> {
-            requireStore().renameCategory(recyclerAdapter.getSelectedItems())
-            mode.finish()
-            false
-          }
-          R.id.menu_pin_password -> {
-            val passwordItem = recyclerAdapter.getSelectedItems()[0]
-            shortcutHandler.addPinnedShortcut(
-              passwordItem,
-              passwordItem.createAuthEnabledIntent(requireContext()),
-            )
-            false
-          }
-          else -> false
-        }
-      }
-
-      // Called when the user exits the action mode
-      override fun onDestroyActionMode(mode: ActionMode) {
-        recyclerAdapter.requireSelectionTracker().clearSelection()
-        actionMode = null
-        // show the fab
-        animateFab(true)
-      }
-
-      private fun animateFab(show: Boolean) =
-        with(binding.fab) {
-          val animation =
-            AnimationUtils.loadAnimation(context, if (show) R.anim.scale_up else R.anim.scale_down)
-          animation.setAnimationListener(
-            object : Animation.AnimationListener {
-              override fun onAnimationRepeat(animation: Animation?) {}
-
-              override fun onAnimationEnd(animation: Animation?) {
-                if (!show) visibility = View.GONE
-              }
-
-              override fun onAnimationStart(animation: Animation?) {
-                if (show) visibility = View.VISIBLE
-              }
-            }
-          )
-          animate()
-            .rotationBy(if (show) -90f else 90f)
-            .setStartDelay(if (show) 100 else 0)
-            .setDuration(100)
-            .start()
-          startAnimation(animation)
-        }
-    }
-
-  override fun onResume() {
-    super.onResume()
-    binding.swipeRefresher.isEnabled = !prefs.getBoolean(PreferenceKeys.DISABLE_SYNC_ACTION, false)
-  }
-
-  override fun onAttach(context: Context) {
-    super.onAttach(context)
-    runCatching {
-        listener =
-          object : OnFragmentInteractionListener {
-            override fun onFragmentInteraction(item: PasswordItem) {
-              if (
-                settings.getString(PreferenceKeys.SORT_ORDER) ==
-                  PasswordSortOrder.RECENTLY_USED.name
-              ) {
-                // save the time when password was used
-                val preferences =
-                  context.getSharedPreferences("recent_password_history", Context.MODE_PRIVATE)
-                preferences.edit {
-                  putString(item.file.absolutePath.base64(), System.currentTimeMillis().toString())
-                }
-              }
-
-              if (item.type == PasswordItem.TYPE_CATEGORY) {
-                navigateTo(item.file)
-              } else {
-                if (requireArguments().getBoolean("matchWith", false)) {
-                  requireStore().matchPasswordWithApp(item)
-                } else {
-                  requireStore().decryptPassword(item)
-                }
-              }
-            }
-          }
-      }
-      .onFailure {
-        throw ClassCastException("$context must implement OnFragmentInteractionListener")
-      }
-  }
-
-  private fun requireStore() = requireActivity() as PasswordStore
-
-  /** Returns true if the back press was handled by the [Fragment]. */
-  fun onBackPressedInActivity(): Boolean {
-    if (!model.canNavigateBack) return false
-    // The RecyclerView state is restored when the asynchronous update operation on the
-    // adapter is completed.
-    recyclerViewStateToRestore = model.navigateBack()
-    if (!model.canNavigateBack) requireStore().supportActionBar?.setDisplayHomeAsUpEnabled(false)
-    return true
-  }
-
-  fun dismissActionMode() {
-    actionMode?.finish()
-  }
-
-  companion object {
-
-    const val ITEM_CREATION_REQUEST_KEY = "creation_key"
-    const val ACTION_KEY = "action"
-    const val ACTION_FOLDER = "folder"
-    const val ACTION_PASSWORD = "password"
-
-    fun newInstance(args: Bundle): PasswordFragment {
-      val fragment = PasswordFragment()
-      fragment.arguments = args
-      return fragment
-    }
-  }
-
-  fun navigateTo(file: File) {
-    requireStore().clearSearch()
-    model.navigateTo(
-      file,
-      recyclerViewState = binding.passRecycler.layoutManager!!.onSaveInstanceState(),
-    )
-    requireStore().supportActionBar?.setDisplayHomeAsUpEnabled(true)
-  }
-
-  fun scrollToOnNextRefresh(file: File) {
-    scrollTarget = file
-  }
-
-  interface OnFragmentInteractionListener {
-
-    fun onFragmentInteraction(item: PasswordItem)
-  }
-}
diff --git a/app/src/main/java/app/passwordstore/ui/passwords/PasswordStore.kt b/app/src/main/java/app/passwordstore/ui/passwords/PasswordStore.kt
deleted file mode 100644
index 059b398f..00000000
--- a/app/src/main/java/app/passwordstore/ui/passwords/PasswordStore.kt
+++ /dev/null
@@ -1,621 +0,0 @@
-/*
- * Copyright © 2014-2024 The Android Password Store Authors. All Rights Reserved.
- * SPDX-License-Identifier: GPL-3.0-only
- */
-package app.passwordstore.ui.passwords
-
-import android.content.ComponentName
-import android.content.Context
-import android.content.Intent
-import android.os.Bundle
-import android.view.KeyEvent
-import android.view.Menu
-import android.view.MenuItem
-import android.view.MenuItem.OnActionExpandListener
-import android.view.WindowManager
-import androidx.activity.result.contract.ActivityResultContracts.StartActivityForResult
-import androidx.activity.viewModels
-import androidx.appcompat.widget.SearchView
-import androidx.appcompat.widget.SearchView.OnQueryTextListener
-import androidx.core.content.edit
-import androidx.fragment.app.FragmentManager
-import androidx.fragment.app.commit
-import androidx.lifecycle.flowWithLifecycle
-import androidx.lifecycle.lifecycleScope
-import app.passwordstore.R
-import app.passwordstore.data.password.PasswordItem
-import app.passwordstore.data.repo.PasswordRepository
-import app.passwordstore.ui.crypto.BasePGPActivity
-import app.passwordstore.ui.crypto.BasePGPActivity.Companion.getLongName
-import app.passwordstore.ui.crypto.DecryptActivity
-import app.passwordstore.ui.crypto.PasswordCreationActivity
-import app.passwordstore.ui.dialogs.FolderCreationDialogFragment
-import app.passwordstore.ui.folderselect.SelectFolderActivity
-import app.passwordstore.ui.git.base.BaseGitActivity
-import app.passwordstore.ui.onboarding.activity.OnboardingActivity
-import app.passwordstore.ui.settings.SettingsActivity
-import app.passwordstore.util.autofill.AutofillMatcher
-import app.passwordstore.util.extensions.base64
-import app.passwordstore.util.extensions.commitChange
-import app.passwordstore.util.extensions.contains
-import app.passwordstore.util.extensions.getString
-import app.passwordstore.util.extensions.isInsideRepository
-import app.passwordstore.util.extensions.launchActivity
-import app.passwordstore.util.extensions.listFilesRecursively
-import app.passwordstore.util.extensions.sharedPrefs
-import app.passwordstore.util.settings.AuthMode
-import app.passwordstore.util.settings.PreferenceKeys
-import app.passwordstore.util.shortcuts.ShortcutHandler
-import app.passwordstore.util.viewmodel.SearchableRepositoryViewModel
-import com.github.michaelbull.result.fold
-import com.github.michaelbull.result.onFailure
-import com.github.michaelbull.result.runCatching
-import com.google.android.material.dialog.MaterialAlertDialogBuilder
-import com.google.android.material.textfield.TextInputEditText
-import dagger.hilt.android.AndroidEntryPoint
-import java.io.File
-import java.lang.Character.UnicodeBlock
-import javax.inject.Inject
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
-import logcat.LogPriority.ERROR
-import logcat.LogPriority.INFO
-import logcat.logcat
-
-const val PASSWORD_FRAGMENT_TAG = "PasswordsList"
-
-@AndroidEntryPoint
-class PasswordStore : BaseGitActivity() {
-
-  @Inject lateinit var shortcutHandler: ShortcutHandler
-  private lateinit var searchItem: MenuItem
-  private val settings by lazy { sharedPrefs }
-
-  private val model: SearchableRepositoryViewModel by viewModels()
-
-  private val listRefreshAction =
-    registerForActivityResult(StartActivityForResult()) { result ->
-      if (result.resultCode == RESULT_OK) {
-        refreshPasswordList()
-      }
-    }
-
-  private val passwordMoveAction =
-    registerForActivityResult(StartActivityForResult()) { result ->
-      val intentData = result.data ?: return@registerForActivityResult
-      val filesToMove =
-        requireNotNull(intentData.getStringArrayExtra("Files")) {
-          "'Files' intent extra must be set"
-        }
-      val target =
-        File(
-          requireNotNull(intentData.getStringExtra("SELECTED_FOLDER_PATH")) {
-            "'SELECTED_FOLDER_PATH' intent extra must be set"
-          }
-        )
-      val repositoryPath = PasswordRepository.getRepositoryDirectory().absolutePath
-      if (!target.isDirectory) {
-        logcat(ERROR) { "Tried moving passwords to a non-existing folder." }
-        return@registerForActivityResult
-      }
-
-      logcat { "Moving passwords to ${intentData.getStringExtra("SELECTED_FOLDER_PATH")}" }
-      logcat { filesToMove.joinToString(", ") }
-
-      lifecycleScope.launch(dispatcherProvider.io()) {
-        for (file in filesToMove) {
-          val source = File(file)
-          if (!source.exists()) {
-            logcat(ERROR) { "Tried moving something that appears non-existent." }
-            continue
-          }
-          val destinationFile = File(target.absolutePath + "/" + source.name)
-          val basename = source.nameWithoutExtension
-          val sourceLongName =
-            getLongName(
-              requireNotNull(source.parent) { "$file has no parent" },
-              repositoryPath,
-              basename,
-            )
-          val destinationLongName = getLongName(target.absolutePath, repositoryPath, basename)
-          if (destinationFile.exists()) {
-            logcat(ERROR) { "Trying to move a file that already exists." }
-            withContext(dispatcherProvider.main()) {
-              MaterialAlertDialogBuilder(this@PasswordStore)
-                .setTitle(resources.getString(R.string.password_exists_title))
-                .setMessage(
-                  resources.getString(
-                    R.string.password_exists_message,
-                    destinationLongName,
-                    sourceLongName,
-                  )
-                )
-                .setPositiveButton(R.string.dialog_ok) { _, _ ->
-                  launch(dispatcherProvider.io()) { moveFile(source, destinationFile) }
-                }
-                .setNegativeButton(R.string.dialog_cancel, null)
-                .show()
-            }
-          } else {
-            launch(dispatcherProvider.io()) { moveFile(source, destinationFile) }
-          }
-        }
-        when (filesToMove.size) {
-          1 -> {
-            val source = File(filesToMove[0])
-            val basename = source.nameWithoutExtension
-            val sourceLongName =
-              getLongName(
-                requireNotNull(source.parent) { "$basename has no parent" },
-                repositoryPath,
-                basename,
-              )
-            val destinationLongName = getLongName(target.absolutePath, repositoryPath, basename)
-            withContext(dispatcherProvider.main()) {
-              commitChange(
-                resources.getString(
-                  R.string.git_commit_move_text,
-                  sourceLongName,
-                  destinationLongName,
-                )
-              )
-            }
-          }
-          else -> {
-            val repoDir = PasswordRepository.getRepositoryDirectory().absolutePath
-            val relativePath = getRelativePath("${target.absolutePath}/", repoDir)
-            withContext(dispatcherProvider.main()) {
-              commitChange(
-                resources.getString(R.string.git_commit_move_multiple_text, relativePath)
-              )
-            }
-          }
-        }
-      }
-      refreshPasswordList()
-      getPasswordFragment()?.dismissActionMode()
-    }
-
-  override fun onKeyDown(keyCode: Int, event: KeyEvent): Boolean {
-    // open search view on search key, or Ctr+F
-    if (
-      (keyCode == KeyEvent.KEYCODE_SEARCH ||
-        keyCode == KeyEvent.KEYCODE_F && event.isCtrlPressed) && !searchItem.isActionViewExpanded
-    ) {
-      searchItem.expandActionView()
-      return true
-    }
-
-    // open search view on any printable character and query for it
-    val c = event.unicodeChar.toChar()
-    val printable = isPrintable(c)
-    if (printable && !searchItem.isActionViewExpanded) {
-      searchItem.expandActionView()
-      (searchItem.actionView as SearchView).setQuery(c.toString(), true)
-      return true
-    }
-    return super.onKeyDown(keyCode, event)
-  }
-
-  override fun onCreate(savedInstanceState: Bundle?) {
-    super.onCreate(savedInstanceState)
-    setContentView(R.layout.activity_pwdstore)
-
-    lifecycleScope.launch {
-      model.currentDir.flowWithLifecycle(lifecycle).collect { dir ->
-        val basePath = PasswordRepository.getRepositoryDirectory().absoluteFile
-        supportActionBar?.apply {
-          if (dir != basePath) title = dir.name else setTitle(R.string.app_name)
-        }
-      }
-    }
-  }
-
-  override fun onStart() {
-    super.onStart()
-    refreshPasswordList()
-  }
-
-  override fun onResume() {
-    super.onResume()
-    checkLocalRepository()
-    if (settings.getBoolean(PreferenceKeys.SEARCH_ON_START, false) && ::searchItem.isInitialized) {
-      if (!searchItem.isActionViewExpanded) {
-        searchItem.expandActionView()
-      }
-    }
-  }
-
-  override fun onCreateOptionsMenu(menu: Menu): Boolean {
-    val menuRes =
-      when {
-        gitSettings.authMode == AuthMode.None -> R.menu.main_menu_no_auth
-        PasswordRepository.isGitRepo() -> R.menu.main_menu_git
-        else -> R.menu.main_menu_non_git
-      }
-    menuInflater.inflate(menuRes, menu)
-    return super.onCreateOptionsMenu(menu)
-  }
-
-  override fun onPrepareOptionsMenu(menu: Menu): Boolean {
-    // Invalidation forces onCreateOptionsMenu to be called again. This is cheap and quick so
-    // we can get by without any noticeable difference in performance.
-    invalidateOptionsMenu()
-    searchItem = menu.findItem(R.id.action_search)
-    val searchView = searchItem.actionView as SearchView
-    searchView.setOnQueryTextListener(
-      object : OnQueryTextListener {
-        override fun onQueryTextSubmit(s: String): Boolean {
-          searchView.clearFocus()
-          return true
-        }
-
-        override fun onQueryTextChange(s: String): Boolean {
-          val filter = s.trim()
-          // List the contents of the current directory if the user enters a blank
-          // search term.
-          if (filter.isEmpty())
-            model.navigateTo(newDirectory = model.currentDir.value, pushPreviousLocation = false)
-          else model.search(filter)
-          return true
-        }
-      }
-    )
-
-    // When using the support library, the setOnActionExpandListener() method is
-    // static and accepts the MenuItem object as an argument
-    searchItem.setOnActionExpandListener(
-      object : OnActionExpandListener {
-        override fun onMenuItemActionCollapse(item: MenuItem): Boolean {
-          refreshPasswordList()
-          return true
-        }
-
-        override fun onMenuItemActionExpand(item: MenuItem): Boolean {
-          return true
-        }
-      }
-    )
-    if (settings.getBoolean(PreferenceKeys.SEARCH_ON_START, false)) {
-      searchItem.expandActionView()
-    }
-    return super.onPrepareOptionsMenu(menu)
-  }
-
-  override fun onOptionsItemSelected(item: MenuItem): Boolean {
-    val id = item.itemId
-    val initBefore =
-      MaterialAlertDialogBuilder(this)
-        .setMessage(resources.getString(R.string.creation_dialog_text))
-        .setPositiveButton(resources.getString(R.string.dialog_ok), null)
-    when (id) {
-      R.id.user_pref -> {
-        runCatching { launchActivity(SettingsActivity::class.java) }
-          .onFailure { e -> e.printStackTrace() }
-      }
-      R.id.git_push -> {
-        if (!PasswordRepository.isInitialized) {
-          initBefore.show()
-        } else {
-          runGitOperation(GitOp.PUSH)
-        }
-      }
-      R.id.git_pull -> {
-        if (!PasswordRepository.isInitialized) {
-          initBefore.show()
-        } else {
-          runGitOperation(GitOp.PULL)
-        }
-      }
-      R.id.git_sync -> {
-        if (!PasswordRepository.isInitialized) {
-          initBefore.show()
-        } else {
-          runGitOperation(GitOp.SYNC)
-        }
-      }
-      R.id.refresh -> refreshPasswordList()
-      android.R.id.home -> {
-        @Suppress("DEPRECATION") onBackPressed()
-      }
-      else -> return super.onOptionsItemSelected(item)
-    }
-    return true
-  }
-
-  @Deprecated("Deprecated in Java")
-  @Suppress("DEPRECATION")
-  override fun onBackPressed() {
-    if (getPasswordFragment()?.onBackPressedInActivity() != true) super.onBackPressed()
-  }
-
-  private fun getPasswordFragment(): PasswordFragment? {
-    return supportFragmentManager.findFragmentByTag(PASSWORD_FRAGMENT_TAG) as? PasswordFragment
-  }
-
-  fun clearSearch() {
-    if (searchItem.isActionViewExpanded) searchItem.collapseActionView()
-  }
-
-  private fun runGitOperation(operation: GitOp) =
-    lifecycleScope.launch {
-      launchGitOperation(operation)
-        .fold(success = { refreshPasswordList() }, failure = { promptOnErrorHandler(it) })
-    }
-
-  private fun checkLocalRepository() {
-    PasswordRepository.initialize()
-    checkLocalRepository(PasswordRepository.getRepositoryDirectory())
-  }
-
-  private fun checkLocalRepository(localDir: File?) {
-    if (localDir != null && settings.getBoolean(PreferenceKeys.REPOSITORY_INITIALIZED, false)) {
-      // do not push the fragment if we already have it
-      if (
-        getPasswordFragment() == null || settings.getBoolean(PreferenceKeys.REPO_CHANGED, false)
-      ) {
-        settings.edit { putBoolean(PreferenceKeys.REPO_CHANGED, false) }
-        val args = Bundle()
-        args.putString(REQUEST_ARG_PATH, PasswordRepository.getRepositoryDirectory().absolutePath)
-
-        // if the activity was started from the autofill settings, the
-        // intent is to match a clicked pwd with app. pass this to fragment
-        if (intent.getBooleanExtra("matchWith", false)) {
-          args.putBoolean("matchWith", true)
-        }
-        supportActionBar?.apply {
-          show()
-          setDisplayHomeAsUpEnabled(false)
-        }
-        supportFragmentManager.popBackStack(null, FragmentManager.POP_BACK_STACK_INCLUSIVE)
-        supportFragmentManager.commit {
-          replace(R.id.main_layout, PasswordFragment.newInstance(args), PASSWORD_FRAGMENT_TAG)
-        }
-      }
-    } else {
-      launchActivity(OnboardingActivity::class.java)
-    }
-  }
-
-  private fun getRelativePath(fullPath: String, repositoryPath: String): String {
-    return fullPath.replace(repositoryPath, "").replace("/+".toRegex(), "/")
-  }
-
-  fun decryptPassword(item: PasswordItem) {
-    val authDecryptIntent = item.createAuthEnabledIntent(this)
-    val decryptIntent =
-      Intent(authDecryptIntent).setComponent(ComponentName(this, DecryptActivity::class.java))
-
-    startActivity(decryptIntent)
-
-    // Adds shortcut
-    shortcutHandler.addDynamicShortcut(item, authDecryptIntent)
-  }
-
-  private fun validateState(): Boolean {
-    if (!PasswordRepository.isInitialized) {
-      MaterialAlertDialogBuilder(this)
-        .setMessage(resources.getString(R.string.creation_dialog_text))
-        .setPositiveButton(resources.getString(R.string.dialog_ok), null)
-        .show()
-      return false
-    }
-    return true
-  }
-
-  fun createPassword() {
-    if (!validateState()) return
-    val currentDir = currentDir
-    logcat(INFO) { "Adding file to : ${currentDir.absolutePath}" }
-    val intent = Intent(this, PasswordCreationActivity::class.java)
-    intent.putExtra(BasePGPActivity.EXTRA_FILE_PATH, currentDir.absolutePath)
-    intent.putExtra(
-      BasePGPActivity.EXTRA_REPO_PATH,
-      PasswordRepository.getRepositoryDirectory().absolutePath,
-    )
-    listRefreshAction.launch(intent)
-  }
-
-  fun createFolder() {
-    if (!validateState()) return
-    FolderCreationDialogFragment.newInstance(currentDir.path).show(supportFragmentManager, null)
-  }
-
-  fun deletePasswords(selectedItems: List<PasswordItem>) {
-    var size = 0
-    selectedItems.forEach {
-      if (it.file.isFile) size++ else size += it.file.listFilesRecursively().size
-    }
-    if (size == 0) {
-      selectedItems.map { item -> item.file.deleteRecursively() }
-      refreshPasswordList()
-      return
-    }
-    MaterialAlertDialogBuilder(this)
-      .setMessage(resources.getQuantityString(R.plurals.delete_dialog_text, size, size))
-      .setPositiveButton(resources.getString(R.string.dialog_yes)) { _, _ ->
-        val filesToDelete = arrayListOf<File>()
-        selectedItems.forEach { item ->
-          if (item.file.isDirectory) filesToDelete.addAll(item.file.listFilesRecursively())
-          else filesToDelete.add(item.file)
-        }
-        selectedItems.map { item -> item.file.deleteRecursively() }
-        refreshPasswordList()
-        AutofillMatcher.updateMatches(applicationContext, delete = filesToDelete)
-        val fmt =
-          selectedItems.joinToString(separator = ", ") { item ->
-            item.file.toRelativeString(PasswordRepository.getRepositoryDirectory())
-          }
-        lifecycleScope.launch {
-          commitChange(resources.getString(R.string.git_commit_remove_text, fmt))
-        }
-      }
-      .setNegativeButton(resources.getString(R.string.dialog_no), null)
-      .show()
-  }
-
-  fun movePasswords(values: List<PasswordItem>) {
-    val intent = Intent(this, SelectFolderActivity::class.java)
-    val fileLocations = values.map { it.file.absolutePath }.toTypedArray()
-    intent.putExtra("Files", fileLocations)
-    passwordMoveAction.launch(intent)
-  }
-
-  enum class CategoryRenameError(val resource: Int) {
-    None(0),
-    EmptyField(R.string.message_category_error_empty_field),
-    CategoryExists(R.string.message_category_error_category_exists),
-    DestinationOutsideRepo(R.string.message_error_destination_outside_repo),
-  }
-
-  /**
-   * Prompt the user with a new category name to assign, if the new category forms/leads a path
-   * (i.e. contains "/"), intermediate directories will be created and new category will be placed
-   * inside.
-   *
-   * @param oldCategory The category to change its name
-   * @param error Determines whether to show an error to the user in the alert dialog, this error
-   *   may be due to the new category the user entered already exists or the field was empty or the
-   *   destination path is outside the repository
-   * @see [CategoryRenameError]
-   * @see [isInsideRepository]
-   */
-  private fun renameCategory(
-    oldCategory: PasswordItem,
-    error: CategoryRenameError = CategoryRenameError.None,
-  ) {
-    val view = layoutInflater.inflate(R.layout.folder_dialog_fragment, null)
-    val newCategoryEditText = view.findViewById<TextInputEditText>(R.id.folder_name_text)
-
-    if (error != CategoryRenameError.None) {
-      newCategoryEditText.error = getString(error.resource)
-    }
-
-    val dialog =
-      MaterialAlertDialogBuilder(this)
-        .setTitle(R.string.title_rename_folder)
-        .setView(view)
-        .setMessage(getString(R.string.message_rename_folder, oldCategory.name))
-        .setPositiveButton(R.string.dialog_ok) { _, _ ->
-          val newCategory = File("${oldCategory.file.parent}/${newCategoryEditText.text}")
-          when {
-            newCategoryEditText.text.isNullOrBlank() ->
-              renameCategory(oldCategory, CategoryRenameError.EmptyField)
-            newCategory.exists() -> renameCategory(oldCategory, CategoryRenameError.CategoryExists)
-            !newCategory.isInsideRepository() ->
-              renameCategory(oldCategory, CategoryRenameError.DestinationOutsideRepo)
-            else ->
-              lifecycleScope.launch(dispatcherProvider.io()) {
-                moveFile(oldCategory.file, newCategory)
-
-                // associate the new category with the last category's timestamp in
-                // history
-                val preference =
-                  getSharedPreferences("recent_password_history", Context.MODE_PRIVATE)
-                val timestamp = preference.getString(oldCategory.file.absolutePath.base64())
-                if (timestamp != null) {
-                  preference.edit {
-                    remove(oldCategory.file.absolutePath.base64())
-                    putString(newCategory.absolutePath.base64(), timestamp)
-                  }
-                }
-
-                withContext(dispatcherProvider.main()) {
-                  commitChange(
-                    resources.getString(
-                      R.string.git_commit_move_text,
-                      oldCategory.name,
-                      newCategory.name,
-                    )
-                  )
-                }
-              }
-          }
-        }
-        .setNegativeButton(R.string.dialog_skip, null)
-        .create()
-
-    dialog.window?.setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE)
-    dialog.show()
-  }
-
-  fun renameCategory(categories: List<PasswordItem>) {
-    for (oldCategory in categories) {
-      renameCategory(oldCategory)
-    }
-  }
-
-  /**
-   * Refreshes the password list by re-executing the last navigation or search action, preserving
-   * the navigation stack and scroll position. If the current directory no longer exists, navigation
-   * is reset to the repository root. If the optional [target] argument is provided, it will be
-   * entered if it is a directory or scrolled into view if it is a file (both inside the current
-   * directory).
-   */
-  fun refreshPasswordList(target: File? = null) {
-    val plist = getPasswordFragment()
-    if (target?.isDirectory == true && model.currentDir.value.contains(target)) {
-      plist?.navigateTo(target)
-    } else if (target?.isFile == true && model.currentDir.value.contains(target)) {
-      // Creating new passwords is handled by an activity, so we will refresh in onStart.
-      plist?.scrollToOnNextRefresh(target)
-    } else if (model.currentDir.value.isDirectory) {
-      model.forceRefresh()
-    } else {
-      model.reset()
-      supportActionBar?.setDisplayHomeAsUpEnabled(false)
-    }
-  }
-
-  private val currentDir: File
-    get() = getPasswordFragment()?.currentDir ?: PasswordRepository.getRepositoryDirectory()
-
-  private suspend fun moveFile(source: File, destinationFile: File) {
-    val sourceDestinationMap =
-      if (source.isDirectory) {
-        destinationFile.mkdirs()
-        // Recursively list all files (not directories) below `source`, then
-        // obtain the corresponding target file by resolving the relative path
-        // starting at the destination folder.
-        source.listFilesRecursively().associateWith {
-          destinationFile.resolve(it.relativeTo(source))
-        }
-      } else {
-        mapOf(source to destinationFile)
-      }
-    if (!source.renameTo(destinationFile)) {
-      logcat(ERROR) { "Something went wrong while moving $source to $destinationFile." }
-      withContext(dispatcherProvider.main()) {
-        MaterialAlertDialogBuilder(this@PasswordStore)
-          .setTitle(R.string.password_move_error_title)
-          .setMessage(getString(R.string.password_move_error_message, source, destinationFile))
-          .setCancelable(true)
-          .setPositiveButton(android.R.string.ok, null)
-          .show()
-      }
-    } else {
-      AutofillMatcher.updateMatches(this, sourceDestinationMap)
-    }
-  }
-
-  fun matchPasswordWithApp(item: PasswordItem) {
-    val path =
-      item.file.absolutePath
-        .replace(PasswordRepository.getRepositoryDirectory().toString() + "/", "")
-        .replace(".gpg", "")
-    val data = Intent()
-    data.putExtra("path", path)
-    setResult(RESULT_OK, data)
-    finish()
-  }
-
-  companion object {
-
-    const val REQUEST_ARG_PATH = "PATH"
-
-    private fun isPrintable(c: Char): Boolean {
-      val block = UnicodeBlock.of(c)
-      return (!Character.isISOControl(c) && block != null && block !== UnicodeBlock.SPECIALS)
-    }
-  }
-}
diff --git a/app/src/main/java/app/passwordstore/ui/util/OnOffItemAnimator.kt b/app/src/main/java/app/passwordstore/ui/util/OnOffItemAnimator.kt
deleted file mode 100644
index cd29f626..00000000
--- a/app/src/main/java/app/passwordstore/ui/util/OnOffItemAnimator.kt
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- * Copyright © 2014-2024 The Android Password Store Authors. All Rights Reserved.
- * SPDX-License-Identifier: GPL-3.0-only
- */
-package app.passwordstore.ui.util
-
-import androidx.recyclerview.widget.DefaultItemAnimator
-import androidx.recyclerview.widget.RecyclerView
-
-class OnOffItemAnimator : DefaultItemAnimator() {
-
-  var isEnabled: Boolean = true
-    set(value) {
-      // Defer update until no animation is running anymore.
-      isRunning { field = value }
-    }
-
-  private fun dontAnimate(viewHolder: RecyclerView.ViewHolder): Boolean {
-    dispatchAnimationFinished(viewHolder)
-    return false
-  }
-
-  override fun animateAppearance(
-    viewHolder: RecyclerView.ViewHolder,
-    preLayoutInfo: ItemHolderInfo?,
-    postLayoutInfo: ItemHolderInfo,
-  ): Boolean {
-    return if (isEnabled) {
-      super.animateAppearance(viewHolder, preLayoutInfo, postLayoutInfo)
-    } else {
-      dontAnimate(viewHolder)
-    }
-  }
-
-  override fun animateChange(
-    oldHolder: RecyclerView.ViewHolder,
-    newHolder: RecyclerView.ViewHolder,
-    preInfo: ItemHolderInfo,
-    postInfo: ItemHolderInfo,
-  ): Boolean {
-    return if (isEnabled) {
-      super.animateChange(oldHolder, newHolder, preInfo, postInfo)
-    } else {
-      dontAnimate(oldHolder)
-    }
-  }
-
-  override fun animateDisappearance(
-    viewHolder: RecyclerView.ViewHolder,
-    preLayoutInfo: ItemHolderInfo,
-    postLayoutInfo: ItemHolderInfo?,
-  ): Boolean {
-    return if (isEnabled) {
-      super.animateDisappearance(viewHolder, preLayoutInfo, postLayoutInfo)
-    } else {
-      dontAnimate(viewHolder)
-    }
-  }
-
-  override fun animatePersistence(
-    viewHolder: RecyclerView.ViewHolder,
-    preInfo: ItemHolderInfo,
-    postInfo: ItemHolderInfo,
-  ): Boolean {
-    return if (isEnabled) {
-      super.animatePersistence(viewHolder, preInfo, postInfo)
-    } else {
-      dontAnimate(viewHolder)
-    }
-  }
-}
diff --git a/app/src/main/java/app/passwordstore/util/autofill/AutofillViewUtils.kt b/app/src/main/java/app/passwordstore/util/autofill/AutofillViewUtils.kt
index ebe4bc7d..59fd5cca 100644
--- a/app/src/main/java/app/passwordstore/util/autofill/AutofillViewUtils.kt
+++ b/app/src/main/java/app/passwordstore/util/autofill/AutofillViewUtils.kt
@@ -20,7 +20,7 @@ import androidx.autofill.inline.UiVersions
 import androidx.autofill.inline.v1.InlineSuggestionUi
 import app.passwordstore.R
 import app.passwordstore.data.repo.PasswordRepository
-import app.passwordstore.ui.passwords.PasswordStore
+import app.passwordstore.ui.main.LaunchActivity
 import java.io.File
 
 data class DatasetMetadata(val title: String, val subtitle: String?, @DrawableRes val iconRes: Int)
@@ -55,7 +55,7 @@ fun makeInlinePresentation(
     PendingIntent.getActivity(
       context,
       0,
-      Intent(context, PasswordStore::class.java),
+      Intent(context, LaunchActivity::class.java),
       if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
         PendingIntent.FLAG_MUTABLE
       } else {