From aa42c280c308542a1b111c5188f3239d7e1df8ca Mon Sep 17 00:00:00 2001 From: fatih ergin Date: Wed, 16 Aug 2023 22:48:20 +0300 Subject: [PATCH 1/9] enable viewbinding update compile sdk to 34 update kotlin version to 1.9.0 --- app/build.gradle | 24 +++++++++++++++++++----- build.gradle | 4 ++-- gradle.properties | 2 ++ gradle/wrapper/gradle-wrapper.properties | 2 +- 4 files changed, 24 insertions(+), 8 deletions(-) diff --git a/app/build.gradle b/app/build.gradle index 6994fba..cf1ec0d 100644 --- a/app/build.gradle +++ b/app/build.gradle @@ -1,6 +1,5 @@ apply plugin: 'com.android.application' apply plugin: 'kotlin-android' -apply plugin: 'kotlin-android-extensions' apply plugin: 'kotlin-kapt' def keystorePropertiesFile = rootProject.file("keystore.properties") @@ -10,12 +9,13 @@ if (keystorePropertiesFile.exists()) { } android { - compileSdk 33 + namespace "com.simplemobiletools.keyboard" + compileSdk 34 defaultConfig { applicationId "com.simplemobiletools.keyboard" minSdk 23 - targetSdk 33 + targetSdk 34 versionCode 22 versionName "5.4.7" multiDexEnabled true @@ -34,6 +34,11 @@ android { } } + buildFeatures { + buildConfig true + viewBinding true + } + buildTypes { debug { applicationIdSuffix ".debug" @@ -47,7 +52,16 @@ android { } } - flavorDimensions "variants" + compileOptions { + sourceCompatibility JavaVersion.VERSION_17 + targetCompatibility JavaVersion.VERSION_17 + } + + kotlinOptions { + jvmTarget = '17' + } + + flavorDimensions = ["variants"] productFlavors { core {} fdroid {} @@ -65,7 +79,7 @@ android { } dependencies { - implementation 'com.github.SimpleMobileTools:Simple-Commons:2d4e07e5f4' + implementation 'com.github.SimpleMobileTools:Simple-Commons:d1629c7f1a' implementation 'androidx.emoji2:emoji2-bundled:1.2.0' implementation 'androidx.autofill:autofill:1.1.0' diff --git a/build.gradle b/build.gradle index 94400f3..4de00de 100644 --- a/build.gradle +++ b/build.gradle @@ -1,7 +1,7 @@ // Top-level build file where you can add configuration options common to all sub-projects/modules. buildscript { - ext.kotlin_version = '1.7.10' + ext.kotlin_version = '1.9.0' repositories { google() @@ -9,7 +9,7 @@ buildscript { } dependencies { - classpath 'com.android.tools.build:gradle:7.3.1' + classpath 'com.android.tools.build:gradle:8.1.0' classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version" // NOTE: Do not place your application dependencies here; they belong diff --git a/gradle.properties b/gradle.properties index dbb7bf7..d1e2283 100644 --- a/gradle.properties +++ b/gradle.properties @@ -1,2 +1,4 @@ android.enableJetifier=true android.useAndroidX=true +android.nonTransitiveRClass=false +org.gradle.jvmargs=-Xmx4g diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties index 3014176..e9e3229 100644 --- a/gradle/wrapper/gradle-wrapper.properties +++ b/gradle/wrapper/gradle-wrapper.properties @@ -1,6 +1,6 @@ #Tue Jan 04 09:48:27 CET 2022 distributionBase=GRADLE_USER_HOME -distributionUrl=https\://services.gradle.org/distributions/gradle-7.4-bin.zip +distributionUrl=https\://services.gradle.org/distributions/gradle-8.2.1-bin.zip distributionPath=wrapper/dists zipStorePath=wrapper/dists zipStoreBase=GRADLE_USER_HOME From ee2422b3c31b396372665ec4f3beecf20fcfe0b1 Mon Sep 17 00:00:00 2001 From: fatih ergin Date: Wed, 16 Aug 2023 23:05:36 +0300 Subject: [PATCH 2/9] migrate activities to viewbinding --- .../keyboard/activities/MainActivity.kt | 30 ++-- .../ManageClipboardItemsActivity.kt | 48 ++--- .../keyboard/activities/SettingsActivity.kt | 170 ++++++++++-------- 3 files changed, 145 insertions(+), 103 deletions(-) diff --git a/app/src/main/kotlin/com/simplemobiletools/keyboard/activities/MainActivity.kt b/app/src/main/kotlin/com/simplemobiletools/keyboard/activities/MainActivity.kt index 1961492..114d835 100644 --- a/app/src/main/kotlin/com/simplemobiletools/keyboard/activities/MainActivity.kt +++ b/app/src/main/kotlin/com/simplemobiletools/keyboard/activities/MainActivity.kt @@ -12,28 +12,32 @@ import com.simplemobiletools.commons.helpers.LICENSE_GSON import com.simplemobiletools.commons.models.FAQItem import com.simplemobiletools.keyboard.BuildConfig import com.simplemobiletools.keyboard.R -import kotlinx.android.synthetic.main.activity_main.* +import com.simplemobiletools.keyboard.databinding.ActivityMainBinding class MainActivity : SimpleActivity() { + private val binding by lazy(LazyThreadSafetyMode.NONE) { ActivityMainBinding.inflate(layoutInflater) } + override fun onCreate(savedInstanceState: Bundle?) { isMaterialActivity = true super.onCreate(savedInstanceState) - setContentView(R.layout.activity_main) + setContentView(binding.root) appLaunched(BuildConfig.APPLICATION_ID) setupOptionsMenu() refreshMenuItems() - updateMaterialActivityViews(main_coordinator, main_holder, useTransparentNavigation = false, useTopSearchMenu = false) - setupMaterialScrollListener(main_nested_scrollview, main_toolbar) + binding.apply { + updateMaterialActivityViews(mainCoordinator, mainHolder, useTransparentNavigation = false, useTopSearchMenu = false) + setupMaterialScrollListener(mainNestedScrollview, mainToolbar) - change_keyboard_holder.setOnClickListener { - (getSystemService(INPUT_METHOD_SERVICE) as InputMethodManager).showInputMethodPicker() + changeKeyboardHolder.setOnClickListener { + (getSystemService(INPUT_METHOD_SERVICE) as InputMethodManager).showInputMethodPicker() + } } } override fun onResume() { super.onResume() - setupToolbar(main_toolbar) + setupToolbar(binding.mainToolbar) if (!isKeyboardEnabled()) { ConfirmationAdvancedDialog(this, messageId = R.string.redirection_note, positive = R.string.ok, negative = 0) { success -> if (success) { @@ -47,12 +51,12 @@ class MainActivity : SimpleActivity() { } } - updateTextColors(main_nested_scrollview) + updateTextColors(binding.mainNestedScrollview) updateChangeKeyboardColor() } private fun setupOptionsMenu() { - main_toolbar.setOnMenuItemClickListener { menuItem -> + binding.mainToolbar.setOnMenuItemClickListener { menuItem -> when (menuItem.itemId) { R.id.more_apps_from_us -> launchMoreAppsFromUsIntent() R.id.settings -> launchSettings() @@ -64,7 +68,7 @@ class MainActivity : SimpleActivity() { } private fun refreshMenuItems() { - main_toolbar.menu.apply { + binding.mainToolbar.menu.apply { findItem(R.id.more_apps_from_us).isVisible = !resources.getBoolean(R.bool.hide_google_relations) } } @@ -89,8 +93,10 @@ class MainActivity : SimpleActivity() { private fun updateChangeKeyboardColor() { val applyBackground = resources.getDrawable(R.drawable.button_background_rounded, theme) as RippleDrawable (applyBackground as LayerDrawable).findDrawableByLayerId(R.id.button_background_holder).applyColorFilter(getProperPrimaryColor()) - change_keyboard.background = applyBackground - change_keyboard.setTextColor(getProperPrimaryColor().getContrastColor()) + binding.changeKeyboard.apply { + background = applyBackground + setTextColor(getProperPrimaryColor().getContrastColor()) + } } private fun isKeyboardEnabled(): Boolean { diff --git a/app/src/main/kotlin/com/simplemobiletools/keyboard/activities/ManageClipboardItemsActivity.kt b/app/src/main/kotlin/com/simplemobiletools/keyboard/activities/ManageClipboardItemsActivity.kt index f39dee4..10ad537 100644 --- a/app/src/main/kotlin/com/simplemobiletools/keyboard/activities/ManageClipboardItemsActivity.kt +++ b/app/src/main/kotlin/com/simplemobiletools/keyboard/activities/ManageClipboardItemsActivity.kt @@ -13,45 +13,51 @@ import com.simplemobiletools.commons.helpers.* import com.simplemobiletools.commons.interfaces.RefreshRecyclerViewListener import com.simplemobiletools.keyboard.R import com.simplemobiletools.keyboard.adapters.ClipsActivityAdapter +import com.simplemobiletools.keyboard.databinding.ActivityManageClipboardItemsBinding import com.simplemobiletools.keyboard.dialogs.AddOrEditClipDialog import com.simplemobiletools.keyboard.dialogs.ExportClipsDialog import com.simplemobiletools.keyboard.extensions.clipsDB import com.simplemobiletools.keyboard.extensions.config import com.simplemobiletools.keyboard.helpers.ClipsHelper import com.simplemobiletools.keyboard.models.Clip -import kotlinx.android.synthetic.main.activity_manage_clipboard_items.* import java.io.File import java.io.InputStream import java.io.OutputStream class ManageClipboardItemsActivity : SimpleActivity(), RefreshRecyclerViewListener { - private val PICK_EXPORT_CLIPS_INTENT = 21 - private val PICK_IMPORT_CLIPS_SOURCE_INTENT = 22 + companion object { + private const val PICK_EXPORT_CLIPS_INTENT = 21 + private const val PICK_IMPORT_CLIPS_SOURCE_INTENT = 22 + } + + private val binding by lazy(LazyThreadSafetyMode.NONE) { ActivityManageClipboardItemsBinding.inflate(layoutInflater) } override fun onCreate(savedInstanceState: Bundle?) { isMaterialActivity = true super.onCreate(savedInstanceState) - setContentView(R.layout.activity_manage_clipboard_items) + setContentView(binding.root) setupOptionsMenu() - updateTextColors(suggestions_items_holder) + updateTextColors(binding.suggestionsItemsHolder) updateClips() - updateMaterialActivityViews(clipboard_coordinator, clipboard_items_list, useTransparentNavigation = true, useTopSearchMenu = false) - setupMaterialScrollListener(clipboard_nested_scrollview, clipboard_toolbar) + binding.apply { + updateMaterialActivityViews(clipboardCoordinator, clipboardItemsList, useTransparentNavigation = true, useTopSearchMenu = false) + setupMaterialScrollListener(clipboardNestedScrollview, clipboardToolbar) - clipboard_items_placeholder.text = "${getText(R.string.manage_clipboard_empty)}\n\n${getText(R.string.manage_clips)}" - clipboard_items_placeholder_2.apply { - underlineText() - setTextColor(getProperPrimaryColor()) - setOnClickListener { - addOrEditClip() + clipboardItemsPlaceholder.text = "${getText(R.string.manage_clipboard_empty)}\n\n${getText(R.string.manage_clips)}" + clipboardItemsPlaceholder2.apply { + underlineText() + setTextColor(getProperPrimaryColor()) + setOnClickListener { + addOrEditClip() + } } } } override fun onResume() { super.onResume() - setupToolbar(clipboard_toolbar, NavigationIcon.Arrow) + setupToolbar(binding.clipboardToolbar, NavigationIcon.Arrow) } override fun onActivityResult(requestCode: Int, resultCode: Int, resultData: Intent?) { @@ -67,7 +73,7 @@ class ManageClipboardItemsActivity : SimpleActivity(), RefreshRecyclerViewListen private fun setupOptionsMenu() { - clipboard_toolbar.setOnMenuItemClickListener { menuItem -> + binding.clipboardToolbar.setOnMenuItemClickListener { menuItem -> when (menuItem.itemId) { R.id.add_clipboard_item -> { addOrEditClip() @@ -97,15 +103,17 @@ class ManageClipboardItemsActivity : SimpleActivity(), RefreshRecyclerViewListen ensureBackgroundThread { val clips = clipsDB.getClips().toMutableList() as ArrayList runOnUiThread { - ClipsActivityAdapter(this, clips, clipboard_items_list, this) { + ClipsActivityAdapter(this, clips, binding.clipboardItemsList, this) { addOrEditClip(it as Clip) }.apply { - clipboard_items_list.adapter = this + binding.clipboardItemsList.adapter = this } - clipboard_items_list.beVisibleIf(clips.isNotEmpty()) - clipboard_items_placeholder.beVisibleIf(clips.isEmpty()) - clipboard_items_placeholder_2.beVisibleIf(clips.isEmpty()) + binding.apply { + clipboardItemsList.beVisibleIf(clips.isNotEmpty()) + clipboardItemsPlaceholder.beVisibleIf(clips.isEmpty()) + clipboardItemsPlaceholder2.beVisibleIf(clips.isEmpty()) + } } } } diff --git a/app/src/main/kotlin/com/simplemobiletools/keyboard/activities/SettingsActivity.kt b/app/src/main/kotlin/com/simplemobiletools/keyboard/activities/SettingsActivity.kt index 5b9a41a..5801ac4 100644 --- a/app/src/main/kotlin/com/simplemobiletools/keyboard/activities/SettingsActivity.kt +++ b/app/src/main/kotlin/com/simplemobiletools/keyboard/activities/SettingsActivity.kt @@ -7,29 +7,31 @@ import com.simplemobiletools.commons.extensions.* import com.simplemobiletools.commons.helpers.NavigationIcon import com.simplemobiletools.commons.helpers.isTiramisuPlus import com.simplemobiletools.commons.models.RadioItem -import com.simplemobiletools.keyboard.R +import com.simplemobiletools.keyboard.databinding.ActivitySettingsBinding import com.simplemobiletools.keyboard.extensions.config import com.simplemobiletools.keyboard.extensions.getKeyboardLanguageText import com.simplemobiletools.keyboard.extensions.getKeyboardLanguages import com.simplemobiletools.keyboard.helpers.* -import kotlinx.android.synthetic.main.activity_settings.* -import java.util.* +import java.util.Locale import kotlin.system.exitProcess class SettingsActivity : SimpleActivity() { + private val binding by lazy(LazyThreadSafetyMode.NONE) { ActivitySettingsBinding.inflate(layoutInflater) } override fun onCreate(savedInstanceState: Bundle?) { isMaterialActivity = true super.onCreate(savedInstanceState) - setContentView(R.layout.activity_settings) + setContentView(binding.root) - updateMaterialActivityViews(settings_coordinator, settings_holder, useTransparentNavigation = false, useTopSearchMenu = false) - setupMaterialScrollListener(settings_nested_scrollview, settings_toolbar) + binding.apply { + updateMaterialActivityViews(settingsCoordinator, settingsHolder, useTransparentNavigation = false, useTopSearchMenu = false) + setupMaterialScrollListener(settingsNestedScrollview, settingsToolbar) + } } override fun onResume() { super.onResume() - setupToolbar(settings_toolbar, NavigationIcon.Arrow) + setupToolbar(binding.settingsToolbar, NavigationIcon.Arrow) setupPurchaseThankYou() setupCustomizeColors() @@ -45,47 +47,57 @@ class SettingsActivity : SimpleActivity() { setupSentencesCapitalization() setupShowNumbersRow() - updateTextColors(settings_nested_scrollview) + binding.apply { + updateTextColors(settingsNestedScrollview) - arrayOf(settings_color_customization_section_label, settings_general_settings_label).forEach { - it.setTextColor(getProperPrimaryColor()) + arrayOf(settingsColorCustomizationSectionLabel, settingsGeneralSettingsLabel).forEach { + it.setTextColor(getProperPrimaryColor()) + } } } private fun setupPurchaseThankYou() { - settings_purchase_thank_you_holder.beGoneIf(isOrWasThankYouInstalled()) - settings_purchase_thank_you_holder.setOnClickListener { - launchPurchaseThankYouIntent() + binding.apply { + settingsPurchaseThankYouHolder.beGoneIf(isOrWasThankYouInstalled()) + settingsPurchaseThankYouHolder.setOnClickListener { + launchPurchaseThankYouIntent() + } } } private fun setupCustomizeColors() { - settings_color_customization_label.text = getCustomizeColorsString() - settings_color_customization_holder.setOnClickListener { - handleCustomizeColorsClick() + binding.apply { + settingsColorCustomizationLabel.text = getCustomizeColorsString() + settingsColorCustomizationHolder.setOnClickListener { + handleCustomizeColorsClick() + } } } private fun setupUseEnglish() { - settings_use_english_holder.beVisibleIf((config.wasUseEnglishToggled || Locale.getDefault().language != "en") && !isTiramisuPlus()) - settings_use_english.isChecked = config.useEnglish - settings_use_english_holder.setOnClickListener { - settings_use_english.toggle() - config.useEnglish = settings_use_english.isChecked - exitProcess(0) + binding.apply { + settingsUseEnglishHolder.beVisibleIf((config.wasUseEnglishToggled || Locale.getDefault().language != "en") && !isTiramisuPlus()) + settingsUseEnglish.isChecked = config.useEnglish + settingsUseEnglishHolder.setOnClickListener { + settingsUseEnglish.toggle() + config.useEnglish = settingsUseEnglish.isChecked + exitProcess(0) + } } } private fun setupLanguage() { - settings_language.text = Locale.getDefault().displayLanguage - settings_language_holder.beVisibleIf(isTiramisuPlus()) - settings_language_holder.setOnClickListener { - launchChangeAppLanguageIntent() + binding.apply { + settingsLanguage.text = Locale.getDefault().displayLanguage + settingsLanguageHolder.beVisibleIf(isTiramisuPlus()) + settingsLanguageHolder.setOnClickListener { + launchChangeAppLanguageIntent() + } } } private fun setupManageClipboardItems() { - settings_manage_clipboard_items_holder.setOnClickListener { + binding.settingsManageClipboardItemsHolder.setOnClickListener { Intent(this, ManageClipboardItemsActivity::class.java).apply { startActivity(this) } @@ -93,56 +105,66 @@ class SettingsActivity : SimpleActivity() { } private fun setupVibrateOnKeypress() { - settings_vibrate_on_keypress.isChecked = config.vibrateOnKeypress - settings_vibrate_on_keypress_holder.setOnClickListener { - settings_vibrate_on_keypress.toggle() - config.vibrateOnKeypress = settings_vibrate_on_keypress.isChecked + binding.apply { + settingsVibrateOnKeypress.isChecked = config.vibrateOnKeypress + settingsVibrateOnKeypressHolder.setOnClickListener { + settingsVibrateOnKeypress.toggle() + config.vibrateOnKeypress = settingsVibrateOnKeypress.isChecked + } } } private fun setupShowPopupOnKeypress() { - settings_show_popup_on_keypress.isChecked = config.showPopupOnKeypress - settings_show_popup_on_keypress_holder.setOnClickListener { - settings_show_popup_on_keypress.toggle() - config.showPopupOnKeypress = settings_show_popup_on_keypress.isChecked + binding.apply { + settingsShowPopupOnKeypress.isChecked = config.showPopupOnKeypress + settingsShowPopupOnKeypressHolder.setOnClickListener { + settingsShowPopupOnKeypress.toggle() + config.showPopupOnKeypress = settingsShowPopupOnKeypress.isChecked + } } } private fun setupShowKeyBorders() { - settings_show_key_borders.isChecked = config.showKeyBorders - settings_show_key_borders_holder.setOnClickListener { - settings_show_key_borders.toggle() - config.showKeyBorders = settings_show_key_borders.isChecked + binding.apply { + settingsShowKeyBorders.isChecked = config.showKeyBorders + settingsShowKeyBordersHolder.setOnClickListener { + settingsShowKeyBorders.toggle() + config.showKeyBorders = settingsShowKeyBorders.isChecked + } } } private fun setupKeyboardLanguage() { - settings_keyboard_language.text = getKeyboardLanguageText(config.keyboardLanguage) - settings_keyboard_language_holder.setOnClickListener { - val items = getKeyboardLanguages() - RadioGroupDialog(this@SettingsActivity, items, config.keyboardLanguage) { - config.keyboardLanguage = it as Int - settings_keyboard_language.text = getKeyboardLanguageText(config.keyboardLanguage) + binding.apply { + settingsKeyboardLanguage.text = getKeyboardLanguageText(config.keyboardLanguage) + settingsKeyboardLanguageHolder.setOnClickListener { + val items = getKeyboardLanguages() + RadioGroupDialog(this@SettingsActivity, items, config.keyboardLanguage) { + config.keyboardLanguage = it as Int + settingsKeyboardLanguage.text = getKeyboardLanguageText(config.keyboardLanguage) + } } } } private fun setupKeyboardHeightMultiplier() { - settings_keyboard_height_multiplier.text = getKeyboardHeightPercentageText(config.keyboardHeightPercentage) - settings_keyboard_height_multiplier_holder.setOnClickListener { - val items = arrayListOf( - RadioItem(KEYBOARD_HEIGHT_70_PERCENT, getKeyboardHeightPercentageText(KEYBOARD_HEIGHT_70_PERCENT)), - RadioItem(KEYBOARD_HEIGHT_80_PERCENT, getKeyboardHeightPercentageText(KEYBOARD_HEIGHT_80_PERCENT)), - RadioItem(KEYBOARD_HEIGHT_90_PERCENT, getKeyboardHeightPercentageText(KEYBOARD_HEIGHT_90_PERCENT)), - RadioItem(KEYBOARD_HEIGHT_100_PERCENT, getKeyboardHeightPercentageText(KEYBOARD_HEIGHT_100_PERCENT)), - RadioItem(KEYBOARD_HEIGHT_120_PERCENT, getKeyboardHeightPercentageText(KEYBOARD_HEIGHT_120_PERCENT)), - RadioItem(KEYBOARD_HEIGHT_140_PERCENT, getKeyboardHeightPercentageText(KEYBOARD_HEIGHT_140_PERCENT)), - RadioItem(KEYBOARD_HEIGHT_160_PERCENT, getKeyboardHeightPercentageText(KEYBOARD_HEIGHT_160_PERCENT)), - ) + binding.apply { + settingsKeyboardHeightMultiplier.text = getKeyboardHeightPercentageText(config.keyboardHeightPercentage) + settingsKeyboardHeightMultiplierHolder.setOnClickListener { + val items = arrayListOf( + RadioItem(KEYBOARD_HEIGHT_70_PERCENT, getKeyboardHeightPercentageText(KEYBOARD_HEIGHT_70_PERCENT)), + RadioItem(KEYBOARD_HEIGHT_80_PERCENT, getKeyboardHeightPercentageText(KEYBOARD_HEIGHT_80_PERCENT)), + RadioItem(KEYBOARD_HEIGHT_90_PERCENT, getKeyboardHeightPercentageText(KEYBOARD_HEIGHT_90_PERCENT)), + RadioItem(KEYBOARD_HEIGHT_100_PERCENT, getKeyboardHeightPercentageText(KEYBOARD_HEIGHT_100_PERCENT)), + RadioItem(KEYBOARD_HEIGHT_120_PERCENT, getKeyboardHeightPercentageText(KEYBOARD_HEIGHT_120_PERCENT)), + RadioItem(KEYBOARD_HEIGHT_140_PERCENT, getKeyboardHeightPercentageText(KEYBOARD_HEIGHT_140_PERCENT)), + RadioItem(KEYBOARD_HEIGHT_160_PERCENT, getKeyboardHeightPercentageText(KEYBOARD_HEIGHT_160_PERCENT)), + ) - RadioGroupDialog(this@SettingsActivity, items, config.keyboardHeightPercentage) { - config.keyboardHeightPercentage = it as Int - settings_keyboard_height_multiplier.text = getKeyboardHeightPercentageText(config.keyboardHeightPercentage) + RadioGroupDialog(this@SettingsActivity, items, config.keyboardHeightPercentage) { + config.keyboardHeightPercentage = it as Int + settingsKeyboardHeightMultiplier.text = getKeyboardHeightPercentageText(config.keyboardHeightPercentage) + } } } } @@ -150,26 +172,32 @@ class SettingsActivity : SimpleActivity() { private fun getKeyboardHeightPercentageText(keyboardHeightPercentage: Int): String = "$keyboardHeightPercentage%" private fun setupShowClipboardContent() { - settings_show_clipboard_content.isChecked = config.showClipboardContent - settings_show_clipboard_content_holder.setOnClickListener { - settings_show_clipboard_content.toggle() - config.showClipboardContent = settings_show_clipboard_content.isChecked + binding.apply { + settingsShowClipboardContent.isChecked = config.showClipboardContent + settingsShowClipboardContentHolder.setOnClickListener { + settingsShowClipboardContent.toggle() + config.showClipboardContent = settingsShowClipboardContent.isChecked + } } } private fun setupSentencesCapitalization() { - settings_start_sentences_capitalized.isChecked = config.enableSentencesCapitalization - settings_start_sentences_capitalized_holder.setOnClickListener { - settings_start_sentences_capitalized.toggle() - config.enableSentencesCapitalization = settings_start_sentences_capitalized.isChecked + binding.apply { + settingsStartSentencesCapitalized.isChecked = config.enableSentencesCapitalization + settingsStartSentencesCapitalizedHolder.setOnClickListener { + settingsStartSentencesCapitalized.toggle() + config.enableSentencesCapitalization = settingsStartSentencesCapitalized.isChecked + } } } private fun setupShowNumbersRow() { - settings_show_numbers_row.isChecked = config.showNumbersRow - settings_show_numbers_row_holder.setOnClickListener { - settings_show_numbers_row.toggle() - config.showNumbersRow = settings_show_numbers_row.isChecked + binding.apply { + settingsShowNumbersRow.isChecked = config.showNumbersRow + settingsShowNumbersRowHolder.setOnClickListener { + settingsShowNumbersRow.toggle() + config.showNumbersRow = settingsShowNumbersRow.isChecked + } } } } From 1972063ca61fe33379e6e5c6007fcd1cdb418151 Mon Sep 17 00:00:00 2001 From: fatih ergin Date: Thu, 17 Aug 2023 00:21:18 +0300 Subject: [PATCH 3/9] migrate adapters to viewbinding --- .../keyboard/adapters/ClipsActivityAdapter.kt | 22 ++++++++-------- .../keyboard/adapters/ClipsKeyboardAdapter.kt | 25 +++++++++---------- .../keyboard/adapters/EmojisAdapter.kt | 8 +++--- 3 files changed, 26 insertions(+), 29 deletions(-) diff --git a/app/src/main/kotlin/com/simplemobiletools/keyboard/adapters/ClipsActivityAdapter.kt b/app/src/main/kotlin/com/simplemobiletools/keyboard/adapters/ClipsActivityAdapter.kt index 5ef709e..2844994 100644 --- a/app/src/main/kotlin/com/simplemobiletools/keyboard/adapters/ClipsActivityAdapter.kt +++ b/app/src/main/kotlin/com/simplemobiletools/keyboard/adapters/ClipsActivityAdapter.kt @@ -19,12 +19,12 @@ import com.simplemobiletools.commons.interfaces.RefreshRecyclerViewListener import com.simplemobiletools.commons.interfaces.StartReorderDragListener import com.simplemobiletools.commons.views.MyRecyclerView import com.simplemobiletools.keyboard.R +import com.simplemobiletools.keyboard.databinding.ItemClipInActivityBinding import com.simplemobiletools.keyboard.dialogs.AddOrEditClipDialog import com.simplemobiletools.keyboard.extensions.clipsDB import com.simplemobiletools.keyboard.helpers.ClipsHelper import com.simplemobiletools.keyboard.models.Clip -import kotlinx.android.synthetic.main.item_clip_in_activity.view.* -import java.util.* +import java.util.Collections class ClipsActivityAdapter( activity: BaseSimpleActivity, var items: ArrayList, recyclerView: MyRecyclerView, val listener: RefreshRecyclerViewListener, itemClick: (Any) -> Unit @@ -98,7 +98,7 @@ class ClipsActivityAdapter( wasClipMoved = false } - override fun onCreateViewHolder(parent: ViewGroup, viewType: Int) = createViewHolder(R.layout.item_clip_in_activity, parent) + override fun onCreateViewHolder(parent: ViewGroup, viewType: Int) = createViewHolder(ItemClipInActivityBinding.inflate(layoutInflater, parent, false).root) override fun onBindViewHolder(holder: ViewHolder, position: Int) { val item = items[position] @@ -154,15 +154,15 @@ class ClipsActivityAdapter( } val isSelected = selectedKeys.contains(clip.id!!.toInt()) - view.apply { - setupViewBackground(activity) - clip_value.text = clip.value - clip_value.setTextColor(textColor) - clip_drag_handle.applyColorFilter(textColor) + ItemClipInActivityBinding.bind(view).apply { + root.setupViewBackground(activity) + clipValue.text = clip.value + clipValue.setTextColor(textColor) + clipDragHandle.applyColorFilter(textColor) - clip_drag_handle.beVisibleIf(selectedKeys.isNotEmpty()) - clip_holder.isSelected = isSelected - clip_drag_handle.setOnTouchListener { v, event -> + clipDragHandle.beVisibleIf(selectedKeys.isNotEmpty()) + clipHolder.isSelected = isSelected + clipDragHandle.setOnTouchListener { v, event -> if (event.action == MotionEvent.ACTION_DOWN) { startReorderDragListener.requestDrag(holder) } diff --git a/app/src/main/kotlin/com/simplemobiletools/keyboard/adapters/ClipsKeyboardAdapter.kt b/app/src/main/kotlin/com/simplemobiletools/keyboard/adapters/ClipsKeyboardAdapter.kt index 2ffd34c..f541a46 100644 --- a/app/src/main/kotlin/com/simplemobiletools/keyboard/adapters/ClipsKeyboardAdapter.kt +++ b/app/src/main/kotlin/com/simplemobiletools/keyboard/adapters/ClipsKeyboardAdapter.kt @@ -12,6 +12,8 @@ import androidx.recyclerview.widget.StaggeredGridLayoutManager import com.simplemobiletools.commons.extensions.* import com.simplemobiletools.commons.helpers.ensureBackgroundThread import com.simplemobiletools.keyboard.R +import com.simplemobiletools.keyboard.databinding.ItemClipOnKeyboardBinding +import com.simplemobiletools.keyboard.databinding.ItemSectionLabelBinding import com.simplemobiletools.keyboard.extensions.config import com.simplemobiletools.keyboard.extensions.getCurrentClip import com.simplemobiletools.keyboard.extensions.getStrokeColor @@ -22,8 +24,6 @@ import com.simplemobiletools.keyboard.interfaces.RefreshClipsListener import com.simplemobiletools.keyboard.models.Clip import com.simplemobiletools.keyboard.models.ClipsSectionLabel import com.simplemobiletools.keyboard.models.ListItem -import kotlinx.android.synthetic.main.item_clip_on_keyboard.view.* -import kotlinx.android.synthetic.main.item_section_label.view.* class ClipsKeyboardAdapter( val context: Context, var items: ArrayList, val refreshClipsListener: RefreshClipsListener, @@ -36,13 +36,12 @@ class ClipsKeyboardAdapter( private var backgroundColor = context.getProperBackgroundColor() override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder { - val layoutId = when (viewType) { - ITEM_SECTION_LABEL -> R.layout.item_section_label - else -> R.layout.item_clip_on_keyboard + val binding = when (viewType) { + ITEM_SECTION_LABEL -> ItemSectionLabelBinding.inflate(layoutInflater, parent, false) + else -> ItemClipOnKeyboardBinding.inflate(layoutInflater, parent, false) } - val view = layoutInflater.inflate(layoutId, parent, false) - return ViewHolder(view) + return ViewHolder(binding.root) } override fun onBindViewHolder(holder: ViewHolder, position: Int) { @@ -65,13 +64,13 @@ class ClipsKeyboardAdapter( } private fun setupClip(view: View, clip: Clip) { - view.apply { - val rippleBg = clip_holder.background as RippleDrawable + ItemClipOnKeyboardBinding.bind(view).apply { + val rippleBg = clipHolder.background as RippleDrawable val layerDrawable = rippleBg.findDrawableByLayerId(R.id.clipboard_background_holder) as LayerDrawable layerDrawable.findDrawableByLayerId(R.id.clipboard_background_stroke).applyColorFilter(context.getStrokeColor()) layerDrawable.findDrawableByLayerId(R.id.clipboard_background_shape).applyColorFilter(backgroundColor) - clip_value.apply { + clipValue.apply { text = clip.value removeUnderlines() setTextColor(textColor) @@ -81,13 +80,13 @@ class ClipsKeyboardAdapter( @SuppressLint("UseCompatLoadingForDrawables") private fun setupSection(view: View, sectionLabel: ClipsSectionLabel) { - view.apply { - clips_section_label.apply { + ItemSectionLabelBinding.bind(view).apply { + clipsSectionLabel.apply { text = sectionLabel.value setTextColor(textColor) } - clips_section_icon.apply { + clipsSectionIcon.apply { applyColorFilter(textColor) if (sectionLabel.isCurrent) { diff --git a/app/src/main/kotlin/com/simplemobiletools/keyboard/adapters/EmojisAdapter.kt b/app/src/main/kotlin/com/simplemobiletools/keyboard/adapters/EmojisAdapter.kt index 12f2114..48b7b16 100644 --- a/app/src/main/kotlin/com/simplemobiletools/keyboard/adapters/EmojisAdapter.kt +++ b/app/src/main/kotlin/com/simplemobiletools/keyboard/adapters/EmojisAdapter.kt @@ -6,15 +6,13 @@ import android.view.View import android.view.ViewGroup import androidx.emoji2.text.EmojiCompat import androidx.recyclerview.widget.RecyclerView -import com.simplemobiletools.keyboard.R -import kotlinx.android.synthetic.main.item_emoji.view.* +import com.simplemobiletools.keyboard.databinding.ItemEmojiBinding class EmojisAdapter(val context: Context, var items: List, val itemClick: (emoji: String) -> Unit) : RecyclerView.Adapter() { private val layoutInflater = LayoutInflater.from(context) override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): EmojisAdapter.ViewHolder { - val layoutId = R.layout.item_emoji - val view = layoutInflater.inflate(layoutId, parent, false) + val view = ItemEmojiBinding.inflate(layoutInflater, parent, false).root return ViewHolder(view) } @@ -29,7 +27,7 @@ class EmojisAdapter(val context: Context, var items: List, val itemClick private fun setupEmoji(view: View, emoji: String) { val processed = EmojiCompat.get().process(emoji) - view.emoji_value.text = processed + ItemEmojiBinding.bind(view).emojiValue.text = processed } inner class ViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) { From dccded4d72107bb9ee8a855d90b7abefd57459a0 Mon Sep 17 00:00:00 2001 From: fatih ergin Date: Thu, 17 Aug 2023 00:22:58 +0300 Subject: [PATCH 4/9] migrate dialogs to viewbinding --- .../keyboard/dialogs/AddOrEditClipDialog.kt | 12 +++++----- .../keyboard/dialogs/ExportClipsDialog.kt | 22 +++++++++---------- .../dialogs/KeyboardRadioGroupDialog.kt | 12 +++++----- 3 files changed, 23 insertions(+), 23 deletions(-) diff --git a/app/src/main/kotlin/com/simplemobiletools/keyboard/dialogs/AddOrEditClipDialog.kt b/app/src/main/kotlin/com/simplemobiletools/keyboard/dialogs/AddOrEditClipDialog.kt index ab8dc89..b055d03 100644 --- a/app/src/main/kotlin/com/simplemobiletools/keyboard/dialogs/AddOrEditClipDialog.kt +++ b/app/src/main/kotlin/com/simplemobiletools/keyboard/dialogs/AddOrEditClipDialog.kt @@ -5,15 +5,15 @@ import com.simplemobiletools.commons.activities.BaseSimpleActivity import com.simplemobiletools.commons.extensions.* import com.simplemobiletools.commons.helpers.ensureBackgroundThread import com.simplemobiletools.keyboard.R +import com.simplemobiletools.keyboard.databinding.DialogAddOrEditClipBinding import com.simplemobiletools.keyboard.helpers.ClipsHelper import com.simplemobiletools.keyboard.models.Clip -import kotlinx.android.synthetic.main.dialog_add_or_edit_clip.view.* class AddOrEditClipDialog(val activity: BaseSimpleActivity, val originalClip: Clip?, val callback: () -> Unit) { init { - val view = activity.layoutInflater.inflate(R.layout.dialog_add_or_edit_clip, null).apply { + val binding = DialogAddOrEditClipBinding.inflate(activity.layoutInflater).apply { if (originalClip != null) { - add_clip_value.setText(originalClip.value) + addClipValue.setText(originalClip.value) } } @@ -21,10 +21,10 @@ class AddOrEditClipDialog(val activity: BaseSimpleActivity, val originalClip: Cl .setPositiveButton(R.string.ok, null) .setNegativeButton(R.string.cancel, null) .apply { - activity.setupDialogStuff(view, this) { alertDialog -> - alertDialog.showKeyboard(view.add_clip_value) + activity.setupDialogStuff(binding.root, this) { alertDialog -> + alertDialog.showKeyboard(binding.addClipValue) alertDialog.getButton(AlertDialog.BUTTON_POSITIVE).setOnClickListener { - val clipValue = view.add_clip_value.value + val clipValue = binding.addClipValue.value if (clipValue.isEmpty()) { activity.toast(R.string.value_cannot_be_empty) return@setOnClickListener diff --git a/app/src/main/kotlin/com/simplemobiletools/keyboard/dialogs/ExportClipsDialog.kt b/app/src/main/kotlin/com/simplemobiletools/keyboard/dialogs/ExportClipsDialog.kt index 6d1f5b4..8f14161 100644 --- a/app/src/main/kotlin/com/simplemobiletools/keyboard/dialogs/ExportClipsDialog.kt +++ b/app/src/main/kotlin/com/simplemobiletools/keyboard/dialogs/ExportClipsDialog.kt @@ -6,8 +6,8 @@ import com.simplemobiletools.commons.dialogs.ConfirmationDialog import com.simplemobiletools.commons.dialogs.FilePickerDialog import com.simplemobiletools.commons.extensions.* import com.simplemobiletools.keyboard.R +import com.simplemobiletools.keyboard.databinding.DialogExportClipsBinding import com.simplemobiletools.keyboard.extensions.config -import kotlinx.android.synthetic.main.dialog_export_clips.view.* class ExportClipsDialog( val activity: BaseSimpleActivity, path: String, val hidePath: Boolean, callback: (path: String, filename: String) -> Unit @@ -19,17 +19,17 @@ class ExportClipsDialog( activity.internalStoragePath } - val view = activity.layoutInflater.inflate(R.layout.dialog_export_clips, null).apply { - export_clips_filename.setText("${activity.getString(R.string.app_launcher_name)}_${activity.getCurrentFormattedDateTime()}") + val binding = DialogExportClipsBinding.inflate(activity.layoutInflater).apply { + exportClipsFilename.setText("${activity.getString(R.string.app_launcher_name)}_${activity.getCurrentFormattedDateTime()}") if (hidePath) { - export_clips_path_label.beGone() - export_clips_path.beGone() + exportClipsPathLabel.beGone() + exportClipsPath.beGone() } else { - export_clips_path.text = activity.humanizePath(folder) - export_clips_path.setOnClickListener { + exportClipsPath.text = activity.humanizePath(folder) + exportClipsPath.setOnClickListener { FilePickerDialog(activity, folder, false, showFAB = true) { - export_clips_path.text = activity.humanizePath(it) + exportClipsPath.text = activity.humanizePath(it) folder = it } } @@ -40,10 +40,10 @@ class ExportClipsDialog( .setPositiveButton(R.string.ok, null) .setNegativeButton(R.string.cancel, null) .apply { - activity.setupDialogStuff(view, this, R.string.export_clipboard_items) { alertDialog -> - alertDialog.showKeyboard(view.export_clips_filename) + activity.setupDialogStuff(binding.root, this, R.string.export_clipboard_items) { alertDialog -> + alertDialog.showKeyboard(binding.exportClipsFilename) alertDialog.getButton(AlertDialog.BUTTON_POSITIVE).setOnClickListener { - val filename = view.export_clips_filename.value + val filename = binding.exportClipsFilename.value if (filename.isEmpty()) { activity.toast(R.string.filename_cannot_be_empty) return@setOnClickListener diff --git a/app/src/main/kotlin/com/simplemobiletools/keyboard/dialogs/KeyboardRadioGroupDialog.kt b/app/src/main/kotlin/com/simplemobiletools/keyboard/dialogs/KeyboardRadioGroupDialog.kt index fcf3c44..40ee1e5 100644 --- a/app/src/main/kotlin/com/simplemobiletools/keyboard/dialogs/KeyboardRadioGroupDialog.kt +++ b/app/src/main/kotlin/com/simplemobiletools/keyboard/dialogs/KeyboardRadioGroupDialog.kt @@ -6,8 +6,8 @@ import android.view.View import android.view.ViewGroup import android.widget.RadioButton import android.widget.RadioGroup -import android.widget.ScrollView import androidx.appcompat.app.AlertDialog +import com.simplemobiletools.commons.databinding.DialogRadioGroupBinding import com.simplemobiletools.commons.extensions.onGlobalLayout import com.simplemobiletools.commons.models.RadioItem import com.simplemobiletools.keyboard.R @@ -31,8 +31,8 @@ class KeyboardRadioGroupDialog( private val layoutInflater = LayoutInflater.from(context) init { - val view = layoutInflater.inflate(R.layout.dialog_radio_group, null) - val radioGroup = view.findViewById(R.id.dialog_radio_group).apply { + val binding = DialogRadioGroupBinding.inflate(layoutInflater) + binding.dialogRadioGroup.apply { for (i in 0 until items.size) { val radioButton = (layoutInflater.inflate(R.layout.radio_button, null) as RadioButton).apply { text = items[i].title @@ -57,15 +57,15 @@ class KeyboardRadioGroupDialog( } builder.apply { - context.setupKeyboardDialogStuff(inputView.windowToken, view, this, titleId) { alertDialog -> + context.setupKeyboardDialogStuff(inputView.windowToken, binding.root, this, titleId) { alertDialog -> dialog = alertDialog } } if (selectedItemId != -1) { - view.findViewById(R.id.dialog_radio_holder).apply { + binding.dialogRadioHolder.apply { onGlobalLayout { - scrollY = radioGroup.findViewById(selectedItemId).bottom - height + scrollY = binding.dialogRadioGroup.findViewById(selectedItemId).bottom - height } } } From a1e66361597df22430f2807916f015498f9922aa Mon Sep 17 00:00:00 2001 From: fatih ergin Date: Thu, 17 Aug 2023 00:25:47 +0300 Subject: [PATCH 5/9] migrate views to viewbinding --- .../keyboard/services/SimpleKeyboardIME.kt | 20 +- .../keyboard/views/MyKeyboardView.kt | 193 +++++++++--------- 2 files changed, 111 insertions(+), 102 deletions(-) diff --git a/app/src/main/kotlin/com/simplemobiletools/keyboard/services/SimpleKeyboardIME.kt b/app/src/main/kotlin/com/simplemobiletools/keyboard/services/SimpleKeyboardIME.kt index d54442e..e1212e9 100644 --- a/app/src/main/kotlin/com/simplemobiletools/keyboard/services/SimpleKeyboardIME.kt +++ b/app/src/main/kotlin/com/simplemobiletools/keyboard/services/SimpleKeyboardIME.kt @@ -31,14 +31,13 @@ import androidx.core.graphics.drawable.toBitmap import com.simplemobiletools.commons.extensions.* import com.simplemobiletools.commons.helpers.isNougatPlus import com.simplemobiletools.keyboard.R +import com.simplemobiletools.keyboard.databinding.KeyboardViewKeyboardBinding import com.simplemobiletools.keyboard.extensions.config import com.simplemobiletools.keyboard.extensions.getStrokeColor import com.simplemobiletools.keyboard.extensions.safeStorageContext import com.simplemobiletools.keyboard.helpers.* import com.simplemobiletools.keyboard.interfaces.OnKeyboardActionListener import com.simplemobiletools.keyboard.views.MyKeyboardView -import kotlinx.android.synthetic.main.keyboard_view_keyboard.view.keyboard_holder -import kotlinx.android.synthetic.main.keyboard_view_keyboard.view.keyboard_view import java.util.Locale // based on https://www.androidauthority.com/lets-build-custom-keyboard-android-832362/ @@ -60,19 +59,22 @@ class SimpleKeyboardIME : InputMethodService(), OnKeyboardActionListener, Shared private var switchToLetters = false private var breakIterator: BreakIterator? = null + private lateinit var binding: KeyboardViewKeyboardBinding + override fun onInitializeInterface() { super.onInitializeInterface() safeStorageContext.getSharedPrefs().registerOnSharedPreferenceChangeListener(this) } override fun onCreateInputView(): View { - val keyboardHolder = layoutInflater.inflate(R.layout.keyboard_view_keyboard, null) - keyboardView = keyboardHolder.keyboard_view as MyKeyboardView - keyboardView!!.setKeyboardHolder(keyboardHolder.keyboard_holder) - keyboardView!!.setKeyboard(keyboard!!) - keyboardView!!.setEditorInfo(currentInputEditorInfo) - keyboardView!!.mOnKeyboardActionListener = this - return keyboardHolder!! + binding = KeyboardViewKeyboardBinding.inflate(layoutInflater) + keyboardView = binding.keyboardView.apply { + setKeyboardHolder(binding) + setKeyboard(keyboard!!) + setEditorInfo(currentInputEditorInfo) + mOnKeyboardActionListener = this@SimpleKeyboardIME + } + return binding.root } override fun onPress(primaryCode: Int) { diff --git a/app/src/main/kotlin/com/simplemobiletools/keyboard/views/MyKeyboardView.kt b/app/src/main/kotlin/com/simplemobiletools/keyboard/views/MyKeyboardView.kt index cbb2a0a..4ad01dc 100644 --- a/app/src/main/kotlin/com/simplemobiletools/keyboard/views/MyKeyboardView.kt +++ b/app/src/main/kotlin/com/simplemobiletools/keyboard/views/MyKeyboardView.kt @@ -37,6 +37,8 @@ import com.simplemobiletools.keyboard.activities.ManageClipboardItemsActivity import com.simplemobiletools.keyboard.activities.SettingsActivity import com.simplemobiletools.keyboard.adapters.ClipsKeyboardAdapter import com.simplemobiletools.keyboard.adapters.EmojisAdapter +import com.simplemobiletools.keyboard.databinding.KeyboardPopupKeyboardBinding +import com.simplemobiletools.keyboard.databinding.KeyboardViewKeyboardBinding import com.simplemobiletools.keyboard.dialogs.ChangeLanguagePopup import com.simplemobiletools.keyboard.extensions.* import com.simplemobiletools.keyboard.helpers.* @@ -51,8 +53,6 @@ import com.simplemobiletools.keyboard.interfaces.RefreshClipsListener import com.simplemobiletools.keyboard.models.Clip import com.simplemobiletools.keyboard.models.ClipsSectionLabel import com.simplemobiletools.keyboard.models.ListItem -import kotlinx.android.synthetic.main.keyboard_popup_keyboard.view.* -import kotlinx.android.synthetic.main.keyboard_view_keyboard.view.* import java.util.* @SuppressLint("UseCompatLoadingForDrawables", "ClickableViewAccessibility") @@ -66,6 +66,9 @@ class MyKeyboardView @JvmOverloads constructor(context: Context, attrs: Attribut } } + private var keyboardPopupBinding: KeyboardPopupKeyboardBinding? = null + private var keyboardViewBinding: KeyboardViewKeyboardBinding? = null + private var accessHelper: AccessHelper? = null private var mKeyboard: MyKeyboard? = null @@ -285,14 +288,14 @@ class MyKeyboardView @JvmOverloads constructor(context: Context, attrs: Attribut } /** Sets the top row above the keyboard containing a couple buttons and the clipboard **/ - fun setKeyboardHolder(keyboardHolder: View) { - mToolbarHolder = keyboardHolder.toolbar_holder - mClipboardManagerHolder = keyboardHolder.clipboard_manager_holder - mEmojiPaletteHolder = keyboardHolder.emoji_palette_holder + fun setKeyboardHolder(binding: KeyboardViewKeyboardBinding) { + keyboardViewBinding = binding.apply { + mToolbarHolder = toolbarHolder + mClipboardManagerHolder = clipboardManagerHolder + mEmojiPaletteHolder = emojiPaletteHolder - mToolbarHolder!!.apply { - settings_cog.setOnLongClickListener { context.toast(R.string.settings); true; } - settings_cog.setOnClickListener { + settingsCog.setOnLongClickListener { context.toast(R.string.settings); true; } + settingsCog.setOnClickListener { vibrateIfNeeded() Intent(context, SettingsActivity::class.java).apply { addFlags(Intent.FLAG_ACTIVITY_NEW_TASK) @@ -300,23 +303,23 @@ class MyKeyboardView @JvmOverloads constructor(context: Context, attrs: Attribut } } - pinned_clipboard_items.setOnLongClickListener { context.toast(R.string.clipboard); true; } - pinned_clipboard_items.setOnClickListener { + pinnedClipboardItems.setOnLongClickListener { context.toast(R.string.clipboard); true; } + pinnedClipboardItems.setOnClickListener { vibrateIfNeeded() openClipboardManager() } - clipboard_clear.setOnLongClickListener { context.toast(R.string.clear_clipboard_data); true; } - clipboard_clear.setOnClickListener { + clipboardClear.setOnLongClickListener { context.toast(R.string.clear_clipboard_data); true; } + clipboardClear.setOnClickListener { vibrateIfNeeded() clearClipboardContent() toggleClipboardVisibility(false) } - suggestions_holder.addOnLayoutChangeListener(object : OnLayoutChangeListener { + suggestionsHolder.addOnLayoutChangeListener(object : OnLayoutChangeListener { override fun onLayoutChange(v: View?, left: Int, top: Int, right: Int, bottom: Int, oldLeft: Int, oldTop: Int, oldRight: Int, oldBottom: Int) { updateSuggestionsToolbarLayout() - suggestions_holder.removeOnLayoutChangeListener(this) + binding.suggestionsHolder.removeOnLayoutChangeListener(this) } }) } @@ -330,23 +333,21 @@ class MyKeyboardView @JvmOverloads constructor(context: Context, attrs: Attribut setupStoredClips() } - mClipboardManagerHolder!!.apply { - clipboard_manager_close.setOnClickListener { + binding.apply { + clipboardManagerClose.setOnClickListener { vibrateIfNeeded() closeClipboardManager() } - clipboard_manager_manage.setOnLongClickListener { context.toast(R.string.manage_clipboard_items); true; } - clipboard_manager_manage.setOnClickListener { + clipboardManagerManage.setOnLongClickListener { context.toast(R.string.manage_clipboard_items); true; } + clipboardManagerManage.setOnClickListener { Intent(context, ManageClipboardItemsActivity::class.java).apply { addFlags(Intent.FLAG_ACTIVITY_NEW_TASK) context.startActivity(this) } } - } - mEmojiPaletteHolder!!.apply { - emoji_palette_close.setOnClickListener { + emojiPaletteClose.setOnClickListener { vibrateIfNeeded() closeEmojiPalette() } @@ -367,7 +368,7 @@ class MyKeyboardView @JvmOverloads constructor(context: Context, attrs: Attribut mUsingSystemTheme = config.isUsingSystemTheme } - val isMainKeyboard = changedView == null || changedView != mini_keyboard_view + val isMainKeyboard = changedView == null || changedView != keyboardPopupBinding?.miniKeyboardView mKeyBackground = if (mShowKeyBorders && isMainKeyboard) { resources.getDrawable(R.drawable.keyboard_key_selector_outlined, context.theme) } else { @@ -397,35 +398,33 @@ class MyKeyboardView @JvmOverloads constructor(context: Context, attrs: Attribut layerDrawable.findDrawableByLayerId(R.id.clipboard_background_shape).applyColorFilter(mBackgroundColor) val wasDarkened = mBackgroundColor != mBackgroundColor.darkenColor() - mToolbarHolder?.apply { - top_keyboard_divider.beGoneIf(wasDarkened) - top_keyboard_divider.background = ColorDrawable(strokeColor) + keyboardViewBinding?.apply { + topKeyboardDivider.beGoneIf(wasDarkened) + topKeyboardDivider.background = ColorDrawable(strokeColor) + mToolbarHolder?.background = ColorDrawable(toolbarColor) - background = ColorDrawable(toolbarColor) - clipboard_value.apply { + clipboardValue.apply { background = rippleBg setTextColor(mTextColor) setLinkTextColor(mTextColor) } - settings_cog.applyColorFilter(mTextColor) - pinned_clipboard_items.applyColorFilter(mTextColor) - clipboard_clear.applyColorFilter(mTextColor) + settingsCog.applyColorFilter(mTextColor) + pinnedClipboardItems.applyColorFilter(mTextColor) + clipboardClear.applyColorFilter(mTextColor) - beInvisibleIf(context.isDeviceLocked) - } + mToolbarHolder?.beInvisibleIf(context.isDeviceLocked) - mClipboardManagerHolder?.apply { - top_clipboard_divider.beGoneIf(wasDarkened) - top_clipboard_divider.background = ColorDrawable(strokeColor) - clipboard_manager_holder.background = ColorDrawable(toolbarColor) + topClipboardDivider.beGoneIf(wasDarkened) + topClipboardDivider.background = ColorDrawable(strokeColor) + clipboardManagerHolder.background = ColorDrawable(toolbarColor) - clipboard_manager_close.applyColorFilter(mTextColor) - clipboard_manager_manage.applyColorFilter(mTextColor) + clipboardManagerClose.applyColorFilter(mTextColor) + clipboardManagerManage.applyColorFilter(mTextColor) - clipboard_manager_label.setTextColor(mTextColor) - clipboard_content_placeholder_1.setTextColor(mTextColor) - clipboard_content_placeholder_2.setTextColor(mTextColor) + clipboardManagerLabel.setTextColor(mTextColor) + clipboardContentPlaceholder1.setTextColor(mTextColor) + clipboardContentPlaceholder2.setTextColor(mTextColor) } setupEmojiPalette(toolbarColor = toolbarColor, backgroundColor = mBackgroundColor, textColor = mTextColor) @@ -739,8 +738,8 @@ class MyKeyboardView @JvmOverloads constructor(context: Context, attrs: Attribut if (mToolbarHolder != null && mPopupParent.id != R.id.mini_keyboard_view && context.config.showClipboardContent) { val clipboardContent = context.getCurrentClip() if (clipboardContent?.isNotEmpty() == true) { - mToolbarHolder?.apply { - clipboard_value.apply { + keyboardViewBinding?.apply { + clipboardValue.apply { text = clipboardContent removeUnderlines() setOnClickListener { @@ -760,11 +759,11 @@ class MyKeyboardView @JvmOverloads constructor(context: Context, attrs: Attribut } private fun hideClipboardViews() { - mToolbarHolder?.apply { - clipboard_value?.beGone() - clipboard_value?.alpha = 0f - clipboard_clear?.beGone() - clipboard_clear?.alpha = 0f + keyboardViewBinding?.apply { + clipboardValue.beGone() + clipboardValue.alpha = 0f + clipboardClear.beGone() + clipboardClear.alpha = 0f } } @@ -779,13 +778,13 @@ class MyKeyboardView @JvmOverloads constructor(context: Context, attrs: Attribut } private fun toggleClipboardVisibility(show: Boolean) { - if ((show && mToolbarHolder?.clipboard_value!!.alpha == 0f) || (!show && mToolbarHolder?.clipboard_value!!.alpha == 1f)) { + if ((show && keyboardViewBinding?.clipboardValue!!.alpha == 0f) || (!show && keyboardViewBinding?.clipboardValue!!.alpha == 1f)) { val newAlpha = if (show) 1f else 0f val animations = ArrayList() - val clipboardValueAnimation = ObjectAnimator.ofFloat(mToolbarHolder!!.clipboard_value!!, "alpha", newAlpha) + val clipboardValueAnimation = ObjectAnimator.ofFloat(keyboardViewBinding!!.clipboardValue, "alpha", newAlpha) animations.add(clipboardValueAnimation) - val clipboardClearAnimation = ObjectAnimator.ofFloat(mToolbarHolder!!.clipboard_clear!!, "alpha", newAlpha) + val clipboardClearAnimation = ObjectAnimator.ofFloat(keyboardViewBinding!!.clipboardClear, "alpha", newAlpha) animations.add(clipboardClearAnimation) val animSet = AnimatorSet() @@ -794,14 +793,14 @@ class MyKeyboardView @JvmOverloads constructor(context: Context, attrs: Attribut animSet.interpolator = AccelerateInterpolator() animSet.doOnStart { if (show) { - mToolbarHolder?.clipboard_value?.beVisible() - mToolbarHolder?.clipboard_clear?.beVisible() + keyboardViewBinding?.clipboardValue?.beVisible() + keyboardViewBinding?.clipboardClear?.beVisible() } } animSet.doOnEnd { if (!show) { - mToolbarHolder?.clipboard_value?.beGone() - mToolbarHolder?.clipboard_clear?.beGone() + keyboardViewBinding?.clipboardValue?.beGone() + keyboardViewBinding?.clipboardClear?.beGone() } } animSet.start() @@ -1001,8 +1000,10 @@ class MyKeyboardView @JvmOverloads constructor(context: Context, attrs: Attribut mMiniKeyboardContainer = mMiniKeyboardCache[popupKey] if (mMiniKeyboardContainer == null) { val inflater = context.getSystemService(Context.LAYOUT_INFLATER_SERVICE) as LayoutInflater - mMiniKeyboardContainer = inflater.inflate(mPopupLayout, null) - mMiniKeyboard = mMiniKeyboardContainer!!.findViewById(R.id.mini_keyboard_view) as MyKeyboardView + keyboardPopupBinding = KeyboardPopupKeyboardBinding.inflate(inflater).apply { + mMiniKeyboardContainer = root + mMiniKeyboard = miniKeyboardView + } mMiniKeyboard!!.mOnKeyboardActionListener = object : OnKeyboardActionListener { override fun onKey(code: Int) { @@ -1048,7 +1049,7 @@ class MyKeyboardView @JvmOverloads constructor(context: Context, attrs: Attribut ) mMiniKeyboardCache[popupKey] = mMiniKeyboardContainer } else { - mMiniKeyboard = mMiniKeyboardContainer!!.findViewById(R.id.mini_keyboard_view) as MyKeyboardView + mMiniKeyboard = keyboardPopupBinding!!.miniKeyboardView } getLocationInWindow(mCoordinates) @@ -1395,13 +1396,17 @@ class MyKeyboardView @JvmOverloads constructor(context: Context, attrs: Attribut } fun closeClipboardManager() { - mClipboardManagerHolder?.clipboard_manager_holder?.beGone() - mToolbarHolder?.suggestions_holder?.showAllInlineContentViews() + keyboardViewBinding?.apply { + clipboardManagerHolder.beGone() + suggestionsHolder.showAllInlineContentViews() + } } private fun openClipboardManager() { - mClipboardManagerHolder!!.clipboard_manager_holder.beVisible() - mToolbarHolder?.suggestions_holder?.hideAllInlineContentViews() + keyboardViewBinding?.apply { + clipboardManagerHolder.beVisible() + suggestionsHolder.hideAllInlineContentViews() + } setupStoredClips() } @@ -1434,10 +1439,10 @@ class MyKeyboardView @JvmOverloads constructor(context: Context, attrs: Attribut } private fun setupClipsAdapter(clips: ArrayList) { - mClipboardManagerHolder?.apply { - clipboard_content_placeholder_1.beVisibleIf(clips.isEmpty()) - clipboard_content_placeholder_2.beVisibleIf(clips.isEmpty()) - clips_list.beVisibleIf(clips.isNotEmpty()) + keyboardViewBinding?.apply { + clipboardContentPlaceholder1.beVisibleIf(clips.isEmpty()) + clipboardContentPlaceholder2.beVisibleIf(clips.isEmpty()) + clipsList.beVisibleIf(clips.isNotEmpty()) } val refreshClipsListener = object : RefreshClipsListener { @@ -1451,26 +1456,27 @@ class MyKeyboardView @JvmOverloads constructor(context: Context, attrs: Attribut vibrateIfNeeded() } - mClipboardManagerHolder?.clips_list?.adapter = adapter + keyboardViewBinding?.clipsList?.adapter = adapter } private fun setupEmojiPalette(toolbarColor: Int, backgroundColor: Int, textColor: Int) { - mEmojiPaletteHolder?.apply { - emoji_palette_top_bar.background = ColorDrawable(toolbarColor) - emoji_palette_holder.background = ColorDrawable(backgroundColor) - emoji_palette_close.applyColorFilter(textColor) - emoji_palette_label.setTextColor(textColor) + keyboardViewBinding?.apply { + emojiPaletteTopBar.background = ColorDrawable(toolbarColor) + emojiPaletteHolder.background = ColorDrawable(backgroundColor) + emojiPaletteClose.applyColorFilter(textColor) + emojiPaletteLabel.setTextColor(textColor) - emoji_palette_bottom_bar.background = ColorDrawable(backgroundColor) + emojiPaletteBottomBar.background = ColorDrawable(backgroundColor) val bottomTextColor = textColor.darkenColor() - emoji_palette_mode_change.apply { + emojiPaletteModeChange.apply { setTextColor(bottomTextColor) setOnClickListener { vibrateIfNeeded() closeEmojiPalette() } } - emoji_palette_backspace.apply { + + emojiPaletteBackspace.apply { applyColorFilter(bottomTextColor) setOnTouchListener { _, event -> when (event.action) { @@ -1498,18 +1504,19 @@ class MyKeyboardView @JvmOverloads constructor(context: Context, attrs: Attribut } } } + setupEmojis() } fun openEmojiPalette() { - mEmojiPaletteHolder!!.emoji_palette_holder.beVisible() + keyboardViewBinding!!.emojiPaletteHolder.beVisible() setupEmojis() } private fun closeEmojiPalette() { - mEmojiPaletteHolder?.apply { - emoji_palette_holder?.beGone() - mEmojiPaletteHolder?.emojis_list?.scrollToPosition(0) + keyboardViewBinding?.apply { + emojiPaletteHolder.beGone() + emojisList?.scrollToPosition(0) } } @@ -1539,7 +1546,7 @@ class MyKeyboardView @JvmOverloads constructor(context: Context, attrs: Attribut } private fun setupEmojiAdapter(emojis: List) { - mEmojiPaletteHolder?.emojis_list?.apply { + keyboardViewBinding?.emojisList?.apply { val emojiItemWidth = context.resources.getDimensionPixelSize(R.dimen.emoji_item_size) val emojiTopBarElevation = context.resources.getDimensionPixelSize(R.dimen.emoji_top_bar_elevation).toFloat() @@ -1550,7 +1557,7 @@ class MyKeyboardView @JvmOverloads constructor(context: Context, attrs: Attribut } onScroll { - mEmojiPaletteHolder!!.emoji_palette_top_bar.elevation = if (it > 4) emojiTopBarElevation else 0f + keyboardViewBinding!!.emojiPaletteTopBar.elevation = if (it > 4) emojiTopBarElevation else 0f } } } @@ -1634,14 +1641,14 @@ class MyKeyboardView @JvmOverloads constructor(context: Context, attrs: Attribut @RequiresApi(Build.VERSION_CODES.R) fun addToClipboardViews(it: InlineContentView, addToFront: Boolean = false) { - if (mToolbarHolder?.autofill_suggestions_holder != null) { + if (keyboardViewBinding?.autofillSuggestionsHolder != null) { val newLayoutParams = LinearLayout.LayoutParams(it.layoutParams) newLayoutParams.updateMarginsRelative(start = resources.getDimensionPixelSize(R.dimen.normal_margin)) it.layoutParams = newLayoutParams if (addToFront) { - mToolbarHolder?.autofill_suggestions_holder?.addView(it, 0) + keyboardViewBinding?.autofillSuggestionsHolder?.addView(it, 0) } else { - mToolbarHolder?.autofill_suggestions_holder?.addView(it) + keyboardViewBinding?.autofillSuggestionsHolder?.addView(it) } updateSuggestionsToolbarLayout() } @@ -1649,21 +1656,21 @@ class MyKeyboardView @JvmOverloads constructor(context: Context, attrs: Attribut @RequiresApi(Build.VERSION_CODES.R) fun clearClipboardViews() { - mToolbarHolder?.autofill_suggestions_holder?.removeAllViews() + keyboardViewBinding?.autofillSuggestionsHolder?.removeAllViews() updateSuggestionsToolbarLayout() } private fun updateSuggestionsToolbarLayout() { - mToolbarHolder?.apply { + keyboardViewBinding?.apply { if (hasInlineViews()) { // make room on suggestion toolbar for inline views - suggestions_items_holder?.gravity = Gravity.NO_GRAVITY - clipboard_value?.maxWidth = resources.getDimensionPixelSize(R.dimen.suggestion_max_width) + suggestionsItemsHolder.gravity = Gravity.NO_GRAVITY + clipboardValue.maxWidth = resources.getDimensionPixelSize(R.dimen.suggestion_max_width) } else { // restore original clipboard toolbar appearance - suggestions_items_holder?.gravity = Gravity.CENTER_HORIZONTAL - suggestions_holder?.measuredWidth?.also { maxWidth -> - clipboard_value?.maxWidth = maxWidth + suggestionsItemsHolder.gravity = Gravity.CENTER_HORIZONTAL + suggestionsHolder.measuredWidth.also { maxWidth -> + clipboardValue.maxWidth = maxWidth } } } @@ -1672,5 +1679,5 @@ class MyKeyboardView @JvmOverloads constructor(context: Context, attrs: Attribut /** * Returns true if there are [InlineContentView]s in [autofill_suggestions_holder] */ - private fun hasInlineViews() = (mToolbarHolder?.autofill_suggestions_holder?.childCount ?: 0) > 0 + private fun hasInlineViews() = (keyboardViewBinding?.autofillSuggestionsHolder?.childCount ?: 0) > 0 } From c1b972998f8150faef5a32065c1cc83d991aa4cf Mon Sep 17 00:00:00 2001 From: fatih ergin Date: Thu, 17 Aug 2023 19:40:36 +0300 Subject: [PATCH 6/9] update commons ref --- app/build.gradle | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/app/build.gradle b/app/build.gradle index cf1ec0d..7c6104f 100644 --- a/app/build.gradle +++ b/app/build.gradle @@ -79,7 +79,7 @@ android { } dependencies { - implementation 'com.github.SimpleMobileTools:Simple-Commons:d1629c7f1a' + implementation 'com.github.SimpleMobileTools:Simple-Commons:0e173dc5ad' implementation 'androidx.emoji2:emoji2-bundled:1.2.0' implementation 'androidx.autofill:autofill:1.1.0' From 27e054e02313e6077354f03d055f731605d9fddd Mon Sep 17 00:00:00 2001 From: fatih ergin Date: Thu, 17 Aug 2023 20:00:58 +0300 Subject: [PATCH 7/9] migrate remaining inflated layouts to viewbinding --- .../keyboard/dialogs/KeyboardRadioGroupDialog.kt | 4 ++-- .../com/simplemobiletools/keyboard/extensions/Context.kt | 4 ++-- .../com/simplemobiletools/keyboard/views/MyKeyboardView.kt | 3 ++- 3 files changed, 6 insertions(+), 5 deletions(-) diff --git a/app/src/main/kotlin/com/simplemobiletools/keyboard/dialogs/KeyboardRadioGroupDialog.kt b/app/src/main/kotlin/com/simplemobiletools/keyboard/dialogs/KeyboardRadioGroupDialog.kt index 40ee1e5..182229a 100644 --- a/app/src/main/kotlin/com/simplemobiletools/keyboard/dialogs/KeyboardRadioGroupDialog.kt +++ b/app/src/main/kotlin/com/simplemobiletools/keyboard/dialogs/KeyboardRadioGroupDialog.kt @@ -4,10 +4,10 @@ import android.view.ContextThemeWrapper import android.view.LayoutInflater import android.view.View import android.view.ViewGroup -import android.widget.RadioButton import android.widget.RadioGroup import androidx.appcompat.app.AlertDialog import com.simplemobiletools.commons.databinding.DialogRadioGroupBinding +import com.simplemobiletools.commons.databinding.RadioButtonBinding import com.simplemobiletools.commons.extensions.onGlobalLayout import com.simplemobiletools.commons.models.RadioItem import com.simplemobiletools.keyboard.R @@ -34,7 +34,7 @@ class KeyboardRadioGroupDialog( val binding = DialogRadioGroupBinding.inflate(layoutInflater) binding.dialogRadioGroup.apply { for (i in 0 until items.size) { - val radioButton = (layoutInflater.inflate(R.layout.radio_button, null) as RadioButton).apply { + val radioButton = RadioButtonBinding.inflate(layoutInflater).dialogRadioButton.apply { text = items[i].title isChecked = items[i].id == checkedItemId id = i diff --git a/app/src/main/kotlin/com/simplemobiletools/keyboard/extensions/Context.kt b/app/src/main/kotlin/com/simplemobiletools/keyboard/extensions/Context.kt index f23a678..eb29b1f 100644 --- a/app/src/main/kotlin/com/simplemobiletools/keyboard/extensions/Context.kt +++ b/app/src/main/kotlin/com/simplemobiletools/keyboard/extensions/Context.kt @@ -11,6 +11,7 @@ import android.widget.TextView import androidx.appcompat.app.AlertDialog import androidx.core.content.res.ResourcesCompat import com.google.android.material.dialog.MaterialAlertDialogBuilder +import com.simplemobiletools.commons.databinding.DialogTitleBinding import com.simplemobiletools.commons.extensions.* import com.simplemobiletools.commons.helpers.isNougatPlus import com.simplemobiletools.commons.models.RadioItem @@ -120,8 +121,7 @@ fun Context.setupKeyboardDialogStuff( } else { var title: TextView? = null if (titleId != 0 || titleText.isNotEmpty()) { - title = LayoutInflater.from(this).inflate(R.layout.dialog_title, null) as TextView - title.apply { + title = DialogTitleBinding.inflate(LayoutInflater.from(this)).dialogTitleTextview.apply { if (titleText.isNotEmpty()) { text = titleText } else { diff --git a/app/src/main/kotlin/com/simplemobiletools/keyboard/views/MyKeyboardView.kt b/app/src/main/kotlin/com/simplemobiletools/keyboard/views/MyKeyboardView.kt index 4ad01dc..db67102 100644 --- a/app/src/main/kotlin/com/simplemobiletools/keyboard/views/MyKeyboardView.kt +++ b/app/src/main/kotlin/com/simplemobiletools/keyboard/views/MyKeyboardView.kt @@ -37,6 +37,7 @@ import com.simplemobiletools.keyboard.activities.ManageClipboardItemsActivity import com.simplemobiletools.keyboard.activities.SettingsActivity import com.simplemobiletools.keyboard.adapters.ClipsKeyboardAdapter import com.simplemobiletools.keyboard.adapters.EmojisAdapter +import com.simplemobiletools.keyboard.databinding.KeyboardKeyPreviewBinding import com.simplemobiletools.keyboard.databinding.KeyboardPopupKeyboardBinding import com.simplemobiletools.keyboard.databinding.KeyboardViewKeyboardBinding import com.simplemobiletools.keyboard.dialogs.ChangeLanguagePopup @@ -206,7 +207,7 @@ class MyKeyboardView @JvmOverloads constructor(context: Context, attrs: Attribut } mPreviewPopup = PopupWindow(context) - mPreviewText = inflater.inflate(resources.getLayout(R.layout.keyboard_key_preview), null) as TextView + mPreviewText = KeyboardKeyPreviewBinding.inflate(inflater).root mPreviewTextSizeLarge = context.resources.getDimension(R.dimen.preview_text_size).toInt() mPreviewPopup.contentView = mPreviewText mPreviewPopup.setBackgroundDrawable(null) From 3db1fdb9f9fa5f49c03860e64cdaf2d9eab989b3 Mon Sep 17 00:00:00 2001 From: fatih ergin Date: Mon, 21 Aug 2023 23:44:13 +0300 Subject: [PATCH 8/9] use common helper function for binding activities --- .../com/simplemobiletools/keyboard/activities/MainActivity.kt | 2 +- .../keyboard/activities/ManageClipboardItemsActivity.kt | 2 +- .../simplemobiletools/keyboard/activities/SettingsActivity.kt | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/app/src/main/kotlin/com/simplemobiletools/keyboard/activities/MainActivity.kt b/app/src/main/kotlin/com/simplemobiletools/keyboard/activities/MainActivity.kt index 114d835..554ee68 100644 --- a/app/src/main/kotlin/com/simplemobiletools/keyboard/activities/MainActivity.kt +++ b/app/src/main/kotlin/com/simplemobiletools/keyboard/activities/MainActivity.kt @@ -15,7 +15,7 @@ import com.simplemobiletools.keyboard.R import com.simplemobiletools.keyboard.databinding.ActivityMainBinding class MainActivity : SimpleActivity() { - private val binding by lazy(LazyThreadSafetyMode.NONE) { ActivityMainBinding.inflate(layoutInflater) } + private val binding by viewBinding(ActivityMainBinding::inflate) override fun onCreate(savedInstanceState: Bundle?) { isMaterialActivity = true diff --git a/app/src/main/kotlin/com/simplemobiletools/keyboard/activities/ManageClipboardItemsActivity.kt b/app/src/main/kotlin/com/simplemobiletools/keyboard/activities/ManageClipboardItemsActivity.kt index 10ad537..f3c6db2 100644 --- a/app/src/main/kotlin/com/simplemobiletools/keyboard/activities/ManageClipboardItemsActivity.kt +++ b/app/src/main/kotlin/com/simplemobiletools/keyboard/activities/ManageClipboardItemsActivity.kt @@ -30,7 +30,7 @@ class ManageClipboardItemsActivity : SimpleActivity(), RefreshRecyclerViewListen private const val PICK_IMPORT_CLIPS_SOURCE_INTENT = 22 } - private val binding by lazy(LazyThreadSafetyMode.NONE) { ActivityManageClipboardItemsBinding.inflate(layoutInflater) } + private val binding by viewBinding(ActivityManageClipboardItemsBinding::inflate) override fun onCreate(savedInstanceState: Bundle?) { isMaterialActivity = true diff --git a/app/src/main/kotlin/com/simplemobiletools/keyboard/activities/SettingsActivity.kt b/app/src/main/kotlin/com/simplemobiletools/keyboard/activities/SettingsActivity.kt index 5801ac4..9ef848c 100644 --- a/app/src/main/kotlin/com/simplemobiletools/keyboard/activities/SettingsActivity.kt +++ b/app/src/main/kotlin/com/simplemobiletools/keyboard/activities/SettingsActivity.kt @@ -16,7 +16,7 @@ import java.util.Locale import kotlin.system.exitProcess class SettingsActivity : SimpleActivity() { - private val binding by lazy(LazyThreadSafetyMode.NONE) { ActivitySettingsBinding.inflate(layoutInflater) } + private val binding by viewBinding(ActivitySettingsBinding::inflate) override fun onCreate(savedInstanceState: Bundle?) { isMaterialActivity = true From bc081164b8098292574165a1304ced84477e0b44 Mon Sep 17 00:00:00 2001 From: fatih ergin Date: Tue, 22 Aug 2023 00:55:55 +0300 Subject: [PATCH 9/9] make settings activity's navigation bar transparent --- .../simplemobiletools/keyboard/activities/SettingsActivity.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/app/src/main/kotlin/com/simplemobiletools/keyboard/activities/SettingsActivity.kt b/app/src/main/kotlin/com/simplemobiletools/keyboard/activities/SettingsActivity.kt index 9ef848c..4f01a88 100644 --- a/app/src/main/kotlin/com/simplemobiletools/keyboard/activities/SettingsActivity.kt +++ b/app/src/main/kotlin/com/simplemobiletools/keyboard/activities/SettingsActivity.kt @@ -24,7 +24,7 @@ class SettingsActivity : SimpleActivity() { setContentView(binding.root) binding.apply { - updateMaterialActivityViews(settingsCoordinator, settingsHolder, useTransparentNavigation = false, useTopSearchMenu = false) + updateMaterialActivityViews(settingsCoordinator, settingsHolder, useTransparentNavigation = true, useTopSearchMenu = false) setupMaterialScrollListener(settingsNestedScrollview, settingsToolbar) } }