Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* Copyright (C) 2022 Slack Technologies, LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
@file:Suppress("TooManyFunctions")
package foundry.gradle
import com.android.builder.model.AndroidProject
import java.util.concurrent.atomic.AtomicBoolean
import kotlin.contracts.InvocationKind
import kotlin.contracts.contract
import kotlin.reflect.javaType
import kotlin.reflect.typeOf
import org.gradle.api.Action
import org.gradle.api.DomainObjectSet
import org.gradle.api.Project
import org.gradle.api.Task
import org.gradle.api.internal.project.ProjectInternal
import org.gradle.api.model.ObjectFactory
import org.gradle.api.plugins.AppliedPlugin
import org.gradle.api.plugins.ExtensionContainer
import org.gradle.api.plugins.PluginManager
import org.gradle.api.provider.ListProperty
import org.gradle.api.provider.MapProperty
import org.gradle.api.provider.Property
import org.gradle.api.provider.Provider
import org.gradle.api.provider.SetProperty
import org.gradle.api.reflect.TypeOf
import org.gradle.api.tasks.TaskContainer
import org.gradle.api.tasks.TaskProvider
import org.gradle.internal.service.ServiceRegistry
/*
* A set of utility functions that check and cache project information stored in extensions.
*/
private const val IS_ANDROID = "foundry.project.ext.isAndroid"
private const val IS_ANDROID_APPLICATION = "foundry.project.ext.isAndroidApplication"
private const val IS_ANDROID_LIBRARY = "foundry.project.ext.isAndroidLibrary"
private const val IS_ANDROID_TEST = "foundry.project.ext.isAndroidTest"
private const val IS_USING_KAPT = "foundry.project.ext.isUsingKapt"
private const val IS_USING_KSP = "foundry.project.ext.isUsingKsp"
private const val IS_USING_MOSHI_IR = "foundry.project.ext.isUsingMoshiIr"
private const val IS_KOTLIN = "foundry.project.ext.isKotlin"
private const val IS_KOTLIN_ANDROID = "foundry.project.ext.isKotlinAndroid"
private const val IS_KOTLIN_JVM = "foundry.project.ext.isKotlinJvm"
private const val IS_KOTLIN_MULTIPLATFORM = "foundry.project.ext.isKotlinMultiplatform"
private const val IS_JAVA_LIBRARY = "foundry.project.ext.isJavaLibrary"
private const val IS_JAVA = "foundry.project.ext.isJava"
internal val Project.isRootProject: Boolean
get() = rootProject === this
internal val Project.isJava: Boolean
get() {
return getOrComputeExt(IS_JAVA) { isJavaLibrary || project.pluginManager.hasPlugin("java") }
}
internal val Project.isJavaLibrary: Boolean
get() {
return getOrComputeExt(IS_JAVA_LIBRARY) { project.pluginManager.hasPlugin("java-library") }
}
internal val Project.isKotlin: Boolean
get() {
return getOrComputeExt(IS_KOTLIN) { isKotlinAndroid || isKotlinJvm }
}
internal val Project.isKotlinAndroid: Boolean
get() {
return getOrComputeExt(IS_KOTLIN_ANDROID) {
project.pluginManager.hasPlugin("org.jetbrains.kotlin.android")
}
}
internal val Project.isKotlinJvm: Boolean
get() {
return getOrComputeExt(IS_KOTLIN_JVM) {
project.pluginManager.hasPlugin("org.jetbrains.kotlin.jvm")
}
}
internal val Project.isKotlinMultiplatform: Boolean
get() {
return getOrComputeExt(IS_KOTLIN_MULTIPLATFORM) {
project.pluginManager.hasPlugin("org.jetbrains.kotlin.multiplatform")
}
}
internal val Project.isUsingKapt: Boolean
get() {
return getOrComputeExt(IS_USING_KAPT) {
project.pluginManager.hasPlugin("org.jetbrains.kotlin.kapt")
}
}
internal val Project.isUsingKsp: Boolean
get() {
return getOrComputeExt(IS_USING_KSP) {
project.pluginManager.hasPlugin("com.google.devtools.ksp")
}
}
internal val Project.isUsingMoshiGradle: Boolean
get() {
return getOrComputeExt(IS_USING_MOSHI_IR) {
project.pluginManager.hasPlugin("dev.zacsweers.moshix")
}
}
internal val Project.isAndroidApplication: Boolean
get() {
return getOrComputeExt(IS_ANDROID_APPLICATION) { plugins.hasPlugin("com.android.application") }
}
internal val Project.isAndroidLibrary: Boolean
get() {
return getOrComputeExt(IS_ANDROID_LIBRARY) { plugins.hasPlugin("com.android.library") }
}
internal val Project.isAndroidTest: Boolean
get() {
return getOrComputeExt(IS_ANDROID_TEST) { plugins.hasPlugin("com.android.test") }
}
internal val Project.isAndroid: Boolean
get() {
return getOrComputeExt(IS_ANDROID) { isAndroidApplication || isAndroidLibrary || isAndroidTest }
}
internal fun Project.getOrComputeExt(key: String, valueCalculator: () -> T): T {
@Suppress("UNCHECKED_CAST")
return (extensions.findByName(key) as? T)
?: run {
val value = valueCalculator()
extensions.add(key, value)
return value
}
}
/** Lifts an action into another action, reusing this action instance as an input to [into]. */
internal fun Action.liftIntoAction(into: R.(task: Action) -> Unit): Action {
return Action { into(this@liftIntoAction) }
}
/** Lifts an action into another action, reusing this action instance as an input to [into]. */
internal fun Action.liftIntoFunction(into: R.(task: Action) -> Unit): R.() -> Unit {
return { into(this@liftIntoFunction) }
}
internal inline fun TaskContainer.register(
name: String,
configuration: Action,
): TaskProvider = register(name, T::class.java, configuration)
internal inline fun Project.configure(action: Action) {
extensions.getByType().apply(action::execute)
}
internal inline fun ExtensionContainer.findByType(): T? {
// Gradle, Kotlin, and Java all have different notions of what a "type" is.
// I'm sorry
return findByType(TypeOf.typeOf(typeOf().javaType))
}
internal inline fun TaskContainer.configureEach(noinline action: T.() -> Unit) {
withType(T::class.java).configureEach(action)
}
internal inline fun ExtensionContainer.getByType(): T {
// Gradle, Kotlin, and Java all have different notions of what a "type" is.
// I'm sorry
return getByType(TypeOf.typeOf(typeOf().javaType))
}
@Suppress("SpreadOperator")
public fun TaskProvider.dependsOn(
vararg tasks: TaskProvider
): TaskProvider {
if (tasks.isEmpty().not()) {
configure { dependsOn(*tasks) }
}
return this
}
internal operator fun ExtensionContainer.set(key: String, value: Any) {
add(key, value)
}
internal fun PluginManager.onFirst(
pluginIds: Iterable,
body: AppliedPlugin.(id: String) -> Unit,
) {
once {
for (id in pluginIds) {
withPlugin(id) { onFirst { body(id) } }
}
}
}
internal inline fun once(body: OnceCheck.() -> Unit) {
contract { callsInPlace(body, InvocationKind.EXACTLY_ONCE) }
OnceCheck().body()
}
@JvmInline
internal value class OnceCheck(val once: AtomicBoolean = AtomicBoolean(false)) {
inline val isActive: Boolean
get() = once.compareAndSet(false, true)
inline fun onFirst(body: () -> Unit) {
if (isActive) {
body()
}
}
}
/**
* Returns true if this execution of Gradle is for an Android Studio Gradle Sync. We're considering
* both the no-task invocation of Gradle that AS uses to build its model, and the invocation of
* "generateXSources" for each project that follows it. (We may want to track these in the future
* too, but for now they're pretty noisy.)
*/
public val Project.isSyncing: Boolean
get() =
invokedFromIde &&
(findProperty(AndroidProject.PROPERTY_BUILD_MODEL_ONLY) == "true" ||
findProperty(AndroidProject.PROPERTY_GENERATE_SOURCES_ONLY) == "true")
// Note that we don't reference the AndroidProject property because this constant moved in AGP 7.2
public val Project.invokedFromIde: Boolean
get() = hasProperty("android.injected.invoked.from.ide")
internal inline fun ObjectFactory.newInstance(vararg parameters: Any): T {
return newInstance(T::class.java, *parameters)
}
internal inline fun ObjectFactory.property(): Property {
return property(T::class.java)
}
internal inline fun ObjectFactory.setProperty(): SetProperty {
return setProperty(E::class.java)
}
internal inline fun ObjectFactory.listProperty(): ListProperty {
return listProperty(E::class.java)
}
internal inline fun ObjectFactory.mapProperty():
MapProperty {
return mapProperty(K::class.java, V::class.java)
}
internal inline fun ObjectFactory.domainObjectSet(): DomainObjectSet {
return domainObjectSet(E::class.java)
}
internal inline fun Project.serviceOf(): T =
(this as ProjectInternal).services.get()
internal inline fun ServiceRegistry.get(): T = this[T::class.java]
@Suppress("UNCHECKED_CAST")
internal inline fun TaskContainer.registerOrConfigure(
taskName: String,
crossinline configureAction: T.() -> Unit,
): TaskProvider =
when (taskName) {
in names -> named(taskName) as TaskProvider
else -> register(taskName, T::class.java)
}.apply { configure { configureAction() } }
/** Returns a provider that is the inverse of this. */
internal fun Provider.not(): Provider = map { !it }
