Merge branch 'develop'

Author: skydoves

buildSrc/src/main/kotlin/io/getstream/video/android/Configuration.kt

@@ -6,9 +6,9 @@ object Configuration {
     const val minSdk = 24
     const val majorVersion = 0
     const val minorVersion = 2
-    const val patchVersion = 0
+    const val patchVersion = 1
     const val versionName = "$majorVersion.$minorVersion.$patchVersion"
-    const val versionCode = 1
+    const val versionCode = 3
     const val snapshotVersionName = "$majorVersion.$minorVersion.${patchVersion}-SNAPSHOT"
     const val artifactGroup = "io.getstream"
 }

docusaurus/docs/Android/02-tutorials/01-video-calling.mdx

@@ -31,7 +31,7 @@ If you're new to android, note that there are 2 `build.gradle` files, you want t
 ```kotlin
 dependencies {
     // Stream Video Compose SDK
-    implementation("io.getstream:stream-video-android-compose:0.2.0")
+    implementation("io.getstream:stream-video-android-compose:0.2.1")
 
     // Optionally add Jetpack Compose if Android studio didn't automatically include them
     implementation(platform("androidx.compose:compose-bom:2023.06.00"))

docusaurus/docs/Android/02-tutorials/02-audio-room.mdx

@@ -35,7 +35,7 @@ If you're new to android, note that there are 2 `build.gradle` files, you want t
 ```groovy
 dependencies {
     // Stream Video Compose SDK
-    implementation("io.getstream:stream-video-android-compose:0.2.0")
+    implementation("io.getstream:stream-video-android-compose:0.2.1")
 
     // Jetpack Compose (optional/ android studio typically adds them when you create a new project)
     implementation(platform("androidx.compose:compose-bom:2023.06.00"))

docusaurus/docs/Android/02-tutorials/03-livestream.mdx

@@ -20,27 +20,40 @@ Let's get started, if you have any questions or feedback be sure to let us know
 
 ### Step 1 - Create a new project in Android Studio
 
-Note that this tutorial was written using Android Studio Giraffe. Setup steps can vary slightly across Android Studio versions.
-We recommend using Android Studio Giraffe or newer.
+Note that this tutorial was written using **Android Studio Giraffe**. Setup steps can vary slightly across Android Studio versions.
+We recommend using [Android Studio Giraffe or newer](https://developer.android.com/studio/releases).
 
 1. Create a new project
-2. Select Phone & Template -> **empty activity**
+2. Select Phone & Tablet -> **Empty Activity**
 3. Name your project **Livestream**.
 
 ### Step 2 - Install the SDK & Setup the client
 
-**Add the video SDK** to your app's `build.gradle.kts` file found in `app/build.gradle.kts`.
-If you're new to android note that there are 2 build.gradle files, you want to open the one in the app folder.
+**Add the Video Compose SDK** and [Jetpack Compose](https://developer.android.com/jetpack/compose) dependencies to your app's `build.gradle.kts` file found in `app/build.gradle.kts`.
+If you're new to android, note that there are 2 `build.gradle` files, you want to open the `build.gradle` in the app folder.
 
 ```kotlin
 dependencies {
-    implementation("io.getstream:stream-video-android-compose:0.2.0")
-
-    ...
+    // Stream Video Compose SDK
+    implementation("io.getstream:stream-video-android-compose:0.2.1")
+
+    // Jetpack Compose (optional/ android studio typically adds them when you create a new project)
+    implementation(platform("androidx.compose:compose-bom:2023.06.00"))
+    implementation("androidx.activity:activity-compose:1.7.2")
+    implementation("androidx.compose.ui:ui")
+    implementation("androidx.compose.ui:ui-tooling")
+    implementation("androidx.compose.runtime:runtime")
+    implementation("androidx.compose.foundation:foundation")
+    implementation("com.google.android.material:material")
 }
 ```
 
-This tutorial uses the compose version of the video SDK. Stream also provides a core library without compose.
+There are 2 versions of Stream's SDK.
+
+- **Video Compose SDK**: `io.getstream:stream-video-android-compose` dependency that includes the video core SDK + compose UI components.
+- **Video Core SDK**: `io.getstream:stream-video-android-core` that only includes the core parts of the video SDK.
+
+This tutorial demonstrates the Compose Video SDK, but you have the option to use the core library without Compose based on your preference.
 
 ### Step 3 - Broadcast a livestream from your phone
 
@@ -149,22 +162,18 @@ lifecycleScope.launch {
 }
 ```
 
-First call object is created by specifying the call type: "livestream" and the callId.
-The "livestream" call type is just a set a defaults that typically works well for a livestream.
-You can edit the features, permissions and settings in the dashboard.
-The dashboard also allows you to create new call types as needed.
+To create the first call object, specify the call type as **livestream** and provide a unique **callId**. The **livestream** call type comes with default settings that are usually suitable for livestreams, but you can customize features, permissions, and settings in the dashboard. Additionally, the dashboard allows you to create new call types as required.
 
-Lastly, call.join(create = true) creates the call object on our servers and joins it.
-The moment you use call.join() the realtime transport for audio and video is started.
+Finally, using `call.join(create = true)` will not only create the call object on our servers but also initiate the real-time transport for audio and video. This allows for seamless and immediate engagement in the livestream.
 
-Note that you can also add members to a call and assign them different roles. (See the [call creation docs](../03-guides/02-joining-creating-calls.mdx))
+Note that you can also add members to a call and assign them different roles. For more information, see the [call creation docs](../03-guides/02-joining-creating-calls.mdx)
 
 ### Step 4 - Rendering the video
 
 In this step we're going to build a UI for showing your local video with a button to start the livestream.
 This example uses Compose, but you could also use our XML VideoRenderer.
 
-In `MainActivity.kt` replace the `VideoTheme` with the following code.
+In `MainActivity.kt` replace the `VideoTheme` with the following code:
 
 ```kotlin
 VideoTheme {
@@ -183,7 +192,7 @@ VideoTheme {
             .background(VideoTheme.colors.appBackground)
             .padding(6.dp),
         contentColor = VideoTheme.colors.appBackground,
-        backgroundColor = VideoTheme.colors.appBackground,
+
         topBar = {
             if (connection == RealtimeConnection.Connected) {
                 if (!backstage) {
@@ -247,18 +256,18 @@ VideoTheme {
 }
 ```
 
-If you now run your app you should see an interface like this:
+Upon running your app, you will be greeted with an interface that looks like this:
 
 ![Livestream](../assets/tutorial-livestream.png)
 
 Stream uses a technology called SFU cascading to replicate your livestream over different SFUs around the world.
 This makes it possible to reach a large audience in realtime.
 
-Now let's press "go live" in the android app and click the link below to watch the video in your browser.
+Now let's press **Go live** in the android app and click the link below to watch the video in your browser.
 
 <TokenSnippet sampleApp='livestream' displayStyle='join' />
 
-Let's take a moment to review the Compose code above. Call.state exposes all the stateflow objects you need.
+Let's take a moment to review the Compose code above. `Call.state` exposes all the stateflow objects you need.
 
 The most important ones are:
 
@@ -269,8 +278,10 @@ call.state.participants
 
 The [participant state docs](../03-guides/03-call-and-participant-state.mdx) show all the available data.
 
-The livestream layout is built using standard Compose. The [VideoRenderer](../04-ui-components/02-video-renderer.mdx) component is provided by Stream.
-VideoRenderer renders the video and a fallback. You can use it for rendering the local and remote video.
+The livestream layout is built using standard Jetpack Compose. The [VideoRenderer](../04-ui-components/02-video-renderer.mdx) component is provided by Stream.
+**VideoRenderer** renders the video and a fallback. You can use it for rendering the local and remote video.
+
+If you want to learn more about building an advanced UIs for watching a livestream, check out [Cookbook: Watching a livestream](../05-ui-cookbook/15-watching-livestream.mdx).
 
 ### Step 4 - (Optional) Publishing RTMP using OBS
 
@@ -304,8 +315,6 @@ Compared to the current code in in `MainActivity.kt` you:
 * Don't render the local video, but instead render the remote video
 * Typically include some small UI elements like viewer count, a button to mute etc
 
-The [docs on building a UI for watching a livestream](../05-ui-cookbook/15-watching-livestream.mdx) explain this in more detail.
-
 ### Step 6 - (Optional) Viewing a livestream with HLS
 
 Another way to watch a livestream is using HLS. HLS tends to have a 10 to 20 seconds delay, while the above WebRTC approach is realtime.

docusaurus/docs/Android/05-ui-cookbook/15-watching-livestream.mdx

@@ -3,10 +3,10 @@ title: Watching a livestream
 description: How to watch a livestream on android with Kotlin
 ---
 
-This cookbook tutorial walks you through how to render the UI for watching a livestream on Android.
+This cookbook tutorial walks you through how to build an advanced UIs for watching a livestream on Android.
 
 :::note
-This cookbook tutorial will skip how to join a livestream call. If you didn't learn about the [Livestream Tutorial](../02-tutorials/03-livestream.mdx), we highly recommend you to read about the tutorial first.
+n this cookbook tutorial, we will assume that you already know how to join a livestream call. If you haven't familiarized yourself with the [Livestream Tutorial](../02-tutorials/03-livestream.mdx) yet, we highly recommend doing so before proceeding with this cookbook.
 :::
 
 When you build a livestreaming UI, there are a few things to keep in mind:
@@ -27,9 +27,9 @@ In this cookbook tutorial, you'll learn how to build the result below at the end
 
 ### Rendering Livestreaming
 
-First thing first, you need to render a livestreaming video, which is the most important part in the screen.
+First and foremost, rendering the livestreaming video is the key feature and the most crucial part of the screen.
 
-You can simply render your livestreaming video like the sample below:
+To accomplish this, you can easily render your livestreaming video using the following simple sample code:
 
 ```kotlin
 val userToken = "REPLACE_WITH_TOKEN"
@@ -91,9 +91,9 @@ If you run the above example, you'll see the very basic video streaming screen b
 
 ### Implement Live Participants Label
 
-Now you need to build labels that indicates the count of participants of your livestreaming, and streaming time.
+Now you need to build labels that display the count of participants in your livestreaming session and indicate the streaming time.
 
-You can simply implement the live label like so:
+You can easily implement the live label using the following approach:
 
 ```kotlin
 @Composable
@@ -133,13 +133,13 @@ fun LiveLabel(
 }
 ```
 
-If you build a preview for `LiveLabel` Composable, you'll see the result below:
+Upon building a preview for the `LiveLabel` Composable, you will observe the following result:
 
 ![LiveLabel](../assets/cookbook/livestream-live-label.png)
 
 ### Implement Live Time Label
 
-Next, you need to implement the live time label, which indicates the time duration once your start live streaming.
+Next, you need to implement the live time label, which will display the duration of the livestream once it starts.
 
 You can simply implement the live time label like so:
 
@@ -239,7 +239,7 @@ VideoTheme {
 }
 ```
 
-As you can see above example, you can see some of state declaration from the call state:
+As demonstrated in the example above, you can observe several state declarations representing the call state.:
 
 - `participantCount`: A model that contains information about participant counts.
 - `connection`: Indicates the connection state of a call.
@@ -250,7 +250,7 @@ As you can see above example, you can see some of state declaration from the cal
 
 ### Implement Live Button
 
-Now let's build a live button that allows you to start/stop broadcast your call, and controls your physical device, such as camera and microphone.
+Let's proceed with building a live button that enables you to start/stop broadcasting your call and control your physical device, including the camera and microphone.
 
 You can implement the live button like so:
 
@@ -353,8 +353,10 @@ Scaffold(
  }
 ```
 
-After building your project, you'll see the final result below:
+Once you've completed building your project, you'll witness the final result as depicted below:
 
 ![LiveStream Backstage](../assets/cookbook/livestream-backstage.png)
 
-You can broadcast your stream by clicking the **Go Live** button.
+By simply clicking the **Go Live** button, you can begin broadcasting your stream.
+
+In this cookbook tutorial, you have learned how to create an advanced live streaming screen. If you wish to refer to the code, feel free to explore the [GitHub Repository](https://github.com/GetStream/stream-video-android/tree/develop/tutorials/tutorial-livestream).

docusaurus/docs/Android/06-advanced/04-chat-with-video.mdx

@@ -31,7 +31,7 @@ Let the project sync. It should have all the dependencies required for you to fi
 ```groovy
 dependencies {
     // Stream Video Compose SDK
-    implementation("io.getstream:stream-video-android-compose:0.2.0")
+    implementation("io.getstream:stream-video-android-compose:0.2.1")
     
     // Stream Chat
     implementation(libs.stream.chat.compose)

stream-video-android-compose/src/main/kotlin/io/getstream/video/android/compose/ui/components/audio/AudioRoomContent.kt

@@ -109,7 +109,6 @@ public fun AudioRoomContent(
             .background(VideoTheme.colors.appBackground)
             .padding(32.dp),
         contentColor = VideoTheme.colors.appBackground,
-        backgroundColor = VideoTheme.colors.appBackground,
         topBar = {
             if (isShowingAppBar) {
                 appBarContent.invoke(call)