Merge pull request #126 from AnyGogin31/feature/project-reimagining

Feature/project reimagining

app/build.gradle.kts

@@ -0,0 +1,36 @@
+plugins {
+    alias(libs.plugins.neilt.application.android)
+}
+
+apply(from = "../scripts/git-hooks.gradle.kts")
+
+kotlin {
+    sourceSets {
+        val desktopMain by getting
+
+        androidMain.dependencies {
+            implementation(libs.android.activity)
+            implementation(libs.koin.android)
+            implementation(projects.features.auth)
+        }
+
+        commonMain.dependencies {
+            implementation(libs.coil.compose)
+            implementation(projects.shared)
+        }
+
+        desktopMain.dependencies {
+            implementation(compose.desktop.currentOs)
+        }
+    }
+}
+
+android {
+    namespace = "neilt.mobile.pixiv.app"
+}
+
+compose.desktop {
+    application {
+        mainClass = "neilt.mobile.pixiv.MainKt"
+    }
+}

core/desingsystem/src/commonMain/kotlin/neilt/mobile/pixiv/desingsystem/icons/PixivIcons.kt → app/src/desktopMain/kotlin/neilt/mobile/pixiv/Main.kt

@@ -22,17 +22,16 @@
  * SOFTWARE.
  */
 
-package neilt.mobile.pixiv.desingsystem.icons
+package neilt.mobile.pixiv
 
-import androidx.compose.ui.graphics.Brush
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.SolidColor
+import androidx.compose.ui.window.application
+import neilt.mobile.pixiv.shared.MainView
+import neilt.mobile.pixiv.shared.di.pixivModules
+import org.koin.core.context.startKoin
 
-object PixivIcons {
-    object Filled
-    object Outlined
-}
-
-internal object PixivIconDefaults {
-    val PathFillBrush: Brush = SolidColor(Color.Gray)
+fun main() = application {
+    startKoin {
+        modules(pixivModules)
+    }
+    MainView()
 }

app/src/iosMain/kotlin/neilt/mobile/pixiv/MainViewController.kt

@@ -0,0 +1,29 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2024 AnyGogin31
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package neilt.mobile.pixiv
+
+import neilt.mobile.pixiv.shared.MainView
+
+fun MainViewController() = MainView()

build-logic/build.gradle.kts

@@ -31,13 +31,13 @@ plugins {
 group = "neilt.mobile.convention"
 
 java {
-    sourceCompatibility = JavaVersion.VERSION_17
-    targetCompatibility = JavaVersion.VERSION_17
+    sourceCompatibility = JavaVersion.VERSION_11
+    targetCompatibility = JavaVersion.VERSION_11
 }
 
 kotlin {
     compilerOptions {
-        jvmTarget = JvmTarget.JVM_17
+        jvmTarget = JvmTarget.JVM_11
     }
 }
 
@@ -51,25 +51,24 @@ dependencies {
     compileOnly(libs.kotlin.compose.gradlePlugin)
 
     // Static Analyzer
-    compileOnly(libs.detekt.gradlePlugin)
     compileOnly(libs.ktlint.gradlePlugin)
 }
 
 gradlePlugin {
     plugins {
-        register("neiltApplicationAndroid") {
-            id = "neilt.application.android"
-            implementationClass = "NeIltApplicationAndroid"
+        register("neiltMultiplatformApplication") {
+            id = "neilt.multiplatform.application"
+            implementationClass = "NeIltMultiplatformApplicationPlugin"
         }
 
         register("neiltMultiplatformCompose") {
             id = "neilt.multiplatform.compose"
             implementationClass = "NeIltMultiplatformComposePlugin"
         }
 
-        register("neiltMultiplatform") {
-            id = "neilt.multiplatform"
-            implementationClass = "NeIltMultiplatformPlugin"
+        register("neiltMultiplatformLibrary") {
+            id = "neilt.multiplatform.library"
+            implementationClass = "NeIltMultiplatformLibraryPlugin"
         }
     }
 }

build-logic/src/main/java/NeIltApplicationAndroid.kt → build-logic/src/main/java/NeIltMultiplatformApplicationPlugin.kt

@@ -23,26 +23,22 @@
  */
 
 import com.android.build.api.dsl.ApplicationExtension
-import neilt.mobile.convention.configureApplicationAndroid
-import neilt.mobile.convention.configureComposeAndroid
-import neilt.mobile.convention.configureKotlinAndroid
+import neilt.mobile.convention.configureApplicationMultiplatform
+import neilt.mobile.convention.configureComposeMultiplatform
+import neilt.mobile.convention.configureKotlinMultiplatform
 import neilt.mobile.convention.extensions.getPlugin
 import neilt.mobile.convention.extensions.libs
 import org.gradle.api.Project
-import org.gradle.api.provider.Provider
 import org.gradle.kotlin.dsl.configure
-import org.gradle.plugin.use.PluginDependency
-
-class NeIltApplicationAndroid : NeIltPlugin() {
-    override val plugin: (target: Project) -> Provider<PluginDependency> = { target: Project ->
-        target.libs.getPlugin("android-application")
-    }
 
+class NeIltMultiplatformApplicationPlugin : NeIltPlugin() {
     override fun Project.configureProject() {
+        pluginManager.apply(libs.getPlugin("android-application").get().pluginId)
+
         extensions.configure<ApplicationExtension> {
-            configureApplicationAndroid(this)
-            configureKotlinAndroid(this)
-            configureComposeAndroid(this)
+            configureApplicationMultiplatform(this)
+            configureKotlinMultiplatform(this)
+            configureComposeMultiplatform(this)
         }
     }
 }

build-logic/src/main/java/NeIltMultiplatformComposePlugin.kt

@@ -25,22 +25,20 @@
 import com.android.build.api.dsl.LibraryExtension
 import neilt.mobile.convention.configureComposeMultiplatform
 import neilt.mobile.convention.configureKotlinMultiplatform
+import neilt.mobile.convention.configureLibraryMultiplatform
 import neilt.mobile.convention.extensions.getPlugin
 import neilt.mobile.convention.extensions.libs
 import org.gradle.api.Project
-import org.gradle.api.provider.Provider
 import org.gradle.kotlin.dsl.configure
-import org.gradle.plugin.use.PluginDependency
 
 class NeIltMultiplatformComposePlugin : NeIltPlugin() {
-    override val plugin: (target: Project) -> Provider<PluginDependency> = { target: Project ->
-        target.libs.getPlugin("android-library")
-    }
-
     override fun Project.configureProject() {
+        pluginManager.apply(libs.getPlugin("android-library").get().pluginId)
+
         extensions.configure<LibraryExtension> {
             configureKotlinMultiplatform(this)
             configureComposeMultiplatform(this)
+            configureLibraryMultiplatform()
         }
     }
 }

build-logic/src/main/java/NeIltMultiplatformPlugin.kt → build-logic/src/main/java/NeIltMultiplatformLibraryPlugin.kt

@@ -24,21 +24,19 @@
 
 import com.android.build.api.dsl.LibraryExtension
 import neilt.mobile.convention.configureKotlinMultiplatform
+import neilt.mobile.convention.configureLibraryMultiplatform
 import neilt.mobile.convention.extensions.getPlugin
 import neilt.mobile.convention.extensions.libs
 import org.gradle.api.Project
-import org.gradle.api.provider.Provider
 import org.gradle.kotlin.dsl.configure
-import org.gradle.plugin.use.PluginDependency
-
-class NeIltMultiplatformPlugin : NeIltPlugin() {
-    override val plugin: (target: Project) -> Provider<PluginDependency> = { target: Project ->
-        target.libs.getPlugin("android-library")
-    }
 
+class NeIltMultiplatformLibraryPlugin : NeIltPlugin() {
     override fun Project.configureProject() {
+        pluginManager.apply(libs.getPlugin("android-library").get().pluginId)
+
         extensions.configure<LibraryExtension> {
             configureKotlinMultiplatform(this)
+            configureLibraryMultiplatform()
         }
     }
 }

build-logic/src/main/java/NeIltPlugin.kt

@@ -22,28 +22,17 @@
  * SOFTWARE.
  */
 
-import neilt.mobile.convention.configureDetekt
 import neilt.mobile.convention.configureKtlint
 import org.gradle.api.Plugin
 import org.gradle.api.Project
-import org.gradle.api.provider.Provider
-import org.gradle.plugin.use.PluginDependency
 
 abstract class NeIltPlugin : Plugin<Project> {
-    protected abstract val plugin: (target: Project) -> Provider<PluginDependency>
-
     override fun apply(target: Project) {
         with(target) {
-            configurePlugin()
             configureKtlint()
-            configureDetekt()
             configureProject()
         }
     }
 
     protected abstract fun Project.configureProject()
-
-    private fun Project.configurePlugin() {
-        pluginManager.apply(plugin(this).get().pluginId)
-    }
 }

build-logic/src/main/java/neilt/mobile/convention/Configuration.kt

@@ -27,22 +27,13 @@ package neilt.mobile.convention
 import org.gradle.api.JavaVersion
 import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 
-object Configuration {
+internal object Configuration {
 
-    object Java {
-        val JAVA_TARGET = JvmTarget.JVM_17
-        val JAVA_VERSION = JavaVersion.VERSION_17
-    }
+    val JAVA_TARGET = JvmTarget.JVM_11
+    val JAVA_VERSION = JavaVersion.VERSION_11
 
-    object Sdk {
-        const val COMPILE_SDK = 35
-        const val TARGET_SDK = 35
-        const val MIN_SDK = 24
-    }
-
-    object App {
-        const val APPLICATION_ID = "neilt.mobile.pixiv"
-        const val VERSION_NAME = "1.2.0"
-        const val VERSION_CODE = 10
-    }
+    const val APPLICATION_ID = "neilt.mobile.pixiv"
 }
+
+//const val VERSION_NAME = "1.2.0"
+//const val VERSION_CODE = 10

build-logic/src/main/java/neilt/mobile/convention/NeIltApplication.kt

@@ -25,23 +25,34 @@
 package neilt.mobile.convention
 
 import com.android.build.api.dsl.ApplicationExtension
+import neilt.mobile.convention.extensions.compose
+import neilt.mobile.convention.extensions.desktop
+import neilt.mobile.convention.extensions.getPlugin
+import neilt.mobile.convention.extensions.getVersion
+import neilt.mobile.convention.extensions.libs
 import org.gradle.api.Project
+import org.jetbrains.compose.desktop.application.dsl.TargetFormat
 
-internal fun Project.configureApplicationAndroid(
+internal fun Project.configureApplicationMultiplatform(
+    applicationExtension: ApplicationExtension,
+) {
+    pluginManager.apply(libs.getPlugin("kotlin-compose").get().pluginId)
+
+    configureApplicationAndroid(applicationExtension)
+    configureApplicationDesktop()
+}
+
+private fun Project.configureApplicationAndroid(
     applicationExtension: ApplicationExtension,
 ) {
     applicationExtension.apply {
         defaultConfig {
-            applicationId = Configuration.App.APPLICATION_ID
-
-            targetSdk = Configuration.Sdk.TARGET_SDK
+            applicationId = Configuration.APPLICATION_ID
 
-            versionName = Configuration.App.VERSION_NAME
-            versionCode = Configuration.App.VERSION_CODE
+            targetSdk = libs.getVersion("android-targetSdk").toString().toInt()
 
-            vectorDrawables {
-                useSupportLibrary = true
-            }
+            versionName = libs.getVersion("version-name").toString()
+            versionCode = libs.getVersion("version-code").toString().toInt()
         }
 
         signingConfigs {
@@ -76,5 +87,21 @@ internal fun Project.configureApplicationAndroid(
                 )
             }
         }
+
+        packaging {
+            resources {
+                excludes += "/META-INF/{AL2.0,LGPL2.1}"
+            }
+        }
+    }
+}
+
+private fun Project.configureApplicationDesktop() {
+    compose.desktop.application {
+        nativeDistributions {
+            targetFormats(TargetFormat.Dmg, TargetFormat.Msi, TargetFormat.Deb)
+            packageName = Configuration.APPLICATION_ID
+            packageVersion = libs.getVersion("version-name").toString()
+        }
     }
 }