[AI重构]AI重构LargeFileCleanActivity

app/src/main/java/com/simplecleaner/app/ui/largefile/LargeFileCleanActivity.kt

@@ -38,10 +38,14 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.async
 import kotlinx.coroutines.launch
 import java.util.Calendar
+import androidx.activity.viewModels
+import com.simplecleaner.app.ui.largefile.LargeFileCleanViewModel
+import com.simplecleaner.app.ui.largefile.LargeFileCleanAdapter
 
 
 class LargeFileCleanActivity : BaseActivity<ActivityLargeFileCleanBinding>(ActivityLargeFileCleanBinding::inflate) {
 
+    private val viewModel: LargeFileCleanViewModel by viewModels()
     private val LARGE_FILE_SIZE: Long = 1024 * 1024 * 10
     private val typeList by lazy {
         listOf(
@@ -74,53 +78,11 @@ class LargeFileCleanActivity : BaseActivity<ActivityLargeFileCleanBinding>(Activ
         )
     }
 
-    private var typePosition = 0
-    private var sizePosition = 0
-    private var timePosition = 0
-    private var total: Long = 0
-    private var allData = mutableListOf<FileBean>()
-    private var list = mutableListOf<FileBean>()
-    private val adapter by lazy {
-        class ViewHolder(val binding: ItemLargeFileCleanBinding) : RecyclerView.ViewHolder(binding.root)
-
-        object : RecyclerView.Adapter<ViewHolder>() {
-            override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
-                val binding = ItemLargeFileCleanBinding.inflate(LayoutInflater.from(parent.context), parent, false)
-                return ViewHolder(binding)
-            }
-
-            override fun getItemCount(): Int = list.size
-
-            override fun onBindViewHolder(holder: ViewHolder, position: Int) {
-                val item = list[position]
-                holder.binding.ivVideo.isVisible = MineTypeUtils.isVideo(item.mineType)
-                if (MineTypeUtils.isImage(item.mineType) || MineTypeUtils.isVideo(item.mineType)) {
-                    val round = resources.getDimensionPixelSize(R.dimen.dp_4)
-                    val options = RequestOptions().transform(CenterCrop(), RoundedCorners(round))
-                    Glide.with(holder.itemView.context)
-                        .load(item.path)
-                        .apply(options)
-                        .into(holder.binding.ivIcon)
-                } else if (MineTypeUtils.isAudio(item.mineType)) {
-                    holder.binding.ivIcon.setImageResource(R.drawable.icon_yinping_large)
-                } else if (MineTypeUtils.isApk(item.mineType)) {
-                    holder.binding.ivIcon.setImageResource(R.drawable.icon_app_large)
-                } else if (MineTypeUtils.isDoc(item.mineType)) {
-                    holder.binding.ivIcon.setImageResource(R.drawable.icon_wenjianx_large)
-                } else {
-                    holder.binding.ivIcon.setImageResource(R.drawable.icon_yingyong_large)
-                }
-
-                holder.binding.tvName.text = item.name
-                holder.binding.tvLength.text = Utils.getSizeFormat(item.length)
-                holder.binding.ivSelect.isSelected = item.isSelected
-                holder.binding.viewLine.visibility = if (position == itemCount - 1) View.GONE else View.VISIBLE
-                holder.itemView.setOnClickListener {
-                    item.isSelected = !item.isSelected
-                    notifyItemChanged(position)
-                    updateView()
-                }
-            }
+    private val adapter: LargeFileCleanAdapter by lazy {
+        LargeFileCleanAdapter(emptyList()) { position ->
+            viewModel.toggleSelect(position)
+            adapter.notifyItemChanged(position)
+            updateView()
         }
     }
 
@@ -153,7 +115,7 @@ class LargeFileCleanActivity : BaseActivity<ActivityLargeFileCleanBinding>(Activ
     }
 
     private fun updateView() {
-        total = list.filter { it.isSelected }.sumOf { it.length }
+        val total = viewModel.getFilteredList().filter { it.isSelected }.sumOf { it.length }
         setTextSize(binding.tvDelete, getString(R.string.delete), total)
         binding.tvDelete.isEnabled = total > 0
         if (binding.tvDelete.isEnabled == true) {
@@ -169,17 +131,17 @@ class LargeFileCleanActivity : BaseActivity<ActivityLargeFileCleanBinding>(Activ
         when (tabType) {
             1 -> {
                 textView = binding.tvType
-                typePosition = position
+                viewModel.typePosition = position
             }
 
             2 -> {
                 textView = binding.tvSize
-                sizePosition = position
+                viewModel.sizePosition = position
             }
 
             3 -> {
                 textView = binding.tvTime
-                timePosition = position
+                viewModel.timePosition = position
             }
         }
         textView.text = item.name
@@ -194,58 +156,12 @@ class LargeFileCleanActivity : BaseActivity<ActivityLargeFileCleanBinding>(Activ
 
     @SuppressLint("NotifyDataSetChanged")
     private fun filterData() {
-        allData.forEach { it.isSelected = false }
-        var data = filterType(allData, typePosition)
-        data = filterSize(data, sizePosition)
-        data = filterTime(data, timePosition)
-        list = data.toMutableList()
-        adapter.notifyDataSetChanged()
-        binding.rvLargeFile.visibility = if (list.isEmpty()) View.GONE else View.VISIBLE
-        binding.ivEmpty.visibility = if (list.isEmpty()) View.VISIBLE else View.GONE
-        binding.tvDelete.visibility = if (list.isEmpty()) View.GONE else View.VISIBLE
-    }
-
-    private fun filterType(list: List<FileBean>, position: Int): List<FileBean> {
-        return when (position) {
-            1 -> list.filter { MineTypeUtils.isImage(it.mineType) }
-            2 -> list.filter { MineTypeUtils.isVideo(it.mineType) }
-            3 -> list.filter { MineTypeUtils.isAudio(it.mineType) }
-            4 -> list.filter { MineTypeUtils.isDoc(it.mineType) }
-            5 -> list.filter { MineTypeUtils.isApk(it.mineType) }
-            6 -> list.filterNot { file ->
-                MineTypeUtils.mineTypes.any { mimeType -> file.mineType.startsWith(mimeType) }
-            }
-
-            else -> {
-                list
-            }
-        }
-    }
-
-    private fun filterSize(list: List<FileBean>, position: Int): List<FileBean> {
-        return when (position) {
-            1 -> list.filter { it.length >= LARGE_FILE_SIZE * 2 }
-            2 -> list.filter { it.length >= LARGE_FILE_SIZE * 5 }
-            3 -> list.filter { it.length >= LARGE_FILE_SIZE * 10 }
-            4 -> list.filter { it.length >= LARGE_FILE_SIZE * 50 }
-            else -> {
-                list.filter { it.length >= LARGE_FILE_SIZE }
-            }
-        }
-    }
-
-
-    private fun filterTime(list: List<FileBean>, position: Int): List<FileBean> {
-        return when (position) {
-            1 -> list.filter { it.lastModified > Calendar.getInstance().apply { add(Calendar.WEEK_OF_YEAR, -1) }.timeInMillis }
-            2 -> list.filter { it.lastModified > Calendar.getInstance().apply { add(Calendar.MONTH, -1) }.timeInMillis }
-            3 -> list.filter { it.lastModified > Calendar.getInstance().apply { add(Calendar.MONTH, -3) }.timeInMillis }
-            4 -> list.filter { it.lastModified > Calendar.getInstance().apply { add(Calendar.MONTH, -6) }.timeInMillis }
-            5 -> list.filter { it.lastModified > Calendar.getInstance().apply { add(Calendar.YEAR, -1) }.timeInMillis }
-            else -> {
-                list
-            }
-        }
+        viewModel.filterData()
+        adapter.setData(viewModel.getFilteredList())
+        binding.rvLargeFile.visibility = if (viewModel.getFilteredList().isEmpty()) View.GONE else View.VISIBLE
+        binding.ivEmpty.visibility = if (viewModel.getFilteredList().isEmpty()) View.VISIBLE else View.GONE
+        binding.tvDelete.visibility = if (viewModel.getFilteredList().isEmpty()) View.GONE else View.VISIBLE
+        updateView()
     }
 
     private fun clearTab() {
@@ -289,6 +205,7 @@ class LargeFileCleanActivity : BaseActivity<ActivityLargeFileCleanBinding>(Activ
                 binding.ivType.isSelected = true
                 binding.tvOtherThan.visibility = View.GONE
                 showTab(1, typeList)
+                viewModel.typePosition = 1
             }
 
             binding.llSize -> {
@@ -296,6 +213,7 @@ class LargeFileCleanActivity : BaseActivity<ActivityLargeFileCleanBinding>(Activ
                 binding.tvOtherThan.text = getString(R.string.larger_than)
                 binding.tvOtherThan.visibility = View.VISIBLE
                 showTab(2, sizeList)
+                viewModel.sizePosition = 2
             }
 
             binding.llTime -> {
@@ -303,8 +221,10 @@ class LargeFileCleanActivity : BaseActivity<ActivityLargeFileCleanBinding>(Activ
                 binding.tvOtherThan.text = getString(R.string.other_types)
                 binding.tvOtherThan.visibility = View.VISIBLE
                 showTab(3, timeList)
+                viewModel.timePosition = 3
             }
         }
+        filterData()
     }
 
     @SuppressLint("NotifyDataSetChanged")
@@ -340,19 +260,19 @@ class LargeFileCleanActivity : BaseActivity<ActivityLargeFileCleanBinding>(Activ
         binding.rvTab.layoutManager = LinearLayoutManager(this)
         binding.rvLargeFile.adapter = adapter
         binding.rvLargeFile.layoutManager = LinearLayoutManager(this)
-        initData()
+        viewModel.largeFileSize = 1024 * 1024 * 10
+        viewModel.loadFiles(this) {
+            adapter.setData(viewModel.getFilteredList())
+            updateView()
+            binding.rvLargeFile.visibility = if (viewModel.getFilteredList().isEmpty()) View.GONE else View.VISIBLE
+            binding.ivEmpty.visibility = if (viewModel.getFilteredList().isEmpty()) View.VISIBLE else View.GONE
+            binding.tvDelete.visibility = if (viewModel.getFilteredList().isEmpty()) View.GONE else View.VISIBLE
+        }
         showAdAnimation(LottieEnum.LARGE_FILE_LOTTIE) {
             AdsMgr.showNative(binding.flAd, R.layout.layout_admob_native_custom)
         }
     }
 
-    private fun initData() {
-        lifecycleScope.launch(Dispatchers.IO) {
-            allData = async { MediaUtils.findFiles(this@LargeFileCleanActivity, LARGE_FILE_SIZE) }.await()
-            launch(Dispatchers.Main) { filterData() }
-        }
-    }
-
     override fun initListener() {
         super.initListener()
         binding.ivBack.setOnClickListener { onBackPressedDispatcher.onBackPressed() }
@@ -369,14 +289,15 @@ class LargeFileCleanActivity : BaseActivity<ActivityLargeFileCleanBinding>(Activ
             hiddenTab()
         }
         binding.tvDelete.setOnClickListener {
-            if (total <= 0) return@setOnClickListener
+            if (viewModel.getFilteredList().isEmpty() || viewModel.getFilteredList().filter { it.isSelected }
+                    .sumOf { it.length } <= 0) return@setOnClickListener
             val dialog = ConfirmDialog(this)
             dialog.action = {
-                cleanFileBeans(list)
+                cleanFileBeans(viewModel.getFilteredList())
                 AdsMgr.showInsert(this, showCallBack = object : AdsShowCallBack() {
                     override fun next() {
                         CleanResultActivity.functionKey = LARGE_FILE_CLEAN
-                        CleanResultActivity.total = total
+                        CleanResultActivity.total = viewModel.getFilteredList().filter { it.isSelected }.sumOf { it.length }
                         CleanResultActivity.titleName = getString(R.string.large_file_clean)
                         goToAc(CleanResultActivity::class.java)
                     }

app/src/main/java/com/simplecleaner/app/ui/largefile/LargeFileCleanAdapter.kt

+package com.simplecleaner.app.ui.largefile
+
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import androidx.core.view.isVisible
+import androidx.recyclerview.widget.RecyclerView
+import com.bumptech.glide.Glide
+import com.bumptech.glide.load.resource.bitmap.CenterCrop
+import com.bumptech.glide.load.resource.bitmap.RoundedCorners
+import com.bumptech.glide.request.RequestOptions
+import com.simplecleaner.app.R
+import com.simplecleaner.app.bean.FileBean
+import com.simplecleaner.app.databinding.ItemLargeFileCleanBinding
+import com.simplecleaner.app.utils.MineTypeUtils
+import com.simplecleaner.app.utils.Utils
+
+class LargeFileCleanAdapter(
+    private var data: List<FileBean>,
+    private val onItemClick: (Int) -> Unit
+) : RecyclerView.Adapter<LargeFileCleanAdapter.ViewHolder>() {
+    inner class ViewHolder(val binding: ItemLargeFileCleanBinding) : RecyclerView.ViewHolder(binding.root) {
+        init {
+            binding.root.setOnClickListener {
+                val position = bindingAdapterPosition
+                if (position != RecyclerView.NO_POSITION) {
+                    onItemClick(position)
+                }
+            }
+        }
+    }
+
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
+        val binding = ItemLargeFileCleanBinding.inflate(LayoutInflater.from(parent.context), parent, false)
+        return ViewHolder(binding)
+    }
+
+    override fun getItemCount(): Int = data.size
+
+    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
+        val item = data[position]
+        holder.binding.ivVideo.isVisible = MineTypeUtils.isVideo(item.mineType)
+        if (MineTypeUtils.isImage(item.mineType) || MineTypeUtils.isVideo(item.mineType)) {
+            val round = holder.itemView.resources.getDimensionPixelSize(R.dimen.dp_4)
+            val options = RequestOptions().transform(CenterCrop(), RoundedCorners(round))
+            Glide.with(holder.itemView.context)
+                .load(item.path)
+                .apply(options)
+                .into(holder.binding.ivIcon)
+        } else if (MineTypeUtils.isAudio(item.mineType)) {
+            holder.binding.ivIcon.setImageResource(R.drawable.icon_yinping_large)
+        } else if (MineTypeUtils.isApk(item.mineType)) {
+            holder.binding.ivIcon.setImageResource(R.drawable.icon_app_large)
+        } else if (MineTypeUtils.isDoc(item.mineType)) {
+            holder.binding.ivIcon.setImageResource(R.drawable.icon_wenjianx_large)
+        } else {
+            holder.binding.ivIcon.setImageResource(R.drawable.icon_yingyong_large)
+        }
+        holder.binding.tvName.text = item.name
+        holder.binding.tvLength.text = Utils.getSizeFormat(item.length)
+        holder.binding.ivSelect.isSelected = item.isSelected
+        holder.binding.viewLine.visibility = if (position == itemCount - 1) View.GONE else View.VISIBLE
+    }
+
+    fun setData(newData: List<FileBean>) {
+        data = newData
+        notifyDataSetChanged()
+    }
+} 
\ No newline at end of file

app/src/main/java/com/simplecleaner/app/ui/largefile/LargeFileCleanViewModel.kt

+package com.simplecleaner.app.ui.largefile
+
+import android.content.Context
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import com.simplecleaner.app.bean.FileBean
+import com.simplecleaner.app.utils.MediaUtils
+import com.simplecleaner.app.utils.MineTypeUtils
+import java.util.Calendar
+
+class LargeFileCleanViewModel : ViewModel() {
+    private var allData: List<FileBean> = emptyList()
+    private var filteredList: List<FileBean> = emptyList()
+
+    var typePosition = 0
+    var sizePosition = 0
+    var timePosition = 0
+    var largeFileSize: Long = 1024 * 1024 * 10
+
+    fun loadFiles(context: Context, onLoaded: (() -> Unit)? = null) {
+        viewModelScope.launch(Dispatchers.IO) {
+            allData = MediaUtils.findFiles(context, largeFileSize)
+            filterData()
+            withContext(Dispatchers.Main) {
+                onLoaded?.invoke()
+            }
+        }
+    }
+
+    fun filterData() {
+        filteredList = filterType(allData, typePosition)
+            .let { filterSize(it, sizePosition) }
+            .let { filterTime(it, timePosition) }
+    }
+
+    fun getFilteredList(): List<FileBean> = filteredList
+
+    fun toggleSelect(position: Int) {
+        if (position in filteredList.indices) {
+            filteredList[position].isSelected = !filteredList[position].isSelected
+        }
+    }
+
+    private fun filterType(list: List<FileBean>, position: Int): List<FileBean> {
+        return when (position) {
+            1 -> list.filter { MineTypeUtils.isImage(it.mineType) }
+            2 -> list.filter { MineTypeUtils.isVideo(it.mineType) }
+            3 -> list.filter { MineTypeUtils.isAudio(it.mineType) }
+            4 -> list.filter { MineTypeUtils.isDoc(it.mineType) }
+            5 -> list.filter { MineTypeUtils.isApk(it.mineType) }
+            6 -> list.filterNot { file ->
+                MineTypeUtils.mineTypes.any { mimeType -> file.mineType.startsWith(mimeType) }
+            }
+            else -> list
+        }
+    }
+
+    private fun filterSize(list: List<FileBean>, position: Int): List<FileBean> {
+        return when (position) {
+            1 -> list.filter { it.length >= largeFileSize * 2 }
+            2 -> list.filter { it.length >= largeFileSize * 5 }
+            3 -> list.filter { it.length >= largeFileSize * 10 }
+            4 -> list.filter { it.length >= largeFileSize * 50 }
+            else -> list.filter { it.length >= largeFileSize }
+        }
+    }
+
+    private fun filterTime(list: List<FileBean>, position: Int): List<FileBean> {
+        return when (position) {
+            1 -> list.filter { it.lastModified > Calendar.getInstance().apply { add(Calendar.WEEK_OF_YEAR, -1) }.timeInMillis }
+            2 -> list.filter { it.lastModified > Calendar.getInstance().apply { add(Calendar.MONTH, -1) }.timeInMillis }
+            3 -> list.filter { it.lastModified > Calendar.getInstance().apply { add(Calendar.MONTH, -3) }.timeInMillis }
+            4 -> list.filter { it.lastModified > Calendar.getInstance().apply { add(Calendar.MONTH, -6) }.timeInMillis }
+            5 -> list.filter { it.lastModified > Calendar.getInstance().apply { add(Calendar.YEAR, -1) }.timeInMillis }
+            else -> list
+        }
+    }
+} 
\ No newline at end of file