From: luozheng <1732036298@qq.com>
Date: Tue, 12 Mar 2024 12:42:29 +0000 (+0800)
Subject: 录音实现：播放，暂停，播放中切换到另一个录音，目前还未实现切换上一首，下一首，声音调节功能
X-Git-Tag: release_V1.2.70_20241020_135402~1274^2~19^2~2
X-Git-Url: http://git.snicker.com.cn/Users/apple/Desktop/static/gitweb.css?a=commitdiff_plain;h=1f41a199ea1feb1af60cedad4b448e96cedf16d7;p=mirrors%2FFD230.git

录音实现：播放，暂停，播放中切换到另一个录音，目前还未实现切换上一首，下一首，声音调节功能
---

diff --git a/code/sdk/application/wearable/fd230app/nativeui/record/include/RecordingModel.h b/code/sdk/application/wearable/fd230app/nativeui/record/include/RecordingModel.h
index d77dfcbcc..3e0fa09e8 100644
--- a/code/sdk/application/wearable/fd230app/nativeui/record/include/RecordingModel.h
+++ b/code/sdk/application/wearable/fd230app/nativeui/record/include/RecordingModel.h
@@ -46,16 +46,19 @@ namespace OHOS
         std::string GetRecordingPlayerUri(void);
         void SetRecordingPlayerUri(std::string src);
         void SetRecordingPlayButtonState(bool state);
+        void SetCircleProgress(int value);
         void AudioInit(void);
         void ConvertMillisecondToTime(int32_t milliseconds);
         int RecordingPlayerInit(void);
         int RecordingPlayerStat(void);
-        int BasePlayerStateOperate(int state);
         int GetRecordingPlayerState(void);
-        bool HasRecordingPlayerPlayed(void);
         int RecordingPlayerPlay(void);
         int RecordingPlayerPause(void);
-
+        int RecordingPlayerStop(void);
+        void NextSong(int index);
+        void PreviousPlayout(void);
+        int ResetSourceAndPrepare(void);
+        int ResetPlayerModuleStatus(void);
         /* -------------------------------------------------------------------------- */
         void InitRecordingListItem();
         std::vector<RecordingListItem> &GetRecordinglistItems();
@@ -63,12 +66,15 @@ namespace OHOS
         std::string GetCleanFileName(const std::string &filePath);
         void SearchFiles(const std::string &directory, std::vector<std::string> &fileNames, int &mp3FileCount);
         void KeepClickRecordingIndex(int index_);
-        int GetClickRecordingIndex(void);
+        int &GetClickRecordingIndex(void);
         std::vector<std::string> &GetFileNames(void);
         void KeepTotalRecordDuration(std::string time);
         std::string GetTotalRecordDuration(void) const;
         std::string Getyyyymmhhh_date(void) const;
-
+        std::shared_ptr<RecordingPlayerInterruptListener> GetRecordingPlayerIntrptListener(void);
+        void ClearActivateAudioInterrupt(void);
+        std::shared_ptr<Player> GetPlayerCtr(void);
+        void SetAudioInitStatus(bool value);
         /* ----------------------------------- 定时器 ---------------------------------- */
         void Recording_StartTimer(uint32_t interval);
         void Recording_StopTimer(void);
@@ -83,6 +89,7 @@ namespace OHOS
     private:
         int64_t DurationTime{0};                                                                       // 播放时长，单位ms
         bool PlayButtonState{false};                                                                   // 播放按钮状态
+        int CircleProgress{0};                                                                         // 播放进度
         bool IsActivateAudioInterrupt{false};                                                          // 是否激活音频中断
         AudioSession SessionId;                                                                        // 音频会话ID
         AudioInterrupt interrupt;                                                                      // 音频中断管理
diff --git a/code/sdk/application/wearable/fd230app/nativeui/record/include/RecordingPlayerView.h b/code/sdk/application/wearable/fd230app/nativeui/record/include/RecordingPlayerView.h
index 9524bf282..dae2180f5 100644
--- a/code/sdk/application/wearable/fd230app/nativeui/record/include/RecordingPlayerView.h
+++ b/code/sdk/application/wearable/fd230app/nativeui/record/include/RecordingPlayerView.h
@@ -54,6 +54,9 @@ namespace OHOS
         void ClearAll(void);
         UILabelExt * GetRecordingFileNameLabel(void);
         UILabelExt *GetRecordingTimeAndDurationLabel(void);
+        UICheckBox * GetPlayerButton(void);
+        void SetPlayerButtonState(UICheckBox::UICheckBoxState state);
+        UICircleProgress * GetPlayerProgressBar(void);
     private:
         UILabelExt *SetUpLabel(LabelConfig &labelconfig); // 设置标签
         UIButton *SetTheButton(ButtonConfig &buttonconfig, UIView::OnClickListener *clickListener);
diff --git a/code/sdk/application/wearable/fd230app/nativeui/record/include/RecordingPresenter.h b/code/sdk/application/wearable/fd230app/nativeui/record/include/RecordingPresenter.h
index e273b4280..25c844333 100644
--- a/code/sdk/application/wearable/fd230app/nativeui/record/include/RecordingPresenter.h
+++ b/code/sdk/application/wearable/fd230app/nativeui/record/include/RecordingPresenter.h
@@ -6,6 +6,7 @@
 #include "KeyInputListener.h"
 #include "common/key_code.h"
 #include "record/include/RecordingModel.h"
+#include <media_thread_adapt.h>
 namespace OHOS
 {
     typedef enum
@@ -36,7 +37,7 @@ namespace OHOS
     static const char *RECORD_DELETE_ON_BUTTON_VIEWID = "RECORD_DELETE_ON_BUTTON";   // 录音删除
     static const char *RECORD_DELETE_OFF_BUTTON_VIEWID = "RECORD_DELETE_OFF_BUTTON"; // 录音不删除
 
-// 播放器中断监听
+    // 播放器中断监听
     class RecordingPlayerInterruptListener : public InterruptListener
     {
     public:
@@ -46,7 +47,7 @@ namespace OHOS
         void SetOwner(std::shared_ptr<Player> player);
         void SetPaused(bool value);
         void SetResumed(bool value);
-        void RestFlag();
+        void ResetFlag();
         bool IsPaused();
         bool IsDelayed();
         bool IsResumed();
diff --git a/code/sdk/application/wearable/fd230app/nativeui/record/src/RecordingModel.cpp b/code/sdk/application/wearable/fd230app/nativeui/record/src/RecordingModel.cpp
index 16c3bfd8d..6e9e39baa 100644
--- a/code/sdk/application/wearable/fd230app/nativeui/record/src/RecordingModel.cpp
+++ b/code/sdk/application/wearable/fd230app/nativeui/record/src/RecordingModel.cpp
@@ -24,7 +24,7 @@ namespace OHOS
     static MutexId g_mutex;
     RecordingModel::RecordingModel()
     {
-        g_mutex = MUTEX_InitValue();
+        // g_mutex = MUTEX_InitValue();
     }
 
     RecordingModel::~RecordingModel()
@@ -55,9 +55,6 @@ namespace OHOS
         Uri = src;
     }
 
-    /// @brief 设置录音播放按钮状态
-    /// @param state true
-
     /*
      * @brief 设置录音播放按钮状态
      * @param state true 开启
@@ -68,6 +65,42 @@ namespace OHOS
         PlayButtonState = state;
     }
 
+    /*
+     * @brief 设置播放进度
+     */
+    void RecordingModel::SetCircleProgress(int value)
+    {
+        CircleProgress = value;
+    }
+    /*
+     * @brief 获取录音播放器中断监听类
+     */
+    std::shared_ptr<RecordingPlayerInterruptListener> RecordingModel::GetRecordingPlayerIntrptListener(void)
+    {
+        return p_RecordingPlayerInterruptListener;
+    }
+
+    /*
+     * @brief 清除音频中断
+     */
+    void RecordingModel::ClearActivateAudioInterrupt(void)
+    {
+        IsActivateAudioInterrupt = false;
+    }
+
+    std::shared_ptr<Player> RecordingModel::GetPlayerCtr(void)
+    {
+        return PlayerCtr;
+    }
+
+    /*
+     * @brief  设置是否音频已经初始化过
+     */
+    void RecordingModel::SetAudioInitStatus(bool value)
+    {
+        audioInitStatus = value;
+    }
+
     /*
      * @brief 初始化音频系统并准备播放器控制器和回调
      */
@@ -134,17 +167,23 @@ namespace OHOS
             WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "No Recording files!!");
             return OHOS_FAILURE;
         };
-        Uri = directory + recordingFileName + ".mp3";
-        /* ------------------------------ 设置播放器的回调函数。 ----------------------------- */
-        PlayerCtr->SetPlayerCallback(PlayerCallback);
+        SetRecordingPlayerUri(directory + recordingFileName + ".mp3");
+
+        int state = GetRecordingPlayerState();
+        if (state != PlayerStates::PLAYER_STATE_ERROR) // 每次setSource前回到idle状态
+        {
+            ret = PlayerCtr->Reset();
+            WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "Reset, ret:%d", ret);
+        }
+
         /* ------------------------- 创建资源对象Resource并进行资源申请。 ------------------------- */
-        Resource = std::make_shared<Source>(Uri);
+        Resource = std::make_shared<Source>(GetRecordingPlayerUri());
         if (Resource.get() == nullptr)
         {
             WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "source request failed!");
             return OHOS_FAILURE;
         }
-        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Player Uri %s", Uri.c_str());
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Player Uri %s", GetRecordingPlayerUri().c_str());
         /* ----------------------- 设置播放器的数据源为Resource，并进行准备操作。 ---------------------- */
         PlayerCtr->SetSource(*Resource);
         PlayerCtr->Prepare();
@@ -160,7 +199,6 @@ namespace OHOS
             return OHOS_FAILURE;
         }
         ConvertMillisecondToTime(DurationTime);
-
         return OHOS_SUCCESS;
     }
 
@@ -170,6 +208,10 @@ namespace OHOS
     int RecordingModel::RecordingPlayerStat()
     {
         int ret;
+        /* ------------------------------ 设置播放器的回调函数。 ----------------------------- */
+        ResetPlayerModuleStatus();
+        ResetSourceAndPrepare();
+        PlayerCtr->SetPlayerCallback(PlayerCallback);
         /* ----------------------------- 如果未激活音频中断处理： ----------------------------- */
         if (!IsActivateAudioInterrupt)
         {
@@ -222,52 +264,6 @@ namespace OHOS
         return OHOS_SUCCESS;
     }
 
-    /*
-     * @brief 根据播放器不同状态执行相应的操作
-     */
-    int RecordingModel::BasePlayerStateOperate(int state)
-    {
-        int ret;
-        if (state == PlayerStates::PLAYER_PAUSED || state == PlayerStates::PLAYER_STOPPED)
-        {
-            /* --------------------------- 如果播放器状态为暂停或停止，则开始播放 -------------------------- */
-            ret = RecordingPlayerStat(); // 播放
-            if (ret != 0)
-            {
-                WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "PlayerStat err, ret:%d", ret);
-                return RECORDER_EXECUTE_FUNC_FAILED;
-            }
-            RecordingModel::GetInstance()->SetRecordingPlayButtonState(true); // 播放控件图形同步
-            return RECORDER_NORMAL;
-        }
-        else if (state == PlayerStates::PLAYER_STARTED || state == PlayerStates::PLAYER_PLAYBACK_COMPLETE)
-        {
-            /* ----------------------------- 如果是开始播放或者是播放完成 ----------------------------- */
-            ret = PlayerCtr->Stop(); // 停止
-            ret = PlayerCtr->Reset();
-            ret = RecordingPlayerStat(); // 播放
-            if (ret != 0)
-            {
-                /* stop and exit */
-                ret = PlayerCtr->Stop(); // 停止
-                ret = PlayerCtr->Reset();
-            }
-            return RECORDER_ALREADY_PLAYING;
-        }
-        else
-        {
-            /* ---------------------------- 其他情况，执行播放器状态相关操作 ---------------------------- */
-            ret = RecordingModel::GetInstance()->RecordingPlayerStat();
-            if (ret != 0)
-            {
-                WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "PlayerStat err, ret:%d", ret);
-                return RECORDER_EXECUTE_FUNC_FAILED;
-            }
-            RecordingModel::GetInstance()->SetRecordingPlayButtonState(true); // 播放控件图形同步
-            return RECORDER_NORMAL;
-        }
-    }
-
     /*
      * @brief 获取录音播放器状态
      */
@@ -277,7 +273,7 @@ namespace OHOS
         /* ------------------------------ 检查播放器控制对象是否为空 ----------------------------- */
         if (PlayerCtr.get() == nullptr)
         {
-            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "playerCtr.get() is nullptr!!");
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "PlayerCtr.get() is nullptr!!");
             return OHOS_FAILURE;
         }
         int32_t state;
@@ -286,26 +282,36 @@ namespace OHOS
     }
 
     /*
-     * @brief 判断播录音放器是否已经播放过
+     * @brief 重新设置SetSource和Prepare
      */
-    bool RecordingModel::HasRecordingPlayerPlayed(void)
+    int RecordingModel::ResetSourceAndPrepare(void)
     {
-        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[RecordingModel] HasRecordingPlayerPlayed");
-        int state = GetRecordingPlayerState();
-        if (state == OHOS_FAILURE)
+        WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "RecordingModel::ResetSourceAndPrepare");
+        if (PlayerCtr.get() == nullptr)
         {
-            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Get Player State failed!!");
-            return false;
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "PlayerCtr.get() is nullptr!!");
+            return OHOS_FAILURE;
         }
-        if (state != PlayerStates::PLAYER_STARTED && state != PlayerStates::PLAYER_PAUSED &&
-            state != PlayerStates::PLAYER_STOPPED && state != PlayerStates::PLAYER_PLAYBACK_COMPLETE)
+        PlayerCtr->SetSource(*Resource);
+        PlayerCtr->Prepare();
+
+        return OHOS_SUCCESS;
+    }
+
+    /*
+     * @brief 重置播放器到IDLE状态
+     */
+    int RecordingModel::ResetPlayerModuleStatus(void)
+    {
+        WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "RecordingModel::ResetPlayerModuleStatus");
+        if (PlayerCtr.get() == nullptr)
         {
-            if (!isStopAndReset)
-            {
-                return false;
-            }
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "PlayerCtr.get() is nullptr!!");
+            return OHOS_FAILURE;
         }
-        return true;
+        PlayerCtr->Reset();
+
+        return OHOS_SUCCESS;
     }
 
     /*
@@ -315,15 +321,14 @@ namespace OHOS
     {
         WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "RecordingModel::RecordingPlayerPlay");
         /* -------------------------------- 获取播放器状态 ------------------------------- */
+        int32_t ret;
         int32_t state = GetRecordingPlayerState();
         if (state == OHOS_FAILURE)
         {
             WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Get state of player failed!!");
             return OHOS_FAILURE;
         }
-
-        int ret;
-        if (state == PlayerStates::PLAYER_PAUSED || state == PlayerStates::PLAYER_STOPPED) // 暂停状态则直接开始
+        if (state == PlayerStates::PLAYER_PAUSED) // 暂停状态则直接开始
         {
             ret = PlayerCtr->Play();
             if (ret != 0)
@@ -334,7 +339,7 @@ namespace OHOS
             SetRecordingPlayButtonState(true); // 播放控件图形同步
             return OHOS_SUCCESS;
         }
-        else if (state == PlayerStates::PLAYER_STARTED || state == PlayerStates::PLAYER_PLAYBACK_COMPLETE) // 已经在播放状态则不做操作
+        else if (state == PlayerStates::PLAYER_STARTED) // 已经在播放状态则不做操作
         {
             return RECORDER_ALREADY_PLAYING;
         }
@@ -373,7 +378,11 @@ namespace OHOS
         {
             return RECORDER_ALREADY_STOPPED;
         }
-        else if (state == PlayerStates::PLAYER_STARTED || state == PlayerStates::PLAYER_PLAYBACK_COMPLETE)
+        else if (state == PlayerStates::PLAYER_PLAYBACK_COMPLETE)
+        {
+            return RECORDER_PLAYBACK_COMPLETED;
+        }
+        else if (state == PlayerStates::PLAYER_STARTED)
         {
             int ret = PlayerCtr->Pause();
             if (ret != 0)
@@ -391,6 +400,136 @@ namespace OHOS
         return OHOS_SUCCESS;
     }
 
+    /*
+     * @brief 录音播放器停止
+     */
+    int RecordingModel::RecordingPlayerStop(void)
+    {
+        WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "RecordingModel::RecordingPlayerStop");
+        int32_t state = GetRecordingPlayerState();
+        if (state == OHOS_FAILURE)
+        {
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Get state of player failed!!");
+            return OHOS_FAILURE;
+        }
+
+        if (state == PlayerStates::PLAYER_STARTED || state == PlayerStates::PLAYER_PLAYBACK_COMPLETE)
+        {
+            int ret = PlayerCtr->Stop();
+            if (ret != 0)
+            {
+                WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Stop err, ret:%d", ret);
+                return OHOS_FAILURE;
+            }
+            ret = PlayerCtr->Reset();
+            if (ret != 0)
+            {
+                WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Reset err, ret:%d", ret);
+                return OHOS_FAILURE;
+            }
+            else
+            {
+                isStopAndReset = true;
+                SetRecordingPlayButtonState(false);
+                SetCircleProgress(0);
+            }
+            AudioManager::GetInstance().DeactivateAudioInterrupt(interrupt);
+            return OHOS_SUCCESS;
+        }
+        else if (state == PlayerStates::PLAYER_PAUSED)
+        {
+            int ret = PlayerCtr->Reset();
+            if (ret != 0)
+            {
+                WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Reset err, ret:%d", ret);
+                return OHOS_FAILURE;
+            }
+            else
+            {
+                SetRecordingPlayButtonState(false);
+                SetCircleProgress(0);
+            }
+            AudioManager::GetInstance().DeactivateAudioInterrupt(interrupt);
+            return OHOS_SUCCESS;
+        }
+        else if (state == PlayerStates::PLAYER_STOPPED)
+        {
+            return RECORDER_ALREADY_STOPPED;
+        }
+        return OHOS_SUCCESS;
+    }
+
+    void RecordingModel::NextSong(int index)
+    {
+        WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, " RecordingModel::NextSong");
+
+        std::string recordingFileName = fileNames[index];
+        if (recordingFileName.c_str() == nullptr)
+        {
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "No Recording files!!");
+            return;
+        };
+        SetRecordingPlayerUri(directory + recordingFileName + ".mp3");
+        /* -------------------------------------------------------------------------- */
+        int32_t playerState = GetRecordingPlayerState();
+        if (playerState == OHOS_FAILURE)
+        {
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Get playerState of player failed!!");
+            return;
+        }
+        int ret;
+        if ((playerState == PlayerStates::PLAYER_STARTED) || (playerState == PlayerStates::PLAYER_PLAYBACK_COMPLETE))
+        {
+            /* start play */
+            WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "start play, 160.");
+            ret = PlayerCtr->Stop(); // 停止
+            WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "Stop, ret:%d", ret);
+            ret = PlayerCtr->Reset();
+            WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "Reset, ret:%d", ret);
+            ret = RecordingPlayerStat(); // 播放
+            if (ret != 0)
+            {
+                /* stop and exit */
+                ret = PlayerCtr->Stop(); // 停止
+                ret = PlayerCtr->Reset();
+            }
+        }
+        else if (playerState == PlayerStates::PLAYER_PAUSED || (playerState == PlayerStates::PLAYER_IDLE) || PlayerStates::PLAYER_PAUSED)
+        {
+            ret = PlayerCtr->Reset();
+            WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "Reset, ret:%d", ret);
+        }
+        ret = RecordingPlayerStat();
+        if (ret != OHOS_SUCCESS)
+        {
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "PlayerStat err, ret:%d", ret);
+            return;
+        }
+        SetRecordingPlayButtonState(true); // 播放控件图形同步
+    }
+
+    /*
+     * @brief 上一首录音播放
+     */
+    void RecordingModel::PreviousPlayout(void)
+    {
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "PreviousPlayout, index %d.", GetClickRecordingIndex());
+        if ((GetClickRecordingIndex() > GetRecordingListNum() - 1) || (GetClickRecordingIndex() < 0))
+        {
+            WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "currentIndex err");
+            KeepClickRecordingIndex(0);
+            return;
+        }
+        GetClickRecordingIndex()--; // 上一曲
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "PreviousPlayout, index %d.", GetClickRecordingIndex());
+        if (GetClickRecordingIndex() < 0)
+        {
+            KeepClickRecordingIndex(GetRecordingListNum() - 1);
+        }
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "PreviousPlayout, index %d.", GetClickRecordingIndex());
+        NextSong(GetClickRecordingIndex());
+    }
+
     /*
      * @brief 获取纯净.mp3后缀文件名
      * @param 文件路径
@@ -511,7 +650,7 @@ namespace OHOS
     /*
      * @brief 获取被点击录音下标
      */
-    int RecordingModel::GetClickRecordingIndex(void)
+    int &RecordingModel::GetClickRecordingIndex(void)
     {
         return index;
     }
diff --git a/code/sdk/application/wearable/fd230app/nativeui/record/src/RecordingPlayerView.cpp b/code/sdk/application/wearable/fd230app/nativeui/record/src/RecordingPlayerView.cpp
index cb91343e1..33bcde0ea 100644
--- a/code/sdk/application/wearable/fd230app/nativeui/record/src/RecordingPlayerView.cpp
+++ b/code/sdk/application/wearable/fd230app/nativeui/record/src/RecordingPlayerView.cpp
@@ -198,7 +198,7 @@ namespace OHOS
         PlayerProgressBar->SetCenterPosition(65, 65);
         PlayerProgressBar->SetRadius(65);
         PlayerProgressBar->SetEndAngle(360);
-        PlayerProgressBar->SetValue(20);
+        PlayerProgressBar->SetValue(0);
 
         return true;
     }
@@ -211,7 +211,7 @@ namespace OHOS
         RecordingPlayPauseButton = new UICheckBox();
         if (RecordingPlayPauseButton == nullptr)
         {
-            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "RecordingPlayerView::PlayerProgressBar is new fail!");
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "RecordingPlayerView::RecordingPlayPauseButton is new fail!");
             return false;
         }
         RecordingPlayPauseButton->SetPosition(188, 188, 90, 90);
@@ -252,7 +252,7 @@ namespace OHOS
      */
     bool RecordingPlayerView::SetUpNextButton(void)
     {
-       
+
         ButtonConfig buttonconfig =
             {
                 .x = 346,
@@ -275,7 +275,7 @@ namespace OHOS
      */
     bool RecordingPlayerView::SetUpDeleteButton(void)
     {
-       
+
         ButtonConfig buttonconfig =
             {
                 .x = 117,
@@ -299,7 +299,7 @@ namespace OHOS
      */
     bool RecordingPlayerView::SetUpVolumeButton(void)
     {
-       
+
         ButtonConfig buttonconfig =
             {
                 .x = 270,
@@ -334,6 +334,30 @@ namespace OHOS
         return RecordingTimeAndDuration;
     }
 
+    /*
+     * @brief 获取播放器按钮
+     */
+    UICheckBox *RecordingPlayerView::GetPlayerButton(void)
+    {
+        return RecordingPlayPauseButton;
+    }
+
+    /*
+     * @brief 设置播放器按钮状态
+     */
+    void RecordingPlayerView::SetPlayerButtonState(UICheckBox::UICheckBoxState state)
+    {
+        RecordingPlayPauseButton->SetState(state);
+    }
+
+    /*
+     * @brief 获取录音播放进度条
+     */
+    UICircleProgress *RecordingPlayerView::GetPlayerProgressBar(void)
+    {
+        return PlayerProgressBar;
+    }
+
     UIScrollView *RecordingPlayerView::RecordingPlayerViewInit()
     {
         if (!SetUpScrollView())
@@ -382,7 +406,6 @@ namespace OHOS
         {
             return nullptr;
         }
-        RecordingModel::GetInstance()->RecordingPlayerInit();
         /* ----------------------------------- Add ---------------------------------- */
         RecordingPlayerViewScrollView->Add(RecordingPlayBackground);
         RecordingPlayerViewScrollView->Add(RecordingFileName);
diff --git a/code/sdk/application/wearable/fd230app/nativeui/record/src/RecordingPresenter.cpp b/code/sdk/application/wearable/fd230app/nativeui/record/src/RecordingPresenter.cpp
index 22f3ba4f4..7204cb7dc 100644
--- a/code/sdk/application/wearable/fd230app/nativeui/record/src/RecordingPresenter.cpp
+++ b/code/sdk/application/wearable/fd230app/nativeui/record/src/RecordingPresenter.cpp
@@ -7,6 +7,7 @@
 #include "../../../../../../drivers/peripheral/utils/custom_utils.h"
 #include "record/include/RecordingListitemView.h"
 #include <service/graphic_service.h>
+#include <unistd.h>
 
 namespace OHOS
 {
@@ -22,7 +23,10 @@ namespace OHOS
 
     RecordingPresenter::~RecordingPresenter()
     {
-
+        p_RecordingModel->GetPlayerCtr()->Stop();
+        p_RecordingModel->GetPlayerCtr()->Release();
+        p_RecordingModel->SetAudioInitStatus(false);
+        p_RecordingModel->GetPlayerCtr().reset();
         g_pRecordPresenter = nullptr;
     }
 
@@ -321,13 +325,42 @@ namespace OHOS
             return false;
         }
 
+        RecordingPlayerView *p_RecordingPlayerView = RecordingPlayerView::GetInstance();
+        if (p_RecordingPlayerView == nullptr)
+        {
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "RecordingPlayerView GetInstance fail");
+            return false;
+        }
+
+        RecordingModel *p_RecordingModel = RecordingModel::GetInstance();
+        if (p_RecordingModel == nullptr)
+        {
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "p_RecordingModel GetInstance fail");
+            return false;
+        }
+
         if (strcmp(view.GetViewId(), RECORD_PLAY_PROVE_BUTTON_VIEWID) == 0)
         {
             WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "recording player prove button being clicked!");
+
+            // if (p_RecordingPlayerView->GetPlayerProgressBar() != nullptr)
+            // {
+            //     p_RecordingPlayerView->GetPlayerProgressBar()->SetValue(0); // 0:进度0%
+            //     p_RecordingPlayerView->SetPlayerButtonState(UICheckBox::UICheckBoxState::SELECTED);
+            //     p_RecordingPlayerView->GetPlayerProgressBar()->Invalidate();
+            // }
+            // p_RecordingModel->PreviousPlayout();
         }
         else if (strcmp(view.GetViewId(), RECORD_PLAY_NEXT_BUTTON_VIEWID) == 0)
         {
             WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "recording player next button being clicked!");
+            // if (p_RecordingPlayerView->GetPlayerProgressBar() != nullptr)
+            // {
+            //     p_RecordingPlayerView->GetPlayerProgressBar()->SetValue(0); // 0:进度0%
+            //     p_RecordingPlayerView->SetPlayerButtonState(UICheckBox::UICheckBoxState::SELECTED);
+            //     p_RecordingPlayerView->GetPlayerProgressBar()->Invalidate();
+            // }
+            // p_RecordingModel->NextSong(p_RecordingModel->GetClickRecordingIndex() + 1);
         }
         else if (strcmp(view.GetViewId(), RECORD_PLAY_DELETE_BUTTON_VIEWID) == 0)
         {
@@ -356,12 +389,38 @@ namespace OHOS
         WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "RecordingPlayerInterruptListener::~RecordingPlayerInterruptListener");
     }
     /*
+     * 函数的调用通常发生在音频播放器或者任何使用音频资源的应用程序遇到外部中断事件时。
+     * 这些中断事件可能包括电话来电、音乐播放器之间的音频焦点切换、系统声音（如闹钟）的播放，或者其他任何需要暂停当前活动以响应的情况。
      * @brief 处理录音播放器中断的方法，可能会根据传入的参数进行不同的操作。
+     * @param type 中断的类型
+     * @param hint 处理中断的额外提示
      */
     void RecordingPlayerInterruptListener::OnInterrupt(int32_t type, int32_t hint)
     {
         WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "RecordingPlayerInterruptListener::OnInterrupt");
-        
+        if (type == INTERRUPT_TYPE_BEGIN && hint == INTERRUPT_HINT_PAUSE) // 这表明当某个中断事件开始时，如果接收到暂停的提示，应当暂停播放器的播放。
+        {
+            PausePlayer();
+        }
+
+        if (type == INTERRUPT_TYPE_END && hint == INTERRUPT_HINT_RESUME) // 这意味着一旦中断事件结束，并且有指示可以恢复播放的提示，就尝试恢复播放器的播放。
+        {
+            ResumePlayer();
+        }
+
+        if (hint == INTERRUPT_HINT_STOP) // 只要提示为INTERRUPT_HINT_STOP，首先调用ResetFlag方法重置相关标志。
+        {
+            ResetFlag();
+            if (type == INTERRUPT_TYPE_BEGIN) // 这表示如果在中断开始时接收到停止的提示，应当停止播放器的播放并标记该事件。
+            {
+                isBeginStopped_ = true;
+                StopPlayer();
+            }
+            else if (type == INTERRUPT_TYPE_END) // 记录中断结束时播放器已被停止
+            {
+                isEndStopped_ = true;
+            }
+        }
     }
 
     /*
@@ -406,7 +465,7 @@ namespace OHOS
     /*
      * @brief 重置标志位
      */
-    void RecordingPlayerInterruptListener::RestFlag(void)
+    void RecordingPlayerInterruptListener::ResetFlag(void)
     {
         WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "RecordingPlayerInterruptListener::RestFlag");
 
@@ -474,14 +533,100 @@ namespace OHOS
 
     static void Pause(void)
     {
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[RecordingPlayerInterruptListener::PausePlayer] start");
+        int32_t state;
+        int32_t ret;
+        std::shared_ptr<RecordingPlayerInterruptListener> PlayerIntrptListener =
+            OHOS::RecordingModel::GetInstance()->GetRecordingPlayerIntrptListener();
+        if (PlayerIntrptListener == nullptr)
+        {
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[RecordingPlayerInterruptListener] PlayerIntrptListener is null");
+            return;
+        }
+
+        std::shared_ptr<Player> player = PlayerIntrptListener->GetPlayer();
+        if (player.get() == nullptr)
+        {
+            WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[RecordingPlayerInterruptListener::PausePlayer] player is nullptr");
+            return;
+        }
+
+        RecordingPlayerView *p_RecordingPlayerView = RecordingPlayerView::GetInstance();
+
+        player->GetPlayerState(state);
+        if (state == PLAYER_STARTED)
+        {
+            ret = player->Pause();
+            if (ret == 0)
+            {
+                if (p_RecordingPlayerView == nullptr)
+                {
+                    RecordingModel::GetInstance()->SetRecordingPlayButtonState(false);
+                }
+                else
+                {
+                    p_RecordingPlayerView->SetPlayerButtonState(UICheckBox::UICheckBoxState::UNSELECTED);
+                    p_RecordingPlayerView->GetPlayerButton()->Invalidate();
+                }
+                PlayerIntrptListener->ResetFlag();
+                PlayerIntrptListener->SetPaused(true);
+                WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[RecordingPlayerInterruptListener::PausePlayer]");
+            }
+        }
     }
 
     static void Resume(void)
     {
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[RecordingPlayerInterruptListener::ResumePlayer] start");
+        int32_t state;
+        int32_t ret;
+        /* ----------------------------- 1.获取播放器中断监听器实例 ----------------------------- */
+        std::shared_ptr<RecordingPlayerInterruptListener> PlayerIntrptListener =
+            OHOS::RecordingModel::GetInstance()->GetRecordingPlayerIntrptListener();
+        if (PlayerIntrptListener == nullptr)
+        {
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[RecordingPlayerInterruptListener] PlayerIntrptListener is null");
+            return;
+        }
+        /* ------------------------------- 2.获取播放器实例 ------------------------------- */
+        std::shared_ptr<Player> player = PlayerIntrptListener->GetPlayer();
+        if (player.get() == nullptr)
+        {
+            WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[RecordingPlayerInterruptListener::ResumePlayer] player is nullptr");
+            return;
+        }
+
+        /* ------------------------------- 3.获取播放器视图实例 ------------------------------ */
+        RecordingPlayerView *p_RecordingPlayerView = RecordingPlayerView::GetInstance();
+        /* --------------------------------- 4.检查播放器状态 -------------------------------- */
+        player->GetPlayerState(state);
+        if (state == PLAYER_PAUSED && PlayerIntrptListener->IsPaused() == true)
+        {
+            /* -------------------------------- 5.尝试恢复播放 -------------------------------- */
+            ret = player->Play();
+            if (ret == 0)
+            {
+                if (p_RecordingPlayerView == nullptr)
+                {
+                    RecordingModel::GetInstance()->SetRecordingPlayButtonState(true);
+                }
+                else
+                {
+                    p_RecordingPlayerView->SetPlayerButtonState(UICheckBox::UICheckBoxState::SELECTED);
+                    p_RecordingPlayerView->GetPlayerButton()->Invalidate();
+                }
+                /* ------------------------------- 6.重置中断监听器状态 ------------------------------ */
+                PlayerIntrptListener->ResetFlag();
+                PlayerIntrptListener->SetResumed(true);
+                WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[RecordingPlayerInterruptListener::ResumePlayer]");
+            }
+        }
     }
 
     static void Stop(void)
     {
+        RecordingModel::GetInstance()->RecordingPlayerStop();
+        RecordingModel::GetInstance()->ClearActivateAudioInterrupt();
     }
 
     /*
@@ -528,6 +673,19 @@ namespace OHOS
     {
         WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "RecordingPlayerCallbackImpl::OnPlaybackComplete");
         /* --------------------------- 处实现代码用于处理文件播放完成的事件 --------------------------- */
+        // 此处实现代码用于处理文件播放完成的事件
+        RecordingPlayerView *p_RecordingPlayerView = RecordingPlayerView::GetInstance();
+        if (p_RecordingPlayerView != nullptr)
+        {
+            if (p_RecordingPlayerView->GetPlayerProgressBar() != nullptr)
+            {
+                p_RecordingPlayerView->GetPlayerProgressBar()->SetValue(100); // 100:进度100%
+                p_RecordingPlayerView->SetPlayerButtonState(UICheckBox::UICheckBoxState::UNSELECTED);
+                p_RecordingPlayerView->GetPlayerProgressBar()->Invalidate();
+            }
+        }
+        // RecordingModel::GetInstance()->ClearActivateAudioInterrupt();
+        // usleep(20000);
     }
 
     void RecordingPlayerCallbackImpl::OnError(int32_t errorType, int32_t errorCode)
diff --git a/code/sdk/application/wearable/fd230app/nativeui/record/src/RecordingView.cpp b/code/sdk/application/wearable/fd230app/nativeui/record/src/RecordingView.cpp
index 9927e1af2..535eba942 100644
--- a/code/sdk/application/wearable/fd230app/nativeui/record/src/RecordingView.cpp
+++ b/code/sdk/application/wearable/fd230app/nativeui/record/src/RecordingView.cpp
@@ -287,6 +287,7 @@ namespace OHOS
         std::string RecordingTimeAndDuration = yyyymmhhh_date + "-" + TotalRecordDuration;
         WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "RecordingTimeAndDuration %s\n", RecordingTimeAndDuration.c_str());
         p_RecordingPlayerView->GetRecordingTimeAndDurationLabel()->SetText(RecordingTimeAndDuration.c_str());
+        p_RecordingPlayerView->SetPlayerButtonState(UICheckBox::UICheckBoxState::UNSELECTED);
         return true;
     }