Need help with Bundler?
Click the “chat” button below for chat support from the developer who created it, or find similar developers for support.

About the developer

skydoves
216 Stars 11 Forks Apache License 2.0 102 Commits 0 Opened issues

Description

🎁 Android Intent & Bundle extensions that insert and retrieve values elegantly.

Services available

!
?

Need anything else?

Contributors list

# 11,647
Kotlin
Android
kotlin-...
annotat...
90 commits
# 88,111
Kotlin
HTML
dagger2
Android
1 commit
# 151,287
Kotlin
HTML
Android
kotlin-...
1 commit

Bundler

License API Build Status Android Weekly KotlinWeekly Medium Javadoc

🎁 Android Intent & Bundle extensions that insert and retrieve values elegantly.

Including in your project

Maven Central Jitpack

Gradle

Add below codes to your root

build.gradle
file (not your module build.gradle file).
gradle
allprojects {
    repositories {
        mavenCentral()
    }
}
And add a dependency code to your module's
build.gradle
file.
gradle
dependencies {
    implementation "com.github.skydoves:bundler:1.0.4"
}

SNAPSHOT

Bundler
Snapshots of the current development version of Bundler are available, which track the latest versions.

Gradle
repositories {
   maven { url 'https://oss.sonatype.org/content/repositories/snapshots/' }
}

Usage

Intent

intentOf
is an expression for creating an Intent using Kotlin DSL style and we can put extras using the
putExtra
method. Also, we can put extras using the
+
keyword in front of a key/value pair. ```kotlin val intent = intentOf { putExtra("posterId", poster.id) // put a Long type 'posterId' value. putExtra("posterName" to poster.name) // put a String type 'posterName' value. putExtra("poster", poster) // put a Parcelable type 'poster' value.
+("id" to userInfo.id) // put a Long type 'id' value.
+("name" to userInfo.nickname) // put a String type 'name' value.

-"name" // remove a String type 'name' value.

} ```

StartActivity

We can start activities using the

intentOf
expression like below.
kotlin
intentOf {
    putExtra("id" to userInfo.id)
    putExtra("name" to userInfo.nickname)
    putExtra("poster", poster)
    startActivity([email protected])
}
We can also use other options for creating an intent.
kotlin
intentOf {
    setAction(Intent.ACTION_MAIN)
    addCategory(Intent.CATEGORY_APP_MUSIC)
    setFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
    startActivity([email protected])
}

bundle

bundle
is an expression for initializing lazily extra values from the intent. ```kotlin class SecondActivity : AppCompatActivity() {

private val id: Long by bundle("id", -1) // initializes a Long extra value lazily. private val name: String by bundle("name", "") // initializes a String extra value lazily. private val poster: Poster? by bundle("poster") // initializes a Parcelable extra value lazily.

// -- stubs -- //

We can initialize a Parcelable value with a defaut value.
kotlin private val poster: Poster? by bundle("poster") { Poster.create() }
Also, we can initialize type of Array and ArrayList using `bundleArray` and `bundleArrayList` expression.
kotlin // initialize lazily without default values. private val posterArray by bundleArray("posterArray") private val posterListArray by bundleArrayList("posterArrayList")

or

// initialize lazily with default values. private val posterArray by bundleArray("posterArray") { arrayOf() } private val posterListArray by bundleArrayList("posterArrayList") { arrayListOf() } ```

bundle in Fragment

The below example shows setting arguments using the

intentOf
expression.
kotlin
arguments = intentOf {
    +("id" to userInfo.id)
    +("name" to userInfo.nickname)
    +("poster" to poster)
}.extras
We can initialize argument values lazily in Fragments using the
bundle
expression like below.
diff
- val id: Long = arguments?.getLong("id", -1) ?: -1
+ val id: Long by bundle("id", -1)
- val poster: Poster? = arguments?.getParcelable("poster")
+ val poster: Poster? by bundle("poster")

bundleNonNull

The

bundle
expression for initializing objects (e.g. Bundle, CharSequence, Parcelable, Serializable, Arrays), the property type must be null-able. But If we want to initialize them non-nullable type, we can initialize them to non-nullable type using the
bundleNonNull
expression.
diff
- val poster: Poster? by bundle("poster")
+ val poster: Poster by bundleNotNull("poster")

observeBundle

We can observe the bundle data as

LiveData
using the
observeBundle
expression. If there are no extra & arguments in the Activity or Fragment,
null
will be passed to the observers. The
observeBundle
emits data only a single time to a single observer. So We can observe only once using one observer. And the observer will be unregistered from the LiveData after observing data at once. ```kotlin private val id: LiveData by observeBundle("id", -1L) private val poster: LiveData by observeBundle("poster")

id.observe(this) { vm.id = it }

poster.observe(this) { binding.name = it.name } ```

bundleValue

We can also retrieve intent & arguments extra values from Activity and Fragment immediately. We can use

bundleValue
,
bundleNonNullValue
,
bundleArrayValue
,
bundleArrayListValue
.
val id = bundleValue("id", 100L)
val name = bundleValue("name", "")
val poster = bundleValue("poster")

Find this library useful? :heart:

Support it by joining stargazers for this repository. :star:
And follow me for my next creations! 🤩

License

Copyright 2020 skydoves (Jaewoong Eum)

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.

We use cookies. If you continue to browse the site, you agree to the use of cookies. For more information on our use of cookies please see our Privacy Policy.