code improvements

.github/workflows/build-gradle-project.yml

@@ -38,7 +38,7 @@ jobs:
       - name: Prepare Version Number
         id: prepare_version
         run: |
-          export GRADLE_PATH="./config/version.prop";
+          export GRADLE_PATH="./config/version.app.prop";
           export GRADLE_FIELD_VMAJ="majorVersion"
           export GRADLE_FIELD_VMIN="minorVersion"
           export GRADLE_FIELD_VPAT="patchVersion"
@@ -54,7 +54,7 @@ jobs:
 # build apk for release
       - name: Build Release APK
         id: build_release_apk
-        run: ./gradlew assembleRelease
+        run: ./gradlew clean assembleRelease
 # publish github release
       - name: Create Release
         id: release

app/build.gradle.kts

@@ -11,14 +11,8 @@ plugins {
 }
 
 appConfig {
+    namespace = "org.mjdev.tvapp"
     description = "Smart TV android app for any android device"
-    autoCorrectCode = true
-    createDocumentation = true
-    createReleaseNotes = true
-    createZipRelease = true
-    // todo
-    createWebApp = true
-    // todo
     createWebSiteFromGit = false
     // todo
     default {

buildSrc/src/main/kotlin/org/mjdev/gradle/base/BaseTask.kt

@@ -21,7 +21,9 @@ import org.mjdev.gradle.extensions.applicationId
 import org.mjdev.gradle.extensions.buildDirectory
 import org.mjdev.gradle.extensions.capitalize
 import org.mjdev.gradle.extensions.file
+import org.mjdev.gradle.extensions.hasAssembleTask
 import org.mjdev.gradle.extensions.println
+import org.mjdev.gradle.extensions.runAfterCleanTask
 import java.net.URL
 
 abstract class BaseTask : DefaultTask() {
@@ -29,12 +31,12 @@ abstract class BaseTask : DefaultTask() {
     @Internal
     lateinit var variant: ApplicationVariant
 
+    @get:Internal
     val variantName: String
-        @Internal
         get() = variant.name.capitalize()
 
+    @get:Internal
     val javaCompiledClasses: URL
-        @Internal
         get() = variant
             .javaCompileProvider
             .get()
@@ -47,8 +49,8 @@ abstract class BaseTask : DefaultTask() {
             .toURI()
             .toURL()
 
+    @get:Internal
     val kotlinCompiledClasses: URL
-        @Internal
         get() = project.buildDirectory
             .file("tmp")
             .file("kotlin-classes")
@@ -60,8 +62,8 @@ abstract class BaseTask : DefaultTask() {
             .toURI()
             .toURL()
 
+    @get:Internal
     val restDependencies
-        @Internal
         get() = variant
             .getCompileClasspath(null)
             .files
@@ -69,18 +71,29 @@ abstract class BaseTask : DefaultTask() {
                 it.toURI().toURL()
             }.toTypedArray()
 
+    @get:Internal
     val kotlinCompileTask
-        @Internal
         get() = project.tasks
             .findByName("compile${variant.name.capitalize()}Kotlin") as? SourceTask
 
+    @get:Internal
+    val isAssembleTask
+        get() = hasAssembleTask
+
+    init {
+        runAfterCleanTask()
+    }
+
     @TaskAction
     fun taskAction() {
-        if (enabled) {
-            doTask()
+        when (isAssembleTask) {
+            true -> onAssemble()
+            false -> onClean()
         }
     }
 
-    abstract fun doTask()
+    abstract fun onClean()
+
+    abstract fun onAssemble()
 
 }

buildSrc/src/main/kotlin/org/mjdev/gradle/tasks/TestCaseGeneratorTask.kt → buildSrc/src/main/kotlin/org/mjdev/gradle/custom/TestCaseGeneratorTask.kt

@@ -6,7 +6,7 @@
  *  w: https://mjdev.org
  */
 
-package org.mjdev.gradle.tasks
+package org.mjdev.gradle.custom
 
 import org.mjdev.gradle.base.BaseTask
 import org.mjdev.gradle.custom.unittest.Worker

buildSrc/src/main/kotlin/org/mjdev/gradle/custom/icons/LauncherIconTask.kt

@@ -41,7 +41,7 @@ open class LauncherIconTask : BaseTask() {
         description = "Generate icon due application variant"
     }
 
-    override fun doTask() {
+    fun doTask() {
         if (filters.isEmpty()) return
         val names = HashSet<String>().apply {
             iconNames.forEach { add(it) }
@@ -91,4 +91,12 @@ open class LauncherIconTask : BaseTask() {
         }
     }
 
+    override fun onClean() {
+        TODO("Not yet implemented")
+    }
+
+    override fun onAssemble() {
+        TODO("Not yet implemented")
+    }
+
 }

buildSrc/src/main/kotlin/org/mjdev/gradle/extensions/ApplicationExtensionExt.kt

@@ -6,15 +6,12 @@
  *  w: https://mjdev.org
  */
 
-@file:Suppress("unused")
-
 package org.mjdev.gradle.extensions
 
 import com.android.build.api.dsl.ApplicationExtension
 import org.gradle.api.Project
 import java.io.FileInputStream
 import java.util.*
-import kotlin.String
 import org.mjdev.gradle.custom.SigningsScope
 
 fun ApplicationExtension.setSigningConfigs(
@@ -24,41 +21,41 @@ fun ApplicationExtension.setSigningConfigs(
 ) = signingConfigs {
     config.invoke(scope)
     create("release") {
-        val rootProject = project.rootProject
-        val keystorePropertiesFile = rootProject.file(scope.releaseKeyFile)
-        if (!keystorePropertiesFile.exists()) {
-            System.err.println("📜 Missing release.signing.properties file for release signing")
-        } else {
-            val keystoreProperties = Properties().apply {
-                load(FileInputStream(keystorePropertiesFile))
-            }
+        val keystorePropertiesFile = project.rootDir.resolve(scope.releaseKeyFile)
+        if (keystorePropertiesFile.exists()) {
             try {
-                storeFile = rootProject.file(keystoreProperties["storeFile"] as String)
-                storePassword = keystoreProperties["storePassword"] as String
-                keyAlias = keystoreProperties["keyAlias"] as String
-                keyPassword = keystoreProperties["keyPassword"] as String
+                val properties = Properties().apply {
+                    load(FileInputStream(keystorePropertiesFile))
+                }
+                storeFile = project.rootDir.resolve(properties["storeFile"].toString())
+                storePassword = properties["storePassword"].toString()
+                keyAlias = properties["keyAlias"].toString()
+                keyPassword = properties["keyPassword"].toString()
             } catch (e: Exception) {
-                System.err.println("📜 release.signing.properties file is malformed")
+                System.err.println("> File $keystorePropertiesFile is malformed or error.")
+                System.err.println("> ${e.message}.")
             }
+        } else {
+            System.err.println("> Missing $keystorePropertiesFile file for release signing.")
         }
     }
     getByName("debug") {
-        val rootProject = project.rootProject
-        val keystorePropertiesFile = rootProject.file(scope.debugKeyFile)
-        if (!keystorePropertiesFile.exists()) {
-            System.err.println("📜 Missing release.signing.properties file for release signing")
-        } else {
-            val keystoreProperties = Properties().apply {
-                load(FileInputStream(keystorePropertiesFile))
-            }
+        val keystorePropertiesFile = project.rootDir.resolve(scope.debugKeyFile)
+        if (keystorePropertiesFile.exists()) {
             try {
-                storeFile = rootProject.file(keystoreProperties["storeFile"] as String)
-                storePassword = keystoreProperties["storePassword"] as String
-                keyAlias = keystoreProperties["keyAlias"] as String
-                keyPassword = keystoreProperties["keyPassword"] as String
+                val properties = Properties().apply {
+                    load(FileInputStream(keystorePropertiesFile))
+                }
+                storeFile = project.rootDir.resolve(properties["storeFile"].toString())
+                storePassword = properties["storePassword"].toString()
+                keyAlias = properties["keyAlias"].toString()
+                keyPassword = properties["keyPassword"].toString()
             } catch (e: Exception) {
-                System.err.println("📜 release.signing.properties file is malformed")
+                System.err.println("> File $keystorePropertiesFile is malformed or error.")
+                System.err.println("> ${e.message}.")
             }
+        } else {
+            System.err.println("> Missing $keystorePropertiesFile file for release signing.")
         }
     }
 }

buildSrc/src/main/kotlin/org/mjdev/gradle/extensions/HashMapExt.kt

@@ -8,18 +8,43 @@
 
 package org.mjdev.gradle.extensions
 
-@Suppress("unused")
-fun <T, V> HashMap<T, V>.onKeyExists(
-    key: T,
-    block: ((key: T, value: V?) -> (Unit))
-) {
-    if (this.containsKey(key)) {
-        block.invoke(key, this[key])
-    }
-}
+import java.lang.reflect.Modifier
+
+//@Suppress("unused")
+//fun <T, V> HashMap<T, V>.onKeyExists(
+//    key: T,
+//    block: ((key: T, value: V?) -> (Unit))
+//) {
+//    if (this.containsKey(key)) {
+//        block.invoke(key, this[key])
+//    }
+//}
 
-fun <K, V> Map<K, V>.mapToString(): String = map { kv ->
+fun <K, V> Map<K, V>.mapToString(
+    separator: String = ": ",
+    quoteFirst: Boolean = true,
+    quoteSecond: Boolean = true,
+    prefix: String = "\t",
+    suffix: String = ",",
+): String = map { kv ->
     val sdKey = kv.key.toString().replace("\"", "")
     val sdValue = kv.value.toString().replace("\"", "")
-    "\t\"$sdKey\": \"$sdValue\""
-}.joinToString(",\n") + "\n"
+    val qf = if (quoteFirst) "\"" else ""
+    val qs = if (quoteSecond) "\"" else ""
+    "$prefix$qf$sdKey$qf$separator$qs$sdValue$qs"
+}.joinToString("$suffix\n") + "\n"
+
+inline fun <reified T : Any> T.toHashMap(): Map<Any, Any> = mutableMapOf<Any, Any>().apply {
+    val fields = T::class.java.declaredFields.filter {
+        !Modifier.isStatic(it.modifiers)
+    }.onEach {
+        it.trySetAccessible()
+    }
+    fields.forEach { field ->
+        if (field.name.lowercase() != "companion") {
+            val key = field.name
+            val value = field.get(this@toHashMap)
+            put(key, value)
+        }
+    }
+}

buildSrc/src/main/kotlin/org/mjdev/gradle/extensions/OtherExt.kt

@@ -0,0 +1,89 @@
+/*
+ *  Copyright (c) Milan Jurkulák 2024.
+ *  Contact:
+ *  e: mimoccc@gmail.com
+ *  e: mj@mjdev.org
+ *  w: https://mjdev.org
+ */
+
+package org.mjdev.gradle.extensions
+
+import org.gradle.api.Project
+import java.lang.reflect.Modifier
+import java.util.Locale
+
+inline fun <reified T> Project.fromBuildPropertiesFile(
+    config: T,
+    configPropertiesFile: String
+) {
+    val props = project.loadBuildPropertiesFile(configPropertiesFile, false)
+    val members = T::class.java.declaredFields.filter {
+        !Modifier.isStatic(it.modifiers)
+    }.onEach {
+        it.trySetAccessible()
+    }
+    props.forEach { prop ->
+        members.firstOrNull { field ->
+            prop.key == field.name
+        }?.apply {
+            val value = prop.value.cast(this.type)
+            try {
+                set(config, value)
+            } catch (e: Exception) {
+                println("> Error set: $name[$type] = $value, ${e.message}")
+            }
+        }
+    }
+}
+
+fun <T : Any> T.cast(type: Class<*>?): Any? = when (type?.simpleName?.lowercase()) {
+    "string" -> this.toString()
+    "int" -> parseInt(this)
+    "long" -> parseLong(this)
+    "boolean" -> parseBoolean(this)
+    "double" -> parseDouble(this)
+    else -> {
+        println("> Cast missing for type: ${type?.simpleName}")
+        null
+    }
+}
+
+fun parseBoolean(value: Any): Boolean? = when (value) {
+    is Boolean -> value
+    is CharSequence ->
+        when (value.toString().lowercase(Locale.US)) {
+            "true" -> true
+            "false" -> false
+            else -> null
+        }
+
+    is Number ->
+        when (value.toInt()) {
+            0 -> false
+            1 -> true
+            else -> null
+        }
+
+    else -> null
+}
+
+fun parseInt(value: Any): Int? = when (value) {
+    is Int -> value
+    is CharSequence -> value.toString().toIntOrNull()
+    is Number -> value.toInt()
+    else -> null
+}
+
+fun parseLong(value: Any): Long? = when (value) {
+    is Long -> value
+    is CharSequence -> value.toString().toLongOrNull()
+    is Number -> value.toLong()
+    else -> null
+}
+
+fun parseDouble(value: Any): Double? = when (value) {
+    is Double -> value
+    is CharSequence -> value.toString().toDoubleOrNull()
+    is Number -> value.toDouble()
+    else -> null
+}

buildSrc/src/main/kotlin/org/mjdev/gradle/extensions/ProjectExt.kt

@@ -24,6 +24,7 @@ import org.gradle.api.Project
 import org.gradle.api.Task
 import org.gradle.api.logging.Logger
 import org.gradle.api.logging.Logging
+import org.gradle.api.plugins.ExtraPropertiesExtension
 import org.gradle.api.tasks.SourceSet
 import org.gradle.api.tasks.SourceSet.MAIN_SOURCE_SET_NAME
 import org.gradle.api.tasks.SourceSet.TEST_SOURCE_SET_NAME
@@ -36,8 +37,11 @@ import org.gradle.kotlin.dsl.withType
 import org.jetbrains.dokka.gradle.DokkaTask
 import org.jetbrains.kotlin.gradle.dsl.KotlinProjectExtension
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
-import org.mjdev.gradle.plugin.config.base.BuildConfigs
+import org.mjdev.gradle.tasks.CreatePropsTask
 import org.kordamp.gradle.plugin.markdown.tasks.MarkdownToHtmlTask
+import org.mjdev.gradle.tasks.ReleaseNotesCreateTask
+import org.mjdev.gradle.tasks.WebServiceCreateTask
+import org.mjdev.gradle.tasks.ZipReleaseCreateTask
 import java.io.File
 import java.io.FileInputStream
 import java.util.Properties
@@ -209,32 +213,61 @@ val Project.log: Logger
 //    })
 //}
 
-fun Project.loadPropertiesFile(path: String) {
-    val propertiesFile = project.rootDir.resolve(path)
-    val props = Properties()
-    props.load(FileInputStream(propertiesFile))
-    props.forEach { prop ->
-        project.rootProject.extra.set(
-            prop.key.toString(),
-            prop.value.toString()
-        )
+fun Project.loadRootPropertiesFile(
+    path: String,
+    exposeToExtra: Boolean = true
+) = loadPropertiesFile(
+    project.rootDir.resolve(path),
+    if (exposeToExtra) project.rootProject.extra else null
+)
+
+fun Project.loadBuildPropertiesFile(
+    path: String,
+    exposeToExtra: Boolean = true
+) = loadPropertiesFile(
+    project.buildDir.resolve(path),
+    if (exposeToExtra) project.extra else null
+)
+
+fun Project.loadPropertiesFile(
+    propertiesFile: File,
+    exposeToExtra: ExtraPropertiesExtension?
+) = Properties().apply {
+    try {
+        load(FileInputStream(propertiesFile))
+    } catch (e: Exception) {
+    }
+}.apply {
+    if (exposeToExtra != null) {
+        forEach { prop ->
+            exposeToExtra.set(prop.key.toString(), prop.value.toString())
+        }
     }
 }
 
-inline fun <reified T> Project.extension(name: String? = null): T = runCatching {
-    var cfg: T? = project.rootProject.extensions.findByType(T::class.java)
-        ?: project.extensions.findByType(T::class.java)
+inline fun <reified T> Project.extension(
+    name: String? = null,
+    config: T.() -> Unit = {}
+): T = runCatching {
+    var cfg: T? = project.extensions.findByType(T::class.java)
     if (cfg == null && name != null) {
         project.extensions.create(name, T::class.java)
     }
     cfg = project.extensions.findByType(T::class.java)
-    cfg!!
+    cfg!!.apply {
+        config(this)
+    }
 }.getOrThrow()
 
 inline fun <reified T : Any> Project.extension(): T =
     rootProject.extensions.findByType(T::class.java)
-        ?: project.extensions.findByType(T::class.java) ?:
-        throw (GradleException("Extension not configured : ${T::class.java.simpleName}"))
+        ?: project.extensions.findByType(T::class.java)
+        ?: throw (GradleException("Extension not configured : ${T::class.java.simpleName}"))
+
+fun <T> Project.extension(cls: Class<T>): T =
+    rootProject.extensions.findByType(cls)
+        ?: project.extensions.findByType(cls)
+        ?: throw (GradleException("Extension not configured : ${cls.simpleName}"))
 
 inline fun <reified T : Task> Project.registerTask(
     name: String? = null,
@@ -254,21 +287,35 @@ fun <T : Plugin<*>> Project.apply(type: KClass<T>): T = plugins.apply(type.java)
 
 fun Project.apply(id: String): Plugin<*> = plugins.apply(id)
 
-fun Project.kotlinCompileOptions(scoped: KotlinCompile.() -> Unit) {
-    tasks.withType<KotlinCompile>().first().also { t -> scoped(t) }
+inline fun <reified T : Task> Project.task(scoped: T.() -> Unit = {}): T {
+    val task = tasks.withType<T>().first()
+    scoped(task)
+    return task
 }
 
-fun Project.detektTask(scoped: Detekt.() -> Unit) {
-    tasks.withType<Detekt>().first().also { t -> scoped(t) }
-}
+fun Project.kotlinCompileOptions(scoped: KotlinCompile.() -> Unit = {}) =
+    task<KotlinCompile>(scoped)
 
-fun Project.dokkaTask(scoped: DokkaTask.() -> Unit) {
-    tasks.withType<DokkaTask>().first().also { t -> scoped(t) }
-}
+fun Project.detektTask(scoped: Detekt.() -> Unit = {}) =
+    task<Detekt>(scoped)
 
-fun Project.markDownToHtmlTask(scoped: MarkdownToHtmlTask.() -> Unit) {
-    tasks.withType<MarkdownToHtmlTask>().first().also { t -> scoped(t) }
-}
+fun Project.createPropsTask(scoped: CreatePropsTask.() -> Unit = {}) =
+    task<CreatePropsTask>(scoped)
+
+fun Project.webServiceCreateTask(scoped: WebServiceCreateTask.() -> Unit = {}) =
+    task<WebServiceCreateTask>(scoped)
+
+fun Project.releaseNotesCreateTask(scoped: ReleaseNotesCreateTask.() -> Unit = {}) =
+    task<ReleaseNotesCreateTask>(scoped)
+
+fun Project.zipReleaseCreateTask(scoped: ZipReleaseCreateTask.() -> Unit = {}) =
+    task<ZipReleaseCreateTask>(scoped)
+
+fun Project.dokkaTask(scoped: DokkaTask.() -> Unit) =
+    task<DokkaTask>(scoped)
+
+fun Project.markDownToHtmlTask(scoped: MarkdownToHtmlTask.() -> Unit) =
+    task<MarkdownToHtmlTask>(scoped)
 
 fun Project.registerSources(outDir: File, variant: BaseVariant) {
     if (outDir.absolutePath.contains("generated/source")) {
@@ -318,20 +365,20 @@ fun Project.fileTree(directory: String, inc: String, exc: String): List<File> {
     }.toList()
 }
 
-inline fun <reified T> Project.runConfigured(crossinline function: T.() -> Unit) {
-    afterEvaluate {
-        val config = project.extension<T>()
-        if (config is BuildConfigs) {
-            project.androidExtension.buildTypes.forEach { bt ->
-                println("> Configuring build : ${bt.name}")
-//                val btConfig = config.buildTypes[bt.name.lowercase()]
-//                println ("> Config: $btConfig")
-//                btConfig?.invoke(bt)
-            }
-        }
-        function(config)
-    }
-}
+//inline fun <reified T> Project.runConfigured(crossinline function: T.() -> Unit) {
+//    afterEvaluate {
+//        val config = project.extension<T>()
+//        if (config is BuildConfigs) {
+//            project.androidExtension.buildTypes.forEach { bt ->
+//                println("> Configuring build : ${bt.name}")
+////                val btConfig = config.buildTypes[bt.name.lowercase()]
+////                println ("> Config: $btConfig")
+////                btConfig?.invoke(bt)
+//            }
+//        }
+//        function(config)
+//    }
+//}
 
 fun Project.androidComponents(
     block: AndroidComponentsExtension<*, *, *>.() -> Unit

buildSrc/src/main/kotlin/org/mjdev/gradle/extensions/TaskExt.kt

@@ -293,17 +293,21 @@ fun Task.setTaskDescription(description: String?): Task = this.apply {
     description?.let { this.description = it }
 }
 
-inline fun <reified T> Task.runConfigured(crossinline function: T.() -> Unit) {
-    val config = project.extension<T>()
-    if (config is BuildConfigs) {
-//            project.androidExtension.buildTypes.forEach { bt ->
-//                println("> Configuring build : ${bt.name}")
-//                val btConfig = config.buildTypes[bt.name.lowercase()]
-//                println ("> Config: $btConfig")
-//                btConfig?.invoke(bt)
-//            }
-    }
-    function(config)
+//inline fun <reified T> Task.runConfigured(crossinline function: T.() -> Unit) {
+//    val config = project.extension<T>()
+//    if (config is BuildConfigs<*>) {
+////            project.androidExtension.buildTypes.forEach { bt ->
+////                println("> Configuring build : ${bt.name}")
+////                val btConfig = config.buildTypes[bt.name.lowercase()]
+////                println ("> Config: $btConfig")
+////                btConfig?.invoke(bt)
+////            }
+//    }
+//    function(config)
+//}
+
+fun Task.mustRunAfter(taskScope: () -> Task) {
+    mustRunAfter(taskScope())
 }
 
 fun <T : Plugin<*>> Task.apply(type: KClass<T>): T =
@@ -318,14 +322,14 @@ fun Task.detektTask(scoped: Detekt.() -> Unit) =
 fun Task.dokkaTask(scoped: DokkaTask.() -> Unit) =
     project.dokkaTask(scoped)
 
-fun Task.println(message: String) = this.log.lifecycle(message)
+fun Task.println(message: String) = this.log.lifecycle("> $message")
 
-fun Task.println(exception: Throwable) = this.log.lifecycle(exception.message)
+fun Task.println(exception: Throwable) = this.log.lifecycle("> ${exception.message}")
 
-fun Task.printError(message: String) = this.log.error(message)
+fun Task.printError(message: String) = this.log.error("> $message")
 
-fun Task.printError(exception: Throwable) = this.log.error(exception.message)
+fun Task.printError(exception: Throwable) = this.log.error("> ${exception.message}")
 
-fun Task.printWarning(message: String) = this.log.warn(message)
+fun Task.printWarning(message: String) = this.log.warn("> $message")
 
-fun Task.printWarning(exception: Throwable) = this.log.warn(exception.message)
+fun Task.printWarning(exception: Throwable) = this.log.warn("> ${exception.message}")

buildSrc/src/main/kotlin/org/mjdev/gradle/plugin/AppPlugin.kt

@@ -28,8 +28,6 @@ import org.mjdev.gradle.extensions.runAfterAssembleTask
 import org.mjdev.gradle.extensions.buildConfigString
 import org.mjdev.gradle.extensions.extension
 import org.mjdev.gradle.extensions.libs
-import org.mjdev.gradle.extensions.string
-import org.mjdev.gradle.extensions.int
 import org.mjdev.gradle.extensions.manifestPlaceholders
 import org.mjdev.gradle.extensions.implementation
 import org.mjdev.gradle.extensions.debugImplementation
@@ -45,49 +43,27 @@ import org.mjdev.gradle.extensions.versionName
 import org.mjdev.gradle.extensions.kotlinCompileOptions
 import org.mjdev.gradle.extensions.detektTask
 import org.mjdev.gradle.extensions.dokkaTask
+import org.mjdev.gradle.extensions.releaseNotesCreateTask
 import org.mjdev.gradle.extensions.apply
 import org.mjdev.gradle.extensions.projectName
-import org.mjdev.gradle.extensions.loadPropertiesFile
-import org.mjdev.gradle.extensions.runConfigured
+import org.mjdev.gradle.extensions.webServiceCreateTask
+import org.mjdev.gradle.extensions.loadRootPropertiesFile
+import org.mjdev.gradle.extensions.fromBuildPropertiesFile
 import org.mjdev.gradle.plugin.config.AppConfig
-import org.mjdev.gradle.tasks.ReleaseNotesCleanTask
 import org.mjdev.gradle.tasks.ReleaseNotesCreateTask
 import org.mjdev.gradle.tasks.WebServiceCreateTask
-import org.mjdev.gradle.tasks.ZipReleaseClearTask
-import org.mjdev.gradle.tasks.ZipReleaseCreateTask
+import org.mjdev.gradle.tasks.CreatePropsTask
 import org.kordamp.gradle.plugin.markdown.MarkdownPlugin
-import org.mjdev.gradle.extensions.markDownToHtmlTask
+import org.mjdev.gradle.extensions.assembleTasks
+import org.mjdev.gradle.extensions.zipReleaseCreateTask
+import org.mjdev.gradle.tasks.ZipReleaseCreateTask
 
 @Suppress("UnstableApiUsage")
 class AppPlugin : BasePlugin() {
-    private val configFieldName = "appConfig"
-
     override fun Project.work() {
-        val appConfig = extension<AppConfig>(configFieldName)
-        loadPropertiesFile(appConfig.versionPropertiesFile)
-//        println("---------------------------------------------------------------------")
-//        println("App Configuration")
-//        println("---------------------------------------------------------------------")
-//        println("Project version : ${project.versionName}")
-//        println("Project description : $description")
-//        println("---------------------------------------------------------------------")
-//        println("autoCorrectCode : ${appConfig.autoCorrectCode}")
-//        println("ignoreCodeFailures : ${appConfig.ignoreCodeFailures}")
-//        println("createDocumentation : ${appConfig.createDocumentation}")
-//        println("reportUndocumentedFiles : ${appConfig.reportUndocumentedFiles}")
-//        println("failOnDocumentationWarning : ${appConfig.failOnDocumentationWarning}")
-//        println("createReleaseNotes : ${appConfig.createReleaseNotes}")
-//        println("createZipRelease : ${appConfig.createZipRelease}")
-//        println("createInfoClass : ${appConfig.createInfoClass}")
-//        println("createWebApp : ${appConfig.createWebApp}")
-//        println("createWebSiteFromGit : ${appConfig.createWebSiteFromGit}")
-//        println("renameApkOutputByAppID : ${appConfig.renameApkOutputByAppID}")
-//        println("launcherIconByBuildType : ${appConfig.launcherIconByBuildType}")
-//        println("---------------------------------------------------------------------")
-//        println("codeReportsDir : ${appConfig.codeReportsDir}")
-//        println("documentationDir : ${appConfig.documentationDir}")
-//        println("detectConfigFile : ${appConfig.detectConfigFile}")
-//        println("---------------------------------------------------------------------")
+        val appConfig: AppConfig = extension<AppConfig>(AppConfig.configFieldName)
+        fromBuildPropertiesFile(appConfig, AppConfig.configPropertiesFile)
+        loadRootPropertiesFile(appConfig.versionPropertiesFile)
         apply(plugin = "com.android.application")
         apply(plugin = "kotlin-kapt")
         apply(plugin = "kotlin-android")
@@ -100,47 +76,45 @@ class AppPlugin : BasePlugin() {
         apply(MarkdownPlugin::class)
         apply(DetektPlugin::class)
         apply(KotlinterPlugin::class)
-        registerTask<ReleaseNotesCleanTask> {
-            enabled = appConfig.createReleaseNotes
+        registerTask<CreatePropsTask> {
+            propsFilePath = AppConfig.configPropertiesFile
+            propsClass = AppConfig::class.java
             runAfterCleanTask()
         }
-        registerTask<ZipReleaseClearTask> {
-            enabled = appConfig.createZipRelease
-            runAfterCleanTask()
+        registerTask<ReleaseNotesCreateTask>() {
+            mustRunAfter(assembleTasks)
+        }
+        registerTask<WebServiceCreateTask>() {
+            mustRunAfter(assembleTasks)
+        }
+        registerTask<ZipReleaseCreateTask>() {
+            mustRunAfter(assembleTasks)
         }
         configure<ApplicationExtension> {
-            // todo : move
-            namespace = libs.versions.app.namespace.string
-            // todo : move
-            compileSdk = libs.versions.compileSdk.int
+            namespace = appConfig.namespace
+            compileSdk = AppConfig.compileSdk
             setSigningConfigs(project) {
-                // todo : move
-                debugKeyFile = libs.versions.debug.keyfile.string
-                // todo : move
-                releaseKeyFile = libs.versions.release.keyfile.string
+                debugKeyFile = appConfig.debugKeySigningFile
+                releaseKeyFile = appConfig.releaseSigningFile
             }
             buildFeatures {
-                compose = true
-                buildConfig = true
+                compose = AppConfig.composeEnabled
+                buildConfig = AppConfig.buildConfigEnabled
             }
             compileOptions {
-                // todo : move
-                sourceCompatibility = appConfig.javaVersion
-                // todo : move
-                targetCompatibility = appConfig.javaVersion
+                sourceCompatibility = AppConfig.javaVersion
+                targetCompatibility = AppConfig.javaVersion
             }
             composeOptions {
-                // todo : move
-                kotlinCompilerExtensionVersion =
-                    libs.versions.kotlin.compiler.version.string
+                kotlinCompilerExtensionVersion = AppConfig.kotlinCompilerVersion
             }
             defaultConfig {
-                applicationId = libs.versions.app.namespace.string
-                minSdk = libs.versions.minSdk.int
-                targetSdk = libs.versions.compileSdk.int
+                applicationId = appConfig.namespace
+                minSdk = AppConfig.minSdk
+                targetSdk = AppConfig.compileSdk
                 versionCode = project.versionCode
                 versionName = project.versionName
-                multiDexEnabled = true
+                multiDexEnabled = AppConfig.multiDexEnabled
                 // todo : move
                 buildConfigString(
                     "IPTV_API_URL" to "https://iptv-org.github.io/api/",
@@ -154,11 +128,7 @@ class AppPlugin : BasePlugin() {
                 )
                 testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
             }
-            packaging {
-                resources {
-                    excludes.addAll(appConfig.projectExcludes)
-                }
-            }
+            packaging.resources.excludes.addAll(AppConfig.projectExcludes)
             buildTypes {
                 debug {
                     applicationIdSuffix = ".$name"
@@ -176,9 +146,10 @@ class AppPlugin : BasePlugin() {
                         "sync_auth",
                         "sync"
                     )
+                    // todo : move
                     proguardFiles(
-                        getDefaultProguardFile(appConfig.projectProguardFile),
-                        appConfig.projectProguardRulesFile
+                        getDefaultProguardFile(appConfig.proguardFile),
+                        appConfig.proguardRulesFile
                     )
                 }
                 release {
@@ -197,9 +168,10 @@ class AppPlugin : BasePlugin() {
                         "sync_auth",
                         "sync"
                     )
+                    // todo : move
                     proguardFiles(
-                        getDefaultProguardFile(appConfig.projectProguardFile),
-                        appConfig.projectProguardRulesFile
+                        getDefaultProguardFile(appConfig.proguardFile),
+                        appConfig.proguardRulesFile
                     )
                 }
             }
@@ -211,52 +183,48 @@ class AppPlugin : BasePlugin() {
                 checkAllWarnings = true
                 showAll = true
                 explainIssues = true
-                // todo : move
-                abortOnError = false
-                // todo move
-                warningsAsErrors = false
+                abortOnError = !appConfig.ignoreCodeFailures
+                warningsAsErrors = !appConfig.ignoreCodeFailures
                 disable += "UnusedIds"
             }
             testOptions {
                 unitTests.isReturnDefaultValues = true
             }
             testCoverage {
-                jacocoVersion = libs.versions.jacoco.version.string
+                jacocoVersion = AppConfig.jacocoVersion
             }
         }
-        runConfigured<AppConfig> {
-            kotlinCompileOptions {
-                kotlinOptions {
-                    freeCompilerArgs += "-Xjsr305=strict"
-                    jvmTarget = javaVersion.toString()
-                }
-            }
-            detektTask {
-                enabled = autoCorrectCode
+        afterEvaluate {
+        detektTask {
+            if (appConfig.autoCorrectCode) {
+                mustRunAfter(assembleTasks)
                 runAfterAssembleTask()
             }
-            dokkaTask {
-                enabled = createDocumentation
-                outputDirectory.set(rootDir.resolve(documentationDir))
-                moduleName.set(projectName)
-                suppressObviousFunctions.set(false)
-                dokkaSourceSets.configureEach {
-                    offlineMode.set(false)
-                    includeNonPublic.set(false)
-                    skipDeprecated.set(false)
-                    failOnWarning.set(failOnDocumentationWarning)
-                    reportUndocumented.set(reportUndocumentedFiles)
-                    skipEmptyPackages.set(false)
-                    platform.set(Platform.jvm)
-                    jdkVersion.set(javaVersion.asInt())
-                    noStdlibLink.set(false)
-                    noJdkLink.set(false)
-                    noAndroidSdkLink.set(false)
-                }
+        }
+        dokkaTask {
+            outputDirectory.set(rootDir.resolve(appConfig.documentationDir))
+            moduleName.set(projectName)
+            suppressObviousFunctions.set(false)
+            dokkaSourceSets.configureEach {
+                offlineMode.set(false)
+                includeNonPublic.set(false)
+                skipDeprecated.set(false)
+                failOnWarning.set(appConfig.failOnDocumentationWarning)
+                reportUndocumented.set(appConfig.reportUndocumentedFiles)
+                skipEmptyPackages.set(false)
+                platform.set(Platform.jvm)
+                jdkVersion.set(AppConfig.javaVersion.asInt())
+                noStdlibLink.set(false)
+                noJdkLink.set(false)
+                noAndroidSdkLink.set(false)
+            }
+            if (appConfig.createDocumentation) {
+                mustRunAfter(assembleTasks)
                 runAfterAssembleTask()
             }
-            markDownToHtmlTask {
-                enabled = createWebSiteFromGit
+        }
+//        markDownToHtmlTask {
+//            enabled = appConfig.createWebSiteFromGit
 //                sourceDir = rootDir
 //                outputDir = rootDir.resolve("web")
 //                hardwraps = true
@@ -277,34 +245,45 @@ class AppPlugin : BasePlugin() {
 //                if(createWebSiteFromGit) {
 //                    runAfterAssembleTask()
 //                }
-            }
-            registerTask<WebServiceCreateTask> {
-                enabled = createWebApp
-                domain = "localhost"
-                servicePort = 2222
-                serviceName = project.name
-                serviceVersion = project.versionName
-                serviceCompany = "mjdev"
-                serviceLicense = ""
-                runAfterCleanTask()
-            }
-            val rnTask = registerTask<ReleaseNotesCreateTask> {
-                enabled = createReleaseNotes
+//        }
+        releaseNotesCreateTask {
+            if (appConfig.createReleaseNotes) {
                 runAfterAssembleTask()
             }
-            registerTask<ZipReleaseCreateTask> {
-                enabled = createZipRelease
-                if (createReleaseNotes) mustRunAfter(rnTask)
+        }
+        webServiceCreateTask {
+            domain = "localhost"
+            servicePort = 2222
+            serviceName = project.name
+            serviceVersion = project.versionName
+            serviceCompany = "mjdev"
+            serviceLicense = ""
+            if (appConfig.createWebApp) {
                 runAfterAssembleTask()
             }
+        }
+            zipReleaseCreateTask {
+                if (appConfig.createZipRelease) {
+                    runAfterAssembleTask()
+                }
+                if (appConfig.createReleaseNotes) {
+                    mustRunAfter(releaseNotesCreateTask())
+                }
+            }
+            kotlinCompileOptions {
+                kotlinOptions {
+                    freeCompilerArgs += "-Xjsr305=strict"
+                    jvmTarget = AppConfig.javaVersion.toString()
+                }
+            }
             configure<DetektExtension> {
-                ignoreFailures = ignoreCodeFailures
-                reportsDir = rootDir.resolve(codeReportsDir)
+                ignoreFailures = appConfig.ignoreCodeFailures
+                reportsDir = rootDir.resolve(appConfig.codeReportsDir)
                 @Suppress("DEPRECATION")
-                config = files(project.rootDir.resolve(detectConfigFile))
+                config = files(project.rootDir.resolve(appConfig.detectConfigFile))
             }
             configure<KotlinterExtension> {
-                ignoreFailures = ignoreCodeFailures
+                ignoreFailures = appConfig.ignoreCodeFailures
                 reporters = arrayOf("checkstyle", "plain")
             }
         }

buildSrc/src/main/kotlin/org/mjdev/gradle/plugin/LibPlugin.kt

@@ -35,17 +35,19 @@ import org.mjdev.gradle.extensions.kotlinCompileOptions
 import org.mjdev.gradle.extensions.detektTask
 import org.mjdev.gradle.extensions.dokkaTask
 import org.mjdev.gradle.extensions.apply
-import org.mjdev.gradle.extensions.int
-import org.mjdev.gradle.extensions.string
+import org.mjdev.gradle.extensions.fromBuildPropertiesFile
+import org.mjdev.gradle.extensions.loadRootPropertiesFile
 import org.mjdev.gradle.extensions.projectName
-import org.mjdev.gradle.extensions.runConfigured
+import org.mjdev.gradle.extensions.registerTask
+import org.mjdev.gradle.extensions.runAfterCleanTask
+import org.mjdev.gradle.tasks.CreatePropsTask
 
 @Suppress("UnstableApiUsage")
 class LibPlugin : BasePlugin() {
-    private val configFieldName = "libConfig"
-
     override fun Project.work() {
-        val libConfig = extension<LibConfig>(configFieldName)
+        val libConfig: LibConfig = extension<LibConfig>(LibConfig.configFieldName)
+        fromBuildPropertiesFile(libConfig, LibConfig.configPropertiesFile)
+        loadRootPropertiesFile(libConfig.versionPropertiesFile)
         apply(plugin = "kotlin-android")
         apply(plugin = "com.android.library")
         apply(plugin = "kotlin-kapt")
@@ -57,51 +59,45 @@ class LibPlugin : BasePlugin() {
         apply("org.jetbrains.dokka")
         apply(DetektPlugin::class)
         apply(KotlinterPlugin::class)
+        registerTask<CreatePropsTask> {
+            propsFilePath = LibConfig.configPropertiesFile
+            propsClass = LibConfig::class.java
+            runAfterCleanTask()
+        }
         configure<LibraryExtension> {
-            // todo : move
-            namespace = libs.versions.lib.namespace.string
-            // todo : move
-            compileSdk = libs.versions.compileSdk.int
+            namespace = libConfig.namespace
+            compileSdk = LibConfig.compileSdk
             compileOptions {
-                // todo : move
-                sourceCompatibility = libConfig.javaVersion
-                // todo : move
-                targetCompatibility = libConfig.javaVersion
+                sourceCompatibility = LibConfig.javaVersion
+                targetCompatibility = LibConfig.javaVersion
             }
             buildFeatures {
-                compose = true
-                buildConfig = true
+                compose = LibConfig.composeEnabled
+                buildConfig = LibConfig.buildConfigEnabled
             }
             composeOptions {
-                // todo : move
-                kotlinCompilerExtensionVersion = libs.versions.kotlin.compiler.version.string
+                kotlinCompilerExtensionVersion = LibConfig.kotlinCompilerVersion
             }
             defaultConfig {
-                // todo : move
-                minSdk = libs.versions.minSdk.int
+                minSdk = LibConfig.minSdk
                 testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
             }
-            packaging {
-                resources {
-                    excludes.addAll(libConfig.projectExcludes)
-                }
-            }
+            packaging.resources.excludes.addAll(LibConfig.projectExcludes)
             buildTypes {
                 debug {
                     isMinifyEnabled = false
                     isShrinkResources = false
                     proguardFiles(
-                        getDefaultProguardFile(libConfig.projectProguardFile),
-                        libConfig.projectProguardRulesFile
+                        getDefaultProguardFile(libConfig.proguardFile),
+                        libConfig.proguardRulesFile
                     )
                 }
                 release {
-                    // todo minify
-                    isMinifyEnabled = false
+                    isMinifyEnabled = libConfig.minify
                     isShrinkResources = false
                     proguardFiles(
-                        getDefaultProguardFile(libConfig.projectProguardFile),
-                        libConfig.projectProguardRulesFile
+                        getDefaultProguardFile(libConfig.proguardFile),
+                        libConfig.proguardRulesFile
                     )
                 }
             }
@@ -111,61 +107,62 @@ class LibPlugin : BasePlugin() {
                 }
             }
             lint {
+                checkReleaseBuilds = true
                 checkAllWarnings = true
                 showAll = true
                 explainIssues = true
-                // todo : move
-                abortOnError = false
-                // todo : move
-                warningsAsErrors = false
+                abortOnError = !libConfig.ignoreCodeFailures
+                warningsAsErrors = !libConfig.ignoreCodeFailures
                 disable += "UnusedIds"
             }
             testOptions {
                 unitTests.isReturnDefaultValues = true
             }
             testCoverage {
-                jacocoVersion = libs.versions.jacoco.version.string
+                jacocoVersion = LibConfig.jacocoVersion
             }
         }
-        runConfigured<LibConfig> {
-            kotlinCompileOptions {
-                kotlinOptions {
-                    freeCompilerArgs += "-Xjsr305=strict"
-                    jvmTarget = javaVersion.toString()
-                }
-            }
+        afterEvaluate {
             detektTask {
-                enabled = autoCorrectCode
-                runAfterAssembleTask()
+                if (libConfig.autoCorrectCode) {
+                    runAfterAssembleTask()
+                }
             }
             dokkaTask {
-                enabled = createDocumentation
-                outputDirectory.set(rootDir.resolve(documentationDir))
+                outputDirectory.set(rootDir.resolve(libConfig.documentationDir))
                 moduleName.set(projectName)
                 suppressObviousFunctions.set(false)
                 dokkaSourceSets.configureEach {
                     offlineMode.set(false)
                     includeNonPublic.set(false)
                     skipDeprecated.set(false)
-                    failOnWarning.set(failOnDocumentationWarning)
-                    reportUndocumented.set(reportUndocumentedFiles)
+                    failOnWarning.set(libConfig.failOnDocumentationWarning)
+                    reportUndocumented.set(libConfig.reportUndocumentedFiles)
                     skipEmptyPackages.set(false)
                     platform.set(Platform.jvm)
-                    jdkVersion.set(javaVersion.asInt())
+                    jdkVersion.set(LibConfig.javaVersion.asInt())
                     noStdlibLink.set(false)
                     noJdkLink.set(false)
                     noAndroidSdkLink.set(false)
                 }
-                runAfterAssembleTask()
+                if (libConfig.createDocumentation) {
+                    runAfterAssembleTask()
+                }
+            }
+            kotlinCompileOptions {
+                kotlinOptions {
+                    freeCompilerArgs += "-Xjsr305=strict"
+                    jvmTarget = LibConfig.javaVersion.toString()
+                }
             }
             configure<DetektExtension> {
-                reportsDir = rootDir.resolve(codeReportsDir)
-                ignoreFailures = ignoreCodeFailures
+                reportsDir = rootDir.resolve(libConfig.codeReportsDir)
+                ignoreFailures = libConfig.ignoreCodeFailures
                 @Suppress("DEPRECATION")
-                config = files(project.rootDir.resolve(detectConfigFile))
+                config = files(project.rootDir.resolve(libConfig.detectConfigFile))
             }
             configure<KotlinterExtension> {
-                ignoreFailures = ignoreCodeFailures
+                ignoreFailures = libConfig.ignoreCodeFailures
                 reporters = arrayOf("checkstyle", "plain")
             }
         }

buildSrc/src/main/kotlin/org/mjdev/gradle/plugin/config/AppConfig.kt

@@ -9,11 +9,13 @@
 package org.mjdev.gradle.plugin.config
 
 import org.gradle.api.JavaVersion
+import org.mjdev.gradle.extensions.toHashMap
 import org.mjdev.gradle.plugin.config.base.BuildConfigs
 
 @Suppress("unused")
 open class AppConfig : BuildConfigs() {
 
+    open var namespace = "org.mjdev.tvapp"
     open var description = ""
 
     open var autoCorrectCode = true
@@ -34,23 +36,44 @@ open class AppConfig : BuildConfigs() {
     open var documentationDir = "documentation/app"
 
     open var detectConfigFile = "config/detekt.yml"
+    open var versionPropertiesFile = "config/version.app.prop"
+    open var debugKeySigningFile = "config/signing.debug.prop"
+    open var releaseSigningFile = "config/signing.release.prop"
 
-    open var javaVersion = JavaVersion.VERSION_17
-
-    open var projectExcludes = listOf(
-        "META-INF/",
-        "/META-INF/{AL2.0,LGPL2.1}",
-        "/META-INF/DEPENDENCIES",
-        "/mozilla/public-suffix-list.txt",
-        "okhttp3/",
-        "kotlin/",
-        "org/",
-        ".properties",
-        ".bin",
-    )
-
-    open var projectProguardFile = "proguard-android-optimize.txt"
-    open var projectProguardRulesFile = "proguard-rules.pro"
-    open var versionPropertiesFile = "config/version.prop"
+    open var proguardFile = "proguard-android-optimize.txt"
+    open var proguardRulesFile = "proguard-rules.pro"
+
+
+    companion object {
+        const val configFieldName = "appConfig"
+        const val configPropertiesFile = "app.config.prop"
+
+        const val composeEnabled = true
+        const val buildConfigEnabled = true
+
+        const val compileSdk = 34
+        const val minSdk = 21
+
+        const val kotlinCompilerVersion = "1.5.8"
+        const val jacocoVersion = "0.8.8"
+
+        const val multiDexEnabled = true
+
+        val javaVersion = JavaVersion.VERSION_17
+
+        val projectExcludes = listOf(
+            "META-INF/",
+            "/META-INF/{AL2.0,LGPL2.1}",
+            "/META-INF/DEPENDENCIES",
+            "/mozilla/public-suffix-list.txt",
+            "okhttp3/",
+            "kotlin/",
+            "org/",
+            ".properties",
+            ".bin",
+        )
+    }
+
+    override fun toMap(): Map<*, *> = toHashMap()
 
 }

buildSrc/src/main/kotlin/org/mjdev/gradle/plugin/config/LibConfig.kt

@@ -9,8 +9,13 @@
 package org.mjdev.gradle.plugin.config
 
 import org.gradle.api.JavaVersion
+import org.mjdev.gradle.extensions.toHashMap
+import org.mjdev.gradle.plugin.config.base.BuildConfigs
+
+open class LibConfig : BuildConfigs() {
+    open var namespace = "org.mjdev.tvlib"
+    open var description = "Smart TV android app lib for android applications running on any android device"
 
-open class LibConfig {
     open var autoCorrectCode = true
     open var ignoreCodeFailures = true
     open var createDocumentation = true
@@ -22,22 +27,39 @@ open class LibConfig {
     open var documentationDir = "documentation/lib"
 
     open var detectConfigFile = "config/detekt.yml"
+    open var versionPropertiesFile = "config/version.lib.prop"
+
+    open var proguardFile = "proguard-android-optimize.txt"
+    open var proguardRulesFile = "proguard-rules.pro"
+
+    companion object {
+        const val configFieldName = "libConfig"
+        const val configPropertiesFile = "lib.config.prop"
+
+        const val composeEnabled = true
+        const val buildConfigEnabled = true
+
+        const val compileSdk = 34
+        const val minSdk = 21
+
+        const val kotlinCompilerVersion = "1.5.8"
+        const val jacocoVersion = "0.8.8"
+
+        val javaVersion = JavaVersion.VERSION_17
+
+        val projectExcludes = listOf(
+            "META-INF/",
+            "/META-INF/{AL2.0,LGPL2.1}",
+            "/META-INF/DEPENDENCIES",
+            "/mozilla/public-suffix-list.txt",
+            "okhttp3/",
+            "kotlin/",
+            "org/",
+            ".properties",
+            ".bin",
+        )
+    }
+
+    override fun toMap(): Map<*, *> = toHashMap()
 
-    open var javaVersion = JavaVersion.VERSION_17
-
-    open var projectExcludes = listOf(
-        "META-INF/",
-        "/META-INF/{AL2.0,LGPL2.1}",
-        "/META-INF/DEPENDENCIES",
-        "/mozilla/public-suffix-list.txt",
-        "okhttp3/",
-        "kotlin/",
-        "org/",
-        ".properties",
-        ".bin",
-    )
-
-    open var projectProguardFile = "proguard-android-optimize.txt"
-    open var projectProguardRulesFile = "proguard-rules.pro"
-    open var versionPropertiesFile = "config/version.prop"
 }

buildSrc/src/main/kotlin/org/mjdev/gradle/plugin/config/base/BuilConfigs.kt

@@ -13,8 +13,9 @@ import com.android.build.api.dsl.BuildType
 typealias BuildTypeFnc = BuildType.() -> Unit
 
 @Suppress("MemberVisibilityCanBePrivate")
-abstract class BuildConfigs {
+abstract class BuildConfigs : IConfig {
 
+    // todo serialize
     val buildTypes = mutableMapOf<String, BuildTypeFnc>()
 
     fun create(name: String, action: BuildTypeFnc) {

buildSrc/src/main/kotlin/org/mjdev/gradle/plugin/config/base/IConfig.kt

@@ -0,0 +1,13 @@
+/*
+ *  Copyright (c) Milan Jurkulák 2024.
+ *  Contact:
+ *  e: mimoccc@gmail.com
+ *  e: mj@mjdev.org
+ *  w: https://mjdev.org
+ */
+
+package org.mjdev.gradle.plugin.config.base
+
+interface IConfig {
+    fun toMap(): Map<*, *>
+}

buildSrc/src/main/kotlin/org/mjdev/gradle/tasks/ApplicationConfigTask.kt

@@ -1,47 +0,0 @@
-/*
- *  Copyright (c) Milan Jurkulák 2024.
- *  Contact:
- *  e: mimoccc@gmail.com
- *  e: mj@mjdev.org
- *  w: https://mjdev.org
- */
-
-package org.mjdev.gradle.tasks
-
-import org.mjdev.gradle.base.BaseTask
-import org.mjdev.gradle.extensions.runConfigured
-import org.mjdev.gradle.plugin.config.AppConfig
-
-open class ApplicationConfigTask : BaseTask() {
-
-    init {
-        group = "mjdev"
-        description = "This task configure android application project."
-        outputs.upToDateWhen { false }
-    }
-
-    override fun doTask() = runConfigured<AppConfig> {
-//        println("---------------------------------------------------------------------")
-//        println("App Configuration")
-//        println("---------------------------------------------------------------------")
-//        println(project.versionName)
-//        println("---------------------------------------------------------------------")
-//        println(autoCorrectCode)
-//        println(ignoreCodeFailures)
-//        println(createDocumentation)
-//        println(reportUndocumentedFiles)
-//        println(failOnDocumentationWarning)
-//        println(createReleaseNotes)
-//        println(createZipRelease)
-//        println(createInfoClass)
-//        println(createWebApp)
-//        println(createWebSiteFromGit)
-//        println(renameApkOutputByAppID)
-//        println(launcherIconByBuildType)
-//        println("---------------------------------------------------------------------")
-//        println(codeReportsDir)
-//        println(documentationDir)
-//        println(detectConfigFile)
-//        println("---------------------------------------------------------------------")
-    }
-}

buildSrc/src/main/kotlin/org/mjdev/gradle/tasks/CreatePropsTask.kt

@@ -0,0 +1,80 @@
+/*
+ *  Copyright (c) Milan Jurkulák 2024.
+ *  Contact:
+ *  e: mimoccc@gmail.com
+ *  e: mj@mjdev.org
+ *  w: https://mjdev.org
+ */
+
+package org.mjdev.gradle.tasks
+
+import org.gradle.api.tasks.Input
+import org.mjdev.gradle.base.BaseTask
+import org.mjdev.gradle.extensions.buildDirectory
+import org.mjdev.gradle.extensions.extension
+import org.mjdev.gradle.extensions.println
+import org.mjdev.gradle.extensions.mapToString
+import java.io.FileInputStream
+import java.util.Properties
+import org.mjdev.gradle.plugin.config.base.IConfig
+
+open class CreatePropsTask : BaseTask() {
+
+    @Input
+    var propsFilePath = "props.prop"
+
+    @Input
+    lateinit var propsClass: Class<*>
+
+    private val propsFile
+        get() = project.buildDirectory.resolve(propsFilePath)
+
+    private val isPropFileExists
+        get() = propsFile.exists()
+
+    init {
+        group = "mjdev"
+        description = "This task configure properties in project."
+        outputs.upToDateWhen { false }
+    }
+
+    private fun printInfo() {
+        println("---------------------------------------------------------------------")
+        println("Configuration for project :${project.name} ")
+        println("class : $propsClass")
+        println("file : $propsFile")
+        println("---------------------------------------------------------------------")
+        val props = Properties()
+        props.load(FileInputStream(propsFile))
+        props.forEach { prop ->
+            println("${prop.key} = ${prop.value}")
+        }
+        println("---------------------------------------------------------------------")
+    }
+
+    override fun onClean() {
+        if (propsFile.exists()) {
+            propsFile.delete()
+        }
+    }
+
+    override fun onAssemble() {
+        val config: IConfig = project.extension(propsClass) as IConfig
+        config
+            .toMap()
+            .mapToString(
+                separator = "=",
+                quoteFirst = false,
+                quoteSecond = false,
+                prefix = "",
+                suffix = ""
+            )
+            .also { props ->
+                propsFile.apply {
+                    parentFile.mkdirs()
+                    writeText(props)
+                }
+            }
+        printInfo()
+    }
+}

buildSrc/src/main/kotlin/org/mjdev/gradle/tasks/InAppInfoCreateTask.kt

@@ -29,7 +29,10 @@ open class InAppInfoCreateTask : BaseTask() {
         outputs.upToDateWhen { false }
     }
 
-    override fun doTask() {
+    override fun onClean() {
+    }
+
+    override fun onAssemble() {
         registerSourceDirectory(srcOutputDir)
         createFile(
             name = "ApplicationInfo",

buildSrc/src/main/kotlin/org/mjdev/gradle/tasks/ReleaseNotesCleanTask.kt

@@ -1,45 +0,0 @@
-/*
- *  Copyright (c) Milan Jurkulák 2024.
- *  Contact:
- *  e: mimoccc@gmail.com
- *  e: mj@mjdev.org
- *  w: https://mjdev.org
- */
-
-package org.mjdev.gradle.tasks
-
-import org.mjdev.gradle.extensions.file
-import org.mjdev.gradle.extensions.projectVersion
-import java.io.File
-import org.mjdev.gradle.base.BaseTask
-
-open class ReleaseNotesCleanTask : BaseTask() {
-
-    private val fileName: String
-        get() = "release-notes-$projectVersion.md"
-
-    private val docDir: File
-        get() = project.rootProject
-            .file("documentation")
-
-    private val outputFiles = listOf(
-        docDir.file(fileName)
-    )
-
-    init {
-        group = "mjdev"
-        description = "This task clear all release-notes files, to clean project."
-        outputs.upToDateWhen { false }
-    }
-
-    override fun doTask() {
-        outputFiles.forEach { file ->
-            if (file.isDirectory) {
-                file.deleteRecursively()
-            } else {
-                file.delete()
-            }
-        }
-    }
-
-}

buildSrc/src/main/kotlin/org/mjdev/gradle/tasks/ReleaseNotesCreateTask.kt

@@ -42,7 +42,17 @@ open class ReleaseNotesCreateTask : BaseTask() {
         outputs.upToDateWhen { false }
     }
 
-    override fun doTask() {
+    override fun onClean() {
+        outputFiles.forEach { file ->
+            if (file.isDirectory) {
+                file.deleteRecursively()
+            } else {
+                file.delete()
+            }
+        }
+    }
+
+    override fun onAssemble() {
         println("Creating release notes")
         StringBuilder().apply {
             @Suppress("DEPRECATION")

buildSrc/src/main/kotlin/org/mjdev/gradle/tasks/TestClassesGeneratorTask.kt

@@ -44,17 +44,6 @@ open class TestClassesGeneratorTask : BaseTask() {
         outputs.upToDateWhen { false }
     }
 
-    override fun doTask() {
-        println("> Got files:")
-        fileMap.keys.forEach { project ->
-            val files = fileMap[project] ?: emptyList()
-            files.forEach { file ->
-                println("> ${project.name} > $file")
-                createTestFile(project, file)
-            }
-        }
-    }
-
     private fun createTestFile(
         project: Project,
         file: File
@@ -85,4 +74,18 @@ open class TestClassesGeneratorTask : BaseTask() {
         override fun makeTestClass(file: File): FileSpec? = null
     }
 
+    override fun onClean() {
+    }
+
+    override fun onAssemble() {
+        println("> Got files:")
+        fileMap.keys.forEach { project ->
+            val files = fileMap[project] ?: emptyList()
+            files.forEach { file ->
+                println("> ${project.name} > $file")
+                createTestFile(project, file)
+            }
+        }
+    }
+
 }

buildSrc/src/main/kotlin/org/mjdev/gradle/tasks/WebServiceCreateTask.kt

@@ -147,7 +147,13 @@ open class WebServiceCreateTask : BaseTask() {
         outputs.upToDateWhen { false }
     }
 
-    override fun doTask() {
+    override fun onClean() {
+        webDir.file(systemdFile).delete()
+        webDir.file(nginxFileName).delete()
+        webDir.file(packageFileName).delete()
+    }
+
+    override fun onAssemble() {
         webDir.file(systemdFile).writeText(systemdFileContent)
         webDir.file(nginxFileName).writeText(nginxFileContent)
         webDir.file(packageFileName).writeText(packageJsonFile)

buildSrc/src/main/kotlin/org/mjdev/gradle/tasks/ZipReleaseClearTask.kt

@@ -1,35 +0,0 @@
-/*
- *  Copyright (c) Milan Jurkulák 2024.
- *  Contact:
- *  e: mimoccc@gmail.com
- *  e: mj@mjdev.org
- *  w: https://mjdev.org
- */
-
-package org.mjdev.gradle.tasks
-
-import org.mjdev.gradle.base.BaseTask
-
-open class ZipReleaseClearTask : BaseTask() {
-
-    private val outputFiles = listOf(
-        project.rootProject.file("release.zip")
-    )
-
-    init {
-        group = "mjdev"
-        description = "This task clear all release-notes files, to clean project."
-        outputs.upToDateWhen { false }
-    }
-
-    override fun doTask() {
-        outputFiles.forEach { file ->
-            if (file.isDirectory) {
-                file.deleteRecursively()
-            } else {
-                file.delete()
-            }
-        }
-    }
-
-}

buildSrc/src/main/kotlin/org/mjdev/gradle/tasks/ZipReleaseCreateTask.kt

@@ -8,12 +8,11 @@
 
 package org.mjdev.gradle.tasks
 
-import org.gradle.api.tasks.bundling.Zip
+import org.mjdev.gradle.base.BaseTask
 import org.mjdev.gradle.extensions.file
 import org.mjdev.gradle.extensions.projectVersion
 
-@Suppress("LeakingThis")
-open class ZipReleaseCreateTask : Zip() {
+open class ZipReleaseCreateTask : BaseTask() {
 
     private val releaseFile = project.rootProject
         .file("documentation")
@@ -26,21 +25,35 @@ open class ZipReleaseCreateTask : Zip() {
         releaseFile,
         readmeFile,
         project.rootProject.file("dependencies.txt"),
+        project.rootProject.file("reports"),
+        project.rootProject.file("web"),
         project.file("build").file("outputs").file("apk").file("debug"),
         project.file("build").file("outputs").file("apk").file("release"),
     )
 
+    private val zipFileName = "zipFileName"
+    private val zipFile = project.rootDir.resolve(zipFileName)
+
     init {
         group = "mjdev"
         description = "This task makes archive from build artifacts and wiki, and logs."
 
         outputs.upToDateWhen { false }
+    }
+
+    override fun onClean() {
+        if (zipFile.exists()) {
+            zipFile.delete()
+        }
+    }
 
-        from(files)
-        include("*", "*/*", "*/**")
-        includeEmptyDirs = true
-        destinationDirectory.set(project.rootProject.rootDir)
-        archiveFileName.set("release.zip")
+    override fun onAssemble() {
+//        from(files)
+//        include("*", "*/*", "*/**")
+//        includeEmptyDirs = true
+//        destinationDirectory.set(project.rootProject.rootDir)
+//        archiveFileName.set("release.zip")
+        // todo
     }
 
 }

config/signing.release.prop

@@ -0,0 +1,14 @@
+#
+# Copyright (c) Milan Jurkulák 2023.
+# Contact:
+# e: mimoccc@gmail.com
+# e: mj@mjdev.org
+# w: https://mjdev.org
+#
+
+# suppress inspection "SpellCheckingInspection" for whole file
+# suppress inspection "UnusedProperty" for whole file
+keyAlias=test
+keyPassword=testtest
+storeFile=keystore/test.key
+storePassword=testtest

config/version.prop → config/version.app.prop

@@ -7,4 +7,4 @@
 #
 majorVersion=1
 minorVersion=2
-patchVersion=6
+patchVersion=7

config/version.lib.prop

@@ -0,0 +1,10 @@
+#
+#  Copyright (c) Milan Jurkulák 2024.
+#  Contact:
+#  e: mimoccc@gmail.com
+#  e: mj@mjdev.org
+#  w: https://mjdev.org
+#
+majorVersion=1
+minorVersion=0
+patchVersion=0

documentation/app/app/org.mjdev.tvapp.database/-d-a-o/cache.md

@@ -1,6 +0,0 @@
-//[app](../../../index.md)/[org.mjdev.tvapp.database](../index.md)/[DAO](index.md)/[cache](cache.md)
-
-# cache
-
-[androidJvm]\
-val [cache](cache.md): [MutableMap](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/-mutable-map/index.html)<[KClass](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.reflect/-k-class/index.html)<*>, [List](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/-list/index.html)<*>>

documentation/app/app/org.mjdev.tvapp.database/-d-a-o/get-cached-list.md

@@ -1,6 +0,0 @@
-//[app](../../../index.md)/[org.mjdev.tvapp.database](../index.md)/[DAO](index.md)/[getCachedList](get-cached-list.md)
-
-# getCachedList
-
-[androidJvm]\
-inline fun <[T](get-cached-list.md)> [getCachedList](get-cached-list.md)(creator: () -> [List](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/-list/index.html)<*>): [List](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/-list/index.html)<*>

documentation/release-notes-1.2.6.md → documentation/release-notes-1.2.7.md

@@ -1,7 +1,8 @@
-** Release notes 1.2.6 - 30. 4. 2024, 22:34:31
+** Release notes 1.0.0 - 1. 5. 2024, 21:24:41
 
 * 30.04.2024
 
+* [milan jurkulák] : code improvements 
 * [milan jurkulák] : code improvements 
 * [milan jurkulak] : on main:  
 * [milan jurkulak] : index on main: beb6796 code improvements  

gradle/libs.versions.toml

@@ -1,8 +1,8 @@
+# versions #########################################################################################
 [versions]
 #
-accompanist-permissions = "0.33.2-alpha"
+accompanist-permissions = "0.34.0"
 aescrypt = "0.0.1"
-android-documentation-plugin = "1.9.10"
 android-material = "1.11.0"
 androidsvg-aar = "1.4"
 #
@@ -27,20 +27,17 @@ androidx-window = "1.2.0"
 androidx-work-runtime-ktx = "2.9.0"
 anrwatchdog = "1.4.0"
 apk-parser = "2.6.10"
-app-namespace = "org.mjdev.tvapp"
 auth0 = "2.10.2"
-compileSdk = "34"
 compose = "1.0.0-beta01"
 converter-moshi = "2.9.0"
 dagger = "2.50"
 dailymotion-sdk-android = "0.2.12"
 #
-debug-keyfile = "config/signing.prop"
+
 dependency-analysis-gradle-plugin = "0.10.0"
 detekt-formatting = "1.23.4"
 detekt-gradle-plugin = "1.23.4"
 dokka-gradle-plugin = "1.8.10"
-gfm-plugin = "1.8.10"
 google-api-services-androidpublisher = "v3-rev41-1.25.0"
 gradle = "8.2.2"
 gradle-api = "8.2.2"
@@ -48,26 +45,22 @@ gradle-docker-plugin = "9.4.0"
 gradleOspackagePlugin = "8.4.1"
 ini4j = "0.5.4"
 #
-jacoco-version = "0.8.8"
 javapoet = "1.13.0"
 jsoup = "1.17.2"
 junit = "4.13.2"
 jwtdecode = "2.0.2"
 korim-jvm = "4.0.2"
-kotlin-compiler-version = "1.5.8"
+
 kotlin-gradle-plugin = "1.9.22"
 kotlin-reflect = "1.9.22"
 kotlin-stdlib-jdk8 = "1.9.22"
 kotlinpoet = "1.13.2"
 kotlinter-gradle = "3.16.0"
 kotlinx-coroutines-android = "1.8.0"
-ktoml = "0.5.1"
 landscapist-glide = "2.2.13"
-lib-namespace = "org.mjdev.tvlib"
 lottie-compose = "6.2.0"
 #
 markdownGradlePlugin = "2.2.0"
-minSdk = "21"
 mockito-kotlin = "5.2.1"
 moshi = "1.15.0"
 moshi-kotlin = "1.12.0"
@@ -80,10 +73,8 @@ org-eclipse-jgit = "4.8.0.201706111038-r"
 paparazzi-gradle-plugin = "1.3.2"
 photofilter = "2.0.2"
 r8 = "8.3.37"
-release-keyfile = "config/signing.prop"
 retrofit2-kotlin-coroutines-adapter = "0.9.2"
 sandwich = "2.0.5"
-targetSdk = "34"
 timber = "5.0.1"
 zxing-core = "3.5.2"
 
@@ -136,7 +127,7 @@ androidx-media3-session = { module = "androidx.media3:media3-session", version.r
 androidx-media3-transformer = { module = "androidx.media3:media3-transformer", version.ref = "androidx-media3" }
 androidx-media3-ui = { module = "androidx.media3:media3-ui", version.ref = "androidx-media3" }
 androidx-media3-ui-leanback = { module = "androidx.media3:media3-ui-leanback", version.ref = "androidx-media3" }
-#
+# pallete
 androidx-palette-ktx = { module = "androidx.palette:palette-ktx", version.ref = "androidx-palette-ktx" }
 # tv
 androidx-tv-foundation = { module = "androidx.tv:tv-foundation", version.ref = "androidx-tv" }
@@ -155,17 +146,16 @@ dagger-android-support = { module = "com.google.dagger:dagger-android-support",
 dagger-compiler = { module = "com.google.dagger:dagger-compiler", version.ref = "dagger" }
 dagger-hilt-android = { module = "com.google.dagger:hilt-android", version.ref = "dagger" }
 dagger-hilt-compiler = { module = "com.google.dagger:hilt-compiler", version.ref = "dagger" }
+# dailymotion
 dailymotion-sdk-android = { module = "com.dailymotion.dailymotion-sdk-android:sdk", version.ref = "dailymotion-sdk-android" }
-#
-dependency-analysis-gradle-plugin = { module = "gradle.plugin.com.autonomousapps:dependency-analysis-gradle-plugin", version.ref = "dependency-analysis-gradle-plugin" }
-detekt-formatting = { module = "io.gitlab.arturbosch.detekt:detekt-formatting", version.ref = "detekt-formatting" }
+# git
 eclipse-jgit = { module = "org.eclipse.jgit:org.eclipse.jgit", version.ref = "org-eclipse-jgit" }
 # glide
 glide-compose = { module = "com.github.bumptech.glide:compose", version.ref = "compose" }
 glide-ksp = { module = "com.github.bumptech.glide:ksp", version.ref = "okhttp3-integration" }
 glide-okhttp3-integration = { module = "com.github.bumptech.glide:okhttp3-integration", version.ref = "okhttp3-integration" }
 google-api-services-androidpublisher = { module = "com.google.apis:google-api-services-androidpublisher", version.ref = "google-api-services-androidpublisher" }
-# gradle ###########################################################################################
+# gradle
 gradle = { module = "com.android.tools.build:gradle", version.ref = "gradle" }
 gradle-api = { module = "com.android.tools.build:gradle-api", version.ref = "gradle-api" }
 gradle-detekt-plugin = { module = "io.gitlab.arturbosch.detekt:detekt-gradle-plugin", version.ref = "detekt-gradle-plugin" }
@@ -194,9 +184,6 @@ landscapist-glide = { module = "com.github.skydoves:landscapist-glide", version.
 landscapist-palette = { module = "com.github.skydoves:landscapist-palette", version.ref = "landscapist-glide" }
 landscapist-placeholder = { module = "com.github.skydoves:landscapist-placeholder", version.ref = "landscapist-glide" }
 landscapist-transformation = { module = "com.github.skydoves:landscapist-transformation", version.ref = "landscapist-glide" }
-# ktoml
-#ktoml-core = { module = "com.akuleshov7:ktoml-core", version.ref = "ktoml" }
-#ktoml-file = { module = "com.akuleshov7:ktoml-file", version.ref = "ktoml" }
 # moshi
 moshi = { module = "com.squareup.moshi:moshi", version.ref = "moshi" }
 moshi-kotlin = { module = "com.squareup.moshi:moshi-kotlin", version.ref = "moshi-kotlin" }

tvlib/build.gradle.kts

@@ -11,7 +11,6 @@ plugins {
 }
 
 libConfig {
-    autoCorrectCode = true
-    createDocumentation = true
-    minify = false
+    namespace = "org.mjdev.tvlib"
+    description = "Smart TV android app lib for android applications running on any android device"
 }