diff --git a/app/build.gradle b/app/build.gradle index 7dfa13ef3..07abead9b 100644 --- a/app/build.gradle +++ b/app/build.gradle @@ -1369,6 +1369,7 @@ dependencies { implementation 'org.tukaani:xz:1.12' implementation 'androidx.profileinstaller:profileinstaller:1.4.0' implementation 'androidx.appcompat:appcompat:1.7.1' + implementation 'androidx.drawerlayout:drawerlayout:1.2.0' implementation 'com.google.android.material:material:1.13.0' implementation 'androidx.constraintlayout:constraintlayout:2.2.1' diff --git a/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/SettingsNavigationLayoutInstrumentedTest.kt b/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/SettingsNavigationLayoutInstrumentedTest.kt index 43e3e56e1..551b662db 100644 --- a/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/SettingsNavigationLayoutInstrumentedTest.kt +++ b/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/SettingsNavigationLayoutInstrumentedTest.kt @@ -49,12 +49,12 @@ class SettingsNavigationLayoutInstrumentedTest { get() = InstrumentationRegistry.getInstrumentation() @Test - fun newHomeStartsWithoutLegacyNavigationAndKeepsTheStaticNavHostAnchor() { + fun newHomeSharesBottomNavigationAndKeepsTheStaticNavHostAnchor() { withHomeMode(useNewHome = true) { scenario -> assertLayout( scenario = scenario, - expectedContainerVisibility = View.GONE, - expectedChildCount = 0, + expectedContainerVisibility = View.VISIBLE, + expectedChildCount = 1, ) } } @@ -100,12 +100,12 @@ class SettingsNavigationLayoutInstrumentedTest { } @Test - fun switchingHomeModesDoesNotDuplicateLegacyNavigation() { + fun switchingHomeModesDoesNotDuplicateSharedNavigation() { withHomeMode(useNewHome = true) { scenario -> assertLayout( scenario = scenario, - expectedContainerVisibility = View.GONE, - expectedChildCount = 0, + expectedContainerVisibility = View.VISIBLE, + expectedChildCount = 1, ) setHomeMode(scenario, useNewHome = false) @@ -118,7 +118,7 @@ class SettingsNavigationLayoutInstrumentedTest { setHomeMode(scenario, useNewHome = true) assertLayout( scenario = scenario, - expectedContainerVisibility = View.GONE, + expectedContainerVisibility = View.VISIBLE, expectedChildCount = 1, ) @@ -312,14 +312,14 @@ class SettingsNavigationLayoutInstrumentedTest { } @Test - fun freshActivityCreationKeepsTheSelectedHomeAndInflatesOnlyItsRequiredNavigation() { + fun freshActivityCreationKeepsTheSelectedHomeAndSharedNavigation() { withHomeMode(useNewHome = true) { scenario -> val relaunchedScenario = relaunchAfterClosing(scenario) try { assertLayout( scenario = relaunchedScenario, - expectedContainerVisibility = View.GONE, - expectedChildCount = 0, + expectedContainerVisibility = View.VISIBLE, + expectedChildCount = 1, ) } finally { closeScenario(relaunchedScenario) @@ -588,10 +588,10 @@ class SettingsNavigationLayoutInstrumentedTest { instrumentation.waitForIdleSync() scenario.recreate() scenario.awaitSettingsContentReady() - assertLayout(scenario, View.GONE, if (useNewHome) 0 else 1) + assertLayout(scenario, View.GONE, 1) scenario.onActivity { assertTrue(navController(it).popBackStack()) } instrumentation.waitForIdleSync() - assertLayout(scenario, if (useNewHome) View.GONE else View.VISIBLE, if (useNewHome) 0 else 1) + assertLayout(scenario, View.VISIBLE, 1) } } } diff --git a/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/navigation/SettingsNavigationInstrumentedTest.kt b/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/navigation/SettingsNavigationInstrumentedTest.kt new file mode 100644 index 000000000..a97c7a6de --- /dev/null +++ b/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/navigation/SettingsNavigationInstrumentedTest.kt @@ -0,0 +1,209 @@ +package com.kazumaproject.markdownhelperkeyboard.setting_activity.navigation + +import android.content.Context +import android.content.Intent +import android.os.SystemClock +import android.view.MotionEvent +import android.view.View +import android.view.ViewGroup +import android.widget.TextView +import androidx.core.view.GravityCompat +import androidx.drawerlayout.widget.DrawerLayout +import androidx.navigation.fragment.NavHostFragment +import androidx.preference.PreferenceManager +import androidx.recyclerview.widget.RecyclerView +import androidx.test.core.app.ActivityScenario +import androidx.test.core.app.ApplicationProvider +import androidx.test.espresso.Espresso.onView +import androidx.test.espresso.action.ViewActions.click +import androidx.test.espresso.matcher.RootMatchers.isDialog +import androidx.test.espresso.matcher.ViewMatchers.withText +import androidx.test.ext.junit.runners.AndroidJUnit4 +import androidx.test.platform.app.InstrumentationRegistry +import androidx.viewpager2.widget.ViewPager2 +import com.google.android.material.bottomnavigation.BottomNavigationView +import com.google.android.material.tabs.TabLayout +import com.kazumaproject.markdownhelperkeyboard.R +import com.kazumaproject.markdownhelperkeyboard.setting_activity.AppPreference +import com.kazumaproject.markdownhelperkeyboard.setting_activity.MainActivity +import com.kazumaproject.markdownhelperkeyboard.setting_activity.awaitSettingsContentReady +import org.junit.Assert.* +import org.junit.Assume.assumeTrue +import org.junit.Test +import org.junit.runner.RunWith + +@RunWith(AndroidJUnit4::class) +class SettingsNavigationInstrumentedTest { + private val context = ApplicationProvider.getApplicationContext() + private val instrumentation = InstrumentationRegistry.getInstrumentation() + private fun descendants(view: View): Sequence = sequence { + yield(view) + if (view is ViewGroup) for (i in 0 until view.childCount) yieldAll(descendants(view.getChildAt(i))) + } + private fun await(scenario: ActivityScenario, message: String, condition: (MainActivity) -> Boolean) { + val deadline = SystemClock.uptimeMillis() + 20_000 + while (SystemClock.uptimeMillis() < deadline) { + var ready = false; scenario.onActivity { ready = condition(it) } + if (ready) return + SystemClock.sleep(50) + } + fail(message) + } + private fun drawer(activity: MainActivity) = activity.findViewById(R.id.settings_drawer_layout) + private fun bar(activity: MainActivity) = activity.findViewById(R.id.nav_view) + private fun host(activity: MainActivity) = (activity.supportFragmentManager.findFragmentById(R.id.nav_host_fragment_activity_main) as NavHostFragment) + private fun launch(legacy: Boolean = false, block: (ActivityScenario, SettingsNavigationStore) -> Unit) { + assumeTrue(context.packageName.endsWith(".settingsuxreview")) + AppPreference.init(context) + val backup = AppPreference.exportAllToJson() + val prefs = PreferenceManager.getDefaultSharedPreferences(context) + try { + prefs.edit().remove(SettingsNavigationStore.KEY).putBoolean("setting_use_new_home_screen_preference", !legacy).commit() + ActivityScenario.launch(Intent(context, MainActivity::class.java)).use { scenario -> + scenario.awaitSettingsContentReady(); block(scenario, SettingsNavigationStore(context)) + } + } finally { AppPreference.importAllFromJson(backup) } + } + @Test fun defaultManagementScreensRemainAccessibleInBothModesAndBackClosesDrawer() = launch { scenario, store -> + val destinations = store.bottom().map { it.destination } + for (legacy in listOf(false, true)) { + scenario.onActivity { + AppPreference.setting_use_new_home_screen_preference = !legacy + it.applySettingHomeModeFromPreference() + bar(it).findViewById(R.id.navigation_setting).performClick() + } + await(scenario, "Wrong settings mode") { host(it).navController.currentDestination?.id == if (legacy) R.id.settingMainFragment else R.id.navigation_setting } + if (legacy) await(scenario, "Selected legacy tab is off screen") { activity -> + val tabs = activity.findViewById(R.id.setting_tab_layout) + val selected = tabs?.getTabAt(tabs.selectedTabPosition)?.view + val bounds = android.graphics.Rect() + selected != null && selected.getGlobalVisibleRect(bounds) && bounds.width() == selected.width + } + scenario.onActivity { activity -> + assertEquals(destinations, (0 until bar(activity).menu.size()).map { bar(activity).menu.getItem(it).itemId }) + assertTrue(bar(activity).isShown) + } + for (destination in destinations.drop(1)) { + scenario.onActivity { bar(it).findViewById(destination).performClick() } + await(scenario, "Missing preserved management screen $destination") { host(it).navController.currentDestination?.id == destination } + } + scenario.onActivity { bar(it).findViewById(R.id.navigation_setting).performClick() } + await(scenario, "Missing settings root") { host(it).navController.currentDestination?.id in setOf(R.id.navigation_setting, R.id.settingMainFragment) } + scenario.onActivity { assertTrue(it.onSupportNavigateUp()) } + await(scenario, "Hamburger did not open drawer") { drawer(it).isDrawerOpen(GravityCompat.START) } + scenario.onActivity { it.onBackPressedDispatcher.onBackPressed() } + await(scenario, "Back did not close drawer") { !drawer(it).isDrawerVisible(GravityCompat.START) && !it.isFinishing } + scenario.onActivity { it.onSupportNavigateUp() } + await(scenario, "Drawer did not reopen") { drawer(it).isDrawerOpen(GravityCompat.START) } + scenario.onActivity { it.onSupportNavigateUp() } + await(scenario, "Hamburger did not close drawer") { !drawer(it).isDrawerVisible(GravityCompat.START) } + } + } + @Test fun drawerEditsBottomTabsAndKeepsTheSameConfigurationAfterModeSwitchAndRecreation() = launch { scenario, store -> + scenario.onActivity { it.onSupportNavigateUp() } + await(scenario, "Drawer missing") { drawer(it).isDrawerOpen(GravityCompat.START) } + scenario.onActivity { activity -> + activity.findViewById(R.id.settings_navigation_edit).performClick() + descendants(activity.findViewById(R.id.settings_drawer_content)).filterIsInstance().single().getTabAt(1)!!.select() + } + val learned = context.getString(R.string.learn_dictionary_fragment_title) + await(scenario, "Bottom editor missing") { it.findViewById(R.id.settings_drawer_list).adapter?.itemCount == 5 } + scenario.onActivity { activity -> + val list = activity.findViewById(R.id.settings_drawer_list) + val remove = descendants(list).filterIsInstance().single { it.contentDescription?.toString() == context.getString(R.string.settings_navigation_remove_item, learned) } + assertTrue("Remove control must be visibly large enough for its text", remove.getGlobalVisibleRect(android.graphics.Rect())) + assertTrue("Remove symbol must fit inside its padding", remove.width - remove.paddingLeft - remove.paddingRight >= remove.paint.measureText(remove.text.toString())) + val handle = descendants(list).filterIsInstance().first { it.text.toString() == context.getString(R.string.settings_navigation_drag_handle) } + assertTrue("Drag symbol must fit inside its padding", handle.width - handle.paddingLeft - handle.paddingRight >= handle.paint.measureText(handle.text.toString())) + remove.performClick() + } + await(scenario, "Bottom removal not reflected") { bar(it).menu.size() == 4 } + assertEquals(listOf("home", "user", "templates", "custom"), store.read().bottom) + scenario.onActivity { it.findViewById(R.id.settings_navigation_add).performClick() } + onView(withText(learned)).inRoot(isDialog()).perform(click()) + await(scenario, "Added bottom screen not saved") { store.read().bottom == listOf("home", "user", "templates", "custom", "learn") } + scenario.recreate(); scenario.awaitSettingsContentReady() + await(scenario, "Open drawer editor was not restored") { activity -> + drawer(activity).isDrawerOpen(GravityCompat.START) && + (activity.findViewById(R.id.settings_navigation_edit)?.text == context.getString(R.string.settings_navigation_done)) && + descendants(activity.findViewById(R.id.settings_drawer_content)).filterIsInstance().single().selectedTabPosition == 1 + } + scenario.onActivity { + drawer(it).closeDrawer(GravityCompat.START) + AppPreference.setting_use_new_home_screen_preference = false + it.applySettingHomeModeFromPreference() + } + scenario.recreate(); scenario.awaitSettingsContentReady() + scenario.onActivity { activity -> + assertEquals(store.bottom().map { it.destination }, (0 until bar(activity).menu.size()).map { bar(activity).menu.getItem(it).itemId }) + assertNotNull(activity.findViewById(R.id.setting_tab_layout)) + } + } + @Test fun sideScreensCanBeRemovedAddedAndMovedWithoutChangingTheirNames() = launch { scenario, store -> + scenario.onActivity { it.onSupportNavigateUp() } + await(scenario, "Drawer missing") { drawer(it).isDrawerOpen(GravityCompat.START) } + val home = store.catalog.single { it.key == "home" }.title + scenario.onActivity { activity -> + activity.findViewById(R.id.settings_navigation_edit).performClick() + val list = activity.findViewById(R.id.settings_drawer_list) + descendants(list).single { it.contentDescription?.toString() == context.getString(R.string.settings_navigation_remove_item, home) }.performClick() + } + assertFalse("home" in store.read().drawer) + scenario.onActivity { it.findViewById(R.id.settings_navigation_add).performClick() } + onView(withText(home)).inRoot(isDialog()).perform(click()) + await(scenario, "Added side screen not saved") { store.read().drawer.lastOrNull() == "home" } + scenario.onActivity { activity -> + val list = activity.findViewById(R.id.settings_drawer_list) + val first = list.findViewHolderForAdapterPosition(0)!!.itemView + assertEquals("search", store.read().drawer.first()) + assertTrue(androidx.core.view.ViewCompat.performAccessibilityAction(first, R.id.setting_frequent_action_move_down, null)) + } + assertEquals("selection", store.read().drawer.first()) + assertEquals("Editing the side menu must not change bottom tabs", SettingsNavigationStore.DEFAULT_BOTTOM, store.read().bottom) + } + + @Test fun bottomLongPressDragChangesOrderWithoutNavigatingAndPersistsAfterRecreation() = launch { scenario, store -> + var from = FloatArray(2); var to = FloatArray(2) + scenario.onActivity { activity -> + fun center(id: Int): FloatArray { val view = bar(activity).findViewById(id); val xy = IntArray(2); view.getLocationOnScreen(xy); return floatArrayOf(xy[0] + view.width / 2f, xy[1] + view.height / 2f) } + from = center(R.id.navigation_setting); to = center(R.id.keyboardListFragment) + } + val down = SystemClock.uptimeMillis() + fun event(action: Int, x: Float, y: Float) { + val event = MotionEvent.obtain(down, SystemClock.uptimeMillis(), action, x, y, 0) + event.source = android.view.InputDevice.SOURCE_TOUCHSCREEN + assertTrue(instrumentation.uiAutomation.injectInputEvent(event, true)); event.recycle() + } + event(MotionEvent.ACTION_DOWN, from[0], from[1]); SystemClock.sleep(800) + for (i in 1..15) { event(MotionEvent.ACTION_MOVE, from[0] + (to[0] - from[0]) * i / 15f, from[1]); SystemClock.sleep(30) } + event(MotionEvent.ACTION_UP, to[0], to[1]) + await(scenario, "Drop did not persist order") { store.read().bottom == listOf("learn", "user", "templates", "custom", "home") } + scenario.onActivity { assertEquals(R.id.navigation_setting, host(it).navController.currentDestination?.id) } + scenario.recreate(); scenario.awaitSettingsContentReady() + scenario.onActivity { assertEquals(R.id.navigation_setting, bar(it).menu.getItem(4).itemId) } + } + @Test fun conventionalTopTabsStayFixedWhileSideAndBottomConfigurationChanges() = launch(legacy = true) { scenario, store -> + val tabs = com.kazumaproject.markdownhelperkeyboard.setting_activity.ui.setting.SettingTabRegistry.createTabs() + await(scenario, "Legacy tabs missing") { it.findViewById(R.id.setting_tab_layout)?.tabCount == tabs.size } + scenario.onActivity { activity -> + store.save(SettingsNavigationConfig(listOf("home", "custom"), listOf("home", "custom", "learn"))) + activity.findViewById(R.id.setting_tab_layout).getTabAt(3)!!.select() + } + scenario.recreate(); scenario.awaitSettingsContentReady() + await(scenario, "Fixed top tabs must retain their selection") { it.findViewById(R.id.setting_tab_layout)?.selectedTabPosition == 3 } + scenario.onActivity { activity -> + val top = activity.findViewById(R.id.setting_tab_layout) + assertEquals(tabs.map { it.title(context) }, (0 until top.tabCount).map { top.getTabAt(it)!!.text.toString() }) + assertEquals(3, bar(activity).menu.size()) + activity.onSupportNavigateUp() + } + await(scenario, "Drawer missing") { drawer(it).isDrawerOpen(GravityCompat.START) } + scenario.onActivity { activity -> + activity.findViewById(R.id.settings_navigation_edit).performClick() + val editor = descendants(activity.findViewById(R.id.settings_drawer_content)).filterIsInstance().single() + assertEquals("Only side and bottom navigation are editable", 2, editor.tabCount) + assertEquals(context.getString(R.string.settings_navigation_side), editor.getTabAt(0)!!.text) + assertEquals(context.getString(R.string.settings_navigation_bottom), editor.getTabAt(1)!!.text) + } + } +} diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/MainActivity.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/MainActivity.kt index 8e5d030bf..a6dfa8dd4 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/MainActivity.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/MainActivity.kt @@ -1,6 +1,11 @@ package com.kazumaproject.markdownhelperkeyboard.setting_activity import android.content.Intent +import android.content.SharedPreferences +import androidx.activity.OnBackPressedCallback +import androidx.core.view.GravityCompat +import androidx.drawerlayout.widget.DrawerLayout +import com.kazumaproject.markdownhelperkeyboard.setting_activity.navigation.* import android.graphics.drawable.Drawable import android.os.Bundle import android.view.Menu @@ -21,11 +26,11 @@ import androidx.lifecycle.withResumed import androidx.lifecycle.withStarted import androidx.navigation.NavController import androidx.navigation.NavOptions +import androidx.navigation.NavGraph.Companion.findStartDestination import androidx.navigation.fragment.NavHostFragment import androidx.navigation.ui.AppBarConfiguration import androidx.navigation.ui.NavigationUI import androidx.navigation.ui.setupActionBarWithNavController -import androidx.navigation.ui.setupWithNavController import com.google.android.material.bottomnavigation.BottomNavigationView import com.google.android.material.color.DynamicColors import com.google.android.material.color.DynamicColorsOptions @@ -57,6 +62,18 @@ class MainActivity : AppCompatActivity() { private lateinit var binding: ActivityMainBinding private lateinit var mainNavController: NavController private var bottomNavigationView: BottomNavigationView? = null + private lateinit var navigationStore: SettingsNavigationStore + private lateinit var navigationDrawer: SettingsNavigationDrawer + private lateinit var appBarConfiguration: AppBarConfiguration + private var bottomDrag: SettingsBottomDrag? = null + private var restoredNavigationState: Bundle? = null + private val navigationPreferencesListener = SharedPreferences.OnSharedPreferenceChangeListener { _, key -> + if (key == SettingsNavigationStore.KEY && ::navigationStore.isInitialized) runOnUiThread { renderBottomNavigation() } + } + private val drawerBack = object : OnBackPressedCallback(true) { + override fun handleOnBackPressed() { binding.settingsDrawerLayout.closeDrawer(GravityCompat.START) } + } + private var currentDestinationId: Int? = null private var restoredNavHost: NavHostFragment? = null private var deferredFragmentManagerState: Bundle? = null @@ -113,6 +130,7 @@ class MainActivity : AppCompatActivity() { ?.getBoolean(PENDING_INTENT_RECEIVED_KEY) ?: false pendingIntentRequest = savedInstanceState?.getString(PENDING_INTENT_REQUEST_KEY) + restoredNavigationState = savedInstanceState?.getBundle("settings-navigation-ui") super.onCreate(savedInstanceState) // Window fitting must be configured before the delayed preferences load. // Configuring it after the Activity has started can leave AppCompat's @@ -175,6 +193,10 @@ class MainActivity : AppCompatActivity() { override fun onSaveInstanceState(outState: Bundle) { super.onSaveInstanceState(outState) + val navigationState = if (::navigationDrawer.isInitialized) navigationDrawer.saveState().apply { + putBoolean("open", binding.settingsDrawerLayout.isDrawerVisible(GravityCompat.START)) + } else restoredNavigationState + navigationState?.let { outState.putBundle("settings-navigation-ui", it) } outState.putBoolean(INITIAL_INTENT_HANDLED_KEY, initialIntentHandled) outState.putBoolean( PENDING_INTENT_RECEIVED_KEY, @@ -222,13 +244,11 @@ class MainActivity : AppCompatActivity() { mainNavController = findMainNavController() val navController = mainNavController installNavigationGraph(navController) - val appBarConfiguration = AppBarConfiguration( - setOf( - R.id.navigation_setting, - R.id.settingMainFragment, - R.id.navigation_learn_dictionary, - R.id.navigation_user_dictionary, - ) + navigationStore = SettingsNavigationStore(this) + setupNavigationDrawer(navController) + appBarConfiguration = AppBarConfiguration( + navigationStore.catalog.map { it.destination }.toSet() + R.id.settingMainFragment, + binding.settingsDrawerLayout, ) setupActionBarWithNavController(navController, appBarConfiguration) if (dynamicColorsAvailable) { @@ -247,10 +267,8 @@ class MainActivity : AppCompatActivity() { ?.findItem(R.id.navigation_setting) ?.isChecked = true } - updateBottomNavigationVisibility( - appPreference.setting_use_new_home_screen_preference, - navController, - ) + updateBottomNavigationVisibility(navController) + updateNavigationSelection(destination.id) updateSharedActionBarVisibility(destination.id) invalidateOptionsMenu() } @@ -305,13 +323,17 @@ class MainActivity : AppCompatActivity() { override fun onSupportNavigateUp(): Boolean { if (!isSettingsContentReady) return super.onSupportNavigateUp() + if (binding.settingsDrawerLayout.isDrawerVisible(GravityCompat.START)) { + binding.settingsDrawerLayout.closeDrawer(GravityCompat.START) + return true + } val navController = currentNavController() val current = (supportFragmentManager.findFragmentById(R.id.nav_host_fragment_activity_main) as? androidx.navigation.fragment.NavHostFragment)?.childFragmentManager?.primaryNavigationFragment if (current is com.kazumaproject.markdownhelperkeyboard.sumire_popup.PopupMapEditorFragment) { current.leaveEditor() return true } - return navController.navigateUp() || super.onSupportNavigateUp() + return NavigationUI.navigateUp(navController, appBarConfiguration) || super.onSupportNavigateUp() } private fun updateSharedActionBarVisibility(destinationId: Int) { @@ -374,23 +396,17 @@ class MainActivity : AppCompatActivity() { } fun applySettingHomeModeFromPreference(navController: NavController? = null) { - val useNewDashboard = appPreference.setting_use_new_home_screen_preference val resolvedNavController = navController ?: currentNavController() - updateBottomNavigationVisibility(useNewDashboard, resolvedNavController) + updateBottomNavigationVisibility(resolvedNavController) ensurePreferredSettingHomeIfNeeded(resolvedNavController) } private fun updateBottomNavigationVisibility( - useNewDashboard: Boolean, navController: NavController, ) { - if (useNewDashboard) { - binding.navViewContainer.visibility = View.GONE - return - } ensureBottomNavigation(navController) binding.navViewContainer.visibility = - if (navController.currentDestination?.id in destinationsWithoutBottomNavigation) { + if (navController.currentDestination?.id in destinationsWithoutBottomNavigation || navigationStore.bottom().isEmpty()) { View.GONE } else { View.VISIBLE @@ -407,6 +423,8 @@ class MainActivity : AppCompatActivity() { binding.navViewContainer.addView(navView) setupBottomNavigation(navView, navController) bottomNavigationView = navView + bottomDrag = SettingsBottomDrag(navView, navigationStore, ::renderBottomNavigation) + renderBottomNavigation() return navView } @@ -414,11 +432,14 @@ class MainActivity : AppCompatActivity() { navView: BottomNavigationView, navController: NavController, ) { - navView.setupWithNavController(navController) navView.setOnItemSelectedListener { item -> if (item.itemId == R.id.navigation_setting) { navigateToPreferredSettingHome(navController) true + } else if (item.itemId == R.id.settingSearchFragment) { + navController.navigate(item.itemId, navigationArguments(item.itemId), NavOptions.Builder() + .setLaunchSingleTop(true).setPopUpTo(navController.graph.findStartDestination().id, false).build()) + true } else { NavigationUI.onNavDestinationSelected(item, navController) } @@ -430,6 +451,67 @@ class MainActivity : AppCompatActivity() { } } + private fun navigationArguments(destination: Int): Bundle? = if (destination == R.id.settingSearchFragment) Bundle().apply { + putString(com.kazumaproject.markdownhelperkeyboard.setting_activity.ui.setting.SettingSearchFragment.ARG_SEARCH_SCOPE, + (if (appPreference.setting_use_new_home_screen_preference) + com.kazumaproject.markdownhelperkeyboard.setting_activity.ui.setting.SettingSearchScope.NEW_HOME + else com.kazumaproject.markdownhelperkeyboard.setting_activity.ui.setting.SettingSearchScope.LEGACY_TABS).name) + } else null + + private fun setupNavigationDrawer(navController: NavController) { + val width = minOf((360 * resources.displayMetrics.density).toInt(), resources.displayMetrics.widthPixels - (56 * resources.displayMetrics.density).toInt()) + binding.settingsDrawerContent.layoutParams = binding.settingsDrawerContent.layoutParams.apply { this.width = width } + navigationDrawer = SettingsNavigationDrawer(this, navigationStore) { item -> + binding.settingsDrawerLayout.closeDrawer(GravityCompat.START) + if (item.key == "home") navigateToPreferredSettingHome(navController) + else navController.navigate(item.destination, navigationArguments(item.destination), NavOptions.Builder().setLaunchSingleTop(true) + .setPopUpTo(navController.graph.findStartDestination().id, false).build()) + } + binding.settingsDrawerContent.addView(navigationDrawer) + navigationDrawer.restoreState(restoredNavigationState) + if (restoredNavigationState?.getBoolean("open") == true) binding.settingsDrawerLayout.post { + if (!isFinishing && !isDestroyed) binding.settingsDrawerLayout.openDrawer(GravityCompat.START) + } + restoredNavigationState = null + binding.settingsDrawerLayout.addDrawerListener(object : DrawerLayout.SimpleDrawerListener() { + private var handlingBack = false + override fun onDrawerSlide(drawerView: View, slideOffset: Float) { + if (slideOffset > 0f && !handlingBack) { + onBackPressedDispatcher.addCallback(this@MainActivity, drawerBack); handlingBack = true + } + } + override fun onDrawerClosed(drawerView: View) { + drawerBack.remove(); handlingBack = false; navigationDrawer.finishEditing() + } + }) + androidx.preference.PreferenceManager.getDefaultSharedPreferences(this) + .registerOnSharedPreferenceChangeListener(navigationPreferencesListener) + } + + private fun renderBottomNavigation() { + if (bottomDrag?.isDragging == true) return + val bar = bottomNavigationView ?: return + val items = navigationStore.bottom() + bar.menu.clear() + items.forEachIndexed { index, item -> bar.menu.add(Menu.NONE, item.destination, index, item.title).setIcon(item.icon) } + bottomDrag?.bind() + updateNavigationSelection(mainNavController.currentDestination?.id) + binding.navViewContainer.visibility = if (items.isEmpty() || mainNavController.currentDestination?.id in destinationsWithoutBottomNavigation) View.GONE else View.VISIBLE + } + + private fun updateNavigationSelection(destination: Int?) { + val resolved = if (destination == R.id.settingMainFragment) R.id.navigation_setting else destination + navigationDrawer.select(resolved) + val menu = bottomNavigationView?.menu ?: return + for (index in 0 until menu.size()) menu.getItem(index).isChecked = menu.getItem(index).itemId == resolved + } + + override fun onDestroy() { + if (::navigationStore.isInitialized) androidx.preference.PreferenceManager.getDefaultSharedPreferences(this) + .unregisterOnSharedPreferenceChangeListener(navigationPreferencesListener) + super.onDestroy() + } + private fun setupSettingHomeSwitchMenu(navController: NavController) { addMenuProvider( object : MenuProvider { diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/navigation/SettingsBottomDrag.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/navigation/SettingsBottomDrag.kt new file mode 100644 index 000000000..a48c1ba48 --- /dev/null +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/navigation/SettingsBottomDrag.kt @@ -0,0 +1,94 @@ +package com.kazumaproject.markdownhelperkeyboard.setting_activity.navigation + +import android.content.ClipData +import android.view.DragEvent +import android.view.View +import androidx.core.view.AccessibilityDelegateCompat +import androidx.core.view.ViewCompat +import androidx.core.view.accessibility.AccessibilityNodeInfoCompat +import com.google.android.material.bottomnavigation.BottomNavigationView +import com.kazumaproject.markdownhelperkeyboard.R +import kotlin.math.abs + +/** Keep the menu intact during a drag, animating slots until the order is committed on drop. */ +internal class SettingsBottomDrag( + private val bar: BottomNavigationView, + private val store: SettingsNavigationStore, + private val refresh: () -> Unit, +) { + private data class Dragged(val key: String, val owner: BottomNavigationView) + var isDragging = false; private set + private var original = emptyList() + private var pending = emptyList() + private val centers = mutableMapOf() + init { + bar.setOnDragListener { _, event -> + val dragged = event.localState as? Dragged + if (dragged?.owner !== bar) return@setOnDragListener false + when (event.action) { + DragEvent.ACTION_DRAG_STARTED -> { isDragging = true; original = store.bottom(); pending = original; captureCenters(); true } + DragEvent.ACTION_DRAG_LOCATION -> { preview(dragged.key, event.x); true } + DragEvent.ACTION_DROP -> { + preview(dragged.key, event.x) + val config = store.read(); val visible = original.map { it.key }.toSet(); val order = pending.map { it.key }.iterator() + store.save(config.copy(bottom = config.bottom.map { if (it in visible) order.next() else it })) + true + } + DragEvent.ACTION_DRAG_ENDED -> { + isDragging = false + original.forEach { item -> bar.findViewById(item.destination)?.apply { animate().cancel(); translationX = 0f; alpha = 1f } } + bar.post { refresh() }; true + } + else -> true + } + } + } + private fun captureCenters() { + centers.clear() + original.forEach { item -> bar.findViewById(item.destination)?.let { view -> + val rect = android.graphics.Rect(); view.getDrawingRect(rect); bar.offsetDescendantRectToMyCoords(view, rect) + centers[item.key] = rect.exactCenterX() + } } + } + private fun preview(key: String, x: Float) { + if (original.size < 2 || centers.size != original.size) return + val target = original.indices.minByOrNull { abs(centers.getValue(original[it].key) - x) } ?: return + val moved = original.find { it.key == key } ?: return + pending = original.filterNot { it.key == key }.toMutableList().apply { add(target, moved) } + pending.forEachIndexed { index, item -> + bar.findViewById(item.destination)?.apply { + alpha = if (item.key == key) .4f else 1f + animate().translationX(centers.getValue(original[index].key) - centers.getValue(item.key)).setDuration(100).start() + } + } + } + fun bind() { + val items = store.bottom() + items.forEachIndexed { index, item -> + bar.findViewById(item.destination)?.let { view -> + view.setOnLongClickListener { + it.startDragAndDrop(ClipData.newPlainText("settings-tab", item.key), View.DragShadowBuilder(it), Dragged(item.key, bar), 0) + } + ViewCompat.setAccessibilityDelegate(view, object : AccessibilityDelegateCompat() { + override fun onInitializeAccessibilityNodeInfo(host: View, info: AccessibilityNodeInfoCompat) { + super.onInitializeAccessibilityNodeInfo(host, info) + if (index > 0) info.addAction(AccessibilityNodeInfoCompat.AccessibilityActionCompat(R.id.setting_frequent_action_move_up, + bar.context.getString(R.string.setting_frequent_move_up, item.title))) + if (index < items.lastIndex) info.addAction(AccessibilityNodeInfoCompat.AccessibilityActionCompat(R.id.setting_frequent_action_move_down, + bar.context.getString(R.string.setting_frequent_move_down, item.title))) + } + override fun performAccessibilityAction(host: View, action: Int, args: android.os.Bundle?): Boolean { + val offset = when (action) { R.id.setting_frequent_action_move_up -> -1; R.id.setting_frequent_action_move_down -> 1; else -> return super.performAccessibilityAction(host, action, args) } + val config = store.read(); val order = store.bottom(config).map { it.key }.toMutableList() + val from = order.indexOf(item.key); val to = from + offset + if (from < 0 || to !in order.indices) return false + java.util.Collections.swap(order, from, to) + val available = order.toSet(); val iterator = order.iterator() + store.save(config.copy(bottom = config.bottom.map { if (it in available) iterator.next() else it })) + refresh(); return true + } + }) + } + } + } +} diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/navigation/SettingsNavigationDrawer.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/navigation/SettingsNavigationDrawer.kt new file mode 100644 index 000000000..0dc67ab62 --- /dev/null +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/navigation/SettingsNavigationDrawer.kt @@ -0,0 +1,202 @@ +package com.kazumaproject.markdownhelperkeyboard.setting_activity.navigation + +import android.annotation.SuppressLint +import android.content.Context +import android.os.Bundle +import android.view.Gravity +import android.view.MotionEvent +import android.view.View +import android.view.ViewGroup +import android.widget.LinearLayout +import android.widget.TextView +import androidx.core.view.AccessibilityDelegateCompat +import androidx.core.view.ViewCompat +import androidx.core.view.accessibility.AccessibilityNodeInfoCompat +import androidx.core.view.isVisible +import androidx.recyclerview.widget.ItemTouchHelper +import androidx.recyclerview.widget.LinearLayoutManager +import androidx.recyclerview.widget.RecyclerView +import com.google.android.material.button.MaterialButton +import com.google.android.material.dialog.MaterialAlertDialogBuilder +import com.google.android.material.tabs.TabLayout +import com.kazumaproject.markdownhelperkeyboard.R + +/** Editing stays inside the drawer. Names come from the destination catalog. */ +internal class SettingsNavigationDrawer( + context: Context, + private val store: SettingsNavigationStore, + private val navigate: (SettingsNavigationItem) -> Unit, +) : LinearLayout(context) { + private enum class Section { DRAWER, BOTTOM } + private var section = Section.DRAWER + private var editing = false + private var selectedDestination: Int? = null + private val rows = Rows() + private val list = RecyclerView(context).apply { + id = R.id.settings_drawer_list + layoutManager = LinearLayoutManager(context); adapter = rows + } + private val tabs = TabLayout(context) + private val hint = TextView(context).apply { textSize = 12f; setPadding(dp(16), dp(8), dp(16), dp(8)) } + private val edit = textButton(R.string.settings_navigation_edit).apply { + id = R.id.settings_navigation_edit + setOnClickListener { editing = !editing; render() } + } + private val add = textButton(R.string.settings_navigation_add).apply { + id = R.id.settings_navigation_add + setOnClickListener { addItem() } + } + private val reset = textButton(R.string.settings_navigation_reset).apply { + setOnClickListener { + MaterialAlertDialogBuilder(context).setMessage(R.string.settings_navigation_reset_confirm) + .setNegativeButton(android.R.string.cancel, null) + .setPositiveButton(R.string.settings_navigation_reset) { _, _ -> store.save(store.defaults); render() }.show() + } + } + private val drag = ItemTouchHelper(object : ItemTouchHelper.SimpleCallback(ItemTouchHelper.UP or ItemTouchHelper.DOWN, 0) { + override fun isLongPressDragEnabled() = editing + override fun onMove(recyclerView: RecyclerView, from: RecyclerView.ViewHolder, to: RecyclerView.ViewHolder): Boolean { + val a = from.bindingAdapterPosition; val b = to.bindingAdapterPosition + if (!editing || a < 0 || b < 0) return false + rows.entries.add(b, rows.entries.removeAt(a)); rows.notifyItemMoved(a, b) + return true + } + override fun onSwiped(holder: RecyclerView.ViewHolder, direction: Int) = Unit + override fun clearView(recyclerView: RecyclerView, holder: RecyclerView.ViewHolder) { + super.clearView(recyclerView, holder) + if (editing) { saveOrder(rows.entries.map { it.key }); render() } + } + }) + init { + orientation = VERTICAL + addView(LinearLayout(context).apply { + gravity = Gravity.CENTER_VERTICAL; setPadding(dp(16), dp(4), dp(8), dp(4)) + addView(TextView(context).apply { setText(R.string.settings_navigation_title); textSize = 20f }, LayoutParams(0, -2, 1f)) + addView(edit, LayoutParams(-2, -2)) + }) + listOf(R.string.settings_navigation_side, R.string.settings_navigation_bottom).forEach { + tabs.addTab(tabs.newTab().setText(it)) + } + tabs.addOnTabSelectedListener(object : TabLayout.OnTabSelectedListener { + override fun onTabSelected(tab: TabLayout.Tab) { section = Section.entries[tab.position]; render() } + override fun onTabUnselected(tab: TabLayout.Tab) = Unit + override fun onTabReselected(tab: TabLayout.Tab) = Unit + }) + addView(tabs); addView(hint) + addView(list, LayoutParams(-1, 0, 1f)) + addView(add, LayoutParams(-1, -2).apply { setMargins(dp(8), 0, dp(8), 0) }) + addView(reset, LayoutParams(-1, -2).apply { setMargins(dp(8), 0, dp(8), dp(8)) }) + drag.attachToRecyclerView(list) + render() + } + private fun dp(value: Int) = (value * resources.displayMetrics.density).toInt() + private fun textButton(label: Int) = MaterialButton(context).apply { + setText(label); minHeight = dp(48); minimumHeight = dp(48) + backgroundTintList = android.content.res.ColorStateList.valueOf(android.graphics.Color.TRANSPARENT) + setTextColor(com.google.android.material.color.MaterialColors.getColor(this, androidx.appcompat.R.attr.colorPrimary)) + insetTop = 0; insetBottom = 0 + } + private fun entries(config: SettingsNavigationConfig): List = when (if (editing) section else Section.DRAWER) { + Section.DRAWER -> store.items(config.drawer) + Section.BOTTOM -> store.bottom(config) + } + fun saveState() = Bundle().apply { + putBoolean("editing", editing); putString("section", section.name) + putParcelable("scroll", list.layoutManager?.onSaveInstanceState()) + } + fun restoreState(state: Bundle?) { + if (state == null) return + editing = state.getBoolean("editing") + section = runCatching { Section.valueOf(state.getString("section").orEmpty()) }.getOrDefault(Section.DRAWER) + tabs.getTabAt(section.ordinal)?.select(); render() + @Suppress("DEPRECATION") val scroll = state.getParcelable("scroll") + list.layoutManager?.onRestoreInstanceState(scroll) + } + fun select(destination: Int?) { selectedDestination = destination; rows.notifyDataSetChanged() } + fun finishEditing() { editing = false; render() } + private fun render() { + edit.setText(if (editing) R.string.settings_navigation_done else R.string.settings_navigation_edit) + tabs.isVisible = editing; add.isVisible = editing; reset.isVisible = editing + hint.setText(if (!editing) R.string.settings_navigation_hint else when (section) { + Section.DRAWER -> R.string.settings_navigation_side_hint + Section.BOTTOM -> R.string.settings_navigation_bottom_hint + }) + rows.entries = entries(store.read()).toMutableList(); rows.notifyDataSetChanged() + } + private fun keys(config: SettingsNavigationConfig) = when (section) { + Section.DRAWER -> config.drawer; Section.BOTTOM -> config.bottom + } + private fun replace(config: SettingsNavigationConfig, keys: List) = when (section) { + Section.DRAWER -> config.copy(drawer = keys); Section.BOTTOM -> config.copy(bottom = keys) + } + private fun saveOrder(order: List) { + val config = store.read(); val available = entries(config).map { it.key }.toSet() + val iterator = order.iterator() + val merged = keys(config).mapNotNull { if (it in available) { if (iterator.hasNext()) iterator.next() else null } else it } + iterator.asSequence().toList() + store.save(replace(config, merged)) + } + private fun remove(key: String) { val config = store.read(); store.save(replace(config, keys(config) - key)); render() } + private fun addItem() { + val config = store.read() + if (section == Section.BOTTOM && store.bottom(config).size >= SettingsNavigationStore.MAX_BOTTOM) { + android.widget.Toast.makeText(context, R.string.settings_navigation_limit, android.widget.Toast.LENGTH_SHORT).show(); return + } + val available = store.catalog + val choices = available.filter { it.key !in keys(config) } + if (choices.isEmpty()) { android.widget.Toast.makeText(context, R.string.settings_navigation_all_added, android.widget.Toast.LENGTH_SHORT).show(); return } + MaterialAlertDialogBuilder(context).setTitle(R.string.settings_navigation_add) + .setItems(choices.map { it.title }.toTypedArray()) { _, index -> + store.save(replace(config, keys(config) + choices[index].key)); render() + }.setNegativeButton(android.R.string.cancel, null).show() + } + private inner class Rows : RecyclerView.Adapter() { + var entries = mutableListOf() + override fun getItemCount() = entries.size + override fun onCreateViewHolder(parent: ViewGroup, type: Int) = Holder(LinearLayout(context)) + override fun onBindViewHolder(holder: Holder, position: Int) = holder.bind(entries[position]) + inner class Holder(private val row: LinearLayout) : RecyclerView.ViewHolder(row) { + private val handle = textButton(R.string.settings_navigation_drag_handle) + private val title = TextView(context).apply { textSize = 16f; gravity = Gravity.CENTER_VERTICAL; setPadding(dp(8), dp(8), dp(8), dp(8)) } + private val remove = textButton(R.string.settings_navigation_remove_symbol) + init { + row.layoutParams = RecyclerView.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT) + row.gravity = Gravity.CENTER_VERTICAL; row.minimumHeight = dp(56) + handle.setPadding(0, 0, 0, 0); handle.minWidth = 0; handle.minimumWidth = 0 + remove.setPadding(0, 0, 0, 0); remove.minWidth = 0; remove.minimumWidth = 0 + row.addView(handle, LayoutParams(dp(48), -2)); row.addView(title, LayoutParams(0, -2, 1f)) + row.addView(remove, LayoutParams(dp(48), -2)) + } + @SuppressLint("ClickableViewAccessibility") + fun bind(item: SettingsNavigationItem) { + title.text = item.title + row.isActivated = selectedDestination == item.destination + row.setBackgroundColor(if (row.isActivated) com.google.android.material.color.MaterialColors.getColor(row, + com.google.android.material.R.attr.colorSecondaryContainer) else android.graphics.Color.TRANSPARENT) + row.setOnClickListener { if (!editing) navigate(item) } + row.isClickable = !editing + row.isFocusable = true; row.contentDescription = item.title + handle.isVisible = editing; remove.isVisible = editing + handle.contentDescription = context.getString(R.string.setting_frequent_drag_reorder) + ": " + item.title + handle.setOnTouchListener { _, event -> if (event.actionMasked == MotionEvent.ACTION_DOWN) { drag.startDrag(this); true } else false } + remove.contentDescription = context.getString(R.string.settings_navigation_remove_item, item.title) + remove.setOnClickListener { remove(item.key) } + ViewCompat.setAccessibilityDelegate(row, object : AccessibilityDelegateCompat() { + override fun onInitializeAccessibilityNodeInfo(host: View, info: AccessibilityNodeInfoCompat) { + super.onInitializeAccessibilityNodeInfo(host, info) + if (!editing) return + if (bindingAdapterPosition > 0) info.addAction(AccessibilityNodeInfoCompat.AccessibilityActionCompat( + R.id.setting_frequent_action_move_up, context.getString(R.string.setting_frequent_move_up, item.title))) + if (bindingAdapterPosition < entries.lastIndex) info.addAction(AccessibilityNodeInfoCompat.AccessibilityActionCompat( + R.id.setting_frequent_action_move_down, context.getString(R.string.setting_frequent_move_down, item.title))) + } + override fun performAccessibilityAction(host: View, action: Int, args: Bundle?): Boolean { + val delta = when (action) { R.id.setting_frequent_action_move_up -> -1; R.id.setting_frequent_action_move_down -> 1; else -> return super.performAccessibilityAction(host, action, args) } + val from = entries.indexOfFirst { it.key == item.key }; val to = from + delta + if (!editing || from < 0 || to !in entries.indices) return false + entries.add(to, entries.removeAt(from)); saveOrder(entries.map { it.key }); render(); return true + } + }) + } + } + } +} diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/navigation/SettingsNavigationStore.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/navigation/SettingsNavigationStore.kt new file mode 100644 index 000000000..8938b9570 --- /dev/null +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/navigation/SettingsNavigationStore.kt @@ -0,0 +1,69 @@ +package com.kazumaproject.markdownhelperkeyboard.setting_activity.navigation + +import android.content.Context +import androidx.preference.PreferenceManager +import com.kazumaproject.markdownhelperkeyboard.R +import com.kazumaproject.core.R as CoreR +import com.kazumaproject.markdownhelperkeyboard.setting_activity.ui.setting.SettingDestinations +import com.kazumaproject.markdownhelperkeyboard.setting_activity.ui.setting.SettingDestinationType +import com.kazumaproject.markdownhelperkeyboard.setting_activity.ui.setting.SettingTabRegistry + +internal data class SettingsNavigationItem(val key: String, val title: String, val destination: Int, val icon: Int) + +internal fun settingsNavigationCatalog(context: Context): List { + val core = listOf( + SettingsNavigationItem("home", context.getString(R.string.settings_navigation_home), R.id.navigation_setting, CoreR.drawable.baseline_settings_24), + SettingsNavigationItem("search", context.getString(R.string.setting_search_title), R.id.settingSearchFragment, CoreR.drawable.baseline_search_24), + SettingsNavigationItem("selection", context.getString(R.string.keyboard_selection_preference_title), R.id.keyboardSelectionFragment, CoreR.drawable.keyboard_24px), + SettingsNavigationItem("appearance", context.getString(R.string.settings_navigation_appearance), R.id.keyboardDisplayPreferenceFragment, CoreR.drawable.keyboard_24px), + SettingsNavigationItem("learn", context.getString(R.string.learn_dictionary_fragment_title), R.id.navigation_learn_dictionary, CoreR.drawable.table_lamp_24px), + SettingsNavigationItem("user", context.getString(R.string.user_dictionary_title), R.id.navigation_user_dictionary, CoreR.drawable.dictionary_24px), + SettingsNavigationItem("templates", context.getString(R.string.user_template), R.id.userTemplateFragment, CoreR.drawable.book_3_24px), + SettingsNavigationItem("custom", context.getString(R.string.custom_keyboard_fragment_label), R.id.keyboardListFragment, CoreR.drawable.keyboard_24px), + ) + val routes = (SettingDestinations.categories(context) + SettingDestinations.management(context)).mapNotNull { item -> + val destination = when (val route = item.destination) { + is SettingDestinationType.NavDestination -> route.destinationId + is SettingDestinationType.ManagementDestination -> route.destinationId + else -> return@mapNotNull null + } + SettingsNavigationItem("route:${item.key}", item.title, destination, item.iconRes) + } + val tabs = SettingTabRegistry.createTabs().map { + SettingsNavigationItem("tab:${it.key}", it.title(context), it.destinationId, CoreR.drawable.baseline_settings_24) + } + return (core + routes + tabs).distinctBy { it.destination } +} + +internal data class SettingsNavigationConfig( + val drawer: List, val bottom: List, +) + +internal class SettingsNavigationStore(context: Context) { + private val preferences = PreferenceManager.getDefaultSharedPreferences(context) + val catalog = settingsNavigationCatalog(context) + val defaults get() = SettingsNavigationConfig(DEFAULT_DRAWER, DEFAULT_BOTTOM) + + fun read(): SettingsNavigationConfig = runCatching { + val json = preferences.getString(KEY, null) ?: return defaults + val data = com.google.gson.JsonParser.parseString(json).asJsonObject + fun keys(name: String) = data.getAsJsonArray(name).map { it.asString }.filter(String::isNotBlank).distinct() + SettingsNavigationConfig(keys("drawer"), keys("bottom")) + }.getOrElse { defaults } + + fun save(config: SettingsNavigationConfig) { + val data = com.google.gson.JsonObject() + for ((name, keys) in listOf("drawer" to config.drawer, "bottom" to config.bottom)) { + data.add(name, com.google.gson.JsonArray().apply { keys.distinct().forEach { add(it) } }) + } + preferences.edit().putString(KEY, data.toString()).apply() + } + fun items(keys: List) = keys.mapNotNull { key -> catalog.find { it.key == key } } + fun bottom(config: SettingsNavigationConfig = read()) = items(config.bottom).take(MAX_BOTTOM) + companion object { + const val KEY = "settings_navigation_v1" + const val MAX_BOTTOM = 5 + val DEFAULT_DRAWER = listOf("home", "search", "selection", "appearance", "learn", "user", "templates", "custom") + val DEFAULT_BOTTOM = listOf("home", "learn", "user", "templates", "custom") + } +} diff --git a/app/src/main/res/layout/activity_main.xml b/app/src/main/res/layout/activity_main.xml index a0ff0a632..90b6d778f 100644 --- a/app/src/main/res/layout/activity_main.xml +++ b/app/src/main/res/layout/activity_main.xml @@ -1,29 +1,42 @@ - - + + + - + - + + + + diff --git a/app/src/main/res/values-ja/settings_navigation.xml b/app/src/main/res/values-ja/settings_navigation.xml new file mode 100644 index 000000000..51360a6de --- /dev/null +++ b/app/src/main/res/values-ja/settings_navigation.xml @@ -0,0 +1,22 @@ + + + メニュー + 表示を編集 + 完了 + 画面を追加 + 初期状態に戻す + サイドメニューと画面下のタブを初期状態に戻しますか? + サイドメニュー + 画面下のタブ + 画面を選んで開きます。「表示を編集」でこのメニューと画面下のタブを変更できます。 + このメニューに表示する画面です。ドラッグで並べ替え、×でメニューから外します。変更は自動保存されます。 + 画面下にタブで表示する画面です。最大5項目まで追加できます。下のタブを長押ししてドラッグでも並べ替えられます。 + 下部タブは最大5項目です。先に1つ外してから追加してください。 + 追加できる画面はすべて追加済みです。 + ≡ + × + サイドナビゲーションを開く + 見た目・配置 + 設定トップ + %1$sを表示から外す + diff --git a/app/src/main/res/values/ids.xml b/app/src/main/res/values/ids.xml index e8eb2b7ee..7837d1489 100644 --- a/app/src/main/res/values/ids.xml +++ b/app/src/main/res/values/ids.xml @@ -18,4 +18,7 @@ + + + diff --git a/app/src/main/res/values/settings_navigation.xml b/app/src/main/res/values/settings_navigation.xml new file mode 100644 index 000000000..541175963 --- /dev/null +++ b/app/src/main/res/values/settings_navigation.xml @@ -0,0 +1,22 @@ + + + Menu + Edit screens + Done + Add screen + Reset tabs + Restore the side menu and bottom tabs to their defaults? + Side menu + Bottom tabs + Choose a screen. Use Edit screens to change this menu or the tabs at the bottom. + Screens shown in this side menu. Drag to reorder; × removes a shortcut. Changes save automatically. + Screens shown as tabs at the bottom. Add up to 5. Long-press and drag the bottom bar to reorder too. + The bottom bar holds 5 tabs. Remove one before adding another. + All available screens have been added. + ≡ + × + Open side navigation + Appearance and position + Settings home + Remove %1$s shortcut + diff --git a/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/navigation/SettingsNavigationStoreTest.kt b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/navigation/SettingsNavigationStoreTest.kt new file mode 100644 index 000000000..e4d8aec3f --- /dev/null +++ b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/navigation/SettingsNavigationStoreTest.kt @@ -0,0 +1,57 @@ +package com.kazumaproject.markdownhelperkeyboard.setting_activity.navigation + +import android.content.Context +import androidx.preference.PreferenceManager +import androidx.test.core.app.ApplicationProvider +import com.kazumaproject.markdownhelperkeyboard.R +import com.kazumaproject.markdownhelperkeyboard.setting_activity.AppPreference +import org.junit.Assert.* +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.annotation.Config + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [35]) +class SettingsNavigationStoreTest { + private val context = ApplicationProvider.getApplicationContext() + private val prefs = PreferenceManager.getDefaultSharedPreferences(context) + @Before fun setup() { prefs.edit().clear().commit(); AppPreference.init(context) } + @Test fun defaultsRetainEveryExistingManagementBottomTab() { + val store = SettingsNavigationStore(context) + assertEquals(SettingsNavigationStore.DEFAULT_BOTTOM, store.read().bottom) + assertEquals(SettingsNavigationStore.DEFAULT_DRAWER, store.read().drawer) + assertEquals(listOf(R.id.navigation_setting, R.id.navigation_learn_dictionary, + R.id.navigation_user_dictionary, R.id.userTemplateFragment, R.id.keyboardListFragment), store.bottom().map { it.destination }) + assertEquals(store.catalog.size, store.catalog.map { it.destination }.distinct().size) + } + @Test fun editsPersistAcrossSettingsModesAndBackupWithoutRenamingDestinations() { + val store = SettingsNavigationStore(context) + val edited = store.defaults.copy(drawer = listOf("custom", "home"), + bottom = listOf("custom", "learn", "home")) + store.save(edited) + prefs.edit().putBoolean("setting_use_new_home_screen_preference", false).commit() + assertEquals(edited, SettingsNavigationStore(context).read()) + val backup = AppPreference.exportAllToJson() + prefs.edit().clear().commit(); AppPreference.importAllFromJson(backup) + assertEquals(edited, SettingsNavigationStore(context).read()) + assertEquals(context.getString(R.string.learn_dictionary_fragment_title), store.bottom()[1].title) + } + @Test fun removedShortcutsStayAbsentButRemainAvailableToAdd() { + val store = SettingsNavigationStore(context) + store.save(SettingsNavigationConfig(emptyList(), emptyList())) + assertEquals(emptyList(), store.bottom()) + assertTrue(store.catalog.map { it.key }.containsAll(SettingsNavigationStore.DEFAULT_BOTTOM)) + assertEquals(emptyList(), SettingsNavigationStore(context).read().drawer) + } + @Test fun unavailableKeysSurviveEditingAndInvalidJsonFallsBackToDefaults() { + val store = SettingsNavigationStore(context) + val config = store.defaults.copy(bottom = listOf("future-screen", "home", "home", "learn")) + store.save(config) + assertEquals(listOf("future-screen", "home", "learn"), store.read().bottom) + assertEquals(listOf("home", "learn"), store.bottom().map { it.key }) + prefs.edit().putString(SettingsNavigationStore.KEY, "{").commit() + assertEquals(store.defaults, store.read()) + } +}