Migrate Gradle scripts to Kotlin DSL and catalog plugins (598e5371) · Commits · e / os / App Lounge

app/build.gradle→app/build.gradle.kts

+318 −0

Original line number	Diff line number	Diff line
		import java.text.SimpleDateFormat
		import java.util.Date
		import java.util.Locale
		import java.util.Properties

		plugins {
		id 'com.android.application'
		id 'kotlin-android'
		id 'com.google.devtools.ksp'
		alias libs.plugins.ktlint
		alias libs.plugins.kotlin.serialization
		id 'androidx.navigation.safeargs.kotlin'
		id 'com.google.dagger.hilt.android'
		id 'kotlin-allopen'
		id 'kotlin-parcelize'
		id 'jacoco'
		alias libs.plugins.compose.compiler
		alias(libs.plugins.android.application)
		alias(libs.plugins.kotlin.android)
		alias(libs.plugins.ksp)
		alias(libs.plugins.ktlint)
		alias(libs.plugins.kotlin.serialization)
		alias(libs.plugins.navigation.safeargs)
		alias(libs.plugins.hilt.android)
		alias(libs.plugins.kotlin.plugin.allopen)
		alias(libs.plugins.kotlin.parcelize)
		alias(libs.plugins.compose.compiler)
		}

		jacoco {
		toolVersion = libs.versions.jacoco.get()
		}
		val versionMajor = 2
		val versionMinor = 14
		val versionPatch = 6

		def versionMajor = 2
		def versionMinor = 14
		def versionPatch = 6
		val latestGitHash = providers.exec {
		commandLine("git", "log", "--pretty=format:%h", "-n", "1")
		}.standardOutput.asText.get().trim()

		def getGitHashProvider = providers.exec {
		commandLine 'git', 'log', '--pretty=format:%h', '-n', '1'
		val propsFile = project.rootProject.file("local.properties")
		val props =
		Properties().apply {
		if (propsFile.exists()) {
		propsFile.inputStream().use(::load)
		}

		def getGitHash = {
		return getGitHashProvider.standardOutput.asText.get().trim()
		}

		def getDate = { ->
		return new Date().format('yyyyMMddHHmmss')
		}

		def getSentryDsn = { ->

		def sentryDsnEnv = System.getenv("SENTRY_DSN")
		fun getSentryDsn(): String? {
		val sentryDsnEnv = System.getenv("SENTRY_DSN")
		if (sentryDsnEnv != null) {
		return sentryDsnEnv
		}

		Properties properties = new Properties()
		def propertiesFile = project.rootProject.file('local.properties')
		if (propertiesFile.exists()) {
		properties.load(propertiesFile.newDataInputStream())
		}
		return properties.getProperty('SENTRY_DSN')
		}

		def jacocoFileFilter = [
		'**/R.class',
		'*/R$',
		'*/BuildConfig.',
		'*/Manifest.*',
		'*/Test.',
		'/ui/',
		'*/_ViewBinding.',
		'*/Binding.class',
		'*/BindingImpl.class',
		'*/Dagger.*',
		'*/MembersInjector.',
		'*/_Factory.',
		'*/_ProvideFactory.*',
		'*/_GeneratedInjector.',
		'*/Hilt.'
		]

		tasks.withType(Test).configureEach {
		jacoco {
		includeNoLocationClasses = true
		excludes = ['jdk.internal.*']
		}
		return props.getProperty("SENTRY_DSN")
		}

		android {
		compileSdk = 36
		namespace = "foundation.e.apps"

		defaultConfig {
		applicationId = "foundation.e.apps"
		@@ -84,164 +53,145 @@ android {
		versionCode = versionMajor * 1000000 + versionMinor * 1000 + versionPatch
		versionName = "${versionMajor}.${versionMinor}.${versionPatch}"

		buildConfigField "String", "BUILD_ID", "\"${getGitHash() + "." + getDate()}\""
		buildConfigField("String", "SENTRY_DSN", "\"${getSentryDsn()}\"")
		buildConfigField "String", "USER_AGENT", "\"${retrieveKey("user_agent", "Dalvik/2.1.0 (Linux; U; Android %s)")}\""

		def parentalControlPkgName = "foundation.e.parentalcontrol"

		manifestPlaceholders = [parentalControlPkgName: parentalControlPkgName]
		buildConfigField "String", "PACKAGE_NAME_PARENTAL_CONTROL", "\"${parentalControlPkgName}\""
		val parentalControlPkgName = "foundation.e.parentalcontrol"
		manifestPlaceholders["parentalControlPkgName"] = parentalControlPkgName

		buildConfigField(
		"String",
		"BUILD_ID",
		"\"$latestGitHash.${SimpleDateFormat("yyyyMMddHHmmss", Locale.getDefault()).format(Date())}\"")
		buildConfigField(
		"String",
		"SENTRY_DSN",
		"\"${getSentryDsn() ?: "null"}\"")
		buildConfigField(
		"String",
		"USER_AGENT",
		"\"${props.getProperty("user_agent", "Dalvik/2.1.0 (Linux; U; Android %s)")}\""
		)
		buildConfigField(
		"String",
		"PACKAGE_NAME_PARENTAL_CONTROL",
		"\"${parentalControlPkgName}\""
		)

		testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
		}

		signingConfigs {
		def keystore_password = System.getenv('KEYSTORE_PASSWORD')
		debugConfig {
		storeFile file("keystore/platform.jks")
		storePassword "platform"
		keyAlias "platform"
		keyPassword "platform"
		}
		releaseTestConfig {
		val keystorePassword = System.getenv("KEYSTORE_PASSWORD")
		create("debugConfig") {
		storeFile = file("keystore/platform.jks")
		storePassword = "platform"
		keyAlias = "platform"
		keyPassword = "platform"
		}
		create("releaseCommunityConfig") {
		storeFile = file("../keystore/proprietary.keystore")
		storePassword = keystore_password
		keyAlias = 'platform.test'
		keyPassword = keystore_password
		storePassword = keystorePassword
		keyAlias = "platform.dev"
		keyPassword = keystorePassword
		}
		releaseCommunityConfig {
		create("releaseOfficialConfig") {
		storeFile = file("../keystore/proprietary.keystore")
		storePassword = keystore_password
		keyAlias = 'platform.dev'
		keyPassword = keystore_password
		}
		releaseOfficialConfig {
		storeFile = file("../keystore/proprietary.keystore")
		storePassword = keystore_password
		keyAlias = 'platform.stable'
		keyPassword = keystore_password
		storePassword = keystorePassword
		keyAlias = "platform.stable"
		keyPassword = keystorePassword
		}
		}

		sourceSets {
		debug {
		manifest.srcFile 'src/debug/AndroidManifest.xml'
		getByName("debug") {
		manifest.srcFile("src/debug/AndroidManifest.xml")
		}
		releaseTest {
		manifest.srcFile 'src/release/AndroidManifest.xml'
		java.srcDirs = ['src/release/java']
		maybeCreate("releaseTest").apply {
		manifest.srcFile("src/release/AndroidManifest.xml")
		java.srcDirs("src/release/java")
		}
		releaseCommunity {
		manifest.srcFile 'src/release/AndroidManifest.xml'
		java.srcDirs = ['src/release/java']
		maybeCreate("releaseCommunity").apply {
		manifest.srcFile("src/release/AndroidManifest.xml")
		java.srcDirs("src/release/java")
		}
		releaseOfficial {
		manifest.srcFile 'src/release/AndroidManifest.xml'
		java.srcDirs = ['src/release/java']
		maybeCreate("releaseOfficial").apply {
		manifest.srcFile("src/release/AndroidManifest.xml")
		java.srcDirs("src/release/java")
		}
		}

		buildTypes {
		debug {
		signingConfig = signingConfigs.debugConfig
		proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
		}
		release {
		minifyEnabled = false
		signingConfig = signingConfigs.debugConfig
		proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
		getByName("debug") {
		signingConfig = signingConfigs.getByName("debugConfig")
		proguardFiles(
		getDefaultProguardFile("proguard-android-optimize.txt"),
		"proguard-rules.pro"
		)
		}
		getByName("release") {
		isMinifyEnabled = false
		signingConfig = signingConfigs.getByName("debugConfig")
		proguardFiles(
		getDefaultProguardFile("proguard-android-optimize.txt"),
		"proguard-rules.pro"
		)
		}
		create("releaseTest") {
		isMinifyEnabled = false
		signingConfig = signingConfigs.getByName("debugConfig")
		proguardFiles(
		getDefaultProguardFile("proguard-android-optimize.txt"),
		"proguard-rules.pro"
		)
		}
		create("releaseCommunity") {
		isMinifyEnabled = false
		signingConfig = signingConfigs.getByName("releaseCommunityConfig")
		proguardFiles(
		getDefaultProguardFile("proguard-android-optimize.txt"),
		"proguard-rules.pro"
		)
		}
		create("releaseOfficial") {
		isMinifyEnabled = false
		signingConfig = signingConfigs.getByName("releaseOfficialConfig")
		proguardFiles(
		getDefaultProguardFile("proguard-android-optimize.txt"),
		"proguard-rules.pro"
		)
		}
		releaseTest {
		minifyEnabled = false
		signingConfig = signingConfigs.releaseTestConfig
		sourceSets
		proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
		}
		releaseCommunity {
		minifyEnabled = false
		signingConfig = signingConfigs.releaseCommunityConfig
		sourceSets
		proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
		}
		releaseOfficial {
		minifyEnabled = false
		signingConfig = signingConfigs.releaseOfficialConfig
		proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
		}

		applicationVariants.all { variant ->
		variant.outputs.all { output ->
		outputFileName = "AppLounge-${variant.versionName}-${variant.buildType.name}.apk"
		}
		}
		}
		buildFeatures {
		buildConfig = true
		viewBinding = true
		compose = true
		}

		compileOptions {
		sourceCompatibility = JavaVersion.VERSION_21
		targetCompatibility = JavaVersion.VERSION_21
		}
		kotlinOptions {
		jvmTarget = '21'
		}
		lint {
		lintConfig = file('lint.xml')
		}
		namespace = 'foundation.e.apps'
		kotlin.sourceSets.configureEach {
		languageSettings.optIn("kotlin.RequiresOptIn")
		}
		}

		android.applicationVariants.configureEach { variant ->
		def variantCap = variant.name.capitalize()
		def unitTestTaskName = "test${variantCap}UnitTest"
		def unitTestTask = tasks.findByName(unitTestTaskName)
		if (unitTestTask == null) {
		return
		}

		tasks.register("jacoco${variantCap}Report", JacocoReport) {
		dependsOn(unitTestTask)
		group = "verification"
		description = "Generates Jacoco coverage report for the ${variant.name} build."

		reports {
		xml.required = true
		html.required = true
		kotlinOptions {
		jvmTarget = "21"
		}

		def javaClasses = fileTree("${buildDir}/intermediates/javac/${variant.name}/classes") {
		exclude jacocoFileFilter
		lint {
		lintConfig = file("lint.xml")
		}
		def kotlinClasses = fileTree("${buildDir}/tmp/kotlin-classes/${variant.name}") {
		exclude jacocoFileFilter
		}

		classDirectories.from = files(javaClasses, kotlinClasses)

		def sourceDirs = variant.sourceSets.collect { sourceSet ->
		def dirs = []
		dirs.addAll(sourceSet.java.srcDirs)
		if (sourceSet.hasProperty('kotlin')) {
		dirs.addAll(sourceSet.kotlin.srcDirs)
		}
		return dirs
		}.flatten()

		sourceDirectories.from = files(sourceDirs)
		executionData.from = file("${buildDir}/jacoco/${unitTestTaskName}.exec")
		android.applicationVariants.configureEach {
		val variant = this
		variant.outputs.forEach { output ->
		(output as com.android.build.gradle.internal.api.BaseVariantOutputImpl).outputFileName =
		"AppLounge-${variant.versionName}-${variant.buildType.name}.apk"
		}
		}

		allOpen {
		// allows mocking for classes w/o directly opening them for release builds
		annotation 'foundation.e.apps.OpenClass'
		annotation 'foundation.e.apps.OpenForTesting'
		annotation("foundation.e.apps.OpenClass")
		annotation("foundation.e.apps.OpenForTesting")
		}

		dependencies {
		@@ -347,29 +297,22 @@ dependencies {
		implementation(libs.jsoup)

		// Compose
		def composeBom = platform(libs.compose.bom)
		implementation composeBom
		androidTestImplementation composeBom
		val composeBom = platform(libs.compose.bom)
		implementation(composeBom)
		androidTestImplementation(composeBom)

		implementation libs.compose.material3
		implementation libs.compose.material.icons.extended
		implementation(libs.compose.material3)
		implementation(libs.compose.material.icons.extended)

		implementation libs.activity.compose
		implementation libs.lifecycle.viewmodel.compose
		implementation libs.runtime.livedata
		implementation(libs.activity.compose)
		implementation(libs.lifecycle.viewmodel.compose)
		implementation(libs.runtime.livedata)

		// Android Studio Preview support for Compose
		implementation libs.compose.ui.tooling.preview
		debugImplementation libs.compose.ui.tooling
		implementation(libs.compose.ui.tooling.preview)
		debugImplementation(libs.compose.ui.tooling)

		// UI Tests for Compose
		androidTestImplementation libs.compose.ui.test.junit4
		debugImplementation libs.compose.ui.test.manifest
		}

		def retrieveKey(String keyName, String defaultValue) {
		Properties properties = new Properties()
		properties.load(project.rootProject.file('local.properties').newDataInputStream())

		return properties.getProperty(keyName, defaultValue)
		androidTestImplementation(libs.compose.ui.test.junit4)
		debugImplementation(libs.compose.ui.test.manifest)
		}

parental-control-data/build.gradle→auth-data-lib/build.gradle.kts

+48 −0

Original line number	Diff line number	Diff line
		plugins {
		id 'java-library'
		id 'org.jetbrains.kotlin.jvm'
		id 'maven-publish'
		alias(libs.plugins.java.library)
		alias(libs.plugins.kotlin.jvm)
		alias(libs.plugins.maven.publish)
		}

		java {
		@@ -11,21 +11,21 @@ java {

		publishing {
		publications {
		jar(MavenPublication) {
		groupId = 'foundation.e.apps'
		artifactId = 'ParentalControlData'
		version = '1.2.0'
		create<MavenPublication>("jar") {
		groupId = "foundation.e.apps"
		artifactId = "auth-data-lib"
		version = "1.1.0"

		artifact("$buildDir/libs/${project.name}.jar")
		artifact("${layout.buildDirectory}/libs/${project.name}.jar")

		pom {
		name = 'ParentalControlContract'
		description = 'Constants to be used in App Lounge content provider'
		name.set("AuthDataLib")
		description.set("Library providing AuthData through a content provider")

		licenses {
		license {
		name = 'The Apache Software License, Version 2.0'
		url = 'http://www.apache.org/licenses/LICENSE-2.0.txt'
		name.set("The Apache Software License, Version 2.0")
		url.set("http://www.apache.org/licenses/LICENSE-2.0.txt")
		}
		}
		}
		@@ -36,12 +36,12 @@ publishing {
		maven {
		name = "GitLab"
		url = uri("https://gitlab.e.foundation/api/v4/projects/355/packages/maven")
		credentials(HttpHeaderCredentials) {
		credentials(HttpHeaderCredentials::class) {
		name = "Job-Token"
		value = System.getenv("CI_JOB_TOKEN")
		}
		authentication {
		header(HttpHeaderAuthentication)
		create("header", HttpHeaderAuthentication::class)
		}
		}
		}

build.gradle

deleted100644 → 0

+0 −48

Original line number	Diff line number	Diff line
		// Top-level build file where you can add configuration options common to all sub-projects/modules.

		plugins {
		alias libs.plugins.android.application apply false
		alias libs.plugins.android.library apply false
		alias libs.plugins.kotlin.android apply false
		alias libs.plugins.kotlin.plugin.allopen apply false
		alias libs.plugins.kotlin.jvm apply false
		alias libs.plugins.kotlin.serialization apply false
		alias libs.plugins.hilt.android apply false
		alias libs.plugins.ksp apply false
		alias libs.plugins.navigation.safeargs apply false
		alias libs.plugins.detekt
		alias libs.plugins.compose.compiler apply false

		}

		allprojects {
		tasks.withType(JavaCompile).tap {
		configureEach {
		options.deprecation = true
		options.compilerArgs += ['-Werror']
		}
		}
		}

		detekt {
		source.setFrom("app/src/main/java", "app/src/main/kotlin")
		config.setFrom("detekt.yml")
		baseline = file("app/detekt-baseline.xml")
		parallel = false
		buildUponDefaultConfig = true
		allRules = false
		disableDefaultRuleSets = false
		debug = false
		ignoreFailures = false
		basePath = projectDir
		}

		dependencies {
		detektPlugins libs.detekt.formatting
		detektPlugins libs.detekt.compose
		}

		tasks.register('clean', Delete) {
		delete rootProject.buildDir
		}

build.gradle.kts

0 → 100644

+141 −0

Original line number	Diff line number	Diff line
		import com.android.build.gradle.AppExtension
		import java.io.File
		import org.gradle.testing.jacoco.plugins.JacocoPluginExtension
		import com.android.builder.model.SourceProvider
		import org.gradle.testing.jacoco.plugins.JacocoTaskExtension
		import org.gradle.testing.jacoco.tasks.JacocoReport

		// Top-level build file where you can add configuration options common to all sub-projects/modules.

		plugins {
		alias(libs.plugins.android.application) apply false
		alias(libs.plugins.android.library) apply false
		alias(libs.plugins.kotlin.android) apply false
		alias(libs.plugins.kotlin.plugin.allopen) apply false
		alias(libs.plugins.kotlin.jvm) apply false
		alias(libs.plugins.kotlin.serialization) apply false
		alias(libs.plugins.hilt.android) apply false
		alias(libs.plugins.ksp) apply false
		alias(libs.plugins.navigation.safeargs) apply false
		alias(libs.plugins.detekt)
		alias(libs.plugins.jacoco)
		alias(libs.plugins.compose.compiler) apply false
		}

		allprojects {
		tasks.withType<JavaCompile>().configureEach {
		options.isDeprecation = true
		options.compilerArgs.add("-Werror")
		}
		}

		subprojects {
		plugins.withId("jacoco") {
		extensions.configure<JacocoPluginExtension> {
		toolVersion = libs.versions.jacoco.get()
		}
		tasks.withType<Test>().configureEach {
		extensions.findByType(JacocoTaskExtension::class.java)?.apply {
		isIncludeNoLocationClasses = true
		excludes = mutableListOf("jdk.internal.*")
		}
		}
		}

		plugins.withId("com.android.application") {
		val jacocoFileFilter = listOf(
		"**/R.class",
		"*/R$",
		"*/BuildConfig.",
		"*/Manifest.*",
		"*/Test.",
		"/ui/",
		"*/_ViewBinding.",
		"*/Binding.class",
		"*/BindingImpl.class",
		"*/Dagger.*",
		"*/MembersInjector.",
		"*/_Factory.",
		"*/_ProvideFactory.*",
		"*/_GeneratedInjector.",
		"*/Hilt."
		)

		extensions.configure<AppExtension> {
		applicationVariants.configureEach {
		val variantName = this.name
		val variantCap = variantName[0].uppercase() + variantName.substring(1)
		val unitTestTaskName = "test${variantCap}UnitTest"
		val unitTestTask = tasks.findByName(unitTestTaskName) ?: return@configureEach

		val jacocoAnt = configurations.findByName("jacocoAnt")
		?: configurations.create("jacocoAnt")
		if (jacocoAnt.dependencies.isEmpty()) {
		jacocoAnt.dependencies.add(
		dependencies.create("org.jacoco:org.jacoco.ant:${libs.versions.jacoco.get()}")
		)
		}

		tasks.register<JacocoReport>("jacoco${variantCap}Report") {
		dependsOn(unitTestTask)
		group = "verification"
		description = "Generates Jacoco coverage report for the ${this.name} build."
		jacocoClasspath = jacocoAnt

		reports {
		xml.required.set(true)
		xml.outputLocation.set(layout.buildDirectory.file("reports/jacoco/${name}/jacoco.xml"))
		html.required.set(true)
		html.outputLocation.set(layout.buildDirectory.dir("reports/jacoco/${name}/html"))
		}

		val javaClasses = fileTree(
		layout.buildDirectory.dir("intermediates/javac/$variantName/classes")) {
		exclude(jacocoFileFilter)
		}
		val kotlinClasses = fileTree(
		layout.buildDirectory.dir("tmp/kotlin-classes/$variantName")) {
		exclude(jacocoFileFilter)
		}

		classDirectories.setFrom(files(javaClasses, kotlinClasses))

		val sourceDirs = mutableListOf<File>()
		sourceSets.forEach { sourceProvider: SourceProvider ->
		sourceDirs.addAll(sourceProvider.javaDirectories)
		val kotlinDir = file("src/${sourceProvider.name}/kotlin")
		if (kotlinDir.exists()) {
		sourceDirs.add(kotlinDir)
		}
		}

		sourceDirectories.setFrom(files(sourceDirs))
		executionData.setFrom(
		layout.buildDirectory.file("jacoco/${unitTestTaskName}.exec"))
		}
		}
		}
		}
		}

		detekt {
		source.setFrom(files("app/src/main/java", "app/src/main/kotlin"))
		config.setFrom(files("detekt.yml"))
		baseline = file("app/detekt-baseline.xml")
		parallel = false
		buildUponDefaultConfig = true
		allRules = false
		disableDefaultRuleSets = false
		debug = false
		ignoreFailures = false
		basePath = projectDir.absolutePath
		}

		dependencies {
		detektPlugins(libs.detekt.formatting)
		detektPlugins(libs.detekt.compose)
		}

		tasks.register<Delete>("clean") {
		delete(rootProject.layout.buildDirectory)
		}

gradle/libs.versions.toml

+5 −1

Original line number	Diff line number	Diff line
		@@ -136,12 +136,16 @@ work-runtime-ktx = { module = "androidx.work:work-runtime-ktx", version.ref = "w
		android-application = { id = "com.android.application", version.ref = "androidGradlePlugin" }
		android-library = { id = "com.android.library", version.ref = "androidGradlePlugin" }
		compose-compiler = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
		kotlin-parcelize = { id = "kotlin-parcelize" }
		kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
		kotlin-plugin-allopen = { id = "org.jetbrains.kotlin.plugin.allopen", version.ref = "kotlin" }
		kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }
		kotlin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }
		hilt-android = { id = "com.google.dagger.hilt.android", version.ref = "hilt" }
		ksp = { id = "com.google.devtools.ksp", version.ref = "ksp" }
		navigation-safeargs = { id = "androidx.navigation.safeargs", version.ref = "navigation" }
		navigation-safeargs = { id = "androidx.navigation.safeargs.kotlin", version.ref = "navigation" }
		detekt = { id = "io.gitlab.arturbosch.detekt", version.ref = "detekt" }
		ktlint = { id = "org.jlleitschuh.gradle.ktlint", version.ref = "ktlint" }
		java-library = { id = "java-library" }
		maven-publish = { id = "maven-publish" }
		jacoco = { id = "jacoco" }