fix set volume error

Author: Nevermore1994

demo/Android/app/src/main/java/com/slark/demo/ui/component/CustomSlider.kt

@@ -9,6 +9,10 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.geometry.CornerRadius
 import androidx.compose.ui.geometry.Offset
 import androidx.compose.foundation.Canvas
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.geometry.Size
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.input.pointer.pointerInput
@@ -33,6 +37,7 @@ fun CustomSlider(
 ) {
     val thumbRadiusPx = with(LocalDensity.current) { thumbRadius.toPx() }
     val trackHeightPx = with(LocalDensity.current) { trackHeight.toPx() }
+    var newValue by remember { mutableStateOf(value) }
 
     BoxWithConstraints(
         modifier = modifier
@@ -41,7 +46,7 @@ fun CustomSlider(
                 detectTapGestures { offset ->
                     val width = size.width - thumbRadiusPx * 2
                     val fraction = ((offset.x - thumbRadiusPx) / width).coerceIn(0f, 1f)
-                    val newValue = lerp(valueRange.start, valueRange.endInclusive, fraction)
+                    newValue = lerp(valueRange.start, valueRange.endInclusive, fraction)
                     onValueChange(newValue, true)
                 }
             }
@@ -54,11 +59,11 @@ fun CustomSlider(
                         change.consume()
                         val width = size.width - thumbRadiusPx * 2
                         val fraction = ((change.position.x - thumbRadiusPx) / width).coerceIn(0f, 1f)
-                        val newValue = lerp(valueRange.start, valueRange.endInclusive, fraction)
+                        newValue = lerp(valueRange.start, valueRange.endInclusive, fraction)
                         onValueChange(newValue, false)
                     },
                     onDragEnd = {
-                        onValueChange(value, true)
+                        onValueChange(newValue, true)
                     }
                 )
             }

demo/Android/app/src/main/java/com/slark/demo/ui/component/PlayerControls.kt

@@ -33,15 +33,6 @@ fun PlayerControls(
     viewModel: PlayerViewModel,
     modifier: Modifier = Modifier
 ) {
-    val isPlaying = viewModel.isPlaying
-    val progress by remember {
-        derivedStateOf {
-            val current = viewModel.currentTime
-            val total = viewModel.totalTime
-            if (total > 0)  current.toFloat() / total.toFloat() else 0f
-        }
-    }
-
     Column(
         modifier = modifier.fillMaxWidth().padding(16.dp),
         horizontalAlignment = Alignment.CenterHorizontally,
@@ -94,10 +85,12 @@ fun PlayerControlBar(viewModel: PlayerViewModel) {
 
         CustomSlider(
             value = viewModel.volume,
-            onValueChange = {  t, _ -> viewModel.volume = t },
-            valueRange = 0f..1f,
+            onValueChange = {  t, _ ->
+                viewModel.volume = t
+            },
+            valueRange = 0f..100f,
             trackColor = Color.LightGray,
-            activeColor = Color(0xFFA9A9A9),
+            activeColor = Color(0xFFE6E6E6),
             modifier = Modifier
                 .constrainAs(volumeSlider) {
                     start.linkTo(volumeIcon.end)

demo/Android/app/src/main/java/com/slark/demo/ui/component/PlayerScreen.kt

@@ -87,7 +87,7 @@ fun PlayerScreen(
         if (controlsVisible) {
             hideJob?.cancel()
             hideJob = CoroutineScope(Dispatchers.Main).launch {
-                delay(3000)
+                delay(5000)
                 controlsVisible = false
             }
         }

demo/Android/app/src/main/java/com/slark/demo/ui/model/PlayerViewModel.kt

@@ -19,20 +19,23 @@ import com.slark.sdk.SlarkLog
 
 class PlayerViewModel(private var player: SlarkPlayer?) : ViewModel() {
     var isPlaying by mutableStateOf(false)
-        //private set
+
 
     var currentTime by mutableStateOf(0.0)
-       // private set
 
     var totalTime by mutableStateOf(0.0)
-        //private set
 
     var cacheTime by mutableStateOf(0.0)
-        //private set
 
     var isLoading by mutableStateOf(false)
 
-    var volume by mutableStateOf(100.0f)
+    private var _volume = mutableStateOf(100.0f)
+    var volume: Float
+        get() = _volume.value
+        set(value) {
+            player?.volume = value
+            _volume.value = value
+        }
 
     var isLoop by mutableStateOf(false)
 
@@ -125,10 +128,6 @@ class PlayerViewModel(private var player: SlarkPlayer?) : ViewModel() {
         player?.setRenderSize(width, height)
     }
 
-    fun setRotation(rotation: Int) {
-        player?.setRotation(rotation)
-    }
-
     fun loop(isLoop: Boolean) {
         player?.isLoop = isLoop
         this.isLoop = isLoop
@@ -163,12 +162,7 @@ class PlayerViewModel(private var player: SlarkPlayer?) : ViewModel() {
         player?.setRenderTarget(SlarkRenderTarget.FromSurface(surface, size.width.toInt(), size.height.toInt()))
     }
 
-    fun stop() {
-        player?.stop()
-    }
-
     fun release() {
-        player?.stop()
         player?.release()
     }
 

src/core/PlayerImpl.cpp

@@ -1097,6 +1097,7 @@ void Player::Impl::setLoop(
     params_.withWriteLock([isLoop](auto& p){
         p->setting.isLoop = isLoop;
     });
+    ownerThread_->start();
 }
 
 void Player::Impl::setVolume(
@@ -1105,6 +1106,7 @@ void Player::Impl::setVolume(
     auto ptr = buildEvent(EventType::UpdateSettingVolume);
     ptr->data = std::make_any<float>(volume);
     sender_->send(std::move(ptr));
+    ownerThread_->start();
 }
 
 void Player::Impl::setMute(
@@ -1113,6 +1115,7 @@ void Player::Impl::setMute(
     auto ptr = buildEvent(EventType::UpdateSettingMute);
     ptr->data = std::make_any<bool>(isMute);
     sender_->send(std::move(ptr));
+    ownerThread_->start();
 }
 
 PlayerState Player::Impl::state() noexcept {

src/platform/Android/sdk/src/main/cpp/PlayerManager.cpp

@@ -199,7 +199,6 @@ enum class Action {
     Prepare = 0,
     Play,
     Pause,
-    Stop,
     Release
 };
 
@@ -292,10 +291,6 @@ Java_com_slark_sdk_SlarkPlayerManager_00024Companion_doAction(
                 player->pause();
             }
                 break;
-            case Action::Stop: {
-                player->stop();
-            }
-                break;
             case Action::Release: {
                 player->stop();
                 PlayerObserverManager::shareInstance().remove(playerId);

src/platform/Android/sdk/src/main/java/com/slark/api/SlarkPlayer.kt

@@ -1,53 +1,125 @@
 package com.slark.api
 
-import android.util.Size
 import com.slark.sdk.SlarkPlayerImpl
 
 /**
  * SlarkPlayer interface that defines the methods for a media player.
  */
 
 interface SlarkPlayer {
+    /**
+     * @param isLoop: value from true to false
+     */
     var isLoop: Boolean
 
+    /**
+     * @param isMute: value from true to false
+     */
     var isMute: Boolean
 
+    /**
+     * @param volume: value from 0.0 to 100.0
+     */
     var volume: Float
 
+    /**
+     * Prepare the player with the given configuration.
+     * This method should be called before any playback actions.
+     */
     fun prepare()
 
-    fun getPlayerId(): String
+    /**
+     * Get the player ID.
+     * This ID is used to identify the player instance in the system.
+     */
+    fun playerId(): String
 
+    /**
+     * Start playback of the media.
+     * This method should be called after prepare() to start playing the media.
+     */
     fun play()
 
+    /**
+     * Pause the playback of the media.
+     * This method can be called to pause the media playback.
+     */
     fun pause()
 
-    fun stop()
+    /**
+     * Stop the playback of the media.
+     * This method stops the media playback and dispose media resources.
+     */
+    fun release()
 
     /**
      * @param time: seconds
      * @param isAccurate:  Accurate seek is only performed when the user releases the progress slider.
      */
     fun seekTo(time: Double, isAccurate: Boolean)
 
-    fun release()
-
+    /**
+     * Set the observer for player events.
+     * The observer will receive notifications about player state changes and events.
+     */
     fun setObserver(observer: SlarkPlayerObserver?)
 
+    /**
+     * Set the render target for the player.
+     * The render target is where the player will render the video frames.
+     */
     fun setRenderTarget(renderTarget: SlarkRenderTarget)
 
+    /**
+     * Get the current state of the player.
+     * This method returns the current state of the player, such as playing, paused, buffering, etc.
+     */
+    fun state(): SlarkPlayerState
+
+    /**
+     * Get the total duration of the media in seconds.
+     * This method returns the total duration of the media being played by the player.
+     */
     fun totalDuration(): Double
 
+    /**
+     * Get the current played time of the media in seconds.
+     * This method returns the current played time of the media.
+     */
     fun currentTime(): Double
 
+    /**
+     * Request a render update with the given texture ID and size.
+     * This method is used to request a render update for the player.
+     */
     fun setRenderSize(width: Int, height: Int)
 
-    fun setRotation(rotation: Int) // 0, 90, 180, 270 degrees
+    enum class Rotation {
+        ROTATION_0,   // 0 degrees
+        ROTATION_90,  // 90 degrees
+        ROTATION_180, // 180 degrees
+        ROTATION_270  // 270 degrees
+    }
+    /**
+     * Set the rotation of the video.
+     * The rotation can be 0, 90, 180, or 270 degrees.
+     */
+    fun setRotation(rotation: Rotation)
 
+    /**
+     * Handle background state changes.
+     * This method is called when the player goes into the background or comes back to the foreground.
+     * @param isBackground: true if the player is in the background, false if it is in the foreground.
+     */
     fun onBackground(isBackground: Boolean)
 }
 
 object SlarkPlayerFactory {
+    /**
+     * Create a SlarkPlayer instance with the given configuration.
+     * @param config: The configuration for the player.
+     * @return A new instance of SlarkPlayer, or null if creation fails.
+     */
     fun createPlayer(config: SlarkPlayerConfig): SlarkPlayer? {
         val player = SlarkPlayerImpl.create(config)
         return player

src/platform/Android/sdk/src/main/java/com/slark/sdk/SlarkPlayerImpl.kt

@@ -9,6 +9,7 @@ import android.view.TextureView
 import android.view.View
 import com.slark.api.KtTimeRange
 import com.slark.api.SlarkPlayer
+import com.slark.api.SlarkPlayer.Rotation
 import com.slark.api.SlarkPlayerConfig
 import com.slark.api.SlarkPlayerObserver
 import com.slark.api.SlarkPlayerState
@@ -18,6 +19,7 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 import kotlin.math.ceil
+import kotlin.math.min
 
 
 class SlarkPlayerImpl(val config: SlarkPlayerConfig, private val playerId: String): SlarkPlayer {
@@ -41,11 +43,11 @@ class SlarkPlayerImpl(val config: SlarkPlayerConfig, private val playerId: Strin
 
     override var volume: Float = 100.0f
         set(value) {
-            field = value
-            SlarkPlayerManager.setVolume(playerId, value)
+            field = min(100.0f, maxOf(0.0f, value))
+            SlarkPlayerManager.setVolume(playerId, field)
         }
 
-    override fun getPlayerId(): String {
+    override fun playerId(): String {
         return playerId
     }
 
@@ -61,10 +63,6 @@ class SlarkPlayerImpl(val config: SlarkPlayerConfig, private val playerId: Strin
         SlarkPlayerManager.doAction(playerId, SlarkPlayerManager.Action.PAUSE.ordinal)
     }
 
-    override fun stop() {
-        SlarkPlayerManager.doAction(playerId, SlarkPlayerManager.Action.STOP.ordinal)
-    }
-
     override fun release() {
         SlarkPlayerManager.doAction(playerId, SlarkPlayerManager.Action.RELEASE.ordinal)
         SlarkPlayerManager.removePlayer(playerId)
@@ -98,8 +96,13 @@ class SlarkPlayerImpl(val config: SlarkPlayerConfig, private val playerId: Strin
         renderThread?.setRenderSize(width, height)
     }
 
-    override fun setRotation(rotation: Int) {
-        renderThread?.setRotation(rotation)
+    override fun setRotation(rotation: Rotation) {
+        when (rotation) {
+            Rotation.ROTATION_0 -> renderThread?.setRotation(0)
+            Rotation.ROTATION_90 -> renderThread?.setRotation(90)
+            Rotation.ROTATION_180 -> renderThread?.setRotation(180)
+            Rotation.ROTATION_270 -> renderThread?.setRotation(270)
+        }
     }
 
     override fun onBackground(isBackground: Boolean) {
@@ -125,11 +128,7 @@ class SlarkPlayerImpl(val config: SlarkPlayerConfig, private val playerId: Strin
         return SlarkPlayerManager.currentPlayedTime(playerId)
     }
 
-    fun playerId(): String {
-        return playerId
-    }
-
-    fun state(): SlarkPlayerState {
+    override fun state(): SlarkPlayerState {
         return SlarkPlayerManager.state(playerId)
     }
 

src/platform/Android/sdk/src/main/java/com/slark/sdk/SlarkPlayerManager.kt

@@ -9,7 +9,6 @@ class SlarkPlayerManager {
         PREPARE,
         PLAY,
         PAUSE,
-        STOP,
         RELEASE
     }