764 lines
24 KiB
C++
764 lines
24 KiB
C++
/*----------------------------------------------------------------------------
|
||
* Copyright (c) TJD Technologies Co., Ltd. 2025. All rights reserved.
|
||
*
|
||
* Description: TjdUiAppPlayerModel.cpp
|
||
*
|
||
* Author: luziquan@ss-tjd.com
|
||
*
|
||
* Create: 2024-06-07
|
||
*--------------------------------------------------------------------------*/
|
||
|
||
#include "TjdUiAppPlayerModel.h"
|
||
#include "TjdUiAppPlayerPresenter.h"
|
||
#include "TjdUiSettingCenter.h"
|
||
#include "UiConfig.h"
|
||
#include "audio_base_type.h"
|
||
#include "audio_manager.h"
|
||
#include "audio_stream_in.h"
|
||
#include "audio_stream_out.h"
|
||
#include "bts_a2dp_sink.h"
|
||
#include "bts_a2dp_source.h"
|
||
#include "bts_br_gap.h"
|
||
#include "bts_feature.h"
|
||
#include "dirent.h"
|
||
#include "media_thread_adapt.h"
|
||
#include "ohos_types.h"
|
||
#include "player.h"
|
||
#include "service_charger.h"
|
||
#include "stdint.h"
|
||
#include "sys_config.h"
|
||
#include "thread_adapter.h"
|
||
#include <string>
|
||
|
||
extern "C"
|
||
{
|
||
#include "ble_api.h"
|
||
#include "service_bt.h"
|
||
}
|
||
|
||
#define ENABLE_PRINT_INFO 1
|
||
#if ENABLE_PRINT_INFO
|
||
#define static_print_info(...) sys_ui_log_i(__VA_ARGS__) // 一般信息打印宏控制
|
||
#define static_print_warn(...) sys_ui_log_w(__VA_ARGS__) // 警告信息打印一般常开
|
||
#define static_print_error(...) sys_ui_log_e(__VA_ARGS__) // 错误信息打印一般常开
|
||
#define static_print_debug(...) sys_ui_log_d(__VA_ARGS__) // 调试信息打印一般常开
|
||
#else
|
||
#define static_print_info(...)
|
||
#define static_print_warn(...)
|
||
#define static_print_error(...)
|
||
#define static_print_debug(...)
|
||
#endif
|
||
|
||
namespace TJD {
|
||
|
||
static MutexId g_mutex;
|
||
|
||
extern BtAvrcpTgInf *GetAvrcpTgInf(void);
|
||
|
||
TjdUiAppPlayerModel::TjdUiAppPlayerModel() { g_mutex = MUTEX_InitValue(); }
|
||
|
||
TjdUiAppPlayerModel::~TjdUiAppPlayerModel() {}
|
||
|
||
TjdUiAppPlayerModel *TjdUiAppPlayerModel::GetInstance(void)
|
||
{
|
||
static TjdUiAppPlayerModel instance;
|
||
return &instance;
|
||
}
|
||
|
||
void TjdUiAppPlayerModel::InitBluetoothPlayer(void)
|
||
{
|
||
InitBtA2dpSourceEvent();
|
||
InitBtA2dpSinkEvent();
|
||
InitBtHeadsetEvent();
|
||
}
|
||
|
||
int TjdUiAppPlayerModel::PlayerInit(void)
|
||
{
|
||
sliceId = PlayersListGroup::GetInstance()->GetCase(currentIndex_);
|
||
if (sliceId == nullptr) {
|
||
static_print_error("GetCase %d sliceId err !!!", currentIndex_);
|
||
char strFile[15] = "No music files";
|
||
sliceId = strFile;
|
||
}
|
||
std::string strSongName = sliceId;
|
||
std::string pureName = strSongName.substr(0, strSongName.rfind("."));
|
||
static_print_info("PlayerInit, url: %s ", sliceId);
|
||
std::string strSrcMusic(TJD_FS_DIR_MUSIC);
|
||
uri_ = strSrcMusic + "/" + sliceId;
|
||
return 0;
|
||
}
|
||
|
||
void TjdUiAppPlayerModel::AudioInit(void)
|
||
{
|
||
if (audioInitStatus_) {
|
||
static_print_info("audioInitStatus_ is true");
|
||
return;
|
||
}
|
||
Audio::AudioManager &amIntance = Audio::AudioManager::GetInstance();
|
||
audioInitStatus_ = amIntance.Initialize();
|
||
playerCtr_ = std::make_shared<OHOS::Media::Player>();
|
||
playerCallback_ = std::make_shared<PlayerCallbackImpl>();
|
||
static_print_info("AudioInit end!");
|
||
}
|
||
|
||
bool TjdUiAppPlayerModel::GetAudioInitStatus(void) { return audioInitStatus_; }
|
||
|
||
int TjdUiAppPlayerModel::PlayerStart()
|
||
{
|
||
int32_t ret = 0;
|
||
|
||
// 设置回调函数
|
||
playerCtr_->SetPlayerCallback(playerCallback_);
|
||
// 申请资源
|
||
source_ = std::make_shared<OHOS::Media::Source>(uri_, header_);
|
||
playerCtr_->SetSource(*source_);
|
||
playerCtr_->Prepare();
|
||
if (!isActivateAudioInterrupt_) {
|
||
// 申请焦点
|
||
Audio::AudioManager &amIntance = Audio::AudioManager::GetInstance();
|
||
sessionId_ = amIntance.MakeSessionId();
|
||
if (sessionId_ == AUDIO_SESSION_ID_NONE) {
|
||
static_print_error("session invalid");
|
||
return OHOS_FAILURE;
|
||
}
|
||
playerInterruptListener_ = std::make_shared<PlayerInterruptListener>();
|
||
playerInterruptListener_->SetOwner(playerCtr_);
|
||
interrupt_ = {AUDIO_STREAM_MUSIC, sessionId_, playerInterruptListener_};
|
||
// 激活音频中断 5s超时
|
||
if (amIntance.ActivateAudioInterrupt(interrupt_) == INTERRUPT_FAILED) {
|
||
static_print_error("ActivateAudioInterrupt faild");
|
||
return OHOS_FAILURE;
|
||
}
|
||
isActivateAudioInterrupt_ = true;
|
||
}
|
||
playerCtr_->SetAudioSessionId(sessionId_);
|
||
// 播放
|
||
ret = playerCtr_->Play();
|
||
if (ret != 0) {
|
||
playerCtr_->Stop(); // 暂停
|
||
playerCtr_->Reset(); // 初始化
|
||
TjdUiAppPlayerPresenter *playersPresenter = TjdUiAppPlayerPresenter::GetInstance();
|
||
if (playersPresenter != nullptr) {
|
||
playersPresenter->PlayerBackReset();
|
||
} else {
|
||
SetPlayButtonState(false);
|
||
}
|
||
Audio::AudioManager::GetInstance().DeactivateAudioInterrupt(interrupt_);
|
||
isActivateAudioInterrupt_ = false;
|
||
}
|
||
return OHOS_SUCCESS;
|
||
}
|
||
|
||
int TjdUiAppPlayerModel::PlayerStop(void)
|
||
{
|
||
int state;
|
||
state = GetPlayerState();
|
||
if (state == -1) {
|
||
static_print_error("Get state of player failed!!");
|
||
return EXECUTE_FUNC_FAILED;
|
||
}
|
||
if (playerCtr_.get() == nullptr) {
|
||
static_print_error("playerCtr_.get() is nullptr!!");
|
||
return EXECUTE_FUNC_FAILED;
|
||
}
|
||
if (state == OHOS::Media::PlayerStates::PLAYER_STARTED ||
|
||
state == OHOS::Media::PlayerStates::PLAYER_PLAYBACK_COMPLETE) {
|
||
int ret = playerCtr_->Stop();
|
||
if (ret != 0) {
|
||
static_print_error("Stop err, ret:%d", ret);
|
||
return EXECUTE_FUNC_FAILED;
|
||
}
|
||
ret = playerCtr_->Reset();
|
||
if (ret != 0) {
|
||
static_print_error("Reset err, ret:%d", ret);
|
||
return EXECUTE_FUNC_FAILED;
|
||
} else {
|
||
SetPlayButtonState(false);
|
||
ConncetBtResetButton();
|
||
}
|
||
Audio::AudioManager::GetInstance().DeactivateAudioInterrupt(interrupt_);
|
||
return NORMAL;
|
||
} else if (state == OHOS::Media::PlayerStates::PLAYER_PAUSED) {
|
||
int ret = playerCtr_->Reset();
|
||
if (ret != 0) {
|
||
static_print_error("Reset err, ret:%d", ret);
|
||
return EXECUTE_FUNC_FAILED;
|
||
} else {
|
||
SetPlayButtonState(false);
|
||
ConncetBtResetButton();
|
||
}
|
||
Audio::AudioManager::GetInstance().DeactivateAudioInterrupt(interrupt_);
|
||
return NORMAL;
|
||
} else if (state == OHOS::Media::PlayerStates::PLAYER_STOPPED) {
|
||
return SONG_ALREADY_STOP;
|
||
}
|
||
return NORMAL;
|
||
}
|
||
|
||
const bd_addr_t *TjdUiAppPlayerModel::GetLastConnedAddr() { return tjd_get_lastconned_addr(); }
|
||
|
||
uint8_t TjdUiAppPlayerModel::GetBartteryLevel(void) { return tjd_service_charger_get_battery(); }
|
||
|
||
static int NotifySnkKey(int key_operation)
|
||
{
|
||
bd_addr_t bd_addr = a2dp_snk_get_active_device();
|
||
int ret = avrcp_ct_press_button(&bd_addr, key_operation);
|
||
if (ret != 0) {
|
||
static_print_error("avrcp_ct_press_button err, ret:%d", ret);
|
||
}
|
||
ret = avrcp_ct_release_button(&bd_addr, key_operation);
|
||
if (ret != 0) {
|
||
static_print_error("avrcp_ct_release_button err, ret:%d", ret);
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
void TjdUiAppPlayerModel::SetVolume(int32_t volume)
|
||
{
|
||
if (playerDeviceState_ == PlayerSource::PLAYER_SOURCE_PHONE && IsConnectPhone()) {
|
||
bd_addr_t bd_addr = a2dp_snk_get_active_device();
|
||
// TODO: 当前版本不准备同步手机端音量
|
||
uint8_t sounding = volume * 127 / 100; // 100：本地音量最大值
|
||
avrcp_ct_set_absolute_volume(&(GetAvrcpTgInf()->bd_addr), sounding);
|
||
Audio::AudioManager::GetInstance().SetVolume(AUDIO_STREAM_A2DP_MUSIC, volume); // 本地音量设置
|
||
return;
|
||
}
|
||
Audio::AudioManager::GetInstance().SetVolume(AUDIO_STREAM_MUSIC, volume); // 本地音量设置
|
||
}
|
||
|
||
int32_t TjdUiAppPlayerModel::GetA2dpVolume(void)
|
||
{
|
||
return Audio::AudioManager::GetInstance().GetVolume(AUDIO_STREAM_A2DP_MUSIC);
|
||
}
|
||
|
||
int32_t TjdUiAppPlayerModel::GetLocalVolume(void)
|
||
{
|
||
return Audio::AudioManager::GetInstance().GetVolume(AUDIO_STREAM_MUSIC);
|
||
}
|
||
|
||
bool TjdUiAppPlayerModel::StartHeadsetPlug(void)
|
||
{
|
||
uint8_t ret = tjd_service_bt_scan_start();
|
||
if (ret != 0) {
|
||
static_print_error("tjd_service_bt_scan_start_open fail, ret:%d.", ret);
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool TjdUiAppPlayerModel::StopHeadsetPlug(void)
|
||
{
|
||
uint8_t ret = tjd_service_bt_scan_stop();
|
||
if (ret != 0) {
|
||
static_print_error("tjd_service_bt_scan_stop_open fail, ret:%d.", ret);
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
osal_list_head *TjdUiAppPlayerModel::GetHeadsetInfo() { return tjd_get_found_dev_list(); }
|
||
|
||
void TjdUiAppPlayerModel::SetPhoneAudioEnable(bool enable)
|
||
{
|
||
int ret = 0;
|
||
if (enable) {
|
||
ret = a2dp_snk_connect(GetLastConnedAddr());
|
||
static_print_info("a2dp_snk_connect %d", ret);
|
||
} else {
|
||
ret = a2dp_snk_disconnect(GetLastConnedAddr());
|
||
static_print_info("a2dp_snk_disconnect %d", ret);
|
||
}
|
||
}
|
||
|
||
int TjdUiAppPlayerModel::ConnectHeadset(const bd_addr_t &addr)
|
||
{
|
||
/* 恢厂后耳机连接要开启BT广播否则会导致AVRCP无法音量控制 */
|
||
bool ret = gap_br_set_bt_scan_mode(GAP_SCAN_MODE_CONNECTABLE, 60);
|
||
if (!ret) {
|
||
WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "ConnectRemoteDevice gap_br_set_bt_scan_mode ret = 0x%x", ret);
|
||
}
|
||
errcode_t retVal = gap_connect_remote_device(&addr);
|
||
WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "ConnectRemoteDevice gap_connect_remote_device ret = 0x%x", retVal);
|
||
return retVal;
|
||
}
|
||
|
||
bool TjdUiAppPlayerModel::IsConnectHeadset(const bd_addr_t &addr)
|
||
{
|
||
tjd_service_bt_is_connect(&addr);
|
||
osDelay(50);
|
||
return tjd_check_bt_is_acl_connected();
|
||
}
|
||
|
||
bool TjdUiAppPlayerModel::UnpairHeadset(const bd_addr_t &addr)
|
||
{
|
||
errcode_t ret = a2dp_src_disconnect(&addr);
|
||
if (ret != ERRCODE_SUCC) {
|
||
static_print_debug("a2dp_src_disconnect fail, ret:%x.", ret);
|
||
return false;
|
||
}
|
||
|
||
return gap_remove_pair(&addr);
|
||
}
|
||
|
||
bool TjdUiAppPlayerModel::DisconnectHeadset(const bd_addr_t &addr)
|
||
{
|
||
errcode_t ret = a2dp_src_disconnect(&addr);
|
||
if (ret != ERRCODE_SUCC) {
|
||
static_print_debug("a2dp_src_disconnect fail, ret:%x.", ret);
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool TjdUiAppPlayerModel::IsConnectBt(void) { return tjd_get_bt_is_connect(); }
|
||
|
||
bool TjdUiAppPlayerModel::IsConnectHeadset(void)
|
||
{
|
||
bd_addr_t activeBdAddr = a2dp_src_get_active_device();
|
||
int32_t connState = a2dp_src_get_device_connect_state(&activeBdAddr);
|
||
if (connState == PROFILE_STATE_CONNECTED) {
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
bool TjdUiAppPlayerModel::IsConnectPhone(void)
|
||
{
|
||
bd_addr_t activeBdAddr = a2dp_snk_get_active_device();
|
||
int state = a2dp_snk_get_device_connect_state(&activeBdAddr);
|
||
if (state == PROFILE_STATE_CONNECTED) {
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
void TjdUiAppPlayerModel::AvrcpCtStatusNotification(avrcp_play_status_t status)
|
||
{
|
||
avrcpPlayStatus_ = status;
|
||
if (avrcpPlayStatus_ == avrcp_play_status_t::AVRCP_PLAY_STATUS_PLAYING) {
|
||
playerDeviceState_ = PlayerSource::PLAYER_SOURCE_PHONE;
|
||
}
|
||
TjdUiAppPlayerPresenter *presenter = TjdUiAppPlayerPresenter::GetInstance();
|
||
if (presenter == nullptr) {
|
||
/* 如果没有打开播放页面，并且手机播放停止，则切换回默认设备 */
|
||
if (avrcpPlayStatus_ == avrcp_play_status_t::AVRCP_PLAY_STATUS_PAUSED ||
|
||
avrcpPlayStatus_ == avrcp_play_status_t::AVRCP_PLAY_STATUS_STOPPED) {
|
||
playerDeviceState_ = PlayerSource::PLAYER_SOURCE_WATCH;
|
||
}
|
||
static_print_error("player presenter is nullptr");
|
||
return;
|
||
}
|
||
if (playerDeviceState_ == PlayerSource::PLAYER_SOURCE_PHONE) {
|
||
presenter->PhonePlayerStatusChange(status);
|
||
}
|
||
}
|
||
|
||
bool TjdUiAppPlayerModel::PhoneAudioIsPlaying(void)
|
||
{
|
||
bd_addr_t activeBdAddr = a2dp_snk_get_active_device();
|
||
int state = a2dp_snk_get_playing_state(&activeBdAddr);
|
||
if (state == A2DP_IS_PLAYING) {
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
void TjdUiAppPlayerModel::NextSong(int16_t index)
|
||
{
|
||
SetCurrentIndex(index);
|
||
// 播放
|
||
sliceId = PlayersListGroup::GetInstance()->GetCase(index);
|
||
if (sliceId == nullptr) {
|
||
static_print_error("GetCase %d sliceId err!!!", index);
|
||
return;
|
||
}
|
||
std::string strSrcMusic(TJD_FS_DIR_MUSIC);
|
||
SetPlayerUri(strSrcMusic + "/" + sliceId);
|
||
std::string strSongName = sliceId;
|
||
std::string pureName = strSongName.substr(0, strSongName.rfind("."));
|
||
TjdUiAppPlayerPresenter *playersPresenter = TjdUiAppPlayerPresenter::GetInstance();
|
||
if (playersPresenter != nullptr) {
|
||
playersPresenter->SetMusicName(pureName.c_str());
|
||
}
|
||
int32_t ret;
|
||
int32_t playerState;
|
||
playerCtr_->GetPlayerState(playerState);
|
||
if ((playerState == OHOS::Media::PlayerStates::PLAYER_STARTED) ||
|
||
(playerState == OHOS::Media::PlayerStates::PLAYER_PLAYBACK_COMPLETE)) {
|
||
/* start play */
|
||
ret = playerCtr_->Stop(); // 停止
|
||
ret = playerCtr_->Reset();
|
||
ret = PlayerStart(); // 播放
|
||
if (ret != 0) {
|
||
/* stop and exit */
|
||
ret = playerCtr_->Stop(); // 停止
|
||
ret = playerCtr_->Reset();
|
||
}
|
||
} else if (playerState == OHOS::Media::PlayerStates::PLAYER_PAUSED ||
|
||
(playerState == OHOS::Media::PlayerStates::PLAYER_IDLE)) {
|
||
ret = playerCtr_->Reset();
|
||
}
|
||
}
|
||
|
||
void TjdUiAppPlayerModel::LoopingPlayout()
|
||
{
|
||
int16_t index;
|
||
std::list<PlayerCaseInfo> &playersCaseList = PlayersListGroup::GetInstance()->GetCase();
|
||
index = GetCurrentIndex();
|
||
if ((index > static_cast<int16_t>(playersCaseList.size() - 1)) || (index < 0)) {
|
||
static_print_error("currentIndex err");
|
||
SetCurrentIndex(0);
|
||
return;
|
||
}
|
||
|
||
// 下一曲
|
||
if (++index > static_cast<int16_t>(playersCaseList.size() - 1)) {
|
||
index = 0;
|
||
}
|
||
NextSong(index);
|
||
}
|
||
|
||
void TjdUiAppPlayerModel::SequencePlayout()
|
||
{
|
||
int16_t index;
|
||
std::list<PlayerCaseInfo> &playersCaseList = PlayersListGroup::GetInstance()->GetCase();
|
||
index = GetCurrentIndex();
|
||
if ((index > static_cast<int16_t>(playersCaseList.size() - 1)) || (index < 0)) {
|
||
static_print_error("currentIndex err");
|
||
SetCurrentIndex(0);
|
||
return;
|
||
}
|
||
|
||
// 下一曲
|
||
if (++index > static_cast<int16_t>(playersCaseList.size() - 1)) {
|
||
playerCtr_->Stop(); // 暂停
|
||
playerCtr_->Reset(); // 初始化
|
||
TjdUiAppPlayerPresenter *playersPresenter = TjdUiAppPlayerPresenter::GetInstance();
|
||
if (playersPresenter != nullptr) {
|
||
playersPresenter->PlayerBackReset();
|
||
} else {
|
||
SetPlayButtonState(false);
|
||
}
|
||
index = playersCaseList.size() - 1;
|
||
}
|
||
NextSong(index);
|
||
}
|
||
|
||
void TjdUiAppPlayerModel::PreviousPlayout()
|
||
{
|
||
int16_t index;
|
||
std::list<PlayerCaseInfo> &playersCaseList = PlayersListGroup::GetInstance()->GetCase();
|
||
index = GetCurrentIndex();
|
||
if ((index > static_cast<int16_t>(playersCaseList.size() - 1)) || (index < 0)) {
|
||
static_print_error("currentIndex err");
|
||
SetCurrentIndex(0);
|
||
return;
|
||
}
|
||
|
||
// 上一曲
|
||
if (--index < 0) {
|
||
index = playersCaseList.size() - 1;
|
||
}
|
||
NextSong(index);
|
||
}
|
||
|
||
void TjdUiAppPlayerModel::PhoneAudioPlay()
|
||
{
|
||
Audio::AudioManager::GetInstance().SetVolume(AUDIO_STREAM_A2DP_MUSIC, 255 * 0.2); // 本地音量设置
|
||
int ret = NotifySnkKey(AVRCP_KEY_PLAY);
|
||
if (ret != 0) {
|
||
static_print_error("[TjdUiAppPlayerModel::PhoneAudioPlay] avrcp_ct_release_button err, ret:%d", ret);
|
||
}
|
||
}
|
||
|
||
void TjdUiAppPlayerModel::PhoneAudioStop()
|
||
{
|
||
Audio::AudioManager::GetInstance().SetVolume(AUDIO_STREAM_A2DP_MUSIC, 0);
|
||
int ret = NotifySnkKey(AVRCP_KEY_PAUSE);
|
||
if (ret != 0) {
|
||
static_print_error("[TjdUiAppPlayerModel::PhoneAudioStop] avrcp_ct_release_button err, ret:%d", ret);
|
||
}
|
||
}
|
||
|
||
void TjdUiAppPlayerModel::PhoneAudioPrevious()
|
||
{
|
||
bd_addr_t bd_addr = a2dp_snk_get_active_device();
|
||
int ret = NotifySnkKey(AVRCP_KEY_BACKWARD);
|
||
if (ret != 0) {
|
||
static_print_error("[TjdUiAppPlayerModel::PhoneAudioPrevious] avrcp_ct_release_button err, ret:%d", ret);
|
||
}
|
||
}
|
||
|
||
void TjdUiAppPlayerModel::PhoneAudioForward()
|
||
{
|
||
bd_addr_t bd_addr = a2dp_snk_get_active_device();
|
||
int ret = NotifySnkKey(AVRCP_KEY_FORWARD);
|
||
if (ret != 0) {
|
||
static_print_error("[TjdUiAppPlayerModel::PhoneAudioForward] avrcp_ct_press_button err, ret:%d", ret);
|
||
}
|
||
}
|
||
|
||
void TjdUiAppPlayerModel::RandomPlayout()
|
||
{
|
||
int16_t random;
|
||
int16_t indexMax;
|
||
srand((unsigned)time(nullptr));
|
||
std::list<PlayerCaseInfo> &playersCaseList = PlayersListGroup::GetInstance()->GetCase();
|
||
indexMax = playersCaseList.size() - 1;
|
||
random = (rand() % (indexMax + 1));
|
||
if ((random > static_cast<int16_t>(playersCaseList.size() - 1)) || (random < 0)) {
|
||
SetCurrentIndex(0);
|
||
return;
|
||
}
|
||
if (GetCurrentIndex() == random) {
|
||
random++;
|
||
if (random > static_cast<int16_t>(playersCaseList.size() - 1)) {
|
||
random = 0;
|
||
}
|
||
}
|
||
NextSong(random);
|
||
}
|
||
|
||
void TjdUiAppPlayerModel::PlaySwitching(void)
|
||
{
|
||
int32_t ret;
|
||
static_print_info("PlayerModel:%d", static_cast<int>(playerModel_));
|
||
switch (playerModel_) {
|
||
case PlayMode::SEQUENCE:
|
||
// 顺序
|
||
SequencePlayout();
|
||
break;
|
||
case PlayMode::REPEATS:
|
||
// 重复
|
||
ret = playerCtr_->Stop(); // 停止
|
||
ret = playerCtr_->Reset();
|
||
PlayerStart(); // 播放
|
||
break;
|
||
case PlayMode::RANDOM:
|
||
// 随机
|
||
RandomPlayout();
|
||
break;
|
||
}
|
||
}
|
||
|
||
int32_t TjdUiAppPlayerModel::GetPlayerStatus()
|
||
{
|
||
int32_t playerState;
|
||
if (playerCtr_.get() == nullptr) {
|
||
static_print_error("PlayersModel::GetPlayerStatus playerCtr_ is nullptr");
|
||
return EXECUTE_FUNC_FAILED;
|
||
}
|
||
playerCtr_->GetPlayerState(playerState);
|
||
|
||
switch (playerState) {
|
||
case OHOS::Media::PLAYER_STARTED:
|
||
playerState = AVRCP_PLAY_STATUS_PLAYING;
|
||
break;
|
||
case OHOS::Media::PLAYER_PAUSED:
|
||
playerState = AVRCP_PLAY_STATUS_PAUSED;
|
||
break;
|
||
case OHOS::Media::PLAYER_STOPPED:
|
||
playerState = AVRCP_PLAY_STATUS_STOPPED;
|
||
break;
|
||
default:
|
||
playerState = AVRCP_PLAY_STATUS_STOPPED;
|
||
break;
|
||
}
|
||
return playerState;
|
||
}
|
||
|
||
void TjdUiAppPlayerModel::SetBTMusicPlay(avrcp_key_operation_t notification)
|
||
{
|
||
int ret = 0;
|
||
bd_addr_t bd_addr = a2dp_src_get_active_device();
|
||
// 设置耳机的状态暂停
|
||
if (notification == AVRCP_KEY_PLAY) {
|
||
ret = a2dp_src_start_playing(&bd_addr);
|
||
avrcp_tg_notify_playback_status_changed(AVRCP_PLAY_STATUS_PLAYING);
|
||
static_print_debug("[TjdUiAppPlayerModel::SetBTMusicPlay] a2dp_src_start_playing err, ret:%d", ret);
|
||
} else if (notification == AVRCP_KEY_PAUSE) {
|
||
ret = a2dp_src_suspend_playing(&bd_addr);
|
||
avrcp_tg_notify_playback_status_changed(AVRCP_PLAY_STATUS_PAUSED);
|
||
static_print_debug("[TjdUiAppPlayerModel::SetBTMusicPlay] a2dp_src_suspend_playing err, ret:%d", ret);
|
||
}
|
||
}
|
||
|
||
// 蓝牙连接和本地音乐的播放
|
||
bool TjdUiAppPlayerModel::ConnectBtAndLocalPlay(int32_t connCtState, int32_t connTgState)
|
||
{
|
||
int ret = 0;
|
||
if (playerCtr_.get() == nullptr) {
|
||
static_print_error("[TjdUiAppPlayerModel::ConnectBtAndLocalPlay] GetPlayerCtr is nullptr ");
|
||
return false;
|
||
}
|
||
int32_t playerState = 0;
|
||
playerCtr_->GetPlayerState(playerState);
|
||
|
||
// 当前是暂停状态则直接播放
|
||
if (playerState == OHOS::Media::PlayerStates::PLAYER_PAUSED) {
|
||
GetPlayerCtr()->Play();
|
||
} else {
|
||
ret = PlayerStart(); // 本地播放
|
||
if (ret != 0) {
|
||
static_print_error("PlayerStart err, ret:%d", ret);
|
||
}
|
||
}
|
||
if (IsConnectHeadset()) {
|
||
SetBTMusicPlay(avrcp_key_operation_t::AVRCP_KEY_PLAY);
|
||
}
|
||
return false;
|
||
}
|
||
|
||
// 蓝牙连接和本地音乐的暂停
|
||
void TjdUiAppPlayerModel::ConnectBtAndLocalPause(int32_t connCtState, int32_t connTgState)
|
||
{
|
||
int ret;
|
||
ret = GetPlayerCtr()->Pause(); // 本地暂停
|
||
if (ret != 0) {
|
||
static_print_error("PlayerPause err, ret:%d", ret);
|
||
}
|
||
if (IsConnectHeadset()) {
|
||
SetBTMusicPlay(avrcp_key_operation_t::AVRCP_KEY_PAUSE);
|
||
}
|
||
}
|
||
|
||
void TjdUiAppPlayerModel::ConncetBtResetButton()
|
||
{
|
||
int32_t connCtState = avrcp_ct_get_device_connect_state(tjd_get_lastconned_addr());
|
||
int32_t connTgState = avrcp_tg_get_device_connect_state(tjd_get_lastconned_addr());
|
||
if (connCtState == PROFILE_STATE_CONNECTED || connTgState == PROFILE_STATE_CONNECTED) {
|
||
if (TjdUiAppPlayerPresenter::GetInstance() == nullptr) {
|
||
static_print_error("PlayersPresenter::GetInstance() == nullptr");
|
||
return;
|
||
}
|
||
TjdUiAppPlayerPresenter::GetInstance()->PlayerButtonReset();
|
||
}
|
||
}
|
||
|
||
int TjdUiAppPlayerModel::GetPlayerState(void)
|
||
{
|
||
int state;
|
||
if (playerCtr_.get() == nullptr) {
|
||
static_print_error("playerCtr_.get() is nullptr!!");
|
||
return -1;
|
||
}
|
||
playerCtr_->GetPlayerState(state);
|
||
return state;
|
||
}
|
||
|
||
#pragma region 音乐列表文件
|
||
PlayersListGroup::~PlayersListGroup()
|
||
{
|
||
if (playersCaseList_ != nullptr) {
|
||
playersCaseList_->clear();
|
||
}
|
||
delete playersCaseList_;
|
||
playersCaseList_ = nullptr;
|
||
}
|
||
|
||
PlayersListGroup *PlayersListGroup::GetInstance()
|
||
{
|
||
static PlayersListGroup instance;
|
||
return &instance;
|
||
}
|
||
|
||
void PlayersListGroup::AddCase(PlayerCaseInfo testCaseInfo)
|
||
{
|
||
if (playersCaseList_ == nullptr) {
|
||
return;
|
||
}
|
||
playersCaseList_->push_back(testCaseInfo);
|
||
}
|
||
|
||
void PlayersListGroup::SetUpListCase(void)
|
||
{
|
||
int16_t ret;
|
||
if (playersCaseList_ == nullptr) {
|
||
playersCaseList_ = new std::list<PlayerCaseInfo>();
|
||
}
|
||
playersCaseList_->clear();
|
||
ret = GetAllFiles();
|
||
if (ret == OHOS_FAILURE) {
|
||
return;
|
||
}
|
||
static_print_debug("playersCaseList_ size %d", playersCaseList_->size());
|
||
}
|
||
|
||
void PlayersListGroup::RemoveCase(int16_t index)
|
||
{
|
||
if (playersCaseList_ == nullptr) {
|
||
return;
|
||
}
|
||
for (auto it = playersCaseList_->begin(); it != playersCaseList_->end();) {
|
||
if (index == it->index) {
|
||
RemoveTargetFile(it->sliceId);
|
||
it = playersCaseList_->erase(it);
|
||
return;
|
||
} else {
|
||
++it;
|
||
}
|
||
}
|
||
}
|
||
|
||
char *PlayersListGroup::GetCase(int16_t index)
|
||
{
|
||
if (index < 0 || playersCaseList_ == nullptr) {
|
||
return nullptr;
|
||
}
|
||
for (auto it = playersCaseList_->begin(); it != playersCaseList_->end(); ++it) {
|
||
if (index == it->index) {
|
||
return it->sliceId;
|
||
}
|
||
}
|
||
return nullptr;
|
||
}
|
||
|
||
int PlayersListGroup::GetAllFiles()
|
||
{
|
||
int ret;
|
||
int i{0};
|
||
struct dirent *direntp;
|
||
struct PlayerCaseInfo playerCaseInfo;
|
||
static_print_debug("PlayersView::GetAllFiles");
|
||
// 打开目录
|
||
DIR *dirp = opendir(TJD_FS_DIR_MUSIC);
|
||
// 遍历文件
|
||
if (dirp != nullptr) {
|
||
while ((direntp = readdir(dirp)) != nullptr) {
|
||
std::string filename(direntp->d_name);
|
||
// 检查文件名的后缀是否为.mp3
|
||
if (filename.rfind(".mp3") == filename.length() - 4) {
|
||
ret = memcpy_s(playerCaseInfo.sliceId, 256, direntp->d_name, 256);
|
||
if (ret != OHOS_SUCCESS) {
|
||
static_print_error("memcpy_s err %d.", ret);
|
||
closedir(dirp);
|
||
return OHOS_FAILURE;
|
||
}
|
||
playerCaseInfo.index = i;
|
||
static_print_debug("song[%d] Name %s.", playerCaseInfo.index, playerCaseInfo.sliceId);
|
||
i++;
|
||
playersCaseList_->push_back(playerCaseInfo);
|
||
}
|
||
}
|
||
} else {
|
||
static_print_debug("PlayersView::opendir err!");
|
||
return OHOS_FAILURE;
|
||
}
|
||
// 关闭目录
|
||
closedir(dirp);
|
||
static_print_debug("PlayersView::GetAllFiles end!");
|
||
return OHOS_SUCCESS;
|
||
}
|
||
|
||
void PlayersListGroup::RemoveTargetFile(const char *sliceId)
|
||
{
|
||
std::string filePath = std::string(TJD_FS_DIR_MUSIC) + "/" + sliceId;
|
||
if (remove(filePath.c_str()) == 0) {
|
||
static_print_debug("File %s successfully deleted", filePath.c_str());
|
||
} else {
|
||
static_print_error("Error deleting file %s", filePath.c_str());
|
||
}
|
||
}
|
||
#pragma endregion
|
||
} // namespace TJD
|