simple-stack-compose-integration - GitLite

KO | EN

gitlite — search

#javascript #python #react #ai #typescript #llm #golang #rust #docker #java #awesome-list #security #ios #mcp

simple-stack-compose-integration

(★ 102)

[ABANDONED] Compose integration for Simple-Stack. Replaced by Navigation3 + Simple-Stack instead.

파일 탐색기

최종 버전 다운로드 (.zip)

- build.gradle
- .gitignore
- build.gradle
- proguard-rules.pro
- .gitignore
- build.gradle
- proguard-rules.pro
- .gitignore
- build.gradle
- proguard-rules.pro
- .gitignore
- build.gradle
- proguard-rules.pro
- - gradle-wrapper.jar
  - gradle-wrapper.properties
- build.gradle
.codeclimate.yml
.gitignore
.jitpack.yml
build.gradle
CHANGELOG.md
circle.yml
gradle.properties
gradlew
gradlew.bat
LICENSE.txt
README.md
settings.gradle

# 설치 가이드

1. 코드 내려받기

git clone https://github.com/Zhuinden/simple-stack-compose-integration

깃허브에서 프로젝트 코드 전체를 내 컴퓨터로 내려받습니다.

cd simple-stack-compose-integration

방금 내려받은 프로젝트 폴더 안으로 이동합니다.

2. Gradle (Java/Kotlin)

보통 추천

사전 준비물

Git GitHub에서 프로젝트 코드를 내려받으려면 필요합니다.
JDK (Java) Java/Kotlin 프로젝트를 빌드/실행하려면 필요합니다.
Gradle 레포에 포함된 gradlew(Gradle Wrapper)를 쓰면 Gradle을 따로 설치할 필요가 없습니다.

In newer projects, you need to also update the `settings.gradle` file's `dependencyResolutionManagement` block:

Gradle로 빌드를 진행합니다.

and then, add the dependency to your module's `build.gradle.kts` (or `build.gradle`):

Gradle로 빌드를 진행합니다.

✅ BUILD SUCCESSFUL 메시지가 뜨면 성공입니다. build/ 폴더에 결과물이 생성됩니다.

이 레포의 README에 적힌 실제 명령어를 그대로 가져왔습니다.

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# DEPRECATION NOTICE

While there is nothing conceptually wrong with this repository, what it does should be managed with a Navigation3's `NavDisplay`.

Everything inside the `core` and specifically by `ComposeStateChanger` is done by `NavDisplay` and it is done better with less trickery in regards to setting up `ViewModelStore`s and whatnot per each screen.

So there was an open question, https://github.com/Zhuinden/simple-stack-compose-integration/issues/23 , which just doesn't need to be done if you do `NavDisplay`. You'd just use the ViewModelStoreDecorator. And you'd manage the state of the navigation via a `Backstack` but not with this module, you can literally just set the current list of keys to the NavDisplay and it'd just work.

# Simple Stack Compose Integration

Default behavior for Jetpack Compose using Simple-Stack.

## Using Simple Stack Compose Integration

In order to use Simple Stack Compose Integration, you need to add `jitpack` to your project root `build.gradle.kts`
(or `build.gradle`):

``` kotlin
// build.gradle.kts
allprojects {
    repositories {
        // ...
        maven { setUrl("https://jitpack.io") }
    }
    // ...
}
```

or

``` groovy
// build.gradle
allprojects {
    repositories {
        // ...
        maven { url "https://jitpack.io" }
    }
    // ...
}
```

In newer projects, you need to also update the `settings.gradle` file's `dependencyResolutionManagement` block:

```
dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
        maven { url 'https://jitpack.io' }  // <--
        jcenter() // Warning: this repository is going to shut down soon
    }
}
```

and then, add the dependency to your module's `build.gradle.kts` (or `build.gradle`):

``` kotlin
// build.gradle.kts
implementation("com.github.Zhuinden:simple-stack-compose-integration:0.13.1")
```

or

``` groovy
// build.gradle
implementation 'com.github.Zhuinden:simple-stack-compose-integration:0.13.1'
```

As Compose requires Java-8 bytecode, you need to also add this:

``` groovy
android {
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
    kotlinOptions {
        jvmTarget = '1.8'
        languageVersion = '1.9'
    }
    buildFeatures {
        compose true
    }
    composeOptions {
        kotlinCompilerExtensionVersion '1.4.3'
    }
}

kotlin.sourceSets.all {
    languageSettings.enableLanguageFeature("DataObjects")
}
```

## What does it do?

Provides defaults for Composable-driven navigation and animation support.

``` kotlin
class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

setContent {
            ComposeNavigator {
                createBackstack(
                    History.of(InitialKey()),
                    scopedServices = DefaultServiceProvider()
                )
            }
        }
    }
}
```

and

``` kotlin
abstract class ComposeKey: DefaultComposeKey(), Parcelable {
    override val saveableStateProviderKey: Any = this // data class + parcelable!
}
```

and

``` kotlin
@Immutable
@Parcelize
data object SecondKey: ComposeKey() {
    operator fun invoke() = this
    
    @Composable
    override fun ScreenComposable(modifier: Modifier) {
        SecondScreen(modifier)
    }
}
```

## What about ViewModels?

While Jetpack ViewModels are also supported, but it is recommended to use `ScopedServices` as provided by **Simple-Stack**, because `ScopedServices` have more powerful feature set than `ViewModel`.

``` kotlin
abstract class ComposeKey : DefaultComposeKey(), Parcelable, DefaultServiceProvider.HasServices {
    override val saveableStateProviderKey: Any = this

override fun getScopeTag(): String = toString()

override fun bindServices(serviceBinder: ServiceBinder) {
    }
}
```

and

``` kotlin
val backstack = Navigator.configure()
                    .setScopedServices(DefaultServiceProvider())
                    // ...
```

and

``` kotlin
@Immutable
@Parcelize
data object DogListKey: ComposeKey() {
    operator fun invoke() = this
    
    override fun bindServices(serviceBinder: ServiceBinder) {
        with(serviceBinder) {
            add(DogListViewModel(lookup<DogDataSource>(), backstack)) // <--
        }
    }

@Composable
    override fun ScreenComposable(modifier: Modifier) {
        val viewModel = remember { backstack.lookup<DogListViewModel>() } // <--

val dogs by viewModel.dogList.observeAsState()

DogListScreen(dogs)
    }
}
```

## Note about using Enum parameters in keys

Unfortunately, `enum.hashCode()` is not stable across process death. so Enum classes shouldn't be passed directly to keys as arguments.

It is preferable to preserve them as a private String, and expose the value as an enum vie a custom getter.

```kotlin
// THIS BREAKS!
// data class DemoKey(val enum: DemoEnum): DefaultComposeKey // <-- breaks!

// DO THIS INSTEAD
data class DemoKey(private val enumName: String): DefaultComposeKey {
    constructor(enum: DemoEnum): this(enum.name)
    
    val enum: DemoEnum get() = DemoEnum.valueOf(enumName)
}
```

Unfortunately, this is a limitation of the JVM, and not of Simple-Stack, meaning it's something we need to remember to do.

## License

Copyright 2021-2025 Gabor Varadi

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

http://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.