Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/lykhonis/kotlinAndroidLib
Kotlin "sugar" for Android
https://github.com/lykhonis/kotlinAndroidLib
Last synced: 3 months ago
JSON representation
Kotlin "sugar" for Android
- Host: GitHub
- URL: https://github.com/lykhonis/kotlinAndroidLib
- Owner: lykhonis
- Created: 2012-05-23T21:55:41.000Z (over 12 years ago)
- Default Branch: master
- Last Pushed: 2015-03-10T16:15:35.000Z (almost 10 years ago)
- Last Synced: 2024-05-05T17:04:07.288Z (8 months ago)
- Language: Kotlin
- Homepage: http://vladimirlichonos.com
- Size: 188 KB
- Stars: 124
- Watchers: 11
- Forks: 17
- Open Issues: 3
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
- awesome-kotlin-android - kotlinAndroidLib - Kotlin "sugar" for Android (Android)
README
Kotlin for Android
=============
Helps not to write boilerplate code with instantiating abstract or interfaces instances.
The purpose of the library is to save time of writing code using Android SDK wrapping as much as possible
common functionality.
The library uses one of the coolest feature of the Kotlin language `inline` almost everywhere, that prevents overhead code.
Warning
-------
This project is not relative to JetBrains company or their products. Use this project as is, no author nor anybody else
is responsible for any damage.
Linking to Android project
--------------------------
1. Create regular or use existing Android project in IDEA
2. Select `File` from menu and click on `Project Structure...`
3. Select `Libraries` section and add new Java library
4. Choose the source `src` folder of kotlinAndroidLib and click `Ok`
5. Choose category `sources` and click `Ok`
6. Select and name the library `kotlinAndroidLib`
7. Add new file to the library `^N` and choose classes.jar of kotlinAndroidLib
8. Add import to your kotlin files in the android project `import com.vlad.android.kotlin.*`
Usage
-----
Small example of usage most of the functions and also some examples like how to create Parcelable.
See [Sample Activity](https://github.com/vladlichonos/kotlinAndroidLib/blob/master/SampleActivity.kt)
* `findViewById` replacement for Activity and View:
val myButton = findView(R.id.my_button)
* `setOnClickListener` for Views:
myView?.setOnClickListener { /* code here */ }
myView?.setOnClickListener { view -> /* code here with view: View? argument */ }
val onClickListener = OnClickListener { view -> /* code here */ }
myView?.setOnTouchListener { view, event -> false /* with view: View? and event: MotionEvent? */ }
val onTouchListener = OnTouchListener { view, event -> false }
* `runOnUiThread` for Activities:
It can be used without the library:
runOnUiThread(runnable { /* action */})
Library just remove runnable call and can be used as:
runOnUiThread { /* action */ }
* Short definition of `BroadcastReceiver`:
Library just wraps `onReceive` call:
val myBroadcastReceiver = BroadcastReceiver { context, intent ->
/* handle intent here */
}
* `setPositiveButton` and `setNegativeButton` for AlertDialog.Builder:
AlertDialog.Builder(this).setTitle("Hello")
?.setMessage("Want to say hello to world?")
?.setPositiveButton("Yes", { dialog, which -> /* hello */ })
?.setNegativeButton("No", { dialog, which -> /* no hello now */ })
?.create()
val positiveButton = dialogOnClickListener { dialog, which -> }
* Short definition of `OnEditorActionListener`:
Library just wraps `onEditorAction` call:
val myEditorActionListener = OnEditorActionListener { v, actionId, event ->
/* handle actionId and/or event */
false
}
myEditText?.setOnEditorActionListener /* OnEditorActionListener */ { v, actionId, event ->
false
}
* `getSystemService` with or without casting for known services:
Library allows call with casting for specific name of the service or call directly for known services:
val inputMethodManager = getSystemServiceAs(Context.INPUT_METHOD_SERVICE)
val inputMethodManager = getInputMethodService()
* `AdapterView.setOnItemClickListener` and `AdapterView.setOnItemLongClickListener`:
listView.setOnItemClickListener { parent, view, position, id -> }
listView.setOnItemLongClickListener { parent, view, position, id -> false }
* Wrap calls without runnable() for `Handler`:
val handler = Handler()
handler.post { /* code here */ }
handler.postDelayed(100) { /* code here */ }
handler.postAtFrontOfQueue { /* code here */ }
handler.postAtTime(System.currentTimeMillis() + 100) { /* code here */ }
Also easy to create handler with callback to handle messages:
val handler = Handler { message ->
when (message.what) {
1 -> handleMessage1(message.getData())
else -> false
}
}
* Wrap `SQLiteDatabase` functionality:
* Wrap pattern: beginTransaction -> setTransactionSuccessful -> endTransaction with try and finally:
sqliteDatabase.transaction {
// call any method of SQLiteDatabase without . or ?.
execSQL("ALTER TABLE table_1 RENAME TO table_2")
}
* Wrap pattern: cursor not null -> moveToFirst -> moveToNext in do-while loop -> close with try and finally:
// query call with same arguments + last argument is a body in the loop
val collection /* of String */ = sqliteDatabase.query("people", array("first_name"), null, null, null, null, null, null) {
/* Cursor namespace */
getString(getColumnIndexOrThrow("first_name"))
}
Support also queryWithFactory, rawQuery and rawQueryWithFactory.
* Wrap ContentValues for insert and update:
sqliteDatabase?.insert("table_name", null) {
// ContentValues namespace
put("column_text", "Hello")
put("column_int", 12.toInt())
put("column_float", 13.toFloat())
}
sqliteDatabase?.update("table_name", "ID = ?", array("3")) {
// ContentValues namespace
put("column_text", "Hello World")
}
* Wrap `Cursor` pattern moveToFirst -> moveToNext in do-while loop:
Possible to call all functions on Cursor?, if Cursor? == null, returns empty collection
try {
val collection /* Of String? */ = cursor.map {
getString(getColumnIndexOrThrow("first_name"))
}
} finally {
cursor?.close()
}
or
val collection = LinkedList()
try {
cursor.mapTo(collection) {
getString(getColumnIndexOrThrow("first_name"))
}
} finally {
cursor?.close()
}
or
val collection /* Of String? */ = cursor.mapAndClose {
getString(getColumnIndexOrThrow("first_name"))
}
* `ExecutorService`:
executorService.execute { /* code here */ }
val future = executorService.submit { /* code here and no result */ }
val future = executorService.submit { /* code here */ "Result" }
val future = executorService.submit("Result") { /* code here and result */ }
* Wrap `Intent`, now easy to create new `Intent` without defining new variable:
sendBroadcast(Intent() { setAction(Intent.ACTION_DEFAULT) })
startActivity(Intent(Intent.ACTION_VIEW) { setDataAndType(Uri.parse("http://example.com/audio.mp3"), "audio/mpeg") })
or make it even nicer if you have an action and it's a `String` value:
"my.application.intent.action.ACTION_MINE" toIntent {
/* namespace of Intent */
}
or just convert `String` to `Intent`:
"my.application.intent.action.ACTION_MINE".toIntent()
* Wrap `IntentFilter`, now easy to create new `IntentFilter` without defining new variable:
registerReceiver(broadcastReceiver, IntentFilter {
addAction(ACTION_HELLO)
})
* Wrap `Bundle`, now easy to create new `Bundle` without defining new variable:
Bundle { putString("result", "Some result!") }
* Short definition of `ResultReceiver`:
Library just wraps `onReceiveResult` call:
val myResultReceiver = ResultReceiver(Hanlder()) { code, data ->
/* handle result here */
}
or automatically create new `Hanlder`
val myResultReceiver = ResultReceiver { code, data ->
/* handle result here */
}
* Wrap 'CREATOR' for `Parcelable`. Example of usage:
WARNING: It might wrong or not supported yet!
class MyParcelable(val number: Int, val text: String?) : Parcelable {
public override fun writeToParcel(p0: Parcel?, p1: Int) = if (p0 != null) {
p0.writeInt(number)
p0.writeString(text)
}
public override fun describeContents(): Int = 0
class object {
val CREATOR = CreateParcelable { MyParcelable(it.readInt(), it.readString()) }
}
}
* Wrap `Thread`, `run` and call `start` method:
async {
// some code here
}