Mastodon
/
pachli-android
mirror of https://github.com/pachli/pachli-android.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
pachli-android/settings.gradle.kts

72 lines
1.8 KiB
Plaintext
Raw Normal View History

refactor: Start creating core modules (#286) The existing code base is a single monolithic module. This is relatively simple to configure, but many of the tasks to compile the module and produce the final app have to run in series. This is unnecessarily slow. This change starts to split the code in to multiple modules, which are: - :core:account - AccountManager, to break a dependency cycle - :core:common - low level types or utilities used in many other modules - :core:database - database types, DAOs, and DI infrastructure - :core:network - network types, API definitions, and DI infrastructure - :core:preferences - shared preferences definitions and DI infrastructure - :core:testing - fakes and rules used across different modules Benchmarking with gradle-profiler shows a ~ 17% reduction in incremental build times after an ABI change. That will improve further as more code is moved to modules. The rough mechanics of the changes are: - Create the modules, and move existing files in to them. This causes a lot of churn in import arguments. - Convert build.gradle files to build.gradle.kts - Separate out the data required to display a tab (`TabViewData`) from the data required to configure a tab (`TabData`) to avoid circular dependencies. - Abstract the repeated build logic shared between the modules in to a set of plugins under `build-logic/`, to simplify configuration of the application and library builds. - Be explicit that some nullable types are non-null at time of use. Nullable properties in types imported from modules generally can't be smart cast to non-null. There's a detailed discussion of why this restriction exists at https://discuss.kotlinlang.org/t/what-is-the-reason-behind-smart-cast-being-impossible-to-perform-when-referenced-class-is-in-another-module/2201. The changes highlight design problems with the current code, including: - The main application code is too tightly coupled to the network types - Too many values are declared unnecessarily nullable - Dependency cycles between code that make modularisation difficult Future changes will add more modules. See #291.
2023-12-04 16:58:36 +01:00
pluginManagement {
repositories {
chore: Only look for Google produced artifacts in Google repositories (#530) Optimise the `repositories` declaration with a Gradle content filter that limits the `google()` repository to just Google artifacts. Results in a slight speedup when checking repositories, as the `google()` repository can be skipped when looking for non-Google artifacts.
2024-03-14 13:31:28 +01:00
google {
content {
includeGroupByRegex("com\\.android.*")
includeGroupByRegex("com\\.google.*")
includeGroupByRegex("androidx.*")
}
}
refactor: Start creating core modules (#286) The existing code base is a single monolithic module. This is relatively simple to configure, but many of the tasks to compile the module and produce the final app have to run in series. This is unnecessarily slow. This change starts to split the code in to multiple modules, which are: - :core:account - AccountManager, to break a dependency cycle - :core:common - low level types or utilities used in many other modules - :core:database - database types, DAOs, and DI infrastructure - :core:network - network types, API definitions, and DI infrastructure - :core:preferences - shared preferences definitions and DI infrastructure - :core:testing - fakes and rules used across different modules Benchmarking with gradle-profiler shows a ~ 17% reduction in incremental build times after an ABI change. That will improve further as more code is moved to modules. The rough mechanics of the changes are: - Create the modules, and move existing files in to them. This causes a lot of churn in import arguments. - Convert build.gradle files to build.gradle.kts - Separate out the data required to display a tab (`TabViewData`) from the data required to configure a tab (`TabData`) to avoid circular dependencies. - Abstract the repeated build logic shared between the modules in to a set of plugins under `build-logic/`, to simplify configuration of the application and library builds. - Be explicit that some nullable types are non-null at time of use. Nullable properties in types imported from modules generally can't be smart cast to non-null. There's a detailed discussion of why this restriction exists at https://discuss.kotlinlang.org/t/what-is-the-reason-behind-smart-cast-being-impossible-to-perform-when-referenced-class-is-in-another-module/2201. The changes highlight design problems with the current code, including: - The main application code is too tightly coupled to the network types - Too many values are declared unnecessarily nullable - Dependency cycles between code that make modularisation difficult Future changes will add more modules. See #291.
2023-12-04 16:58:36 +01:00
gradlePluginPortal()
}
includeBuild("build-logic")
includeBuild("plugins/markdown2resource")
}
dependencyResolutionManagement {
chore(deps): update dependency gradle to v8.6 (#411) Use new simple property assignment syntax in build files where appropriate.
2024-02-03 15:05:43 +01:00
repositoriesMode = RepositoriesMode.FAIL_ON_PROJECT_REPOS
refactor: Start creating core modules (#286) The existing code base is a single monolithic module. This is relatively simple to configure, but many of the tasks to compile the module and produce the final app have to run in series. This is unnecessarily slow. This change starts to split the code in to multiple modules, which are: - :core:account - AccountManager, to break a dependency cycle - :core:common - low level types or utilities used in many other modules - :core:database - database types, DAOs, and DI infrastructure - :core:network - network types, API definitions, and DI infrastructure - :core:preferences - shared preferences definitions and DI infrastructure - :core:testing - fakes and rules used across different modules Benchmarking with gradle-profiler shows a ~ 17% reduction in incremental build times after an ABI change. That will improve further as more code is moved to modules. The rough mechanics of the changes are: - Create the modules, and move existing files in to them. This causes a lot of churn in import arguments. - Convert build.gradle files to build.gradle.kts - Separate out the data required to display a tab (`TabViewData`) from the data required to configure a tab (`TabData`) to avoid circular dependencies. - Abstract the repeated build logic shared between the modules in to a set of plugins under `build-logic/`, to simplify configuration of the application and library builds. - Be explicit that some nullable types are non-null at time of use. Nullable properties in types imported from modules generally can't be smart cast to non-null. There's a detailed discussion of why this restriction exists at https://discuss.kotlinlang.org/t/what-is-the-reason-behind-smart-cast-being-impossible-to-perform-when-referenced-class-is-in-another-module/2201. The changes highlight design problems with the current code, including: - The main application code is too tightly coupled to the network types - Too many values are declared unnecessarily nullable - Dependency cycles between code that make modularisation difficult Future changes will add more modules. See #291.
2023-12-04 16:58:36 +01:00
repositories {
chore: Only look for Google produced artifacts in Google repositories (#530) Optimise the `repositories` declaration with a Gradle content filter that limits the `google()` repository to just Google artifacts. Results in a slight speedup when checking repositories, as the `google()` repository can be skipped when looking for non-Google artifacts.
2024-03-14 13:31:28 +01:00
google {
content {
includeGroupByRegex("com\\.android.*")
includeGroupByRegex("com\\.google.*")
includeGroupByRegex("androidx.*")
}
}
refactor: Start creating core modules (#286) The existing code base is a single monolithic module. This is relatively simple to configure, but many of the tasks to compile the module and produce the final app have to run in series. This is unnecessarily slow. This change starts to split the code in to multiple modules, which are: - :core:account - AccountManager, to break a dependency cycle - :core:common - low level types or utilities used in many other modules - :core:database - database types, DAOs, and DI infrastructure - :core:network - network types, API definitions, and DI infrastructure - :core:preferences - shared preferences definitions and DI infrastructure - :core:testing - fakes and rules used across different modules Benchmarking with gradle-profiler shows a ~ 17% reduction in incremental build times after an ABI change. That will improve further as more code is moved to modules. The rough mechanics of the changes are: - Create the modules, and move existing files in to them. This causes a lot of churn in import arguments. - Convert build.gradle files to build.gradle.kts - Separate out the data required to display a tab (`TabViewData`) from the data required to configure a tab (`TabData`) to avoid circular dependencies. - Abstract the repeated build logic shared between the modules in to a set of plugins under `build-logic/`, to simplify configuration of the application and library builds. - Be explicit that some nullable types are non-null at time of use. Nullable properties in types imported from modules generally can't be smart cast to non-null. There's a detailed discussion of why this restriction exists at https://discuss.kotlinlang.org/t/what-is-the-reason-behind-smart-cast-being-impossible-to-perform-when-referenced-class-is-in-another-module/2201. The changes highlight design problems with the current code, including: - The main application code is too tightly coupled to the network types - Too many values are declared unnecessarily nullable - Dependency cycles between code that make modularisation difficult Future changes will add more modules. See #291.
2023-12-04 16:58:36 +01:00
mavenCentral()
maven("https://jitpack.io")
}
}
build: Publish Gradle buildscans when CI variable is non-empty (#316) This should allow for periodic tracking of improvements (or regressions) in the build performance. Fixes #314
2023-12-12 15:17:47 +01:00
plugins {
chore(deps): update plugin com.gradle.enterprise to com.gradle.develocity (#612)
2024-04-10 20:03:06 +02:00
id("com.gradle.develocity") version "3.17"
build: Publish Gradle buildscans when CI variable is non-empty (#316) This should allow for periodic tracking of improvements (or regressions) in the build performance. Fixes #314
2023-12-12 15:17:47 +01:00
}
chore(deps): update plugin com.gradle.enterprise to com.gradle.develocity (#612)
2024-04-10 20:03:06 +02:00
develocity {
build: Publish Gradle buildscans when CI variable is non-empty (#316) This should allow for periodic tracking of improvements (or regressions) in the build performance. Fixes #314
2023-12-12 15:17:47 +01:00
buildScan {
chore(deps): update plugin com.gradle.enterprise to com.gradle.develocity (#612)
2024-04-10 20:03:06 +02:00
termsOfUseUrl = "https://gradle.com/help/legal-terms-of-use"
termsOfUseAgree = "yes"
val isCiBuild = providers.environmentVariable("CI").isPresent
uploadInBackground = !isCiBuild
build: Publish Gradle buildscans when CI variable is non-empty (#316) This should allow for periodic tracking of improvements (or regressions) in the build performance. Fixes #314
2023-12-12 15:17:47 +01:00
tag(if (isCiBuild) "CI" else "Local")
chore(deps): update plugin com.gradle.enterprise to com.gradle.develocity (#612)
2024-04-10 20:03:06 +02:00
publishing.onlyIf { isCiBuild }
build: Publish Gradle buildscans when CI variable is non-empty (#316) This should allow for periodic tracking of improvements (or regressions) in the build performance. Fixes #314
2023-12-12 15:17:47 +01:00
}
}
refactor: Start creating core modules (#286) The existing code base is a single monolithic module. This is relatively simple to configure, but many of the tasks to compile the module and produce the final app have to run in series. This is unnecessarily slow. This change starts to split the code in to multiple modules, which are: - :core:account - AccountManager, to break a dependency cycle - :core:common - low level types or utilities used in many other modules - :core:database - database types, DAOs, and DI infrastructure - :core:network - network types, API definitions, and DI infrastructure - :core:preferences - shared preferences definitions and DI infrastructure - :core:testing - fakes and rules used across different modules Benchmarking with gradle-profiler shows a ~ 17% reduction in incremental build times after an ABI change. That will improve further as more code is moved to modules. The rough mechanics of the changes are: - Create the modules, and move existing files in to them. This causes a lot of churn in import arguments. - Convert build.gradle files to build.gradle.kts - Separate out the data required to display a tab (`TabViewData`) from the data required to configure a tab (`TabData`) to avoid circular dependencies. - Abstract the repeated build logic shared between the modules in to a set of plugins under `build-logic/`, to simplify configuration of the application and library builds. - Be explicit that some nullable types are non-null at time of use. Nullable properties in types imported from modules generally can't be smart cast to non-null. There's a detailed discussion of why this restriction exists at https://discuss.kotlinlang.org/t/what-is-the-reason-behind-smart-cast-being-impossible-to-perform-when-referenced-class-is-in-another-module/2201. The changes highlight design problems with the current code, including: - The main application code is too tightly coupled to the network types - Too many values are declared unnecessarily nullable - Dependency cycles between code that make modularisation difficult Future changes will add more modules. See #291.
2023-12-04 16:58:36 +01:00
enableFeaturePreview("STABLE_CONFIGURATION_CACHE")
enableFeaturePreview("TYPESAFE_PROJECT_ACCESSORS")
rootProject.name = "pachli-android"
include(":app")
include(":core:accounts")
refactor: Modularise core activity classes, (#393) Continue modularisation by moving core activity classes that almost all activities depende on to a `core.activity` module. This includes core "helper" classes as well. Implement core.activity: - Contains BaseActivity, BottomSheetActivity - Contains LinkHelper and other utility classes used by activities Implement core.common.extensions: - Move ViewBindingExtensions and ViewExtensions here Implement core.common.util: - Move BlurHashDecoder and VersionName here Implement core.designsystem: - Holds common resources (animations, colours, drawables, etc) used through the app - Import "core.designsystem.R as DR" through the app to distinguish from the module's own resources Implement feature.login: - Move the LoginActivity and related code/resources to its own module Implement tools/mvstring - Moves string resources (and all translations) from one module to another
2024-01-30 11:37:00 +01:00
include(":core:activity")
refactor: Start creating core modules (#286) The existing code base is a single monolithic module. This is relatively simple to configure, but many of the tasks to compile the module and produce the final app have to run in series. This is unnecessarily slow. This change starts to split the code in to multiple modules, which are: - :core:account - AccountManager, to break a dependency cycle - :core:common - low level types or utilities used in many other modules - :core:database - database types, DAOs, and DI infrastructure - :core:network - network types, API definitions, and DI infrastructure - :core:preferences - shared preferences definitions and DI infrastructure - :core:testing - fakes and rules used across different modules Benchmarking with gradle-profiler shows a ~ 17% reduction in incremental build times after an ABI change. That will improve further as more code is moved to modules. The rough mechanics of the changes are: - Create the modules, and move existing files in to them. This causes a lot of churn in import arguments. - Convert build.gradle files to build.gradle.kts - Separate out the data required to display a tab (`TabViewData`) from the data required to configure a tab (`TabData`) to avoid circular dependencies. - Abstract the repeated build logic shared between the modules in to a set of plugins under `build-logic/`, to simplify configuration of the application and library builds. - Be explicit that some nullable types are non-null at time of use. Nullable properties in types imported from modules generally can't be smart cast to non-null. There's a detailed discussion of why this restriction exists at https://discuss.kotlinlang.org/t/what-is-the-reason-behind-smart-cast-being-impossible-to-perform-when-referenced-class-is-in-another-module/2201. The changes highlight design problems with the current code, including: - The main application code is too tightly coupled to the network types - Too many values are declared unnecessarily nullable - Dependency cycles between code that make modularisation difficult Future changes will add more modules. See #291.
2023-12-04 16:58:36 +01:00
include(":core:common")
refactor: Modularise "about" activities (#405) Continue modularisation by moving activities in the "About" feature to a new `feature.about` module. Implement `feature.about: - Move `AboutActivity`, `LicenseActivity`, and `PrivacyPolicyActivity` here. - Update `markdown2resource` plugin to work with libraries Implement `core.data`: - Types and repositories used through the app - Move `InstanceInfo` and `InstanceInfoRepository` here so they are available to `feature.about`. Implement `core.ui`: - App-specific views, spans, and other UI content - Move `ClickableSpanTextView` and `NoUnderlineURLSpan` here so they are available to `feature.about`.
2024-02-02 15:14:31 +01:00
include(":core:data")
refactor: Start creating core modules (#286) The existing code base is a single monolithic module. This is relatively simple to configure, but many of the tasks to compile the module and produce the final app have to run in series. This is unnecessarily slow. This change starts to split the code in to multiple modules, which are: - :core:account - AccountManager, to break a dependency cycle - :core:common - low level types or utilities used in many other modules - :core:database - database types, DAOs, and DI infrastructure - :core:network - network types, API definitions, and DI infrastructure - :core:preferences - shared preferences definitions and DI infrastructure - :core:testing - fakes and rules used across different modules Benchmarking with gradle-profiler shows a ~ 17% reduction in incremental build times after an ABI change. That will improve further as more code is moved to modules. The rough mechanics of the changes are: - Create the modules, and move existing files in to them. This causes a lot of churn in import arguments. - Convert build.gradle files to build.gradle.kts - Separate out the data required to display a tab (`TabViewData`) from the data required to configure a tab (`TabData`) to avoid circular dependencies. - Abstract the repeated build logic shared between the modules in to a set of plugins under `build-logic/`, to simplify configuration of the application and library builds. - Be explicit that some nullable types are non-null at time of use. Nullable properties in types imported from modules generally can't be smart cast to non-null. There's a detailed discussion of why this restriction exists at https://discuss.kotlinlang.org/t/what-is-the-reason-behind-smart-cast-being-impossible-to-perform-when-referenced-class-is-in-another-module/2201. The changes highlight design problems with the current code, including: - The main application code is too tightly coupled to the network types - Too many values are declared unnecessarily nullable - Dependency cycles between code that make modularisation difficult Future changes will add more modules. See #291.
2023-12-04 16:58:36 +01:00
include(":core:database")
refactor: Modularise core activity classes, (#393) Continue modularisation by moving core activity classes that almost all activities depende on to a `core.activity` module. This includes core "helper" classes as well. Implement core.activity: - Contains BaseActivity, BottomSheetActivity - Contains LinkHelper and other utility classes used by activities Implement core.common.extensions: - Move ViewBindingExtensions and ViewExtensions here Implement core.common.util: - Move BlurHashDecoder and VersionName here Implement core.designsystem: - Holds common resources (animations, colours, drawables, etc) used through the app - Import "core.designsystem.R as DR" through the app to distinguish from the module's own resources Implement feature.login: - Move the LoginActivity and related code/resources to its own module Implement tools/mvstring - Moves string resources (and all translations) from one module to another
2024-01-30 11:37:00 +01:00
include(":core:designsystem")
refactor: Remove `TabData` type (#576) `TabData` recorded the type of the timeline the user had added to a tab. `TimelineKind` is another type that records general information about configured timelines, with identical properties. There's no need for both, so remove `TabData` and use `TimelineKind` in its place. `TimelineKind` is itself mis-named; it's not just the timeline's kind but also holds data necessary to display that timeline (e.g., the list ID if it's a `.UserList`, or the hashtags if it's a `.Hashtags`) so rename to `Timeline` to better reflect its usage. Move it to a new `core.model` module.
2024-03-30 23:27:25 +01:00
include(":core:model")
refactor: Start creating core modules (#286) The existing code base is a single monolithic module. This is relatively simple to configure, but many of the tasks to compile the module and produce the final app have to run in series. This is unnecessarily slow. This change starts to split the code in to multiple modules, which are: - :core:account - AccountManager, to break a dependency cycle - :core:common - low level types or utilities used in many other modules - :core:database - database types, DAOs, and DI infrastructure - :core:network - network types, API definitions, and DI infrastructure - :core:preferences - shared preferences definitions and DI infrastructure - :core:testing - fakes and rules used across different modules Benchmarking with gradle-profiler shows a ~ 17% reduction in incremental build times after an ABI change. That will improve further as more code is moved to modules. The rough mechanics of the changes are: - Create the modules, and move existing files in to them. This causes a lot of churn in import arguments. - Convert build.gradle files to build.gradle.kts - Separate out the data required to display a tab (`TabViewData`) from the data required to configure a tab (`TabData`) to avoid circular dependencies. - Abstract the repeated build logic shared between the modules in to a set of plugins under `build-logic/`, to simplify configuration of the application and library builds. - Be explicit that some nullable types are non-null at time of use. Nullable properties in types imported from modules generally can't be smart cast to non-null. There's a detailed discussion of why this restriction exists at https://discuss.kotlinlang.org/t/what-is-the-reason-behind-smart-cast-being-impossible-to-perform-when-referenced-class-is-in-another-module/2201. The changes highlight design problems with the current code, including: - The main application code is too tightly coupled to the network types - Too many values are declared unnecessarily nullable - Dependency cycles between code that make modularisation difficult Future changes will add more modules. See #291.
2023-12-04 16:58:36 +01:00
include(":core:preferences")
refactor: Break navigation dependency cycles with :core:navigation (#305) The previous code generally started an activity by having the activity provide a method in a companion object that returns the relevant intent, possibly taking additional parameters that will be included in the intent as extras. E.g., if A wants to start B, B provides the method that returns the intent that starts B. This introduces a dependency between A and B. This is worse if B also wants to start A. For example, if A is `StatusListActivity` and B is`ViewThreadActivity`. The user might click a status in `StatusListActivity` to view the thread, starting `ViewThreadActivity`. But from the thread they might click a hashtag to view the list of statuses with that hashtag. Now `StatusListActivity` and `ViewThreadActivity` have a circular dependency. Even if that doesn't happen the dependency means that any changes to B will trigger a rebuild of A, even if the changes to B are not relevant. Break this dependency by adding a `:core:navigation` module with an `app.pachli.core.navigation` package that contains `Intent` subclasses that should be used instead. The `quadrant` plugin is used to generate constants that can be used to launch activities by name instead of by class, breaking the dependency chain. The plugin uses the `Activity` names from the manifest, so when an activity is moved in the future the constant will automatically update to reflect the new package name. If the activity's intent requires specific extras those are passed via the constructor, with companion object methods to extract them from the intent. Using the intent classes from this package is enforced by a lint `IntentDetector` which will warn if any intents are created using a class literal. See #291
2023-12-07 18:36:00 +01:00
include(":core:navigation")
refactor: Start creating core modules (#286) The existing code base is a single monolithic module. This is relatively simple to configure, but many of the tasks to compile the module and produce the final app have to run in series. This is unnecessarily slow. This change starts to split the code in to multiple modules, which are: - :core:account - AccountManager, to break a dependency cycle - :core:common - low level types or utilities used in many other modules - :core:database - database types, DAOs, and DI infrastructure - :core:network - network types, API definitions, and DI infrastructure - :core:preferences - shared preferences definitions and DI infrastructure - :core:testing - fakes and rules used across different modules Benchmarking with gradle-profiler shows a ~ 17% reduction in incremental build times after an ABI change. That will improve further as more code is moved to modules. The rough mechanics of the changes are: - Create the modules, and move existing files in to them. This causes a lot of churn in import arguments. - Convert build.gradle files to build.gradle.kts - Separate out the data required to display a tab (`TabViewData`) from the data required to configure a tab (`TabData`) to avoid circular dependencies. - Abstract the repeated build logic shared between the modules in to a set of plugins under `build-logic/`, to simplify configuration of the application and library builds. - Be explicit that some nullable types are non-null at time of use. Nullable properties in types imported from modules generally can't be smart cast to non-null. There's a detailed discussion of why this restriction exists at https://discuss.kotlinlang.org/t/what-is-the-reason-behind-smart-cast-being-impossible-to-perform-when-referenced-class-is-in-another-module/2201. The changes highlight design problems with the current code, including: - The main application code is too tightly coupled to the network types - Too many values are declared unnecessarily nullable - Dependency cycles between code that make modularisation difficult Future changes will add more modules. See #291.
2023-12-04 16:58:36 +01:00
include(":core:network")
include(":core:testing")
refactor: Modularise "about" activities (#405) Continue modularisation by moving activities in the "About" feature to a new `feature.about` module. Implement `feature.about: - Move `AboutActivity`, `LicenseActivity`, and `PrivacyPolicyActivity` here. - Update `markdown2resource` plugin to work with libraries Implement `core.data`: - Types and repositories used through the app - Move `InstanceInfo` and `InstanceInfoRepository` here so they are available to `feature.about`. Implement `core.ui`: - App-specific views, spans, and other UI content - Move `ClickableSpanTextView` and `NoUnderlineURLSpan` here so they are available to `feature.about`.
2024-02-02 15:14:31 +01:00
include(":core:ui")
include(":feature:about")
refactor: Extract user list functionality to `feature:lists` (#537) Move `ListsActivity`, along with fragments and viewmodels, to a new `feature:lists` module. Previous code used the `item_follow_request` layout, which was not ideal, so update it to use a dedicated layout, `item_account_in_list`. The UI uses strings and views originally defined in the main app, so move them elsewhere so they can be re-used. - `BackgroundMessageView` moves to `core.ui`. - `Lazy` moves to `core.common`. - `ThrowableExtensions` split; the extensions specific to throwables from network activity move to `core.network`, others move to `core.ui`. - `BindingHolder` moves to `core.ui` - Shared drawables and strings move to `core.ui`.
2024-03-16 18:42:11 +01:00
include(":feature:lists")
refactor: Modularise core activity classes, (#393) Continue modularisation by moving core activity classes that almost all activities depende on to a `core.activity` module. This includes core "helper" classes as well. Implement core.activity: - Contains BaseActivity, BottomSheetActivity - Contains LinkHelper and other utility classes used by activities Implement core.common.extensions: - Move ViewBindingExtensions and ViewExtensions here Implement core.common.util: - Move BlurHashDecoder and VersionName here Implement core.designsystem: - Holds common resources (animations, colours, drawables, etc) used through the app - Import "core.designsystem.R as DR" through the app to distinguish from the module's own resources Implement feature.login: - Move the LoginActivity and related code/resources to its own module Implement tools/mvstring - Moves string resources (and all translations) from one module to another
2024-01-30 11:37:00 +01:00
include(":feature:login")
refactor: Start creating core modules (#286) The existing code base is a single monolithic module. This is relatively simple to configure, but many of the tasks to compile the module and produce the final app have to run in series. This is unnecessarily slow. This change starts to split the code in to multiple modules, which are: - :core:account - AccountManager, to break a dependency cycle - :core:common - low level types or utilities used in many other modules - :core:database - database types, DAOs, and DI infrastructure - :core:network - network types, API definitions, and DI infrastructure - :core:preferences - shared preferences definitions and DI infrastructure - :core:testing - fakes and rules used across different modules Benchmarking with gradle-profiler shows a ~ 17% reduction in incremental build times after an ABI change. That will improve further as more code is moved to modules. The rough mechanics of the changes are: - Create the modules, and move existing files in to them. This causes a lot of churn in import arguments. - Convert build.gradle files to build.gradle.kts - Separate out the data required to display a tab (`TabViewData`) from the data required to configure a tab (`TabData`) to avoid circular dependencies. - Abstract the repeated build logic shared between the modules in to a set of plugins under `build-logic/`, to simplify configuration of the application and library builds. - Be explicit that some nullable types are non-null at time of use. Nullable properties in types imported from modules generally can't be smart cast to non-null. There's a detailed discussion of why this restriction exists at https://discuss.kotlinlang.org/t/what-is-the-reason-behind-smart-cast-being-impossible-to-perform-when-referenced-class-is-in-another-module/2201. The changes highlight design problems with the current code, including: - The main application code is too tightly coupled to the network types - Too many values are declared unnecessarily nullable - Dependency cycles between code that make modularisation difficult Future changes will add more modules. See #291.
2023-12-04 16:58:36 +01:00
include(":tools:mklanguages")
fix: Improve parsing of Friendica (and other server) version formats (#376) Previous code could return an error on Friendica version strings like `2024.03-dev-1547`. Fix this: - Extend the list of explicitly supported servers to include Fedibird, Friendica, Glitch, Hometown, Iceshrimp, Pixelfed, and Sharkey. - Add version parsing routines for these servers. - Test the version parsing routines fetching every server and version seen by Fediverse Observer (~ 2,000 servers) and ensuring that the server and version information can be parsed. Improve the error message: - Show the hostname with a `ServerRepository` error Clean up the code: - Remove the custom `resultOf` and `mapResult` functions, they have equivalents in newer versions of the library (like `runSuspendCatching`) Fixes #372
2024-01-23 20:27:25 +01:00
include(":tools:mkserverversions")
refactor: Modularise core activity classes, (#393) Continue modularisation by moving core activity classes that almost all activities depende on to a `core.activity` module. This includes core "helper" classes as well. Implement core.activity: - Contains BaseActivity, BottomSheetActivity - Contains LinkHelper and other utility classes used by activities Implement core.common.extensions: - Move ViewBindingExtensions and ViewExtensions here Implement core.common.util: - Move BlurHashDecoder and VersionName here Implement core.designsystem: - Holds common resources (animations, colours, drawables, etc) used through the app - Import "core.designsystem.R as DR" through the app to distinguish from the module's own resources Implement feature.login: - Move the LoginActivity and related code/resources to its own module Implement tools/mvstring - Moves string resources (and all translations) from one module to another
2024-01-30 11:37:00 +01:00
include(":tools:mvstring")
refactor: Start creating core modules (#286) The existing code base is a single monolithic module. This is relatively simple to configure, but many of the tasks to compile the module and produce the final app have to run in series. This is unnecessarily slow. This change starts to split the code in to multiple modules, which are: - :core:account - AccountManager, to break a dependency cycle - :core:common - low level types or utilities used in many other modules - :core:database - database types, DAOs, and DI infrastructure - :core:network - network types, API definitions, and DI infrastructure - :core:preferences - shared preferences definitions and DI infrastructure - :core:testing - fakes and rules used across different modules Benchmarking with gradle-profiler shows a ~ 17% reduction in incremental build times after an ABI change. That will improve further as more code is moved to modules. The rough mechanics of the changes are: - Create the modules, and move existing files in to them. This causes a lot of churn in import arguments. - Convert build.gradle files to build.gradle.kts - Separate out the data required to display a tab (`TabViewData`) from the data required to configure a tab (`TabData`) to avoid circular dependencies. - Abstract the repeated build logic shared between the modules in to a set of plugins under `build-logic/`, to simplify configuration of the application and library builds. - Be explicit that some nullable types are non-null at time of use. Nullable properties in types imported from modules generally can't be smart cast to non-null. There's a detailed discussion of why this restriction exists at https://discuss.kotlinlang.org/t/what-is-the-reason-behind-smart-cast-being-impossible-to-perform-when-referenced-class-is-in-another-module/2201. The changes highlight design problems with the current code, including: - The main application code is too tightly coupled to the network types - Too many values are declared unnecessarily nullable - Dependency cycles between code that make modularisation difficult Future changes will add more modules. See #291.
2023-12-04 16:58:36 +01:00
include(":checks")