├── app
    ├── .gitignore
    ├── src
    │   ├── main
    │   │   ├── res
    │   │   │   ├── values
    │   │   │   │   ├── strings.xml
    │   │   │   │   ├── colors.xml
    │   │   │   │   └── themes.xml
    │   │   │   ├── font
    │   │   │   │   └── varimoji.ttf
    │   │   │   ├── mipmap-hdpi
    │   │   │   │   ├── ic_launcher.webp
    │   │   │   │   └── ic_launcher_round.webp
    │   │   │   ├── mipmap-mdpi
    │   │   │   │   ├── ic_launcher.webp
    │   │   │   │   └── ic_launcher_round.webp
    │   │   │   ├── mipmap-xhdpi
    │   │   │   │   ├── ic_launcher.webp
    │   │   │   │   └── ic_launcher_round.webp
    │   │   │   ├── mipmap-xxhdpi
    │   │   │   │   ├── ic_launcher.webp
    │   │   │   │   └── ic_launcher_round.webp
    │   │   │   ├── mipmap-xxxhdpi
    │   │   │   │   ├── ic_launcher.webp
    │   │   │   │   └── ic_launcher_round.webp
    │   │   │   ├── xml
    │   │   │   │   └── file_paths.xml
    │   │   │   ├── mipmap-anydpi-v26
    │   │   │   │   ├── ic_launcher.xml
    │   │   │   │   └── ic_launcher_round.xml
    │   │   │   ├── values-night
    │   │   │   │   └── themes.xml
    │   │   │   ├── drawable
    │   │   │   │   ├── ic_header.xml
    │   │   │   │   └── ic_launcher_background.xml
    │   │   │   ├── drawable-v24
    │   │   │   │   └── ic_launcher_foreground.xml
    │   │   │   └── raw
    │   │   │   │   └── videos.json
    │   │   ├── java
    │   │   │   └── com
    │   │   │   │   └── halilibo
    │   │   │   │       └── madewithcompose
    │   │   │   │           ├── ui
    │   │   │   │               └── theme
    │   │   │   │               │   ├── Color.kt
    │   │   │   │               │   ├── Shape.kt
    │   │   │   │               │   ├── NightMode.kt
    │   │   │   │               │   ├── Type.kt
    │   │   │   │               │   └── Theme.kt
    │   │   │   │           ├── videoplayer
    │   │   │   │               ├── Video.kt
    │   │   │   │               ├── VideoListPage.kt
    │   │   │   │               ├── MinimizedTitleAndControls.kt
    │   │   │   │               ├── VideoPlayerPage.kt
    │   │   │   │               ├── MinimizeLayout.kt
    │   │   │   │               └── VideoPlayerDemo.kt
    │   │   │   │           ├── HomePage.kt
    │   │   │   │           ├── weightentry
    │   │   │   │               └── WeightEntryDemo.kt
    │   │   │   │           ├── markdowneditor
    │   │   │   │               ├── TextFieldMutators.kt
    │   │   │   │               ├── MarkdownEditorDemo.kt
    │   │   │   │               ├── MarkdownPreview.kt
    │   │   │   │               └── MarkdownEditor.kt
    │   │   │   │           ├── brush
    │   │   │   │               ├── LightingTextDemoState.kt
    │   │   │   │               └── BrushDemo.kt
    │   │   │   │           ├── DemoEntry.kt
    │   │   │   │           ├── schedulecalendar
    │   │   │   │               └── ScheduleCalendarDemo.kt
    │   │   │   │           ├── calendar
    │   │   │   │               └── CalendarDemo.kt
    │   │   │   │           ├── varimoji
    │   │   │   │               └── VarimojiDemo.kt
    │   │   │   │           ├── circlesonlines
    │   │   │   │               └── CirclesOnLines.kt
    │   │   │   │           ├── MainActivity.kt
    │   │   │   │           ├── pip
    │   │   │   │               └── PictureInPictureDemo.kt
    │   │   │   │           ├── dotsandlines
    │   │   │   │               └── DotsAndLinesDemo.kt
    │   │   │   │           └── textonpath
    │   │   │   │               └── GlyphAnimationDemos.kt
    │   │   └── AndroidManifest.xml
    │   ├── test
    │   │   └── java
    │   │   │   └── com
    │   │   │       └── halilibo
    │   │   │           └── madewithcompose
    │   │   │               └── ExampleUnitTest.kt
    │   └── androidTest
    │   │   └── java
    │   │       └── com
    │   │           └── halilibo
    │   │               └── madewithcompose
    │   │                   └── ExampleInstrumentedTest.kt
    ├── proguard-rules.pro
    └── build.gradle.kts
├── colors
    ├── .gitignore
    ├── src
    │   └── main
    │   │   ├── AndroidManifest.xml
    │   │   └── java
    │   │       └── com
    │   │           └── halilibo
    │   │               └── colors
    │   │                   └── Colors.kt
    ├── build.gradle.kts
    └── proguard-rules.pro
├── calendar
    ├── .gitignore
    ├── src
    │   └── main
    │   │   ├── AndroidManifest.xml
    │   │   └── java
    │   │       └── com
    │   │           └── halilibo
    │   │               └── calendar
    │   │                   └── CalendarEvent.kt
    ├── proguard-rules.pro
    └── build.gradle.kts
├── screenshot
    ├── .gitignore
    ├── src
    │   └── main
    │   │   ├── AndroidManifest.xml
    │   │   └── java
    │   │       └── com
    │   │           └── halilibo
    │   │               └── screenshot
    │   │                   └── Screenshot.kt
    ├── proguard-rules.pro
    └── build.gradle.kts
├── videoplayer
    ├── .gitignore
    ├── src
    │   └── main
    │   │   ├── AndroidManifest.xml
    │   │   └── java
    │   │       └── com
    │   │           └── halilibo
    │   │               └── videoplayer
    │   │                   ├── util
    │   │                       ├── StateFlowExt.kt
    │   │                       ├── FlowDebouncer.kt
    │   │                       └── Helpers.kt
    │   │                   ├── VideoPlayerSource.kt
    │   │                   ├── PlaybackState.kt
    │   │                   ├── VideoPlayerController.kt
    │   │                   ├── PlayerSurface.kt
    │   │                   ├── VideoPlayerState.kt
    │   │                   ├── ShadowedIconButton.kt
    │   │                   ├── ProgressIndicator.kt
    │   │                   ├── VideoPlayer.kt
    │   │                   └── MediaControlButtons.kt
    ├── proguard-rules.pro
    └── build.gradle.kts
├── weightentry
    ├── .gitignore
    ├── src
    │   └── main
    │   │   ├── AndroidManifest.xml
    │   │   └── java
    │   │       └── com
    │   │           └── halilibo
    │   │               └── weightentry
    │   │                   └── WeightScale.kt
    ├── proguard-rules.pro
    └── build.gradle.kts
├── dotsandlines
    ├── .gitignore
    ├── src
    │   └── main
    │   │   ├── AndroidManifest.xml
    │   │   └── java
    │   │       └── com
    │   │           └── halilibo
    │   │               └── dotsandlines
    │   │                   ├── DotsAndLinesState.kt
    │   │                   ├── Dot.kt
    │   │                   └── DotsAndLinesModifier.kt
    ├── proguard-rules.pro
    └── build.gradle.kts
├── schedulecalendar
    ├── .gitignore
    ├── src
    │   └── main
    │   │   ├── AndroidManifest.xml
    │   │   └── java
    │   │       └── com
    │   │           └── halilibo
    │   │               └── schedulecalendar
    │   │                   └── ScheduleCalendarState.kt
    ├── proguard-rules.pro
    └── build.gradle.kts
├── gradle
    └── wrapper
    │   ├── gradle-wrapper.jar
    │   └── gradle-wrapper.properties
├── .gitignore
├── settings.gradle.kts
├── gradle.properties
├── gradlew.bat
├── README.md
└── gradlew


/app/.gitignore:
--------------------------------------------------------------------------------
1 | /build


--------------------------------------------------------------------------------
/colors/.gitignore:
--------------------------------------------------------------------------------
1 | /build


--------------------------------------------------------------------------------
/calendar/.gitignore:
--------------------------------------------------------------------------------
1 | /build


--------------------------------------------------------------------------------
/screenshot/.gitignore:
--------------------------------------------------------------------------------
1 | /build


--------------------------------------------------------------------------------
/videoplayer/.gitignore:
--------------------------------------------------------------------------------
1 | /build


--------------------------------------------------------------------------------
/weightentry/.gitignore:
--------------------------------------------------------------------------------
1 | /build


--------------------------------------------------------------------------------
/dotsandlines/.gitignore:
--------------------------------------------------------------------------------
1 | /build


--------------------------------------------------------------------------------
/schedulecalendar/.gitignore:
--------------------------------------------------------------------------------
1 | /build


--------------------------------------------------------------------------------
/calendar/src/main/AndroidManifest.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <manifest/>
3 | 


--------------------------------------------------------------------------------
/colors/src/main/AndroidManifest.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <manifest/>
3 | 


--------------------------------------------------------------------------------
/screenshot/src/main/AndroidManifest.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <manifest/>
3 | 


--------------------------------------------------------------------------------
/dotsandlines/src/main/AndroidManifest.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <manifest/>
3 | 


--------------------------------------------------------------------------------
/videoplayer/src/main/AndroidManifest.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <manifest/>
3 | 


--------------------------------------------------------------------------------
/weightentry/src/main/AndroidManifest.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <manifest/>
3 | 


--------------------------------------------------------------------------------
/schedulecalendar/src/main/AndroidManifest.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <manifest/>
3 | 


--------------------------------------------------------------------------------
/app/src/main/res/values/strings.xml:
--------------------------------------------------------------------------------
1 | <resources>
2 |     <string name="app_name">Made with Compose</string>
3 | </resources>


--------------------------------------------------------------------------------
/app/src/main/res/font/varimoji.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/halilozercan/madewithcompose/HEAD/app/src/main/res/font/varimoji.ttf


--------------------------------------------------------------------------------
/gradle/wrapper/gradle-wrapper.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/halilozercan/madewithcompose/HEAD/gradle/wrapper/gradle-wrapper.jar


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-hdpi/ic_launcher.webp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/halilozercan/madewithcompose/HEAD/app/src/main/res/mipmap-hdpi/ic_launcher.webp


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-mdpi/ic_launcher.webp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/halilozercan/madewithcompose/HEAD/app/src/main/res/mipmap-mdpi/ic_launcher.webp


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-xhdpi/ic_launcher.webp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/halilozercan/madewithcompose/HEAD/app/src/main/res/mipmap-xhdpi/ic_launcher.webp


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-xxhdpi/ic_launcher.webp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/halilozercan/madewithcompose/HEAD/app/src/main/res/mipmap-xxhdpi/ic_launcher.webp


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-xxxhdpi/ic_launcher.webp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/halilozercan/madewithcompose/HEAD/app/src/main/res/mipmap-xxxhdpi/ic_launcher.webp


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-hdpi/ic_launcher_round.webp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/halilozercan/madewithcompose/HEAD/app/src/main/res/mipmap-hdpi/ic_launcher_round.webp


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-mdpi/ic_launcher_round.webp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/halilozercan/madewithcompose/HEAD/app/src/main/res/mipmap-mdpi/ic_launcher_round.webp


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-xhdpi/ic_launcher_round.webp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/halilozercan/madewithcompose/HEAD/app/src/main/res/mipmap-xhdpi/ic_launcher_round.webp


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | *.iml
 2 | .gradle
 3 | /local.properties
 4 | /.idea
 5 | .DS_Store
 6 | /build
 7 | /captures
 8 | .externalNativeBuild
 9 | .cxx
10 | local.properties
11 | 


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.webp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/halilozercan/madewithcompose/HEAD/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.webp


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.webp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/halilozercan/madewithcompose/HEAD/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.webp


--------------------------------------------------------------------------------
/app/src/main/res/xml/file_paths.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <resources>
3 |     <paths xmlns:android="http://schemas.android.com/apk/res/android">
4 |         <cache-path name="shared_images" path="images/"/>
5 |     </paths>
6 | </resources>


--------------------------------------------------------------------------------
/videoplayer/src/main/java/com/halilibo/videoplayer/util/StateFlowExt.kt:
--------------------------------------------------------------------------------
1 | package com.halilibo.videoplayer.util
2 | 
3 | import kotlinx.coroutines.flow.MutableStateFlow
4 | 
5 | fun <T> MutableStateFlow<T>.set(block: T.() -> T) {
6 |     this.value = this.value.block()
7 | }


--------------------------------------------------------------------------------
/gradle/wrapper/gradle-wrapper.properties:
--------------------------------------------------------------------------------
1 | #Mon Oct 02 22:57:05 TRT 2023
2 | distributionBase=GRADLE_USER_HOME
3 | distributionPath=wrapper/dists
4 | distributionUrl=https\://services.gradle.org/distributions/gradle-8.0-bin.zip
5 | zipStoreBase=GRADLE_USER_HOME
6 | zipStorePath=wrapper/dists
7 | 


--------------------------------------------------------------------------------
/app/src/main/java/com/halilibo/madewithcompose/ui/theme/Color.kt:
--------------------------------------------------------------------------------
1 | package com.halilibo.madewithcompose.ui.theme
2 | 
3 | import androidx.compose.ui.graphics.Color
4 | 
5 | val Purple200 = Color(0xFFBB86FC)
6 | val Purple500 = Color(0xFF6200EE)
7 | val Purple700 = Color(0xFF3700B3)
8 | val Teal200 = Color(0xFF03DAC5)


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
3 |     <background android:drawable="@drawable/ic_launcher_background" />
4 |     <foreground android:drawable="@drawable/ic_launcher_foreground" />
5 | </adaptive-icon>


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
3 |     <background android:drawable="@drawable/ic_launcher_background" />
4 |     <foreground android:drawable="@drawable/ic_launcher_foreground" />
5 | </adaptive-icon>


--------------------------------------------------------------------------------
/videoplayer/src/main/java/com/halilibo/videoplayer/VideoPlayerSource.kt:
--------------------------------------------------------------------------------
1 | package com.halilibo.videoplayer
2 | 
3 | import androidx.annotation.RawRes
4 | 
5 | sealed class VideoPlayerSource {
6 |     data class Raw(@RawRes val resId: Int) : VideoPlayerSource()
7 |     data class Network(val url: String, val headers: Map<String, String> = mapOf()) : VideoPlayerSource()
8 | }


--------------------------------------------------------------------------------
/calendar/src/main/java/com/halilibo/calendar/CalendarEvent.kt:
--------------------------------------------------------------------------------
 1 | package com.halilibo.calendar
 2 | 
 3 | import androidx.compose.ui.graphics.Color
 4 | import com.halilibo.colors.G500
 5 | import java.util.*
 6 | 
 7 | data class CalendarEvent(
 8 |     val startDate: Date,
 9 |     val endDate: Date,
10 |     val name: String = "",
11 |     val description: String = "",
12 |     val color: Color = G500
13 | )


--------------------------------------------------------------------------------
/app/src/main/java/com/halilibo/madewithcompose/ui/theme/Shape.kt:
--------------------------------------------------------------------------------
 1 | package com.halilibo.madewithcompose.ui.theme
 2 | 
 3 | import androidx.compose.foundation.shape.RoundedCornerShape
 4 | import androidx.compose.material.Shapes
 5 | import androidx.compose.ui.unit.dp
 6 | 
 7 | val Shapes = Shapes(
 8 |   small = RoundedCornerShape(4.dp),
 9 |   medium = RoundedCornerShape(4.dp),
10 |   large = RoundedCornerShape(0.dp)
11 | )


--------------------------------------------------------------------------------
/app/src/main/res/values/colors.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <resources>
 3 |     <color name="purple_200">#FFBB86FC</color>
 4 |     <color name="purple_500">#FF6200EE</color>
 5 |     <color name="purple_700">#FF3700B3</color>
 6 |     <color name="teal_200">#FF03DAC5</color>
 7 |     <color name="teal_700">#FF018786</color>
 8 |     <color name="black">#FF000000</color>
 9 |     <color name="white">#FFFFFFFF</color>
10 | </resources>


--------------------------------------------------------------------------------
/app/src/test/java/com/halilibo/madewithcompose/ExampleUnitTest.kt:
--------------------------------------------------------------------------------
 1 | package com.halilibo.madewithcompose
 2 | 
 3 | import org.junit.Assert.assertEquals
 4 | import org.junit.Test
 5 | 
 6 | /**
 7 |  * Example local unit test, which will execute on the development machine (host).
 8 |  *
 9 |  * See [testing documentation](http://d.android.com/tools/testing).
10 |  */
11 | class ExampleUnitTest {
12 |   @Test
13 |   fun addition_isCorrect() {
14 |     assertEquals(4, 2 + 2)
15 |   }
16 | }


--------------------------------------------------------------------------------
/app/src/main/java/com/halilibo/madewithcompose/videoplayer/Video.kt:
--------------------------------------------------------------------------------
 1 | package com.halilibo.madewithcompose.videoplayer
 2 | 
 3 | import android.os.Parcelable
 4 | import kotlinx.parcelize.Parcelize
 5 | 
 6 | @Parcelize
 7 | data class Video(
 8 |     val description: String,
 9 |     val sources: List<String>,
10 |     val subtitle: String,
11 |     val title: String,
12 |     val thumb: String
13 | ): Parcelable
14 | 
15 | @Parcelize
16 | data class VideoList(
17 |     val videos: List<Video>
18 | ): Parcelable


--------------------------------------------------------------------------------
/videoplayer/src/main/java/com/halilibo/videoplayer/PlaybackState.kt:
--------------------------------------------------------------------------------
 1 | package com.halilibo.videoplayer
 2 | 
 3 | import com.google.android.exoplayer2.Player.*
 4 | 
 5 | enum class PlaybackState(val value: Int) {
 6 | 
 7 |     IDLE(STATE_IDLE),
 8 |     BUFFERING(STATE_BUFFERING),
 9 |     READY(STATE_READY),
10 |     ENDED(STATE_ENDED);
11 | 
12 |     companion object {
13 |         fun of(value: Int): PlaybackState {
14 |             return values().first { it.value == value }
15 |         }
16 |     }
17 | }


--------------------------------------------------------------------------------
/settings.gradle.kts:
--------------------------------------------------------------------------------
 1 | @file:Suppress("UnstableApiUsage")
 2 | 
 3 | dependencyResolutionManagement {
 4 |   repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
 5 |   repositories {
 6 |     google()
 7 |     mavenCentral()
 8 |     mavenLocal()
 9 |   }
10 | }
11 | rootProject.name = "madewithcompose"
12 | include(":app")
13 | include(":videoplayer")
14 | include(":schedulecalendar")
15 | include(":dotsandlines")
16 | include(":calendar")
17 | include(":weightentry")
18 | include(":screenshot")
19 | include(":colors")
20 | 


--------------------------------------------------------------------------------
/app/src/main/java/com/halilibo/madewithcompose/ui/theme/NightMode.kt:
--------------------------------------------------------------------------------
 1 | package com.halilibo.madewithcompose.ui.theme
 2 | 
 3 | import androidx.compose.runtime.*
 4 | 
 5 | val LocalNightMode = staticCompositionLocalOf<NightMode> { error("Night Mode is not provided") }
 6 | 
 7 | @Stable
 8 | class NightMode(
 9 |     initialNightMode: Boolean
10 | ) {
11 |     var isNight by mutableStateOf(initialNightMode)
12 | 
13 |     fun setDay() {
14 |         isNight = false
15 |     }
16 | 
17 |     fun setNight() {
18 |         isNight = true
19 |     }
20 | 
21 |     fun toggle() {
22 |         isNight = !isNight
23 |     }
24 | }


--------------------------------------------------------------------------------
/videoplayer/src/main/java/com/halilibo/videoplayer/VideoPlayerController.kt:
--------------------------------------------------------------------------------
 1 | package com.halilibo.videoplayer
 2 | 
 3 | import kotlinx.coroutines.flow.StateFlow
 4 | 
 5 | interface VideoPlayerController {
 6 | 
 7 |     fun setSource(source: VideoPlayerSource)
 8 | 
 9 |     fun play()
10 | 
11 |     fun pause()
12 | 
13 |     fun playPauseToggle()
14 | 
15 |     fun quickSeekForward()
16 | 
17 |     fun quickSeekRewind()
18 | 
19 |     fun seekTo(position: Long)
20 | 
21 |     fun reset()
22 | 
23 |     fun startMediaSession()
24 | 
25 |     fun stopMediaSession()
26 | 
27 |     val state: StateFlow<VideoPlayerState>
28 | 
29 |     fun dispose()
30 | }


--------------------------------------------------------------------------------
/videoplayer/src/main/java/com/halilibo/videoplayer/PlayerSurface.kt:
--------------------------------------------------------------------------------
 1 | package com.halilibo.videoplayer
 2 | 
 3 | import androidx.compose.runtime.Composable
 4 | import androidx.compose.ui.Modifier
 5 | import androidx.compose.ui.viewinterop.AndroidView
 6 | import com.google.android.exoplayer2.ui.PlayerView
 7 | 
 8 | @Composable
 9 | fun PlayerSurface(
10 |     modifier: Modifier = Modifier,
11 |     onPlayerViewAvailable: (PlayerView) -> Unit = {}
12 | ) {
13 |     AndroidView(
14 |         factory = { context ->
15 |             PlayerView(context).apply {
16 |                 useController = false
17 |                 onPlayerViewAvailable(this)
18 |             }
19 |         },
20 |         modifier = modifier
21 |     )
22 | }


--------------------------------------------------------------------------------
/app/src/androidTest/java/com/halilibo/madewithcompose/ExampleInstrumentedTest.kt:
--------------------------------------------------------------------------------
 1 | package com.halilibo.madewithcompose
 2 | 
 3 | import androidx.test.ext.junit.runners.AndroidJUnit4
 4 | import androidx.test.platform.app.InstrumentationRegistry
 5 | import org.junit.Assert.assertEquals
 6 | import org.junit.Test
 7 | import org.junit.runner.RunWith
 8 | 
 9 | /**
10 |  * Instrumented test, which will execute on an Android device.
11 |  *
12 |  * See [testing documentation](http://d.android.com/tools/testing).
13 |  */
14 | @RunWith(AndroidJUnit4::class)
15 | class ExampleInstrumentedTest {
16 |   @Test
17 |   fun useAppContext() {
18 |     // Context of the app under test.
19 |     val appContext = InstrumentationRegistry.getInstrumentation().targetContext
20 |     assertEquals("com.halilibo.schedulecalendar", appContext.packageName)
21 |   }
22 | }


--------------------------------------------------------------------------------
/app/proguard-rules.pro:
--------------------------------------------------------------------------------
 1 | # Add project specific ProGuard rules here.
 2 | # You can control the set of applied configuration files using the
 3 | # proguardFiles setting in build.gradle.
 4 | #
 5 | # For more details, see
 6 | #   http://developer.android.com/guide/developing/tools/proguard.html
 7 | 
 8 | # If your project uses WebView with JS, uncomment the following
 9 | # and specify the fully qualified class name to the JavaScript interface
10 | # class:
11 | #-keepclassmembers class fqcn.of.javascript.interface.for.webview {
12 | #   public *;
13 | #}
14 | 
15 | # Uncomment this to preserve the line number information for
16 | # debugging stack traces.
17 | #-keepattributes SourceFile,LineNumberTable
18 | 
19 | # If you keep the line number information, uncomment this to
20 | # hide the original source file name.
21 | #-renamesourcefileattribute SourceFile


--------------------------------------------------------------------------------
/colors/build.gradle.kts:
--------------------------------------------------------------------------------
 1 | plugins {
 2 |     id("com.android.library")
 3 |     id("kotlin-android")
 4 | }
 5 | 
 6 | android {
 7 |     compileSdk = 34
 8 |     namespace = "com.halilibo.colors"
 9 | 
10 |     defaultConfig {
11 |         minSdk = 26
12 | 
13 |         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
14 |     }
15 | 
16 |     buildTypes {
17 |         release {
18 |             isMinifyEnabled = false
19 |             proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro")
20 |         }
21 |     }
22 |     compileOptions {
23 |         sourceCompatibility = JavaVersion.VERSION_11
24 |         targetCompatibility = JavaVersion.VERSION_11
25 |     }
26 |     kotlinOptions {
27 |         jvmTarget = "11"
28 |     }
29 | }
30 | 
31 | dependencies {
32 |     implementation(Compose.ui)
33 | }


--------------------------------------------------------------------------------
/calendar/proguard-rules.pro:
--------------------------------------------------------------------------------
 1 | # Add project specific ProGuard rules here.
 2 | # You can control the set of applied configuration files using the
 3 | # proguardFiles setting in build.gradle.
 4 | #
 5 | # For more details, see
 6 | #   http://developer.android.com/guide/developing/tools/proguard.html
 7 | 
 8 | # If your project uses WebView with JS, uncomment the following
 9 | # and specify the fully qualified class name to the JavaScript interface
10 | # class:
11 | #-keepclassmembers class fqcn.of.javascript.interface.for.webview {
12 | #   public *;
13 | #}
14 | 
15 | # Uncomment this to preserve the line number information for
16 | # debugging stack traces.
17 | #-keepattributes SourceFile,LineNumberTable
18 | 
19 | # If you keep the line number information, uncomment this to
20 | # hide the original source file name.
21 | #-renamesourcefileattribute SourceFile


--------------------------------------------------------------------------------
/colors/proguard-rules.pro:
--------------------------------------------------------------------------------
 1 | # Add project specific ProGuard rules here.
 2 | # You can control the set of applied configuration files using the
 3 | # proguardFiles setting in build.gradle.
 4 | #
 5 | # For more details, see
 6 | #   http://developer.android.com/guide/developing/tools/proguard.html
 7 | 
 8 | # If your project uses WebView with JS, uncomment the following
 9 | # and specify the fully qualified class name to the JavaScript interface
10 | # class:
11 | #-keepclassmembers class fqcn.of.javascript.interface.for.webview {
12 | #   public *;
13 | #}
14 | 
15 | # Uncomment this to preserve the line number information for
16 | # debugging stack traces.
17 | #-keepattributes SourceFile,LineNumberTable
18 | 
19 | # If you keep the line number information, uncomment this to
20 | # hide the original source file name.
21 | #-renamesourcefileattribute SourceFile


--------------------------------------------------------------------------------
/dotsandlines/proguard-rules.pro:
--------------------------------------------------------------------------------
 1 | # Add project specific ProGuard rules here.
 2 | # You can control the set of applied configuration files using the
 3 | # proguardFiles setting in build.gradle.
 4 | #
 5 | # For more details, see
 6 | #   http://developer.android.com/guide/developing/tools/proguard.html
 7 | 
 8 | # If your project uses WebView with JS, uncomment the following
 9 | # and specify the fully qualified class name to the JavaScript interface
10 | # class:
11 | #-keepclassmembers class fqcn.of.javascript.interface.for.webview {
12 | #   public *;
13 | #}
14 | 
15 | # Uncomment this to preserve the line number information for
16 | # debugging stack traces.
17 | #-keepattributes SourceFile,LineNumberTable
18 | 
19 | # If you keep the line number information, uncomment this to
20 | # hide the original source file name.
21 | #-renamesourcefileattribute SourceFile


--------------------------------------------------------------------------------
/screenshot/proguard-rules.pro:
--------------------------------------------------------------------------------
 1 | # Add project specific ProGuard rules here.
 2 | # You can control the set of applied configuration files using the
 3 | # proguardFiles setting in build.gradle.
 4 | #
 5 | # For more details, see
 6 | #   http://developer.android.com/guide/developing/tools/proguard.html
 7 | 
 8 | # If your project uses WebView with JS, uncomment the following
 9 | # and specify the fully qualified class name to the JavaScript interface
10 | # class:
11 | #-keepclassmembers class fqcn.of.javascript.interface.for.webview {
12 | #   public *;
13 | #}
14 | 
15 | # Uncomment this to preserve the line number information for
16 | # debugging stack traces.
17 | #-keepattributes SourceFile,LineNumberTable
18 | 
19 | # If you keep the line number information, uncomment this to
20 | # hide the original source file name.
21 | #-renamesourcefileattribute SourceFile


--------------------------------------------------------------------------------
/videoplayer/proguard-rules.pro:
--------------------------------------------------------------------------------
 1 | # Add project specific ProGuard rules here.
 2 | # You can control the set of applied configuration files using the
 3 | # proguardFiles setting in build.gradle.
 4 | #
 5 | # For more details, see
 6 | #   http://developer.android.com/guide/developing/tools/proguard.html
 7 | 
 8 | # If your project uses WebView with JS, uncomment the following
 9 | # and specify the fully qualified class name to the JavaScript interface
10 | # class:
11 | #-keepclassmembers class fqcn.of.javascript.interface.for.webview {
12 | #   public *;
13 | #}
14 | 
15 | # Uncomment this to preserve the line number information for
16 | # debugging stack traces.
17 | #-keepattributes SourceFile,LineNumberTable
18 | 
19 | # If you keep the line number information, uncomment this to
20 | # hide the original source file name.
21 | #-renamesourcefileattribute SourceFile


--------------------------------------------------------------------------------
/weightentry/proguard-rules.pro:
--------------------------------------------------------------------------------
 1 | # Add project specific ProGuard rules here.
 2 | # You can control the set of applied configuration files using the
 3 | # proguardFiles setting in build.gradle.
 4 | #
 5 | # For more details, see
 6 | #   http://developer.android.com/guide/developing/tools/proguard.html
 7 | 
 8 | # If your project uses WebView with JS, uncomment the following
 9 | # and specify the fully qualified class name to the JavaScript interface
10 | # class:
11 | #-keepclassmembers class fqcn.of.javascript.interface.for.webview {
12 | #   public *;
13 | #}
14 | 
15 | # Uncomment this to preserve the line number information for
16 | # debugging stack traces.
17 | #-keepattributes SourceFile,LineNumberTable
18 | 
19 | # If you keep the line number information, uncomment this to
20 | # hide the original source file name.
21 | #-renamesourcefileattribute SourceFile


--------------------------------------------------------------------------------
/schedulecalendar/proguard-rules.pro:
--------------------------------------------------------------------------------
 1 | # Add project specific ProGuard rules here.
 2 | # You can control the set of applied configuration files using the
 3 | # proguardFiles setting in build.gradle.
 4 | #
 5 | # For more details, see
 6 | #   http://developer.android.com/guide/developing/tools/proguard.html
 7 | 
 8 | # If your project uses WebView with JS, uncomment the following
 9 | # and specify the fully qualified class name to the JavaScript interface
10 | # class:
11 | #-keepclassmembers class fqcn.of.javascript.interface.for.webview {
12 | #   public *;
13 | #}
14 | 
15 | # Uncomment this to preserve the line number information for
16 | # debugging stack traces.
17 | #-keepattributes SourceFile,LineNumberTable
18 | 
19 | # If you keep the line number information, uncomment this to
20 | # hide the original source file name.
21 | #-renamesourcefileattribute SourceFile


--------------------------------------------------------------------------------
/videoplayer/src/main/java/com/halilibo/videoplayer/VideoPlayerState.kt:
--------------------------------------------------------------------------------
 1 | package com.halilibo.videoplayer
 2 | 
 3 | import android.os.Parcelable
 4 | import androidx.compose.ui.geometry.Size
 5 | import kotlinx.parcelize.IgnoredOnParcel
 6 | import kotlinx.parcelize.Parcelize
 7 | 
 8 | @Parcelize
 9 | data class VideoPlayerState(
10 |     val isPlaying: Boolean = true,
11 |     val controlsVisible: Boolean = true,
12 |     val controlsEnabled: Boolean = true,
13 |     val gesturesEnabled: Boolean = true,
14 |     val duration: Long = 1L,
15 |     val currentPosition: Long = 1L,
16 |     val secondaryProgress: Long = 1L,
17 |     val videoWidth: Float = 1920f,
18 |     val videoHeight: Float = 1080f,
19 |     val draggingProgress: DraggingProgress? = null,
20 |     val playbackState: PlaybackState = PlaybackState.IDLE
21 | ): Parcelable {
22 |     @IgnoredOnParcel
23 |     val videoSize: Size = Size(videoWidth, videoHeight)
24 | }


--------------------------------------------------------------------------------
/videoplayer/src/main/java/com/halilibo/videoplayer/util/FlowDebouncer.kt:
--------------------------------------------------------------------------------
 1 | package com.halilibo.videoplayer.util
 2 | 
 3 | import kotlinx.coroutines.FlowPreview
 4 | import kotlinx.coroutines.InternalCoroutinesApi
 5 | import kotlinx.coroutines.channels.Channel
 6 | import kotlinx.coroutines.flow.Flow
 7 | import kotlinx.coroutines.flow.FlowCollector
 8 | import kotlinx.coroutines.flow.consumeAsFlow
 9 | import kotlinx.coroutines.flow.debounce
10 | 
11 | class FlowDebouncer<T>(timeoutMillis: Long): Flow<T> {
12 | 
13 |     private val sourceChannel: Channel<T> = Channel(capacity = 1)
14 | 
15 |     @OptIn(FlowPreview::class)
16 |     private val flow: Flow<T> = sourceChannel.consumeAsFlow().debounce(timeoutMillis)
17 | 
18 |     suspend fun put(item: T) {
19 |         sourceChannel.send(item)
20 |     }
21 | 
22 |     override suspend fun collect(collector: FlowCollector<T>) {
23 |         flow.collect(collector)
24 |     }
25 | }


--------------------------------------------------------------------------------
/app/src/main/res/values-night/themes.xml:
--------------------------------------------------------------------------------
 1 | <resources xmlns:tools="http://schemas.android.com/tools">
 2 |     <!-- Base application theme. -->
 3 |     <style name="Theme.ScheduleCalendar" parent="Theme.MaterialComponents.DayNight.DarkActionBar">
 4 |         <!-- Primary brand color. -->
 5 |         <item name="colorPrimary">@color/purple_200</item>
 6 |         <item name="colorPrimaryVariant">@color/purple_700</item>
 7 |         <item name="colorOnPrimary">@color/black</item>
 8 |         <!-- Secondary brand color. -->
 9 |         <item name="colorSecondary">@color/teal_200</item>
10 |         <item name="colorSecondaryVariant">@color/teal_200</item>
11 |         <item name="colorOnSecondary">@color/black</item>
12 |         <!-- Status bar color. -->
13 |         <item name="android:statusBarColor" tools:targetApi="l">?attr/colorPrimaryVariant</item>
14 |         <!-- Customize your theme here. -->
15 |     </style>
16 | </resources>


--------------------------------------------------------------------------------
/app/src/main/java/com/halilibo/madewithcompose/ui/theme/Type.kt:
--------------------------------------------------------------------------------
 1 | package com.halilibo.madewithcompose.ui.theme
 2 | 
 3 | import androidx.compose.material.Typography
 4 | import androidx.compose.ui.text.TextStyle
 5 | import androidx.compose.ui.text.font.FontFamily
 6 | import androidx.compose.ui.text.font.FontWeight
 7 | import androidx.compose.ui.unit.sp
 8 | 
 9 | // Set of Material typography styles to start with
10 | val Typography = Typography(
11 |   body1 = TextStyle(
12 |     fontFamily = FontFamily.Default,
13 |     fontWeight = FontWeight.Normal,
14 |     fontSize = 16.sp
15 |   )
16 |   /* Other default text styles to override
17 |     button = TextStyle(
18 |         fontFamily = FontFamily.Default,
19 |         fontWeight = FontWeight.W500,
20 |         fontSize = 14.sp
21 |     ),
22 |     caption = TextStyle(
23 |         fontFamily = FontFamily.Default,
24 |         fontWeight = FontWeight.Normal,
25 |         fontSize = 12.sp
26 |     )
27 |     */
28 | )


--------------------------------------------------------------------------------
/videoplayer/src/main/java/com/halilibo/videoplayer/util/Helpers.kt:
--------------------------------------------------------------------------------
 1 | package com.halilibo.videoplayer.util
 2 | 
 3 | import java.util.*
 4 | import java.util.concurrent.TimeUnit
 5 | 
 6 | fun getDurationString(durationMs: Long, negativePrefix: Boolean): String {
 7 |     val hours = TimeUnit.MILLISECONDS.toHours(durationMs)
 8 |     val minutes = TimeUnit.MILLISECONDS.toMinutes(durationMs)
 9 |     val seconds = TimeUnit.MILLISECONDS.toSeconds(durationMs)
10 | 
11 |     return if (hours > 0) {
12 |         java.lang.String.format(Locale.getDefault(), "%s%02d:%02d:%02d",
13 |                 if (negativePrefix) "-" else "",
14 |                 hours,
15 |                 minutes - TimeUnit.HOURS.toMinutes(hours),
16 |                 seconds - TimeUnit.MINUTES.toSeconds(minutes))
17 |     } else java.lang.String.format(Locale.getDefault(), "%s%02d:%02d",
18 |             if (negativePrefix) "-" else "",
19 |             minutes,
20 |             seconds - TimeUnit.MINUTES.toSeconds(minutes)
21 |     )
22 | }


--------------------------------------------------------------------------------
/dotsandlines/build.gradle.kts:
--------------------------------------------------------------------------------
 1 | plugins {
 2 |     id("com.android.library")
 3 |     id("kotlin-android")
 4 |     id("kotlin-parcelize")
 5 | }
 6 | 
 7 | android {
 8 |     compileSdk = 34
 9 |     namespace = "com.halilibo.dotsandlines"
10 | 
11 |     defaultConfig {
12 |         minSdk = 26
13 | 
14 |         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
15 |         vectorDrawables {
16 |             useSupportLibrary = true
17 |         }
18 |     }
19 | 
20 |     buildTypes {
21 |         release {
22 |             isMinifyEnabled = false
23 |             proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro")
24 |         }
25 |     }
26 |     compileOptions {
27 |         sourceCompatibility = JavaVersion.VERSION_11
28 |         targetCompatibility = JavaVersion.VERSION_11
29 |     }
30 |     kotlinOptions {
31 |         jvmTarget = "11"
32 |     }
33 |     buildFeatures {
34 |         compose = true
35 |     }
36 |     composeOptions {
37 |         kotlinCompilerExtensionVersion = Compose.compilerVersion
38 |     }
39 | }
40 | 
41 | dependencies {
42 |     implementation(Compose.ui)
43 |     implementation(Compose.material)
44 |     implementation(Compose.uiTooling)
45 | }


--------------------------------------------------------------------------------
/gradle.properties:
--------------------------------------------------------------------------------
 1 | # Project-wide Gradle settings.
 2 | # IDE (e.g. Android Studio) users:
 3 | # Gradle settings configured through the IDE *will override*
 4 | # any settings specified in this file.
 5 | # For more details on how to configure your build environment visit
 6 | # http://www.gradle.org/docs/current/userguide/build_environment.html
 7 | # Specifies the JVM arguments used for the daemon process.
 8 | # The setting is particularly useful for tweaking memory settings.
 9 | org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8
10 | # When configured, Gradle will run in incubating parallel mode.
11 | # This option should only be used with decoupled projects. More details, visit
12 | # http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
13 | # org.gradle.parallel=true
14 | # AndroidX package structure to make it clearer which packages are bundled with the
15 | # Android operating system, and which are packaged with your app"s APK
16 | # https://developer.android.com/topic/libraries/support-library/androidx-rn
17 | android.useAndroidX=true
18 | # Automatically convert third-party libraries to use AndroidX
19 | android.enableJetifier=true
20 | # Kotlin code style for this project: "official" or "obsolete":
21 | kotlin.code.style=official


--------------------------------------------------------------------------------
/calendar/build.gradle.kts:
--------------------------------------------------------------------------------
 1 | plugins {
 2 |     id("com.android.library")
 3 |     id("kotlin-android")
 4 |     id("kotlin-parcelize")
 5 | }
 6 | 
 7 | android {
 8 |     compileSdk = 34
 9 |     namespace = "com.halilibo.calendar"
10 | 
11 |     defaultConfig {
12 |         minSdk = 26
13 | 
14 |         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
15 |         vectorDrawables {
16 |             useSupportLibrary = true
17 |         }
18 |     }
19 | 
20 |     buildTypes {
21 |         release {
22 |             isMinifyEnabled = false
23 |             proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro")
24 |         }
25 |     }
26 |     compileOptions {
27 |         sourceCompatibility = JavaVersion.VERSION_11
28 |         targetCompatibility = JavaVersion.VERSION_11
29 |     }
30 |     kotlinOptions {
31 |         jvmTarget = "11"
32 |     }
33 |     buildFeatures {
34 |         compose = true
35 |     }
36 |     composeOptions {
37 |         kotlinCompilerExtensionVersion = Compose.compilerVersion
38 |     }
39 | }
40 | 
41 | dependencies {
42 |     implementation(project(":colors"))
43 |     implementation(Compose.ui)
44 |     implementation(Compose.uiUtil)
45 |     implementation(Compose.material)
46 |     implementation(Compose.uiTooling)
47 | }


--------------------------------------------------------------------------------
/app/src/main/res/values/themes.xml:
--------------------------------------------------------------------------------
 1 | <resources xmlns:tools="http://schemas.android.com/tools">
 2 |     <!-- Base application theme. -->
 3 |     <style name="Theme.MadeWithCompose" parent="Theme.MaterialComponents.DayNight.DarkActionBar">
 4 |         <!-- Primary brand color. -->
 5 |         <item name="colorPrimary">@color/purple_500</item>
 6 |         <item name="colorPrimaryVariant">@color/purple_700</item>
 7 |         <item name="colorOnPrimary">@color/white</item>
 8 |         <!-- Secondary brand color. -->
 9 |         <item name="colorSecondary">@color/teal_200</item>
10 |         <item name="colorSecondaryVariant">@color/teal_700</item>
11 |         <item name="colorOnSecondary">@color/black</item>
12 |         <!-- Status bar color. -->
13 |         <item name="android:statusBarColor" tools:targetApi="l">?attr/colorPrimaryVariant</item>
14 |         <!-- Customize your theme here. -->
15 |     </style>
16 | 
17 |     <style name="Theme.MadeWithCompose.NoActionBar">
18 |         <item name="windowActionBar">false</item>
19 |         <item name="windowNoTitle">true</item>
20 |     </style>
21 | 
22 |     <style name="Theme.MadeWithCompose.AppBarOverlay" parent="ThemeOverlay.AppCompat.Dark.ActionBar" />
23 | 
24 |     <style name="Theme.MadeWithCompose.PopupOverlay" parent="ThemeOverlay.AppCompat.Light" />
25 | </resources>


--------------------------------------------------------------------------------
/screenshot/build.gradle.kts:
--------------------------------------------------------------------------------
 1 | plugins {
 2 |     id("com.android.library")
 3 |     id("kotlin-android")
 4 | }
 5 | 
 6 | android {
 7 |     compileSdk = 34
 8 |     namespace = "com.halilibo.screenshot"
 9 | 
10 |     defaultConfig {
11 |         minSdk = 26
12 | 
13 |         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
14 |         vectorDrawables {
15 |             useSupportLibrary = true
16 |         }
17 |     }
18 | 
19 |     buildTypes {
20 |         release {
21 |             isMinifyEnabled = false
22 |             proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro")
23 |         }
24 |     }
25 |     compileOptions {
26 |         sourceCompatibility = JavaVersion.VERSION_11
27 |         targetCompatibility = JavaVersion.VERSION_11
28 |     }
29 |     kotlinOptions {
30 |         jvmTarget = "11"
31 |     }
32 |     buildFeatures {
33 |         compose = true
34 |     }
35 |     composeOptions {
36 |         kotlinCompilerExtensionVersion = Compose.compilerVersion
37 |     }
38 | }
39 | 
40 | dependencies {
41 |     implementation(project(":colors"))
42 |     implementation(Compose.ui)
43 |     implementation(Compose.material)
44 |     implementation(Compose.uiTooling)
45 |     implementation(Compose.iconsExtended)
46 |     implementation(Compose.activity)
47 | }


--------------------------------------------------------------------------------
/weightentry/build.gradle.kts:
--------------------------------------------------------------------------------
 1 | plugins {
 2 |     id("com.android.library")
 3 |     id("kotlin-android")
 4 | }
 5 | 
 6 | android {
 7 |     compileSdk = 34
 8 |     namespace = "com.halilibo.weightentry"
 9 | 
10 |     defaultConfig {
11 |         minSdk = 26
12 | 
13 |         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
14 |         vectorDrawables {
15 |             useSupportLibrary = true
16 |         }
17 |     }
18 | 
19 |     buildTypes {
20 |         release {
21 |             isMinifyEnabled = false
22 |             proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro")
23 |         }
24 |     }
25 |     compileOptions {
26 |         sourceCompatibility = JavaVersion.VERSION_11
27 |         targetCompatibility = JavaVersion.VERSION_11
28 |     }
29 |     kotlinOptions {
30 |         jvmTarget = "11"
31 |     }
32 |     buildFeatures {
33 |         compose = true
34 |     }
35 |     composeOptions {
36 |         kotlinCompilerExtensionVersion = Compose.compilerVersion
37 |     }
38 | }
39 | 
40 | dependencies {
41 |     implementation(project(":colors"))
42 |     implementation(Compose.ui)
43 |     implementation(Compose.material)
44 |     implementation(Compose.uiTooling)
45 |     implementation(Compose.iconsExtended)
46 |     implementation(Compose.activity)
47 | }


--------------------------------------------------------------------------------
/schedulecalendar/build.gradle.kts:
--------------------------------------------------------------------------------
 1 | plugins {
 2 |     id("com.android.library")
 3 |     id("kotlin-android")
 4 | }
 5 | 
 6 | android {
 7 |     compileSdk = 34
 8 |     namespace = "com.halilibo.schedulecalendar"
 9 | 
10 |     defaultConfig {
11 |         minSdk = 26
12 | 
13 |         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
14 |         vectorDrawables {
15 |             useSupportLibrary = true
16 |         }
17 |     }
18 | 
19 |     buildTypes {
20 |         release {
21 |             isMinifyEnabled = false
22 |             proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro")
23 |         }
24 |     }
25 |     compileOptions {
26 |         sourceCompatibility = JavaVersion.VERSION_11
27 |         targetCompatibility = JavaVersion.VERSION_11
28 |     }
29 |     kotlinOptions {
30 |         jvmTarget = "11"
31 |     }
32 |     buildFeatures {
33 |         compose = true
34 |     }
35 |     composeOptions {
36 |         kotlinCompilerExtensionVersion = Compose.compilerVersion
37 |     }
38 | }
39 | 
40 | dependencies {
41 |     implementation(project(":colors"))
42 |     implementation(Compose.ui)
43 |     implementation(Compose.material)
44 |     implementation(Compose.uiTooling)
45 |     implementation(Compose.iconsExtended)
46 |     implementation(Compose.activity)
47 | }


--------------------------------------------------------------------------------
/videoplayer/src/main/java/com/halilibo/videoplayer/ShadowedIconButton.kt:
--------------------------------------------------------------------------------
 1 | package com.halilibo.videoplayer
 2 | 
 3 | import androidx.compose.foundation.layout.Box
 4 | import androidx.compose.foundation.layout.offset
 5 | import androidx.compose.foundation.layout.size
 6 | import androidx.compose.material.Icon
 7 | import androidx.compose.runtime.Composable
 8 | import androidx.compose.ui.Alignment
 9 | import androidx.compose.ui.Modifier
10 | import androidx.compose.ui.graphics.Color
11 | import androidx.compose.ui.graphics.vector.ImageVector
12 | import androidx.compose.ui.unit.Dp
13 | import androidx.compose.ui.unit.dp
14 | 
15 | 
16 | @Composable
17 | fun ShadowedIcon(
18 |     icon: ImageVector,
19 |     modifier: Modifier = Modifier,
20 |     iconSize: Dp = 48.dp,
21 | ) {
22 |     Box(modifier = modifier) {
23 |         Icon(
24 |             imageVector = icon,
25 |             tint = Color.Black.copy(alpha = 0.3f),
26 |             modifier = Modifier
27 |                 .size(iconSize)
28 |                 .align(Alignment.Center)
29 |                 .offset(2.dp, 2.dp),
30 |             contentDescription = null
31 |         )
32 |         Icon(
33 |             imageVector = icon,
34 |             modifier = Modifier
35 |                 .size(iconSize)
36 |                 .align(Alignment.Center),
37 |             contentDescription = null
38 |         )
39 |     }
40 | }


--------------------------------------------------------------------------------
/videoplayer/build.gradle.kts:
--------------------------------------------------------------------------------
 1 | plugins {
 2 |     id("com.android.library")
 3 |     id("kotlin-android")
 4 |     id("kotlin-parcelize")
 5 | }
 6 | 
 7 | android {
 8 |     compileSdk = 34
 9 |     namespace = "com.halilibo.videoplayer"
10 | 
11 |     defaultConfig {
12 |         minSdk = 26
13 | 
14 |         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
15 |         vectorDrawables {
16 |             useSupportLibrary = true
17 |         }
18 |     }
19 | 
20 |     buildTypes {
21 |         release {
22 |             isMinifyEnabled = false
23 |             proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro")
24 |         }
25 |     }
26 |     compileOptions {
27 |         sourceCompatibility = JavaVersion.VERSION_11
28 |         targetCompatibility = JavaVersion.VERSION_11
29 |     }
30 |     kotlinOptions {
31 |         jvmTarget = "11"
32 |     }
33 |     buildFeatures {
34 |         compose = true
35 |     }
36 |     composeOptions {
37 |         kotlinCompilerExtensionVersion = Compose.compilerVersion
38 |     }
39 | }
40 | 
41 | dependencies {
42 |     implementation(Compose.ui)
43 |     implementation(Compose.material)
44 |     implementation(Compose.uiTooling)
45 |     implementation(Compose.iconsExtended)
46 |     implementation(Compose.activity)
47 |     implementation(Libraries.media)
48 |     implementation("com.google.android.exoplayer:exoplayer:2.14.0")
49 |     implementation("com.google.android.exoplayer:extension-mediasession:2.14.0")
50 | }


--------------------------------------------------------------------------------
/app/src/main/java/com/halilibo/madewithcompose/HomePage.kt:
--------------------------------------------------------------------------------
 1 | package com.halilibo.madewithcompose
 2 | 
 3 | import androidx.compose.foundation.clickable
 4 | import androidx.compose.foundation.layout.fillMaxSize
 5 | import androidx.compose.foundation.layout.fillMaxWidth
 6 | import androidx.compose.foundation.layout.padding
 7 | import androidx.compose.foundation.lazy.LazyColumn
 8 | import androidx.compose.foundation.lazy.items
 9 | import androidx.compose.material.Card
10 | import androidx.compose.material.Text
11 | import androidx.compose.runtime.Composable
12 | import androidx.compose.ui.Modifier
13 | import androidx.compose.ui.unit.dp
14 | import androidx.compose.ui.unit.sp
15 | import androidx.navigation.NavController
16 | 
17 | 
18 | @Composable
19 | fun HomePage(navController: NavController) {
20 |     LazyColumn(
21 |         modifier = Modifier
22 |             .fillMaxSize()
23 |             .padding(8.dp)
24 |     ) {
25 |         items(DemoEntry.values()) { demo ->
26 |             Card(
27 |                 elevation = 4.dp,
28 |                 modifier = Modifier
29 |                     .padding(8.dp)
30 |                     .clickable {
31 |                         navController.navigate(demo.destination)
32 |                     }) {
33 |                 Text(
34 |                     text = demo.title,
35 |                     fontSize = 20.sp,
36 |                     modifier = Modifier
37 |                         .fillMaxWidth()
38 |                         .padding(8.dp)
39 |                 )
40 |             }
41 |         }
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/app/src/main/java/com/halilibo/madewithcompose/weightentry/WeightEntryDemo.kt:
--------------------------------------------------------------------------------
 1 | package com.halilibo.madewithcompose.weightentry
 2 | 
 3 | import androidx.compose.foundation.layout.Column
 4 | import androidx.compose.foundation.layout.fillMaxWidth
 5 | import androidx.compose.foundation.layout.height
 6 | import androidx.compose.foundation.layout.padding
 7 | import androidx.compose.runtime.Composable
 8 | import androidx.compose.ui.Modifier
 9 | import androidx.compose.ui.tooling.preview.Preview
10 | import androidx.compose.ui.unit.dp
11 | import com.halilibo.madewithcompose.ui.theme.MadeWithComposeTheme
12 | import com.halilibo.weightentry.WeightEntry
13 | import com.halilibo.weightentry.WeightScale
14 | import com.halilibo.weightentry.rememberWeightEntryState
15 | import kotlin.math.roundToInt
16 | 
17 | @Composable
18 | fun WeightEntryDemo() {
19 |     Column(modifier = Modifier.padding(16.dp)) {
20 |         val state = rememberWeightEntryState(
21 |             initialValue = 78,
22 |             valueRange = 20..180
23 |         )
24 | 
25 |         WeightEntry(
26 |             state = state,
27 |             modifier = Modifier
28 |         )
29 | 
30 |         WeightScale(
31 |             weight = state.value.roundToInt(),
32 |             valueRange = 20..180,
33 |             modifier = Modifier
34 |                 .fillMaxWidth()
35 |                 .height(300.dp)
36 |         )
37 |     }
38 | }
39 | 
40 | @Preview(showBackground = true)
41 | @Composable
42 | fun DefaultPreview() {
43 |     MadeWithComposeTheme {
44 |         WeightEntryDemo()
45 |     }
46 | }


--------------------------------------------------------------------------------
/videoplayer/src/main/java/com/halilibo/videoplayer/ProgressIndicator.kt:
--------------------------------------------------------------------------------
 1 | package com.halilibo.videoplayer
 2 | 
 3 | import androidx.compose.foundation.background
 4 | import androidx.compose.foundation.layout.height
 5 | import androidx.compose.foundation.layout.width
 6 | import androidx.compose.runtime.Composable
 7 | import androidx.compose.runtime.getValue
 8 | import androidx.compose.ui.Modifier
 9 | import androidx.compose.ui.graphics.Color
10 | import androidx.compose.ui.unit.dp
11 | 
12 | 
13 | @Composable
14 | fun ProgressIndicator(
15 |     modifier: Modifier = Modifier
16 | ) {
17 |     val controller = LocalVideoPlayerController.current
18 |     val videoPlayerUiState by controller.collect()
19 | 
20 |     with(videoPlayerUiState) {
21 |         SeekBar(
22 |             progress = currentPosition,
23 |             max = duration,
24 |             enabled = controlsVisible && controlsEnabled,
25 |             onSeek = {
26 |                 controller.previewSeekTo(it)
27 |             },
28 |             onSeekStopped = {
29 |                 controller.seekTo(it)
30 |             },
31 |             secondaryProgress = secondaryProgress,
32 |             seekerPopup = {
33 |                 PlayerSurface(
34 |                     modifier = Modifier
35 |                         .height(48.dp)
36 |                         .width(48.dp * videoSize.width / videoSize.height)
37 |                         .background(Color.DarkGray)
38 |                 ) {
39 |                     controller.previewPlayerViewAvailable(it)
40 |                 }
41 |             },
42 |             modifier = modifier
43 |         )
44 |     }
45 | }


--------------------------------------------------------------------------------
/app/src/main/res/drawable/ic_header.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <vector android:height="24dp" android:viewportHeight="31.29"
3 |     android:viewportWidth="31.29" android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
4 |     <path android:fillColor="#FF000000" android:pathData="M18.585,31.226v-1.833h0.577c0.497,0 0.961,-0.036 1.395,-0.105c0.436,-0.072 0.812,-0.219 1.131,-0.438s0.576,-0.537 0.769,-0.948c0.192,-0.412 0.287,-0.959 0.287,-1.643V16.03H8.547v10.229c0,0.683 0.095,1.229 0.287,1.644c0.192,0.41 0.448,0.729 0.768,0.947c0.32,0.221 0.699,0.365 1.14,0.438c0.442,0.07 0.902,0.106 1.386,0.106h0.577v1.833H0v-1.833h0.555c0.497,0 0.961,-0.036 1.396,-0.106c0.434,-0.071 0.813,-0.217 1.141,-0.438c0.326,-0.221 0.582,-0.537 0.769,-0.947c0.184,-0.412 0.275,-0.961 0.275,-1.644v-21.4c0,-0.639 -0.096,-1.153 -0.287,-1.545c-0.194,-0.392 -0.454,-0.693 -0.78,-0.906C2.742,2.195 2.363,2.056 1.927,1.992c-0.431,-0.065 -0.89,-0.096 -1.373,-0.096H0V0.063h12.705v1.833h-0.577c-0.483,0 -0.943,0.035 -1.386,0.107c-0.44,0.07 -0.819,0.217 -1.14,0.437C9.283,2.66 9.027,2.976 8.834,3.389C8.642,3.8 8.547,4.348 8.547,5.03v8.823h14.195V5.03c0,-0.683 -0.096,-1.23 -0.287,-1.642s-0.448,-0.729 -0.768,-0.948c-0.32,-0.22 -0.696,-0.366 -1.131,-0.437c-0.435,-0.072 -0.897,-0.107 -1.396,-0.107h-0.577V0.063h12.705v1.833h-0.553c-0.498,0 -0.961,0.035 -1.396,0.107c-0.434,0.07 -0.812,0.217 -1.141,0.437c-0.326,0.22 -0.582,0.536 -0.768,0.948c-0.186,0.411 -0.277,0.959 -0.277,1.642v21.442c0,0.64 0.097,1.155 0.287,1.545c0.192,0.392 0.453,0.687 0.779,0.884c0.326,0.2 0.705,0.331 1.141,0.396c0.434,0.064 0.892,0.096 1.373,0.096h0.556v1.833H18.585z"/>
5 | </vector>
6 | 


--------------------------------------------------------------------------------
/app/src/main/java/com/halilibo/madewithcompose/ui/theme/Theme.kt:
--------------------------------------------------------------------------------
 1 | package com.halilibo.madewithcompose.ui.theme
 2 | 
 3 | import androidx.compose.foundation.isSystemInDarkTheme
 4 | import androidx.compose.material.MaterialTheme
 5 | import androidx.compose.material.darkColors
 6 | import androidx.compose.material.lightColors
 7 | import androidx.compose.runtime.Composable
 8 | import androidx.compose.runtime.CompositionLocalProvider
 9 | import androidx.compose.runtime.remember
10 | import com.halilibo.colors.*
11 | 
12 | private val DarkColorPalette = darkColors(
13 |     primary = B400,
14 |     primaryVariant = B400,
15 |     secondary = N800,
16 |     background = DN20,
17 |     surface = DN40,
18 |     onPrimary = N20,
19 |     onSecondary = N0,
20 |     onBackground = DN800,
21 | )
22 | 
23 | private val LightColorPalette = lightColors(
24 |     primary = B400,
25 |     primaryVariant = B400,
26 |     secondary = N800,
27 |     background = N30,
28 |     surface = N0,
29 |     onPrimary = N20,
30 |     onSecondary = N0,
31 |     onBackground = N800,
32 | )
33 | 
34 | 
35 | @Composable
36 | fun MadeWithComposeTheme(
37 |     content: @Composable () -> Unit
38 | ) {
39 |     val isDarkMode = isSystemInDarkTheme()
40 |     val nightMode = remember { NightMode(isDarkMode) }
41 | 
42 |     val colors = if (nightMode.isNight) {
43 |         DarkColorPalette
44 |     } else {
45 |         LightColorPalette
46 |     }
47 | 
48 |     CompositionLocalProvider(LocalNightMode provides nightMode) {
49 |         MaterialTheme(
50 |             colors = colors,
51 |             typography = Typography,
52 |             shapes = Shapes,
53 |             content = content
54 |         )
55 |     }
56 | }


--------------------------------------------------------------------------------
/app/src/main/res/drawable-v24/ic_launcher_foreground.xml:
--------------------------------------------------------------------------------
 1 | <vector xmlns:android="http://schemas.android.com/apk/res/android"
 2 |     xmlns:aapt="http://schemas.android.com/aapt"
 3 |     android:width="108dp"
 4 |     android:height="108dp"
 5 |     android:viewportWidth="108"
 6 |     android:viewportHeight="108">
 7 |     <path android:pathData="M31,63.928c0,0 6.4,-11 12.1,-13.1c7.2,-2.6 26,-1.4 26,-1.4l38.1,38.1L107,108.928l-32,-1L31,63.928z">
 8 |         <aapt:attr name="android:fillColor">
 9 |             <gradient
10 |                 android:endX="85.84757"
11 |                 android:endY="92.4963"
12 |                 android:startX="42.9492"
13 |                 android:startY="49.59793"
14 |                 android:type="linear">
15 |                 <item
16 |                     android:color="#44000000"
17 |                     android:offset="0.0" />
18 |                 <item
19 |                     android:color="#00000000"
20 |                     android:offset="1.0" />
21 |             </gradient>
22 |         </aapt:attr>
23 |     </path>
24 |     <path
25 |         android:fillColor="#FFFFFF"
26 |         android:fillType="nonZero"
27 |         android:pathData="M65.3,45.828l3.8,-6.6c0.2,-0.4 0.1,-0.9 -0.3,-1.1c-0.4,-0.2 -0.9,-0.1 -1.1,0.3l-3.9,6.7c-6.3,-2.8 -13.4,-2.8 -19.7,0l-3.9,-6.7c-0.2,-0.4 -0.7,-0.5 -1.1,-0.3C38.8,38.328 38.7,38.828 38.9,39.228l3.8,6.6C36.2,49.428 31.7,56.028 31,63.928h46C76.3,56.028 71.8,49.428 65.3,45.828zM43.4,57.328c-0.8,0 -1.5,-0.5 -1.8,-1.2c-0.3,-0.7 -0.1,-1.5 0.4,-2.1c0.5,-0.5 1.4,-0.7 2.1,-0.4c0.7,0.3 1.2,1 1.2,1.8C45.3,56.528 44.5,57.328 43.4,57.328L43.4,57.328zM64.6,57.328c-0.8,0 -1.5,-0.5 -1.8,-1.2s-0.1,-1.5 0.4,-2.1c0.5,-0.5 1.4,-0.7 2.1,-0.4c0.7,0.3 1.2,1 1.2,1.8C66.5,56.528 65.6,57.328 64.6,57.328L64.6,57.328z"
28 |         android:strokeWidth="1"
29 |         android:strokeColor="#00000000" />
30 | </vector>


--------------------------------------------------------------------------------
/app/src/main/AndroidManifest.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <manifest xmlns:android="http://schemas.android.com/apk/res/android">
 3 | 
 4 |     <uses-permission android:name="android.permission.INTERNET" />
 5 | 
 6 |     <application
 7 |         android:allowBackup="true"
 8 |         android:icon="@mipmap/ic_launcher"
 9 |         android:label="@string/app_name"
10 |         android:roundIcon="@mipmap/ic_launcher_round"
11 |         android:supportsRtl="true"
12 |         android:theme="@style/Theme.MadeWithCompose"
13 |         android:usesCleartextTraffic="true">
14 |         <activity
15 |             android:name="com.halilibo.madewithcompose.MainActivity"
16 |             android:exported="true"
17 |             android:supportsPictureInPicture="true"
18 |             android:configChanges="colorMode|density|fontScale|keyboard|keyboardHidden|layoutDirection|locale|mcc|mnc|navigation|orientation|screenLayout|screenSize|smallestScreenSize|touchscreen|uiMode"
19 |             android:launchMode="singleTask"
20 |             android:resizeableActivity="true"
21 |             android:theme="@style/Theme.MadeWithCompose.NoActionBar">
22 |             <intent-filter>
23 |                 <action android:name="android.intent.action.MAIN" />
24 | 
25 |                 <category android:name="android.intent.category.LAUNCHER" />
26 |             </intent-filter>
27 |         </activity>
28 | 
29 |         <provider
30 |             android:name="androidx.core.content.FileProvider"
31 |             android:authorities="com.halilibo.fileprovider"
32 |             android:exported="false"
33 |             android:grantUriPermissions="true">
34 |             <meta-data
35 |                 android:name="android.support.FILE_PROVIDER_PATHS"
36 |                 android:resource="@xml/file_paths" />
37 |         </provider>
38 |     </application>
39 | 
40 | </manifest>


--------------------------------------------------------------------------------
/dotsandlines/src/main/java/com/halilibo/dotsandlines/DotsAndLinesState.kt:
--------------------------------------------------------------------------------
 1 | package com.halilibo.dotsandlines
 2 | 
 3 | import android.os.Parcelable
 4 | import androidx.compose.ui.unit.IntSize
 5 | import com.halilibo.dotsandlines.Dot.Companion.next
 6 | import kotlinx.parcelize.Parcelize
 7 | import kotlin.math.roundToInt
 8 | 
 9 | data class DotsAndLinesState(
10 |     val dots: List<Dot> = emptyList(),
11 |     val pointer: Dot? = null,
12 |     val dotRadius: Float,
13 |     val size: IntSize = IntSize.Zero,
14 |     val speed: Float
15 | ) {
16 | 
17 |     companion object {
18 |         // TODO(halilozercan): A real size changed algorithm instead of resetting everything
19 |         fun DotsAndLinesState.sizeChanged(
20 |             size: IntSize,
21 |             populationFactor: Float
22 |         ) : DotsAndLinesState {
23 |             if (size == this.size) return this
24 |             return copy(
25 |                 dots = (0..size.realPopulation(populationFactor)).map {
26 |                     Dot.create(size)
27 |                 },
28 |                 size = size
29 |             )
30 |         }
31 | 
32 |         fun DotsAndLinesState.next(durationMillis: Long): DotsAndLinesState {
33 |             return copy(
34 |                 dots = dots.map {
35 |                     it.next(size, durationMillis, dotRadius, speed)
36 |                 }
37 |             )
38 |         }
39 | 
40 |         fun DotsAndLinesState.populationControl(populationFactor: Float): DotsAndLinesState {
41 |             val count = size.realPopulation(populationFactor = populationFactor)
42 | 
43 |             return if(count < dots.size) {
44 |                 copy(dots = dots.shuffled().take(count))
45 |             } else {
46 |                 copy(dots = dots + (0..count-dots.size).map { Dot.create(size) })
47 |             }
48 |         }
49 | 
50 |         private fun IntSize.realPopulation(populationFactor: Float): Int {
51 |             return (width * height / 10_000 * populationFactor).roundToInt()
52 |         }
53 |     }
54 | }


--------------------------------------------------------------------------------
/app/src/main/java/com/halilibo/madewithcompose/videoplayer/VideoListPage.kt:
--------------------------------------------------------------------------------
 1 | package com.halilibo.madewithcompose.videoplayer
 2 | 
 3 | import androidx.compose.foundation.Image
 4 | import androidx.compose.foundation.clickable
 5 | import androidx.compose.foundation.layout.*
 6 | import androidx.compose.foundation.lazy.LazyColumn
 7 | import androidx.compose.foundation.lazy.items
 8 | import androidx.compose.material.Text
 9 | import androidx.compose.runtime.Composable
10 | import androidx.compose.ui.Alignment
11 | import androidx.compose.ui.Modifier
12 | import androidx.compose.ui.unit.dp
13 | import androidx.compose.ui.unit.sp
14 | import coil.compose.LocalImageLoader
15 | import coil.compose.rememberImagePainter
16 | 
17 | @Composable
18 | fun VideoListPage(
19 |     onVideoSelected: (Video) -> Unit,
20 |     modifier: Modifier = Modifier,
21 |     contentPadding: PaddingValues = PaddingValues(),
22 | ) {
23 |     val videoList = getVideoList()
24 | 
25 |     LazyColumn(
26 |         modifier = modifier.fillMaxHeight(),
27 |         contentPadding = contentPadding
28 |     ) {
29 |         items(videoList) { video ->
30 |             Row(
31 |                 verticalAlignment = Alignment.CenterVertically,
32 |                 modifier = Modifier
33 |                     .fillMaxWidth()
34 |                     .clickable {
35 |                         onVideoSelected(video)
36 |                     }
37 |                     .padding(horizontal = 16.dp, vertical = 8.dp)
38 |             ) {
39 |                 Image(
40 |                     painter = rememberImagePainter(
41 |                         data = video.thumb,
42 |                         imageLoader = LocalImageLoader.current
43 |                     ),
44 |                     contentDescription = video.title,
45 |                     modifier = Modifier.size(64.dp)
46 |                 )
47 | 
48 |                 Spacer(modifier = Modifier.width(16.dp))
49 | 
50 |                 Text(
51 |                     video.title,
52 |                     fontSize = 20.sp
53 |                 )
54 |             }
55 | 
56 |             Spacer(modifier = Modifier.height(8.dp))
57 |         }
58 |     }
59 | }


--------------------------------------------------------------------------------
/app/src/main/java/com/halilibo/madewithcompose/markdowneditor/TextFieldMutators.kt:
--------------------------------------------------------------------------------
 1 | @file:OptIn(ExperimentalFoundationApi::class)
 2 | 
 3 | package com.halilibo.madewithcompose.markdowneditor
 4 | 
 5 | import androidx.compose.foundation.ExperimentalFoundationApi
 6 | import androidx.compose.foundation.text2.input.TextFieldBuffer
 7 | import androidx.compose.ui.text.TextRange
 8 | 
 9 | fun TextFieldBuffer.inlineWrap(
10 |   startWrappedString: String,
11 |   endWrappedString: String = startWrappedString
12 | ) {
13 |   val initialSelection = selectionInChars
14 |   replace(initialSelection.min, initialSelection.min, startWrappedString)
15 |   replace(
16 |     initialSelection.max + startWrappedString.length,
17 |     initialSelection.max + startWrappedString.length,
18 |     endWrappedString
19 |   )
20 |   selectCharsIn(
21 |     TextRange(
22 |       initialSelection.min,
23 |       initialSelection.max + startWrappedString.length + endWrappedString.length
24 |     )
25 |   )
26 | }
27 | 
28 | fun TextFieldBuffer.bold() = inlineWrap("**")
29 | 
30 | fun TextFieldBuffer.italic() = inlineWrap("_")
31 | 
32 | fun TextFieldBuffer.inlineCode() = inlineWrap("`")
33 | 
34 | fun TextFieldBuffer.strikeThrough() = inlineWrap("~~")
35 | 
36 | fun TextFieldBuffer.header() {
37 |   val text = toString()
38 |   val lineStart = text.take(selectionInChars.min)
39 |     .lastIndexOf('\n')
40 |     .takeIf { it != -1 }
41 |     ?.let { it + 1 }
42 |     ?: 0
43 | 
44 |   val appendedString = if (text[lineStart] == '#') "#" else "# "
45 | 
46 |   val initialSelection = selectionInChars
47 | 
48 |   replace(lineStart, lineStart, appendedString)
49 |   selectCharsIn(
50 |     TextRange(
51 |       initialSelection.min + appendedString.length,
52 |       initialSelection.max + appendedString.length
53 |     )
54 |   )
55 | }
56 | 
57 | fun TextFieldBuffer.quote() {
58 |   val text = toString()
59 |   val lineStart = text.take(selectionInChars.min)
60 |     .lastIndexOf('\n')
61 |     .takeIf { it != -1 }
62 |     ?.let { it + 1 }
63 |     ?: 0
64 | 
65 |   val initialSelection = selectionInChars
66 | 
67 |   replace(lineStart, lineStart, "> ")
68 |   selectCharsIn(
69 |     TextRange(
70 |       initialSelection.min + 2,
71 |       initialSelection.max + 2
72 |     )
73 |   )
74 | }


--------------------------------------------------------------------------------
/app/src/main/java/com/halilibo/madewithcompose/brush/LightingTextDemoState.kt:
--------------------------------------------------------------------------------
 1 | package com.halilibo.madewithcompose.brush
 2 | 
 3 | import androidx.compose.animation.core.Animatable
 4 | import androidx.compose.animation.core.Spring
 5 | import androidx.compose.animation.core.VectorConverter
 6 | import androidx.compose.animation.core.spring
 7 | import androidx.compose.foundation.ScrollState
 8 | import androidx.compose.runtime.derivedStateOf
 9 | import androidx.compose.runtime.getValue
10 | import androidx.compose.runtime.mutableStateOf
11 | import androidx.compose.runtime.setValue
12 | import androidx.compose.ui.geometry.Offset
13 | import androidx.compose.ui.geometry.Size
14 | import androidx.compose.ui.graphics.*
15 | import androidx.compose.ui.input.pointer.PointerInputChange
16 | 
17 | private val BULB_START_X = 0.5f
18 | private val BULB_START_Y = 0.1f
19 | 
20 | class LightingTextDemoState(private val size: Size) {
21 |   var isLightOn by mutableStateOf(true)
22 | 
23 |   fun toggleLight() {
24 |     isLightOn = !isLightOn
25 |   }
26 | 
27 |   // bulb dragging animatable
28 |   val dragAnimatable = Animatable(Offset(0f, 0f), Offset.VectorConverter)
29 | 
30 |   // text scroll
31 |   val scrollState = ScrollState(0)
32 | 
33 |   private val scrollOffset by derivedStateOf {
34 |     Offset(0f, scrollState.value.toFloat())
35 |   }
36 | 
37 |   val bulbOffset by derivedStateOf {
38 |     dragAnimatable.value.exactPositionIn()
39 |   }
40 | 
41 |   suspend fun onDragEnd() {
42 |     dragAnimatable.animateTo(
43 |       Offset.Zero,
44 |       spring(Spring.DampingRatioLowBouncy, Spring.StiffnessLow)
45 |     )
46 |   }
47 | 
48 |   suspend fun onDrag(change: PointerInputChange, dragAmount: Offset) {
49 |     change.consume()
50 |     dragAnimatable.snapTo(dragAnimatable.value + dragAmount)
51 |   }
52 | 
53 |   val bulbBackground by derivedStateOf {
54 |     if (isLightOn) {
55 |       Brush.radialGradient(listOf(Color.Yellow, Color(0xff85733a)))
56 |     } else {
57 |       SolidColor(Color.Gray)
58 |     }
59 |   }
60 | 
61 |   val lightSourceBrush by derivedStateOf {
62 |     if (isLightOn) {
63 |       Brush.radialGradient(
64 |         center = bulbOffset + scrollOffset,
65 |         radius = size.minDimension,
66 |         colors = listOf(Color.Yellow, Color(0xff85733a), Color.DarkGray)
67 |       )
68 |     } else {
69 |       SolidColor(Color.DarkGray)
70 |     }
71 |   }
72 | 
73 |   private fun Offset.exactPositionIn(): Offset {
74 |     return this + Offset(size.width * BULB_START_X, size.height * BULB_START_Y)
75 |   }
76 | }


--------------------------------------------------------------------------------
/gradlew.bat:
--------------------------------------------------------------------------------
 1 | @if "%DEBUG%" == "" @echo off
 2 | @rem ##########################################################################
 3 | @rem
 4 | @rem  Gradle startup script for Windows
 5 | @rem
 6 | @rem ##########################################################################
 7 | 
 8 | @rem Set local scope for the variables with windows NT shell
 9 | if "%OS%"=="Windows_NT" setlocal
10 | 
11 | set DIRNAME=%~dp0
12 | if "%DIRNAME%" == "" set DIRNAME=.
13 | set APP_BASE_NAME=%~n0
14 | set APP_HOME=%DIRNAME%
15 | 
16 | @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
17 | set DEFAULT_JVM_OPTS=
18 | 
19 | @rem Find java.exe
20 | if defined JAVA_HOME goto findJavaFromJavaHome
21 | 
22 | set JAVA_EXE=java.exe
23 | %JAVA_EXE% -version >NUL 2>&1
24 | if "%ERRORLEVEL%" == "0" goto init
25 | 
26 | echo.
27 | echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
28 | echo.
29 | echo Please set the JAVA_HOME variable in your environment to match the
30 | echo location of your Java installation.
31 | 
32 | goto fail
33 | 
34 | :findJavaFromJavaHome
35 | set JAVA_HOME=%JAVA_HOME:"=%
36 | set JAVA_EXE=%JAVA_HOME%/bin/java.exe
37 | 
38 | if exist "%JAVA_EXE%" goto init
39 | 
40 | echo.
41 | echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
42 | echo.
43 | echo Please set the JAVA_HOME variable in your environment to match the
44 | echo location of your Java installation.
45 | 
46 | goto fail
47 | 
48 | :init
49 | @rem Get command-line arguments, handling Windows variants
50 | 
51 | if not "%OS%" == "Windows_NT" goto win9xME_args
52 | 
53 | :win9xME_args
54 | @rem Slurp the command line arguments.
55 | set CMD_LINE_ARGS=
56 | set _SKIP=2
57 | 
58 | :win9xME_args_slurp
59 | if "x%~1" == "x" goto execute
60 | 
61 | set CMD_LINE_ARGS=%*
62 | 
63 | :execute
64 | @rem Setup the command line
65 | 
66 | set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
67 | 
68 | @rem Execute Gradle
69 | "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
70 | 
71 | :end
72 | @rem End local scope for the variables with windows NT shell
73 | if "%ERRORLEVEL%"=="0" goto mainEnd
74 | 
75 | :fail
76 | rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
77 | rem the _cmd.exe /c_ return code!
78 | if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
79 | exit /b 1
80 | 
81 | :mainEnd
82 | if "%OS%"=="Windows_NT" endlocal
83 | 
84 | :omega
85 | 


--------------------------------------------------------------------------------
/app/src/main/java/com/halilibo/madewithcompose/DemoEntry.kt:
--------------------------------------------------------------------------------
 1 | package com.halilibo.madewithcompose
 2 | 
 3 | import androidx.compose.runtime.Composable
 4 | import com.halilibo.madewithcompose.brush.BrushDemo
 5 | import com.halilibo.madewithcompose.calendar.CalendarDemo
 6 | import com.halilibo.madewithcompose.circlesonlines.CirclesOnLinesDemo
 7 | import com.halilibo.madewithcompose.dotsandlines.DotsAndLinesDemo
 8 | import com.halilibo.madewithcompose.textonpath.DrawTextOnPathDemo
 9 | import com.halilibo.madewithcompose.schedulecalendar.ScheduleCalendarDemo
10 | import com.halilibo.madewithcompose.videoplayer.VideoPlayerDemo
11 | import com.halilibo.madewithcompose.weightentry.WeightEntryDemo
12 | import com.halilibo.madewithcompose.markdowneditor.MarkdownEditorDemo
13 | import com.halilibo.madewithcompose.pip.PictureInPictureDemo
14 | import com.halilibo.madewithcompose.varimoji.VarimojiDemo
15 | 
16 | enum class DemoEntry(
17 |     val title: String,
18 |     val destination: String,
19 |     val composable: @Composable () -> Unit
20 | ) {
21 |     ScheduleCalendar(
22 |         "Schedule Calendar",
23 |         "schedulecalendar",
24 |         @Composable {
25 |             ScheduleCalendarDemo()
26 |         }
27 |     ),
28 |     VideoPlayer(
29 |         "Video Player",
30 |         "videoplayer",
31 |         @Composable {
32 |             VideoPlayerDemo()
33 |         }
34 |     ),
35 |     DotsAndLines(
36 |         "Dots and Lines",
37 |         "dotsandlines",
38 |         @Composable {
39 |             DotsAndLinesDemo()
40 |         }
41 |     ),
42 |     Calendar(
43 |         "Calendar",
44 |         "calendar",
45 |         @Composable {
46 |             CalendarDemo()
47 |         }
48 |     ),
49 |     CirclesOnLines(
50 |         "Circles on Lines",
51 |         "circlesonlines",
52 |         @Composable {
53 |             CirclesOnLinesDemo()
54 |         }
55 |     ),
56 |     WeightEntry(
57 |         "Weight Entry",
58 |         "weightentry",
59 |         @Composable {
60 |             WeightEntryDemo()
61 |         }
62 |     ),
63 |     MarkdownEditor(
64 |         "Markdown Editor",
65 |         "markdowneditor",
66 |         @Composable {
67 |             MarkdownEditorDemo()
68 |         }
69 |     ),
70 |     PictureInPicture(
71 |         "Picture in Picture",
72 |         "pictureinpicture",
73 |         @Composable {
74 |             PictureInPictureDemo()
75 |         }
76 |     ),
77 |     TextLighting(
78 |         "Text Lighting",
79 |         "textlighting",
80 |         @Composable {
81 |             BrushDemo()
82 |         }
83 |     ),
84 |     DrawTextOnPath(
85 |         "Draw text on Path",
86 |         "textonpath",
87 |         @Composable {
88 |             DrawTextOnPathDemo()
89 |         }
90 |     ),
91 |     Varimoji(
92 |         "Varimoji",
93 |         "varimoji",
94 |         @Composable {
95 |             VarimojiDemo()
96 |         }
97 |     )
98 | }
99 | 


--------------------------------------------------------------------------------
/videoplayer/src/main/java/com/halilibo/videoplayer/VideoPlayer.kt:
--------------------------------------------------------------------------------
 1 | package com.halilibo.videoplayer
 2 | 
 3 | import androidx.compose.foundation.background
 4 | import androidx.compose.foundation.layout.Box
 5 | import androidx.compose.foundation.layout.aspectRatio
 6 | import androidx.compose.foundation.layout.fillMaxWidth
 7 | import androidx.compose.material.LocalContentColor
 8 | import androidx.compose.runtime.*
 9 | import androidx.compose.runtime.saveable.rememberSaveable
10 | import androidx.compose.ui.Alignment
11 | import androidx.compose.ui.Modifier
12 | import androidx.compose.ui.graphics.Color
13 | import androidx.compose.ui.platform.LocalContext
14 | 
15 | internal val LocalVideoPlayerController =
16 |     compositionLocalOf<DefaultVideoPlayerController> { error("VideoPlayerController is not initialized") }
17 | 
18 | @Composable
19 | fun rememberVideoPlayerController(
20 |     source: VideoPlayerSource? = null
21 | ): VideoPlayerController {
22 |     val context = LocalContext.current
23 | 
24 |     return rememberSaveable(
25 |         context,
26 |         saver = DefaultVideoPlayerController.saver(context),
27 |         init = {
28 |             DefaultVideoPlayerController(
29 |                 context = context,
30 |                 initialState = VideoPlayerState()
31 |             ).apply {
32 |                 source?.let { setSource(it) }
33 |             }
34 |         }
35 |     )
36 | }
37 | 
38 | @OptIn(ExperimentalUnsignedTypes::class)
39 | @Composable
40 | fun VideoPlayer(
41 |     videoPlayerController: VideoPlayerController,
42 |     modifier: Modifier = Modifier,
43 |     controlsEnabled: Boolean = true,
44 |     gesturesEnabled: Boolean = true,
45 |     backgroundColor: Color = Color.Black
46 | ) {
47 |     require(videoPlayerController is DefaultVideoPlayerController) {
48 |         "Use [rememberVideoPlayerController] to create an instance of [VideoPlayerController]"
49 |     }
50 | 
51 |     SideEffect {
52 |         videoPlayerController.videoPlayerBackgroundColor = backgroundColor.value.toInt()
53 |         videoPlayerController.enableControls(controlsEnabled)
54 |         videoPlayerController.enableGestures(gesturesEnabled)
55 |     }
56 | 
57 |     CompositionLocalProvider(
58 |         LocalContentColor provides Color.White,
59 |         LocalVideoPlayerController provides videoPlayerController
60 |     ) {
61 |         val aspectRatio by videoPlayerController.collect { videoSize.width / videoSize.height }
62 | 
63 |         Box(
64 |             modifier = Modifier
65 |                 .background(color = backgroundColor)
66 |                 .aspectRatio(aspectRatio)
67 |                 .then(modifier)
68 |         ) {
69 |             PlayerSurface {
70 |                 videoPlayerController.playerViewAvailable(it)
71 |             }
72 | 
73 |             MediaControlGestures(modifier = Modifier.matchParentSize())
74 |             MediaControlButtons(modifier = Modifier.matchParentSize())
75 |             ProgressIndicator(
76 |                 modifier = Modifier
77 |                     .fillMaxWidth()
78 |                     .align(Alignment.BottomCenter)
79 |             )
80 |         }
81 |     }
82 | }


--------------------------------------------------------------------------------
/app/build.gradle.kts:
--------------------------------------------------------------------------------
 1 | plugins {
 2 |   id("com.android.application")
 3 |   id("kotlin-android")
 4 |   id("kotlin-parcelize")
 5 | }
 6 | 
 7 | android {
 8 |   compileSdk = 34
 9 |   buildToolsVersion = "33.0.1"
10 |   namespace = "com.halilibo.madewithcompose"
11 | 
12 |   defaultConfig {
13 |     applicationId = "com.halilibo.madewithcompose"
14 |     minSdk = 26
15 |     targetSdk = 34
16 |     versionCode = 1
17 |     versionName = "1.0"
18 | 
19 |     testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
20 |     vectorDrawables {
21 |       useSupportLibrary = true
22 |     }
23 |   }
24 | 
25 |   buildTypes {
26 |     release {
27 |       isMinifyEnabled = false
28 |       proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro")
29 |     }
30 |   }
31 |   compileOptions {
32 |     sourceCompatibility = JavaVersion.VERSION_11
33 |     targetCompatibility = JavaVersion.VERSION_11
34 |   }
35 |   kotlinOptions {
36 |     jvmTarget = "11"
37 |   }
38 |   buildFeatures {
39 |     compose = true
40 |   }
41 |   composeOptions {
42 |     kotlinCompilerExtensionVersion = Compose.compilerVersion
43 |   }
44 |   packaging {
45 |     resources.excludes.add("META-INF/DEPENDENCIES")
46 |     resources.excludes.add("META-INF/LICENSE")
47 |     resources.excludes.add("META-INF/LICENSE.txt")
48 |     resources.excludes.add("META-INF/license.txt")
49 |     resources.excludes.add("META-INF/NOTICE")
50 |     resources.excludes.add("META-INF/NOTICE.txt")
51 |     resources.excludes.add("META-INF/notice.txt")
52 |     resources.excludes.add("META-INF/ASL2.0")
53 |     resources.excludes.add("META-INF/*.kotlin_module")
54 |   }
55 | }
56 | 
57 | configurations.all {
58 |   resolutionStrategy.eachDependency {
59 |     if (requested.group.contains("org.jetbrains.compose")) {
60 |       val groupName = requested.group.replace("org.jetbrains.compose", "androidx.compose")
61 |       useTarget("$groupName:${requested.name}:${Compose.version}")
62 |     }
63 |   }
64 | }
65 | 
66 | dependencies {
67 |   implementation(project(":videoplayer"))
68 |   implementation(project(":schedulecalendar"))
69 |   implementation(project(":dotsandlines"))
70 |   implementation(project(":calendar"))
71 |   implementation(project(":weightentry"))
72 |   implementation(project(":screenshot"))
73 |   implementation(project(":colors"))
74 | 
75 |   implementation("com.google.android.material:material:1.9.0")
76 | 
77 |   implementation(Compose.ui)
78 |   implementation(Compose.material)
79 |   implementation(Compose.uiTooling)
80 |   implementation(Compose.iconsExtended)
81 |   implementation(Compose.activity)
82 |   implementation(Compose.animation)
83 |   implementation(Compose.navigation)
84 |   implementation(Compose.uiUtil)
85 | 
86 |   implementation(Libraries.coil)
87 |   implementation(Libraries.media)
88 | 
89 |   implementation(RichText.material)
90 |   implementation(RichText.markdown)
91 |   implementation(RichText.printing)
92 | 
93 |   implementation("com.google.code.gson:gson:2.9.1")
94 |   implementation("androidx.lifecycle:lifecycle-common-java8:2.6.2")
95 |   testImplementation("junit:junit:4.13.2")
96 |   androidTestImplementation("androidx.test.ext:junit:1.1.5")
97 |   androidTestImplementation("androidx.test.espresso:espresso-core:3.5.1")
98 |   androidTestImplementation(Compose.testing)
99 | }


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Made with Compose
 2 | 
 3 | Cool demos I've made with Compose that are somewhat worthy of sharing. 
 4 | 
 5 | [![Twitter URL](https://img.shields.io/twitter/url/https/twitter.com/halilozercan.svg?style=social&label=Follow%20%40halilozercan)](https://twitter.com/halilozercan)
 6 | 
 7 | # Video Player
 8 | 
 9 | [This is a Youtube like Video Player App that is completely written in #JetpackCompose using good old #ExoPlayer. IMO, It nicely demonstrates the smooth interoperability with the existing Android Views.](https://twitter.com/halilozercan/status/1372635576416006146)
10 | 
11 | # Dots And Lines
12 | 
13 | [Made this animation as a background modifier in #JetpackCompose a while ago. So fun to just watch the dots travel, bond connections again and again. The responsiveness of canvas to configuration options is outstanding. Great work by the compose team](https://twitter.com/halilozercan/status/1371197797400207368)
14 | 
15 | # Schedule Calendar
16 | 
17 | [Made this on-call schedule calendar with #JetpackCompose. RecyclerView & PageSnapHelper & Decorators & Multiple hacks for ripple & Text Drawing with more hacks VS one swipeable boi](https://twitter.com/halilozercan/status/1395862026073817089)
18 | 
19 | # Calendar
20 | 
21 | [Implemented this calendar under 200 LoC using #JetpackCompose for Desktop (copy&paste for Android support 🙃). It wasn't so long ago that we had to use a 3rd party library to have this kind of functionality in our app.](https://twitter.com/halilozercan/status/1382432402325262338)
22 | 
23 | # Circles On Lines
24 | 
25 | [I knew I had to try this out as soon as I saw it on Reddit. Although I couldn't get the math exactly right, it still looks fine.](https://twitter.com/halilozercan/status/1400202985335148550)
26 | 
27 | # Weight Entry
28 | 
29 | [My last experiment with #JetpackCompose, a weight entry view. No LazyRow or anything. Just a simple Animatable float and draggable modifiers.](https://twitter.com/halilozercan/status/1408437121858392064)
30 | 
31 | # Markdown Editor
32 | [For this project, I wrote the first line of code around a year ago to have a composable Markdown renderer. Then, I completely forgot about why I even implemented the renderer Smiling face with open mouth and cold sweat This is a resurrection of my very old project Hugetwit (from 140 era)](https://twitter.com/halilozercan/status/1424352149664935936)
33 | 
34 | # Picture-in-Picture
35 | 
36 | [Picture in Picture is one of those niche features that don't get much love but it's super important for video players. I tried running it using #JetpackCompose. It was ofc very trivial to update the UI Grinning face with smiling eyes](https://twitter.com/halilozercan/status/1446982300311375877)
37 | 
38 | # Text Lighting
39 | 
40 | [This demo](https://twitter.com/halilozercan/status/1546563464025481216) was inspired by [light.cretu.dev](https://light.cretu.dev/). Using Experimental Brush API for TextStyle, we are able to shine a light of radial gradient on a background text composable.
41 | 
42 | # Drawing text on a Path
43 | 
44 | [Making the waves with Jetpack Compose](https://twitter.com/halilozercan/status/1555736000910983169)
45 | 
46 | # Variable Fonts
47 | 
48 | [Variable fonts can be very awe-inspiring. Just by controlling two axes of Font loading via `FontVariation.Settings`, we can create an emoji face with a unique emotion.](https://twitter.com/halilozercan/status/1704607217708650793)
49 | 
50 | All the credit goes to [crt-mate](https://crt-mate.github.io/varimoji/)


--------------------------------------------------------------------------------
/app/src/main/java/com/halilibo/madewithcompose/schedulecalendar/ScheduleCalendarDemo.kt:
--------------------------------------------------------------------------------
 1 | package com.halilibo.madewithcompose.schedulecalendar
 2 | 
 3 | import androidx.compose.foundation.layout.*
 4 | import androidx.compose.material.Icon
 5 | import androidx.compose.material.IconButton
 6 | import androidx.compose.material.icons.Icons
 7 | import androidx.compose.material.icons.filled.HideImage
 8 | import androidx.compose.material.icons.filled.ZoomIn
 9 | import androidx.compose.material.icons.filled.ZoomOut
10 | import androidx.compose.runtime.Composable
11 | import androidx.compose.runtime.mutableStateOf
12 | import androidx.compose.runtime.remember
13 | import androidx.compose.ui.Modifier
14 | import androidx.compose.ui.tooling.preview.Preview
15 | import androidx.compose.ui.unit.dp
16 | import com.halilibo.colors.*
17 | import com.halilibo.madewithcompose.ui.theme.MadeWithComposeTheme
18 | import com.halilibo.schedulecalendar.CalendarEvent
19 | import com.halilibo.schedulecalendar.CalendarSection
20 | import com.halilibo.schedulecalendar.ScheduleCalendar
21 | import com.halilibo.schedulecalendar.rememberScheduleCalendarState
22 | import java.time.LocalDateTime
23 | import kotlin.random.Random
24 | 
25 | @Composable
26 | fun ScheduleCalendarDemo() {
27 |   val viewSpan = remember { mutableStateOf(48 * 3600L) }
28 |   val eventTimesVisible = remember { mutableStateOf(true) }
29 |   Column {
30 |     Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
31 |       IconButton(onClick = {
32 |         viewSpan.value = (viewSpan.value * 2).coerceAtMost(96 * 3600)
33 |       }) {
34 |         Icon(imageVector = Icons.Default.ZoomOut, contentDescription = "increase")
35 |       }
36 | 
37 |       IconButton(onClick = {
38 |         viewSpan.value = (viewSpan.value / 2).coerceAtLeast(3 * 3600)
39 |       }) {
40 |         Icon(imageVector = Icons.Default.ZoomIn, contentDescription = "decrease")
41 |       }
42 | 
43 |       IconButton(onClick = {
44 |         eventTimesVisible.value = !(eventTimesVisible.value)
45 |       }) {
46 |         Icon(imageVector = Icons.Default.HideImage, contentDescription = "decrease")
47 |       }
48 |     }
49 | 
50 |     val calendarState = rememberScheduleCalendarState()
51 | 
52 |     Spacer(modifier = Modifier.height(8.dp))
53 | 
54 |     val colors = remember {
55 |       listOf(R500, G500, Y500, B500, P500, T500)
56 |     }
57 | 
58 |     val sections = remember {
59 |       (1..Random.nextInt(3,7)).map { sectionNumber ->
60 |         CalendarSection(
61 |           name = "Schedule #$sectionNumber",
62 |           events = (1..Random.nextInt(1,3)).map { eventNumber ->
63 |             val start = Random.nextLong(-72, 72)
64 |             val end = Random.nextLong(start + 1, 96)
65 |             CalendarEvent(
66 |               startDate = LocalDateTime.now().plusHours(start),
67 |               endDate = LocalDateTime.now().plusHours(end),
68 |               name = "Event #$sectionNumber#$eventNumber",
69 |               description = "",
70 |               color = colors.random()
71 |             )
72 |           }
73 |         )
74 |       }
75 |     }
76 | 
77 |     ScheduleCalendar(
78 |       state = calendarState,
79 |       now = LocalDateTime.now(),
80 |       eventTimesVisible = eventTimesVisible.value,
81 |       sections = sections,
82 |       viewSpan = viewSpan.value
83 |     )
84 |   }
85 | }
86 | 
87 | @Preview(showBackground = true)
88 | @Composable
89 | fun DefaultPreview() {
90 |   MadeWithComposeTheme {
91 |     ScheduleCalendarDemo()
92 |   }
93 | }
94 | 


--------------------------------------------------------------------------------
/app/src/main/java/com/halilibo/madewithcompose/calendar/CalendarDemo.kt:
--------------------------------------------------------------------------------
  1 | package com.halilibo.madewithcompose.calendar
  2 | 
  3 | import androidx.compose.animation.*
  4 | import androidx.compose.foundation.layout.*
  5 | import androidx.compose.material.Text
  6 | import androidx.compose.runtime.Composable
  7 | import androidx.compose.runtime.mutableStateOf
  8 | import androidx.compose.runtime.remember
  9 | import androidx.compose.ui.Modifier
 10 | import androidx.compose.ui.text.style.TextAlign
 11 | import androidx.compose.ui.tooling.preview.Preview
 12 | import androidx.compose.ui.unit.dp
 13 | import androidx.compose.ui.unit.sp
 14 | import com.halilibo.calendar.*
 15 | import com.halilibo.colors.B500
 16 | import com.halilibo.colors.R500
 17 | import com.halilibo.colors.Y500
 18 | import com.halilibo.madewithcompose.ui.theme.MadeWithComposeTheme
 19 | import java.text.SimpleDateFormat
 20 | import java.util.*
 21 | 
 22 | @Composable
 23 | fun CalendarDemo() {
 24 |   val events = remember {
 25 |     setOf(
 26 |       CalendarEvent(
 27 |         startDate = Date().apply { time -= 6 * 60 * 60 * 1000 },
 28 |         endDate = Date().apply { time += 12 * 60 * 60 * 1000 },
 29 |         name = "Event 1",
 30 |         description = "",
 31 |         color = R500
 32 |       ),
 33 |       CalendarEvent(
 34 |         startDate = Date().apply { time += 24 * 60 * 60 * 1000 },
 35 |         endDate = Date().apply { time += 48 * 60 * 60 * 1000 },
 36 |         name = "Event 2",
 37 |         description = "",
 38 |         color = B500
 39 |       ),
 40 |       CalendarEvent(
 41 |         startDate = Date(),
 42 |         endDate = Date().apply { time += 36 * 60 * 60 * 1000 },
 43 |         name = "Event 3",
 44 |         description = "",
 45 |         color = Y500,
 46 |       )
 47 |     )
 48 |   }
 49 | 
 50 |   val selectedDay = remember { mutableStateOf(CalendarDay.create()) }
 51 |   val visibleMonth = remember { mutableStateOf(CalendarDay.create()) }
 52 | 
 53 |   Column(modifier = Modifier.padding(16.dp)) {
 54 |     MonthRow(
 55 |       month = visibleMonth.value,
 56 |       modifier = Modifier.fillMaxWidth()
 57 |     )
 58 |     Spacer(modifier = Modifier.height(16.dp))
 59 |     Calendar(
 60 |       selectedDay = selectedDay.value,
 61 |       onSelectedDayChange = {
 62 |         selectedDay.value = it
 63 |       },
 64 |       visibleMonth = visibleMonth.value,
 65 |       onVisibleMonthChange = {
 66 |         visibleMonth.value = it
 67 |       },
 68 |       events = events
 69 |     )
 70 |   }
 71 | }
 72 | 
 73 | @Composable
 74 | fun MonthRow(
 75 |   month: CalendarDay,
 76 |   modifier: Modifier = Modifier
 77 | ) {
 78 |   val formatter = remember {
 79 |     SimpleDateFormat("MMM", Locale.getDefault())
 80 |   }
 81 |   AnimatedContent(
 82 |     targetState = month.asCalendar.asDate,
 83 |     transitionSpec = {
 84 |       if (initialState < targetState) {
 85 |         slideInHorizontally { it } togetherWith slideOutHorizontally { -it }
 86 |       } else {
 87 |         slideInHorizontally { -it } togetherWith slideOutHorizontally { it }
 88 |       }
 89 |     },
 90 |     modifier = modifier
 91 |   ) { targetState ->
 92 |     Text(
 93 |       text = formatter.format(targetState),
 94 |       fontSize = 20.sp,
 95 |       textAlign = TextAlign.Center,
 96 |       modifier = Modifier.fillMaxWidth()
 97 |     )
 98 |   }
 99 | }
100 | 
101 | @Preview(showBackground = true)
102 | @Composable
103 | fun DefaultPreview() {
104 |   MadeWithComposeTheme {
105 |     CalendarDemo()
106 |   }
107 | }


--------------------------------------------------------------------------------
/app/src/main/java/com/halilibo/madewithcompose/markdowneditor/MarkdownEditorDemo.kt:
--------------------------------------------------------------------------------
 1 | package com.halilibo.madewithcompose.markdowneditor
 2 | 
 3 | import androidx.compose.foundation.ExperimentalFoundationApi
 4 | import androidx.compose.foundation.layout.fillMaxSize
 5 | import androidx.compose.foundation.layout.imePadding
 6 | import androidx.compose.foundation.layout.navigationBarsPadding
 7 | import androidx.compose.foundation.layout.padding
 8 | import androidx.compose.foundation.shape.RoundedCornerShape
 9 | import androidx.compose.foundation.text2.input.TextFieldState
10 | import androidx.compose.material.BottomSheetScaffold
11 | import androidx.compose.material.Card
12 | import androidx.compose.material.ExperimentalMaterialApi
13 | import androidx.compose.material.rememberBottomSheetScaffoldState
14 | import androidx.compose.runtime.Composable
15 | import androidx.compose.runtime.rememberCoroutineScope
16 | import androidx.compose.runtime.saveable.rememberSaveable
17 | import androidx.compose.ui.Modifier
18 | import androidx.compose.ui.unit.dp
19 | import kotlinx.coroutines.launch
20 | 
21 | @OptIn(ExperimentalMaterialApi::class, ExperimentalFoundationApi::class)
22 | @Composable
23 | fun MarkdownEditorDemo() {
24 |     val coroutineScope = rememberCoroutineScope()
25 |     val bottomSheetScaffoldState = rememberBottomSheetScaffoldState()
26 | 
27 |     val state = rememberSaveable(saver = TextFieldState.Saver) {
28 |         TextFieldState(
29 |             """
30 |             Hello World
31 |             
32 |             This huuuge tweet 😛 was written/rendered by a #JetpackCompose app using Markdown.
33 |              
34 |             RichText Commonmark module enables us to easily render any raw Markdown content into
35 |             a Composable. Later, we can simply Screenshot the whole view and share the image.
36 |             
37 |             Hugetwit was one of my first Android projects that made me decide to take #AndroidDev as my career.
38 |             
39 |             This is just a reincarnation of that project in Compose :)
40 |             """.trimIndent()
41 |         )
42 |     }
43 | 
44 |     BottomSheetScaffold(
45 |         sheetContent = {
46 |             MarkdownPreview(
47 |                 content = state.text,
48 |                 onPreviewClick = {
49 |                     coroutineScope.launch {
50 |                         if (bottomSheetScaffoldState.bottomSheetState.isExpanded) {
51 |                             bottomSheetScaffoldState.bottomSheetState.collapse()
52 |                         } else {
53 |                             bottomSheetScaffoldState.bottomSheetState.expand()
54 |                         }
55 |                     }
56 |                 }
57 |             )
58 |         },
59 |         scaffoldState = bottomSheetScaffoldState,
60 |         sheetPeekHeight = 72.dp,
61 |         sheetElevation = 12.dp,
62 |         sheetShape = RoundedCornerShape(8.dp),
63 |         modifier = Modifier
64 |             .fillMaxSize()
65 |             .navigationBarsPadding()
66 |             .imePadding()
67 |     ) {
68 |         Card {
69 |             MarkdownEditor(
70 |                 state = state,
71 |                 enabled = !bottomSheetScaffoldState.bottomSheetState.isExpanded,
72 |                 onUndo = { state.undoState.undo() },
73 |                 onRedo = { state.undoState.redo() },
74 |                 undoEnabled = state.undoState.canUndo,
75 |                 redoEnabled = state.undoState.canRedo,
76 |                 modifier = Modifier.padding(bottom = 72.dp)
77 |             )
78 |         }
79 |     }
80 | }
81 | 


--------------------------------------------------------------------------------
/app/src/main/java/com/halilibo/madewithcompose/videoplayer/MinimizedTitleAndControls.kt:
--------------------------------------------------------------------------------
 1 | package com.halilibo.madewithcompose.videoplayer
 2 | 
 3 | import androidx.compose.foundation.layout.fillMaxWidth
 4 | import androidx.compose.foundation.layout.padding
 5 | import androidx.compose.material.Icon
 6 | import androidx.compose.material.IconButton
 7 | import androidx.compose.material.Text
 8 | import androidx.compose.material.icons.Icons
 9 | import androidx.compose.material.icons.filled.Close
10 | import androidx.compose.material.icons.filled.Pause
11 | import androidx.compose.material.icons.filled.PlayArrow
12 | import androidx.compose.runtime.Composable
13 | import androidx.compose.runtime.getValue
14 | import androidx.compose.runtime.rememberUpdatedState
15 | import androidx.compose.ui.Modifier
16 | import androidx.compose.ui.layout.Layout
17 | import androidx.compose.ui.text.TextStyle
18 | import androidx.compose.ui.text.font.FontWeight
19 | import androidx.compose.ui.text.style.TextOverflow
20 | import androidx.compose.ui.unit.dp
21 | import androidx.compose.ui.unit.sp
22 | 
23 | 
24 | @Composable
25 | fun MinimizedTitleAndControls(
26 |     videoTitle: String,
27 |     isPlaying: Boolean,
28 |     onPlayPauseToggle: () -> Unit,
29 |     onDismiss: () -> Unit,
30 |     modifier: Modifier = Modifier
31 | ) {
32 |     val onPlayPauseToggleState by rememberUpdatedState(newValue = onPlayPauseToggle)
33 |     val onDismissState by rememberUpdatedState(newValue = onDismiss)
34 |     Layout(
35 |         content = {
36 |             Text(
37 |                 videoTitle,
38 |                 style = TextStyle(
39 |                     fontSize = 16.sp,
40 |                     fontWeight = FontWeight.Bold
41 |                 ),
42 |                 modifier = Modifier
43 |                     .padding(16.dp)
44 |                     .fillMaxWidth(),
45 |                 maxLines = 1,
46 |                 overflow = TextOverflow.Ellipsis
47 |             )
48 | 
49 |             IconButton(onClick = {
50 |                 onPlayPauseToggleState()
51 |             }) {
52 |                 if (isPlaying) {
53 |                     Icon(Icons.Default.Pause, contentDescription = null)
54 |                 } else {
55 |                     Icon(Icons.Default.PlayArrow, contentDescription = null)
56 |                 }
57 |             }
58 | 
59 |             IconButton(onClick = {
60 |                 onDismissState()
61 |             }) {
62 |                 Icon(Icons.Default.Close, contentDescription = null)
63 |             }
64 |         },
65 |         modifier = modifier
66 |     ) { measurables, constraints ->
67 |         val playPausePlaceable = measurables[1].measure(constraints)
68 |         val dismissPlaceable = measurables[2].measure(constraints)
69 | 
70 |         val remainingWidth =
71 |             (constraints.maxWidth - playPausePlaceable.width - dismissPlaceable.width).coerceAtLeast(
72 |                 0
73 |             )
74 |         val titlePlaceable = measurables[0].measure(constraints.copy(maxWidth = remainingWidth))
75 | 
76 |         layout(constraints.maxWidth, constraints.maxHeight) {
77 |             titlePlaceable.placeRelative(0, (constraints.maxHeight - titlePlaceable.height) / 2)
78 |             playPausePlaceable.placeRelative(
79 |                 titlePlaceable.width,
80 |                 (constraints.maxHeight - playPausePlaceable.height) / 2
81 |             )
82 |             dismissPlaceable.placeRelative(
83 |                 titlePlaceable.width + dismissPlaceable.width,
84 |                 (constraints.maxHeight - dismissPlaceable.height) / 2
85 |             )
86 |         }
87 |     }
88 | }


--------------------------------------------------------------------------------
/app/src/main/java/com/halilibo/madewithcompose/videoplayer/VideoPlayerPage.kt:
--------------------------------------------------------------------------------
 1 | package com.halilibo.madewithcompose.videoplayer
 2 | 
 3 | import androidx.compose.foundation.layout.Column
 4 | import androidx.compose.foundation.layout.ColumnScope
 5 | import androidx.compose.foundation.layout.fillMaxWidth
 6 | import androidx.compose.material.*
 7 | import androidx.compose.runtime.Composable
 8 | import androidx.compose.ui.Modifier
 9 | import androidx.compose.ui.graphics.TransformOrigin
10 | import androidx.compose.ui.layout.Layout
11 | import androidx.compose.ui.unit.Constraints
12 | import androidx.compose.ui.unit.dp
13 | 
14 | @OptIn(ExperimentalMaterialApi::class)
15 | @Composable
16 | fun VideoPlayerPage(
17 |     videoPlayer: @Composable () -> Unit,
18 |     content: @Composable ColumnScope.() -> Unit,
19 |     minimizedContent: @Composable () -> Unit,
20 |     swipeProgress: SwipeProgress<MinimizeLayoutValue>,
21 |     modifier: Modifier = Modifier
22 | ) {
23 |     Surface(
24 |         modifier.fillMaxWidth(),
25 |         shape = MaterialTheme.shapes.large,
26 |         elevation = 16.dp,
27 |         color = MaterialTheme.colors.surface,
28 |         contentColor = contentColorFor(MaterialTheme.colors.surface)
29 |     ) {
30 |         Layout(
31 |             content = {
32 |                 videoPlayer()
33 |                 Column {
34 |                     content()
35 |                 }
36 |                 minimizedContent()
37 |             },
38 |             measurePolicy = { measurables, constraints ->
39 |                 val minimizableHeight = constraints.maxHeight
40 | 
41 |                 val videoPlayerPlaceable =
42 |                     measurables[0].measure(constraints.copy(maxHeight = Constraints.Infinity))
43 |                 val fullPagePlaceable = measurables[1].measure(constraints)
44 | 
45 |                 val videoPlayerScale =
46 |                     (minimizableHeight.toFloat() / videoPlayerPlaceable.height.toFloat()).coerceAtMost(1f)
47 |                 val videoPlayerScaledWidth =
48 |                     (videoPlayerPlaceable.width * videoPlayerScale).toInt()
49 | 
50 |                 val minimizedPlaceable = measurables[2].measure(
51 |                     constraints.copy(
52 |                         maxHeight = minimizableHeight,
53 |                         maxWidth = constraints.maxWidth - videoPlayerScaledWidth,
54 |                         minWidth = 0
55 |                     )
56 |                 )
57 | 
58 |                 layout(constraints.maxWidth, constraints.maxHeight) {
59 |                     videoPlayerPlaceable.placeRelativeWithLayer(0, 0) {
60 |                         if (videoPlayerPlaceable.height > minimizableHeight) {
61 |                             scaleX = videoPlayerScale
62 |                             scaleY = videoPlayerScale
63 |                             transformOrigin = TransformOrigin(0f, 0f)
64 |                         }
65 |                     }
66 |                     if (videoPlayerPlaceable.height <= minimizableHeight) {
67 |                         fullPagePlaceable.placeRelativeWithLayer(0, videoPlayerPlaceable.height) {
68 |                             alpha = when {
69 |                                 swipeProgress.from == swipeProgress.to &&
70 |                                     swipeProgress.to == MinimizeLayoutValue.Expanded -> 1f
71 |                                 swipeProgress.to == MinimizeLayoutValue.Expanded -> swipeProgress.fraction
72 |                                 swipeProgress.from == MinimizeLayoutValue.Expanded -> 1 - swipeProgress.fraction
73 |                                 else -> 0f
74 |                             }
75 |                         }
76 |                     } else {
77 |                         minimizedPlaceable.placeRelative(videoPlayerScaledWidth, 0)
78 |                     }
79 |                 }
80 |             }
81 |         )
82 |     }
83 | }


--------------------------------------------------------------------------------
/app/src/main/java/com/halilibo/madewithcompose/varimoji/VarimojiDemo.kt:
--------------------------------------------------------------------------------
  1 | package com.halilibo.madewithcompose.varimoji
  2 | 
  3 | import androidx.compose.foundation.gestures.awaitEachGesture
  4 | import androidx.compose.foundation.layout.Box
  5 | import androidx.compose.foundation.layout.Column
  6 | import androidx.compose.foundation.layout.Spacer
  7 | import androidx.compose.foundation.layout.fillMaxSize
  8 | import androidx.compose.foundation.layout.height
  9 | import androidx.compose.foundation.layout.padding
 10 | import androidx.compose.material.Text
 11 | import androidx.compose.runtime.Composable
 12 | import androidx.compose.runtime.getValue
 13 | import androidx.compose.runtime.mutableFloatStateOf
 14 | import androidx.compose.runtime.remember
 15 | import androidx.compose.runtime.setValue
 16 | import androidx.compose.ui.Alignment
 17 | import androidx.compose.ui.Modifier
 18 | import androidx.compose.ui.draw.drawBehind
 19 | import androidx.compose.ui.geometry.Offset
 20 | import androidx.compose.ui.graphics.Brush
 21 | import androidx.compose.ui.graphics.Color
 22 | import androidx.compose.ui.input.pointer.pointerInput
 23 | import androidx.compose.ui.text.ExperimentalTextApi
 24 | import androidx.compose.ui.text.font.Font
 25 | import androidx.compose.ui.text.font.FontFamily
 26 | import androidx.compose.ui.text.font.FontVariation
 27 | import androidx.compose.ui.unit.dp
 28 | import androidx.compose.ui.unit.sp
 29 | import com.halilibo.madewithcompose.R
 30 | 
 31 | @OptIn(ExperimentalTextApi::class)
 32 | @Composable
 33 | fun VarimojiDemo() {
 34 |   var actv by remember { mutableFloatStateOf(50f) }
 35 |   var vlnc by remember { mutableFloatStateOf(50f) }
 36 |   Column(
 37 |     modifier = Modifier.padding(32.dp),
 38 |     horizontalAlignment = Alignment.CenterHorizontally
 39 |   ) {
 40 |     Text(
 41 |       text = "A",
 42 |       fontFamily = FontFamily(
 43 |         Font(
 44 |           resId = R.font.varimoji,
 45 |           variationSettings = FontVariation.Settings(
 46 |             FontVariation.Setting("ACTV", actv),
 47 |             FontVariation.Setting("VLNC", vlnc),
 48 |           )
 49 |         )
 50 |       ),
 51 |       fontSize = 140.sp
 52 |     )
 53 |     Spacer(modifier = Modifier.height(32.dp))
 54 |     Box(modifier = Modifier
 55 |       .fillMaxSize()
 56 |       .pointerInput(Unit) {
 57 |         awaitEachGesture {
 58 |           do {
 59 |             val event = awaitPointerEvent()
 60 |             event.changes.filter { it.pressed }.forEach {
 61 |               val coercedPosition = Offset(
 62 |                 it.position.x.coerceIn(0f, size.width.toFloat()),
 63 |                 it.position.y.coerceIn(0f, size.height.toFloat()),
 64 |               )
 65 |               actv = coercedPosition.x / size.width * 100f
 66 |               vlnc = coercedPosition.y / size.height * 100f
 67 |               it.consume()
 68 |             }
 69 |           } while (event.changes.all { it.pressed })
 70 |         }
 71 |       }
 72 |       .drawBehind {
 73 |         drawRect(
 74 |           Brush.linearGradient(
 75 |             listOf(Color(0xFFE5E5E5), Color.White),
 76 |             start = Offset(size.width / 2f, size.height / 2f),
 77 |             end = Offset(size.width, 0f)
 78 |           ),
 79 |           topLeft = Offset(size.width / 2f, 0f),
 80 |           size = size / 2f
 81 |         )
 82 | 
 83 |         drawRect(
 84 |           Brush.linearGradient(
 85 |             listOf(Color(0xFFE5E5E5), Color.White),
 86 |             start = Offset(size.width / 2f, size.height / 2f),
 87 |             end = Offset(0f, size.height)
 88 |           ),
 89 |           topLeft = Offset(0f, size.height / 2f),
 90 |           size = size / 2f
 91 |         )
 92 | 
 93 |         val point = Offset(actv / 100f * size.width, vlnc / 100f * size.height)
 94 |         drawCircle(
 95 |           Brush.radialGradient(
 96 |             listOf(Color.Red.copy(alpha = 0.5f), Color.Transparent),
 97 |             radius = 36.dp.toPx(),
 98 |             center = point
 99 |           ),
100 |           radius = 36.dp.toPx(),
101 |           center = point
102 |         )
103 |       }) {
104 |     }
105 |   }
106 | }


--------------------------------------------------------------------------------
/colors/src/main/java/com/halilibo/colors/Colors.kt:
--------------------------------------------------------------------------------
  1 | package com.halilibo.colors
  2 | 
  3 | import androidx.compose.ui.graphics.Color
  4 | 
  5 | val B100 = Color(0xFF4C9AFF)
  6 | val B200 = Color(0xFF2684FF)
  7 | val B300 = Color(0xFF0065FF)
  8 | val B300_85 = Color(0x550065FF)
  9 | val B400 = Color(0xFF0052CC)
 10 | val B50 = Color(0xFFDEEBFF)
 11 | val B500 = Color(0xFF0747A6)
 12 | val B75 = Color(0xFFB3D4FF)
 13 | val DN0 = Color(0xFF090a0b)
 14 | val DN0a = Color(0x00090a0b)
 15 | val DN10 = Color(0xFF101213)
 16 | val DN100 = Color(0xFF5a697c)
 17 | val DN100a = Color(0xBA090a0b)
 18 | val DN10a = Color(0x0F090a0b)
 19 | val DN20 = Color(0xFF17191c)
 20 | val DN200 = Color(0xFF65758b)
 21 | val DN200a = Color(0xC7090a0b)
 22 | val DN20a = Color(0x24090a0b)
 23 | val DN30 = Color(0xFF202328)
 24 | val DN300 = Color(0xFF718298)
 25 | val DN300a = Color(0xCF090a0b)
 26 | val DN30a = Color(0x2E090a0b)
 27 | val DN40 = Color(0xFF262b31)
 28 | val DN400 = Color(0xFF8392a5)
 29 | val DN400a = Color(0xD9090a0b)
 30 | val DN40a = Color(0x4A090a0b)
 31 | val DN50 = Color(0xFF2f353d)
 32 | val DN500 = Color(0xFF929fb0)
 33 | val DN500a = Color(0xE3090a0b)
 34 | val DN50a = Color(0x5C090a0b)
 35 | val DN60 = Color(0xFF373f49)
 36 | val DN600 = Color(0xFFa3aebd)
 37 | val DN600a = Color(0xEb090a0b)
 38 | val DN60a = Color(0x66090a0b)
 39 | val DN70 = Color(0xFF3f4855)
 40 | val DN700 = Color(0xFFb5bec9)
 41 | val DN700a = Color(0xF2090a0b)
 42 | val DN70a = Color(0x78090a0b)
 43 | val DN80 = Color(0xFF475262)
 44 | val DN800 = Color(0xFFc7ced6)
 45 | val DN800a = Color(0xF7090a0b)
 46 | val DN80a = Color(0x87090a0b)
 47 | val DN90 = Color(0xFF515f70)
 48 | val DN900 = Color(0xFFd9dde3)
 49 | val DN900a = Color(0xFF090a0b)
 50 | val DN90a = Color(0xA1090a0b)
 51 | val G100 = Color(0xFF79F2C0)
 52 | val G200 = Color(0xFF57D9A3)
 53 | val G300 = Color(0xFF36B37E)
 54 | val G400 = Color(0xFF00875A)
 55 | val G50 = Color(0xFFE3FCEF)
 56 | val G500 = Color(0xFF006644)
 57 | val G75 = Color(0xFFABF5D1)
 58 | val N0 = Color(0xFFffffff)
 59 | val N0a = Color(0x00091E42)
 60 | val N10 = Color(0xFFFAFBFC)
 61 | val N100 = Color(0xFF7A869A)
 62 | val N100a = Color(0xA3091E42)
 63 | val N10a = Color(0x05091E42)
 64 | val N20 = Color(0xFFF4F5F7)
 65 | val N200 = Color(0xFF6B778C)
 66 | val N200a = Color(0x99091E42)
 67 | val N20a = Color(0x0A091E42)
 68 | val N30 = Color(0xFFEBECF0)
 69 | val N300 = Color(0xFF5E6C84)
 70 | val N300a = Color(0xA8091E42)
 71 | val N30a = Color(0x14091E42)
 72 | val N40 = Color(0xFFDFE1E6)
 73 | val N400 = Color(0xFF505F79)
 74 | val N400a = Color(0xB5091E42)
 75 | val N40a = Color(0x21091E42)
 76 | val N50 = Color(0xFFC1C7D0)
 77 | val N500 = Color(0xFF42526E)
 78 | val N500a = Color(0xC4091E42)
 79 | val N50a = Color(0x40091E42)
 80 | val N60 = Color(0xFFB3BAC5)
 81 | val N600 = Color(0xFF344563)
 82 | val N600a = Color(0xD1091E42)
 83 | val N60a = Color(0x4F091E42)
 84 | val N70 = Color(0xFFA5ADBA)
 85 | val N700 = Color(0xFF253858)
 86 | val N700a = Color(0xE3091E42)
 87 | val N70a = Color(0x5C091E42)
 88 | val N80 = Color(0xFF97A0AF)
 89 | val N800 = Color(0xFF172B4D)
 90 | val N800a = Color(0xF2091E42)
 91 | val N80a = Color(0x6B091E42)
 92 | val N90 = Color(0xFF8993A4)
 93 | val N900 = Color(0xFF091E42)
 94 | val N900a = Color(0xFF091E42)
 95 | val N90a = Color(0x7A091E42)
 96 | val P100 = Color(0xFF998DD9)
 97 | val P200 = Color(0xFF8777D9)
 98 | val P300 = Color(0xFF6554C0)
 99 | val P400 = Color(0xFF5243AA)
100 | val P50 = Color(0xFFEAE6FF)
101 | val P500 = Color(0xFF403294)
102 | val P75 = Color(0xFFC0B6F2)
103 | val R100 = Color(0xFFFF8F73)
104 | val R200 = Color(0xFFFF7452)
105 | val R300 = Color(0xFFFF5630)
106 | val R400 = Color(0xFFDE350B)
107 | val R50 = Color(0xFFFFEBE6)
108 | val R500 = Color(0xFFBF2600)
109 | val R75 = Color(0xFFFFBDAD)
110 | val T100 = Color(0xFF79E2F2)
111 | val T200 = Color(0xFF00C7E5)
112 | val T300 = Color(0xFF00B8D9)
113 | val T400 = Color(0xFF00A3BF)
114 | val T50 = Color(0xFFE6FCFF)
115 | val T500 = Color(0xFF008DA6)
116 | val T75 = Color(0xFFB3F5FF)
117 | val Y100 = Color(0xFFFFE380)
118 | val Y200 = Color(0xFFFFC400)
119 | val Y300 = Color(0xFFFFAB00)
120 | val Y400 = Color(0xFFFF991F)
121 | val Y50 = Color(0xFFFFFAE6)
122 | val Y500 = Color(0xFFFF8B00)
123 | val Y75 = Color(0xFFFFF0B3)


--------------------------------------------------------------------------------
/dotsandlines/src/main/java/com/halilibo/dotsandlines/Dot.kt:
--------------------------------------------------------------------------------
  1 | package com.halilibo.dotsandlines
  2 | 
  3 | import android.os.Parcelable
  4 | import androidx.compose.ui.geometry.Offset
  5 | import androidx.compose.ui.unit.IntSize
  6 | import kotlinx.parcelize.Parcelize
  7 | import kotlin.math.sqrt
  8 | 
  9 | data class Dot(
 10 |     val position: Offset,
 11 |     val vector: Offset
 12 | ) {
 13 |     companion object {
 14 |         /**
 15 |          * Calculate this [Dot]'s distance to another one.
 16 |          */
 17 |         infix fun Dot.distanceTo(another: Dot): Float {
 18 |             return (position - another.position).getDistance()
 19 |         }
 20 | 
 21 |         /**
 22 |          * Calculate where this dot will be in the next iteration.
 23 |          *
 24 |          * @param borders Size of the canvas where dots bounce.
 25 |          * @param durationMillis How long time is going to pass until next iteration.
 26 |          * @param dotRadius The radius of this dot when it is drawn.
 27 |          * @param speedCoefficient Although there is vector that indicates motion, this
 28 |          * parameter is used to speed up or down the animation at will.
 29 |          */
 30 |         fun Dot.next(
 31 |             borders: IntSize,
 32 |             durationMillis: Long,
 33 |             dotRadius: Float,
 34 |             speedCoefficient: Float
 35 |         ): Dot {
 36 |             val speed = vector * speedCoefficient
 37 | 
 38 |             return Dot(
 39 |                 position = position + Offset(
 40 |                     x = speed.x / 1000f * durationMillis,
 41 |                     y = speed.y / 1000f * durationMillis,
 42 |                 ),
 43 |                 vector = vector
 44 |             ).let { (position, vector) ->
 45 |                 val borderTop = dotRadius
 46 |                 val borderLeft = dotRadius
 47 |                 val borderBottom = borders.height - dotRadius
 48 |                 val borderRight = borders.width - dotRadius
 49 |                 Dot(
 50 |                     position = Offset(
 51 |                         x = when {
 52 |                             position.x < borderLeft -> borderLeft - (position.x - borderLeft)
 53 |                             position.x > borderRight -> borderRight - (position.x - borderRight)
 54 |                             else -> position.x
 55 |                         },
 56 |                         y = when {
 57 |                             position.y < borderTop -> borderTop - (position.y - borderTop)
 58 |                             position.y > borderBottom -> borderBottom - (position.y - borderBottom)
 59 |                             else -> position.y
 60 |                         }
 61 |                     ),
 62 |                     vector = Offset(
 63 |                         x = when {
 64 |                             position.x < borderLeft -> -vector.x
 65 |                             position.x > borderRight -> -vector.x
 66 |                             else -> vector.x
 67 |                         },
 68 |                         y = when {
 69 |                             position.y < borderTop -> -vector.y
 70 |                             position.y > borderBottom -> -vector.y
 71 |                             else -> vector.y
 72 |                         }
 73 |                     )
 74 |                 )
 75 |             }
 76 |         }
 77 | 
 78 |         /**
 79 |          * Create a random dot instance belonging to @param borders.
 80 |          */
 81 |         fun create(borders: IntSize): Dot {
 82 |             return Dot(
 83 |                 position = Offset(
 84 |                     (0..borders.width).random().toFloat(),
 85 |                     (0..borders.height).random().toFloat()
 86 |                 ),
 87 |                 vector = Offset(
 88 |                     // First, randomize direction. Second, randomize amplitude of speed vector.
 89 |                     listOf(-1f, 1f).random() * ((borders.width.toFloat() / 100f).toInt()..(borders.width.toFloat() / 10f).toInt()).random()
 90 |                         .toFloat(),
 91 |                     listOf(-1f, 1f).random() * ((borders.height.toFloat() / 100f).toInt()..(borders.height.toFloat() / 10f).toInt()).random()
 92 |                         .toFloat()
 93 |                 )
 94 |             )
 95 |         }
 96 | 
 97 |         // Treat offset as a vector
 98 |         fun Offset.normalize(): Offset {
 99 |             val l = 1.0f / length()
100 |             return Offset(x * l, y * l)
101 |         }
102 | 
103 |         fun Offset.length(): Float {
104 |             return sqrt(x * x + y * y)
105 |         }
106 |     }
107 | }


--------------------------------------------------------------------------------
/weightentry/src/main/java/com/halilibo/weightentry/WeightScale.kt:
--------------------------------------------------------------------------------
  1 | package com.halilibo.weightentry
  2 | 
  3 | import androidx.compose.animation.core.Animatable
  4 | import androidx.compose.animation.core.VectorConverter
  5 | import androidx.compose.foundation.layout.Box
  6 | import androidx.compose.foundation.layout.padding
  7 | import androidx.compose.material.Text
  8 | import androidx.compose.runtime.Composable
  9 | import androidx.compose.runtime.LaunchedEffect
 10 | import androidx.compose.runtime.remember
 11 | import androidx.compose.ui.Alignment
 12 | import androidx.compose.ui.Modifier
 13 | import androidx.compose.ui.draw.drawBehind
 14 | import androidx.compose.ui.geometry.Offset
 15 | import androidx.compose.ui.geometry.Size
 16 | import androidx.compose.ui.graphics.Color
 17 | import androidx.compose.ui.graphics.StrokeCap
 18 | import androidx.compose.ui.graphics.drawscope.Fill
 19 | import androidx.compose.ui.graphics.drawscope.Stroke
 20 | import androidx.compose.ui.text.SpanStyle
 21 | import androidx.compose.ui.text.buildAnnotatedString
 22 | import androidx.compose.ui.text.font.FontWeight
 23 | import androidx.compose.ui.unit.dp
 24 | import androidx.compose.ui.unit.sp
 25 | import kotlin.math.PI
 26 | import kotlin.math.cos
 27 | import kotlin.math.sin
 28 | 
 29 | val ScaleGray = Color(239, 239, 239)
 30 | val ScaleAccent = Color(119, 49, 255)
 31 | 
 32 | @Composable
 33 | fun WeightScale(
 34 |     weight: Int,
 35 |     valueRange: ClosedRange<Int>,
 36 |     modifier: Modifier
 37 | ) {
 38 |     val animatedValue = remember { Animatable(weight, Int.VectorConverter) }
 39 |     LaunchedEffect(weight) {
 40 |         animatedValue.snapTo(weight)
 41 |     }
 42 | 
 43 |     Box(
 44 |         modifier = modifier
 45 |             .padding(16.dp)
 46 |             .weightScaleBackground(animatedValue.value, valueRange),
 47 |         contentAlignment = Alignment.Center,
 48 |     ) {
 49 |         Text(
 50 |             text = buildAnnotatedString {
 51 |                 pushStyle(SpanStyle(fontWeight = FontWeight.Bold))
 52 |                 append("$weight")
 53 |                 pop()
 54 |                 append(" kg")
 55 |             },
 56 |             fontSize = 40.sp
 57 |         )
 58 |     }
 59 | }
 60 | 
 61 | private fun Modifier.weightScaleBackground(
 62 |     weight: Int,
 63 |     valueRange: ClosedRange<Int>,
 64 | ) = drawBehind {
 65 |     val radius = size.width / 2
 66 |     val squareSize = Size(radius * 2, radius * 2)
 67 |     drawArc(
 68 |         color = ScaleGray,
 69 |         startAngle = 165f,
 70 |         sweepAngle = 210f,
 71 |         useCenter = false,
 72 |         size = squareSize,
 73 |         style = Stroke(width = 12f, cap = StrokeCap.Round)
 74 |     )
 75 | 
 76 |     drawArc(
 77 |         color = ScaleAccent,
 78 |         startAngle = -105f,
 79 |         sweepAngle = 30f,
 80 |         useCenter = true,
 81 |         topLeft = Offset(
 82 |             squareSize.width / 2 - squareSize.div(8f).width,
 83 |             (squareSize.height - squareSize.height / 1.1f) / 2
 84 |         ),
 85 |         size = squareSize.div(4f),
 86 |         style = Fill
 87 |     )
 88 | 
 89 |     drawArc(
 90 |         color = ScaleGray,
 91 |         startAngle = 165f,
 92 |         sweepAngle = 210f,
 93 |         useCenter = false,
 94 |         topLeft = Offset(
 95 |             (squareSize.width - squareSize.width / 1.1f) / 2,
 96 |             (squareSize.height - squareSize.height / 1.1f) / 2
 97 |         ),
 98 |         size = squareSize.div(1.1f),
 99 |         style = Stroke(width = 20f, cap = StrokeCap.Round)
100 |     )
101 | 
102 |     ((0..14) - 7).forEach { index ->
103 |         val alpha = (165f + index * 15f) / 180f * PI.toFloat()
104 |         drawLine(
105 |             color = ScaleGray,
106 |             start = Offset(
107 |                 x = radius + (radius / 1.12f) * cos(alpha),
108 |                 y = radius + (radius / 1.12f) * sin(alpha),
109 |             ),
110 |             end = Offset(
111 |                 x = radius + (radius / 1.3f) * cos(alpha),
112 |                 y = radius + (radius / 1.3f) * sin(alpha),
113 |             ),
114 |             strokeWidth = 20f,
115 |             cap = StrokeCap.Round
116 |         )
117 |     }
118 | 
119 |     drawArc(
120 |         color = ScaleAccent,
121 |         startAngle = 165f,
122 |         sweepAngle = (210f / (valueRange.endInclusive - valueRange.start)) * (weight - valueRange.start),
123 |         useCenter = false,
124 |         topLeft = Offset(
125 |             (squareSize.width - squareSize.width / 1.1f) / 2,
126 |             (squareSize.height - squareSize.height / 1.1f) / 2
127 |         ),
128 |         size = squareSize.div(1.1f),
129 |         style = Stroke(width = 30f, cap = StrokeCap.Round)
130 |     )
131 | }


--------------------------------------------------------------------------------
/app/src/main/java/com/halilibo/madewithcompose/circlesonlines/CirclesOnLines.kt:
--------------------------------------------------------------------------------
  1 | package com.halilibo.madewithcompose.circlesonlines
  2 | 
  3 | import androidx.compose.animation.core.*
  4 | import androidx.compose.foundation.Canvas
  5 | import androidx.compose.foundation.background
  6 | import androidx.compose.foundation.layout.*
  7 | import androidx.compose.foundation.shape.CircleShape
  8 | import androidx.compose.material.Button
  9 | import androidx.compose.material.Text
 10 | import androidx.compose.runtime.*
 11 | import androidx.compose.ui.Modifier
 12 | import androidx.compose.ui.draw.alpha
 13 | import androidx.compose.ui.draw.clip
 14 | import androidx.compose.ui.geometry.Offset
 15 | import androidx.compose.ui.graphics.Color
 16 | import androidx.compose.ui.unit.dp
 17 | import kotlinx.coroutines.delay
 18 | import kotlinx.coroutines.isActive
 19 | import kotlin.math.PI
 20 | import kotlin.math.cos
 21 | import kotlin.math.sin
 22 | 
 23 | @Composable
 24 | fun CirclesOnLinesDemo() {
 25 |     var isStarted by remember { mutableStateOf(false) }
 26 |     val revealOrderAnimation = remember { Animatable(initialValue = 0, Int.VectorConverter) }
 27 |     LaunchedEffect(isStarted) {
 28 |         revealOrderAnimation.animateTo(
 29 |             targetValue = if (isStarted) 8 else 0,
 30 |             animationSpec = tween(16000, easing = LinearEasing)
 31 |         )
 32 |     }
 33 | 
 34 |     var linesVisible by remember { mutableStateOf(true) }
 35 |     Column(
 36 |         Modifier
 37 |             .fillMaxSize()
 38 |             .padding(16.dp)) {
 39 |         Row {
 40 |             if (!isStarted) {
 41 |                 Button(onClick = {
 42 |                     isStarted = true
 43 |                 }, modifier = Modifier.padding(16.dp)) {
 44 |                     Text("Start")
 45 |                 }
 46 |             }
 47 |             if (isStarted) {
 48 |                 Button(onClick = {
 49 |                     linesVisible = !linesVisible
 50 |                 }, modifier = Modifier.padding(16.dp)) {
 51 |                     Text("${if (linesVisible) "Hide" else "Show"} Lines")
 52 |                 }
 53 |             }
 54 |         }
 55 |         Box(
 56 |             modifier = Modifier
 57 |                 .fillMaxWidth()
 58 |                 .aspectRatio(1f)
 59 |                 .clip(CircleShape)
 60 |                 .background(Color.Red)
 61 |         ) {
 62 |             repeat(8) { index ->
 63 |                 val angle = PI.toFloat() / 8 * index
 64 |                 val alpha by animateFloatAsState(
 65 |                     if (DELAY_ORDER.take(revealOrderAnimation.value).contains(index)) 1f else 0f,
 66 |                     animationSpec = tween(1000)
 67 |                 )
 68 |                 LineOscillator(
 69 |                     angle = angle,
 70 |                     delayMillis = PERIOD + index * PERIOD / 8,
 71 |                     lineVisible = linesVisible,
 72 |                     modifier = Modifier.alpha(alpha)
 73 |                 )
 74 |             }
 75 |         }
 76 |     }
 77 | }
 78 | 
 79 | @Composable
 80 | fun LineOscillator(
 81 |     angle: Float,
 82 |     delayMillis: Int,
 83 |     lineVisible: Boolean,
 84 |     modifier: Modifier
 85 | ) {
 86 |     val animatedValue = remember { Animatable(initialValue = -1f) }
 87 |     LaunchedEffect(Unit) {
 88 |         delay(delayMillis.toLong())
 89 |         animatedValue.animateTo(
 90 |             targetValue = 1f,
 91 |             animationSpec = infiniteRepeatable(
 92 |                 animation = tween(durationMillis = PERIOD, easing = EASING),
 93 |                 repeatMode = RepeatMode.Reverse
 94 |             )
 95 |         )
 96 |     }
 97 | 
 98 |     Canvas(modifier.fillMaxSize()) {
 99 |         val circleRadius = 16.dp.toPx()
100 |         drawCircle(
101 |             Color.White,
102 |             radius = circleRadius,
103 |             center = Offset(
104 |                 (1 + animatedValue.value * cos(angle)) * (size.width / 2 - circleRadius) + circleRadius,
105 |                 (1 + animatedValue.value * sin(angle)) * (size.width / 2 - circleRadius) + circleRadius
106 |             )
107 |         )
108 |         if (lineVisible) {
109 |             drawLine(
110 |                 Color.Black,
111 |                 start = Offset(
112 |                     ((1 + cos(angle)) * size.width / 2),
113 |                     (1 + sin(angle)) * size.width / 2
114 |                 ),
115 |                 end = Offset(
116 |                     ((1 - cos(angle)) * size.width / 2),
117 |                     (1 - sin(angle)) * size.width / 2
118 |                 ),
119 |                 strokeWidth = 4f,
120 |             )
121 |         }
122 |     }
123 | }
124 | 
125 | const val PERIOD = 2400
126 | val EASING = CubicBezierEasing(0.375f, 0f, 0.6f, 1f)
127 | val DELAY_ORDER = listOf(0, 4, 2, 6, 1, 5, 3, 7)


--------------------------------------------------------------------------------
/app/src/main/java/com/halilibo/madewithcompose/MainActivity.kt:
--------------------------------------------------------------------------------
  1 | package com.halilibo.madewithcompose
  2 | 
  3 | import android.content.res.Configuration
  4 | import android.os.Bundle
  5 | import androidx.activity.ComponentActivity
  6 | import androidx.activity.compose.setContent
  7 | import androidx.compose.foundation.layout.Spacer
  8 | import androidx.compose.foundation.layout.navigationBarsPadding
  9 | import androidx.compose.foundation.layout.padding
 10 | import androidx.compose.foundation.layout.statusBarsPadding
 11 | import androidx.compose.foundation.layout.width
 12 | import androidx.compose.material.*
 13 | import androidx.compose.material.icons.Icons
 14 | import androidx.compose.material.icons.filled.DarkMode
 15 | import androidx.compose.material.icons.filled.LightMode
 16 | import androidx.compose.runtime.Composable
 17 | import androidx.compose.ui.Modifier
 18 | import androidx.compose.ui.unit.dp
 19 | import androidx.core.view.WindowCompat
 20 | import androidx.navigation.NavController
 21 | import androidx.navigation.compose.NavHost
 22 | import androidx.navigation.compose.composable
 23 | import androidx.navigation.compose.currentBackStackEntryAsState
 24 | import androidx.navigation.compose.rememberNavController
 25 | import com.halilibo.madewithcompose.pip.LocalPipState
 26 | import com.halilibo.madewithcompose.pip.composePip
 27 | import com.halilibo.madewithcompose.ui.theme.LocalNightMode
 28 | import com.halilibo.madewithcompose.ui.theme.MadeWithComposeTheme
 29 | 
 30 | class MainActivity : ComponentActivity() {
 31 | 
 32 |     private val composePipController = composePip()
 33 | 
 34 |     override fun onCreate(savedInstanceState: Bundle?) {
 35 |         super.onCreate(savedInstanceState)
 36 |         WindowCompat.setDecorFitsSystemWindows(window, false)
 37 | 
 38 |         setContent {
 39 |             MadeWithComposeTheme {
 40 |                 composePipController.ProvidePip {
 41 |                     val navController = rememberNavController()
 42 |                     Scaffold(
 43 |                         topBar = {
 44 |                             TopBar(navController = navController)
 45 |                         }
 46 |                     ) {
 47 |                         Surface(modifier = Modifier.padding(it).navigationBarsPadding()) {
 48 |                             NavHost(navController = navController, startDestination = "home") {
 49 |                                 composable("home") {
 50 |                                     HomePage(navController)
 51 |                                 }
 52 |                                 DemoEntry.values().forEach { demo ->
 53 |                                     composable(demo.destination) {
 54 |                                         demo.composable()
 55 |                                     }
 56 |                                 }
 57 |                             }
 58 |                         }
 59 |                     }
 60 |                 }
 61 |             }
 62 |         }
 63 |     }
 64 | 
 65 |     override fun onUserLeaveHint() {
 66 |         super.onUserLeaveHint()
 67 |         composePipController.onUserLeaveHint(this)
 68 |     }
 69 | 
 70 |     override fun onPictureInPictureModeChanged(
 71 |         isInPictureInPictureMode: Boolean,
 72 |         newConfig: Configuration
 73 |     ) {
 74 |         super.onPictureInPictureModeChanged(isInPictureInPictureMode, newConfig)
 75 |         composePipController.pictureInPictureModeChanged(isInPictureInPictureMode)
 76 |     }
 77 | }
 78 | 
 79 | @Composable
 80 | fun TopBar(navController: NavController) {
 81 |     val currentBackStackEntry = navController.currentBackStackEntryAsState().value
 82 |     val currentRouteName = currentBackStackEntry?.destination?.route
 83 |     val currentRouteTitle = DemoEntry.values().firstOrNull { it.destination == currentRouteName }?.title
 84 | 
 85 |     val pipController = LocalPipState.current
 86 | 
 87 |     if (!pipController.isInPictureInPicture.value) {
 88 |         TopAppBar(
 89 |             title = {
 90 |                 Text(text = currentRouteTitle ?: "Home")
 91 |             },
 92 |             actions = {
 93 |                 val nightMode = LocalNightMode.current
 94 |                 Icon(Icons.Default.LightMode, contentDescription = "")
 95 |                 Spacer(modifier = Modifier.width(8.dp))
 96 |                 Switch(
 97 |                     checked = nightMode.isNight,
 98 |                     onCheckedChange = { isNight ->
 99 |                         if (isNight) nightMode.setNight() else nightMode.setDay()
100 |                     }
101 |                 )
102 |                 Spacer(modifier = Modifier.width(8.dp))
103 |                 Icon(Icons.Default.DarkMode, contentDescription = "")
104 |                 Spacer(modifier = Modifier.width(16.dp))
105 |             },
106 |             modifier = Modifier.statusBarsPadding()
107 |         )
108 |     }
109 | }
110 | 


--------------------------------------------------------------------------------
/screenshot/src/main/java/com/halilibo/screenshot/Screenshot.kt:
--------------------------------------------------------------------------------
  1 | package com.halilibo.screenshot
  2 | 
  3 | import android.graphics.Bitmap
  4 | import android.graphics.Picture
  5 | import androidx.compose.runtime.getValue
  6 | import androidx.compose.runtime.mutableIntStateOf
  7 | import androidx.compose.runtime.setValue
  8 | import androidx.compose.ui.Modifier
  9 | import androidx.compose.ui.draw.drawWithContent
 10 | import androidx.compose.ui.geometry.Size
 11 | import androidx.compose.ui.graphics.Canvas
 12 | import androidx.compose.ui.graphics.ImageBitmap
 13 | import androidx.compose.ui.graphics.asImageBitmap
 14 | import androidx.compose.ui.graphics.drawscope.CanvasDrawScope
 15 | import androidx.compose.ui.graphics.drawscope.DrawScope
 16 | import androidx.compose.ui.graphics.drawscope.draw
 17 | import androidx.compose.ui.graphics.drawscope.drawIntoCanvas
 18 | import androidx.compose.ui.graphics.nativeCanvas
 19 | import androidx.compose.ui.unit.Density
 20 | import androidx.compose.ui.unit.LayoutDirection
 21 | import kotlinx.coroutines.Dispatchers
 22 | import kotlinx.coroutines.TimeoutCancellationException
 23 | import kotlinx.coroutines.delay
 24 | import kotlinx.coroutines.withContext
 25 | import kotlinx.coroutines.withTimeout
 26 | import kotlin.math.abs
 27 | 
 28 | /**
 29 |  * A modifier that can delegate its draw operations to a [screenshotController] to obtain an
 30 |  * [ImageBitmap] of its contents.
 31 |  *
 32 |  * @see com.halilibo.screenshot.ScreenshotController
 33 |  */
 34 | fun Modifier.screenshot(
 35 |   screenshotController: ScreenshotController
 36 | ): Modifier = this.drawWithContent {
 37 |   if (screenshotController.recordingRequested > 0) {
 38 |     val pictureCanvas =
 39 |       Canvas(
 40 |         screenshotController.picture.beginRecording(
 41 |           this.size.width.toInt(),
 42 |           this.size.height.toInt()
 43 |         )
 44 |       )
 45 |     screenshotController.density = this
 46 |     screenshotController.layoutDirection = this.layoutDirection
 47 |     draw(this, this.layoutDirection, pictureCanvas, this.size) {
 48 |       this@drawWithContent.drawContent()
 49 |     }
 50 |     screenshotController.picture.endRecording()
 51 | 
 52 |     drawIntoCanvas { canvas ->
 53 |       canvas.nativeCanvas.drawPicture(screenshotController.picture)
 54 |     }
 55 | 
 56 |     screenshotController.recordingRequested = -abs(screenshotController.recordingRequested)
 57 |   } else {
 58 |     drawContent()
 59 |   }
 60 | }
 61 | 
 62 | /**
 63 |  * Controller class to request a screenshot of a Composable.
 64 |  */
 65 | class ScreenshotController {
 66 | 
 67 |   internal val picture: Picture = Picture()
 68 | 
 69 |   // These initial values are just placeholders and will be filled with actual values by the
 70 |   // screenshot modifier.
 71 |   internal var density: Density = Density(1f)
 72 |   internal var layoutDirection = LayoutDirection.Ltr
 73 | 
 74 |   internal var recordingRequested by mutableIntStateOf(-1)
 75 | 
 76 |   /**
 77 |    * Provides a [DrawScope] to draw onto a canvas that has the same size as the composable
 78 |    * which is managed by this [ScreenshotController]. Do not forget to call the provided
 79 |    * `drawScreenshot` lambda to actually draw the contents of the managed composable.
 80 |    */
 81 |   suspend fun drawWithScreenshot(block: DrawScope.(drawScreenshot: () -> Unit) -> Unit): ImageBitmap {
 82 |     withContext(Dispatchers.Unconfined) {
 83 |       try {
 84 |         waitForDrawCycle()
 85 |       } catch (e: TimeoutCancellationException) {
 86 |         throw IllegalStateException("Composable could not be drawn into a Bitmap")
 87 |       }
 88 |     }
 89 |     val bitmap = Bitmap.createBitmap(
 90 |       picture.width,
 91 |       picture.height,
 92 |       Bitmap.Config.ARGB_8888
 93 |     )
 94 |     val canvas = android.graphics.Canvas(bitmap)
 95 |     val composeCanvas = Canvas(canvas)
 96 |     val backingDrawScope: DrawScope = CanvasDrawScope()
 97 |     backingDrawScope.draw(
 98 |       density,
 99 |       layoutDirection,
100 |       composeCanvas,
101 |       Size(picture.width.toFloat(), picture.height.toFloat()),
102 |     ) {
103 |       block {
104 |         canvas.drawPicture(picture)
105 |       }
106 |     }
107 | 
108 |     return bitmap.asImageBitmap()
109 |   }
110 | 
111 |   /**
112 |    * Simply returns the contents of the composable that's managed by this controller on an
113 |    * [ImageBitmap].
114 |    */
115 |   suspend fun draw(): ImageBitmap {
116 |     withContext(Dispatchers.Unconfined) {
117 |       try {
118 |         waitForDrawCycle()
119 |       } catch (e: TimeoutCancellationException) {
120 |         throw IllegalStateException("Composable could not be drawn into a Bitmap")
121 |       }
122 |     }
123 |     val bitmap = Bitmap.createBitmap(
124 |       picture.width,
125 |       picture.height,
126 |       Bitmap.Config.ARGB_8888
127 |     )
128 |     val canvas = android.graphics.Canvas(bitmap)
129 |     canvas.drawPicture(picture)
130 | 
131 |     return bitmap.asImageBitmap()
132 |   }
133 | 
134 |   private suspend fun waitForDrawCycle() {
135 |     recordingRequested = abs(recordingRequested) + 1
136 |     withTimeout(1000) {
137 |       while (recordingRequested > 0) {
138 |         delay(8)
139 |       }
140 |     }
141 |   }
142 | }
143 | 


--------------------------------------------------------------------------------
/app/src/main/java/com/halilibo/madewithcompose/pip/PictureInPictureDemo.kt:
--------------------------------------------------------------------------------
  1 | package com.halilibo.madewithcompose.pip
  2 | 
  3 | import android.app.PictureInPictureParams
  4 | import android.graphics.Rect
  5 | import android.util.Rational
  6 | import androidx.activity.ComponentActivity
  7 | import androidx.compose.foundation.layout.Box
  8 | import androidx.compose.foundation.layout.Column
  9 | import androidx.compose.foundation.layout.Row
 10 | import androidx.compose.foundation.layout.Spacer
 11 | import androidx.compose.foundation.layout.fillMaxSize
 12 | import androidx.compose.foundation.layout.width
 13 | import androidx.compose.material.Checkbox
 14 | import androidx.compose.material.Text
 15 | import androidx.compose.runtime.Composable
 16 | import androidx.compose.runtime.CompositionLocalProvider
 17 | import androidx.compose.runtime.DisposableEffect
 18 | import androidx.compose.runtime.Stable
 19 | import androidx.compose.runtime.State
 20 | import androidx.compose.runtime.compositionLocalOf
 21 | import androidx.compose.runtime.derivedStateOf
 22 | import androidx.compose.runtime.getValue
 23 | import androidx.compose.runtime.mutableStateMapOf
 24 | import androidx.compose.runtime.mutableStateOf
 25 | import androidx.compose.runtime.remember
 26 | import androidx.compose.runtime.setValue
 27 | import androidx.compose.ui.Alignment
 28 | import androidx.compose.ui.Modifier
 29 | import androidx.compose.ui.unit.dp
 30 | import java.util.UUID
 31 | import kotlin.math.roundToInt
 32 | 
 33 | @Composable
 34 | fun PictureInPictureDemo() {
 35 |     val pipState = LocalPipState.current
 36 |     var pipEnabledCheckboxState by remember { mutableStateOf(true) }
 37 | 
 38 |     pipState.PipEnabled(isEnabled = pipEnabledCheckboxState)
 39 | 
 40 |     Box(modifier = Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
 41 |         Column {
 42 |             if (pipState.isInPictureInPicture.value) {
 43 |                 Text("Currently in PiP")
 44 |             } else {
 45 |                 Text("This is not PiP")
 46 | 
 47 |                 Row(verticalAlignment = Alignment.CenterVertically) {
 48 |                     Checkbox(
 49 |                         checked = pipEnabledCheckboxState,
 50 |                         onCheckedChange = { isChecked ->
 51 |                             pipEnabledCheckboxState = isChecked
 52 |                         }
 53 |                     )
 54 | 
 55 |                     Spacer(modifier = Modifier.width(4.dp))
 56 | 
 57 |                     Text(text = "Should enter PiP?")
 58 |                 }
 59 |             }
 60 |         }
 61 |     }
 62 | }
 63 | 
 64 | private class DefaultPipState : PipState {
 65 |     private val _isInPictureInPicture = mutableStateOf(false)
 66 |     override val isInPictureInPicture: State<Boolean> = _isInPictureInPicture
 67 | 
 68 |     override fun pictureInPictureModeChanged(newValue: Boolean) {
 69 |         _isInPictureInPicture.value = newValue
 70 |     }
 71 | 
 72 |     override fun onUserLeaveHint(activity: ComponentActivity) {
 73 |         if (shouldEnterPip.value) {
 74 |             activity.enterPictureInPictureMode(pipParams)
 75 |         }
 76 |     }
 77 | 
 78 |     override val pipParams
 79 |         get() = PictureInPictureParams.Builder()
 80 |             .setAspectRatio(aspectRatio)
 81 |             .apply { sourceRectHint?.let(::setSourceRectHint) }
 82 |             .build()
 83 | 
 84 |     private var aspectRatio = Rational(16, 9)
 85 |     override fun setAspectRatio(width: Float, height: Float) {
 86 |         aspectRatio = Rational(width.roundToInt(), height.roundToInt())
 87 |     }
 88 | 
 89 |     private var sourceRectHint: Rect? = null
 90 |     override fun setSourceRectHint(rect: Rect) {
 91 |         sourceRectHint = rect
 92 |     }
 93 | 
 94 |     private val shouldEnterPipValues = mutableStateMapOf<String, Boolean>()
 95 |     override val shouldEnterPip: State<Boolean> = derivedStateOf {
 96 |         if (shouldEnterPipValues.isEmpty()) {
 97 |             false
 98 |         } else {
 99 |             shouldEnterPipValues.values.reduce { acc, b -> acc && b }
100 |         }
101 |     }
102 | 
103 |     @Composable
104 |     override fun PipEnabled(isEnabled: Boolean) {
105 |         val uuid = remember { UUID.randomUUID().toString() }
106 |         DisposableEffect(isEnabled) {
107 |             shouldEnterPipValues[uuid] = isEnabled
108 |             onDispose {
109 |                 shouldEnterPipValues.remove(uuid)
110 |             }
111 |         }
112 |     }
113 | }
114 | 
115 | interface PipState {
116 |     val isInPictureInPicture: State<Boolean>
117 |     val shouldEnterPip: State<Boolean>
118 | 
119 |     val pipParams: PictureInPictureParams
120 | 
121 |     fun setAspectRatio(width: Float, height: Float)
122 |     fun setSourceRectHint(rect: Rect)
123 | 
124 |     fun pictureInPictureModeChanged(newValue: Boolean)
125 |     fun onUserLeaveHint(activity: ComponentActivity)
126 | 
127 |     @Composable fun PipEnabled(isEnabled: Boolean)
128 | }
129 | 
130 | val LocalPipState = compositionLocalOf<PipState> { error("Not defined") }
131 | 
132 | @Stable
133 | data class ComposePip(
134 |     val ProvidePip: @Composable (content: @Composable () -> Unit) -> Unit,
135 |     val pipState: PipState
136 | ) : PipState by pipState
137 | 
138 | fun composePip(): ComposePip {
139 |     val controller = DefaultPipState()
140 |     val provider: @Composable (content: @Composable () -> Unit) -> Unit = @Composable { content ->
141 |         CompositionLocalProvider(LocalPipState provides controller) {
142 |             content()
143 |         }
144 |     }
145 | 
146 |     return ComposePip(provider, controller)
147 | }
148 | 


--------------------------------------------------------------------------------
/videoplayer/src/main/java/com/halilibo/videoplayer/MediaControlButtons.kt:
--------------------------------------------------------------------------------
  1 | package com.halilibo.videoplayer
  2 | 
  3 | import androidx.compose.animation.core.Animatable
  4 | import androidx.compose.animation.core.LinearEasing
  5 | import androidx.compose.animation.core.tween
  6 | import androidx.compose.foundation.background
  7 | import androidx.compose.foundation.clickable
  8 | import androidx.compose.foundation.interaction.MutableInteractionSource
  9 | import androidx.compose.foundation.layout.*
 10 | import androidx.compose.material.CircularProgressIndicator
 11 | import androidx.compose.material.IconButton
 12 | import androidx.compose.material.Text
 13 | import androidx.compose.material.icons.Icons
 14 | import androidx.compose.material.icons.filled.Pause
 15 | import androidx.compose.material.icons.filled.PlayArrow
 16 | import androidx.compose.material.icons.filled.Restore
 17 | import androidx.compose.runtime.*
 18 | import androidx.compose.ui.Alignment
 19 | import androidx.compose.ui.Modifier
 20 | import androidx.compose.ui.draw.alpha
 21 | import androidx.compose.ui.geometry.Offset
 22 | import androidx.compose.ui.graphics.Color
 23 | import androidx.compose.ui.graphics.Shadow
 24 | import androidx.compose.ui.text.TextStyle
 25 | import androidx.compose.ui.unit.dp
 26 | import com.halilibo.videoplayer.util.getDurationString
 27 | 
 28 | @Composable
 29 | fun MediaControlButtons(
 30 |     modifier: Modifier = Modifier
 31 | ) {
 32 |     val controller = LocalVideoPlayerController.current
 33 | 
 34 |     val controlsEnabled by controller.collect { controlsEnabled }
 35 | 
 36 |     // Dictates the direction of appear animation.
 37 |     // If controlsVisible is true, appear animation needs to be triggered.
 38 |     val controlsVisible by controller.collect { controlsVisible }
 39 | 
 40 |     // When controls are not visible anymore we should remove them from UI tree
 41 |     // Controls by default should always be on screen.
 42 |     // Only when disappear animation finishes, controls can be freely cleared from the tree.
 43 |     val (controlsExistOnUITree, setControlsExistOnUITree) = remember(controlsVisible) {
 44 |         mutableStateOf(true)
 45 |     }
 46 | 
 47 |     val appearAlpha = remember { Animatable(0f) }
 48 | 
 49 |     LaunchedEffect(controlsVisible) {
 50 |         appearAlpha.animateTo(
 51 |             targetValue = if (controlsVisible) 1f else 0f,
 52 |             animationSpec = tween(
 53 |                 durationMillis = 250,
 54 |                 easing = LinearEasing
 55 |             )
 56 |         )
 57 |         setControlsExistOnUITree(controlsVisible)
 58 |     }
 59 | 
 60 |     if (controlsEnabled && controlsExistOnUITree) {
 61 |         MediaControlButtonsContent(
 62 |             modifier = Modifier
 63 |                 .alpha(appearAlpha.value)
 64 |                 .background(Color.Black.copy(alpha = appearAlpha.value * 0.6f))
 65 |                 .then(modifier)
 66 |         )
 67 |     }
 68 | }
 69 | 
 70 | @Composable
 71 | private fun MediaControlButtonsContent(modifier: Modifier = Modifier) {
 72 |     val controller = LocalVideoPlayerController.current
 73 | 
 74 |     Box(modifier = modifier) {
 75 |         Box(modifier = Modifier
 76 |             .fillMaxSize()
 77 |             .clickable(
 78 |                 indication = null,
 79 |                 interactionSource = remember { MutableInteractionSource() }
 80 |             ) {
 81 |                 controller.hideControls()
 82 |             })
 83 |         PositionAndDurationNumbers(modifier = Modifier.align(Alignment.BottomCenter))
 84 |         PlayPauseButton(modifier = Modifier.align(Alignment.Center))
 85 |     }
 86 | }
 87 | 
 88 | @Composable
 89 | fun PositionAndDurationNumbers(
 90 |     modifier: Modifier = Modifier
 91 | ) {
 92 |     val controller = LocalVideoPlayerController.current
 93 | 
 94 |     val positionText by controller.collect {
 95 |         getDurationString(currentPosition, false)
 96 |     }
 97 |     val remainingDurationText by controller.collect {
 98 |         getDurationString(duration - currentPosition, false)
 99 |     }
100 | 
101 |     Row(
102 |         modifier = modifier
103 |             .fillMaxWidth()
104 |             .padding(4.dp)
105 |     ) {
106 |         Text(
107 |             positionText,
108 |             style = TextStyle(
109 |                 shadow = Shadow(
110 |                     blurRadius = 8f,
111 |                     offset = Offset(2f, 2f)
112 |                 )
113 |             )
114 |         )
115 |         Box(modifier = Modifier.weight(1f))
116 |         Text(
117 |             remainingDurationText,
118 |             style = TextStyle(
119 |                 shadow = Shadow(
120 |                     blurRadius = 8f,
121 |                     offset = Offset(2f, 2f)
122 |                 )
123 |             )
124 |         )
125 |     }
126 | }
127 | 
128 | @Composable
129 | fun PlayPauseButton(modifier: Modifier = Modifier) {
130 |     val controller = LocalVideoPlayerController.current
131 | 
132 |     val isPlaying by controller.collect { isPlaying }
133 |     val playbackState by controller.collect { playbackState }
134 | 
135 |     IconButton(
136 |         onClick = { controller.playPauseToggle() },
137 |         modifier = modifier
138 |     ) {
139 |         if (isPlaying) {
140 |             ShadowedIcon(icon = Icons.Filled.Pause)
141 |         } else {
142 |             when (playbackState) {
143 |                 PlaybackState.ENDED -> {
144 |                     ShadowedIcon(icon = Icons.Filled.Restore)
145 |                 }
146 |                 PlaybackState.BUFFERING -> {
147 |                     CircularProgressIndicator()
148 |                 }
149 |                 else -> {
150 |                     ShadowedIcon(icon = Icons.Filled.PlayArrow)
151 |                 }
152 |             }
153 |         }
154 |     }
155 | }


--------------------------------------------------------------------------------
/dotsandlines/src/main/java/com/halilibo/dotsandlines/DotsAndLinesModifier.kt:
--------------------------------------------------------------------------------
  1 | package com.halilibo.dotsandlines
  2 | 
  3 | import androidx.compose.foundation.gestures.detectDragGestures
  4 | import androidx.compose.runtime.Immutable
  5 | import androidx.compose.runtime.LaunchedEffect
  6 | import androidx.compose.runtime.getValue
  7 | import androidx.compose.runtime.mutableStateOf
  8 | import androidx.compose.runtime.remember
  9 | import androidx.compose.runtime.setValue
 10 | import androidx.compose.ui.Modifier
 11 | import androidx.compose.ui.composed
 12 | import androidx.compose.ui.draw.drawBehind
 13 | import androidx.compose.ui.geometry.Offset
 14 | import androidx.compose.ui.graphics.Color
 15 | import androidx.compose.ui.input.pointer.pointerInput
 16 | import androidx.compose.ui.layout.onSizeChanged
 17 | import androidx.compose.ui.unit.IntSize
 18 | import com.halilibo.dotsandlines.Dot.Companion.distanceTo
 19 | import com.halilibo.dotsandlines.DotsAndLinesState.Companion.next
 20 | import com.halilibo.dotsandlines.DotsAndLinesState.Companion.populationControl
 21 | import com.halilibo.dotsandlines.DotsAndLinesState.Companion.sizeChanged
 22 | import kotlinx.coroutines.android.awaitFrame
 23 | import kotlinx.coroutines.isActive
 24 | import kotlin.math.pow
 25 | import kotlin.math.sqrt
 26 | 
 27 | fun Modifier.dotsAndLines(
 28 |     contentColor: Color = Color.White,
 29 |     threshold: Float,
 30 |     maxThickness: Float,
 31 |     dotRadius: Float,
 32 |     speed: Float,
 33 |     populationFactor: Float
 34 | ) = this.composed {
 35 |     val dotsAndLinesModel = remember {
 36 |         DotsAndLinesModel(
 37 |             DotsAndLinesState(
 38 |                 dotRadius = dotRadius,
 39 |                 speed = speed
 40 |             )
 41 |         )
 42 |     }
 43 | 
 44 |     LaunchedEffect(speed, dotRadius, populationFactor) {
 45 |         dotsAndLinesModel.populationControl(speed, dotRadius, populationFactor)
 46 |     }
 47 | 
 48 |     LaunchedEffect(Unit) {
 49 |         var lastFrame = 0L
 50 |         while (isActive) {
 51 |             val nextFrame = awaitFrame() / 100_000L
 52 |             if (lastFrame != 0L) {
 53 |                 val period = nextFrame - lastFrame
 54 |                 dotsAndLinesModel.next(period)
 55 |             }
 56 |             lastFrame = nextFrame
 57 |         }
 58 |     }
 59 | 
 60 |     pointerInput(Unit) {
 61 |         detectDragGestures(
 62 |             onDragStart = { offset ->
 63 |                 dotsAndLinesModel.pointerDown(offset)
 64 |             },
 65 |             onDragEnd = {
 66 |                 dotsAndLinesModel.pointerUp()
 67 |             },
 68 |             onDragCancel = {
 69 |                 dotsAndLinesModel.pointerUp()
 70 |             },
 71 |             onDrag = { change, dragAmount ->
 72 |                 dotsAndLinesModel.pointerMove(dragAmount)
 73 |                 change.consume()
 74 |             }
 75 |         )
 76 |     }
 77 |         .onSizeChanged {
 78 |             dotsAndLinesModel.sizeChanged(it, populationFactor)
 79 |         }
 80 |         .drawBehind {
 81 |             val allDots = with(dotsAndLinesModel.dotsAndLinesState) { (dots + pointer).filterNotNull() }
 82 | 
 83 |             allDots.forEach {
 84 |                 drawCircle(contentColor, radius = dotRadius, center = it.position)
 85 |             }
 86 | 
 87 |             val realThreshold = threshold * sqrt(size.width.pow(2) + size.height.pow(2))
 88 | 
 89 |             allDots.nestedForEach { first, second ->
 90 |                 val distance = first distanceTo second
 91 | 
 92 |                 if (distance <= realThreshold) {
 93 |                     drawLine(
 94 |                         contentColor,
 95 |                         first.position,
 96 |                         second.position,
 97 |                         0.5f + (realThreshold - distance) * maxThickness / realThreshold
 98 |                     )
 99 |                 }
100 |             }
101 |         }
102 | }
103 | 
104 | @Immutable
105 | class DotsAndLinesModel(
106 |     initialDotsAndLinesState: DotsAndLinesState
107 | ) {
108 |     var dotsAndLinesState by mutableStateOf(initialDotsAndLinesState)
109 | 
110 |     fun populationControl(
111 |         speed: Float,
112 |         dotRadius: Float,
113 |         populationFactor: Float
114 |     ) {
115 |         dotsAndLinesState = dotsAndLinesState.copy(
116 |             speed = speed,
117 |             dotRadius = dotRadius
118 |         ).populationControl(populationFactor)
119 |     }
120 | 
121 |     fun next(period: Long) {
122 |         dotsAndLinesState = dotsAndLinesState.next(period)
123 |     }
124 | 
125 |     fun sizeChanged(size: IntSize, populationFactor: Float) {
126 |         dotsAndLinesState = dotsAndLinesState.sizeChanged(
127 |             size = size,
128 |             populationFactor = populationFactor
129 |         )
130 |     }
131 | 
132 |     fun pointerDown(offset: Offset) {
133 |         dotsAndLinesState = dotsAndLinesState.copy(
134 |             pointer = Dot(
135 |                 position = offset,
136 |                 vector = Offset.Zero
137 |             )
138 |         )
139 |     }
140 | 
141 |     fun pointerMove(offset: Offset) {
142 |         val currentPointer = dotsAndLinesState.pointer ?: return
143 | 
144 |         dotsAndLinesState = dotsAndLinesState.copy(
145 |             pointer = dotsAndLinesState.pointer?.copy(
146 |                 position = currentPointer.position + offset,
147 |                 vector = Offset.Zero
148 |             )
149 |         )
150 |     }
151 | 
152 |     fun pointerUp() {
153 |         dotsAndLinesState = dotsAndLinesState.copy(pointer = null)
154 |     }
155 | }
156 | 
157 | private fun <T> List<T>.nestedForEach(block: (T, T) -> Unit) {
158 |     for (i in this.indices) {
159 |         for (j in i + 1 until this.size) {
160 |             block(this[i], this[j])
161 |         }
162 |     }
163 | }


--------------------------------------------------------------------------------
/app/src/main/java/com/halilibo/madewithcompose/dotsandlines/DotsAndLinesDemo.kt:
--------------------------------------------------------------------------------
  1 | package com.halilibo.madewithcompose.dotsandlines
  2 | 
  3 | 
  4 | import android.os.Parcelable
  5 | import androidx.compose.foundation.background
  6 | import androidx.compose.foundation.layout.*
  7 | import androidx.compose.material.*
  8 | import androidx.compose.runtime.*
  9 | import androidx.compose.runtime.saveable.rememberSaveable
 10 | import androidx.compose.ui.Alignment
 11 | import androidx.compose.ui.Modifier
 12 | import androidx.compose.ui.unit.dp
 13 | import com.halilibo.dotsandlines.dotsAndLines
 14 | import kotlinx.parcelize.Parcelize
 15 | import kotlinx.coroutines.launch
 16 | 
 17 | @OptIn(ExperimentalMaterialApi::class)
 18 | @Composable
 19 | fun DotsAndLinesDemo() {
 20 |     var dotsAndLinesConfig by rememberSaveable { mutableStateOf(DotsAndLinesConfig()) }
 21 |     val scaffoldState = rememberBottomSheetScaffoldState()
 22 |     val coroutineScope = rememberCoroutineScope()
 23 |     BottomSheetScaffold(
 24 |         scaffoldState = scaffoldState,
 25 |         sheetPeekHeight = 0.dp,
 26 |         sheetBackgroundColor = MaterialTheme.colors.surface.copy(alpha = 0.5f),
 27 |         sheetContentColor = MaterialTheme.colors.onSurface,
 28 |         sheetElevation = 0.dp,
 29 |         sheetGesturesEnabled = false,
 30 |         sheetContent = {
 31 |             DotsAndLinesSliderRow(
 32 |                 title = "Connectivity",
 33 |                 value = dotsAndLinesConfig.threshold,
 34 |                 valueRange = 0f..0.2f,
 35 |                 onValueChanged = {
 36 |                     dotsAndLinesConfig = dotsAndLinesConfig.copy(threshold = it)
 37 |                 }
 38 |             )
 39 |             DotsAndLinesSliderRow(
 40 |                 title = "Line Thickness",
 41 |                 value = dotsAndLinesConfig.maxThickness,
 42 |                 valueRange = 2f..20f,
 43 |                 onValueChanged = {
 44 |                     dotsAndLinesConfig = dotsAndLinesConfig.copy(maxThickness = it)
 45 |                 }
 46 |             )
 47 |             DotsAndLinesSliderRow(
 48 |                 title = "Dot Size",
 49 |                 value = dotsAndLinesConfig.dotRadius,
 50 |                 valueRange = 2f..20f,
 51 |                 onValueChanged = {
 52 |                     dotsAndLinesConfig = dotsAndLinesConfig.copy(dotRadius = it)
 53 |                 }
 54 |             )
 55 |             DotsAndLinesSliderRow(
 56 |                 title = "Speed",
 57 |                 value = dotsAndLinesConfig.speedCoefficient,
 58 |                 valueRange = 0.001f..0.1f,
 59 |                 onValueChanged = {
 60 |                     dotsAndLinesConfig = dotsAndLinesConfig.copy(speedCoefficient = it)
 61 |                 }
 62 |             )
 63 |             DotsAndLinesSliderRow(
 64 |                 title = "Density",
 65 |                 value = dotsAndLinesConfig.population,
 66 |                 valueRange = 0.1f..2f,
 67 |                 onValueChanged = {
 68 |                     dotsAndLinesConfig = dotsAndLinesConfig.copy(population = it)
 69 |                 }
 70 |             )
 71 |             Row(
 72 |                 modifier = Modifier.fillMaxWidth(),
 73 |                 horizontalArrangement = Arrangement.End
 74 |             ) {
 75 |                 Button(
 76 |                     onClick = { coroutineScope.launch { scaffoldState.bottomSheetState.collapse() } },
 77 |                     modifier = Modifier
 78 |                         .padding(8.dp)
 79 |                 ) {
 80 |                     Text("Done")
 81 |                 }
 82 |             }
 83 |         }
 84 |     ) {
 85 |         with(dotsAndLinesConfig) {
 86 |             Box(
 87 |                 modifier = Modifier
 88 |                     .fillMaxSize()
 89 |                     .background(MaterialTheme.colors.surface)
 90 |                     .dotsAndLines(
 91 |                         contentColor = MaterialTheme.colors.onSurface,
 92 |                         threshold = threshold,
 93 |                         maxThickness = maxThickness,
 94 |                         dotRadius = dotRadius,
 95 |                         speed = speedCoefficient,
 96 |                         populationFactor = population
 97 |                     )
 98 |             ) {
 99 |                 if (scaffoldState.bottomSheetState.isCollapsed && !scaffoldState.bottomSheetState.isAnimationRunning) {
100 |                     Button(
101 |                         onClick = { coroutineScope.launch { scaffoldState.bottomSheetState.expand() } },
102 |                         modifier = Modifier
103 |                             .align(Alignment.BottomEnd)
104 |                             .padding(8.dp)
105 |                     ) {
106 |                         Text("Options")
107 |                     }
108 |                 }
109 |             }
110 |         }
111 |     }
112 | }
113 | 
114 | @Composable
115 | fun DotsAndLinesSliderRow(
116 |     title: String,
117 |     value: Float,
118 |     valueRange: ClosedFloatingPointRange<Float>,
119 |     onValueChanged: (Float) -> Unit
120 | ) {
121 |     Column(modifier = Modifier.padding(horizontal = 8.dp)) {
122 |         Text("$title: $value")
123 |         Slider(
124 |             value = value,
125 |             valueRange = valueRange,
126 |             onValueChange = onValueChanged
127 |         )
128 |     }
129 | }
130 | 
131 | @Parcelize
132 | data class DotsAndLinesConfig(
133 |     val threshold: Float = 0.06f,
134 |     val maxThickness: Float = 6f,
135 |     val dotRadius: Float = 4f,
136 |     val speedCoefficient: Float = 0.05f,
137 |     val population: Float = 0.3f // per 100^2 pixels
138 | ) : Parcelable
139 | 
140 | 
141 | @OptIn(ExperimentalMaterialApi::class)
142 | val BottomSheetState.isAnimationRunning: Boolean
143 |     @OptIn(ExperimentalMaterialApi::class)
144 |     get() = targetValue != currentValue


--------------------------------------------------------------------------------
/schedulecalendar/src/main/java/com/halilibo/schedulecalendar/ScheduleCalendarState.kt:
--------------------------------------------------------------------------------
  1 | package com.halilibo.schedulecalendar
  2 | 
  3 | import androidx.compose.animation.core.*
  4 | import androidx.compose.foundation.gestures.FlingBehavior
  5 | import androidx.compose.foundation.gestures.ScrollScope
  6 | import androidx.compose.foundation.gestures.ScrollableState
  7 | import androidx.compose.runtime.*
  8 | import kotlinx.coroutines.CoroutineScope
  9 | import kotlinx.coroutines.launch
 10 | import java.time.LocalDateTime
 11 | import java.time.temporal.ChronoUnit
 12 | import kotlin.math.abs
 13 | import kotlin.math.roundToLong
 14 | 
 15 | @Composable
 16 | fun rememberScheduleCalendarState(
 17 |     referenceDateTime: LocalDateTime = LocalDateTime.now().truncatedTo(ChronoUnit.DAYS),
 18 |     onDateTimeSelected: (LocalDateTime) -> Unit = {}
 19 | ): ScheduleCalendarState {
 20 |     val coroutineScope = rememberCoroutineScope()
 21 |     return remember(coroutineScope) {
 22 |         ScheduleCalendarState(
 23 |             referenceDateTime = referenceDateTime,
 24 |             onDateTimeSelected = onDateTimeSelected,
 25 |             coroutineScope = coroutineScope,
 26 |         )
 27 |     }
 28 | }
 29 | 
 30 | class ScheduleCalendarState(
 31 |     referenceDateTime: LocalDateTime,
 32 |     private val onDateTimeSelected: (LocalDateTime) -> Unit,
 33 |     private val coroutineScope: CoroutineScope
 34 | ) {
 35 |     val startDateTime: LocalDateTime by derivedStateOf {
 36 |         referenceDateTime.plusSeconds(secondsOffset.value)
 37 |     }
 38 | 
 39 |     val endDateTime: LocalDateTime by derivedStateOf {
 40 |         startDateTime.plusSeconds(this.viewSpanSeconds.value)
 41 |     }
 42 | 
 43 |     private val viewSpanSeconds = Animatable(ChronoUnit.DAYS.duration.seconds, LongToVector)
 44 |     private val secondsOffset = Animatable(0L, LongToVector)
 45 |     private val width = mutableStateOf(1)
 46 | 
 47 |     internal fun updateView(newViewSpanSeconds: Long, newWidth: Int) {
 48 |         this.width.value = newWidth
 49 |         val currentViewSpanSeconds = viewSpanSeconds.value
 50 |         coroutineScope.launch {
 51 |             viewSpanSeconds.animateTo(newViewSpanSeconds)
 52 |         }
 53 |         coroutineScope.launch {
 54 |             if (newViewSpanSeconds != currentViewSpanSeconds) {
 55 |                 updateAnchors(newViewSpanSeconds)
 56 |             }
 57 |         }
 58 |     }
 59 | 
 60 |     internal val scrollableState = ScrollableState {
 61 |         coroutineScope.launch {
 62 |             secondsOffset.snapTo(secondsOffset.value - it.toSeconds())
 63 |         }
 64 |         it
 65 |     }
 66 | 
 67 |     private val secondsInPx by derivedStateOf {
 68 |         this.viewSpanSeconds.value.toFloat() / width.value.toFloat()
 69 |     }
 70 | 
 71 |     private fun Float.toSeconds(): Long {
 72 |         return (this * secondsInPx).roundToLong()
 73 |     }
 74 | 
 75 |     private fun Long.toPx(): Float {
 76 |         return this / secondsInPx
 77 |     }
 78 | 
 79 |     internal val scrollFlingBehavior = object : FlingBehavior {
 80 |         val decay = exponentialDecay<Float>(frictionMultiplier = 2f)
 81 |         override suspend fun ScrollScope.performFling(initialVelocity: Float): Float {
 82 |             val endPosition = decay.calculateTargetValue(0f, -initialVelocity)
 83 |             flingToNearestAnchor(secondsOffset.value.toPx() + endPosition)
 84 |             return 0f
 85 |         }
 86 |     }
 87 | 
 88 |     internal val visibleHours by derivedStateOf {
 89 |         val startHour = startDateTime.truncatedTo(ChronoUnit.HOURS)
 90 |         val endHour = endDateTime.truncatedTo(ChronoUnit.HOURS).plusHours(1)
 91 | 
 92 |         startHour.between(endHour) { plusHours(1L) }.filter {
 93 |             it.hour % (anchorRangeSeconds / 3600) == 0L && it.hour != 0
 94 |         }.toList()
 95 |     }
 96 | 
 97 |     private var anchorRangeSeconds by mutableStateOf(Long.MAX_VALUE)
 98 |     private var anchorRangePx by mutableStateOf(Float.MAX_VALUE)
 99 |     private suspend fun updateAnchors(viewSpanInSeconds: Long) {
100 |         anchorRangeSeconds = when(viewSpanInSeconds) {
101 |             in (24*3600L+1..Long.MAX_VALUE) -> 24 * 3600L
102 |             in (12*3600L+1..24*3600L) -> 6 * 3600L
103 |             in (6*3600L+1..12*3600L) -> 3 * 3600L
104 |             in (3*3600L+1..6*3600L) -> 2 * 3600L
105 |             else -> 3600L
106 |         }
107 |         anchorRangePx = anchorRangeSeconds.toPx()
108 |         flingToNearestAnchor(secondsOffset.value.toPx())
109 |     }
110 | 
111 |     private suspend fun flingToNearestAnchor(target: Float) {
112 |         val nearestAnchor = target - (target.absRem(anchorRangePx))
113 |         val nearestAnchor2 = nearestAnchor + anchorRangePx
114 | 
115 |         val newAnchoredPosition = (abs(target - nearestAnchor) to abs(target - nearestAnchor2)).let {
116 |             if (it.first > it.second) nearestAnchor2 else nearestAnchor
117 |         }
118 |         secondsOffset.animateTo(newAnchoredPosition.toSeconds())
119 |         onDateTimeSelected(startDateTime)
120 |     }
121 | 
122 |     internal fun offsetFraction(localDateTime: LocalDateTime): Float {
123 |         return ChronoUnit.SECONDS.between(startDateTime, localDateTime).toFloat() / (viewSpanSeconds.value).toFloat()
124 |     }
125 | 
126 |     internal fun widthAndOffsetForEvent(
127 |         start: LocalDateTime, end: LocalDateTime, totalWidth: Int
128 |     ): Pair<Int, Int> {
129 |         val startOffsetPercent = offsetFraction(start).coerceIn(0f, 1f)
130 |         val endOffsetPercent = offsetFraction(end).coerceIn(0f, 1f)
131 | 
132 |         val width = ((endOffsetPercent - startOffsetPercent) * totalWidth).toInt() + 1
133 |         val offsetX = (startOffsetPercent * totalWidth).toInt()
134 |         return width to offsetX
135 |     }
136 | }
137 | 
138 | private val LongToVector: TwoWayConverter<Long, AnimationVector1D> =
139 |     TwoWayConverter({ AnimationVector1D(it.toFloat()) }, { it.value.toLong() })
140 | 
141 | private fun Float.absRem(modular: Float): Float {
142 |     return ((this % modular) + modular) % modular
143 | }


--------------------------------------------------------------------------------
/gradlew:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env sh
  2 | 
  3 | ##############################################################################
  4 | ##
  5 | ##  Gradle start up script for UN*X
  6 | ##
  7 | ##############################################################################
  8 | 
  9 | # Attempt to set APP_HOME
 10 | # Resolve links: $0 may be a link
 11 | PRG="$0"
 12 | # Need this for relative symlinks.
 13 | while [ -h "$PRG" ] ; do
 14 |     ls=`ls -ld "$PRG"`
 15 |     link=`expr "$ls" : '.*-> \(.*\)$'`
 16 |     if expr "$link" : '/.*' > /dev/null; then
 17 |         PRG="$link"
 18 |     else
 19 |         PRG=`dirname "$PRG"`"/$link"
 20 |     fi
 21 | done
 22 | SAVED="`pwd`"
 23 | cd "`dirname \"$PRG\"`/" >/dev/null
 24 | APP_HOME="`pwd -P`"
 25 | cd "$SAVED" >/dev/null
 26 | 
 27 | APP_NAME="Gradle"
 28 | APP_BASE_NAME=`basename "$0"`
 29 | 
 30 | # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
 31 | DEFAULT_JVM_OPTS=""
 32 | 
 33 | # Use the maximum available, or set MAX_FD != -1 to use that value.
 34 | MAX_FD="maximum"
 35 | 
 36 | warn () {
 37 |     echo "$*"
 38 | }
 39 | 
 40 | die () {
 41 |     echo
 42 |     echo "$*"
 43 |     echo
 44 |     exit 1
 45 | }
 46 | 
 47 | # OS specific support (must be 'true' or 'false').
 48 | cygwin=false
 49 | msys=false
 50 | darwin=false
 51 | nonstop=false
 52 | case "`uname`" in
 53 |   CYGWIN* )
 54 |     cygwin=true
 55 |     ;;
 56 |   Darwin* )
 57 |     darwin=true
 58 |     ;;
 59 |   MINGW* )
 60 |     msys=true
 61 |     ;;
 62 |   NONSTOP* )
 63 |     nonstop=true
 64 |     ;;
 65 | esac
 66 | 
 67 | CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 68 | 
 69 | # Determine the Java command to use to start the JVM.
 70 | if [ -n "$JAVA_HOME" ] ; then
 71 |     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
 72 |         # IBM's JDK on AIX uses strange locations for the executables
 73 |         JAVACMD="$JAVA_HOME/jre/sh/java"
 74 |     else
 75 |         JAVACMD="$JAVA_HOME/bin/java"
 76 |     fi
 77 |     if [ ! -x "$JAVACMD" ] ; then
 78 |         die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
 79 | 
 80 | Please set the JAVA_HOME variable in your environment to match the
 81 | location of your Java installation."
 82 |     fi
 83 | else
 84 |     JAVACMD="java"
 85 |     which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
 86 | 
 87 | Please set the JAVA_HOME variable in your environment to match the
 88 | location of your Java installation."
 89 | fi
 90 | 
 91 | # Increase the maximum file descriptors if we can.
 92 | if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
 93 |     MAX_FD_LIMIT=`ulimit -H -n`
 94 |     if [ $? -eq 0 ] ; then
 95 |         if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
 96 |             MAX_FD="$MAX_FD_LIMIT"
 97 |         fi
 98 |         ulimit -n $MAX_FD
 99 |         if [ $? -ne 0 ] ; then
100 |             warn "Could not set maximum file descriptor limit: $MAX_FD"
101 |         fi
102 |     else
103 |         warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
104 |     fi
105 | fi
106 | 
107 | # For Darwin, add options to specify how the application appears in the dock
108 | if $darwin; then
109 |     GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
110 | fi
111 | 
112 | # For Cygwin, switch paths to Windows format before running java
113 | if $cygwin ; then
114 |     APP_HOME=`cygpath --path --mixed "$APP_HOME"`
115 |     CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
116 |     JAVACMD=`cygpath --unix "$JAVACMD"`
117 | 
118 |     # We build the pattern for arguments to be converted via cygpath
119 |     ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
120 |     SEP=""
121 |     for dir in $ROOTDIRSRAW ; do
122 |         ROOTDIRS="$ROOTDIRS$SEP$dir"
123 |         SEP="|"
124 |     done
125 |     OURCYGPATTERN="(^($ROOTDIRS))"
126 |     # Add a user-defined pattern to the cygpath arguments
127 |     if [ "$GRADLE_CYGPATTERN" != "" ] ; then
128 |         OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
129 |     fi
130 |     # Now convert the arguments - kludge to limit ourselves to /bin/sh
131 |     i=0
132 |     for arg in "$@" ; do
133 |         CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
134 |         CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
135 | 
136 |         if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
137 |             eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
138 |         else
139 |             eval `echo args$i`="\"$arg\""
140 |         fi
141 |         i=$((i+1))
142 |     done
143 |     case $i in
144 |         (0) set -- ;;
145 |         (1) set -- "$args0" ;;
146 |         (2) set -- "$args0" "$args1" ;;
147 |         (3) set -- "$args0" "$args1" "$args2" ;;
148 |         (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
149 |         (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
150 |         (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
151 |         (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
152 |         (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
153 |         (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
154 |     esac
155 | fi
156 | 
157 | # Escape application args
158 | save () {
159 |     for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
160 |     echo " "
161 | }
162 | APP_ARGS=$(save "$@")
163 | 
164 | # Collect all arguments for the java command, following the shell quoting and substitution rules
165 | eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
166 | 
167 | # by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
168 | if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
169 |   cd "$(dirname "$0")"
170 | fi
171 | 
172 | exec "$JAVACMD" "$@"
173 | 


--------------------------------------------------------------------------------
/app/src/main/java/com/halilibo/madewithcompose/markdowneditor/MarkdownPreview.kt:
--------------------------------------------------------------------------------
  1 | package com.halilibo.madewithcompose.markdowneditor
  2 | 
  3 | import android.content.Context
  4 | import android.content.Intent
  5 | import android.graphics.Bitmap
  6 | import android.net.Uri
  7 | import android.util.Log
  8 | import androidx.compose.foundation.background
  9 | import androidx.compose.foundation.clickable
 10 | import androidx.compose.foundation.layout.Arrangement
 11 | import androidx.compose.foundation.layout.Column
 12 | import androidx.compose.foundation.layout.Row
 13 | import androidx.compose.foundation.layout.Spacer
 14 | import androidx.compose.foundation.layout.fillMaxSize
 15 | import androidx.compose.foundation.layout.fillMaxWidth
 16 | import androidx.compose.foundation.layout.padding
 17 | import androidx.compose.foundation.layout.width
 18 | import androidx.compose.foundation.rememberScrollState
 19 | import androidx.compose.foundation.shape.RoundedCornerShape
 20 | import androidx.compose.foundation.verticalScroll
 21 | import androidx.compose.material.Button
 22 | import androidx.compose.material.Icon
 23 | import androidx.compose.material.MaterialTheme
 24 | import androidx.compose.material.Text
 25 | import androidx.compose.material.icons.Icons
 26 | import androidx.compose.material.icons.filled.Share
 27 | import androidx.compose.runtime.Composable
 28 | import androidx.compose.runtime.getValue
 29 | import androidx.compose.runtime.mutableStateOf
 30 | import androidx.compose.runtime.remember
 31 | import androidx.compose.runtime.rememberCoroutineScope
 32 | import androidx.compose.runtime.setValue
 33 | import androidx.compose.ui.Alignment
 34 | import androidx.compose.ui.Modifier
 35 | import androidx.compose.ui.graphics.asAndroidBitmap
 36 | import androidx.compose.ui.platform.LocalContext
 37 | import androidx.compose.ui.text.font.FontWeight
 38 | import androidx.compose.ui.unit.dp
 39 | import androidx.compose.ui.unit.sp
 40 | import androidx.core.content.FileProvider
 41 | import com.halilibo.richtext.markdown.Markdown
 42 | import com.halilibo.richtext.ui.CodeBlockStyle
 43 | import com.halilibo.richtext.ui.RichTextStyle
 44 | import com.halilibo.richtext.ui.material.MaterialRichText
 45 | import com.halilibo.screenshot.ScreenshotController
 46 | import com.halilibo.screenshot.screenshot
 47 | import kotlinx.coroutines.Dispatchers
 48 | import kotlinx.coroutines.launch
 49 | import kotlinx.coroutines.withContext
 50 | import java.io.File
 51 | import java.io.FileOutputStream
 52 | import java.io.IOException
 53 | 
 54 | @Composable
 55 | fun MarkdownPreview(
 56 |   content: CharSequence,
 57 |   modifier: Modifier = Modifier,
 58 |   onPreviewClick: () -> Unit
 59 | ) {
 60 |   val context = LocalContext.current
 61 |   val coroutineScope = rememberCoroutineScope()
 62 |   val screenshotController = remember { ScreenshotController() }
 63 |   val backgroundColor = MaterialTheme.colors.surface
 64 | 
 65 |   Column(modifier) {
 66 |     Row(
 67 |       modifier = Modifier
 68 |         .fillMaxWidth()
 69 |         .padding(8.dp),
 70 |       horizontalArrangement = Arrangement.Center
 71 |     ) {
 72 |       Text(
 73 |         text = "PREVIEW",
 74 |         letterSpacing = 8.sp,
 75 |         fontSize = 12.sp,
 76 |         fontWeight = FontWeight.Bold,
 77 |         color = MaterialTheme.colors.onPrimary,
 78 |         modifier = Modifier
 79 |           .background(MaterialTheme.colors.primary, shape = RoundedCornerShape(4.dp))
 80 |           .clickable { onPreviewClick() }
 81 |           .padding(4.dp)
 82 |       )
 83 |     }
 84 |     Column(
 85 |       modifier = Modifier.fillMaxSize()
 86 |     ) {
 87 |       // Scrollable Markdown
 88 |       Column(
 89 |         Modifier
 90 |           .weight(1f)
 91 |           .verticalScroll(rememberScrollState())) {
 92 |         MaterialRichText(
 93 |           style = RichTextStyle(codeBlockStyle = CodeBlockStyle(wordWrap = false)),
 94 |           modifier = Modifier
 95 |             .screenshot(screenshotController)
 96 |             .padding(8.dp)
 97 |         ) {
 98 |           Markdown(content = content.toString())
 99 |         }
100 |       }
101 | 
102 |       var isButtonEnabled by remember { mutableStateOf(true) }
103 | 
104 |       Button(
105 |         enabled = isButtonEnabled,
106 |         modifier = Modifier
107 |           .align(Alignment.End)
108 |           .padding(8.dp), onClick = {
109 |           coroutineScope.launch {
110 |             isButtonEnabled = false
111 | 
112 |             val bitmap = screenshotController
113 |               .drawWithScreenshot {
114 |                 drawRect(backgroundColor)
115 |                 it()
116 |               }
117 |               .asAndroidBitmap()
118 | 
119 |             saveImage(bitmap, context)?.shareImage(context)
120 | 
121 |             isButtonEnabled = true
122 |           }
123 |         }) {
124 |         Icon(imageVector = Icons.Default.Share, contentDescription = "share")
125 |         Spacer(modifier = Modifier.width(8.dp))
126 |         Text(text = "Share")
127 |       }
128 |     }
129 |   }
130 | }
131 | 
132 | /**
133 |  * Saves the image as PNG to the app's cache directory.
134 |  * @param image Bitmap to save.
135 |  * @return Uri of the saved file or null
136 |  */
137 | private suspend fun saveImage(image: Bitmap, context: Context): Uri? = withContext(Dispatchers.IO) {
138 |   val imagesFolder = File(context.cacheDir, "images")
139 |   var uri: Uri? = null
140 |   try {
141 |     imagesFolder.mkdirs()
142 |     val file = File(imagesFolder, "shared_image.png")
143 |     val stream = FileOutputStream(file)
144 |     image.compress(Bitmap.CompressFormat.PNG, 90, stream)
145 |     stream.flush()
146 |     stream.close()
147 |     uri = FileProvider.getUriForFile(context, "com.halilibo.fileprovider", file)
148 |   } catch (e: IOException) {
149 |     Log.d("MarkdownPreview", "IOException while trying to write file for sharing: " + e.message)
150 |   }
151 |   uri
152 | }
153 | 
154 | /**
155 |  * Shares the PNG image from [this] Uri.
156 |  */
157 | private fun Uri.shareImage(context: Context) {
158 |   val intent = Intent(Intent.ACTION_SEND)
159 |   intent.putExtra(Intent.EXTRA_STREAM, this)
160 |   intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
161 |   intent.type = "image/png"
162 |   context.startActivity(intent)
163 | }
164 | 


--------------------------------------------------------------------------------
/app/src/main/res/drawable/ic_launcher_background.xml:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <vector xmlns:android="http://schemas.android.com/apk/res/android"
  3 |     android:width="108dp"
  4 |     android:height="108dp"
  5 |     android:viewportWidth="108"
  6 |     android:viewportHeight="108">
  7 |     <path
  8 |         android:fillColor="#3DDC84"
  9 |         android:pathData="M0,0h108v108h-108z" />
 10 |     <path
 11 |         android:fillColor="#00000000"
 12 |         android:pathData="M9,0L9,108"
 13 |         android:strokeWidth="0.8"
 14 |         android:strokeColor="#33FFFFFF" />
 15 |     <path
 16 |         android:fillColor="#00000000"
 17 |         android:pathData="M19,0L19,108"
 18 |         android:strokeWidth="0.8"
 19 |         android:strokeColor="#33FFFFFF" />
 20 |     <path
 21 |         android:fillColor="#00000000"
 22 |         android:pathData="M29,0L29,108"
 23 |         android:strokeWidth="0.8"
 24 |         android:strokeColor="#33FFFFFF" />
 25 |     <path
 26 |         android:fillColor="#00000000"
 27 |         android:pathData="M39,0L39,108"
 28 |         android:strokeWidth="0.8"
 29 |         android:strokeColor="#33FFFFFF" />
 30 |     <path
 31 |         android:fillColor="#00000000"
 32 |         android:pathData="M49,0L49,108"
 33 |         android:strokeWidth="0.8"
 34 |         android:strokeColor="#33FFFFFF" />
 35 |     <path
 36 |         android:fillColor="#00000000"
 37 |         android:pathData="M59,0L59,108"
 38 |         android:strokeWidth="0.8"
 39 |         android:strokeColor="#33FFFFFF" />
 40 |     <path
 41 |         android:fillColor="#00000000"
 42 |         android:pathData="M69,0L69,108"
 43 |         android:strokeWidth="0.8"
 44 |         android:strokeColor="#33FFFFFF" />
 45 |     <path
 46 |         android:fillColor="#00000000"
 47 |         android:pathData="M79,0L79,108"
 48 |         android:strokeWidth="0.8"
 49 |         android:strokeColor="#33FFFFFF" />
 50 |     <path
 51 |         android:fillColor="#00000000"
 52 |         android:pathData="M89,0L89,108"
 53 |         android:strokeWidth="0.8"
 54 |         android:strokeColor="#33FFFFFF" />
 55 |     <path
 56 |         android:fillColor="#00000000"
 57 |         android:pathData="M99,0L99,108"
 58 |         android:strokeWidth="0.8"
 59 |         android:strokeColor="#33FFFFFF" />
 60 |     <path
 61 |         android:fillColor="#00000000"
 62 |         android:pathData="M0,9L108,9"
 63 |         android:strokeWidth="0.8"
 64 |         android:strokeColor="#33FFFFFF" />
 65 |     <path
 66 |         android:fillColor="#00000000"
 67 |         android:pathData="M0,19L108,19"
 68 |         android:strokeWidth="0.8"
 69 |         android:strokeColor="#33FFFFFF" />
 70 |     <path
 71 |         android:fillColor="#00000000"
 72 |         android:pathData="M0,29L108,29"
 73 |         android:strokeWidth="0.8"
 74 |         android:strokeColor="#33FFFFFF" />
 75 |     <path
 76 |         android:fillColor="#00000000"
 77 |         android:pathData="M0,39L108,39"
 78 |         android:strokeWidth="0.8"
 79 |         android:strokeColor="#33FFFFFF" />
 80 |     <path
 81 |         android:fillColor="#00000000"
 82 |         android:pathData="M0,49L108,49"
 83 |         android:strokeWidth="0.8"
 84 |         android:strokeColor="#33FFFFFF" />
 85 |     <path
 86 |         android:fillColor="#00000000"
 87 |         android:pathData="M0,59L108,59"
 88 |         android:strokeWidth="0.8"
 89 |         android:strokeColor="#33FFFFFF" />
 90 |     <path
 91 |         android:fillColor="#00000000"
 92 |         android:pathData="M0,69L108,69"
 93 |         android:strokeWidth="0.8"
 94 |         android:strokeColor="#33FFFFFF" />
 95 |     <path
 96 |         android:fillColor="#00000000"
 97 |         android:pathData="M0,79L108,79"
 98 |         android:strokeWidth="0.8"
 99 |         android:strokeColor="#33FFFFFF" />
100 |     <path
101 |         android:fillColor="#00000000"
102 |         android:pathData="M0,89L108,89"
103 |         android:strokeWidth="0.8"
104 |         android:strokeColor="#33FFFFFF" />
105 |     <path
106 |         android:fillColor="#00000000"
107 |         android:pathData="M0,99L108,99"
108 |         android:strokeWidth="0.8"
109 |         android:strokeColor="#33FFFFFF" />
110 |     <path
111 |         android:fillColor="#00000000"
112 |         android:pathData="M19,29L89,29"
113 |         android:strokeWidth="0.8"
114 |         android:strokeColor="#33FFFFFF" />
115 |     <path
116 |         android:fillColor="#00000000"
117 |         android:pathData="M19,39L89,39"
118 |         android:strokeWidth="0.8"
119 |         android:strokeColor="#33FFFFFF" />
120 |     <path
121 |         android:fillColor="#00000000"
122 |         android:pathData="M19,49L89,49"
123 |         android:strokeWidth="0.8"
124 |         android:strokeColor="#33FFFFFF" />
125 |     <path
126 |         android:fillColor="#00000000"
127 |         android:pathData="M19,59L89,59"
128 |         android:strokeWidth="0.8"
129 |         android:strokeColor="#33FFFFFF" />
130 |     <path
131 |         android:fillColor="#00000000"
132 |         android:pathData="M19,69L89,69"
133 |         android:strokeWidth="0.8"
134 |         android:strokeColor="#33FFFFFF" />
135 |     <path
136 |         android:fillColor="#00000000"
137 |         android:pathData="M19,79L89,79"
138 |         android:strokeWidth="0.8"
139 |         android:strokeColor="#33FFFFFF" />
140 |     <path
141 |         android:fillColor="#00000000"
142 |         android:pathData="M29,19L29,89"
143 |         android:strokeWidth="0.8"
144 |         android:strokeColor="#33FFFFFF" />
145 |     <path
146 |         android:fillColor="#00000000"
147 |         android:pathData="M39,19L39,89"
148 |         android:strokeWidth="0.8"
149 |         android:strokeColor="#33FFFFFF" />
150 |     <path
151 |         android:fillColor="#00000000"
152 |         android:pathData="M49,19L49,89"
153 |         android:strokeWidth="0.8"
154 |         android:strokeColor="#33FFFFFF" />
155 |     <path
156 |         android:fillColor="#00000000"
157 |         android:pathData="M59,19L59,89"
158 |         android:strokeWidth="0.8"
159 |         android:strokeColor="#33FFFFFF" />
160 |     <path
161 |         android:fillColor="#00000000"
162 |         android:pathData="M69,19L69,89"
163 |         android:strokeWidth="0.8"
164 |         android:strokeColor="#33FFFFFF" />
165 |     <path
166 |         android:fillColor="#00000000"
167 |         android:pathData="M79,19L79,89"
168 |         android:strokeWidth="0.8"
169 |         android:strokeColor="#33FFFFFF" />
170 | </vector>
171 | 


--------------------------------------------------------------------------------
/app/src/main/java/com/halilibo/madewithcompose/markdowneditor/MarkdownEditor.kt:
--------------------------------------------------------------------------------
  1 | package com.halilibo.madewithcompose.markdowneditor
  2 | 
  3 | import androidx.compose.foundation.ExperimentalFoundationApi
  4 | import androidx.compose.foundation.background
  5 | import androidx.compose.foundation.horizontalScroll
  6 | import androidx.compose.foundation.interaction.MutableInteractionSource
  7 | import androidx.compose.foundation.layout.Box
  8 | import androidx.compose.foundation.layout.Column
  9 | import androidx.compose.foundation.layout.IntrinsicSize
 10 | import androidx.compose.foundation.layout.Row
 11 | import androidx.compose.foundation.layout.fillMaxHeight
 12 | import androidx.compose.foundation.layout.fillMaxSize
 13 | import androidx.compose.foundation.layout.fillMaxWidth
 14 | import androidx.compose.foundation.layout.height
 15 | import androidx.compose.foundation.layout.padding
 16 | import androidx.compose.foundation.layout.size
 17 | import androidx.compose.foundation.layout.width
 18 | import androidx.compose.foundation.rememberScrollState
 19 | import androidx.compose.foundation.text2.BasicTextField2
 20 | import androidx.compose.foundation.text2.input.TextFieldState
 21 | import androidx.compose.material.ExperimentalMaterialApi
 22 | import androidx.compose.material.Icon
 23 | import androidx.compose.material.IconButton
 24 | import androidx.compose.material.LocalContentColor
 25 | import androidx.compose.material.LocalTextStyle
 26 | import androidx.compose.material.TextFieldDefaults
 27 | import androidx.compose.material.icons.Icons
 28 | import androidx.compose.material.icons.automirrored.filled.Redo
 29 | import androidx.compose.material.icons.automirrored.filled.Undo
 30 | import androidx.compose.material.icons.filled.Code
 31 | import androidx.compose.material.icons.filled.FormatBold
 32 | import androidx.compose.material.icons.filled.FormatItalic
 33 | import androidx.compose.material.icons.filled.FormatQuote
 34 | import androidx.compose.material.icons.filled.FormatStrikethrough
 35 | import androidx.compose.runtime.Composable
 36 | import androidx.compose.runtime.remember
 37 | import androidx.compose.ui.Alignment
 38 | import androidx.compose.ui.Modifier
 39 | import androidx.compose.ui.graphics.Color
 40 | import androidx.compose.ui.graphics.SolidColor
 41 | import androidx.compose.ui.res.painterResource
 42 | import androidx.compose.ui.text.input.VisualTransformation
 43 | import androidx.compose.ui.unit.dp
 44 | import androidx.compose.ui.unit.sp
 45 | import com.halilibo.madewithcompose.R
 46 | 
 47 | @OptIn(ExperimentalFoundationApi::class, ExperimentalMaterialApi::class)
 48 | @Composable
 49 | fun MarkdownEditor(
 50 |   state: TextFieldState,
 51 |   modifier: Modifier = Modifier,
 52 |   enabled: Boolean = true,
 53 |   onUndo: () -> Unit = {},
 54 |   onRedo: () -> Unit = {},
 55 |   undoEnabled: Boolean = true,
 56 |   redoEnabled: Boolean = true,
 57 | ) {
 58 |   Column(modifier = modifier) {
 59 |     Row(
 60 |       modifier = Modifier
 61 |         .fillMaxWidth()
 62 |         .height(IntrinsicSize.Min)
 63 |         .horizontalScroll(rememberScrollState()),
 64 |       verticalAlignment = Alignment.CenterVertically
 65 |     ) {
 66 |       val contentColor = LocalContentColor.current
 67 | 
 68 |       IconButton(
 69 |         onClick = onUndo,
 70 |         enabled = undoEnabled
 71 |       ) {
 72 |         Icon(
 73 |           imageVector = Icons.AutoMirrored.Filled.Undo,
 74 |           contentDescription = "Undo",
 75 |           tint = contentColor
 76 |         )
 77 |       }
 78 | 
 79 |       IconButton(
 80 |         onClick = onRedo,
 81 |         enabled = redoEnabled
 82 |       ) {
 83 |         Icon(
 84 |           imageVector = Icons.AutoMirrored.Filled.Redo,
 85 |           contentDescription = "Redo",
 86 |           tint = contentColor
 87 |         )
 88 |       }
 89 | 
 90 |       Box(
 91 |         modifier = Modifier
 92 |           .fillMaxHeight()
 93 |           .width(1.dp)
 94 |           .padding(vertical = 4.dp)
 95 |           .background(Color.Gray)
 96 |       )
 97 | 
 98 |       IconButton(onClick = {
 99 |         state.edit { header() }
100 |       }) {
101 |         Icon(
102 |           painter = painterResource(id = R.drawable.ic_header),
103 |           contentDescription = "Header",
104 |           tint = contentColor,
105 |           modifier = Modifier.size(16.dp)
106 |         )
107 |       }
108 | 
109 |       IconButton(onClick = {
110 |         state.edit { bold() }
111 |       }) {
112 |         Icon(
113 |           imageVector = Icons.Default.FormatBold,
114 |           contentDescription = "Format Bold",
115 |           tint = contentColor
116 |         )
117 |       }
118 | 
119 |       IconButton(onClick = {
120 |         state.edit { italic() }
121 |       }) {
122 |         Icon(
123 |           imageVector = Icons.Default.FormatItalic,
124 |           contentDescription = "FormatItalic",
125 |           tint = contentColor
126 |         )
127 |       }
128 | 
129 |       IconButton(onClick = {
130 |         state.edit { strikeThrough() }
131 |       }) {
132 |         Icon(
133 |           imageVector = Icons.Default.FormatStrikethrough,
134 |           contentDescription = "Format Strikethrough",
135 |           tint = contentColor
136 |         )
137 |       }
138 | 
139 | 
140 |       IconButton(onClick = {
141 |         state.edit { inlineCode() }
142 |       }) {
143 |         Icon(
144 |           imageVector = Icons.Default.Code,
145 |           contentDescription = "Format Code",
146 |           tint = contentColor
147 |         )
148 |       }
149 | 
150 |       IconButton(onClick = {
151 |         state.edit { quote() }
152 |       }) {
153 |         Icon(
154 |           imageVector = Icons.Default.FormatQuote,
155 |           contentDescription = "Format Quote",
156 |           tint = contentColor
157 |         )
158 |       }
159 |     }
160 | 
161 |     val interactionSource = remember { MutableInteractionSource() }
162 |     val colors = TextFieldDefaults.outlinedTextFieldColors()
163 |     BasicTextField2(
164 |       state = state,
165 |       textStyle = LocalTextStyle.current.copy(fontSize = 20.sp, color = LocalContentColor.current),
166 |       interactionSource = interactionSource,
167 |       enabled = enabled,
168 |       cursorBrush = SolidColor(colors.cursorColor(false).value),
169 |       decorationBox = {
170 |         TextFieldDefaults.OutlinedTextFieldDecorationBox(
171 |           value = state.text.toString(),
172 |           innerTextField = it,
173 |           enabled = true,
174 |           singleLine = false,
175 |           visualTransformation = VisualTransformation.None,
176 |           interactionSource = interactionSource
177 |         )
178 |       },
179 |       modifier = Modifier
180 |         .padding(8.dp)
181 |         .fillMaxSize()
182 |         .weight(1f)
183 |     )
184 |   }
185 | }


--------------------------------------------------------------------------------
/app/src/main/java/com/halilibo/madewithcompose/brush/BrushDemo.kt:
--------------------------------------------------------------------------------
  1 | package com.halilibo.madewithcompose.brush
  2 | 
  3 | import androidx.compose.foundation.background
  4 | import androidx.compose.foundation.gestures.detectDragGestures
  5 | import androidx.compose.foundation.gestures.detectTapGestures
  6 | import androidx.compose.foundation.layout.*
  7 | import androidx.compose.foundation.shape.CircleShape
  8 | import androidx.compose.foundation.verticalScroll
  9 | import androidx.compose.material.LocalTextStyle
 10 | import androidx.compose.material.Text
 11 | import androidx.compose.runtime.Composable
 12 | import androidx.compose.runtime.remember
 13 | import androidx.compose.runtime.rememberCoroutineScope
 14 | import androidx.compose.ui.Modifier
 15 | import androidx.compose.ui.draw.drawBehind
 16 | import androidx.compose.ui.draw.shadow
 17 | import androidx.compose.ui.geometry.Offset
 18 | import androidx.compose.ui.geometry.Size
 19 | import androidx.compose.ui.graphics.Color
 20 | import androidx.compose.ui.graphics.drawscope.withTransform
 21 | import androidx.compose.ui.input.pointer.pointerInput
 22 | import androidx.compose.ui.text.*
 23 | import androidx.compose.ui.text.font.FontWeight
 24 | import androidx.compose.ui.unit.IntOffset
 25 | import androidx.compose.ui.unit.dp
 26 | import androidx.compose.ui.unit.sp
 27 | import kotlinx.coroutines.launch
 28 | import kotlin.math.PI
 29 | import kotlin.math.atan
 30 | import kotlin.math.roundToInt
 31 | 
 32 | private val BULB_RADIUS = 18.dp
 33 | private val SOCKET_HEIGHT = 10.dp
 34 | private val SOCKET_WIDTH = 10.dp
 35 | private val CABLE_WIDTH = 2.dp
 36 | 
 37 | @Composable
 38 | fun BrushDemo() {
 39 |   BoxWithConstraints(modifier = Modifier.background(Color.Black)) {
 40 |     val size = Size(constraints.maxWidth.toFloat(), constraints.maxHeight.toFloat())
 41 |     val lightingTextDemoState = remember(size) { LightingTextDemoState(size) }
 42 |     // Text on the background, put first in the box.
 43 |     LightingText(state = lightingTextDemoState)
 44 |     // Cable attachment to bulb can be drawn freely
 45 |     Box(
 46 |       modifier = Modifier
 47 |         .matchParentSize()
 48 |         .bulbAttachments(lightingTextDemoState)
 49 |     )
 50 |     // Bulb will float freely in the box. Its initial location should be; x = 50%, y = 100dp
 51 |     LightBulb(state = lightingTextDemoState)
 52 |   }
 53 | }
 54 | 
 55 | fun Modifier.bulbAttachments(
 56 |   state: LightingTextDemoState
 57 | ): Modifier {
 58 |   return drawBehind {
 59 |     val bulbPosition = state.bulbOffset
 60 | 
 61 |     drawLine(
 62 |       Color.DarkGray,
 63 |       start = center.copy(y = 0f),
 64 |       end = bulbPosition,
 65 |       CABLE_WIDTH.toPx()
 66 |     )
 67 | 
 68 |     val angle = atan((bulbPosition.x - center.x) / (bulbPosition.y))
 69 | 
 70 |     val rectHeight = SOCKET_HEIGHT.toPx()
 71 |     val rectWidth = SOCKET_WIDTH.toPx()
 72 | 
 73 |     withTransform({
 74 |       rotate(-(angle / PI * 180).toFloat(), pivot = center.copy(y = 0f))
 75 |     }) {
 76 |       drawRect(
 77 |         Color.LightGray,
 78 |         topLeft = Offset(
 79 |           x = center.x - rectWidth / 2,
 80 |           y = (bulbPosition - center.copy(y = 0f)).getDistance() - (BULB_RADIUS.toPx() + rectHeight)
 81 |         ),
 82 |         size = Size(rectWidth, rectHeight),
 83 |       )
 84 |     }
 85 |   }
 86 | }
 87 | 
 88 | @Composable
 89 | fun LightBulb(state: LightingTextDemoState) {
 90 |   val coroutineScope = rememberCoroutineScope()
 91 | 
 92 |   Box(Modifier
 93 |     .size(36.dp)
 94 |     .offset {
 95 |       val position = state.bulbOffset - Offset(BULB_RADIUS.toPx(), BULB_RADIUS.toPx())
 96 |       IntOffset(position.x.roundToInt(), position.y.roundToInt())
 97 |     }
 98 |     .background(
 99 |       state.bulbBackground,
100 |       shape = CircleShape
101 |     )
102 |     .shadow(16.dp, shape = CircleShape, clip = false)
103 |     .pointerInput(Unit) {
104 |       detectTapGestures { state.toggleLight() }
105 |     }
106 |     .pointerInput(Unit) {
107 |       detectDragGestures(
108 |         onDragEnd = { coroutineScope.launch { state.onDragEnd() } },
109 |         onDragCancel = { coroutineScope.launch { state.onDragEnd() } },
110 |         onDrag = { change, dragAmount ->
111 |           coroutineScope.launch { state.onDrag(change, dragAmount) }
112 |         }
113 |       )
114 |     }
115 |   )
116 | }
117 | 
118 | @OptIn(ExperimentalTextApi::class)
119 | @Composable
120 | fun LightingText(state: LightingTextDemoState) {
121 |   Text(
122 |     text = lipsum,
123 |     modifier = Modifier
124 |       .fillMaxSize()
125 |       .padding(16.dp)
126 |       .verticalScroll(state.scrollState),
127 |     style = LocalTextStyle.current.merge(
128 |       TextStyle(
129 |         fontSize = 18.sp,
130 |         brush = state.lightSourceBrush
131 |       )
132 |     )
133 |   )
134 | }
135 | 
136 | val lipsum = buildAnnotatedString {
137 |   append("\n\n\n\n\n\n")
138 |   withStyle(SpanStyle(fontSize = 24.sp, fontWeight = FontWeight.Bold)) {
139 |     append("Jetpack Compose lets you do awesome things 🎉")
140 |   }
141 |   append(
142 |     """
143 |       
144 |       
145 |   Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aliquam luctus, libero in laoreet viverra, dolor diam dignissim sapien, id lacinia quam metus ut nunc. Sed sit amet leo est. Donec vulputate congue bibendum. Maecenas scelerisque pellentesque nulla eget vulputate. Nam tempor varius finibus. Donec sit amet blandit nibh. Fusce vel ex massa. Pellentesque tincidunt tincidunt lacus sit amet lobortis.
146 | 
147 |   Quisque malesuada est vel ex iaculis iaculis. Aenean luctus lorem vitae tincidunt placerat. Nullam porta finibus neque. Nullam ipsum justo, feugiat et interdum ut, rhoncus a tellus. Suspendisse urna nibh, pulvinar tempor dolor non, dictum condimentum sem. Nullam molestie, nisl sit amet imperdiet varius, urna justo scelerisque massa, vitae imperdiet magna turpis ac lacus. Integer pulvinar tincidunt nisl a iaculis. Nulla eu lacus a leo posuere rhoncus.
148 | 
149 |   Donec venenatis viverra metus ac tempor. Etiam iaculis lacinia arcu ut sodales. Phasellus sollicitudin sit amet felis a molestie. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Curabitur vulputate neque in mi feugiat, in rutrum mauris viverra. Aenean vestibulum, justo eu molestie rhoncus, justo dolor faucibus tellus, vitae lobortis libero elit quis velit. Nulla nec efficitur eros. Nunc interdum elit sit amet ipsum egestas condimentum non a massa. Aenean in tortor sollicitudin, malesuada risus in, ultricies purus. Donec nec erat ante. Donec convallis tellus eu lacus placerat, eu feugiat turpis tempus.
150 | 
151 |   Nulla facilisi. Maecenas quis diam a mi auctor dapibus id quis est. Ut ultricies purus non ultrices posuere. Integer ac diam eu magna dapibus fringilla. Etiam posuere ultrices sem, ut mattis metus facilisis in. Nam viverra id libero vel rutrum. Donec pellentesque tortor sed nisl laoreet bibendum. Vestibulum sagittis tortor vel libero porta sagittis. Etiam odio tortor, vestibulum non auctor vitae, blandit nec justo. Nulla facilisi. Duis ut consequat velit.
152 | 
153 |   Etiam sed est massa. Sed in metus semper, luctus mauris vel, placerat eros. Nulla interdum leo at diam efficitur, ac dapibus tellus elementum. Nunc ipsum tellus, interdum rutrum interdum vel, ullamcorper eget orci. Vivamus vitae posuere purus, nec facilisis dui. Aenean ornare nisi est, eget faucibus nulla mollis ac. Curabitur auctor feugiat dui, eu hendrerit lorem. Nulla tortor libero, placerat in leo sodales, dictum dictum velit. Nam luctus sollicitudin quam, dapibus iaculis odio sollicitudin at. Aenean aliquet venenatis pellentesque. Nam in rutrum ligula. Vivamus mattis enim quis consectetur viverra. Vivamus placerat orci condimentum aliquet commodo. 
154 | """.trimIndent()
155 |   )
156 | }


--------------------------------------------------------------------------------
/app/src/main/java/com/halilibo/madewithcompose/textonpath/GlyphAnimationDemos.kt:
--------------------------------------------------------------------------------
  1 | package com.halilibo.madewithcompose.textonpath
  2 | 
  3 | import androidx.compose.animation.core.Animatable
  4 | import androidx.compose.animation.core.spring
  5 | import androidx.compose.animation.core.tween
  6 | import androidx.compose.foundation.layout.Box
  7 | import androidx.compose.foundation.layout.fillMaxWidth
  8 | import androidx.compose.foundation.layout.height
  9 | import androidx.compose.material.Button
 10 | import androidx.compose.material.Text
 11 | import androidx.compose.runtime.Composable
 12 | import androidx.compose.runtime.remember
 13 | import androidx.compose.runtime.rememberCoroutineScope
 14 | import androidx.compose.ui.Modifier
 15 | import androidx.compose.ui.draw.drawWithCache
 16 | import androidx.compose.ui.graphics.Brush
 17 | import androidx.compose.ui.graphics.Color
 18 | import androidx.compose.ui.graphics.drawscope.rotate
 19 | import androidx.compose.ui.graphics.drawscope.scale
 20 | import androidx.compose.ui.graphics.drawscope.translate
 21 | import androidx.compose.ui.text.AnnotatedString
 22 | import androidx.compose.ui.text.ExperimentalTextApi
 23 | import androidx.compose.ui.text.TextStyle
 24 | import androidx.compose.ui.text.rememberTextMeasurer
 25 | import androidx.compose.ui.unit.Constraints
 26 | import androidx.compose.ui.unit.dp
 27 | import androidx.compose.ui.unit.sp
 28 | import kotlinx.coroutines.delay
 29 | import kotlinx.coroutines.launch
 30 | import kotlin.math.roundToInt
 31 | import kotlin.random.Random
 32 | 
 33 | @Composable
 34 | fun DemoBouncy(text: String) {
 35 |   val textMeasurer = rememberTextMeasurer()
 36 |   val animatables = remember { List(text.length) { Animatable(0f) } }
 37 |   val coroutineScope = rememberCoroutineScope()
 38 | 
 39 |   Button(onClick = {
 40 |     coroutineScope.launch {
 41 |       animatables.forEach { it.snapTo(0f) }
 42 |       animatables.forEachIndexed { index, animatable ->
 43 |         launch {
 44 |           delay(Random.nextLong(300) + index * 100)
 45 |           animatable.animateTo(1f, spring(dampingRatio = 0.3f, stiffness = 150f))
 46 |         }
 47 |       }
 48 |     }
 49 |   }) {
 50 |     Text("Bounce")
 51 |   }
 52 |   Box(modifier = Modifier
 53 |     .fillMaxWidth()
 54 |     .height(300.dp)
 55 |     .drawWithCache {
 56 |       val textLayoutResult = textMeasurer.measure(
 57 |         text = AnnotatedString(text),
 58 |         style = TextStyle(
 59 |           fontSize = 40.sp,
 60 |           brush = Brush.horizontalGradient(colors = listOf(Color.Blue, Color.Red))
 61 |         ),
 62 |         constraints = Constraints.fixed(size.width.roundToInt(), size.height.roundToInt())
 63 |       )
 64 |       val glyphs = textLayoutResult.toGlyphs()
 65 |       onDrawBehind {
 66 |         drawGlyphs(glyphs) {
 67 |           val value = animatables[offset].value
 68 |           if (value > 0f) {
 69 |             translate(top = -(1 - value) * 200f) {
 70 |               this@drawGlyphs.drawGlyph(alpha = value)
 71 |             }
 72 |           }
 73 |         }
 74 |       }
 75 |     })
 76 | }
 77 | 
 78 | @OptIn(ExperimentalTextApi::class)
 79 | @Composable
 80 | fun DemoTyping(text: String) {
 81 |   val textMeasurer = rememberTextMeasurer()
 82 |   val animatables = remember { List(text.length) { Animatable(0f) } }
 83 |   val coroutineScope = rememberCoroutineScope()
 84 | 
 85 |   Button(onClick = {
 86 |     coroutineScope.launch {
 87 |       animatables.forEach { it.snapTo(0f) }
 88 |       animatables.forEachIndexed { index, animatable ->
 89 |         launch {
 90 |           delay(index * 100L)
 91 |           animatable.animateTo(1f, tween(100))
 92 |         }
 93 |       }
 94 |     }
 95 |   }) {
 96 |     Text("Type")
 97 |   }
 98 |   Box(modifier = Modifier
 99 |     .fillMaxWidth()
100 |     .height(300.dp)
101 |     .drawWithCache {
102 |       val textLayoutResult = textMeasurer.measure(
103 |         text = AnnotatedString(text),
104 |         style = TextStyle(
105 |           fontSize = 40.sp,
106 |           brush = Brush.horizontalGradient(colors = listOf(Color.Blue, Color.Red))
107 |         ),
108 |         constraints = Constraints.fixed(size.width.roundToInt(), size.height.roundToInt())
109 |       )
110 |       val glyphs = textLayoutResult.toGlyphs()
111 |       onDrawBehind {
112 |         drawGlyphs(glyphs) {
113 |           val value = animatables[offset].value
114 |           if (value > 0f) {
115 |             translate(left = (1f - value) * 40f) {
116 |               this@drawGlyphs.drawGlyph(alpha = value)
117 |             }
118 |           }
119 |         }
120 |       }
121 |     })
122 | }
123 | 
124 | @OptIn(ExperimentalTextApi::class)
125 | @Composable
126 | fun DemoRotating(text: String) {
127 |   val textMeasurer = rememberTextMeasurer()
128 |   val animatables = remember { List(text.length) { Animatable(0f) } }
129 |   val coroutineScope = rememberCoroutineScope()
130 | 
131 |   Button(onClick = {
132 |     coroutineScope.launch {
133 |       animatables.forEach { it.snapTo(0f) }
134 |       animatables.forEachIndexed { index, animatable ->
135 |         launch {
136 |           delay(index * 200L)
137 |           animatable.animateTo(1f, spring(dampingRatio = 0.3f, stiffness = 150f))
138 |         }
139 |       }
140 |     }
141 |   }) {
142 |     Text("Whirl")
143 |   }
144 |   Box(modifier = Modifier
145 |     .fillMaxWidth()
146 |     .height(300.dp)
147 |     .drawWithCache {
148 |       val textLayoutResult = textMeasurer.measure(
149 |         text = AnnotatedString(text),
150 |         style = TextStyle(
151 |           fontSize = 40.sp,
152 |           brush = Brush.horizontalGradient(colors = listOf(Color.Blue, Color.Red))
153 |         ),
154 |         constraints = Constraints.fixed(size.width.roundToInt(), size.height.roundToInt())
155 |       )
156 |       val glyphs = textLayoutResult.toGlyphs()
157 |       onDrawBehind {
158 |         drawGlyphs(glyphs) {
159 |           val value = animatables[offset].value
160 |           if (value > 0f) {
161 |             rotate(value * 360f) {
162 |               scale(value) {
163 |                 this@drawGlyphs.drawGlyph(alpha = value)
164 |               }
165 |             }
166 |           }
167 |         }
168 |       }
169 |     })
170 | }
171 | 
172 | @OptIn(ExperimentalTextApi::class)
173 | @Composable
174 | fun DemoDropping(text: String) {
175 |   val textMeasurer = rememberTextMeasurer()
176 |   val animatables = remember { List(text.length) { Animatable(0f) } }
177 |   val coroutineScope = rememberCoroutineScope()
178 | 
179 |   Button(onClick = {
180 |     coroutineScope.launch {
181 |       animatables.forEach { it.snapTo(0f) }
182 |       animatables.indices.toList().shuffled().forEachIndexed { index, animatableIndex ->
183 |         launch {
184 |           delay(index * Random.nextLong(75L, 100L))
185 |           animatables[animatableIndex].snapTo(20f)
186 |           animatables[animatableIndex].animateTo(1f, tween(500))
187 |         }
188 |       }
189 |     }
190 |   }) {
191 |     Text("Drop")
192 |   }
193 |   Box(modifier = Modifier
194 |     .fillMaxWidth()
195 |     .height(300.dp)
196 |     .drawWithCache {
197 |       val textLayoutResult = textMeasurer.measure(
198 |         text = AnnotatedString(text),
199 |         style = TextStyle(
200 |           fontSize = 40.sp,
201 |           brush = Brush.horizontalGradient(colors = listOf(Color.Blue, Color.Red))
202 |         ),
203 |         constraints = Constraints.fixed(size.width.roundToInt(), size.height.roundToInt())
204 |       )
205 |       val glyphs = textLayoutResult.toGlyphs()
206 |       onDrawBehind {
207 |         drawGlyphs(glyphs) {
208 |           val value = animatables[offset].value
209 |           if (value > 0f) {
210 |             scale(value) {
211 |               this@drawGlyphs.drawGlyph(alpha = (20f - value) / 19f)
212 |             }
213 |           }
214 |         }
215 |       }
216 |     })
217 | }
218 | 


--------------------------------------------------------------------------------
/app/src/main/java/com/halilibo/madewithcompose/videoplayer/MinimizeLayout.kt:
--------------------------------------------------------------------------------
  1 | package com.halilibo.madewithcompose.videoplayer
  2 | 
  3 | import androidx.compose.animation.core.Animatable
  4 | import androidx.compose.animation.core.AnimationSpec
  5 | import androidx.compose.animation.core.animateFloatAsState
  6 | import androidx.compose.foundation.gestures.Orientation
  7 | import androidx.compose.foundation.layout.Box
  8 | import androidx.compose.foundation.layout.PaddingValues
  9 | import androidx.compose.foundation.layout.fillMaxSize
 10 | import androidx.compose.foundation.layout.height
 11 | import androidx.compose.material.*
 12 | import androidx.compose.runtime.Composable
 13 | import androidx.compose.runtime.getValue
 14 | import androidx.compose.runtime.remember
 15 | import androidx.compose.runtime.rememberUpdatedState
 16 | import androidx.compose.runtime.saveable.Saver
 17 | import androidx.compose.runtime.saveable.rememberSaveable
 18 | import androidx.compose.ui.Modifier
 19 | import androidx.compose.ui.layout.SubcomposeLayout
 20 | import androidx.compose.ui.platform.LocalDensity
 21 | import androidx.compose.ui.unit.Constraints
 22 | import androidx.compose.ui.unit.Density
 23 | import androidx.compose.ui.unit.Dp
 24 | 
 25 | /**
 26 |  * Possible values of [MinimizeLayoutState].
 27 |  */
 28 | enum class MinimizeLayoutValue {
 29 |     Expanded,
 30 |     Minimized
 31 | }
 32 | 
 33 | @OptIn(ExperimentalMaterialApi::class)
 34 | class MinimizeLayoutState(
 35 |     initialValue: MinimizeLayoutValue,
 36 |     animationSpec: AnimationSpec<Float> = SwipeableDefaults.AnimationSpec,
 37 |     confirmStateChange: (MinimizeLayoutValue) -> Boolean = { true },
 38 |     initialHidden: Boolean = true
 39 | ) : SwipeableState<MinimizeLayoutValue>(
 40 |     initialValue = initialValue,
 41 |     animationSpec = animationSpec,
 42 |     confirmStateChange = confirmStateChange
 43 | ) {
 44 |     internal val hiddenOffset = Animatable(if (initialHidden) 1f else 0f)
 45 | 
 46 |     suspend fun expand() {
 47 |         hiddenOffset.snapTo(0f)
 48 |         animateTo(MinimizeLayoutValue.Expanded)
 49 |     }
 50 | 
 51 |     suspend fun minimize() {
 52 |         hiddenOffset.snapTo(0f)
 53 |         animateTo(MinimizeLayoutValue.Minimized)
 54 |     }
 55 | 
 56 |     suspend fun hide() {
 57 |         hiddenOffset.animateTo(1f)
 58 |     }
 59 | 
 60 |     val isHidden: Boolean
 61 |         get() = hiddenOffset.value == 1f
 62 | 
 63 |     // There is a bug in swipeableState.progress in which an exception
 64 |     // is thrown when progress reaches completion
 65 |     val swipeProgress: SwipeProgress<MinimizeLayoutValue>
 66 |         get() = runCatching { progress }
 67 |             .getOrElse {
 68 |                 SwipeProgress(
 69 |                     MinimizeLayoutValue.Expanded,
 70 |                     MinimizeLayoutValue.Expanded,
 71 |                     1f
 72 |                 )
 73 |             }
 74 | 
 75 |     companion object {
 76 | 
 77 |         fun Saver(
 78 |             animationSpec: AnimationSpec<Float>,
 79 |             confirmStateChange: (MinimizeLayoutValue) -> Boolean
 80 |         ): Saver<MinimizeLayoutState, *> = Saver(
 81 |             save = { it.currentValue },
 82 |             restore = {
 83 |                 MinimizeLayoutState(
 84 |                     initialValue = it,
 85 |                     animationSpec = animationSpec,
 86 |                     confirmStateChange = confirmStateChange
 87 |                 )
 88 |             }
 89 |         )
 90 |     }
 91 | }
 92 | 
 93 | /**
 94 |  * Create a [MinimizeLayoutState] and [remember] it.
 95 |  *
 96 |  * @param initialValue The initial value of the state.
 97 |  * @param animationSpec The default animation that will be used to animate to a new state.
 98 |  * @param confirmStateChange Optional callback invoked to confirm or veto a pending state change.
 99 |  */
100 | @OptIn(ExperimentalMaterialApi::class)
101 | @Composable
102 | fun rememberMinimizeLayoutState(
103 |     initialValue: MinimizeLayoutValue,
104 |     animationSpec: AnimationSpec<Float> = SwipeableDefaults.AnimationSpec,
105 |     confirmStateChange: (MinimizeLayoutValue) -> Boolean = { true }
106 | ): MinimizeLayoutState {
107 |     return rememberSaveable(
108 |         saver = MinimizeLayoutState.Saver(
109 |             animationSpec = animationSpec,
110 |             confirmStateChange = confirmStateChange
111 |         )
112 |     ) {
113 |         MinimizeLayoutState(
114 |             initialValue = initialValue,
115 |             animationSpec = animationSpec,
116 |             confirmStateChange = confirmStateChange
117 |         )
118 |     }
119 | }
120 | 
121 | @OptIn(ExperimentalMaterialApi::class)
122 | @Composable
123 | fun MinimizeLayout(
124 |     minimizableContent: @Composable (swipeableModifier: Modifier) -> Unit,
125 |     modifier: Modifier = Modifier,
126 |     minimizeLayoutState: MinimizeLayoutState =
127 |         rememberMinimizeLayoutState(MinimizeLayoutValue.Minimized),
128 |     minimizedContentHeight: Density.(Dp) -> Dp = { it / 10 },
129 |     content: @Composable (PaddingValues) -> Unit
130 | ) {
131 |     val minimizedContentHeightState by rememberUpdatedState(minimizedContentHeight)
132 |     val density = LocalDensity.current
133 |     MinimizeStack(
134 |         modifier = modifier,
135 |         hideOffsetFraction = minimizeLayoutState.hiddenOffset.value,
136 |         minimizableContent = { constraints ->
137 |             val fullHeight = constraints.maxHeight.toFloat()
138 |             val minimizedHeight = animateFloatAsState(targetValue = with(density) {
139 |                 minimizedContentHeightState(fullHeight.toDp()).toPx()
140 |             }).value.coerceAtMost(fullHeight)
141 |             val anchors = mapOf(
142 |                 fullHeight - minimizedHeight to MinimizeLayoutValue.Minimized,
143 |                 0f to MinimizeLayoutValue.Expanded
144 |             )
145 |             val swipeable = Modifier.swipeable(
146 |                 state = minimizeLayoutState,
147 |                 anchors = anchors,
148 |                 orientation = Orientation.Vertical
149 |             )
150 | 
151 |             val swipeOffset = minimizeLayoutState.offset.value
152 |             val currentHeight = if (swipeOffset.isNaN()) {
153 |                 0f
154 |             } else {
155 |                 (fullHeight - minimizeLayoutState.offset.value).coerceIn(minimizedHeight, fullHeight)
156 |             }
157 | 
158 |             Box(modifier = Modifier
159 |                 .height(with(density) { currentHeight.toDp() })) {
160 |                 minimizableContent(swipeable)
161 |             }
162 |         },
163 |         content = { bottomPadding ->
164 |             Box(Modifier.fillMaxSize()) {
165 |                 content(PaddingValues(bottom = bottomPadding))
166 |             }
167 |         }
168 |     )
169 | }
170 | 
171 | @Composable
172 | private fun MinimizeStack(
173 |     modifier: Modifier,
174 |     hideOffsetFraction: Float,
175 |     minimizableContent: @Composable (constraints: Constraints) -> Unit,
176 |     content: @Composable (bottomPadding: Dp) -> Unit
177 | ) {
178 |     val density = LocalDensity.current
179 |     SubcomposeLayout(modifier) { constraints ->
180 |         val minimizablePlaceable =
181 |             subcompose(MinimizeStackSlot.Minimizable) {
182 |                 minimizableContent(constraints)
183 |             }.first().measure(constraints.copy(minWidth = 0, minHeight = 0))
184 | 
185 |         val animatedHideOffset = (minimizablePlaceable.height * hideOffsetFraction).toInt()
186 | 
187 |         val contentPlaceable =
188 |             subcompose(MinimizeStackSlot.Main) {
189 |                 content(with(density) {
190 |                     (minimizablePlaceable.height - animatedHideOffset).coerceAtLeast(0).toDp()
191 |                 })
192 |             }
193 |                 .first().measure(constraints)
194 | 
195 |         val middleX = (contentPlaceable.width - minimizablePlaceable.width) / 2
196 |         val bottomY = (contentPlaceable.height - minimizablePlaceable.height) + animatedHideOffset
197 | 
198 |         layout(contentPlaceable.width, contentPlaceable.height) {
199 |             contentPlaceable.placeRelative(0, 0)
200 |             minimizablePlaceable.placeRelative(middleX, bottomY)
201 |         }
202 |     }
203 | }
204 | 
205 | private enum class MinimizeStackSlot { Minimizable, Main }
206 | 


--------------------------------------------------------------------------------
/app/src/main/res/raw/videos.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "videos": [
  3 |     {
  4 |       "description": "Big Buck Bunny tells the story of a giant rabbit with a heart bigger than himself. When one sunny day three rodents rudely harass him, something snaps... and the rabbit ain't no bunny anymore! In the typical cartoon tradition he prepares the nasty rodents a comical revenge.\n\nLicensed under the Creative Commons Attribution license\nhttp://www.bigbuckbunny.org",
  5 |       "sources": [
  6 |         "http://commondatastorage.googleapis.com/gtv-videos-bucket/sample/BigBuckBunny.mp4"
  7 |       ],
  8 |       "subtitle": "By Blender Foundation",
  9 |       "thumb": "http://commondatastorage.googleapis.com/gtv-videos-bucket/sample/images/BigBuckBunny.jpg",
 10 |       "title": "Big Buck Bunny"
 11 |     },
 12 |     {
 13 |       "description": "The first Blender Open Movie from 2006",
 14 |       "sources": [
 15 |         "http://commondatastorage.googleapis.com/gtv-videos-bucket/sample/ElephantsDream.mp4"
 16 |       ],
 17 |       "subtitle": "By Blender Foundation",
 18 |       "thumb": "http://commondatastorage.googleapis.com/gtv-videos-bucket/sample/images/ElephantsDream.jpg",
 19 |       "title": "Elephant Dream"
 20 |     },
 21 |     {
 22 |       "description": "HBO GO now works with Chromecast -- the easiest way to enjoy online video on your TV. For when you want to settle into your Iron Throne to watch the latest episodes. For $35.\nLearn how to use Chromecast with HBO GO and more at google.com/chromecast.",
 23 |       "sources": [
 24 |         "http://commondatastorage.googleapis.com/gtv-videos-bucket/sample/ForBiggerBlazes.mp4"
 25 |       ],
 26 |       "subtitle": "By Google",
 27 |       "thumb": "http://commondatastorage.googleapis.com/gtv-videos-bucket/sample/images/ForBiggerBlazes.jpg",
 28 |       "title": "For Bigger Blazes"
 29 |     },
 30 |     {
 31 |       "description": "Introducing Chromecast. The easiest way to enjoy online video and music on your TV—for when Batman's escapes aren't quite big enough. For $35. Learn how to use Chromecast with Google Play Movies and more at google.com/chromecast.",
 32 |       "sources": [
 33 |         "http://commondatastorage.googleapis.com/gtv-videos-bucket/sample/ForBiggerEscapes.mp4"
 34 |       ],
 35 |       "subtitle": "By Google",
 36 |       "thumb": "http://commondatastorage.googleapis.com/gtv-videos-bucket/sample/images/ForBiggerEscapes.jpg",
 37 |       "title": "For Bigger Escape"
 38 |     },
 39 |     {
 40 |       "description": "Introducing Chromecast. The easiest way to enjoy online video and music on your TV. For $35.  Find out more at google.com/chromecast.",
 41 |       "sources": [
 42 |         "http://commondatastorage.googleapis.com/gtv-videos-bucket/sample/ForBiggerFun.mp4"
 43 |       ],
 44 |       "subtitle": "By Google",
 45 |       "thumb": "http://commondatastorage.googleapis.com/gtv-videos-bucket/sample/images/ForBiggerFun.jpg",
 46 |       "title": "For Bigger Fun"
 47 |     },
 48 |     {
 49 |       "description": "Introducing Chromecast. The easiest way to enjoy online video and music on your TV—for the times that call for bigger joyrides. For $35. Learn how to use Chromecast with YouTube and more at google.com/chromecast.",
 50 |       "sources": [
 51 |         "http://commondatastorage.googleapis.com/gtv-videos-bucket/sample/ForBiggerJoyrides.mp4"
 52 |       ],
 53 |       "subtitle": "By Google",
 54 |       "thumb": "http://commondatastorage.googleapis.com/gtv-videos-bucket/sample/images/ForBiggerJoyrides.jpg",
 55 |       "title": "For Bigger Joyrides"
 56 |     },
 57 |     {
 58 |       "description": "Introducing Chromecast. The easiest way to enjoy online video and music on your TV—for when you want to make Buster's big meltdowns even bigger. For $35. Learn how to use Chromecast with Netflix and more at google.com/chromecast.",
 59 |       "sources": [
 60 |         "http://commondatastorage.googleapis.com/gtv-videos-bucket/sample/ForBiggerMeltdowns.mp4"
 61 |       ],
 62 |       "subtitle": "By Google",
 63 |       "thumb": "http://commondatastorage.googleapis.com/gtv-videos-bucket/sample/images/ForBiggerMeltdowns.jpg",
 64 |       "title": "For Bigger Meltdowns"
 65 |     },
 66 |     {
 67 |       "description": "Sintel is an independently produced short film, initiated by the Blender Foundation as a means to further improve and validate the free/open source 3D creation suite Blender. With initial funding provided by 1000s of donations via the internet community, it has again proven to be a viable development model for both open 3D technology as for independent animation film.\nThis 15 minute film has been realized in the studio of the Amsterdam Blender Institute, by an international team of artists and developers. In addition to that, several crucial technical and creative targets have been realized online, by developers and artists and teams all over the world.\nwww.sintel.org",
 68 |       "sources": [
 69 |         "http://commondatastorage.googleapis.com/gtv-videos-bucket/sample/Sintel.mp4"
 70 |       ],
 71 |       "subtitle": "By Blender Foundation",
 72 |       "thumb": "http://commondatastorage.googleapis.com/gtv-videos-bucket/sample/images/Sintel.jpg",
 73 |       "title": "Sintel"
 74 |     },
 75 |     {
 76 |       "description": "Smoking Tire takes the all-new Subaru Outback to the highest point we can find in hopes our customer-appreciation Balloon Launch will get some free T-shirts into the hands of our viewers.",
 77 |       "sources": [
 78 |         "http://commondatastorage.googleapis.com/gtv-videos-bucket/sample/SubaruOutbackOnStreetAndDirt.mp4"
 79 |       ],
 80 |       "subtitle": "By Garage419",
 81 |       "thumb": "http://commondatastorage.googleapis.com/gtv-videos-bucket/sample/images/SubaruOutbackOnStreetAndDirt.jpg",
 82 |       "title": "Subaru Outback On Street And Dirt"
 83 |     },
 84 |     {
 85 |       "description": "Tears of Steel was realized with crowd-funding by users of the open source 3D creation tool Blender. Target was to improve and test a complete open and free pipeline for visual effects in film - and to make a compelling sci-fi film in Amsterdam, the Netherlands.  The film itself, and all raw material used for making it, have been released under the Creatieve Commons 3.0 Attribution license. Visit the tearsofsteel.org website to find out more about this, or to purchase the 4-DVD box with a lot of extras.  (CC) Blender Foundation - http://www.tearsofsteel.org",
 86 |       "sources": [
 87 |         "http://commondatastorage.googleapis.com/gtv-videos-bucket/sample/TearsOfSteel.mp4"
 88 |       ],
 89 |       "subtitle": "By Blender Foundation",
 90 |       "thumb": "http://commondatastorage.googleapis.com/gtv-videos-bucket/sample/images/TearsOfSteel.jpg",
 91 |       "title": "Tears of Steel"
 92 |     },
 93 |     {
 94 |       "description": "The Smoking Tire heads out to Adams Motorsports Park in Riverside, CA to test the most requested car of 2010, the Volkswagen GTI. Will it beat the Mazdaspeed3's standard-setting lap time? Watch and see...",
 95 |       "sources": [
 96 |         "http://commondatastorage.googleapis.com/gtv-videos-bucket/sample/VolkswagenGTIReview.mp4"
 97 |       ],
 98 |       "subtitle": "By Garage419",
 99 |       "thumb": "http://commondatastorage.googleapis.com/gtv-videos-bucket/sample/images/VolkswagenGTIReview.jpg",
100 |       "title": "Volkswagen GTI Review"
101 |     },
102 |     {
103 |       "description": "The Smoking Tire is going on the 2010 Bullrun Live Rally in a 2011 Shelby GT500, and posting a video from the road every single day! The only place to watch them is by subscribing to The Smoking Tire or watching at BlackMagicShine.com",
104 |       "sources": [
105 |         "http://commondatastorage.googleapis.com/gtv-videos-bucket/sample/WeAreGoingOnBullrun.mp4"
106 |       ],
107 |       "subtitle": "By Garage419",
108 |       "thumb": "http://commondatastorage.googleapis.com/gtv-videos-bucket/sample/images/WeAreGoingOnBullrun.jpg",
109 |       "title": "We Are Going On Bullrun"
110 |     },
111 |     {
112 |       "description": "The Smoking Tire meets up with Chris and Jorge from CarsForAGrand.com to see just how far $1,000 can go when looking for a car.The Smoking Tire meets up with Chris and Jorge from CarsForAGrand.com to see just how far $1,000 can go when looking for a car.",
113 |       "sources": [
114 |         "http://commondatastorage.googleapis.com/gtv-videos-bucket/sample/WhatCarCanYouGetForAGrand.mp4"
115 |       ],
116 |       "subtitle": "By Garage419",
117 |       "thumb": "http://commondatastorage.googleapis.com/gtv-videos-bucket/sample/images/WhatCarCanYouGetForAGrand.jpg",
118 |       "title": "What care can you get for a grand?"
119 |     }
120 |   ]
121 | }


--------------------------------------------------------------------------------
/app/src/main/java/com/halilibo/madewithcompose/videoplayer/VideoPlayerDemo.kt:
--------------------------------------------------------------------------------
  1 | package com.halilibo.madewithcompose.videoplayer
  2 | 
  3 | import android.graphics.Rect
  4 | import androidx.activity.compose.BackHandler
  5 | import androidx.compose.foundation.clickable
  6 | import androidx.compose.foundation.layout.fillMaxSize
  7 | import androidx.compose.foundation.layout.padding
  8 | import androidx.compose.material.ExperimentalMaterialApi
  9 | import androidx.compose.material.Surface
 10 | import androidx.compose.material.Text
 11 | import androidx.compose.runtime.*
 12 | import androidx.compose.runtime.saveable.rememberSaveable
 13 | import androidx.compose.ui.Modifier
 14 | import androidx.compose.ui.geometry.Offset
 15 | import androidx.compose.ui.graphics.Color
 16 | import androidx.compose.ui.layout.onGloballyPositioned
 17 | import androidx.compose.ui.platform.LocalContext
 18 | import androidx.compose.ui.platform.LocalLifecycleOwner
 19 | import androidx.compose.ui.text.TextStyle
 20 | import androidx.compose.ui.text.font.FontWeight
 21 | import androidx.compose.ui.unit.dp
 22 | import androidx.compose.ui.unit.sp
 23 | import androidx.lifecycle.DefaultLifecycleObserver
 24 | import androidx.lifecycle.LifecycleOwner
 25 | import com.google.gson.Gson
 26 | import com.halilibo.madewithcompose.R
 27 | import com.halilibo.madewithcompose.pip.LocalPipState
 28 | import com.halilibo.videoplayer.VideoPlayer
 29 | import com.halilibo.videoplayer.VideoPlayerController
 30 | import com.halilibo.videoplayer.VideoPlayerSource
 31 | import com.halilibo.videoplayer.rememberVideoPlayerController
 32 | import kotlinx.coroutines.flow.*
 33 | import kotlinx.coroutines.launch
 34 | 
 35 | @OptIn(ExperimentalMaterialApi::class)
 36 | @Composable
 37 | fun VideoPlayerDemo() {
 38 |     var selectedVideo by rememberSaveable { mutableStateOf<Video?>(null) }
 39 | 
 40 |     val coroutineScope = rememberCoroutineScope()
 41 |     val videoPlayerController = rememberVideoPlayerController()
 42 |     val videoPlayerUiState by videoPlayerController.state.collectAsState()
 43 |     val lifecycleOwner = LocalLifecycleOwner.current
 44 |     val pipState = LocalPipState.current
 45 | 
 46 |     DisposableEffect(videoPlayerController, lifecycleOwner) {
 47 |         val observer = object : DefaultLifecycleObserver {
 48 |             override fun onStart(owner: LifecycleOwner) {
 49 |                 videoPlayerController.startMediaSession()
 50 |             }
 51 | 
 52 |             override fun onStop(owner: LifecycleOwner) {
 53 |                 videoPlayerController.pause()
 54 |                 videoPlayerController.stopMediaSession()
 55 |             }
 56 | 
 57 |             override fun onDestroy(owner: LifecycleOwner) {
 58 |                 videoPlayerController.reset()
 59 |             }
 60 |         }
 61 |         lifecycleOwner.lifecycle.addObserver(observer)
 62 | 
 63 |         onDispose {
 64 |             lifecycleOwner.lifecycle.removeObserver(observer)
 65 |         }
 66 |     }
 67 | 
 68 |     with(pipState) {
 69 |         PipEnabled(isEnabled = selectedVideo != null && videoPlayerUiState.isPlaying)
 70 |         setAspectRatio(videoPlayerUiState.videoSize.width, videoPlayerUiState.videoSize.height)
 71 |     }
 72 | 
 73 |     val minimizeLayoutState = rememberMinimizeLayoutState(MinimizeLayoutValue.Expanded)
 74 | 
 75 |     val selectedVideoFlow = remember { snapshotFlow { selectedVideo } }
 76 | 
 77 |     LaunchedEffect(Unit) {
 78 |         selectedVideoFlow.onEach { video ->
 79 |             if (video != null) {
 80 |                 videoPlayerController.setSource(VideoPlayerSource.Network(video.sources.first()))
 81 |                 minimizeLayoutState.expand()
 82 |             } else {
 83 |                 minimizeLayoutState.hide()
 84 |                 videoPlayerController.reset()
 85 |             }
 86 |         }.launchIn(this)
 87 |     }
 88 | 
 89 |     val isFullyMaximized = minimizeLayoutState.currentValue == MinimizeLayoutValue.Expanded &&
 90 |             minimizeLayoutState.targetValue != MinimizeLayoutValue.Minimized &&
 91 |             !minimizeLayoutState.isHidden
 92 | 
 93 |     BackHandler(
 94 |         onBack = {
 95 |             coroutineScope.launch { minimizeLayoutState.minimize() }
 96 |         },
 97 |         enabled = isFullyMaximized
 98 |     )
 99 | 
100 |     if (pipState.isInPictureInPicture.value) {
101 |         PictureInPictureVideoPlayerDemo(videoPlayerController)
102 |     } else {
103 |         MinimizeLayout(
104 |             minimizeLayoutState = minimizeLayoutState,
105 |             minimizedContentHeight = { 60.dp },
106 |             minimizableContent = { swipeable ->
107 |                 val videoTitle = selectedVideo?.title ?: ""
108 |                 val videoDescription = selectedVideo?.description ?: ""
109 | 
110 |                 VideoPlayerPage(
111 |                     videoPlayer = {
112 |                         VideoPlayer(
113 |                             videoPlayerController = videoPlayerController,
114 |                             backgroundColor = Color.Transparent,
115 |                             modifier = Modifier
116 |                                 .then(swipeable)
117 |                                 .onGloballyPositioned {
118 |                                     val size = it.size
119 |                                     val positionInWindow = it.localToWindow(Offset.Zero)
120 |                                     pipState.setSourceRectHint(Rect(
121 |                                         positionInWindow.x.toInt(),
122 |                                         positionInWindow.y.toInt(),
123 |                                         (positionInWindow.x + size.width).toInt(),
124 |                                         (positionInWindow.y + size.height).toInt()
125 |                                     ))
126 |                                 },
127 |                             controlsEnabled = isFullyMaximized
128 |                         )
129 |                     },
130 |                     content = {
131 |                         Text(
132 |                             videoTitle,
133 |                             style = TextStyle(
134 |                                 fontSize = 22.sp,
135 |                                 fontWeight = FontWeight.Bold
136 |                             ),
137 |                             modifier = Modifier
138 |                                 .padding(16.dp)
139 |                                 .clickable {
140 |                                     selectedVideo = null
141 |                                 }
142 |                         )
143 |                         Text(
144 |                             videoDescription,
145 |                             style = TextStyle(
146 |                                 fontSize = 14.sp
147 |                             ),
148 |                             modifier = Modifier.padding(horizontal = 16.dp)
149 |                         )
150 |                     },
151 |                     minimizedContent = {
152 |                         MinimizedTitleAndControls(
153 |                             videoTitle = videoTitle,
154 |                             isPlaying = videoPlayerUiState.isPlaying,
155 |                             onPlayPauseToggle = { videoPlayerController.playPauseToggle() },
156 |                             onDismiss = { selectedVideo = null },
157 |                             modifier = Modifier.then(swipeable)
158 |                         )
159 |                     },
160 |                     swipeProgress = minimizeLayoutState.swipeProgress,
161 |                     modifier = Modifier
162 |                 )
163 |             }
164 |         ) { paddingValues ->
165 |             Surface {
166 |                 VideoListPage(
167 |                     onVideoSelected = { video ->
168 |                         selectedVideo = video
169 |                     },
170 |                     contentPadding = paddingValues
171 |                 )
172 |             }
173 |         }
174 |     }
175 | }
176 | 
177 | @Composable
178 | fun PictureInPictureVideoPlayerDemo(
179 |     videoPlayerController: VideoPlayerController
180 | ) {
181 |     VideoPlayer(
182 |         videoPlayerController = videoPlayerController,
183 |         backgroundColor = Color.Transparent,
184 |         controlsEnabled = false,
185 |         modifier = Modifier.fillMaxSize()
186 |     )
187 | }
188 | 
189 | @Composable
190 | fun getVideoList(): List<Video> {
191 |     val context = LocalContext.current
192 | 
193 |     return remember(context) {
194 |         val content = context.resources.openRawResource(R.raw.videos)
195 |             .bufferedReader()
196 |             .use { it.readText() }
197 |         Gson().fromJson(content, VideoList::class.java).videos
198 |     }
199 | }
200 | 


--------------------------------------------------------------------------------