Reformated all the code

2025-06-16 20:39:20 +00:00 · 2021-06-08 21:18:44 +05:30
parent 74e8287cf1
commit 29ef88853d
50 changed files with 6043 additions and 4857 deletions
--- a/src/main/kotlin/com/looker/droidify/database/CursorOwner.kt
+++ b/src/main/kotlin/com/looker/droidify/database/CursorOwner.kt
@ -7,95 +7,127 @@ import androidx.loader.app.LoaderManager
 import androidx.loader.content.Loader
 import com.looker.droidify.entity.ProductItem

-class CursorOwner: Fragment(), LoaderManager.LoaderCallbacks<Cursor> {
-  sealed class Request {
-    internal abstract val id: Int
+class CursorOwner : Fragment(), LoaderManager.LoaderCallbacks<Cursor> {
+    sealed class Request {
+        internal abstract val id: Int

-    data class ProductsAvailable(val searchQuery: String, val section: ProductItem.Section,
-      val order: ProductItem.Order): Request() {
-      override val id: Int
-        get() = 1
+        data class ProductsAvailable(
+            val searchQuery: String, val section: ProductItem.Section,
+            val order: ProductItem.Order
+        ) : Request() {
+            override val id: Int
+                get() = 1
+        }
+
+        data class ProductsInstalled(
+            val searchQuery: String, val section: ProductItem.Section,
+            val order: ProductItem.Order
+        ) : Request() {
+            override val id: Int
+                get() = 2
+        }
+
+        data class ProductsUpdates(
+            val searchQuery: String, val section: ProductItem.Section,
+            val order: ProductItem.Order
+        ) : Request() {
+            override val id: Int
+                get() = 3
+        }
+
+        object Repositories : Request() {
+            override val id: Int
+                get() = 4
+        }
    }

-    data class ProductsInstalled(val searchQuery: String, val section: ProductItem.Section,
-      val order: ProductItem.Order): Request() {
-      override val id: Int
-        get() = 2
+    interface Callback {
+        fun onCursorData(request: Request, cursor: Cursor?)
    }

-    data class ProductsUpdates(val searchQuery: String, val section: ProductItem.Section,
-      val order: ProductItem.Order): Request() {
-      override val id: Int
-        get() = 3
+    private data class ActiveRequest(
+        val request: Request,
+        val callback: Callback?,
+        val cursor: Cursor?
+    )
+
+    init {
+        retainInstance = true
    }

-    object Repositories: Request() {
-      override val id: Int
-        get() = 4
+    private val activeRequests = mutableMapOf<Int, ActiveRequest>()
+
+    fun attach(callback: Callback, request: Request) {
+        val oldActiveRequest = activeRequests[request.id]
+        if (oldActiveRequest?.callback != null &&
+            oldActiveRequest.callback != callback && oldActiveRequest.cursor != null
+        ) {
+            oldActiveRequest.callback.onCursorData(oldActiveRequest.request, null)
+        }
+        val cursor = if (oldActiveRequest?.request == request && oldActiveRequest.cursor != null) {
+            callback.onCursorData(request, oldActiveRequest.cursor)
+            oldActiveRequest.cursor
+        } else {
+            null
+        }
+        activeRequests[request.id] = ActiveRequest(request, callback, cursor)
+        if (cursor == null) {
+            LoaderManager.getInstance(this).restartLoader(request.id, null, this)
+        }
    }
-  }

-  interface Callback {
-    fun onCursorData(request: Request, cursor: Cursor?)
-  }
-
-  private data class ActiveRequest(val request: Request, val callback: Callback?, val cursor: Cursor?)
-
-  init {
-    retainInstance = true
-  }
-
-  private val activeRequests = mutableMapOf<Int, ActiveRequest>()
-
-  fun attach(callback: Callback, request: Request) {
-    val oldActiveRequest = activeRequests[request.id]
-    if (oldActiveRequest?.callback != null &&
-      oldActiveRequest.callback != callback && oldActiveRequest.cursor != null) {
-      oldActiveRequest.callback.onCursorData(oldActiveRequest.request, null)
+    fun detach(callback: Callback) {
+        for (id in activeRequests.keys) {
+            val activeRequest = activeRequests[id]!!
+            if (activeRequest.callback == callback) {
+                activeRequests[id] = activeRequest.copy(callback = null)
+            }
+        }
    }
-    val cursor = if (oldActiveRequest?.request == request && oldActiveRequest.cursor != null) {
-      callback.onCursorData(request, oldActiveRequest.cursor)
-      oldActiveRequest.cursor
-    } else {
-      null
-    }
-    activeRequests[request.id] = ActiveRequest(request, callback, cursor)
-    if (cursor == null) {
-      LoaderManager.getInstance(this).restartLoader(request.id, null, this)
-    }
-  }

-  fun detach(callback: Callback) {
-    for (id in activeRequests.keys) {
-      val activeRequest = activeRequests[id]!!
-      if (activeRequest.callback == callback) {
-        activeRequests[id] = activeRequest.copy(callback = null)
-      }
+    override fun onCreateLoader(id: Int, args: Bundle?): Loader<Cursor> {
+        val request = activeRequests[id]!!.request
+        return QueryLoader(requireContext()) {
+            when (request) {
+                is Request.ProductsAvailable -> Database.ProductAdapter
+                    .query(
+                        installed = false,
+                        updates = false,
+                        searchQuery = request.searchQuery,
+                        section = request.section,
+                        order = request.order,
+                        signal = it
+                    )
+                is Request.ProductsInstalled -> Database.ProductAdapter
+                    .query(
+                        installed = true,
+                        updates = false,
+                        searchQuery = request.searchQuery,
+                        section = request.section,
+                        order = request.order,
+                        signal = it
+                    )
+                is Request.ProductsUpdates -> Database.ProductAdapter
+                    .query(
+                        installed = true,
+                        updates = true,
+                        searchQuery = request.searchQuery,
+                        section = request.section,
+                        order = request.order,
+                        signal = it
+                    )
+                is Request.Repositories -> Database.RepositoryAdapter.query(it)
+            }
+        }
    }
-  }

-  override fun onCreateLoader(id: Int, args: Bundle?): Loader<Cursor> {
-    val request = activeRequests[id]!!.request
-    return QueryLoader(requireContext()) {
-      when (request) {
-        is Request.ProductsAvailable -> Database.ProductAdapter
-          .query(false, false, request.searchQuery, request.section, request.order, it)
-        is Request.ProductsInstalled -> Database.ProductAdapter
-          .query(true, false, request.searchQuery, request.section, request.order, it)
-        is Request.ProductsUpdates -> Database.ProductAdapter
-          .query(true, true, request.searchQuery, request.section, request.order, it)
-        is Request.Repositories -> Database.RepositoryAdapter.query(it)
-      }
+    override fun onLoadFinished(loader: Loader<Cursor>, data: Cursor?) {
+        val activeRequest = activeRequests[loader.id]
+        if (activeRequest != null) {
+            activeRequests[loader.id] = activeRequest.copy(cursor = data)
+            activeRequest.callback?.onCursorData(activeRequest.request, data)
+        }
    }
-  }

-  override fun onLoadFinished(loader: Loader<Cursor>, data: Cursor?) {
-    val activeRequest = activeRequests[loader.id]
-    if (activeRequest != null) {
-      activeRequests[loader.id] = activeRequest.copy(cursor = data)
-      activeRequest.callback?.onCursorData(activeRequest.request, data)
-    }
-  }
-
-  override fun onLoaderReset(loader: Loader<Cursor>) = onLoadFinished(loader, null)
+    override fun onLoaderReset(loader: Loader<Cursor>) = onLoadFinished(loader, null)
 }
--- a/src/main/kotlin/com/looker/droidify/database/Database.kt
+++ b/src/main/kotlin/com/looker/droidify/database/Database.kt
--- a/src/main/kotlin/com/looker/droidify/database/ObservableCursor.kt
+++ b/src/main/kotlin/com/looker/droidify/database/ObservableCursor.kt
@ -5,53 +5,57 @@ import android.database.ContentObserver
 import android.database.Cursor
 import android.database.CursorWrapper

-class ObservableCursor(cursor: Cursor, private val observable: (register: Boolean,
-  observer: () -> Unit) -> Unit): CursorWrapper(cursor) {
-  private var registered = false
-  private val contentObservable = ContentObservable()
+class ObservableCursor(
+    cursor: Cursor, private val observable: (
+        register: Boolean,
+        observer: () -> Unit
+    ) -> Unit
+) : CursorWrapper(cursor) {
+    private var registered = false
+    private val contentObservable = ContentObservable()

-  private val onChange: () -> Unit = {
-    contentObservable.dispatchChange(false, null)
-  }
-
-  init {
-    observable(true, onChange)
-    registered = true
-  }
-
-  override fun registerContentObserver(observer: ContentObserver) {
-    super.registerContentObserver(observer)
-    contentObservable.registerObserver(observer)
-  }
-
-  override fun unregisterContentObserver(observer: ContentObserver) {
-    super.unregisterContentObserver(observer)
-    contentObservable.unregisterObserver(observer)
-  }
-
-  @Suppress("DEPRECATION")
-  override fun requery(): Boolean {
-    if (!registered) {
-      observable(true, onChange)
-      registered = true
+    private val onChange: () -> Unit = {
+        contentObservable.dispatchChange(false, null)
    }
-    return super.requery()
-  }

-  @Suppress("DEPRECATION")
-  override fun deactivate() {
-    super.deactivate()
-    deactivateOrClose()
-  }
+    init {
+        observable(true, onChange)
+        registered = true
+    }

-  override fun close() {
-    super.close()
-    contentObservable.unregisterAll()
-    deactivateOrClose()
-  }
+    override fun registerContentObserver(observer: ContentObserver) {
+        super.registerContentObserver(observer)
+        contentObservable.registerObserver(observer)
+    }

-  private fun deactivateOrClose() {
-    observable(false, onChange)
-    registered = false
-  }
+    override fun unregisterContentObserver(observer: ContentObserver) {
+        super.unregisterContentObserver(observer)
+        contentObservable.unregisterObserver(observer)
+    }
+
+    @Suppress("DEPRECATION")
+    override fun requery(): Boolean {
+        if (!registered) {
+            observable(true, onChange)
+            registered = true
+        }
+        return super.requery()
+    }
+
+    @Suppress("DEPRECATION")
+    override fun deactivate() {
+        super.deactivate()
+        deactivateOrClose()
+    }
+
+    override fun close() {
+        super.close()
+        contentObservable.unregisterAll()
+        deactivateOrClose()
+    }
+
+    private fun deactivateOrClose() {
+        observable(false, onChange)
+        registered = false
+    }
 }
--- a/src/main/kotlin/com/looker/droidify/database/QueryBuilder.kt
+++ b/src/main/kotlin/com/looker/droidify/database/QueryBuilder.kt
@ -4,8 +4,8 @@ import android.database.Cursor
 import android.database.sqlite.SQLiteDatabase
 import android.os.CancellationSignal
 import com.looker.droidify.BuildConfig
-import com.looker.droidify.utility.extension.android.*
-import com.looker.droidify.utility.extension.text.*
+import com.looker.droidify.utility.extension.android.asSequence
+import com.looker.droidify.utility.extension.text.debug

 class QueryBuilder {
  companion object {
--- a/src/main/kotlin/com/looker/droidify/database/QueryLoader.kt
+++ b/src/main/kotlin/com/looker/droidify/database/QueryLoader.kt
@ -6,89 +6,89 @@ import android.os.CancellationSignal
 import android.os.OperationCanceledException
 import androidx.loader.content.AsyncTaskLoader

-class QueryLoader(context: Context, private val query: (CancellationSignal) -> Cursor?):
-  AsyncTaskLoader<Cursor>(context) {
-  private val observer = ForceLoadContentObserver()
-  private var cancellationSignal: CancellationSignal? = null
-  private var cursor: Cursor? = null
+class QueryLoader(context: Context, private val query: (CancellationSignal) -> Cursor?) :
+    AsyncTaskLoader<Cursor>(context) {
+    private val observer = ForceLoadContentObserver()
+    private var cancellationSignal: CancellationSignal? = null
+    private var cursor: Cursor? = null

-  override fun loadInBackground(): Cursor? {
-    val cancellationSignal = synchronized(this) {
-      if (isLoadInBackgroundCanceled) {
-        throw OperationCanceledException()
-      }
-      val cancellationSignal = CancellationSignal()
-      this.cancellationSignal = cancellationSignal
-      cancellationSignal
-    }
-    try {
-      val cursor = query(cancellationSignal)
-      if (cursor != null) {
-        try {
-          cursor.count // Ensure the cursor window is filled
-          cursor.registerContentObserver(observer)
-        } catch (e: Exception) {
-          cursor.close()
-          throw e
+    override fun loadInBackground(): Cursor? {
+        val cancellationSignal = synchronized(this) {
+            if (isLoadInBackgroundCanceled) {
+                throw OperationCanceledException()
+            }
+            val cancellationSignal = CancellationSignal()
+            this.cancellationSignal = cancellationSignal
+            cancellationSignal
+        }
+        try {
+            val cursor = query(cancellationSignal)
+            if (cursor != null) {
+                try {
+                    cursor.count // Ensure the cursor window is filled
+                    cursor.registerContentObserver(observer)
+                } catch (e: Exception) {
+                    cursor.close()
+                    throw e
+                }
+            }
+            return cursor
+        } finally {
+            synchronized(this) {
+                this.cancellationSignal = null
+            }
        }
-      }
-      return cursor
-    } finally {
-      synchronized(this) {
-        this.cancellationSignal = null
-      }
    }
-  }

-  override fun cancelLoadInBackground() {
-    super.cancelLoadInBackground()
+    override fun cancelLoadInBackground() {
+        super.cancelLoadInBackground()

-    synchronized(this) {
-      cancellationSignal?.cancel()
+        synchronized(this) {
+            cancellationSignal?.cancel()
+        }
    }
-  }

-  override fun deliverResult(data: Cursor?) {
-    if (isReset) {
-      data?.close()
-    } else {
-      val oldCursor = cursor
-      cursor = data
-      if (isStarted) {
-        super.deliverResult(data)
-      }
-      if (oldCursor != data) {
-        oldCursor.closeIfNeeded()
-      }
+    override fun deliverResult(data: Cursor?) {
+        if (isReset) {
+            data?.close()
+        } else {
+            val oldCursor = cursor
+            cursor = data
+            if (isStarted) {
+                super.deliverResult(data)
+            }
+            if (oldCursor != data) {
+                oldCursor.closeIfNeeded()
+            }
+        }
    }
-  }

-  override fun onStartLoading() {
-    cursor?.let(this::deliverResult)
-    if (takeContentChanged() || cursor == null) {
-      forceLoad()
+    override fun onStartLoading() {
+        cursor?.let(this::deliverResult)
+        if (takeContentChanged() || cursor == null) {
+            forceLoad()
+        }
    }
-  }

-  override fun onStopLoading() {
-    cancelLoad()
-  }
-
-  override fun onCanceled(data: Cursor?) {
-    data.closeIfNeeded()
-  }
-
-  override fun onReset() {
-    super.onReset()
-
-    stopLoading()
-    cursor.closeIfNeeded()
-    cursor = null
-  }
-
-  private fun Cursor?.closeIfNeeded() {
-    if (this != null && !isClosed) {
-      close()
+    override fun onStopLoading() {
+        cancelLoad()
+    }
+
+    override fun onCanceled(data: Cursor?) {
+        data.closeIfNeeded()
+    }
+
+    override fun onReset() {
+        super.onReset()
+
+        stopLoading()
+        cursor.closeIfNeeded()
+        cursor = null
+    }
+
+    private fun Cursor?.closeIfNeeded() {
+        if (this != null && !isClosed) {
+            close()
+        }
    }
-  }
 }