Issue: None associated

Platform

• [x] iOS
• [x] Android
• [x] KMP

Summary

JCenter is shutting down, which means that active projects should not rely on it. All of KaMPKit's dependencies are now available through other artifact repositories which means it's safe to remove JCenter from this project.

Fix

Removed references to JCenter.

Testing

Checked if syncing Gradle fails.

Closes #194

[Platform]

• [x] iOS
• [x] Android
• [x] KMP

[Summary]

We were still reading Koin from Bintray (oops!)

[Fix]

Update to release version of Koin which is published to Maven Central, and remove remaining stray Bintray dependencies

[Testing]

Unit tests still pass, and ran App on both platforms with no issues.

Reviewer Tips:

* Use "Nitpick:" if it's a minor non-crucial request.

* If you're done with comments either end with a review or comment something helpful like "done with comments for now"

Project is building and running fine (tested on Android), however, IDE (Android Studio 4.1) is having issues with resolving imports from db package from common and Android code, and as a result, IDE is underlining all the time those files and doesn't autocomple when typing their names. Invalidating cache/restart doesn't solve this issue.

Whenever I try to debug a suspend function I get the following error:

From what I've read online it used to not be possible to debug suspend functions but apparently this has been resolved now. Is it still impossible for MPP?

I followed the instructions to open KaMPKitiOS in XCode 12. However, the Kotlin code isn't highlighted, nor can I put breakpoints in it. See screenshot:

Hi,

Apologies if this is too generic and/or ignorant, but both my clones in the latest OSX and Windows Android Studio would fail at syncing with the

NDK Resolution Outcome: Project settings: Gradle model version=5.6.2, NDK version is UNKNOWN

This failure persisted after setting the NDK path under Project Structure, in Windows there is a "Download" button to get the NDK, in MacOS I pointed to a manually unpacked NDK.

The "sync" and eventually the build completed successfully after closing the projects on both platforms and clicking Import Project, which revealed that the UKNOWN message is still in the log, but somehow not the showstopper that it was before the import, no clue what is happening there. I am also confused why Android Studio does not automagically fetch and configure an NDK when required in a project, is it possible that KaMPKit is using an antipattern here, or hitting a Google bug (I saw there is an open issue in Google's Issue Tracker)?

Thanks!

This is another proposal of a shared ViewModel.

Common ViewModel concept

Using the expect/actual modifiers provided by Kotlin, we can create a common ViewModel declaration. It can be pretty straightforward, with just one method that will run when the view is being destroyed to finish any work in progress.

This proposal keeps the Android standard of using the onCleared to perform such action.

expect abstract class PlatformViewModel() {
    protected open fun onCleared()
}

To provide the correct coroutine scope in the shared code, we will have an extension function (using expect/actual), similar to what is done by Android Lifecycle Components.

actual val PlatformViewModel.coroutineScope: CoroutineScope

This abstract class will be used to implement a shared ViewModel (like a CommonBreedViewModel). But it will not be visible for the apps. Each platform will have to implement a subclass from this ViewModel exposing the data so that the platform's native language can access.

abstract class CommonBreedViewModel : PlatformViewModel(), KoinComponent {
    protected val _breedStateFlow: MutableStateFlow<DataState<ItemDataSummary>> =
        MutableStateFlow(DataState(loading = true))

    fun fetch() {
        // TODO: Fetch data and post to _breedStateFlow
    }
}

We can have an Android implementation that just exposes some StateFlow (or LiveData/Rx):

class BreedViewModel : CommonBreedViewModel() {
    val breedStateFlow: StateFlow<DataState<ItemDataSummary>> = _breedStateFlow
}

And on iOS, we can use constructor callbacks (or SwiftCoroutines/Hyperdrive):

class BreedViewModel(
    private val onDataState: (DataState<ItemDataSummary>) -> Unit,
) : CommonBreedViewModel() {
    init {
        coroutineScope.launch {
            _breedStateFlow.collect { dataState ->
                onDataState(dataState)
            }
        }
    }
}

Pain points

During the development of this PoC, I was able to experience some pain points that need to be discussed and stress the current (and other possible) solutions. All of them are placed as comments in the code, but here are a few of them:

Dependencies

The first problem I had with it was about having the dependencies in the common code. The problems are:

1. If you add them as constructor parameters, you will not be able to create a new instance without using Koin (or other dependency injection lib) to inject that on the iOS side;
   1. If you consider the callback approach, things can be a bit more complicated;
   2. Maybe having a generated ViewModelProvider (or similar) for iOS would help
2. If you set them as abstract, for some reason, the app crashes if you use any of them in the init from the common class;

The solution used here was to make the CommonViewModel a KoinComponent, with that, we can call by inject() directly in the shared code.

Native Coroutine Scope

Right now, the MainScope class depends on Kermit to run. To avoid forcing the user to import unwanted libraries, I created a new class that provides the coroutine scope called NativeCoroutineScope. It now does not depend on any external library, but we lose the logging capability.

Some solutions for that are:

• Having an internal Logger class that we send as a parameter for the native ViewModel may be a solution.
• Implementing a more complex ViewModel that stores values for keys (like Android) is another solution, but much more complex.

iOS Lifecycle

In this implementation, we need to manually call the .destroy() function on the iOS side to dispose of the ViewModel. A way to attach to a ViewController lifecycle would be helpful.

Pros

• Allows you to share more code with the multiple targets
• Flexible in a way that each platform can expose that as they need
  • Including the name that it will use. Some iOS devs prefer to call these "Service", which will not be a problem in this format
• All Android ViewModel features are kept and can be used in the android SourceSet
• The "ViewModel" model is simple and provides everything we need
  • Right now is just the coroutine scope, but we can add more stuff with expect extensions

Cons

• Handling dependencies in the shared code (Pain Point 1)
• Native Coroutine Scope (Pain Point 2)
• Error-Prone in the iOS Side (Pain Point 3)
• It's not as flexible for extension as the Android ViewModel
  • We could add the same "mBagOfTags" that Android has on the shared code to fix this. But we would need to depend on atomic (which may have some performance impacts)

Hello,

I would like to add the Firebase database library in the shared modules for begin test use KMM for app Android and iOs

want use : implementation("dev.gitlive:firebase-database:1.4.2")

but have this error : org.gradle.internal.resolve.ArtifactNotFoundException: Could not find firebase-app-debug.aar (dev.gitlive:firebase-app-android-debug:1.4.2).

Do I am using the correct Firebase library ? Do you have any example to connect and use firebase database ?

Thanks!

I am trying to have 1st build of KaMPKit. I was able to successfully build and run it in Android Studio.

Now I am trying to run 1st optional step of iOS build. I have already downloaded and run XCode 11.5.

For unknown reasons the build takes too long and all tests are failing.

Just in case I am running the build on MacBook Pro 16" (2019), MacOS Catalina 10.15.4.

$ ./gradlew clean build
> Task :shared:testReleaseUnitTest

...

> Task :shared:testReleaseUnitTest

co.touchlab.kampkit.KoinTest > checkAllModules FAILED
    org.apache.tools.ant.BuildException
        Caused by: org.apache.maven.artifact.resolver.MultipleArtifactsNotFoundException

co.touchlab.kampkit.ConcurrencyTest > testMain FAILED
    org.apache.tools.ant.BuildException
        Caused by: org.apache.maven.artifact.resolver.MultipleArtifactsNotFoundException

co.touchlab.kampkit.BreedModelTest > updateFavoriteTest FAILED
    org.apache.tools.ant.BuildException
        Caused by: org.apache.maven.artifact.resolver.MultipleArtifactsNotFoundException

co.touchlab.kampkit.BreedModelTest > notifyErrorOnException FAILED
    org.apache.tools.ant.BuildException
        Caused by: org.apache.maven.artifact.resolver.MultipleArtifactsNotFoundException

co.touchlab.kampkit.BreedModelTest > staleDataCheckTest FAILED
    org.apache.tools.ant.BuildException
        Caused by: org.apache.maven.artifact.resolver.MultipleArtifactsNotFoundException

co.touchlab.kampkit.SqlDelightTest > Select All Items Success FAILED
    org.apache.tools.ant.BuildException
        Caused by: org.apache.maven.artifact.resolver.MultipleArtifactsNotFoundException

co.touchlab.kampkit.SqlDelightTest > Update Favorite Success FAILED
    org.apache.tools.ant.BuildException
        Caused by: org.apache.maven.artifact.resolver.MultipleArtifactsNotFoundException

co.touchlab.kampkit.SqlDelightTest > Select Item by Id Success FAILED
    org.apache.tools.ant.BuildException
        Caused by: org.apache.maven.artifact.resolver.MultipleArtifactsNotFoundException

co.touchlab.kampkit.SqlDelightTest > Delete All Success FAILED
    org.apache.tools.ant.BuildException
        Caused by: org.apache.maven.artifact.resolver.MultipleArtifactsNotFoundException

9 tests completed, 9 failed

> Task :shared:testReleaseUnitTest FAILED

FAILURE: Build failed with an exception.

* What went wrong:
Execution failed for task ':shared:testReleaseUnitTest'.
> There were failing tests. See the report at: file:///Users/otrotsenko/dev/repos/3rd_party/kmp/KaMPKit/shared/build/reports/tests/testReleaseUnitTest/index.html

* Try:
Run with --stacktrace option to get the stack trace. Run with --info or --debug option to get more log output. Run with --scan to get full insights.

* Get more help at https://help.gradle.org

BUILD FAILED in 47m 53s

And then in the index.html for each test I see the same:

Unable to resolve artifact: Missing:
----------
1) org.robolectric:android-all:jar:4.1.2_r1-robolectric-r1

  Try downloading the file manually from the project website.

  Then, install it using the command: 
      mvn install:install-file -DgroupId=org.robolectric -DartifactId=android-all -Dversion=4.1.2_r1-robolectric-r1 -Dpackaging=jar -Dfile=/path/to/file

  Alternatively, if you host your own repository you can deploy the file there: 
      mvn deploy:deploy-file -DgroupId=org.robolectric -DartifactId=android-all -Dversion=4.1.2_r1-robolectric-r1 -Dpackaging=jar -Dfile=/path/to/file -Durl=[url] -DrepositoryId=[id]

  Path to dependency: 
  	1) org.apache.maven:super-pom:pom:2.0
  	2) org.robolectric:android-all:jar:4.1.2_r1-robolectric-r1

----------
1 required artifact is missing.

for artifact: 
  org.apache.maven:super-pom:pom:2.0

from the specified remote repositories:
  adeya.central (https://nexus.adeya.ch/content/repositories/adeya.central/)


	at org.apache.maven.artifact.ant.DependenciesTask.doExecuteResolution(DependenciesTask.java:268)

is there a reason why you use jdk7 instead of jdk8 ?

from your build.gradle.kts:

implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk7:1.3.72")

This updates the project to allow injection directly from iOS similar to how Android can as seen in: MainApp.kt. Fixes #113

NOTES: These changes introduce a library to allow us to have a shared object while still being able to mutate it. I think it's not the most ideal setup but it's a good tradeoff for the clean interface to the developer and seeing that this will only be set once. However, I'm open to other suggestions.

Switch from RC to official release, reverify that 1.8 still works and get the branch ready to merge

Perform the list of sanity checks on your work projects (it mostly consists of basic actions).

• Compile your project with a current Kotlin version.
• Check the highlighting in different IDE modules.
• Compile the project with the EAP Kotlin version and install the EAP IDE plugin.
• Verify that the project re-imported successfully.
• Check that highlighting from p.2 works not worse than before.
• Compile the project again and look for new surprising warnings.
• Change something in the code and check if incremental compilation works.
• Run your tests with a new Kotlin version.
• Stop at some well-known piece of code, run the debugger and try stepping.
• Look for performance issues in compilation, runtime, re-import or IDE behavior.

Pay additional attention to these features and subsystems if applicable to your use case:

• Kotlin Gradle plugin: lots of changes in all typical usage scenarios
• The new Gradle Incremental compilation, which we plan to stabilize soon
• Expose compiler flags via Gradle lazy properties
• Ability to not fallback with compiler daemon by default
• arm64 support for watchOS targets
• Xcode 14 and new Objective-C frameworks support in Kotlin/Native

Hi, ios architecture has problems. Please look at this line https://github.com/touchlab/KaMPKit/blob/620ce2711ea5084e5d028cdc9134fe76d5170271/shared/src/commonMain/kotlin/co/touchlab/kampkit/Koin.kt#L68 Here we should have a factory. Because if we have two screens A and B (and two view models). If we leave screen B, then we will call the code

.onDisappear(perform: {
            observableModel.deactivate()
        })

And next step this code

 /**
     * Cancels the internal [CoroutineScope][kotlinx.coroutines.CoroutineScope]. After this is called, the ViewModel should
     * no longer be used.
     */
    fun clear() {
        onCleared()
        viewModelScope.cancel()
    }

If we try to open the screen B, we will see white screen evert time. As a result, we have a view model with cancelled scope and koin always returns this instance for us (because of single operator). Of course it is not reproducible for app with one screen but better to improve this sample. Thanks

Issues: https://github.com/touchlab/KaMPKit/issues/162, https://github.com/touchlab/KaMPKit/issues/277

Summary

Update Kotlin to version 1.8.0-RC, update to SQLDelight 2.

Trial latest version of SQLDelight 2. Confirm it works and make changes required to integrate with KaMPKit. https://github.com/cashapp/sqldelight/blob/master/CHANGELOG.md

Create draft PR