replace kotlin synthetic usages with viewbinding

app/src/main/kotlin/com/simplemobiletools/flashlight/activities/BrightDisplayActivity.kt

@@ -7,11 +7,12 @@ import android.view.WindowManager
 import com.simplemobiletools.commons.dialogs.ColorPickerDialog
 import com.simplemobiletools.commons.extensions.applyColorFilter
 import com.simplemobiletools.commons.extensions.getContrastColor
-import com.simplemobiletools.flashlight.R
+import com.simplemobiletools.flashlight.databinding.ActivityBrightDisplayBinding
 import com.simplemobiletools.flashlight.extensions.config
-import kotlinx.android.synthetic.main.activity_bright_display.*
 
 class BrightDisplayActivity : SimpleActivity() {
+    private lateinit var binding: ActivityBrightDisplayBinding
+
     override fun onCreate(savedInstanceState: Bundle?) {
         window.addFlags(
             WindowManager.LayoutParams.FLAG_DISMISS_KEYGUARD or
@@ -22,11 +23,12 @@ class BrightDisplayActivity : SimpleActivity() {
 
         useDynamicTheme = false
         super.onCreate(savedInstanceState)
-        setContentView(R.layout.activity_bright_display)
+        binding = ActivityBrightDisplayBinding.inflate(layoutInflater)
+        setContentView(binding.root)
         supportActionBar?.hide()
         setBackgroundColor(config.brightDisplayColor)
 
-        bright_display_change_color.setOnClickListener {
+        binding.brightDisplayChangeColor.setOnClickListener {
             ColorPickerDialog(this, config.brightDisplayColor, true, currentColorCallback = {
                 setBackgroundColor(it)
             }) { wasPositivePressed, color ->
@@ -34,8 +36,10 @@ class BrightDisplayActivity : SimpleActivity() {
                     config.brightDisplayColor = color
 
                     val contrastColor = color.getContrastColor()
-                    bright_display_change_color.setTextColor(contrastColor)
+                    binding.brightDisplayChangeColor.apply {
-                    bright_display_change_color.background.applyColorFilter(contrastColor)
+                        setTextColor(contrastColor)
+                        background.applyColorFilter(contrastColor)
+                    }
                 } else {
                     setBackgroundColor(config.brightDisplayColor)
                 }
@@ -57,11 +61,15 @@ class BrightDisplayActivity : SimpleActivity() {
     }
 
     private fun setBackgroundColor(color: Int) {
-        bright_display.background = ColorDrawable(color)
+        binding.apply {
+            brightDisplay.background = ColorDrawable(color)
 
-        val contrastColor = config.brightDisplayColor.getContrastColor()
+            val contrastColor = config.brightDisplayColor.getContrastColor()
-        bright_display_change_color.setTextColor(contrastColor)
+            brightDisplayChangeColor.apply {
-        bright_display_change_color.background.applyColorFilter(contrastColor)
+                setTextColor(contrastColor)
+                background.applyColorFilter(contrastColor)
+            }
+        }
     }
 
     private fun toggleBrightness(increase: Boolean) {

app/src/main/kotlin/com/simplemobiletools/flashlight/activities/MainActivity.kt

@@ -17,12 +17,12 @@ import com.simplemobiletools.commons.helpers.isNougatPlus
 import com.simplemobiletools.commons.models.FAQItem
 import com.simplemobiletools.flashlight.BuildConfig
 import com.simplemobiletools.flashlight.R
+import com.simplemobiletools.flashlight.databinding.ActivityMainBinding
 import com.simplemobiletools.flashlight.extensions.config
 import com.simplemobiletools.flashlight.helpers.CameraTorchListener
 import com.simplemobiletools.flashlight.helpers.MIN_BRIGHTNESS_LEVEL
 import com.simplemobiletools.flashlight.helpers.MyCameraImpl
 import com.simplemobiletools.flashlight.models.Events
-import kotlinx.android.synthetic.main.activity_main.*
 import org.greenrobot.eventbus.EventBus
 import org.greenrobot.eventbus.Subscribe
 import java.util.*
@@ -33,6 +33,7 @@ class MainActivity : SimpleActivity() {
     private val FLASHLIGHT_STATE = "flashlight_state"
     private val STROBOSCOPE_STATE = "stroboscope_state"
 
+    private lateinit var binding: ActivityMainBinding
     private var mBus: EventBus? = null
     private var mCameraImpl: MyCameraImpl? = null
     private var mIsFlashlightOn = false
@@ -41,32 +42,36 @@ class MainActivity : SimpleActivity() {
     override fun onCreate(savedInstanceState: Bundle?) {
         isMaterialActivity = true
         super.onCreate(savedInstanceState)
-        setContentView(R.layout.activity_main)
+        binding = ActivityMainBinding.inflate(layoutInflater)
+        setContentView(binding.root)
         appLaunched(BuildConfig.APPLICATION_ID)
         setupOptionsMenu()
         refreshMenuItems()
 
-        updateMaterialActivityViews(main_coordinator, main_holder, useTransparentNavigation = true, useTopSearchMenu = false)
-        setupMaterialScrollListener(main_nested_scrollview, main_toolbar)
-
         mBus = EventBus.getDefault()
-        changeIconColor(getContrastColor(), stroboscope_btn)
 
-        bright_display_btn.setOnClickListener {
+        binding.apply {
-            reTurnFlashlightOn = false
+            updateMaterialActivityViews(mainCoordinator, mainHolder, useTransparentNavigation = true, useTopSearchMenu = false)
-            startActivity(Intent(applicationContext, BrightDisplayActivity::class.java))
+            setupMaterialScrollListener(mainNestedScrollview, mainToolbar)
-        }
 
-        flashlight_btn.setOnClickListener {
+            changeIconColor(getContrastColor(), stroboscopeBtn)
-            mCameraImpl!!.toggleFlashlight()
-        }
 
-        sos_btn.setOnClickListener {
+            brightDisplayBtn.setOnClickListener {
-            toggleStroboscope(true)
+                reTurnFlashlightOn = false
-        }
+                startActivity(Intent(applicationContext, BrightDisplayActivity::class.java))
+            }
 
-        stroboscope_btn.setOnClickListener {
+            flashlightBtn.setOnClickListener {
-            toggleStroboscope(false)
+                mCameraImpl!!.toggleFlashlight()
+            }
+
+            sosBtn.setOnClickListener {
+                toggleStroboscope(true)
+            }
+
+            stroboscopeBtn.setOnClickListener {
+                toggleStroboscope(false)
+            }
         }
 
         setupStroboscope()
@@ -75,29 +80,32 @@ class MainActivity : SimpleActivity() {
 
     override fun onResume() {
         super.onResume()
-        setupToolbar(main_toolbar)
+        setupToolbar(binding.mainToolbar)
         mCameraImpl!!.handleCameraSetup()
         checkState(MyCameraImpl.isFlashlightOn)
 
         val contrastColor = getContrastColor()
-        changeIconColor(contrastColor, bright_display_btn)
-        bright_display_btn.beVisibleIf(config.brightDisplay)
-        sos_btn.beVisibleIf(config.sos)
 
-        if (sos_btn.currentTextColor != getProperPrimaryColor()) {
+        binding.apply {
-            sos_btn.setTextColor(contrastColor)
+            changeIconColor(contrastColor, brightDisplayBtn)
-        }
+            brightDisplayBtn.beVisibleIf(config.brightDisplay)
+            sosBtn.beVisibleIf(config.sos)
 
-        stroboscope_btn.beVisibleIf(config.stroboscope)
+            if (sosBtn.currentTextColor != getProperPrimaryColor()) {
+                sosBtn.setTextColor(contrastColor)
+            }
 
-        if (!config.stroboscope) {
+            stroboscopeBtn.beVisibleIf(config.stroboscope)
-            mCameraImpl!!.stopStroboscope()
-            stroboscope_bar.beInvisible()
-        }
 
-        updateTextColors(main_holder)
+            if (!config.stroboscope) {
-        if (stroboscope_bar.isInvisible()) {
+                mCameraImpl!!.stopStroboscope()
-            changeIconColor(contrastColor, stroboscope_btn)
+                stroboscopeBar.beInvisible()
+            }
+
+            updateTextColors(mainHolder)
+            if (stroboscopeBar.isInvisible()) {
+                changeIconColor(contrastColor, stroboscopeBtn)
+            }
         }
 
         requestedOrientation = if (config.forcePortraitMode) ActivityInfo.SCREEN_ORIENTATION_PORTRAIT else ActivityInfo.SCREEN_ORIENTATION_SENSOR
@@ -132,7 +140,7 @@ class MainActivity : SimpleActivity() {
     }
 
     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()
@@ -144,14 +152,14 @@ 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)
         }
     }
 
     override fun onSaveInstanceState(outState: Bundle) {
         outState.putBoolean(FLASHLIGHT_STATE, mIsFlashlightOn)
-        outState.putBoolean(STROBOSCOPE_STATE, stroboscope_bar.isVisible())
+        outState.putBoolean(STROBOSCOPE_STATE, binding.stroboscopeBar.isVisible())
         super.onSaveInstanceState(outState)
     }
 
@@ -196,7 +204,7 @@ class MainActivity : SimpleActivity() {
             override fun onTorchEnabled(isEnabled: Boolean) {
                 mCameraImpl!!.onTorchEnabled(isEnabled)
                 if (mCameraImpl!!.supportsBrightnessControl()) {
-                    brightness_bar.beVisibleIf(isEnabled)
+                    binding.brightnessBar.beVisibleIf(isEnabled)
                 }
             }
 
@@ -211,13 +219,15 @@ class MainActivity : SimpleActivity() {
     }
 
     private fun setupStroboscope() {
-        stroboscope_bar.max = (MAX_STROBO_DELAY - MIN_STROBO_DELAY).toInt()
+        binding.stroboscopeBar.apply {
-        stroboscope_bar.progress = config.stroboscopeProgress
+            max = (MAX_STROBO_DELAY - MIN_STROBO_DELAY).toInt()
-        stroboscope_bar.onSeekBarChangeListener { progress ->
+            progress = config.stroboscopeProgress
-            val frequency = stroboscope_bar.max - progress + MIN_STROBO_DELAY
+            onSeekBarChangeListener { progress ->
-            mCameraImpl?.stroboFrequency = frequency
+                val frequency = max - progress + MIN_STROBO_DELAY
-            config.stroboscopeFrequency = frequency
+                mCameraImpl?.stroboFrequency = frequency
-            config.stroboscopeProgress = progress
+                config.stroboscopeFrequency = frequency
+                config.stroboscopeProgress = progress
+            }
         }
     }
 
@@ -237,22 +247,26 @@ class MainActivity : SimpleActivity() {
     }
 
     private fun setupBrightness() {
-        brightness_bar.max = mCameraImpl?.getMaximumBrightnessLevel() ?: MIN_BRIGHTNESS_LEVEL
+        binding.brightnessBar.apply {
-        brightness_bar.progress = mCameraImpl?.getCurrentBrightnessLevel() ?: MIN_BRIGHTNESS_LEVEL
+            max = mCameraImpl?.getMaximumBrightnessLevel() ?: MIN_BRIGHTNESS_LEVEL
-        brightness_bar.onSeekBarChangeListener { level ->
+            progress = mCameraImpl?.getCurrentBrightnessLevel() ?: MIN_BRIGHTNESS_LEVEL
-            val newLevel = level.coerceAtLeast(MIN_BRIGHTNESS_LEVEL)
+            onSeekBarChangeListener { level ->
-            mCameraImpl?.updateBrightnessLevel(newLevel)
+                val newLevel = level.coerceAtLeast(MIN_BRIGHTNESS_LEVEL)
-            config.brightnessLevel = newLevel
+                mCameraImpl?.updateBrightnessLevel(newLevel)
+                config.brightnessLevel = newLevel
+            }
         }
     }
 
     private fun cameraPermissionGranted(isSOS: Boolean) {
         if (isSOS) {
             val isSOSRunning = mCameraImpl!!.toggleSOS()
-            sos_btn.setTextColor(if (isSOSRunning) getProperPrimaryColor() else getContrastColor())
+            binding.sosBtn.setTextColor(if (isSOSRunning) getProperPrimaryColor() else getContrastColor())
         } else if (mCameraImpl!!.toggleStroboscope()) {
-            stroboscope_bar.beInvisibleIf(stroboscope_bar.isVisible())
+            binding.apply {
-            changeIconColor(if (stroboscope_bar.isVisible()) getProperPrimaryColor() else getContrastColor(), stroboscope_btn)
+                stroboscopeBar.beInvisibleIf(stroboscopeBar.isVisible())
+                changeIconColor(if (stroboscopeBar.isVisible()) getProperPrimaryColor() else getContrastColor(), stroboscopeBtn)
+            }
         }
     }
 
@@ -270,13 +284,13 @@ class MainActivity : SimpleActivity() {
 
     @Subscribe
     fun stopStroboscope(event: Events.StopStroboscope) {
-        stroboscope_bar.beInvisible()
+        binding.stroboscopeBar.beInvisible()
-        changeIconColor(getContrastColor(), stroboscope_btn)
+        changeIconColor(getContrastColor(), binding.stroboscopeBtn)
     }
 
     @Subscribe
     fun stopSOS(event: Events.StopSOS) {
-        sos_btn.setTextColor(getContrastColor())
+        binding.sosBtn.setTextColor(getContrastColor())
     }
 
     private fun checkState(isEnabled: Boolean) {
@@ -288,18 +302,20 @@ class MainActivity : SimpleActivity() {
     }
 
     private fun enableFlashlight() {
-        changeIconColor(getProperPrimaryColor(), flashlight_btn)
+        changeIconColor(getProperPrimaryColor(), binding.flashlightBtn)
         window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
         mIsFlashlightOn = true
 
-        sos_btn.setTextColor(getContrastColor())
+        binding.apply {
+            sosBtn.setTextColor(getContrastColor())
 
-        changeIconColor(getContrastColor(), stroboscope_btn)
+            changeIconColor(getContrastColor(), stroboscopeBtn)
-        stroboscope_bar.beInvisible()
+            stroboscopeBar.beInvisible()
+        }
     }
 
     private fun disableFlashlight() {
-        changeIconColor(getContrastColor(), flashlight_btn)
+        changeIconColor(getContrastColor(), binding.flashlightBtn)
         window.clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
         mIsFlashlightOn = false
     }

app/src/main/kotlin/com/simplemobiletools/flashlight/activities/SettingsActivity.kt

@@ -6,25 +6,29 @@ import com.simplemobiletools.commons.extensions.*
 import com.simplemobiletools.commons.helpers.IS_CUSTOMIZING_COLORS
 import com.simplemobiletools.commons.helpers.NavigationIcon
 import com.simplemobiletools.commons.helpers.isTiramisuPlus
-import com.simplemobiletools.flashlight.R
+import com.simplemobiletools.flashlight.databinding.ActivitySettingsBinding
 import com.simplemobiletools.flashlight.extensions.config
-import kotlinx.android.synthetic.main.activity_settings.*
+import java.util.Locale
-import java.util.*
 import kotlin.system.exitProcess
 
 class SettingsActivity : SimpleActivity() {
+    private lateinit var binding: ActivitySettingsBinding
+
     override fun onCreate(savedInstanceState: Bundle?) {
         isMaterialActivity = true
         super.onCreate(savedInstanceState)
-        setContentView(R.layout.activity_settings)
+        binding = ActivitySettingsBinding.inflate(layoutInflater)
+        setContentView(binding.root)
 
-        updateMaterialActivityViews(settings_coordinator, settings_holder, useTransparentNavigation = true, useTopSearchMenu = false)
+        binding.apply {
-        setupMaterialScrollListener(settings_nested_scrollview, settings_toolbar)
+            updateMaterialActivityViews(settingsCoordinator, settingsHolder, useTransparentNavigation = true, useTopSearchMenu = false)
+            setupMaterialScrollListener(settingsNestedScrollview, settingsToolbar)
+        }
     }
 
     override fun onResume() {
         super.onResume()
-        setupToolbar(settings_toolbar, NavigationIcon.Arrow)
+        setupToolbar(binding.settingsToolbar, NavigationIcon.Arrow)
 
         setupPurchaseThankYou()
         setupCustomizeColors()
@@ -36,29 +40,33 @@ class SettingsActivity : SimpleActivity() {
         setupStroboscope()
         setupSOS()
         setupForcePortrait()
-        updateTextColors(settings_holder)
+        updateTextColors(binding.settingsHolder)
 
-        arrayOf(settings_color_customization_section_label, settings_general_settings_label).forEach {
+        arrayOf(binding.settingsColorCustomizationSectionLabel, binding.settingsGeneralSettingsLabel).forEach {
             it.setTextColor(getProperPrimaryColor())
         }
     }
 
     private fun setupPurchaseThankYou() {
-        settings_purchase_thank_you_holder.beGoneIf(isOrWasThankYouInstalled())
+        binding.settingsPurchaseThankYouHolder.apply {
-        settings_purchase_thank_you_holder.setOnClickListener {
+            beGoneIf(isOrWasThankYouInstalled())
-            launchPurchaseThankYouIntent()
+            setOnClickListener {
+                launchPurchaseThankYouIntent()
+            }
         }
     }
 
     private fun setupCustomizeColors() {
-        settings_color_customization_label.text = getCustomizeColorsString()
+        binding.apply {
-        settings_color_customization_holder.setOnClickListener {
+            settingsColorCustomizationLabel.text = getCustomizeColorsString()
-            handleCustomizeColorsClick()
+            settingsColorCustomizationHolder.setOnClickListener {
+                handleCustomizeColorsClick()
+            }
         }
     }
 
     private fun setupCustomizeWidgetColors() {
-        settings_widget_color_customization_holder.setOnClickListener {
+        binding.settingsWidgetColorCustomizationHolder.setOnClickListener {
             Intent(this, WidgetTorchConfigureActivity::class.java).apply {
                 putExtra(IS_CUSTOMIZING_COLORS, true)
                 startActivity(this)
@@ -67,60 +75,74 @@ class SettingsActivity : SimpleActivity() {
     }
 
     private fun setupUseEnglish() {
-        settings_use_english_holder.beVisibleIf((config.wasUseEnglishToggled || Locale.getDefault().language != "en") && !isTiramisuPlus())
+        binding.apply {
-        settings_use_english.isChecked = config.useEnglish
+            settingsUseEnglishHolder.beVisibleIf((config.wasUseEnglishToggled || Locale.getDefault().language != "en") && !isTiramisuPlus())
-        settings_use_english_holder.setOnClickListener {
+            settingsUseEnglish.isChecked = config.useEnglish
-            settings_use_english.toggle()
+            settingsUseEnglishHolder.setOnClickListener {
-            config.useEnglish = settings_use_english.isChecked
+                settingsUseEnglish.toggle()
-            exitProcess(0)
+                config.useEnglish = settingsUseEnglish.isChecked
+                exitProcess(0)
+            }
         }
     }
 
     private fun setupLanguage() {
-        settings_language.text = Locale.getDefault().displayLanguage
+        binding.apply {
-        settings_language_holder.beVisibleIf(isTiramisuPlus())
+            settingsLanguage.text = Locale.getDefault().displayLanguage
-        settings_language_holder.setOnClickListener {
+            settingsLanguageHolder.beVisibleIf(isTiramisuPlus())
-            launchChangeAppLanguageIntent()
+            settingsLanguageHolder.setOnClickListener {
+                launchChangeAppLanguageIntent()
+            }
         }
     }
 
     private fun setupTurnFlashlightOn() {
-        settings_turn_flashlight_on.isChecked = config.turnFlashlightOn
+        binding.apply {
-        settings_turn_flashlight_on_holder.setOnClickListener {
+            settingsTurnFlashlightOn.isChecked = config.turnFlashlightOn
-            settings_turn_flashlight_on.toggle()
+            settingsTurnFlashlightOnHolder.setOnClickListener {
-            config.turnFlashlightOn = settings_turn_flashlight_on.isChecked
+                settingsTurnFlashlightOn.toggle()
+                config.turnFlashlightOn = settingsTurnFlashlightOn.isChecked
+            }
         }
     }
 
     private fun setupBrightDisplay() {
-        settings_bright_display.isChecked = config.brightDisplay
+        binding.apply {
-        settings_bright_display_holder.setOnClickListener {
+            settingsBrightDisplay.isChecked = config.brightDisplay
-            settings_bright_display.toggle()
+            settingsBrightDisplayHolder.setOnClickListener {
-            config.brightDisplay = settings_bright_display.isChecked
+                settingsBrightDisplay.toggle()
+                config.brightDisplay = settingsBrightDisplay.isChecked
+            }
         }
     }
 
     private fun setupStroboscope() {
-        settings_stroboscope.isChecked = config.stroboscope
+        binding.apply {
-        settings_stroboscope_holder.setOnClickListener {
+            settingsStroboscope.isChecked = config.stroboscope
-            settings_stroboscope.toggle()
+            settingsStroboscopeHolder.setOnClickListener {
-            config.stroboscope = settings_stroboscope.isChecked
+                settingsStroboscope.toggle()
+                config.stroboscope = settingsStroboscope.isChecked
+            }
         }
     }
 
     private fun setupSOS() {
-        settings_sos.isChecked = config.sos
+        binding.apply {
-        settings_sos_holder.setOnClickListener {
+            settingsSos.isChecked = config.sos
-            settings_sos.toggle()
+            settingsSosHolder.setOnClickListener {
-            config.sos = settings_sos.isChecked
+                settingsSos.toggle()
+                config.sos = settingsSos.isChecked
+            }
         }
     }
 
     private fun setupForcePortrait() {
-        settings_force_portrait.isChecked = config.forcePortraitMode
+        binding.apply {
-        settings_force_portrait_holder.setOnClickListener {
+            settingsForcePortrait.isChecked = config.forcePortraitMode
-            settings_force_portrait.toggle()
+            settingsForcePortraitHolder.setOnClickListener {
-            config.forcePortraitMode = settings_force_portrait.isChecked
+                settingsForcePortrait.toggle()
+                config.forcePortraitMode = settingsForcePortrait.isChecked
+            }
         }
     }
 }

app/src/main/kotlin/com/simplemobiletools/flashlight/activities/WidgetBrightDisplayConfigureActivity.kt

@@ -12,11 +12,12 @@ import com.simplemobiletools.commons.dialogs.FeatureLockedDialog
 import com.simplemobiletools.commons.extensions.*
 import com.simplemobiletools.commons.helpers.IS_CUSTOMIZING_COLORS
 import com.simplemobiletools.flashlight.R
+import com.simplemobiletools.flashlight.databinding.WidgetBrightDisplayConfigBinding
 import com.simplemobiletools.flashlight.extensions.config
 import com.simplemobiletools.flashlight.helpers.MyWidgetBrightDisplayProvider
-import kotlinx.android.synthetic.main.widget_bright_display_config.*
 
 class WidgetBrightDisplayConfigureActivity : SimpleActivity() {
+    private lateinit var binding: WidgetBrightDisplayConfigBinding
     private var mWidgetAlpha = 0f
     private var mWidgetId = 0
     private var mWidgetColor = 0
@@ -26,8 +27,9 @@ class WidgetBrightDisplayConfigureActivity : SimpleActivity() {
     public override fun onCreate(savedInstanceState: Bundle?) {
         useDynamicTheme = false
         super.onCreate(savedInstanceState)
+        binding = WidgetBrightDisplayConfigBinding.inflate(layoutInflater)
         setResult(Activity.RESULT_CANCELED)
-        setContentView(R.layout.widget_bright_display_config)
+        setContentView(binding.root)
         initVariables()
 
         val isCustomizingColors = intent.extras?.getBoolean(IS_CUSTOMIZING_COLORS) ?: false
@@ -37,11 +39,13 @@ class WidgetBrightDisplayConfigureActivity : SimpleActivity() {
             finish()
         }
 
-        config_save.setOnClickListener { saveConfig() }
+        binding.apply {
-        config_widget_color.setOnClickListener { pickBackgroundColor() }
+            configSave.setOnClickListener { saveConfig() }
+            configWidgetColor.setOnClickListener { pickBackgroundColor() }
 
-        val primaryColor = getProperPrimaryColor()
+            val primaryColor = getProperPrimaryColor()
-        config_widget_seekbar.setColors(getProperTextColor(), primaryColor, primaryColor)
+            configWidgetSeekbar.setColors(getProperTextColor(), primaryColor, primaryColor)
+        }
 
         if (!isCustomizingColors && !isOrWasThankYouInstalled()) {
             mFeatureLockedDialog = FeatureLockedDialog(this) {
@@ -51,8 +55,10 @@ class WidgetBrightDisplayConfigureActivity : SimpleActivity() {
             }
         }
 
-        config_save.backgroundTintList = ColorStateList.valueOf(getProperPrimaryColor())
+        binding.configSave.apply {
-        config_save.setTextColor(getProperPrimaryColor().getContrastColor())
+            backgroundTintList = ColorStateList.valueOf(getProperPrimaryColor())
+            setTextColor(getProperPrimaryColor().getContrastColor())
+        }
     }
 
     override fun onResume() {
@@ -73,8 +79,10 @@ class WidgetBrightDisplayConfigureActivity : SimpleActivity() {
         mWidgetAlpha = Color.alpha(mWidgetColor) / 255.toFloat()
 
         mWidgetColorWithoutTransparency = Color.rgb(Color.red(mWidgetColor), Color.green(mWidgetColor), Color.blue(mWidgetColor))
-        config_widget_seekbar.setOnSeekBarChangeListener(seekbarChangeListener)
+        binding.configWidgetSeekbar.apply {
-        config_widget_seekbar.progress = (mWidgetAlpha * 100).toInt()
+            setOnSeekBarChangeListener(seekbarChangeListener)
+            progress = (mWidgetAlpha * 100).toInt()
+        }
         updateColors()
     }
 
@@ -107,8 +115,10 @@ class WidgetBrightDisplayConfigureActivity : SimpleActivity() {
 
     private fun updateColors() {
         mWidgetColor = mWidgetColorWithoutTransparency.adjustAlpha(mWidgetAlpha)
-        config_widget_color.setFillWithStroke(mWidgetColor, mWidgetColor)
+        binding.apply {
-        config_image.background.mutate().applyColorFilter(mWidgetColor)
+            configWidgetColor.setFillWithStroke(mWidgetColor, mWidgetColor)
+            configImage.background.mutate().applyColorFilter(mWidgetColor)
+        }
     }
 
     private val seekbarChangeListener = object : SeekBar.OnSeekBarChangeListener {

app/src/main/kotlin/com/simplemobiletools/flashlight/activities/WidgetTorchConfigureActivity.kt

@@ -12,12 +12,13 @@ import com.simplemobiletools.commons.dialogs.FeatureLockedDialog
 import com.simplemobiletools.commons.extensions.*
 import com.simplemobiletools.commons.helpers.IS_CUSTOMIZING_COLORS
 import com.simplemobiletools.flashlight.R
+import com.simplemobiletools.flashlight.databinding.WidgetTorchConfigBinding
 import com.simplemobiletools.flashlight.extensions.config
 import com.simplemobiletools.flashlight.extensions.updateBrightDisplayWidget
 import com.simplemobiletools.flashlight.helpers.MyWidgetTorchProvider
-import kotlinx.android.synthetic.main.widget_torch_config.*
 
 class WidgetTorchConfigureActivity : SimpleActivity() {
+    private lateinit var binding: WidgetTorchConfigBinding
     private var mWidgetAlpha = 0f
     private var mWidgetId = 0
     private var mWidgetColor = 0
@@ -27,8 +28,9 @@ class WidgetTorchConfigureActivity : SimpleActivity() {
     public override fun onCreate(savedInstanceState: Bundle?) {
         useDynamicTheme = false
         super.onCreate(savedInstanceState)
+        binding = WidgetTorchConfigBinding.inflate(layoutInflater)
         setResult(Activity.RESULT_CANCELED)
-        setContentView(R.layout.widget_torch_config)
+        setContentView(binding.root)
         initVariables()
 
         val isCustomizingColors = intent.extras?.getBoolean(IS_CUSTOMIZING_COLORS) ?: false
@@ -38,22 +40,24 @@ class WidgetTorchConfigureActivity : SimpleActivity() {
             finish()
         }
 
-        config_save.setOnClickListener { saveConfig() }
+        binding.apply {
-        config_widget_color.setOnClickListener { pickBackgroundColor() }
+            configSave.setOnClickListener { saveConfig() }
+            configWidgetColor.setOnClickListener { pickBackgroundColor() }
 
-        val primaryColor = getProperPrimaryColor()
+            val primaryColor = getProperPrimaryColor()
-        config_widget_seekbar.setColors(getProperTextColor(), primaryColor, primaryColor)
+            configWidgetSeekbar.setColors(getProperTextColor(), primaryColor, primaryColor)
 
-        if (!isCustomizingColors && !isOrWasThankYouInstalled()) {
+            if (!isCustomizingColors && !isOrWasThankYouInstalled()) {
-            mFeatureLockedDialog = FeatureLockedDialog(this) {
+                mFeatureLockedDialog = FeatureLockedDialog(this@WidgetTorchConfigureActivity) {
-                if (!isOrWasThankYouInstalled()) {
+                    if (!isOrWasThankYouInstalled()) {
-                    finish()
+                        finish()
+                    }
                 }
             }
-        }
 
-        config_save.backgroundTintList = ColorStateList.valueOf(getProperPrimaryColor())
+            configSave.backgroundTintList = ColorStateList.valueOf(getProperPrimaryColor())
-        config_save.setTextColor(getProperPrimaryColor().getContrastColor())
+            configSave.setTextColor(getProperPrimaryColor().getContrastColor())
+        }
     }
 
     override fun onResume() {
@@ -74,8 +78,10 @@ class WidgetTorchConfigureActivity : SimpleActivity() {
         mWidgetAlpha = Color.alpha(mWidgetColor) / 255.toFloat()
 
         mWidgetColorWithoutTransparency = Color.rgb(Color.red(mWidgetColor), Color.green(mWidgetColor), Color.blue(mWidgetColor))
-        config_widget_seekbar.setOnSeekBarChangeListener(seekbarChangeListener)
+        binding.configWidgetSeekbar.apply {
-        config_widget_seekbar.progress = (mWidgetAlpha * 100).toInt()
+            setOnSeekBarChangeListener(seekbarChangeListener)
+            progress = (mWidgetAlpha * 100).toInt()
+        }
         updateColors()
     }
 
@@ -110,8 +116,10 @@ class WidgetTorchConfigureActivity : SimpleActivity() {
 
     private fun updateColors() {
         mWidgetColor = mWidgetColorWithoutTransparency.adjustAlpha(mWidgetAlpha)
-        config_widget_color.setFillWithStroke(mWidgetColor, mWidgetColor)
+        binding.apply {
-        config_image.background.mutate().applyColorFilter(mWidgetColor)
+            configWidgetColor.setFillWithStroke(mWidgetColor, mWidgetColor)
+            configImage.background.mutate().applyColorFilter(mWidgetColor)
+        }
     }
 
     private val seekbarChangeListener = object : SeekBar.OnSeekBarChangeListener {