mirror of
https://github.com/openharmony/multimedia_av_session.git
synced 2026-08-25 06:18:12 -04:00
红袍小恶魔
4627 lines
180 KiB
C++
4627 lines
180 KiB
C++
/*
|
|
* Copyright (c) 2022-2025 Huawei Device Co., Ltd.
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include <gtest/gtest.h>
|
|
#include <memory>
|
|
#include <fstream>
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
#include <vector>
|
|
|
|
#include "avsession_log.h"
|
|
#include "input_manager.h"
|
|
#include "key_event.h"
|
|
#include "avsession_manager.h"
|
|
#include "avsession_errors.h"
|
|
#include "avmeta_data.h"
|
|
#include "avplayback_state.h"
|
|
#include "avmedia_description.h"
|
|
#include "avqueue_item.h"
|
|
#include "avsession_log.h"
|
|
#include "nativetoken_kit.h"
|
|
#include "token_setproc.h"
|
|
#include "accesstoken_kit.h"
|
|
#include "system_ability_definition.h"
|
|
#include "system_ability_ondemand_reason.h"
|
|
#include "parameters.h"
|
|
#include "audio_info.h"
|
|
#include "avsession_callback_client.h"
|
|
#include "avsession_pixel_map.h"
|
|
#include "avsession_pixel_map_adapter.h"
|
|
#include "avsession_info.h"
|
|
#include "params_config_operator.h"
|
|
#include "avcontrol_command.h"
|
|
#include "want_agent_helper.h"
|
|
|
|
#define private public
|
|
#define protected public
|
|
#include "avsession_service.h"
|
|
#undef protected
|
|
#undef private
|
|
|
|
#ifdef CAR_FEATURE_ENABLE
|
|
#include "audio_zone_types.h"
|
|
#endif
|
|
|
|
#ifdef CASTPLUS_CAST_ENGINE_ENABLE
|
|
#include "i_avcast_controller_proxy.h"
|
|
#include "avcast_control_command.h"
|
|
#include "av_router.h"
|
|
|
|
// Mock Cast Controller Proxy for testing
|
|
class MockCastControllerProxy : public OHOS::AVSession::IAVCastControllerProxy {
|
|
public:
|
|
MockCastControllerProxy()
|
|
{
|
|
castPlaybackState_.SetState(AVPlaybackState::PLAYBACK_STATE_INITIAL);
|
|
}
|
|
~MockCastControllerProxy() override = default;
|
|
|
|
void SetCastPlaybackState(int32_t state)
|
|
{
|
|
castPlaybackState_.SetState(state);
|
|
}
|
|
|
|
int32_t GetCastAVPlaybackState(AVPlaybackState& avPlaybackState) override
|
|
{
|
|
avPlaybackState = castPlaybackState_;
|
|
return OHOS::AVSession::AVSESSION_SUCCESS;
|
|
}
|
|
|
|
// Implement all pure virtual methods from IAVCastControllerProxy
|
|
void Release() override {}
|
|
|
|
int32_t RegisterControllerListener(
|
|
const std::shared_ptr<OHOS::AVSession::IAVCastControllerProxyListener> listener) override
|
|
{
|
|
return OHOS::AVSession::AVSESSION_ERROR;
|
|
}
|
|
|
|
int32_t UnRegisterControllerListener(
|
|
const std::shared_ptr<OHOS::AVSession::IAVCastControllerProxyListener> listener) override
|
|
{
|
|
return OHOS::AVSession::AVSESSION_ERROR;
|
|
}
|
|
|
|
AVQueueItem GetCurrentItem() override
|
|
{
|
|
return AVQueueItem();
|
|
}
|
|
|
|
int32_t RefreshCurrentAVQueueItem(const AVQueueItem& avQueueItem) override
|
|
{
|
|
return OHOS::AVSession::AVSESSION_ERROR;
|
|
}
|
|
|
|
int32_t Start(const AVQueueItem& avQueueItem) override
|
|
{
|
|
return OHOS::AVSession::AVSESSION_ERROR;
|
|
}
|
|
|
|
int32_t Prepare(const AVQueueItem& avQueueItem) override
|
|
{
|
|
return OHOS::AVSession::AVSESSION_ERROR;
|
|
}
|
|
|
|
void SendControlCommand(const OHOS::AVSession::AVCastControlCommand cmd) override {}
|
|
|
|
void SendCustomData(const std::string& customData) override {}
|
|
|
|
int32_t GetDuration(int32_t& duration) override
|
|
{
|
|
return OHOS::AVSession::AVSESSION_ERROR;
|
|
}
|
|
|
|
int32_t GetSupportedDecoders(std::vector<std::string>& decoderTypes) override
|
|
{
|
|
return OHOS::AVSession::AVSESSION_ERROR;
|
|
}
|
|
|
|
int32_t GetRecommendedResolutionLevel(std::string& decoderType,
|
|
OHOS::AVSession::ResolutionLevel& resolutionLevel) override
|
|
{
|
|
return OHOS::AVSession::AVSESSION_ERROR;
|
|
}
|
|
|
|
int32_t GetSupportedHdrCapabilities(std::vector<OHOS::AVSession::HDRFormat>& hdrFormats) override
|
|
{
|
|
return OHOS::AVSession::AVSESSION_ERROR;
|
|
}
|
|
|
|
int32_t GetSupportedPlaySpeeds(std::vector<float>& playSpeeds) override
|
|
{
|
|
return OHOS::AVSession::AVSESSION_ERROR;
|
|
}
|
|
|
|
int32_t SetValidAbility(const std::vector<int32_t>& validAbilityList) override
|
|
{
|
|
return OHOS::AVSession::AVSESSION_ERROR;
|
|
}
|
|
|
|
int32_t GetValidAbility(std::vector<int32_t>& validAbilityList) override
|
|
{
|
|
return OHOS::AVSession::AVSESSION_ERROR;
|
|
}
|
|
|
|
int32_t SetDisplaySurface(std::string& surfaceId) override
|
|
{
|
|
return OHOS::AVSession::AVSESSION_ERROR;
|
|
}
|
|
|
|
int32_t ProcessMediaKeyResponse(const std::string& assetId, const std::vector<uint8_t>& response) override
|
|
{
|
|
return OHOS::AVSession::AVSESSION_ERROR;
|
|
}
|
|
|
|
void SetSessionCallbackForCastCap(const std::function<void(bool, bool)>& callback) override {}
|
|
|
|
void SetSpid(uint32_t spid) override {}
|
|
|
|
private:
|
|
AVPlaybackState castPlaybackState_;
|
|
};
|
|
#endif
|
|
|
|
using namespace testing::ext;
|
|
using namespace OHOS::AVSession;
|
|
using namespace OHOS::Security::AccessToken;
|
|
using namespace OHOS::AudioStandard;
|
|
#ifdef CAR_FEATURE_ENABLE
|
|
using OHOS::ErrCode;
|
|
|
|
class ISessionListenerMock : public ISessionListener {
|
|
public:
|
|
ErrCode OnSessionCreate(const AVSessionDescriptor& descriptor) override { return AVSESSION_SUCCESS; }
|
|
ErrCode OnSessionRelease(const AVSessionDescriptor& descriptor) override { return AVSESSION_SUCCESS; }
|
|
ErrCode OnTopSessionChange(const AVSessionDescriptor& descriptor) override { return AVSESSION_SUCCESS; }
|
|
ErrCode OnAudioSessionChecked(const int32_t uid) override { return AVSESSION_SUCCESS; }
|
|
ErrCode OnDeviceAvailable(
|
|
const OutputDeviceInfo& castOutputDeviceInfo) override { return AVSESSION_SUCCESS; }
|
|
ErrCode OnDeviceLogEvent(const int32_t eventId, const int64_t param) override { return AVSESSION_SUCCESS; }
|
|
ErrCode OnDeviceOffline(const std::string& deviceId) override { return AVSESSION_SUCCESS; }
|
|
ErrCode OnDeviceStateChange(const DeviceState& deviceState) override { return AVSESSION_SUCCESS; }
|
|
ErrCode OnSystemCommonEvent(const std::string& commonEvent,
|
|
const std::string& args) override { return AVSESSION_SUCCESS; }
|
|
ErrCode OnRemoteDistributedSessionChange(
|
|
const std::vector<OHOS::sptr<IRemoteObject>>& sessionControllers) override { return AVSESSION_SUCCESS; }
|
|
ErrCode OnActiveSessionChanged(
|
|
const std::vector<AVSessionDescriptor> &descriptors) override { return AVSESSION_SUCCESS; }
|
|
ErrCode OnSessionAddForAudioZone(
|
|
int32_t userId, const AVSessionDescriptor &descriptor) override {return AVSESSION_SUCCESS;}
|
|
ErrCode OnSessionRemoveForAudioZone(
|
|
int32_t userId, const AVSessionDescriptor &descriptor) override {return AVSESSION_SUCCESS;}
|
|
ErrCode OnTopSessionChangeForAudioZone(
|
|
int32_t userId, const AVSessionDescriptor &descriptor) override {return AVSESSION_SUCCESS;}
|
|
OHOS::sptr<IRemoteObject> AsObject() override { return nullptr; }
|
|
};
|
|
#endif
|
|
|
|
static AVMetaData g_metaData;
|
|
static AVPlaybackState g_playbackState;
|
|
static char g_testSessionTag[] = "test";
|
|
static char g_testAnotherBundleName[] = "testAnother.ohos.avsession";
|
|
static char g_testAnotherAbilityName[] = "testAnother.ability";
|
|
static int32_t g_playOnCall = AVSESSION_ERROR;
|
|
static int32_t g_pauseOnCall = AVSESSION_ERROR;
|
|
static int32_t g_nextOnCall = AVSESSION_ERROR;
|
|
static int32_t g_previousOnCall = AVSESSION_ERROR;
|
|
static AVSessionService *avservice_;
|
|
|
|
class AVSessionServiceTest : public testing::Test {
|
|
public:
|
|
static void SetUpTestCase();
|
|
static void TearDownTestCase();
|
|
void SetUp() override;
|
|
void TearDown() override;
|
|
|
|
std::shared_ptr<AVSession> avsession_ = nullptr;
|
|
};
|
|
|
|
void AVSessionServiceTest::SetUpTestCase()
|
|
{
|
|
SLOGI("set up AVSessionServiceTest");
|
|
system("killall -9 com.huawei.hmsapp.music");
|
|
sleep(1);
|
|
avservice_ = new AVSessionService(OHOS::AVSESSION_SERVICE_ID);
|
|
avservice_->InitKeyEvent();
|
|
}
|
|
|
|
void AVSessionServiceTest::TearDownTestCase()
|
|
{
|
|
if (avservice_ != nullptr) {
|
|
delete avservice_;
|
|
avservice_ = nullptr;
|
|
}
|
|
}
|
|
|
|
void AVSessionServiceTest::SetUp()
|
|
{
|
|
SLOGI("set up test function in AVSessionServiceTest");
|
|
}
|
|
|
|
void AVSessionServiceTest::TearDown()
|
|
{
|
|
SLOGI("tear down test function in AVSessionServiceTest");
|
|
[[maybe_unused]] int32_t ret = AVSESSION_ERROR;
|
|
if (avsession_ != nullptr) {
|
|
ret = avsession_->Destroy();
|
|
avsession_ = nullptr;
|
|
}
|
|
}
|
|
|
|
class AVSessionCallbackImpl : public AVSessionCallback {
|
|
public:
|
|
void OnPlay(const AVControlCommand& cmd) override;
|
|
void OnPause() override;
|
|
void OnStop() override {};
|
|
void OnPlayNext(const AVControlCommand& cmd) override;
|
|
void OnPlayPrevious(const AVControlCommand& cmd) override;
|
|
void OnFastForward(int64_t time, const AVControlCommand& cmd) override {};
|
|
void OnRewind(int64_t time, const AVControlCommand& cmd) override {};
|
|
void OnSeek(int64_t time) override {};
|
|
void OnSetSpeed(double speed) override {};
|
|
void OnSetLoopMode(int32_t loopMode) override {};
|
|
void OnSetTargetLoopMode(int32_t targetLoopMode) override {};
|
|
void OnToggleFavorite(const std::string& mediaId) override {};
|
|
void OnMediaKeyEvent(const OHOS::MMI::KeyEvent& keyEvent) override {};
|
|
void OnOutputDeviceChange(const int32_t connectionState,
|
|
const OHOS::AVSession::OutputDeviceInfo& outputDeviceInfo) override {};
|
|
void OnCommonCommand(const std::string& commonCommand, const OHOS::AAFwk::WantParams& commandArgs) override {};
|
|
void OnSkipToQueueItem(int32_t itemId) override {};
|
|
void OnAVCallAnswer() override {};
|
|
void OnAVCallHangUp() override {};
|
|
void OnAVCallToggleCallMute() override {};
|
|
void OnPlayFromAssetId(int64_t assetId) override {};
|
|
void OnPlayWithAssetId(const std::string& assetId) override {};
|
|
void OnCastDisplayChange(const CastDisplayInfo& castDisplayInfo) override {};
|
|
|
|
~AVSessionCallbackImpl() override;
|
|
};
|
|
|
|
void AVSessionCallbackImpl::OnPlay(const AVControlCommand& cmd)
|
|
{
|
|
g_playOnCall = AVSESSION_SUCCESS;
|
|
SLOGI("OnPlay %{public}d", g_playOnCall);
|
|
}
|
|
|
|
void AVSessionCallbackImpl::OnPause()
|
|
{
|
|
g_pauseOnCall = AVSESSION_SUCCESS;
|
|
SLOGI("OnPause %{public}d", g_pauseOnCall);
|
|
}
|
|
|
|
void AVSessionCallbackImpl::OnPlayNext(const AVControlCommand& cmd)
|
|
{
|
|
g_nextOnCall = AVSESSION_SUCCESS;
|
|
SLOGI("OnPlayNext %{public}d", g_nextOnCall);
|
|
}
|
|
|
|
void AVSessionCallbackImpl::OnPlayPrevious(const AVControlCommand& cmd)
|
|
{
|
|
g_previousOnCall = AVSESSION_SUCCESS;
|
|
SLOGI("OnPlayPrevious %{public}d", g_previousOnCall);
|
|
}
|
|
|
|
AVSessionCallbackImpl::~AVSessionCallbackImpl()
|
|
{
|
|
}
|
|
|
|
/**
|
|
* @tc.name: SendSystemAVKeyEvent001
|
|
* @tc.desc: verifying send system keyEvent
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, SendSystemAVKeyEvent001, TestSize.Level0)
|
|
{
|
|
SLOGI("SendSystemAVKeyEvent001 with level0 begin!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
avsessionHere_->Activate();
|
|
avservice_->UpdateTopSession(avsessionHere_);
|
|
|
|
g_metaData.Reset();
|
|
g_metaData.SetAssetId("123");
|
|
g_metaData.SetTitle("Black Humor");
|
|
g_metaData.SetArtist("zhoujielun");
|
|
g_metaData.SetAuthor("zhoujielun");
|
|
g_metaData.SetAlbum("Jay");
|
|
g_metaData.SetWriter("zhoujielun");
|
|
g_metaData.SetComposer("zhoujielun");
|
|
g_metaData.SetDuration(40000);
|
|
g_metaData.SetMediaImageUri("xxxxx");
|
|
g_metaData.SetSubTitle("fac");
|
|
g_metaData.SetDescription("for friends");
|
|
g_metaData.SetLyric("xxxxx");
|
|
avsessionHere_->SetAVMetaData(g_metaData);
|
|
|
|
g_playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_PLAY);
|
|
g_playbackState.SetSpeed(1.5);
|
|
g_playbackState.SetPosition({80000, 0});
|
|
g_playbackState.SetBufferedTime(60000);
|
|
g_playbackState.SetLoopMode(2);
|
|
g_playbackState.SetFavorite(true);
|
|
avsessionHere_->SetAVPlaybackState(g_playbackState);
|
|
|
|
std::shared_ptr<AVSessionCallback> callback = std::make_shared<AVSessionCallbackImpl>();
|
|
OHOS::sptr<IAVSessionCallback> callbackClient = new(std::nothrow) AVSessionCallbackClient(callback);
|
|
EXPECT_EQ(avsessionHere_->RegisterCallbackInner(callbackClient), AVSESSION_SUCCESS);
|
|
|
|
auto keyEvent = OHOS::MMI::KeyEvent::Create();
|
|
ASSERT_NE(keyEvent, nullptr);
|
|
keyEvent->SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
|
|
keyEvent->SetKeyAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
|
|
OHOS::MMI::KeyEvent::KeyItem item;
|
|
item.SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
|
|
item.SetDownTime(0);
|
|
item.SetPressed(true);
|
|
keyEvent->AddPressedKeyItems(item);
|
|
OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
|
|
sleep(1);
|
|
EXPECT_EQ(g_pauseOnCall, AVSESSION_SUCCESS);
|
|
g_pauseOnCall = false;
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
SLOGI("SendSystemAVKeyEvent001 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: CreateSessionInnerCorrectElement001
|
|
* @tc.desc: system caller (thirdPartyApp=false) keeps the passed elementName unchanged
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, CreateSessionInnerCorrectElement001, TestSize.Level0)
|
|
{
|
|
SLOGI("CreateSessionInnerCorrectElement001 begin!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
ASSERT_TRUE(avsessionHere_ != nullptr);
|
|
EXPECT_EQ(avsessionHere_->GetBundleName(), g_testAnotherBundleName);
|
|
EXPECT_EQ(avsessionHere_->GetAbilityName(), g_testAnotherAbilityName);
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
SLOGI("CreateSessionInnerCorrectElement001 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: CreateSessionInnerCorrectElement002
|
|
* @tc.desc: non-hap caller (SA/native token) with thirdPartyApp=true keeps elementName unchanged
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, CreateSessionInnerCorrectElement002, TestSize.Level0)
|
|
{
|
|
SLOGI("CreateSessionInnerCorrectElement002 begin!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, true, elementName);
|
|
ASSERT_TRUE(avsessionHere_ != nullptr);
|
|
EXPECT_EQ(avsessionHere_->GetBundleName(), g_testAnotherBundleName);
|
|
EXPECT_EQ(avsessionHere_->GetAbilityName(), g_testAnotherAbilityName);
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
SLOGI("CreateSessionInnerCorrectElement002 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: SendSystemAVKeyEvent002
|
|
* @tc.desc: verifying send system keyEvent
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, SendSystemAVKeyEvent002, TestSize.Level0)
|
|
{
|
|
SLOGI("SendSystemAVKeyEvent002 begin!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
avsessionHere_->Activate();
|
|
avservice_->UpdateTopSession(avsessionHere_);
|
|
|
|
g_metaData.Reset();
|
|
g_metaData.SetAssetId("123");
|
|
g_metaData.SetTitle("Black Humor");
|
|
g_metaData.SetArtist("zhoujielun");
|
|
g_metaData.SetAuthor("zhoujielun");
|
|
g_metaData.SetAlbum("Jay");
|
|
g_metaData.SetWriter("zhoujielun");
|
|
g_metaData.SetComposer("zhoujielun");
|
|
g_metaData.SetDuration(40000);
|
|
g_metaData.SetMediaImageUri("xxxxx");
|
|
g_metaData.SetSubTitle("fac");
|
|
g_metaData.SetDescription("for friends");
|
|
g_metaData.SetLyric("xxxxx");
|
|
avsessionHere_->SetAVMetaData(g_metaData);
|
|
|
|
g_playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_PAUSE);
|
|
g_playbackState.SetSpeed(1.5);
|
|
g_playbackState.SetPosition({80000, 0});
|
|
g_playbackState.SetBufferedTime(60000);
|
|
g_playbackState.SetLoopMode(2);
|
|
g_playbackState.SetFavorite(true);
|
|
avsessionHere_->SetAVPlaybackState(g_playbackState);
|
|
|
|
std::shared_ptr<AVSessionCallback> callback = std::make_shared<AVSessionCallbackImpl>();
|
|
OHOS::sptr<IAVSessionCallback> callbackClient = new(std::nothrow) AVSessionCallbackClient(callback);
|
|
EXPECT_EQ(avsessionHere_->RegisterCallbackInner(callbackClient), AVSESSION_SUCCESS);
|
|
|
|
auto keyEvent = OHOS::MMI::KeyEvent::Create();
|
|
ASSERT_NE(keyEvent, nullptr);
|
|
keyEvent->SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
|
|
keyEvent->SetKeyAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
|
|
OHOS::MMI::KeyEvent::KeyItem item;
|
|
item.SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
|
|
item.SetDownTime(0);
|
|
item.SetPressed(true);
|
|
keyEvent->AddPressedKeyItems(item);
|
|
OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
|
|
sleep(1);
|
|
EXPECT_EQ(g_playOnCall, AVSESSION_SUCCESS);
|
|
g_playOnCall = false;
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
SLOGI("SendSystemAVKeyEvent002 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: SendSystemAVKeyEvent003
|
|
* @tc.desc: verifying send system keyEvent
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, SendSystemAVKeyEvent003, TestSize.Level0)
|
|
{
|
|
SLOGI("SendSystemAVKeyEvent003 begin!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
avsessionHere_->Activate();
|
|
avservice_->UpdateTopSession(avsessionHere_);
|
|
|
|
g_metaData.Reset();
|
|
g_metaData.SetAssetId("123");
|
|
g_metaData.SetTitle("Black Humor");
|
|
g_metaData.SetArtist("zhoujielun");
|
|
g_metaData.SetAuthor("zhoujielun");
|
|
g_metaData.SetAlbum("Jay");
|
|
g_metaData.SetWriter("zhoujielun");
|
|
g_metaData.SetComposer("zhoujielun");
|
|
g_metaData.SetDuration(40000);
|
|
g_metaData.SetMediaImageUri("xxxxx");
|
|
g_metaData.SetSubTitle("fac");
|
|
g_metaData.SetDescription("for friends");
|
|
g_metaData.SetLyric("xxxxx");
|
|
avsessionHere_->SetAVMetaData(g_metaData);
|
|
|
|
g_playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_PLAY);
|
|
g_playbackState.SetSpeed(1.5);
|
|
g_playbackState.SetPosition({80000, 0});
|
|
g_playbackState.SetBufferedTime(60000);
|
|
g_playbackState.SetLoopMode(2);
|
|
g_playbackState.SetFavorite(true);
|
|
avsessionHere_->SetAVPlaybackState(g_playbackState);
|
|
|
|
std::shared_ptr<AVSessionCallback> callback = std::make_shared<AVSessionCallbackImpl>();
|
|
OHOS::sptr<IAVSessionCallback> callbackClient = new(std::nothrow) AVSessionCallbackClient(callback);
|
|
EXPECT_EQ(avsessionHere_->RegisterCallbackInner(callbackClient), AVSESSION_SUCCESS);
|
|
|
|
auto keyEvent = OHOS::MMI::KeyEvent::Create();
|
|
ASSERT_NE(keyEvent, nullptr);
|
|
keyEvent->SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
|
|
keyEvent->SetKeyAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
|
|
OHOS::MMI::KeyEvent::KeyItem item;
|
|
item.SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
|
|
item.SetDownTime(0);
|
|
item.SetPressed(true);
|
|
keyEvent->AddPressedKeyItems(item);
|
|
OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
|
|
OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
|
|
sleep(1);
|
|
EXPECT_EQ(g_nextOnCall, AVSESSION_SUCCESS);
|
|
g_nextOnCall = false;
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
SLOGI("SendSystemAVKeyEvent003 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: SendSystemAVKeyEvent004
|
|
* @tc.desc: verifying send system keyEvent
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, SendSystemAVKeyEvent004, TestSize.Level0)
|
|
{
|
|
SLOGI("SendSystemAVKeyEvent004 begin!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
avsessionHere_->Activate();
|
|
avservice_->UpdateTopSession(avsessionHere_);
|
|
g_metaData.SetAssetId("123");
|
|
g_metaData.SetTitle("Black Humor");
|
|
g_metaData.SetArtist("zhoujielun");
|
|
g_metaData.SetAuthor("zhoujielun");
|
|
g_metaData.SetAlbum("Jay");
|
|
g_metaData.SetWriter("zhoujielun");
|
|
g_metaData.SetComposer("zhoujielun");
|
|
g_metaData.SetDuration(40000);
|
|
g_metaData.SetSubTitle("fac");
|
|
g_metaData.SetDescription("for friends");
|
|
g_metaData.SetLyric("xxxxx");
|
|
avsessionHere_->SetAVMetaData(g_metaData);
|
|
g_playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_PLAY);
|
|
g_playbackState.SetSpeed(1.5);
|
|
g_playbackState.SetPosition({80000, 0});
|
|
g_playbackState.SetBufferedTime(60000);
|
|
g_playbackState.SetLoopMode(2);
|
|
g_playbackState.SetFavorite(true);
|
|
avsessionHere_->SetAVPlaybackState(g_playbackState);
|
|
std::shared_ptr<AVSessionCallback> callback = std::make_shared<AVSessionCallbackImpl>();
|
|
OHOS::sptr<IAVSessionCallback> callbackClient = new(std::nothrow) AVSessionCallbackClient(callback);
|
|
EXPECT_EQ(avsessionHere_->RegisterCallbackInner(callbackClient), AVSESSION_SUCCESS);
|
|
auto keyEvent = OHOS::MMI::KeyEvent::Create();
|
|
ASSERT_NE(keyEvent, nullptr);
|
|
keyEvent->SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
|
|
keyEvent->SetKeyAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
|
|
OHOS::MMI::KeyEvent::KeyItem item;
|
|
item.SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
|
|
item.SetDownTime(0);
|
|
item.SetPressed(true);
|
|
keyEvent->AddPressedKeyItems(item);
|
|
OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
|
|
OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
|
|
OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
|
|
sleep(1);
|
|
EXPECT_EQ(g_previousOnCall, AVSESSION_SUCCESS);
|
|
g_previousOnCall = false;
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
SLOGI("SendSystemAVKeyEvent004 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: SendSystemAVKeyEvent005
|
|
* @tc.desc: verifying send system keyEvent
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, SendSystemAVKeyEvent005, TestSize.Level0)
|
|
{
|
|
SLOGI("SendSystemAVKeyEvent005 begin!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
avsessionHere_->Activate();
|
|
avservice_->UpdateTopSession(avsessionHere_);
|
|
g_metaData.SetAssetId("123");
|
|
g_metaData.SetTitle("Black Humor");
|
|
g_metaData.SetArtist("zhoujielun");
|
|
g_metaData.SetAuthor("zhoujielun");
|
|
g_metaData.SetAlbum("Jay");
|
|
g_metaData.SetWriter("zhoujielun");
|
|
g_metaData.SetComposer("zhoujielun");
|
|
g_metaData.SetDuration(40000);
|
|
g_metaData.SetMediaImageUri("xxxxx");
|
|
g_metaData.SetDescription("for friends");
|
|
avsessionHere_->SetAVMetaData(g_metaData);
|
|
g_playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_PLAY);
|
|
g_playbackState.SetSpeed(1.5);
|
|
g_playbackState.SetPosition({80000, 0});
|
|
g_playbackState.SetBufferedTime(60000);
|
|
g_playbackState.SetLoopMode(2);
|
|
g_playbackState.SetFavorite(true);
|
|
avsessionHere_->SetAVPlaybackState(g_playbackState);
|
|
std::shared_ptr<AVSessionCallback> callback = std::make_shared<AVSessionCallbackImpl>();
|
|
OHOS::sptr<IAVSessionCallback> callbackClient = new(std::nothrow) AVSessionCallbackClient(callback);
|
|
EXPECT_EQ(avsessionHere_->RegisterCallbackInner(callbackClient), AVSESSION_SUCCESS);
|
|
auto keyEvent = OHOS::MMI::KeyEvent::Create();
|
|
ASSERT_NE(keyEvent, nullptr);
|
|
keyEvent->SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
|
|
keyEvent->SetKeyAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
|
|
OHOS::MMI::KeyEvent::KeyItem item;
|
|
item.SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
|
|
item.SetDownTime(0);
|
|
item.SetPressed(true);
|
|
keyEvent->AddPressedKeyItems(item);
|
|
OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
|
|
OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
|
|
OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
|
|
OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
|
|
sleep(1);
|
|
EXPECT_EQ(g_previousOnCall, AVSESSION_SUCCESS);
|
|
g_previousOnCall = false;
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
SLOGI("SendSystemAVKeyEvent005 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: SendSystemAVKeyEvent006
|
|
* @tc.desc: verifying send system keyEvent
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, SendSystemAVKeyEvent006, TestSize.Level0)
|
|
{
|
|
SLOGI("SendSystemAVKeyEvent006 begin!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
avsessionHere_->Activate();
|
|
avservice_->UpdateTopSession(avsessionHere_);
|
|
g_metaData.SetAssetId("123");
|
|
g_metaData.SetTitle("Black Humor");
|
|
g_metaData.SetArtist("zhoujielun");
|
|
g_metaData.SetAuthor("zhoujielun");
|
|
g_metaData.SetAlbum("Jay");
|
|
g_metaData.SetWriter("zhoujielun");
|
|
g_metaData.SetComposer("zhoujielun");
|
|
g_metaData.SetDuration(40000);
|
|
avsessionHere_->SetAVMetaData(g_metaData);
|
|
g_playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_PLAY);
|
|
g_playbackState.SetSpeed(1.5);
|
|
g_playbackState.SetPosition({80000, 0});
|
|
g_playbackState.SetBufferedTime(60000);
|
|
g_playbackState.SetLoopMode(2);
|
|
g_playbackState.SetFavorite(true);
|
|
avsessionHere_->SetAVPlaybackState(g_playbackState);
|
|
std::shared_ptr<AVSessionCallback> callback = std::make_shared<AVSessionCallbackImpl>();
|
|
OHOS::sptr<IAVSessionCallback> callbackClient = new(std::nothrow) AVSessionCallbackClient(callback);
|
|
EXPECT_EQ(avsessionHere_->RegisterCallbackInner(callbackClient), AVSESSION_SUCCESS);
|
|
auto keyEvent = OHOS::MMI::KeyEvent::Create();
|
|
ASSERT_NE(keyEvent, nullptr);
|
|
keyEvent->SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
|
|
keyEvent->SetKeyAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
|
|
OHOS::MMI::KeyEvent::KeyItem item;
|
|
item.SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
|
|
item.SetDownTime(0);
|
|
item.SetPressed(true);
|
|
keyEvent->AddPressedKeyItems(item);
|
|
OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
|
|
OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
|
|
sleep(1);
|
|
EXPECT_EQ(g_nextOnCall, AVSESSION_SUCCESS);
|
|
g_nextOnCall = false;
|
|
OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
|
|
sleep(1);
|
|
EXPECT_EQ(g_pauseOnCall, AVSESSION_SUCCESS);
|
|
g_pauseOnCall = false;
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
SLOGI("SendSystemAVKeyEvent006 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, NotifyDeviceAvailable001, TestSize.Level0)
|
|
{
|
|
SLOGI("NotifyDeviceAvailable001 begin!");
|
|
#ifdef CASTPLUS_CAST_ENGINE_ENABLE
|
|
SLOGI("NotifyDeviceAvailable001 in!");
|
|
OutputDeviceInfo outputDeviceInfo;
|
|
OHOS::AVSession::DeviceInfo deviceInfo;
|
|
deviceInfo.castCategory_ = 1;
|
|
deviceInfo.deviceId_ = "deviceId";
|
|
outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
|
|
avservice_->NotifyDeviceAvailable(outputDeviceInfo);
|
|
EXPECT_EQ(0, AVSESSION_SUCCESS);
|
|
#endif
|
|
EXPECT_EQ(0, AVSESSION_SUCCESS);
|
|
SLOGI("NotifyDeviceAvailable001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, NotifyMirrorToStreamCast001, TestSize.Level0)
|
|
{
|
|
SLOGI("NotifyMirrorToStreamCast001 begin!");
|
|
#ifdef CASTPLUS_CAST_ENGINE_ENABLE
|
|
SLOGI("NotifyMirrorToStreamCast001 in!");
|
|
avservice_->NotifyMirrorToStreamCast();
|
|
#endif
|
|
EXPECT_EQ(0, AVSESSION_SUCCESS);
|
|
SLOGI("NotifyMirrorToStreamCast001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, NotifyMirrorToStreamCast002, TestSize.Level0)
|
|
{
|
|
SLOGI("NotifyMirrorToStreamCast002 begin!");
|
|
#ifdef CASTPLUS_CAST_ENGINE_ENABLE
|
|
SLOGI("NotifyMirrorToStreamCast002 in!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
EXPECT_EQ(avsessionHere_ != nullptr, true);
|
|
avservice_->UpdateTopSession(avsessionHere_);
|
|
avservice_->NotifyMirrorToStreamCast();
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
#endif
|
|
EXPECT_EQ(0, AVSESSION_SUCCESS);
|
|
SLOGI("NotifyMirrorToStreamCast002 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, NotifyMirrorToStreamCast003, TestSize.Level0)
|
|
{
|
|
SLOGI("NotifyMirrorToStreamCast003 begin!");
|
|
#ifdef CASTPLUS_CAST_ENGINE_ENABLE
|
|
SLOGI("NotifyMirrorToStreamCast002 in!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_VIDEO, false, elementName);
|
|
EXPECT_EQ(avsessionHere_ != nullptr, true);
|
|
avservice_->UpdateTopSession(avsessionHere_);
|
|
avservice_->NotifyMirrorToStreamCast();
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
#endif
|
|
EXPECT_EQ(0, AVSESSION_SUCCESS);
|
|
SLOGI("NotifyMirrorToStreamCast003 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, NotifyMirrorToStreamCast004, TestSize.Level0)
|
|
{
|
|
SLOGI("NotifyMirrorToStreamCast004 begin!");
|
|
#ifdef CASTPLUS_CAST_ENGINE_ENABLE
|
|
ASSERT_TRUE(avservice_ != nullptr);
|
|
AVRouter::GetInstance().SetStreamToMirrorFromSink(true);
|
|
avservice_->castServiceNameStatePair_.second = "IDLE";
|
|
avservice_->NotifyMirrorToStreamCast();
|
|
EXPECT_FALSE(AVRouter::GetInstance().IsStreamToMirrorFromSink());
|
|
#endif
|
|
SLOGI("NotifyMirrorToStreamCast004 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, RefreshFocusSessionSort001, TestSize.Level0)
|
|
{
|
|
SLOGI("RefreshFocusSessionSort001 begin!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
EXPECT_EQ(avsessionHere_ != nullptr, true);
|
|
avservice_->RefreshFocusSessionSort(avsessionHere_);
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
EXPECT_EQ(0, AVSESSION_SUCCESS);
|
|
SLOGI("RefreshFocusSessionSort001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, SelectSessionByUid001, TestSize.Level0)
|
|
{
|
|
SLOGI("SelectSessionByUid001 begin!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
EXPECT_EQ(avsessionHere_ != nullptr, true);
|
|
AudioRendererChangeInfo info = {};
|
|
info.clientUID = 0;
|
|
avservice_->SelectSessionByUid(info);
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
EXPECT_EQ(0, AVSESSION_SUCCESS);
|
|
SLOGI("SelectSessionByUid001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, SelectSessionByUid002, TestSize.Level0)
|
|
{
|
|
SLOGI("SelectSessionByUid002 begin!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
EXPECT_EQ(avsessionHere_ != nullptr, true);
|
|
AudioRendererChangeInfo info = {};
|
|
info.clientUID = avsessionHere_->GetUid();
|
|
avservice_->SelectSessionByUid(info);
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
EXPECT_EQ(0, AVSESSION_SUCCESS);
|
|
SLOGI("SelectSessionByUid002 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, InitBMS001, TestSize.Level0)
|
|
{
|
|
SLOGI("InitBMS001 begin!");
|
|
avservice_->InitBMS();
|
|
EXPECT_EQ(0, AVSESSION_SUCCESS);
|
|
SLOGI("InitBMS001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, ReleaseCastSession001, TestSize.Level0)
|
|
{
|
|
SLOGI("ReleaseCastSession001 begin!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner("RemoteCast", AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
EXPECT_EQ(avsessionHere_ != nullptr, true);
|
|
#ifdef CASTPLUS_CAST_ENGINE_ENABLE
|
|
SLOGI("ReleaseCastSession001 in!");
|
|
avservice_->ReleaseCastSession();
|
|
#endif
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
EXPECT_EQ(0, AVSESSION_SUCCESS);
|
|
SLOGI("ReleaseCastSession001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, CreateSessionByCast001, TestSize.Level0)
|
|
{
|
|
SLOGI("CreateSessionByCast001 begin!");
|
|
#ifdef CASTPLUS_CAST_ENGINE_ENABLE
|
|
SLOGI("CreateSessionByCast001 in!");
|
|
avservice_->CreateSessionByCast(0);
|
|
avservice_->ClearSessionForClientDiedNoLock(getpid(), false);
|
|
#endif
|
|
EXPECT_EQ(0, AVSESSION_SUCCESS);
|
|
SLOGI("CreateSessionByCast001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, MirrorToStreamCast001, TestSize.Level0)
|
|
{
|
|
SLOGI("MirrorToStreamCast001 begin!");
|
|
#ifdef CASTPLUS_CAST_ENGINE_ENABLE
|
|
SLOGI("MirrorToStreamCast001 in!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner("RemoteCast", AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
EXPECT_EQ(avsessionHere_ != nullptr, true);
|
|
avservice_->isCastableDevice_ = true;
|
|
avservice_->MirrorToStreamCast(avsessionHere_);
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
#endif
|
|
EXPECT_EQ(0, AVSESSION_SUCCESS);
|
|
SLOGI("MirrorToStreamCast001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, MirrorToStreamCast002, TestSize.Level0)
|
|
{
|
|
SLOGI("MirrorToStreamCast002 begin!");
|
|
#ifdef CASTPLUS_CAST_ENGINE_ENABLE
|
|
SLOGI("MirrorToStreamCast002 in!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner("RemoteCast", AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
EXPECT_EQ(avsessionHere_ != nullptr, true);
|
|
avservice_->isCastableDevice_ = false;
|
|
avservice_->MirrorToStreamCast(avsessionHere_);
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
#endif
|
|
EXPECT_EQ(0, AVSESSION_SUCCESS);
|
|
SLOGI("MirrorToStreamCast002 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, MirrorToStreamCast003, TestSize.Level0)
|
|
{
|
|
SLOGI("MirrorToStreamCast003 begin!");
|
|
#ifdef CASTPLUS_CAST_ENGINE_ENABLE
|
|
SLOGI("MirrorToStreamCast003 in!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner("RemoteCast", AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
EXPECT_EQ(avsessionHere_ != nullptr, true);
|
|
avservice_->isCastableDevice_ = true;
|
|
avservice_->MirrorToStreamCast(avsessionHere_);
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
#endif
|
|
EXPECT_EQ(0, AVSESSION_SUCCESS);
|
|
SLOGI("MirrorToStreamCast003 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, SaveSessionInfoInFile001, TestSize.Level0)
|
|
{
|
|
SLOGI("SaveSessionInfoInFile001 begin!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner("RemoteCast", AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
EXPECT_EQ(avsessionHere_ != nullptr, true);
|
|
avservice_->SaveSessionInfoInFile("RemoteCast", avsessionHere_->GetSessionId(),
|
|
"audio", elementName);
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
EXPECT_EQ(0, AVSESSION_SUCCESS);
|
|
SLOGI("SaveSessionInfoInFile001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, HandleSystemKeyColdStart001, TestSize.Level0)
|
|
{
|
|
SLOGI("HandleSystemKeyColdStart001 begin");
|
|
ASSERT_TRUE(avservice_ != nullptr);
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
ASSERT_EQ(avsessionHere_ != nullptr, true);
|
|
AVControlCommand command;
|
|
avservice_->HandleSystemKeyColdStart(command);
|
|
EXPECT_NE(avsessionHere_, avservice_->topSession_);
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
avsessionHere_->Destroy();
|
|
SLOGI("HandleSystemKeyColdStart001 end");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, HandleSystemKeyColdStart002, TestSize.Level0)
|
|
{
|
|
SLOGD("HandleSystemKeyColdStart002 begin");
|
|
ASSERT_TRUE(avservice_ != nullptr);
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
ASSERT_EQ(avsessionHere != nullptr, true);
|
|
AVControlCommand command;
|
|
command.SetCommand(AVControlCommand::SESSION_CMD_PLAY);
|
|
avservice_->HandleSystemKeyColdStart(command);
|
|
command.SetCommand(AVControlCommand::SESSION_CMD_PLAY_PREVIOUS);
|
|
avservice_->HandleSystemKeyColdStart(command);
|
|
command.SetCommand(AVControlCommand::SESSION_CMD_PLAY_NEXT);
|
|
avservice_->HandleSystemKeyColdStart(command);
|
|
EXPECT_NE(avsessionHere, avservice_->topSession_);
|
|
avservice_->HandleSessionRelease(avsessionHere->GetSessionId());
|
|
avsessionHere->Destroy();
|
|
SLOGD("HandleSystemKeyColdStart002 end");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, GetHistoricalAVQueueInfos001, TestSize.Level0)
|
|
{
|
|
SLOGI("GetHistoricalAVQueueInfos001 begin!");
|
|
std::vector<AVQueueInfo> avQueueInfos_;
|
|
avservice_->GetHistoricalAVQueueInfos(0, 0, avQueueInfos_);
|
|
EXPECT_EQ(0, AVSESSION_SUCCESS);
|
|
SLOGI("GetHistoricalAVQueueInfos001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, SaveAvQueueInfo001, TestSize.Level0)
|
|
{
|
|
SLOGI("SaveAvQueueInfo001 begin!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner("RemoteCast", AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
EXPECT_EQ(avsessionHere_ != nullptr, true);
|
|
AVMetaData meta = avsessionHere_->GetMetaData();
|
|
std::string oldContent;
|
|
if (!avservice_->LoadStringFromFileEx(avservice_->GetAVQueueDir(), oldContent)) {
|
|
SLOGE("SaveAvQueueInfo001 read avqueueinfo fail, Return!");
|
|
} else {
|
|
avservice_->SaveAvQueueInfo(oldContent, g_testAnotherBundleName, meta,
|
|
avservice_->GetUsersManager().GetCurrentUserId());
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
EXPECT_EQ(0, AVSESSION_SUCCESS);
|
|
SLOGI("SaveAvQueueInfo001 end!");
|
|
}
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, AddAvQueueInfoToFile001, TestSize.Level0)
|
|
{
|
|
SLOGI("AddAvQueueInfoToFile001 begin!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner("RemoteCast", AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
EXPECT_EQ(avsessionHere_ != nullptr, true);
|
|
avservice_->AddAvQueueInfoToFile(*avsessionHere_);
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
EXPECT_EQ(0, AVSESSION_SUCCESS);
|
|
SLOGI("AddAvQueueInfoToFile001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, StartAVPlayback001, TestSize.Level0)
|
|
{
|
|
SLOGI("StartAVPlayback001 begin!");
|
|
std::string moduleName = "moduleName";
|
|
avservice_->StartAVPlayback(g_testAnotherBundleName, "FAKE_ASSET_NAME", moduleName);
|
|
EXPECT_EQ(0, AVSESSION_SUCCESS);
|
|
SLOGI("StartAVPlayback001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, StartAVPlayback002, TestSize.Level0)
|
|
{
|
|
SLOGI("StartAVPlayback002 begin!");
|
|
std::string deviceId = "123";
|
|
std::string moduleName = "moduleName";
|
|
avservice_->StartAVPlayback(g_testAnotherBundleName, "FAKE_ASSET_NAME", moduleName, deviceId);
|
|
EXPECT_EQ(0, AVSESSION_SUCCESS);
|
|
SLOGI("StartAVPlayback002 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, StartAVPlayback003, TestSize.Level1)
|
|
{
|
|
SLOGI("StartAVPlayback003 begin!");
|
|
ASSERT_TRUE(avservice_ != nullptr);
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner("ancoMediaSession", AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
EXPECT_EQ(avsessionHere_ != nullptr, true);
|
|
avservice_->SaveSessionInfoInFile("ancoMediaSession", avsessionHere_->GetSessionId(),
|
|
"audio", elementName);
|
|
avservice_->isAudioBrokerStart_ = true;
|
|
std::string moduleName = "moduleName";
|
|
auto ret = avservice_->StartAVPlayback(g_testAnotherBundleName, "FAKE_ASSET_NAME", moduleName);
|
|
EXPECT_EQ(ret, AVSESSION_ERROR);
|
|
avservice_->isAudioBrokerStart_ = false;
|
|
avsessionHere_->Destroy();
|
|
SLOGI("StartAVPlayback003 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, GetSubNode001, TestSize.Level0)
|
|
{
|
|
SLOGI("GetSubNode001 begin!");
|
|
|
|
cJSON* value = cJSON_CreateObject();
|
|
if (value == nullptr) {
|
|
SLOGE("get value nullptr");
|
|
FAIL();
|
|
}
|
|
if (cJSON_IsInvalid(value)) {
|
|
SLOGE("get value invalid");
|
|
cJSON_Delete(value);
|
|
value = nullptr;
|
|
FAIL();
|
|
}
|
|
cJSON_AddStringToObject(value, "bundleName", g_testAnotherBundleName);
|
|
avservice_->GetSubNode(value, "FAKE_NAME");
|
|
EXPECT_EQ(0, AVSESSION_SUCCESS);
|
|
|
|
cJSON_Delete(value);
|
|
value = nullptr;
|
|
SLOGI("GetSubNode001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, Close001, TestSize.Level0)
|
|
{
|
|
SLOGI("Close001 begin!");
|
|
avservice_->Close();
|
|
EXPECT_EQ(0, AVSESSION_SUCCESS);
|
|
SLOGI("Close001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, DeleteHistoricalRecord001, TestSize.Level0)
|
|
{
|
|
SLOGI("DeleteHistoricalRecord001 begin!");
|
|
avservice_->DeleteHistoricalRecord(g_testAnotherBundleName);
|
|
EXPECT_EQ(0, AVSESSION_SUCCESS);
|
|
SLOGI("DeleteHistoricalRecord001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, Dump001, TestSize.Level0)
|
|
{
|
|
SLOGI("Dump001 begin!");
|
|
std::vector<std::u16string> argsList;
|
|
avservice_->Dump(1, argsList);
|
|
EXPECT_EQ(0, AVSESSION_SUCCESS);
|
|
SLOGI("Dump001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, ProcessCastAudioCommand001, TestSize.Level0)
|
|
{
|
|
SLOGI("ProcessCastAudioCommand001 begin!");
|
|
std::string sourceSessionInfo = "SOURCE";
|
|
std::string sinkSessionInfo = " SINK";
|
|
avservice_->ProcessCastAudioCommand(
|
|
OHOS::AVSession::AVSessionServiceStub::RemoteServiceCommand::COMMAND_CAST_AUDIO,
|
|
sourceSessionInfo, sinkSessionInfo);
|
|
EXPECT_EQ(0, AVSESSION_SUCCESS);
|
|
SLOGI("ProcessCastAudioCommand001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, ProcessCastAudioCommand002, TestSize.Level0)
|
|
{
|
|
SLOGI("ProcessCastAudioCommand002 begin!");
|
|
std::string sourceSessionInfo = "SOURCE";
|
|
std::string sinkSessionInfo = " SINK";
|
|
avservice_->ProcessCastAudioCommand(
|
|
OHOS::AVSession::AVSessionServiceStub::RemoteServiceCommand::COMMAND_CANCEL_CAST_AUDIO,
|
|
sourceSessionInfo, sinkSessionInfo);
|
|
EXPECT_EQ(0, AVSESSION_SUCCESS);
|
|
SLOGI("ProcessCastAudioCommand002 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, OnReceiveEvent001, TestSize.Level1)
|
|
{
|
|
SLOGI("OnReceiveEvent001 begin!");
|
|
OHOS::EventFwk::CommonEventData eventData;
|
|
string action = OHOS::EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_ON;
|
|
OHOS::AAFwk::Want want = eventData.GetWant();
|
|
want.SetAction(action);
|
|
eventData.SetWant(want);
|
|
OHOS::EventFwk::MatchingSkills matchingSkills;
|
|
OHOS::EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
|
|
EventSubscriber eventSubscriber(subscriberInfo, avservice_);
|
|
eventSubscriber.OnReceiveEvent(eventData);
|
|
EXPECT_EQ(0, AVSESSION_SUCCESS);
|
|
SLOGI("OnReceiveEvent001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, OnReceiveEvent002, TestSize.Level0)
|
|
{
|
|
SLOGI("OnReceiveEvent002 begin!");
|
|
OHOS::EventFwk::CommonEventData eventData;
|
|
string action = OHOS::EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_OFF;
|
|
OHOS::AAFwk::Want want = eventData.GetWant();
|
|
want.SetAction(action);
|
|
eventData.SetWant(want);
|
|
OHOS::EventFwk::MatchingSkills matchingSkills;
|
|
OHOS::EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
|
|
EventSubscriber eventSubscriber(subscriberInfo, avservice_);
|
|
eventSubscriber.OnReceiveEvent(eventData);
|
|
EXPECT_EQ(0, AVSESSION_SUCCESS);
|
|
SLOGI("OnReceiveEvent002 end!");
|
|
}
|
|
|
|
static std::string GetUnlockCleanFlagPath(int32_t userId)
|
|
{
|
|
std::string cacheDir = AVSessionUtils::GetCachePathName(userId);
|
|
return cacheDir.substr(0, cacheDir.find("cache/")) + "unlock_clean_flag";
|
|
}
|
|
|
|
// Reset both in-memory cache and on-disk flag so a case starts from a "never cleaned this boot" state.
|
|
// The in-memory members are private; this UT uses `#define private public` so they are reachable.
|
|
static void ResetFirstUnlockCleanupState(int32_t userId)
|
|
{
|
|
avservice_->cleanedBootCountByUser_.clear();
|
|
OHOS::RemoveFile(GetUnlockCleanFlagPath(userId));
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, HandleFirstUnlockCleanup001, TestSize.Level0)
|
|
{
|
|
SLOGI("HandleFirstUnlockCleanup001 begin!");
|
|
int32_t userId = AVSessionUsersManager::GetInstance().GetCurrentUserId();
|
|
std::string cacheDir = AVSessionUtils::GetCachePathName(userId);
|
|
ASSERT_TRUE(OHOS::ForceCreateDirectory(cacheDir));
|
|
std::string staleFile = cacheDir + "staleclean001.image.dat";
|
|
ASSERT_TRUE(OHOS::SaveStringToFile(staleFile, "stale"));
|
|
ResetFirstUnlockCleanupState(userId);
|
|
|
|
avservice_->HandleFirstUnlockCleanup(userId);
|
|
EXPECT_FALSE(OHOS::FileExists(staleFile));
|
|
EXPECT_TRUE(OHOS::ForceRemoveDirectory(cacheDir));
|
|
OHOS::RemoveFile(GetUnlockCleanFlagPath(userId));
|
|
SLOGI("HandleFirstUnlockCleanup001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, HandleFirstUnlockCleanup002, TestSize.Level0)
|
|
{
|
|
SLOGI("HandleFirstUnlockCleanup002 begin!");
|
|
int32_t userId = AVSessionUsersManager::GetInstance().GetCurrentUserId();
|
|
std::string cacheDir = AVSessionUtils::GetCachePathName(userId);
|
|
ASSERT_TRUE(OHOS::ForceCreateDirectory(cacheDir));
|
|
std::string staleFile = cacheDir + "staleclean002.image.dat";
|
|
ASSERT_TRUE(OHOS::SaveStringToFile(staleFile, "stale"));
|
|
ResetFirstUnlockCleanupState(userId);
|
|
|
|
avservice_->HandleFirstUnlockCleanup(0);
|
|
EXPECT_FALSE(OHOS::FileExists(staleFile));
|
|
EXPECT_TRUE(OHOS::ForceRemoveDirectory(cacheDir));
|
|
OHOS::RemoveFile(GetUnlockCleanFlagPath(userId));
|
|
SLOGI("HandleFirstUnlockCleanup002 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, HandleFirstUnlockCleanupDedup001, TestSize.Level0)
|
|
{
|
|
SLOGI("HandleFirstUnlockCleanupDedup001 begin!");
|
|
int32_t userId = AVSessionUsersManager::GetInstance().GetCurrentUserId();
|
|
std::string cacheDir = AVSessionUtils::GetCachePathName(userId);
|
|
ASSERT_TRUE(OHOS::ForceCreateDirectory(cacheDir));
|
|
std::string flagPath = GetUnlockCleanFlagPath(userId);
|
|
ResetFirstUnlockCleanupState(userId);
|
|
|
|
std::string firstFile = cacheDir + "dedupfirst.image.dat";
|
|
ASSERT_TRUE(OHOS::SaveStringToFile(firstFile, "stale"));
|
|
avservice_->HandleFirstUnlockCleanup(userId);
|
|
EXPECT_FALSE(OHOS::FileExists(firstFile));
|
|
EXPECT_TRUE(OHOS::FileExists(flagPath));
|
|
|
|
std::string secondFile = cacheDir + "dedupsecond.image.dat";
|
|
ASSERT_TRUE(OHOS::SaveStringToFile(secondFile, "stale"));
|
|
avservice_->HandleFirstUnlockCleanup(userId);
|
|
EXPECT_TRUE(OHOS::FileExists(secondFile));
|
|
|
|
EXPECT_TRUE(OHOS::ForceRemoveDirectory(cacheDir));
|
|
OHOS::RemoveFile(flagPath);
|
|
SLOGI("HandleFirstUnlockCleanupDedup001 end!");
|
|
}
|
|
|
|
// Verify the in-memory fast path: after the first cleanup this boot, the user is cached and a second
|
|
// call returns without touching the flag file even if the file is recreated.
|
|
static HWTEST_F(AVSessionServiceTest, HandleFirstUnlockCleanupMemCache001, TestSize.Level0)
|
|
{
|
|
SLOGI("HandleFirstUnlockCleanupMemCache001 begin!");
|
|
int32_t userId = AVSessionUsersManager::GetInstance().GetCurrentUserId();
|
|
std::string cacheDir = AVSessionUtils::GetCachePathName(userId);
|
|
ASSERT_TRUE(OHOS::ForceCreateDirectory(cacheDir));
|
|
std::string flagPath = GetUnlockCleanFlagPath(userId);
|
|
ResetFirstUnlockCleanupState(userId);
|
|
|
|
std::string firstFile = cacheDir + "memcache1.image.dat";
|
|
ASSERT_TRUE(OHOS::SaveStringToFile(firstFile, "stale"));
|
|
avservice_->HandleFirstUnlockCleanup(userId);
|
|
EXPECT_FALSE(OHOS::FileExists(firstFile));
|
|
int32_t realBootCount = OHOS::system::GetIntParameter("persist.startup.bootcount", -1);
|
|
auto it = avservice_->cleanedBootCountByUser_.find(userId);
|
|
ASSERT_TRUE(it != avservice_->cleanedBootCountByUser_.end());
|
|
EXPECT_EQ(it->second, realBootCount);
|
|
|
|
// Second call: in-memory cache should short-circuit; a new stale file survives.
|
|
std::string secondFile = cacheDir + "memcache2.image.dat";
|
|
ASSERT_TRUE(OHOS::SaveStringToFile(secondFile, "stale"));
|
|
avservice_->HandleFirstUnlockCleanup(userId);
|
|
EXPECT_TRUE(OHOS::FileExists(secondFile));
|
|
|
|
EXPECT_TRUE(OHOS::ForceRemoveDirectory(cacheDir));
|
|
OHOS::RemoveFile(flagPath);
|
|
SLOGI("HandleFirstUnlockCleanupMemCache001 end!");
|
|
}
|
|
|
|
// Verify the reboot-handling branch: the in-memory cache stores the bootcount at which each user was
|
|
// last cleaned. When that stored value no longer matches the current bootcount (simulating a real
|
|
// reboot), the cache simply misses and cleanup runs again -- no explicit reset step is needed.
|
|
static HWTEST_F(AVSessionServiceTest, HandleFirstUnlockCleanupBootCountChange001, TestSize.Level0)
|
|
{
|
|
SLOGI("HandleFirstUnlockCleanupBootCountChange001 begin!");
|
|
int32_t userId = AVSessionUsersManager::GetInstance().GetCurrentUserId();
|
|
int32_t realBootCount = OHOS::system::GetIntParameter("persist.startup.bootcount", -1);
|
|
ASSERT_GE(realBootCount, 0); // bootcount must be readable for this case to be meaningful
|
|
std::string cacheDir = AVSessionUtils::GetCachePathName(userId);
|
|
ASSERT_TRUE(OHOS::ForceCreateDirectory(cacheDir));
|
|
std::string flagPath = GetUnlockCleanFlagPath(userId);
|
|
ResetFirstUnlockCleanupState(userId);
|
|
|
|
// Simulate "already cleaned during a previous boot" by storing a stale bootcount in the cache and
|
|
// removing the flag file. The mismatch means this boot has not cleaned yet.
|
|
avservice_->cleanedBootCountByUser_[userId] = realBootCount + 1; // different boot -> miss
|
|
OHOS::RemoveFile(flagPath);
|
|
|
|
std::string staleFile = cacheDir + "bootchg1.image.dat";
|
|
ASSERT_TRUE(OHOS::SaveStringToFile(staleFile, "stale"));
|
|
avservice_->HandleFirstUnlockCleanup(userId);
|
|
// Cache missed on the bootcount mismatch, so cleanup ran and the stale file is gone.
|
|
EXPECT_FALSE(OHOS::FileExists(staleFile));
|
|
// Cache refreshed to the real bootcount, so a second call now short-circuits.
|
|
EXPECT_EQ(avservice_->cleanedBootCountByUser_[userId], realBootCount);
|
|
|
|
std::string secondFile = cacheDir + "bootchg2.image.dat";
|
|
ASSERT_TRUE(OHOS::SaveStringToFile(secondFile, "stale"));
|
|
avservice_->HandleFirstUnlockCleanup(userId);
|
|
EXPECT_TRUE(OHOS::FileExists(secondFile));
|
|
|
|
EXPECT_TRUE(OHOS::ForceRemoveDirectory(cacheDir));
|
|
OHOS::RemoveFile(flagPath);
|
|
SLOGI("HandleFirstUnlockCleanupBootCountChange001 end!");
|
|
}
|
|
|
|
// Verify the on-disk dedup path: after a cleanup, if the in-memory cache is lost (simulating a
|
|
// process crash/restart within the same boot), the on-disk flag still suppresses re-cleanup.
|
|
static HWTEST_F(AVSessionServiceTest, HandleFirstUnlockCleanupDiskDedup001, TestSize.Level0)
|
|
{
|
|
SLOGI("HandleFirstUnlockCleanupDiskDedup001 begin!");
|
|
int32_t userId = AVSessionUsersManager::GetInstance().GetCurrentUserId();
|
|
std::string cacheDir = AVSessionUtils::GetCachePathName(userId);
|
|
ASSERT_TRUE(OHOS::ForceCreateDirectory(cacheDir));
|
|
std::string flagPath = GetUnlockCleanFlagPath(userId);
|
|
ResetFirstUnlockCleanupState(userId);
|
|
|
|
// First call: cleanup runs and writes the on-disk flag.
|
|
std::string firstFile = cacheDir + "diskdedup1.image.dat";
|
|
ASSERT_TRUE(OHOS::SaveStringToFile(firstFile, "stale"));
|
|
avservice_->HandleFirstUnlockCleanup(userId);
|
|
EXPECT_FALSE(OHOS::FileExists(firstFile));
|
|
|
|
// Simulate a process crash: wipe the in-memory cache but keep the on-disk flag.
|
|
avservice_->cleanedBootCountByUser_.clear();
|
|
|
|
// Second call: in-memory miss, but the on-disk flag matches the current bootcount, so cleanup
|
|
// must be skipped and a new stale file survives.
|
|
std::string secondFile = cacheDir + "diskdedup2.image.dat";
|
|
ASSERT_TRUE(OHOS::SaveStringToFile(secondFile, "stale"));
|
|
avservice_->HandleFirstUnlockCleanup(userId);
|
|
EXPECT_TRUE(OHOS::FileExists(secondFile));
|
|
// The in-memory cache is repopulated from the on-disk flag.
|
|
int32_t realBootCount = OHOS::system::GetIntParameter("persist.startup.bootcount", -1);
|
|
EXPECT_EQ(avservice_->cleanedBootCountByUser_[userId], realBootCount);
|
|
|
|
EXPECT_TRUE(OHOS::ForceRemoveDirectory(cacheDir));
|
|
OHOS::RemoveFile(flagPath);
|
|
SLOGI("HandleFirstUnlockCleanupDiskDedup001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, OnReceiveEventScreenUnlocked001, TestSize.Level0)
|
|
{
|
|
SLOGI("OnReceiveEventScreenUnlocked001 begin!");
|
|
int32_t userId = AVSessionUsersManager::GetInstance().GetCurrentUserId();
|
|
std::string cacheDir = AVSessionUtils::GetCachePathName(userId);
|
|
ASSERT_TRUE(OHOS::ForceCreateDirectory(cacheDir));
|
|
std::string staleFile = cacheDir + "screenunlock001.image.dat";
|
|
ASSERT_TRUE(OHOS::SaveStringToFile(staleFile, "stale"));
|
|
std::string flagPath = GetUnlockCleanFlagPath(userId);
|
|
ResetFirstUnlockCleanupState(userId);
|
|
|
|
OHOS::EventFwk::CommonEventData eventData;
|
|
OHOS::AAFwk::Want want = eventData.GetWant();
|
|
want.SetAction(OHOS::EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_UNLOCKED);
|
|
eventData.SetWant(want);
|
|
OHOS::EventFwk::MatchingSkills matchingSkills;
|
|
OHOS::EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
|
|
EventSubscriber eventSubscriber(subscriberInfo, avservice_);
|
|
eventSubscriber.OnReceiveEvent(eventData);
|
|
EXPECT_FALSE(OHOS::FileExists(staleFile));
|
|
EXPECT_TRUE(OHOS::ForceRemoveDirectory(cacheDir));
|
|
OHOS::RemoveFile(flagPath);
|
|
SLOGI("OnReceiveEventScreenUnlocked001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, OnReceiveEventUserUnlockedNoCleanup001, TestSize.Level0)
|
|
{
|
|
SLOGI("OnReceiveEventUserUnlockedNoCleanup001 begin!");
|
|
int32_t userId = AVSessionUsersManager::GetInstance().GetCurrentUserId();
|
|
std::string cacheDir = AVSessionUtils::GetCachePathName(userId);
|
|
ASSERT_TRUE(OHOS::ForceCreateDirectory(cacheDir));
|
|
std::string staleFile = cacheDir + "userlockednoclean.image.dat";
|
|
ASSERT_TRUE(OHOS::SaveStringToFile(staleFile, "stale"));
|
|
std::string flagPath = GetUnlockCleanFlagPath(userId);
|
|
ResetFirstUnlockCleanupState(userId);
|
|
|
|
OHOS::EventFwk::CommonEventData eventData;
|
|
OHOS::AAFwk::Want want = eventData.GetWant();
|
|
want.SetAction(OHOS::EventFwk::CommonEventSupport::COMMON_EVENT_USER_UNLOCKED);
|
|
eventData.SetWant(want);
|
|
OHOS::EventFwk::MatchingSkills matchingSkills;
|
|
OHOS::EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
|
|
EventSubscriber eventSubscriber(subscriberInfo, avservice_);
|
|
eventSubscriber.OnReceiveEvent(eventData);
|
|
// USER_UNLOCKED must NOT trigger cleanup, so the stale file remains.
|
|
EXPECT_TRUE(OHOS::FileExists(staleFile));
|
|
EXPECT_TRUE(OHOS::ForceRemoveDirectory(cacheDir));
|
|
OHOS::RemoveFile(flagPath);
|
|
SLOGI("OnReceiveEventUserUnlockedNoCleanup001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, OnReceiveEvent004, TestSize.Level1)
|
|
{
|
|
SLOGD("OnReceiveEvent004 begin!");
|
|
OHOS::EventFwk::CommonEventData eventData;
|
|
string action = "usual.event.PACKAGE_REMOVED";
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::AAFwk::Want want = eventData.GetWant();
|
|
want.SetAction(action);
|
|
want.SetElement(elementName);
|
|
eventData.SetWant(want);
|
|
OHOS::EventFwk::MatchingSkills matchingSkills;
|
|
OHOS::EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
|
|
EventSubscriber eventSubscriber(subscriberInfo, avservice_);
|
|
eventSubscriber.OnReceiveEvent(eventData);
|
|
SLOGD("OnReceiveEvent004 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, OnReceiveEvent005, TestSize.Level1)
|
|
{
|
|
SLOGD("OnReceiveEvent005 begin!");
|
|
OHOS::EventFwk::CommonEventData eventData;
|
|
string action = "usual.event.CAST_SESSION_CREATE";
|
|
OHOS::AAFwk::Want want = eventData.GetWant();
|
|
want.SetAction(action);
|
|
eventData.SetWant(want);
|
|
OHOS::EventFwk::MatchingSkills matchingSkills;
|
|
OHOS::EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
|
|
EventSubscriber eventSubscriber(subscriberInfo, avservice_);
|
|
eventSubscriber.OnReceiveEvent(eventData);
|
|
EXPECT_TRUE(avservice_ != nullptr);
|
|
SLOGD("OnReceiveEvent005 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, OnReceiveEvent006, TestSize.Level1)
|
|
{
|
|
SLOGD("OnReceiveEvent006 begin!");
|
|
OHOS::EventFwk::CommonEventData eventData;
|
|
string action = "usual.event.MEDIA_NTF_SWITCH";
|
|
OHOS::AAFwk::Want want = eventData.GetWant();
|
|
want.SetAction(action);
|
|
eventData.SetWant(want);
|
|
OHOS::EventFwk::MatchingSkills matchingSkills;
|
|
OHOS::EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
|
|
EventSubscriber eventSubscriber(subscriberInfo, avservice_);
|
|
eventSubscriber.OnReceiveEvent(eventData);
|
|
EXPECT_TRUE(avservice_ != nullptr);
|
|
SLOGD("OnReceiveEvent006 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, UnSubscribeCommonEvent001, TestSize.Level0)
|
|
{
|
|
SLOGI("SubscribeCommonEvent001 begin!");
|
|
EXPECT_TRUE(avservice_ != nullptr);
|
|
avservice_->SubscribeCommonEvent();
|
|
avservice_->UnSubscribeCommonEvent();
|
|
SLOGI("SubscribeCommonEvent001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, UnSubscribeCommonEvent002, TestSize.Level0)
|
|
{
|
|
SLOGI("SubscribeCommonEvent002 begin!");
|
|
EXPECT_TRUE(avservice_ != nullptr);
|
|
avservice_->UnSubscribeCommonEvent();
|
|
SLOGI("SubscribeCommonEvent002 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, OnRemoveSystemAbility001, TestSize.Level0)
|
|
{
|
|
SLOGI("OnRemoveSystemAbility001 begin!");
|
|
EXPECT_TRUE(avservice_ != nullptr);
|
|
int32_t systemAbilityId = 65546;
|
|
std::string deviceId = "";
|
|
avservice_->OnRemoveSystemAbility(systemAbilityId, deviceId);
|
|
SLOGI("OnRemoveSystemAbility001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, OnRemoveSystemAbility002, TestSize.Level0)
|
|
{
|
|
SLOGI("OnRemoveSystemAbility002 begin!");
|
|
EXPECT_TRUE(avservice_ != nullptr);
|
|
int32_t systemAbilityId = 111222;
|
|
std::string deviceId = "";
|
|
avservice_->OnRemoveSystemAbility(systemAbilityId, deviceId);
|
|
SLOGI("OnRemoveSystemAbility002 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, OnRemoveSystemAbility003, TestSize.Level1)
|
|
{
|
|
SLOGI("OnRemoveSystemAbility003 begin!");
|
|
ASSERT_TRUE(avservice_ != nullptr);
|
|
int32_t systemAbilityId = 66849;
|
|
std::string deviceId = "";
|
|
avservice_->OnRemoveSystemAbility(systemAbilityId, deviceId);
|
|
EXPECT_EQ(avservice_->isAudioBrokerStart_, false);
|
|
SLOGI("OnRemoveSystemAbility003 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, GetHistoricalSessionDescriptorsFromFile001, TestSize.Level0)
|
|
{
|
|
SLOGI("GetHistoricalSessionDescriptorsFromFile001 begin!");
|
|
std::vector<AVSessionDescriptor> descriptors;
|
|
int32_t ret = avservice_->GetHistoricalSessionDescriptorsFromFile(descriptors);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
SLOGI("GetHistoricalSessionDescriptorsFromFile001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, GetHistoricalSessionDescriptorsFromFile002, TestSize.Level1)
|
|
{
|
|
SLOGI("GetHistoricalSessionDescriptorsFromFile002 begin!");
|
|
ASSERT_TRUE(avservice_ != nullptr);
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner("ancoMediaSession", AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
EXPECT_EQ(avsessionHere_ != nullptr, true);
|
|
avservice_->SaveSessionInfoInFile("ancoMediaSession", avsessionHere_->GetSessionId(),
|
|
"audio", elementName);
|
|
avservice_->isAudioBrokerStart_ = false;
|
|
std::vector<AVSessionDescriptor> descriptors;
|
|
auto ret = avservice_->GetHistoricalSessionDescriptorsFromFile(descriptors);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
avservice_->isAudioBrokerStart_ = true;
|
|
ret = avservice_->GetHistoricalSessionDescriptorsFromFile(descriptors);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
avsessionHere_->Destroy();
|
|
SLOGI("GetHistoricalSessionDescriptorsFromFile002 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, GetHistoricalSessionDescriptors001, TestSize.Level0)
|
|
{
|
|
SLOGI("GetHistoricalSessionDescriptors001 begin!");
|
|
int32_t maxSize = -1;
|
|
std::vector<AVSessionDescriptor> descriptors;
|
|
int32_t ret = avservice_->GetHistoricalSessionDescriptors(maxSize, descriptors);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
SLOGI("GetHistoricalSessionDescriptors001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, GetHistoricalSessionDescriptors002, TestSize.Level0)
|
|
{
|
|
SLOGI("GetHistoricalSessionDescriptors002 begin!");
|
|
int32_t maxSize = 50;
|
|
std::vector<AVSessionDescriptor> descriptors;
|
|
int32_t ret = avservice_->GetHistoricalSessionDescriptors(maxSize, descriptors);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
SLOGI("GetHistoricalSessionDescriptors002 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, GetHistoricalSessionDescriptors003, TestSize.Level0)
|
|
{
|
|
SLOGI("GetHistoricalSessionDescriptors003 begin!");
|
|
int32_t maxSize = 10;
|
|
std::vector<AVSessionDescriptor> descriptors;
|
|
for (int i = 0; i <= maxSize; i++) {
|
|
AVSessionDescriptor aVSessionDescriptor;
|
|
descriptors.emplace_back(aVSessionDescriptor);
|
|
}
|
|
int32_t ret = avservice_->GetHistoricalSessionDescriptors(maxSize, descriptors);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
SLOGI("GetHistoricalSessionDescriptors003 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, DoMetadataImgClean001, TestSize.Level0)
|
|
{
|
|
SLOGI("DoMetadataImgClean001 begin!");
|
|
EXPECT_TRUE(avservice_ != nullptr);
|
|
OHOS::AVSession::AVMetaData metaData;
|
|
|
|
std::shared_ptr<AVSessionPixelMap> avQueuePixelMap = std::make_shared<AVSessionPixelMap>();
|
|
std::vector<uint8_t> imgBuffer = {1, 1, 0, 1, 1};
|
|
avQueuePixelMap->SetInnerImgBuffer(imgBuffer);
|
|
metaData.SetAVQueueImage(avQueuePixelMap);
|
|
|
|
std::shared_ptr<AVSessionPixelMap> mediaPixelMap = std::make_shared<AVSessionPixelMap>();
|
|
std::vector<uint8_t> imgBuffer2 = {1, 0, 0, 0, 1};
|
|
mediaPixelMap->SetInnerImgBuffer(imgBuffer2);
|
|
metaData.SetMediaImage(mediaPixelMap);
|
|
|
|
avservice_->DoMetadataImgClean(metaData);
|
|
SLOGI("DoMetadataImgClean001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, DoMetadataImgClean002, TestSize.Level0)
|
|
{
|
|
SLOGI("DoMetadataImgClean002 begin!");
|
|
EXPECT_TRUE(avservice_ != nullptr);
|
|
OHOS::AVSession::AVMetaData metaData;
|
|
avservice_->DoMetadataImgClean(metaData);
|
|
SLOGI("DoMetadataImgClean002 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, Dump002, TestSize.Level0)
|
|
{
|
|
SLOGI("Dump002 begin!");
|
|
int32_t fd = -1;
|
|
std::vector<std::u16string> argsList;
|
|
int32_t ret = avservice_->Dump(fd, argsList);
|
|
EXPECT_EQ(ret, ERR_INVALID_PARAM);
|
|
SLOGI("Dump002 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, GetTrustedDeviceName001, TestSize.Level0)
|
|
{
|
|
SLOGI("GetTrustedDeviceName001 begin!");
|
|
std::string networkId = "";
|
|
std::string deviceName = "";
|
|
int32_t ret = avservice_->GetTrustedDeviceName(networkId, deviceName);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
SLOGI("GetTrustedDeviceName001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, HandleFocusSession001, TestSize.Level0)
|
|
{
|
|
SLOGI("HandleFocusSession001 begin!");
|
|
EXPECT_TRUE(avservice_ != nullptr);
|
|
int32_t pid = 201;
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
avsessionHere_->SetUid(pid);
|
|
avservice_->UpdateTopSession(avsessionHere_);
|
|
FocusSessionStrategy::FocusSessionChangeInfo info;
|
|
info.uid = pid;
|
|
avservice_->HandleFocusSession(info, false);
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
avsessionHere_->Destroy();
|
|
SLOGI("HandleFocusSession001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, HandleFocusSession002, TestSize.Level0)
|
|
{
|
|
SLOGI("HandleFocusSession002 begin!");
|
|
EXPECT_TRUE(avservice_ != nullptr);
|
|
int32_t pid = 202;
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_VOICE_CALL, false, elementName);
|
|
avsessionHere_->SetUid(pid);
|
|
avservice_->UpdateTopSession(avsessionHere_);
|
|
FocusSessionStrategy::FocusSessionChangeInfo info;
|
|
info.uid = 203;
|
|
avservice_->HandleFocusSession(info, false);
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
avsessionHere_->Destroy();
|
|
SLOGI("HandleFocusSession002 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, UpdateFrontSession001, TestSize.Level0)
|
|
{
|
|
SLOGI("HandleFocusSession001 begin!");
|
|
EXPECT_TRUE(avservice_ != nullptr);
|
|
int32_t pid = 203;
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
avsessionHere_->SetUid(pid);
|
|
FocusSessionStrategy::FocusSessionChangeInfo info;
|
|
info.uid = pid;
|
|
avservice_->HandleFocusSession(info, false);
|
|
avservice_->UpdateFrontSession(avsessionHere_, true);
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
avsessionHere_->Destroy();
|
|
SLOGI("HandleFocusSession001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, UpdateFrontSession002, TestSize.Level0)
|
|
{
|
|
SLOGI("UpdateFrontSession002 begin!");
|
|
EXPECT_TRUE(avservice_ != nullptr);
|
|
int32_t pid = 204;
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
avsessionHere_->SetUid(pid);
|
|
FocusSessionStrategy::FocusSessionChangeInfo info;
|
|
info.uid = 205;
|
|
avservice_->HandleFocusSession(info, false);
|
|
avservice_->UpdateFrontSession(avsessionHere_, true);
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
avsessionHere_->Destroy();
|
|
SLOGI("UpdateFrontSession002 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, SelectFocusSession001, TestSize.Level0)
|
|
{
|
|
SLOGI("SelectFocusSession001 begin!");
|
|
int32_t pid = 205;
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
avsessionHere_->SetUid(pid);
|
|
FocusSessionStrategy::FocusSessionChangeInfo info;
|
|
info.pid = avsessionHere_->GetPid();
|
|
bool ret = avservice_->SelectFocusSession(info);
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
avsessionHere_->Destroy();
|
|
EXPECT_EQ(ret, true);
|
|
SLOGI("SelectFocusSession001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, SelectFocusSession002, TestSize.Level0)
|
|
{
|
|
SLOGI("SelectFocusSession002 begin!");
|
|
int32_t pid = 206;
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
avsessionHere_->SetUid(pid);
|
|
FocusSessionStrategy::FocusSessionChangeInfo info;
|
|
info.uid = 207;
|
|
bool ret = avservice_->SelectFocusSession(info);
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
avsessionHere_->Destroy();
|
|
EXPECT_EQ(ret, false);
|
|
SLOGI("SelectFocusSession002 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, SelectSessionByUid003, TestSize.Level0)
|
|
{
|
|
SLOGI("SelectSessionByUid003 begin!");
|
|
int32_t pid = 207;
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
EXPECT_EQ(avsessionHere_ != nullptr, true);
|
|
avsessionHere_->SetUid(pid);
|
|
AudioRendererChangeInfo info = {};
|
|
info.clientUID = 208;
|
|
auto ret = avservice_->SelectSessionByUid(info);
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
avsessionHere_->Destroy();
|
|
EXPECT_EQ(ret, nullptr);
|
|
SLOGI("SelectSessionByUid003 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, GetSessionDescriptorsBySessionId001, TestSize.Level0)
|
|
{
|
|
SLOGI("GetSessionDescriptorsBySessionId001 begin!");
|
|
int32_t pid = 206;
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
avsessionHere_->SetUid(pid);
|
|
std::string sessionId = "";
|
|
AVSessionDescriptor descriptor;
|
|
int32_t ret = avservice_->GetSessionDescriptorsBySessionId(sessionId, descriptor);
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
avsessionHere_->Destroy();
|
|
EXPECT_EQ(ret, AVSESSION_ERROR);
|
|
SLOGI("GetSessionDescriptorsBySessionId001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, SendSystemAVKeyEvent007, TestSize.Level0)
|
|
{
|
|
SLOGI("SendSystemAVKeyEvent007 begin!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_VOICE_CALL, false, elementName);
|
|
auto keyEvent = OHOS::MMI::KeyEvent::Create();
|
|
ASSERT_NE(keyEvent, nullptr);
|
|
bool ret = avservice_->SendSystemAVKeyEvent(*keyEvent);
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
avsessionHere_->Destroy();
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
SLOGI("SendSystemAVKeyEvent007 end!");
|
|
}
|
|
|
|
|
|
static HWTEST_F(AVSessionServiceTest, SendSystemAVKeyEvent008, TestSize.Level0)
|
|
{
|
|
SLOGI("SendSystemAVKeyEvent008 begin!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
auto keyEvent = OHOS::MMI::KeyEvent::Create();
|
|
ASSERT_NE(keyEvent, nullptr);
|
|
avservice_->UpdateTopSession(avsessionHere_);
|
|
bool ret = avservice_->SendSystemAVKeyEvent(*keyEvent);
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
avsessionHere_->Destroy();
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
SLOGI("SendSystemAVKeyEvent008 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, SendSystemAVKeyEvent009, TestSize.Level0)
|
|
{
|
|
SLOGI("SendSystemAVKeyEvent009 begin!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
auto keyEvent = OHOS::MMI::KeyEvent::Create();
|
|
ASSERT_NE(keyEvent, nullptr);
|
|
OHOS::AAFwk::Want bluetoothWant;
|
|
std::string activeAddress = "00:00:00:00:00:00";
|
|
bluetoothWant.SetParam("deviceId", activeAddress);
|
|
bool ret = avservice_->SendSystemAVKeyEvent(*keyEvent, bluetoothWant);
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
avsessionHere_->Destroy();
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
SLOGI("SendSystemAVKeyEvent009 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, PullMigrateStub001, TestSize.Level0)
|
|
{
|
|
SLOGI("PullMigrateStub001 begin!");
|
|
EXPECT_TRUE(avservice_ != nullptr);
|
|
avservice_->PullMigrateStub();
|
|
SLOGI("PullMigrateStub001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, UpdateFrontSession003, TestSize.Level0)
|
|
{
|
|
SLOGI("UpdateFrontSession003 begin!");
|
|
EXPECT_TRUE(avservice_ != nullptr);
|
|
int32_t pid = 304;
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_VOICE_CALL, false, elementName);
|
|
avsessionHere_->SetUid(pid);
|
|
avservice_->UpdateFrontSession(avsessionHere_, true);
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
avsessionHere_->Destroy();
|
|
SLOGI("UpdateFrontSession003 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, CreateSessionInner001, TestSize.Level0)
|
|
{
|
|
SLOGI("CreateSessionInner001 begin!");
|
|
OHOS::sptr<AVSessionItem> sessionItem = nullptr;
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName("######");
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
int32_t ret = avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO,
|
|
false, elementName, sessionItem);
|
|
EXPECT_EQ(ret, ERR_INVALID_PARAM);
|
|
SLOGI("CreateSessionInner001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, CreateSessionInner002, TestSize.Level0)
|
|
{
|
|
SLOGI("CreateSessionInner001 begin!");
|
|
OHOS::sptr<AVSessionItem> sessionItem = nullptr;
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName("######");
|
|
int32_t ret = avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO,
|
|
false, elementName, sessionItem);
|
|
EXPECT_EQ(ret, ERR_INVALID_PARAM);
|
|
SLOGI("CreateSessionInner001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, CreateAndReleaseSessionSetCritical001, TestSize.Level0)
|
|
{
|
|
SLOGI("CreateAndReleaseSessionSetCritical001 begin!");
|
|
OHOS::sptr<AVSessionItem> sessionItem = nullptr;
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName("Test_1.abc");
|
|
int32_t ret = avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO,
|
|
false, elementName, sessionItem);
|
|
avservice_->SetCriticalWhenCreate(sessionItem);
|
|
avservice_->SetCriticalWhenRelease(sessionItem);
|
|
int32_t ancoUid = 1041;
|
|
sessionItem->SetUid(ancoUid);
|
|
avservice_->SetCriticalWhenCreate(sessionItem);
|
|
avservice_->SetCriticalWhenRelease(sessionItem);
|
|
avservice_->HandleSessionRelease(sessionItem->GetSessionId());
|
|
avservice_->SetCriticalWhenRelease(sessionItem);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
SLOGI("CreateAndReleaseSessionSetCritical001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, ReportSessionInfo001, TestSize.Level0)
|
|
{
|
|
SLOGI("ReportSessionInfo001 begin!");
|
|
EXPECT_TRUE(avservice_ != nullptr);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ = nullptr;
|
|
avservice_->ReportSessionInfo(avsessionHere_, true);
|
|
SLOGI("ReportSessionInfo001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, CreateNewControllerForSession001, TestSize.Level0)
|
|
{
|
|
SLOGI("CreateNewControllerForSession001 begin!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_VOICE_CALL, false, elementName);
|
|
pid_t pid = 2222;
|
|
auto ret = avservice_->CreateNewControllerForSession(pid, avsessionHere_);
|
|
EXPECT_NE(ret, nullptr);
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
avsessionHere_->Destroy();
|
|
SLOGI("CreateNewControllerForSession001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, IsHistoricalSession001, TestSize.Level0)
|
|
{
|
|
SLOGI("IsHistoricalSession001 begin!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
std::string sessionId = avsessionHere_->GetSessionId();
|
|
bool ret = avservice_->IsHistoricalSession(sessionId);
|
|
EXPECT_EQ(ret, false);
|
|
avservice_->HandleSessionRelease(sessionId);
|
|
avsessionHere_->Destroy();
|
|
SLOGI("IsHistoricalSession001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, StartDefaultAbilityByCall001, TestSize.Level0)
|
|
{
|
|
SLOGI("StartDefaultAbilityByCall001 begin!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
std::string sessionId = avsessionHere_->GetSessionId();
|
|
int32_t ret = avservice_->StartDefaultAbilityByCall(sessionId);
|
|
// startability may go with mediaintent, will return AVSESSION_ERROR
|
|
EXPECT_EQ(ret == ERR_ABILITY_NOT_AVAILABLE || ret == AVSESSION_SUCCESS || ret == AVSESSION_ERROR||
|
|
ret == ERR_START_ABILITY_TIMEOUT, true);
|
|
avservice_->HandleSessionRelease(sessionId);
|
|
avsessionHere_->Destroy();
|
|
SLOGI("StartDefaultAbilityByCall001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, StartAbilityByCall001, TestSize.Level0)
|
|
{
|
|
SLOGI("StartAbilityByCall001 begin!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
std::string sessionIdNeeded = "";
|
|
std::string sessionId = "";
|
|
int32_t ret = avservice_->StartAbilityByCall(sessionIdNeeded, sessionId);
|
|
EXPECT_EQ(ret, AVSESSION_ERROR);
|
|
avsessionHere_->Destroy();
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
SLOGI("StartAbilityByCall001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, SendSystemControlCommand001, TestSize.Level0)
|
|
{
|
|
SLOGI("SendSystemControlCommand001 begin!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
avservice_->UpdateFrontSession(avsessionHere_, true);
|
|
AVControlCommand command;
|
|
command.SetCommand(1000);
|
|
int32_t ret = avservice_->SendSystemControlCommand(command);
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
avsessionHere_->Destroy();
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
SLOGI("SendSystemControlCommand001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, HandleControllerRelease001, TestSize.Level0)
|
|
{
|
|
SLOGI("HandleControllerRelease001 begin!");
|
|
EXPECT_TRUE(avservice_ != nullptr);
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_VOICE_CALL, false, elementName);
|
|
OHOS::sptr<AVControllerItem> avcontrollerHere_ =
|
|
avservice_->CreateNewControllerForSession(avsessionHere_->GetPid(), avsessionHere_);
|
|
avservice_->HandleControllerRelease(*avcontrollerHere_);
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
avsessionHere_->Destroy();
|
|
SLOGI("HandleControllerRelease001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, GetDeviceInfo001, TestSize.Level0)
|
|
{
|
|
SLOGI("GetDeviceInfo001 begin!");
|
|
EXPECT_TRUE(avservice_ != nullptr);
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_VOICE_CALL, false, elementName);
|
|
std::vector<OHOS::AudioStandard::AudioDeviceDescriptor> descriptors;
|
|
avservice_->GetDeviceInfo(avsessionHere_, descriptors, descriptors, descriptors);
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
avsessionHere_->Destroy();
|
|
SLOGI("GetDeviceInfo001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, CreateControllerInner001, TestSize.Level0)
|
|
{
|
|
SLOGI("CreateControllerInner001 begin!");
|
|
std::string sessionId = "default";
|
|
OHOS::sptr<IRemoteObject> object = nullptr;
|
|
int32_t ret = avservice_->CreateControllerInner(sessionId, object);
|
|
// startability may go with mediaintent, will return AVSESSION_ERROR
|
|
EXPECT_EQ(ret == ERR_ABILITY_NOT_AVAILABLE || ret == AVSESSION_SUCCESS
|
|
|| ret == AVSESSION_ERROR || ret == ERR_SESSION_NOT_EXIST, true);
|
|
SLOGI("CreateControllerInner001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, ClearControllerForClientDiedNoLock001, TestSize.Level0)
|
|
{
|
|
SLOGI("ClearControllerForClientDiedNoLock001 begin!");
|
|
EXPECT_TRUE(avservice_ != nullptr);
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_VOICE_CALL, false, elementName);
|
|
std::string sessionId = avsessionHere_->GetSessionId();
|
|
OHOS::sptr<IRemoteObject> object = nullptr;
|
|
int32_t ret = avservice_->CreateControllerInner(sessionId, object);
|
|
ASSERT_EQ(ret, AVSESSION_SUCCESS);
|
|
avservice_->ClearControllerForClientDiedNoLock(avsessionHere_->GetPid());
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
avsessionHere_->Destroy();
|
|
SLOGI("ClearControllerForClientDiedNoLock001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, LoadStringFromFileEx001, TestSize.Level0)
|
|
{
|
|
SLOGI("LoadStringFromFileEx001 begin!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
EXPECT_EQ(avsessionHere_ != nullptr, true);
|
|
|
|
std::string filePath = avservice_->GetUsersManager().GetDirForCurrentUser() + "test1.txt";
|
|
std::string content;
|
|
bool ret = avservice_->LoadStringFromFileEx(filePath, content);
|
|
EXPECT_EQ(ret, true);
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
avsessionHere_->Destroy();
|
|
SLOGI("LoadStringFromFileEx001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, LoadStringFromFileEx002, TestSize.Level0)
|
|
{
|
|
SLOGI("LoadStringFromFileEx002 begin!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
EXPECT_EQ(avsessionHere_ != nullptr, true);
|
|
int32_t maxFileLength = 32 * 1024 * 1024;
|
|
std::string filePath = avservice_->GetUsersManager().GetDirForCurrentUser() + "test2.txt";
|
|
std::ofstream ofs;
|
|
ofs.open(filePath, std::ios::out);
|
|
for (int32_t i = 0; i <= maxFileLength; i++) {
|
|
ofs << "A";
|
|
}
|
|
ofs.close();
|
|
std::string content;
|
|
bool ret = avservice_->LoadStringFromFileEx(filePath, content);
|
|
EXPECT_EQ(ret, false);
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
avsessionHere_->Destroy();
|
|
SLOGI("LoadStringFromFileEx002 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, LoadStringFromFileEx003, TestSize.Level0)
|
|
{
|
|
SLOGI("LoadStringFromFileEx003 begin!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
EXPECT_EQ(avsessionHere_ != nullptr, true);
|
|
|
|
std::string filePath = avservice_->GetUsersManager().GetDirForCurrentUser() + "abcdeXYZ123/test3.txt";
|
|
std::string content;
|
|
std::ifstream file(filePath, std::ios_base::in);
|
|
bool ret = avservice_->LoadStringFromFileEx(filePath, content);
|
|
file.close();
|
|
EXPECT_EQ(ret, false);
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
avsessionHere_->Destroy();
|
|
SLOGI("LoadStringFromFileEx003 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, CheckStringAndCleanFile001, TestSize.Level0)
|
|
{
|
|
SLOGI("CheckStringAndCleanFile001 begin!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
EXPECT_EQ(avsessionHere_ != nullptr, true);
|
|
|
|
std::string filePath = avservice_->GetUsersManager().GetDirForCurrentUser() + "test6.txt";
|
|
bool ret = avservice_->CheckStringAndCleanFile(filePath);
|
|
EXPECT_EQ(ret, true);
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
avsessionHere_->Destroy();
|
|
SLOGI("CheckStringAndCleanFile001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, CheckStringAndCleanFile002, TestSize.Level0)
|
|
{
|
|
SLOGI("CheckStringAndCleanFile002 begin!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
EXPECT_EQ(avsessionHere_ != nullptr, true);
|
|
|
|
std::string filePath = avservice_->GetUsersManager().GetDirForCurrentUser() + "adcdXYZ123/test7.txt";
|
|
std::ifstream file(filePath, std::ios_base::in);
|
|
bool ret = avservice_->CheckStringAndCleanFile(filePath);
|
|
file.close();
|
|
// file not exist for ifstream file can not create file in non-existent folder
|
|
EXPECT_EQ(ret, false);
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
avsessionHere_->Destroy();
|
|
SLOGI("CheckStringAndCleanFile002 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, ReportStartCastEnd001, TestSize.Level0)
|
|
{
|
|
SLOGI("NotifyDeviceAvailable001 begin!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
EXPECT_EQ(avsessionHere_ != nullptr, true);
|
|
std::string func = "";
|
|
int32_t uid = avsessionHere_->GetUid();
|
|
int ret = 1;
|
|
OutputDeviceInfo outputDeviceInfo;
|
|
OHOS::AVSession::DeviceInfo deviceInfo;
|
|
deviceInfo.castCategory_ = 1;
|
|
deviceInfo.deviceId_ = "deviceId";
|
|
avservice_->ReportStartCastEnd(func, outputDeviceInfo, uid, ret);
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
avsessionHere_->Destroy();
|
|
SLOGI("NotifyDeviceAvailable001 end!");
|
|
}
|
|
|
|
#ifdef BLUETOOTH_ENABLE
|
|
static HWTEST_F(AVSessionServiceTest, OnReceiveEvent003, TestSize.Level0)
|
|
{
|
|
SLOGD("OnReceiveEvent003 begin!");
|
|
OHOS::EventFwk::CommonEventData eventData;
|
|
string action = OHOS::EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_LOCKED;
|
|
OHOS::AAFwk::Want want = eventData.GetWant();
|
|
want.SetAction(action);
|
|
eventData.SetWant(want);
|
|
OHOS::EventFwk::MatchingSkills matchingSkills;
|
|
OHOS::EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
|
|
EventSubscriber eventSubscriber(subscriberInfo, avservice_);
|
|
eventSubscriber.OnReceiveEvent(eventData);
|
|
int32_t ret = action.compare(OHOS::EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_LOCKED);
|
|
EXPECT_EQ(ret, 0);
|
|
SLOGD("OnReceiveEvent003 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, UpdateFrontSession004, TestSize.Level0)
|
|
{
|
|
SLOGD("UpdateFrontSession004 begin!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_VOICE_CALL, false, elementName);
|
|
EXPECT_EQ(avsessionHere != nullptr, true);
|
|
avservice_->UpdateTopSession(avsessionHere);
|
|
avservice_->UpdateFrontSession(avsessionHere, false);
|
|
avservice_->HandleSessionRelease(avsessionHere->GetSessionId());
|
|
avsessionHere->Destroy();
|
|
SLOGD("UpdateFrontSession004 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, CheckAncoAudio001, TestSize.Level0)
|
|
{
|
|
SLOGD("CheckAncoAudio001 begin!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_VOICE_CALL, false, elementName);
|
|
bool ret = avservice_->CheckAncoAudio();
|
|
EXPECT_EQ(ret, false);
|
|
avsessionHere->Destroy();
|
|
SLOGD("CheckAncoAudio001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, SendSystemControlCommand002, TestSize.Level0)
|
|
{
|
|
SLOGD("SendSystemControlCommand002 begin!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
avservice_->UpdateTopSession(avsessionHere);
|
|
AVControlCommand command;
|
|
command.SetCommand(1000);
|
|
int32_t ret = avservice_->SendSystemControlCommand(command);
|
|
avservice_->HandleSessionRelease(avsessionHere->GetSessionId());
|
|
avsessionHere->Destroy();
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
SLOGD("SendSystemControlCommand002 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: SendSystemControlCommand003
|
|
* @tc.desc: Verifying the SendSystemControlCommand method with valid parameters.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, SendSystemControlCommand003, TestSize.Level0)
|
|
{
|
|
SLOGI("SendSystemControlCommand003 begin!");
|
|
ASSERT_TRUE(avservice_ != nullptr);
|
|
std::vector<int> tempAudioPlayingUids {1, 2};
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
ASSERT_TRUE(avsessionHere != nullptr);
|
|
tempAudioPlayingUids.push_back(avsessionHere->GetUid());
|
|
avservice_->focusSessionStrategy_.SetAudioPlayingUids(tempAudioPlayingUids);
|
|
|
|
AVControlCommand command;
|
|
command.SetCommand(1000);
|
|
int32_t ret = avservice_->SendSystemControlCommand(command);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
avservice_->HandleSessionRelease(avsessionHere->GetSessionId());
|
|
avsessionHere->Destroy();
|
|
SLOGI("SendSystemControlCommand003 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: SendSystemCommonCommand001
|
|
* @tc.desc: valid command and args
|
|
* @tc.type: FUNC
|
|
* @tc.require: AR000H31JB
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, SendSystemCommonCommand001, TestSize.Level0)
|
|
{
|
|
SLOGD("SendSystemCommonCommand001 begin!");
|
|
ASSERT_TRUE(avservice_ != nullptr);
|
|
avservice_->pcmCastSession_ = std::make_shared<PcmCastSession>();
|
|
std::string commonCommand = "CHANGE_CAST_MODE";
|
|
OHOS::AAFwk::WantParams commandArgs;
|
|
#ifdef CASTPLUS_CAST_ENGINE_ENABLE
|
|
auto result = avservice_->SendSystemCommonCommand(commonCommand, commandArgs);
|
|
EXPECT_EQ(result, AVSESSION_SUCCESS);
|
|
#endif
|
|
SLOGD("SendSystemCommonCommand001 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: SendSystemCommonCommand002
|
|
* @tc.desc: valid cast enable
|
|
* @tc.type: FUNC
|
|
* @tc.require: AR000H31JB
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, SendSystemCommonCommand002, TestSize.Level0)
|
|
{
|
|
SLOGD("SendSystemCommonCommand002 begin!");
|
|
ASSERT_TRUE(avservice_ != nullptr);
|
|
avservice_->pcmCastSession_ = nullptr;
|
|
std::string commonCommand = "CHANGE_CAST_MODE";
|
|
OHOS::AAFwk::WantParams commandArgs;
|
|
#ifdef CASTPLUS_CAST_ENGINE_ENABLE
|
|
auto result = avservice_->SendSystemCommonCommand(commonCommand, commandArgs);
|
|
EXPECT_EQ(result, ERR_SESSION_NOT_EXIST);
|
|
#endif
|
|
|
|
SLOGD("SendSystemCommonCommand002 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: SendSystemCommonCommand003
|
|
* @tc.desc: valid pcm cast session
|
|
* @tc.type: FUNC
|
|
* @tc.require: AR000H31JB
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, SendSystemCommonCommand003, TestSize.Level0)
|
|
{
|
|
SLOGD("SendSystemCommonCommand003 begin!");
|
|
ASSERT_TRUE(avservice_ != nullptr);
|
|
std::string commonCommand = "CHANGE_CAST_MODE";
|
|
OHOS::AAFwk::WantParams commandArgs;
|
|
#ifdef CASTPLUS_CAST_ENGINE_ENABLE
|
|
avservice_->pcmCastSession_ = std::make_shared<PcmCastSession>();
|
|
auto result = avservice_->SendSystemCommonCommand(commonCommand, commandArgs);
|
|
EXPECT_EQ(result, AVSESSION_SUCCESS);
|
|
#endif
|
|
|
|
SLOGD("SendSystemCommonCommand003 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, CreateWantAgent001, TestSize.Level0)
|
|
{
|
|
SLOGD("CreateWantAgent001 begin!");
|
|
auto ret = avservice_->CreateWantAgent(nullptr);
|
|
EXPECT_EQ(ret, nullptr);
|
|
SLOGD("CreateWantAgent001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, CreateWantAgent002, TestSize.Level0)
|
|
{
|
|
SLOGD("CreateWantAgent002 begin!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_PHOTO, false, elementName);
|
|
auto ret = avservice_->CreateWantAgent(avsessionHere);
|
|
EXPECT_EQ(ret, nullptr);
|
|
avsessionHere->Destroy();
|
|
SLOGD("CreateWantAgent002 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, CreateWantAgent003, TestSize.Level0)
|
|
{
|
|
SLOGD("CreateWantAgent003 begin!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
avservice_->UpdateTopSession(avsessionHere);
|
|
auto ret = avservice_->CreateWantAgent(nullptr);
|
|
EXPECT_EQ(ret, nullptr);
|
|
avsessionHere->Destroy();
|
|
SLOGD("CreateWantAgent003 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, CreateWantAgent004, TestSize.Level0)
|
|
{
|
|
SLOGD("CreateWantAgent004 begin!");
|
|
ASSERT_TRUE(avservice_ != nullptr);
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
EXPECT_NE(avsessionHere, nullptr);
|
|
avsessionHere->SetUid(5557);
|
|
avservice_->UpdateTopSession(avsessionHere);
|
|
EXPECT_NE(avservice_->topSession_, nullptr);
|
|
auto wantAgent = avservice_->CreateWantAgent(nullptr);
|
|
EXPECT_EQ(wantAgent, nullptr);
|
|
avsessionHere->Destroy();
|
|
SLOGD("CreateWantAgent004 end!");
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* @tc.name: UpdateOrder001
|
|
* @tc.desc: Verifying the UpdateOrder.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, UpdateOrder001, TestSize.Level1)
|
|
{
|
|
SLOGI("UpdateOrder001 begin!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
bool ret = avservice_->UpdateOrder(avsessionHere_);
|
|
EXPECT_EQ(ret, true);
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
avsessionHere_->Destroy();
|
|
SLOGI("UpdateOrder001 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: UpdateOrder002
|
|
* @tc.desc: Verifying the UpdateOrder.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, UpdateOrder002, TestSize.Level1)
|
|
{
|
|
SLOGI("UpdateOrder002 begin!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
avservice_->UpdateFrontSession(avsessionHere_, true);
|
|
bool ret = avservice_->UpdateOrder(avsessionHere_);
|
|
EXPECT_EQ(ret, true);
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
avsessionHere_->Destroy();
|
|
SLOGI("UpdateOrder002 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: HandleOtherSessionPlaying001
|
|
* @tc.desc: Verifying the HandleOtherSessionPlaying.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, HandleOtherSessionPlaying001, TestSize.Level1)
|
|
{
|
|
SLOGI("HandleOtherSessionPlaying001 begin!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
avservice_->HandleOtherSessionPlaying(avsessionHere_);
|
|
EXPECT_EQ(avsessionHere_ != nullptr, true);
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
avsessionHere_->Destroy();
|
|
SLOGI("HandleOtherSessionPlaying001 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: HandleOtherSessionPlaying002
|
|
* @tc.desc: Verifying the HandleOtherSessionPlaying.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, HandleOtherSessionPlaying002, TestSize.Level1)
|
|
{
|
|
SLOGI("HandleOtherSessionPlaying002 begin!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
int32_t ancoUid = 1041;
|
|
avsessionHere_->SetUid(ancoUid);
|
|
avservice_->HandleOtherSessionPlaying(avsessionHere_);
|
|
bool check = avsessionHere_->GetUid() == ancoUid;
|
|
EXPECT_EQ(check, true);
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
avsessionHere_->Destroy();
|
|
SLOGI("HandleOtherSessionPlaying002 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: HandleOtherSessionPlaying003
|
|
* @tc.desc: Verifying the HandleOtherSessionPlaying.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, HandleOtherSessionPlaying003, TestSize.Level1)
|
|
{
|
|
SLOGI("HandleOtherSessionPlaying003 begin!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_VOICE_CALL, false, elementName);
|
|
avservice_->HandleOtherSessionPlaying(avsessionHere_);
|
|
EXPECT_EQ(avsessionHere_ != nullptr, true);
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
avsessionHere_->Destroy();
|
|
SLOGI("HandleOtherSessionPlaying003 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: GetOtherPlayingSession001
|
|
* @tc.desc: Verifying the GetOtherPlayingSession.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, GetOtherPlayingSession001, TestSize.Level1)
|
|
{
|
|
SLOGI("GetOtherPlayingSession001 begin!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
std::string bundleName = "test";
|
|
int32_t userId = 0;
|
|
bool ret = avservice_->GetOtherPlayingSession(userId, bundleName) == nullptr;
|
|
EXPECT_EQ(ret, true);
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
avsessionHere_->Destroy();
|
|
SLOGI("GetOtherPlayingSession001 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: GetOtherPlayingSession002
|
|
* @tc.desc: Verifying the GetOtherPlayingSession.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, GetOtherPlayingSession002, TestSize.Level1)
|
|
{
|
|
SLOGI("GetOtherPlayingSession002 begin!");
|
|
int32_t userId = 0;
|
|
static char gTestFrontBundleName[] = "testFront.ohos.avsession";
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionFront_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
avservice_->UpdateFrontSession(avsessionFront_, true);
|
|
g_playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_PLAY);
|
|
avsessionFront_->SetAVPlaybackState(g_playbackState);
|
|
bool ret = avservice_->GetOtherPlayingSession(userId, gTestFrontBundleName) == nullptr;
|
|
EXPECT_EQ(ret, true);
|
|
avservice_->HandleSessionRelease(avsessionFront_->GetSessionId());
|
|
avsessionFront_->Destroy();
|
|
SLOGI("GetOtherPlayingSession002 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: GetOtherPlayingSession003
|
|
* @tc.desc: Verifying the GetOtherPlayingSession.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, GetOtherPlayingSession003, TestSize.Level1)
|
|
{
|
|
SLOGI("GetOtherPlayingSession003 begin!");
|
|
int32_t userId = 0;
|
|
static char gTestFrontBundleName[] = "testFront.ohos.avsession";
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionFront_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
avservice_->UpdateFrontSession(avsessionFront_, true);
|
|
g_playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_PLAY);
|
|
avsessionFront_->SetAVPlaybackState(g_playbackState);
|
|
avsessionFront_->castHandle_ = 1;
|
|
bool ret = avservice_->GetOtherPlayingSession(userId, gTestFrontBundleName) == nullptr;
|
|
EXPECT_EQ(ret, true);
|
|
avservice_->HandleSessionRelease(avsessionFront_->GetSessionId());
|
|
avsessionFront_->Destroy();
|
|
SLOGI("GetOtherPlayingSession003 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: GetOtherPlayingSession004
|
|
* @tc.desc: Test GetOtherPlayingSession with 2 sessions,
|
|
* second session casting with PLAYBACK_STATE_PLAY returns the session
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, GetOtherPlayingSession004, TestSize.Level1)
|
|
{
|
|
SLOGI("GetOtherPlayingSession004 begin!");
|
|
int32_t userId = avservice_->GetUsersManager().GetCurrentUserId();
|
|
static char gTestFrontBundleName[] = "testFront.ohos.avsession";
|
|
|
|
// Get front list and create mock sessions directly
|
|
auto sessionListForFront = avservice_->GetUsersManager().GetCurSessionListForFront(userId);
|
|
|
|
// Save original size for cleanup
|
|
size_t originalSize = sessionListForFront->size();
|
|
|
|
// Create first mock session
|
|
AVSessionDescriptor descriptor1;
|
|
descriptor1.sessionTag_ = g_testSessionTag;
|
|
descriptor1.sessionType_ = AVSession::SESSION_TYPE_AUDIO;
|
|
descriptor1.elementName_.SetBundleName(gTestFrontBundleName);
|
|
descriptor1.elementName_.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionFront1_ = new AVSessionItem(descriptor1, userId);
|
|
|
|
// Create second mock session
|
|
AVSessionDescriptor descriptor2;
|
|
descriptor2.sessionTag_ = "tag2";
|
|
descriptor2.sessionType_ = AVSession::SESSION_TYPE_AUDIO;
|
|
descriptor2.elementName_.SetBundleName(g_testAnotherBundleName);
|
|
descriptor2.elementName_.SetAbilityName("testThird.ability");
|
|
OHOS::sptr<AVSessionItem> avsessionFront2_ = new AVSessionItem(descriptor2, userId);
|
|
|
|
// Add sessions to front list
|
|
sessionListForFront->push_back(avsessionFront1_);
|
|
sessionListForFront->push_back(avsessionFront2_);
|
|
|
|
// Set first session to STOP state to ensure it's not considered as playing
|
|
g_playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_STOP);
|
|
avsessionFront1_->SetAVPlaybackState(g_playbackState);
|
|
|
|
// Set second session as casting with PLAYBACK_STATE_PLAY
|
|
avsessionFront2_->castHandle_ = 100;
|
|
g_playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_PLAY);
|
|
avsessionFront2_->SetAVPlaybackState(g_playbackState);
|
|
|
|
#ifdef CASTPLUS_CAST_ENGINE_ENABLE
|
|
// Create mock cast controller proxy and set it to return PLAYBACK_STATE_PLAY
|
|
auto mockProxy = std::make_shared<MockCastControllerProxy>();
|
|
mockProxy->SetCastPlaybackState(AVPlaybackState::PLAYBACK_STATE_PLAY);
|
|
avsessionFront2_->castControllerProxy_ = mockProxy;
|
|
|
|
// Call GetOtherPlayingSession - should return the second session
|
|
auto result = avservice_->GetOtherPlayingSession(userId, gTestFrontBundleName);
|
|
ASSERT_TRUE(result != nullptr) << "GetOtherPlayingSession should return casting session, not nullptr";
|
|
EXPECT_TRUE(result.GetRefPtr() == avsessionFront2_.GetRefPtr())
|
|
<< "Should return the second casting session";
|
|
#endif
|
|
|
|
// Clean up: remove sessions from front list
|
|
while (sessionListForFront->size() > originalSize) {
|
|
sessionListForFront->pop_back();
|
|
}
|
|
|
|
// Clear cast controller proxy before destroy to avoid memory leak
|
|
avsessionFront2_->castControllerProxy_ = nullptr;
|
|
avsessionFront1_->castControllerProxy_ = nullptr;
|
|
|
|
avsessionFront1_->Destroy();
|
|
avsessionFront2_->Destroy();
|
|
|
|
// Verify cleanup was successful
|
|
EXPECT_EQ(sessionListForFront->size(), originalSize);
|
|
|
|
SLOGI("GetOtherPlayingSession004 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: GetOtherPlayingSession005
|
|
* @tc.desc: Test GetOtherPlayingSession with 2 sessions,
|
|
* second session casting with PLAYBACK_STATE_PAUSE returns nullptr
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, GetOtherPlayingSession005, TestSize.Level1)
|
|
{
|
|
SLOGI("GetOtherPlayingSession005 begin!");
|
|
int32_t userId = avservice_->GetUsersManager().GetCurrentUserId();
|
|
static char gTestFrontBundleName[] = "testFront.ohos.avsession";
|
|
|
|
// Get front list and create mock sessions directly
|
|
auto sessionListForFront = avservice_->GetUsersManager().GetCurSessionListForFront(userId);
|
|
|
|
// Save original size for cleanup
|
|
size_t originalSize = sessionListForFront->size();
|
|
|
|
// Create first mock session
|
|
AVSessionDescriptor descriptor1;
|
|
descriptor1.sessionTag_ = g_testSessionTag;
|
|
descriptor1.sessionType_ = AVSession::SESSION_TYPE_AUDIO;
|
|
descriptor1.elementName_.SetBundleName(g_testAnotherBundleName);
|
|
descriptor1.elementName_.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionFront1_ = new AVSessionItem(descriptor1, userId);
|
|
|
|
// Create second mock session
|
|
AVSessionDescriptor descriptor2;
|
|
descriptor2.sessionTag_ = "tag2";
|
|
descriptor2.sessionType_ = AVSession::SESSION_TYPE_AUDIO;
|
|
descriptor2.elementName_.SetBundleName(g_testAnotherBundleName);
|
|
descriptor2.elementName_.SetAbilityName("testThird.ability");
|
|
OHOS::sptr<AVSessionItem> avsessionFront2_ = new AVSessionItem(descriptor2, userId);
|
|
|
|
// Add sessions to front list
|
|
sessionListForFront->push_back(avsessionFront1_);
|
|
sessionListForFront->push_back(avsessionFront2_);
|
|
|
|
// Set first session to STOP state to ensure it's not considered as playing
|
|
g_playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_STOP);
|
|
avsessionFront1_->SetAVPlaybackState(g_playbackState);
|
|
|
|
// Set second session as casting with PLAYBACK_STATE_PAUSE
|
|
avsessionFront2_->castHandle_ = 100;
|
|
g_playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_PAUSE);
|
|
avsessionFront2_->SetAVPlaybackState(g_playbackState);
|
|
|
|
#ifdef CASTPLUS_CAST_ENGINE_ENABLE
|
|
// Create mock cast controller proxy and set it to return PLAYBACK_STATE_PAUSE
|
|
auto mockProxy = std::make_shared<MockCastControllerProxy>();
|
|
mockProxy->SetCastPlaybackState(AVPlaybackState::PLAYBACK_STATE_PAUSE);
|
|
avsessionFront2_->castControllerProxy_ = mockProxy;
|
|
|
|
// Call GetOtherPlayingSession - should return nullptr because cast state is PAUSE, not PLAY
|
|
auto result = avservice_->GetOtherPlayingSession(userId, gTestFrontBundleName);
|
|
EXPECT_TRUE(result == nullptr);
|
|
#endif
|
|
|
|
// Clean up: remove sessions from front list
|
|
while (sessionListForFront->size() > originalSize) {
|
|
sessionListForFront->pop_back();
|
|
}
|
|
|
|
// Clear cast controller proxy before destroy to avoid memory leak
|
|
avsessionFront2_->castControllerProxy_ = nullptr;
|
|
avsessionFront1_->castControllerProxy_ = nullptr;
|
|
|
|
avsessionFront1_->Destroy();
|
|
avsessionFront2_->Destroy();
|
|
|
|
// Verify cleanup was successful
|
|
EXPECT_EQ(sessionListForFront->size(), originalSize);
|
|
|
|
SLOGI("GetOtherPlayingSession005 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: GetOtherPlayingSession006
|
|
* @tc.desc: Test GetOtherPlayingSession with 2 sessions,
|
|
* second session casting with PLAYBACK_STATE_STOP returns nullptr
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, GetOtherPlayingSession006, TestSize.Level1)
|
|
{
|
|
SLOGI("GetOtherPlayingSession006 begin!");
|
|
int32_t userId = avservice_->GetUsersManager().GetCurrentUserId();
|
|
static char gTestFrontBundleName[] = "testFront.ohos.avsession";
|
|
|
|
// Get front list and create mock sessions directly
|
|
auto sessionListForFront = avservice_->GetUsersManager().GetCurSessionListForFront(userId);
|
|
|
|
// Save original size for cleanup
|
|
size_t originalSize = sessionListForFront->size();
|
|
|
|
// Create first mock session
|
|
AVSessionDescriptor descriptor1;
|
|
descriptor1.sessionTag_ = g_testSessionTag;
|
|
descriptor1.sessionType_ = AVSession::SESSION_TYPE_AUDIO;
|
|
descriptor1.elementName_.SetBundleName(g_testAnotherBundleName);
|
|
descriptor1.elementName_.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionFront1_ = new AVSessionItem(descriptor1, userId);
|
|
|
|
// Create second mock session
|
|
AVSessionDescriptor descriptor2;
|
|
descriptor2.sessionTag_ = "tag2";
|
|
descriptor2.sessionType_ = AVSession::SESSION_TYPE_AUDIO;
|
|
descriptor2.elementName_.SetBundleName(g_testAnotherBundleName);
|
|
descriptor2.elementName_.SetAbilityName("testThird.ability");
|
|
OHOS::sptr<AVSessionItem> avsessionFront2_ = new AVSessionItem(descriptor2, userId);
|
|
|
|
// Add sessions to front list
|
|
sessionListForFront->push_back(avsessionFront1_);
|
|
sessionListForFront->push_back(avsessionFront2_);
|
|
|
|
// Set first session to STOP state to ensure it's not considered as playing
|
|
g_playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_STOP);
|
|
avsessionFront1_->SetAVPlaybackState(g_playbackState);
|
|
|
|
// Set second session as casting with PLAYBACK_STATE_STOP
|
|
avsessionFront2_->castHandle_ = 100;
|
|
g_playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_STOP);
|
|
avsessionFront2_->SetAVPlaybackState(g_playbackState);
|
|
|
|
#ifdef CASTPLUS_CAST_ENGINE_ENABLE
|
|
// Create mock cast controller proxy and set it to return PLAYBACK_STATE_STOP
|
|
auto mockProxy = std::make_shared<MockCastControllerProxy>();
|
|
mockProxy->SetCastPlaybackState(AVPlaybackState::PLAYBACK_STATE_STOP);
|
|
avsessionFront2_->castControllerProxy_ = mockProxy;
|
|
|
|
// Call GetOtherPlayingSession - should return nullptr because cast state is STOP, not PLAY
|
|
auto result = avservice_->GetOtherPlayingSession(userId, gTestFrontBundleName);
|
|
EXPECT_TRUE(result == nullptr);
|
|
#endif
|
|
|
|
// Clean up: remove sessions from front list
|
|
while (sessionListForFront->size() > originalSize) {
|
|
sessionListForFront->pop_back();
|
|
}
|
|
|
|
// Clear cast controller proxy before destroy to avoid memory leak
|
|
avsessionFront2_->castControllerProxy_ = nullptr;
|
|
avsessionFront1_->castControllerProxy_ = nullptr;
|
|
|
|
avsessionFront1_->Destroy();
|
|
avsessionFront2_->Destroy();
|
|
|
|
// Verify cleanup was successful
|
|
EXPECT_EQ(sessionListForFront->size(), originalSize);
|
|
|
|
SLOGI("GetOtherPlayingSession006 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: GetOtherPlayingSession007
|
|
* @tc.desc: Test GetOtherPlayingSession with 2 sessions, second session not casting returns nullptr
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, GetOtherPlayingSession007, TestSize.Level1)
|
|
{
|
|
SLOGI("GetOtherPlayingSession007 begin!");
|
|
int32_t userId = avservice_->GetUsersManager().GetCurrentUserId();
|
|
static char gTestFrontBundleName[] = "testFront.ohos.avsession";
|
|
|
|
// Get front list and create mock sessions directly
|
|
auto sessionListForFront = avservice_->GetUsersManager().GetCurSessionListForFront(userId);
|
|
|
|
// Save original size for cleanup
|
|
size_t originalSize = sessionListForFront->size();
|
|
|
|
// Create first mock session
|
|
AVSessionDescriptor descriptor1;
|
|
descriptor1.sessionTag_ = g_testSessionTag;
|
|
descriptor1.sessionType_ = AVSession::SESSION_TYPE_AUDIO;
|
|
descriptor1.elementName_.SetBundleName(g_testAnotherBundleName);
|
|
descriptor1.elementName_.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionFront1_ = new AVSessionItem(descriptor1, userId);
|
|
|
|
// Create second mock session
|
|
AVSessionDescriptor descriptor2;
|
|
descriptor2.sessionTag_ = "tag2";
|
|
descriptor2.sessionType_ = AVSession::SESSION_TYPE_AUDIO;
|
|
descriptor2.elementName_.SetBundleName(g_testAnotherBundleName);
|
|
descriptor2.elementName_.SetAbilityName("testThird.ability");
|
|
OHOS::sptr<AVSessionItem> avsessionFront2_ = new AVSessionItem(descriptor2, userId);
|
|
|
|
// Add sessions to front list
|
|
sessionListForFront->push_back(avsessionFront1_);
|
|
sessionListForFront->push_back(avsessionFront2_);
|
|
|
|
// Set first session to STOP state to ensure it's not considered as playing
|
|
g_playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_STOP);
|
|
avsessionFront1_->SetAVPlaybackState(g_playbackState);
|
|
|
|
// Ensure second session is NOT casting (castHandle_ = 0 by default)
|
|
EXPECT_EQ(avsessionFront2_->castHandle_, 0);
|
|
|
|
// Call GetOtherPlayingSession - should return nullptr because second session is not casting
|
|
auto result = avservice_->GetOtherPlayingSession(userId, gTestFrontBundleName);
|
|
EXPECT_TRUE(result == nullptr);
|
|
|
|
// Clean up: remove sessions from front list
|
|
while (sessionListForFront->size() > originalSize) {
|
|
sessionListForFront->pop_back();
|
|
}
|
|
|
|
// Clear cast controller proxy before destroy to avoid memory leak
|
|
avsessionFront2_->castControllerProxy_ = nullptr;
|
|
avsessionFront1_->castControllerProxy_ = nullptr;
|
|
|
|
avsessionFront1_->Destroy();
|
|
avsessionFront2_->Destroy();
|
|
|
|
// Verify cleanup was successful
|
|
EXPECT_EQ(sessionListForFront->size(), originalSize);
|
|
|
|
SLOGI("GetOtherPlayingSession007 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: OnIdleWithSessions001
|
|
* @tc.desc: Verifying the OnIdle method with a valid idle reason.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, OnIdleWithSessions001, TestSize.Level0)
|
|
{
|
|
SLOGD("OnIdleWithSessions001 begin!");
|
|
const OHOS::SystemAbilityOnDemandReason idleReason(
|
|
OHOS::OnDemandReasonId::INTERFACE_CALL, "INTERFACE_CALL", "TestValue", 12345);
|
|
int32_t result = avservice_->OnIdle(idleReason);
|
|
EXPECT_EQ(result, 0);
|
|
SLOGD("OnIdleWithSessions001 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: CheckAndUpdateAncoMediaSession001
|
|
* @tc.desc: update anco media session without anco uid.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, CheckAndUpdateAncoMediaSession001, TestSize.Level1)
|
|
{
|
|
SLOGD("CheckAndUpdateAncoMediaSession001 begin!");
|
|
EXPECT_TRUE(avservice_ != nullptr);
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
EXPECT_EQ(avsessionHere_ != nullptr, true);
|
|
OHOS::AppExecFwk::ElementName newElementName;
|
|
newElementName.SetBundleName("bundleName");
|
|
newElementName.SetAbilityName("AbilityName");
|
|
avservice_->CheckAndUpdateAncoMediaSession(newElementName);
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
avsessionHere_->Destroy();
|
|
SLOGD("CheckAndUpdateAncoMediaSession001 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: CheckSessionHandleKeyEvent001
|
|
* @tc.desc: check which session handle key event.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, CheckSessionHandleKeyEvent001, TestSize.Level1)
|
|
{
|
|
SLOGD("CheckSessionHandleKeyEvent001 begin!");
|
|
ASSERT_TRUE(avservice_ != nullptr);
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
EXPECT_NE(avsessionHere_, nullptr);
|
|
AVControlCommand cmd;
|
|
cmd.SetCommand(AVControlCommand::SESSION_CMD_PLAY);
|
|
auto keyEvent = OHOS::MMI::KeyEvent::Create();
|
|
ASSERT_NE(keyEvent, nullptr);
|
|
auto ret = avservice_->CheckSessionHandleKeyEvent(true, cmd, *keyEvent, avsessionHere_);
|
|
EXPECT_EQ(ret, true);
|
|
keyEvent->SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_MEDIA_PLAY);
|
|
keyEvent->SetKeyAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
|
|
ret = avservice_->CheckSessionHandleKeyEvent(false, cmd, *keyEvent, avsessionHere_);
|
|
EXPECT_EQ(ret, true);
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
avsessionHere_->Destroy();
|
|
SLOGD("CheckSessionHandleKeyEvent001 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: CheckSessionHandleKeyEvent002
|
|
* @tc.desc: check which session handle key event.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, CheckSessionHandleKeyEvent002, TestSize.Level1)
|
|
{
|
|
SLOGD("CheckSessionHandleKeyEvent002 begin!");
|
|
ASSERT_TRUE(avservice_ != nullptr);
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
EXPECT_NE(avsessionHere_, nullptr);
|
|
FocusSessionStrategy::FocusSessionChangeInfo info;
|
|
info.uid = 1041;
|
|
info.pid = 1041;
|
|
avservice_->HandleFocusSession(info, true);
|
|
AVControlCommand cmd;
|
|
cmd.SetCommand(AVControlCommand::SESSION_CMD_PLAY);
|
|
auto keyEvent = OHOS::MMI::KeyEvent::Create();
|
|
ASSERT_NE(keyEvent, nullptr);
|
|
auto ret = avservice_->CheckSessionHandleKeyEvent(true, cmd, *keyEvent, avsessionHere_);
|
|
EXPECT_EQ(ret, true);
|
|
keyEvent->SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_MEDIA_PLAY);
|
|
keyEvent->SetKeyAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
|
|
ret = avservice_->CheckSessionHandleKeyEvent(false, cmd, *keyEvent, avsessionHere_);
|
|
EXPECT_EQ(ret, true);
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
avsessionHere_->Destroy();
|
|
SLOGD("CheckSessionHandleKeyEvent002 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: UpdateSessionTimestamp001
|
|
* @tc.desc: update timestamp for session item.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, UpdateSessionTimestamp001, TestSize.Level1)
|
|
{
|
|
SLOGD("UpdateSessionTimestamp001 begin!");
|
|
EXPECT_TRUE(avservice_ != nullptr);
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
EXPECT_EQ(avsessionHere_ != nullptr, true);
|
|
avservice_->UpdateSessionTimestamp(avsessionHere_);
|
|
EXPECT_NE(avsessionHere_->GetPlayingTime(), 0);
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
avsessionHere_->Destroy();
|
|
SLOGD("UpdateSessionTimestamp001 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: GetLocalTitle001
|
|
* @tc.desc: get local title.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, GetLocalTitle001, TestSize.Level1)
|
|
{
|
|
SLOGD("GetLocalTitle001 begin!");
|
|
ASSERT_TRUE(avservice_ != nullptr);
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName("com.huawei.hmsapp.music");
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
EXPECT_NE(avsessionHere_, nullptr);
|
|
avservice_->UpdateTopSession(avsessionHere_);
|
|
EXPECT_NE(avservice_->topSession_, nullptr);
|
|
AVMetaData metadata;
|
|
metadata.SetAssetId("mediaId");
|
|
metadata.SetDescription("title;artist");
|
|
avsessionHere_->SetAVMetaData(metadata);
|
|
std::string songName = avservice_->GetLocalTitle();
|
|
EXPECT_TRUE(songName == "" || songName == "title");
|
|
avsessionHere_->Destroy();
|
|
SLOGD("GetLocalTitle001 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: GetLocalTitle002
|
|
* @tc.desc: get local title.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, GetLocalTitle002, TestSize.Level1)
|
|
{
|
|
SLOGD("GetLocalTitle002 begin!");
|
|
ASSERT_TRUE(avservice_ != nullptr);
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
EXPECT_NE(avsessionHere_, nullptr);
|
|
avsessionHere_->SetUid(5557);
|
|
avservice_->UpdateTopSession(avsessionHere_);
|
|
EXPECT_NE(avservice_->topSession_, nullptr);
|
|
AVMetaData metadata;
|
|
metadata.SetAssetId("mediaId");
|
|
metadata.SetTitle("title");
|
|
metadata.SetArtist("title-artist");
|
|
avsessionHere_->SetAVMetaData(metadata);
|
|
std::string songName = avservice_->GetLocalTitle();
|
|
EXPECT_EQ(songName, "title");
|
|
avsessionHere_->Destroy();
|
|
SLOGD("GetLocalTitle002 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, GetSessionDescriptors001, TestSize.Level0)
|
|
{
|
|
SLOGI("GetSessionDescriptors001 begin!");
|
|
std::vector<AVSessionDescriptor> descriptors;
|
|
int ret = avservice_->GetSessionDescriptors(SessionCategory::CATEGORY_ACTIVE, descriptors);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
EXPECT_EQ(descriptors.size(), 0);
|
|
|
|
ret = avservice_->GetSessionDescriptors(SessionCategory::CATEGORY_NOT_ACTIVE, descriptors);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
EXPECT_EQ(descriptors.size(), 0);
|
|
|
|
ret = avservice_->GetSessionDescriptors(SessionCategory::CATEGORY_ALL, descriptors);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
EXPECT_EQ(descriptors.size(), 0);
|
|
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
EXPECT_NE(avsessionHere_, nullptr);
|
|
avsessionHere_->Activate();
|
|
|
|
ret = avservice_->GetSessionDescriptors(SessionCategory::CATEGORY_ACTIVE, descriptors);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
|
|
ret = avservice_->GetSessionDescriptors(SessionCategory::CATEGORY_NOT_ACTIVE, descriptors);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
EXPECT_EQ(descriptors.size() >= 1, true);
|
|
|
|
ret = avservice_->GetSessionDescriptors(SessionCategory::CATEGORY_ALL, descriptors);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
EXPECT_EQ(descriptors.size() >= 1, true);
|
|
avsessionHere_->Destroy();
|
|
SLOGI("GetSessionDescriptors001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, GetSessionDescriptors002, TestSize.Level0)
|
|
{
|
|
SLOGI("GetSessionDescriptors002 begin!");
|
|
std::vector<AVSessionDescriptor> descriptors;
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
EXPECT_NE(avsessionHere_, nullptr);
|
|
|
|
int ret = avservice_->GetSessionDescriptors(SessionCategory::CATEGORY_ACTIVE, descriptors);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
|
|
ret = avservice_->GetSessionDescriptors(SessionCategory::CATEGORY_NOT_ACTIVE, descriptors);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
|
|
ret = avservice_->GetSessionDescriptors(SessionCategory::CATEGORY_ALL, descriptors);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
avsessionHere_->Destroy();
|
|
SLOGI("GetSessionDescriptors002 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, GetSessionDescriptors003, TestSize.Level0)
|
|
{
|
|
SLOGI("GetSessionDescriptors003 begin!");
|
|
std::vector<AVSessionDescriptor> descriptors;
|
|
#ifdef CASTPLUS_CAST_ENGINE_ENABLE
|
|
int32_t ret = avservice_->GetSessionDescriptors(SessionCategory::CATEGORY_HIPLAY, descriptors);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
#endif
|
|
|
|
SLOGI("GetSessionDescriptors003 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: GetSessionDescriptors004
|
|
* @tc.desc: 测试 pcmCastSession_ 非空且 CheckIsCasting() 为真
|
|
* @tc.type: FUNC
|
|
* @tc.require: CASTPLUS_CAST_ENGINE_ENABLE
|
|
*/
|
|
HWTEST_F(AVSessionServiceTest, GetSessionDescriptors004, TestSize.Level0)
|
|
{
|
|
SLOGI("GetSessionDescriptors004 begin!");
|
|
int32_t category = SessionCategory::CATEGORY_HIPLAY;
|
|
ASSERT_TRUE(avservice_ != nullptr);
|
|
avservice_->pcmCastSession_ = std::make_shared<PcmCastSession>();
|
|
DeviceInfo deviceInfo;
|
|
deviceInfo.hiPlayDeviceInfo_.castMode_ = 1;
|
|
avservice_->pcmCastSession_->tempDeviceInfo_ = deviceInfo;
|
|
std::vector<AVSessionDescriptor> descriptors;
|
|
int32_t ret = avservice_->GetSessionDescriptors(category, descriptors);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
SLOGI("GetSessionDescriptors004 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: GetSessionDescriptors005
|
|
* @tc.desc: 测试 pcmCastSession_ 非空且 CheckIsCasting() 为假
|
|
* @tc.type: FUNC
|
|
* @tc.require: CASTPLUS_CAST_ENGINE_ENABLE
|
|
*/
|
|
HWTEST_F(AVSessionServiceTest, GetSessionDescriptors005, TestSize.Level0)
|
|
{
|
|
SLOGI("GetSessionDescriptors005 begin!");
|
|
int32_t category = SessionCategory::CATEGORY_HIPLAY;
|
|
ASSERT_TRUE(avservice_ != nullptr);
|
|
avservice_->pcmCastSession_ = std::make_shared<PcmCastSession>();
|
|
avservice_->pcmCastSession_->castState_ = 0;
|
|
std::vector<AVSessionDescriptor> descriptors;
|
|
int32_t ret = avservice_->GetSessionDescriptors(category, descriptors);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
SLOGI("GetSessionDescriptors005 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: GetSessionDescriptors006
|
|
* @tc.desc: 测试 pcmCastSession_ 为空
|
|
* @tc.type: FUNC
|
|
* @tc.require: CASTPLUS_CAST_ENGINE_ENABLE
|
|
*/
|
|
HWTEST_F(AVSessionServiceTest, GetSessionDescriptors006, TestSize.Level0)
|
|
{
|
|
SLOGI("GetSessionDescriptors006 begin!");
|
|
int32_t category = SessionCategory::CATEGORY_HIPLAY;
|
|
ASSERT_TRUE(avservice_ != nullptr);
|
|
avservice_->pcmCastSession_ = nullptr;
|
|
std::vector<AVSessionDescriptor> descriptors;
|
|
int32_t ret = avservice_->GetSessionDescriptors(category, descriptors);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
SLOGI("GetSessionDescriptors006 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: OnClientDied001
|
|
* @tc.desc: pcmCastSession_ not null GetCastMode()=2
|
|
* @tc.type: FUNC
|
|
* @tc.require: CASTPLUS_CAST_ENGINE_ENABLE
|
|
*/
|
|
HWTEST_F(AVSessionServiceTest, OnClientDied001, TestSize.Level0)
|
|
{
|
|
SLOGI("OnClientDied001 begin!");
|
|
ASSERT_TRUE(avservice_ != nullptr);
|
|
avservice_->pcmCastSession_ = std::make_shared<PcmCastSession>();
|
|
DeviceInfo deviceInfo;
|
|
deviceInfo.hiPlayDeviceInfo_.castMode_ = 2;
|
|
avservice_->pcmCastSession_->tempDeviceInfo_ = deviceInfo;
|
|
avservice_->pcmCastSession_->descriptor_.uid_ = 1;
|
|
pid_t uid = 1;
|
|
pid_t pid = 1;
|
|
avservice_->OnClientDied(pid, uid);
|
|
EXPECT_EQ(0, AVSESSION_SUCCESS);
|
|
SLOGI("OnClientDied001 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: OnClientDied002
|
|
* @tc.desc: pcmCastSession_ not null GetCastMode()=1
|
|
* @tc.type: FUNC
|
|
* @tc.require: CASTPLUS_CAST_ENGINE_ENABLE
|
|
*/
|
|
HWTEST_F(AVSessionServiceTest, OnClientDied002, TestSize.Level0)
|
|
{
|
|
SLOGI("OnClientDied002 begin!");
|
|
ASSERT_TRUE(avservice_ != nullptr);
|
|
avservice_->pcmCastSession_ = std::make_shared<PcmCastSession>();
|
|
DeviceInfo deviceInfo;
|
|
deviceInfo.hiPlayDeviceInfo_.castMode_ = 1;
|
|
avservice_->pcmCastSession_->tempDeviceInfo_ = deviceInfo;
|
|
avservice_->pcmCastSession_->descriptor_.uid_ = 1;
|
|
pid_t uid = 1;
|
|
pid_t pid = 1;
|
|
avservice_->OnClientDied(pid, uid);
|
|
EXPECT_EQ(0, AVSESSION_SUCCESS);
|
|
SLOGI("OnClientDied002 end!");
|
|
}
|
|
|
|
|
|
/**
|
|
* @tc.name: ProcTopSessionPlaying001
|
|
* @tc.desc: Process top session playing.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, ProcTopSessionPlaying001, TestSize.Level1)
|
|
{
|
|
SLOGI("ProcTopSessionPlaying001 begin!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
EXPECT_NE(avsessionHere_, nullptr);
|
|
avservice_->UpdateTopSession(avsessionHere_);
|
|
EXPECT_NE(avservice_->topSession_, nullptr);
|
|
avservice_->ProcTopSessionPlaying(avsessionHere_, false, false);
|
|
EXPECT_EQ(avservice_->hasMediaCapsule_, false);
|
|
avservice_->ProcTopSessionPlaying(avsessionHere_, true, false);
|
|
EXPECT_EQ(avservice_->hasMediaCapsule_, true);
|
|
avsessionHere_->Destroy();
|
|
SLOGI("ProcTopSessionPlaying001 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: CheckIfOtherAudioPlaying001
|
|
* @tc.desc: check if other audio playing.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, CheckIfOtherAudioPlaying001, TestSize.Level1)
|
|
{
|
|
SLOGI("CheckIfOtherAudioPlaying001 begin!");
|
|
ASSERT_TRUE(avservice_ != nullptr);
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner("ancoMediaSession", AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
int oriUid = avsessionHere_->GetUid();
|
|
int oriPid = avsessionHere_->GetPid();
|
|
avsessionHere_->SetUid(1041);
|
|
avsessionHere_->SetPid(1041);
|
|
avservice_->UpdateFrontSession(avsessionHere_, true);
|
|
FocusSessionStrategy::FocusSessionChangeInfo info;
|
|
info.uid = 1041;
|
|
info.pid = 1041;
|
|
avservice_->HandleFocusSession(info, true);
|
|
std::vector<int> audioPlayingUids;
|
|
audioPlayingUids.push_back(1041);
|
|
avservice_->focusSessionStrategy_.SetAudioPlayingUids(audioPlayingUids);
|
|
EXPECT_EQ(avservice_->CheckIfOtherAudioPlaying(), true);
|
|
avsessionHere_->SetUid(oriUid);
|
|
avsessionHere_->SetPid(oriPid);
|
|
avsessionHere_->Destroy();
|
|
SLOGI("CheckIfOtherAudioPlaying001 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: HandleRemoveMediaCardEvent001
|
|
* @tc.desc: Verifying the HandleRemoveMediaCardEvent method with a valid session.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, HandleRemoveMediaCardEvent001, TestSize.Level0)
|
|
{
|
|
SLOGD("HandleRemoveMediaCardEvent001 begin!");
|
|
const int32_t uid = 5557;
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
EXPECT_NE(avsessionHere_, nullptr);
|
|
avservice_->UpdateTopSession(avsessionHere_);
|
|
EXPECT_NE(avservice_->topSession_, nullptr);
|
|
avsessionHere_->SetUid(uid);
|
|
AVPlaybackState playbackState;
|
|
playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_PLAY);
|
|
avservice_->HandleRemoveMediaCardEvent(0, false);
|
|
playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_PAUSE);
|
|
avservice_->HandleRemoveMediaCardEvent(0, false);
|
|
avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
|
|
avsessionHere_->Destroy();
|
|
EXPECT_EQ(avservice_->topSession_, nullptr);
|
|
SLOGD("HandleRemoveMediaCardEvent001 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: HandleRemoveMediaCardEvent002
|
|
* @tc.desc: Verifying the HandleRemoveMediaCardEvent method with a valid session.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, HandleRemoveMediaCardEvent002, TestSize.Level0)
|
|
{
|
|
SLOGD("HandleRemoveMediaCardEvent002 begin!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
avservice_->topSession_ =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
bool ret = avservice_->topSession_->IsCasting();
|
|
avservice_->HandleRemoveMediaCardEvent(0, false);
|
|
EXPECT_EQ(ret, false);
|
|
SLOGD("HandleRemoveMediaCardEvent002 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: HandleRemoveMediaCardEvent003
|
|
* @tc.desc: Verifying the HandleRemoveMediaCardEvent method with a null session.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, HandleRemoveMediaCardEvent003, TestSize.Level0)
|
|
{
|
|
SLOGD("HandleRemoveMediaCardEvent003 begin!");
|
|
avservice_->topSession_ = nullptr;
|
|
avservice_->HandleRemoveMediaCardEvent(0, false);
|
|
EXPECT_EQ(avservice_->topSession_, nullptr);
|
|
SLOGD("HandleRemoveMediaCardEvent003 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: IsTopSessionPlaying001
|
|
* @tc.desc: Verifying the IsTopSessionPlaying method with a null top session.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, IsTopSessionPlaying001, TestSize.Level0)
|
|
{
|
|
SLOGD("IsTopSessionPlaying001 begin!");
|
|
avservice_->topSession_ = nullptr;
|
|
bool ret = avservice_->IsTopSessionPlaying();
|
|
EXPECT_EQ(ret, false);
|
|
SLOGD("IsTopSessionPlaying001 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: IsTopSessionPlaying002
|
|
* @tc.desc: Verifying the IsTopSessionPlaying method with a valid top session.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, IsTopSessionPlaying002, TestSize.Level0)
|
|
{
|
|
SLOGD("IsTopSessionPlaying002 begin!");
|
|
std::shared_ptr<AVSessionDescriptor> histroyDescriptor = std::make_shared<AVSessionDescriptor>();
|
|
avservice_->topSession_ = OHOS::sptr<AVSessionItem>::MakeSptr(*histroyDescriptor);
|
|
EXPECT_NE(avservice_->topSession_, nullptr);
|
|
bool ret = avservice_->IsTopSessionPlaying();
|
|
EXPECT_EQ(ret, false);
|
|
SLOGD("IsTopSessionPlaying002 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: HandleMediaCardStateChangeEvent001
|
|
* @tc.desc: Verifying the HandleMediaCardStateChangeEvent method with "APPEAR" state.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, HandleMediaCardStateChangeEvent001, TestSize.Level0)
|
|
{
|
|
SLOGD("HandleMediaCardStateChangeEvent001 begin!");
|
|
std::string isAppear = "APPEAR";
|
|
avservice_->HandleMediaCardStateChangeEvent(isAppear);
|
|
EXPECT_NE(avservice_->topSession_, nullptr);
|
|
SLOGD("HandleMediaCardStateChangeEvent001 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: HandleMediaCardStateChangeEvent002
|
|
* @tc.desc: Verifying the HandleMediaCardStateChangeEvent method with "DISAPPEAR" state.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, HandleMediaCardStateChangeEvent002, TestSize.Level0)
|
|
{
|
|
SLOGD("HandleMediaCardStateChangeEvent002 begin!");
|
|
std::string isAppear = "DISAPPEAR";
|
|
avservice_->HandleMediaCardStateChangeEvent(isAppear);
|
|
EXPECT_NE(avservice_->topSession_, nullptr);
|
|
SLOGD("HandleMediaCardStateChangeEvent002 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: HandleMediaCardStateChangeEvent003
|
|
* @tc.desc: Verifying the HandleMediaCardStateChangeEvent method with an invalid state.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, HandleMediaCardStateChangeEvent003, TestSize.Level0)
|
|
{
|
|
SLOGD("HandleMediaCardStateChangeEvent003 begin!");
|
|
std::string isAppear = "ISDISAPPEAR";
|
|
avservice_->HandleMediaCardStateChangeEvent(isAppear);
|
|
EXPECT_NE(avservice_->topSession_, nullptr);
|
|
SLOGD("HandleMediaCardStateChangeEvent003 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: OnAddSystemAbility001
|
|
* @tc.desc: Verifying the OnAddSystemAbility method with valid system ability ID and device ID.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, OnAddSystemAbility001, TestSize.Level0)
|
|
{
|
|
SLOGD("OnAddSystemAbility001 begin!");
|
|
int32_t systemAbilityId = OHOS::XPOWER_MANAGER_SYSTEM_ABILITY_ID;
|
|
const std::string deviceId = "AUDIO";
|
|
avservice_->OnAddSystemAbility(systemAbilityId, deviceId);
|
|
EXPECT_NE(avservice_->topSession_, nullptr);
|
|
SLOGD("OnAddSystemAbility001 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: UpdateTopSession001
|
|
* @tc.desc: Verifying the UpdateTopSession method with a valid new top session.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, UpdateTopSession001, TestSize.Level0)
|
|
{
|
|
SLOGD("UpdateTopSession001 begin!");
|
|
std::shared_ptr<AVSessionDescriptor> histroyDescriptor = std::make_shared<AVSessionDescriptor>();
|
|
const OHOS::sptr<AVSessionItem> newTopSession = OHOS::sptr<AVSessionItem>::MakeSptr(*histroyDescriptor);
|
|
avservice_->UpdateTopSession(newTopSession);
|
|
EXPECT_NE(avservice_->topSession_, nullptr);
|
|
SLOGD("UpdateTopSession001 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: LowQualityCheck001
|
|
* @tc.desc: Verifying the LowQualityCheck method with valid parameters.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, LowQualityCheck001, TestSize.Level0)
|
|
{
|
|
SLOGD("LowQualityCheck001 begin!");
|
|
int32_t uid = g_playOnCall;
|
|
int32_t pid = g_pauseOnCall;
|
|
StreamUsage streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
|
|
RendererState rendererState = RendererState::RENDERER_PAUSED;
|
|
avservice_->LowQualityCheck(uid, pid, streamUsage, rendererState);
|
|
EXPECT_NE(avservice_->topSession_, nullptr);
|
|
SLOGD("LowQualityCheck001 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: PlayStateCheck001
|
|
* @tc.desc: Verifying the PlayStateCheck method with valid parameters.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, PlayStateCheck001, TestSize.Level0)
|
|
{
|
|
SLOGD("PlayStateCheck001 begin!");
|
|
int32_t uid = AVSESSION_ERROR_BASE;
|
|
StreamUsage streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
|
|
RendererState rendererState = RendererState::RENDERER_PAUSED;
|
|
avservice_->PlayStateCheck(uid, streamUsage, rendererState);
|
|
EXPECT_NE(avservice_->topSession_, nullptr);
|
|
SLOGD("PlayStateCheck001 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: NotifyBackgroundReportCheck001
|
|
* @tc.desc: Verifying NotifyBackgroundReportCheck with RENDERER_RUNNING state.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, NotifyBackgroundReportCheck001, TestSize.Level0)
|
|
{
|
|
SLOGD("NotifyBackgroundReportCheck001 begin!");
|
|
int32_t uid = g_playOnCall;
|
|
int32_t pid = g_pauseOnCall;
|
|
StreamUsage streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
|
|
RendererState rendererState = RendererState::RENDERER_RUNNING;
|
|
avservice_->NotifyBackgroundReportCheck(uid, pid, streamUsage, rendererState);
|
|
EXPECT_NE(avservice_->topSession_, nullptr);
|
|
SLOGD("NotifyBackgroundReportCheck001 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: NotifyBackgroundReportCheck002
|
|
* @tc.desc: Verifying NotifyBackgroundReportCheck with RENDERER_PAUSED state.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, NotifyBackgroundReportCheck002, TestSize.Level0)
|
|
{
|
|
SLOGD("NotifyBackgroundReportCheck002 begin!");
|
|
int32_t uid = g_playOnCall;
|
|
int32_t pid = g_pauseOnCall;
|
|
StreamUsage streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
|
|
RendererState rendererState = RendererState::RENDERER_PAUSED;
|
|
avservice_->NotifyBackgroundReportCheck(uid, pid, streamUsage, rendererState);
|
|
EXPECT_NE(avservice_->topSession_, nullptr);
|
|
SLOGD("NotifyBackgroundReportCheck002 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: ServiceCallback001
|
|
* @tc.desc: Verifying ServiceCallback with a null session item.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, ServiceCallback001, TestSize.Level0)
|
|
{
|
|
SLOGD("ServiceCallback001 begin!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
auto sessionItem =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
EXPECT_EQ(sessionItem, nullptr);
|
|
avservice_->ServiceCallback(sessionItem);
|
|
SLOGD("ServiceCallback001 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: IsParamInvalid001
|
|
* @tc.desc: Verifying IsParamInvalid with an empty tag.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, IsParamInvalid001, TestSize.Level0)
|
|
{
|
|
SLOGD("IsParamInvalid001 begin!");
|
|
std::string tag = "";
|
|
int32_t type = AVSession::SESSION_TYPE_AUDIO;
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
bool result = avservice_->IsParamInvalid(tag, type, elementName);
|
|
EXPECT_FALSE(result);
|
|
SLOGD("IsParamInvalid001 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: IsParamInvalid002
|
|
* @tc.desc: Verifying IsParamInvalid with an invalid session type.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, IsParamInvalid002, TestSize.Level0)
|
|
{
|
|
SLOGD("IsParamInvalid002 begin!");
|
|
std::string tag = "testTag";
|
|
int32_t type = AVSession::SESSION_TYPE_INVALID;
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName("com.example.bundle");
|
|
elementName.SetAbilityName("com.example.ability");
|
|
bool result = avservice_->IsParamInvalid(tag, type, elementName);
|
|
EXPECT_FALSE(result);
|
|
SLOGD("IsParamInvalid002 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: IsParamInvalid003
|
|
* @tc.desc: Verifying IsParamInvalid with an empty bundle name.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, IsParamInvalid003, TestSize.Level0)
|
|
{
|
|
SLOGD("IsParamInvalid003 begin!");
|
|
std::string tag = "testTag";
|
|
int32_t type = AVSession::SESSION_TYPE_AUDIO;
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName("");
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
bool result = avservice_->IsParamInvalid(tag, type, elementName);
|
|
EXPECT_FALSE(result);
|
|
SLOGD("IsParamInvalid003 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: IsParamInvalid004
|
|
* @tc.desc: Verifying IsParamInvalid with an empty ability name.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, IsParamInvalid004, TestSize.Level0)
|
|
{
|
|
SLOGD("IsParamInvalid004 begin!");
|
|
std::string tag = "testTag";
|
|
int32_t type = AVSession::SESSION_TYPE_AUDIO;
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName("");
|
|
bool result = avservice_->IsParamInvalid(tag, type, elementName);
|
|
EXPECT_FALSE(result);
|
|
SLOGD("IsParamInvalid004 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: IsLocalDevice001
|
|
* @tc.desc: Verifying IsLocalDevice with a valid local network ID.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, IsLocalDevice001, TestSize.Level0)
|
|
{
|
|
SLOGD("IsLocalDevice001 begin!");
|
|
const std::string networkId = "LocalDevice";
|
|
bool result = avservice_->IsLocalDevice(networkId);
|
|
EXPECT_TRUE(result);
|
|
SLOGD("IsLocalDevice001 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: GetDeviceInfo002
|
|
* @tc.desc: Verifying GetDeviceInfo with a valid session item and descriptors.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, GetDeviceInfo002, TestSize.Level0)
|
|
{
|
|
SLOGI("GetDeviceInfo002 begin!");
|
|
std::shared_ptr<AVSessionDescriptor> histroyDescriptor = std::make_shared<AVSessionDescriptor>();
|
|
auto avsessionHere = OHOS::sptr<AVSessionItem>::MakeSptr(*histroyDescriptor);
|
|
std::vector<OHOS::AudioStandard::AudioDeviceDescriptor> descriptors = {
|
|
OHOS::AudioStandard::AudioDeviceDescriptor(OHOS::AudioStandard::DeviceType::DEVICE_TYPE_EARPIECE,
|
|
OHOS::AudioStandard::DeviceRole::INPUT_DEVICE, 1, 1, "LocalDevice")
|
|
};
|
|
avservice_->SetDeviceInfo(descriptors, avsessionHere);
|
|
avservice_->GetDeviceInfo(avsessionHere, descriptors, descriptors, descriptors);
|
|
EXPECT_NE(avsessionHere, nullptr);
|
|
SLOGI("GetDeviceInfo002 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: CastAudioProcess001
|
|
* @tc.desc: Verifying CastAudioProcess with a valid session item and descriptors.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, CastAudioProcess001, TestSize.Level0)
|
|
{
|
|
SLOGI("CastAudioProcess001 begin!");
|
|
EXPECT_TRUE(avservice_ != nullptr);
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_VOICE_CALL, false, elementName);
|
|
std::vector<OHOS::AudioStandard::AudioDeviceDescriptor> descriptors;
|
|
avservice_->GetDeviceInfo(avsessionHere, descriptors, descriptors, descriptors);
|
|
const std::string sourceSessionInfo = "123443";
|
|
auto ret = avservice_->CastAudioProcess(descriptors, sourceSessionInfo, avsessionHere);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
SLOGI("CastAudioProcess001 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: CastAudioProcess002
|
|
* @tc.desc: Verifying CastAudioProcess with a valid session item and descriptors.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, CastAudioProcess002, TestSize.Level0)
|
|
{
|
|
SLOGI("CastAudioProcess002 begin!");
|
|
std::shared_ptr<AVSessionDescriptor> histroyDescriptor = std::make_shared<AVSessionDescriptor>();
|
|
auto avsessionHere = OHOS::sptr<AVSessionItem>::MakeSptr(*histroyDescriptor);
|
|
std::vector<OHOS::AudioStandard::AudioDeviceDescriptor> descriptors = {
|
|
OHOS::AudioStandard::AudioDeviceDescriptor(OHOS::AudioStandard::DeviceType::DEVICE_TYPE_EARPIECE,
|
|
OHOS::AudioStandard::DeviceRole::INPUT_DEVICE, 1, 1, "LocalDevice")
|
|
};
|
|
avservice_->SetDeviceInfo(descriptors, avsessionHere);
|
|
avservice_->GetDeviceInfo(avsessionHere, descriptors, descriptors, descriptors);
|
|
EXPECT_NE(avsessionHere, nullptr);
|
|
const std::string sourceSessionInfo = "123443";
|
|
auto ret = avservice_->CastAudioProcess(descriptors, sourceSessionInfo, avsessionHere);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
SLOGI("CastAudioProcess002 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: CastAudioInner001
|
|
* @tc.desc: Verifying CastAudioInner with a valid session item and descriptors.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, CastAudioInner001, TestSize.Level0)
|
|
{
|
|
SLOGI("CastAudioInner001 begin!");
|
|
EXPECT_TRUE(avservice_ != nullptr);
|
|
std::shared_ptr<AVSessionDescriptor> histroyDescriptor = std::make_shared<AVSessionDescriptor>();
|
|
auto avsessionHere = OHOS::sptr<AVSessionItem>::MakeSptr(*histroyDescriptor);
|
|
std::vector<OHOS::AudioStandard::AudioDeviceDescriptor> descriptors = {
|
|
OHOS::AudioStandard::AudioDeviceDescriptor(OHOS::AudioStandard::DeviceType::DEVICE_TYPE_EARPIECE,
|
|
OHOS::AudioStandard::DeviceRole::INPUT_DEVICE, 1, 1, "LocalDevice")
|
|
};
|
|
const std::string sourceSessionInfo = "123443";
|
|
auto ret = avservice_->CastAudioInner(descriptors, sourceSessionInfo, avsessionHere);
|
|
EXPECT_EQ(ret, AVSESSION_ERROR);
|
|
SLOGI("CastAudioInner001 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: CancelCastAudioInner001
|
|
* @tc.desc: Verifying CancelCastAudioInner with a valid session item and descriptors.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, CancelCastAudioInner001, TestSize.Level0)
|
|
{
|
|
SLOGI("CancelCastAudioInner001 begin!");
|
|
EXPECT_TRUE(avservice_ != nullptr);
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionHere =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_VOICE_CALL, false, elementName);
|
|
std::vector<OHOS::AudioStandard::AudioDeviceDescriptor> descriptors = {
|
|
OHOS::AudioStandard::AudioDeviceDescriptor(OHOS::AudioStandard::DeviceType::DEVICE_TYPE_EARPIECE,
|
|
OHOS::AudioStandard::DeviceRole::INPUT_DEVICE, 1, 1, "LocalDevice")
|
|
};
|
|
const std::string sourceSessionInfo = "123443";
|
|
auto ret = avservice_->CancelCastAudioInner(descriptors, sourceSessionInfo, avsessionHere);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
SLOGI("CancelCastAudioInner001 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: CastAudioForAll001
|
|
* @tc.desc: Verifying CastAudioForAll with valid descriptors.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, CastAudioForAll001, TestSize.Level0)
|
|
{
|
|
SLOGI("CastAudioForAll001 begin!");
|
|
EXPECT_TRUE(avservice_ != nullptr);
|
|
std::vector<OHOS::AudioStandard::AudioDeviceDescriptor> descriptors = {
|
|
OHOS::AudioStandard::AudioDeviceDescriptor(OHOS::AudioStandard::DeviceType::DEVICE_TYPE_EARPIECE,
|
|
OHOS::AudioStandard::DeviceRole::INPUT_DEVICE, 1, 1, "LocalDevice")
|
|
};
|
|
auto ret = avservice_->CastAudioForAll(descriptors);
|
|
EXPECT_EQ(ret, AVSESSION_ERROR);
|
|
SLOGI("CastAudioForAll001 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: ClearControllerForClientDiedNoLock002
|
|
* @tc.desc: Verifying ClearControllerForClientDiedNoLock with a valid PID.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, ClearControllerForClientDiedNoLock002, TestSize.Level0)
|
|
{
|
|
SLOGI("ClearControllerForClientDiedNoLock002 begin!");
|
|
EXPECT_TRUE(avservice_ != nullptr);
|
|
pid_t pid = 1234;
|
|
avservice_->ClearControllerForClientDiedNoLock(pid);
|
|
EXPECT_TRUE(avservice_ != nullptr);
|
|
SLOGI("ClearControllerForClientDiedNoLock002 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: CheckAndCreateDir001
|
|
* @tc.desc: Verifying CheckAndCreateDir with a valid file path.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, CheckAndCreateDir001, TestSize.Level0)
|
|
{
|
|
SLOGI("CheckAndCreateDir001 begin!");
|
|
EXPECT_TRUE(avservice_ != nullptr);
|
|
const string filePath = "/data/path";
|
|
bool ret = avservice_->CheckAndCreateDir(filePath);
|
|
EXPECT_TRUE(ret);
|
|
SLOGI("CheckAndCreateDir001 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: SaveStringToFileEx001
|
|
* @tc.desc: Verifying SaveStringToFileEx with a valid file path and content.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, SaveStringToFileEx001, TestSize.Level0)
|
|
{
|
|
SLOGI("SaveStringToFileEx001 begin!");
|
|
std::string filePath = "uripath";
|
|
std::string content = "123456";
|
|
bool ret = avservice_->SaveStringToFileEx(filePath, content);
|
|
EXPECT_EQ(ret, true);
|
|
SLOGI("SaveStringToFileEx001 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: SaveStringToFileEx002
|
|
* @tc.desc: Verifying SaveStringToFileEx with an empty content.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, SaveStringToFileEx002, TestSize.Level0)
|
|
{
|
|
SLOGI("SaveStringToFileEx002 begin!");
|
|
OHOS::AppExecFwk::ElementName elementName;
|
|
elementName.SetBundleName(g_testAnotherBundleName);
|
|
elementName.SetAbilityName(g_testAnotherAbilityName);
|
|
OHOS::sptr<AVSessionItem> avsessionItem =
|
|
avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
|
|
|
|
std::string filePath = avservice_->GetAVSortDir();
|
|
std::string content = "";
|
|
bool ret = avservice_->SaveStringToFileEx(filePath, content);
|
|
EXPECT_EQ(ret, false);
|
|
SLOGI("SaveStringToFileEx002 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: RemoveExpired001
|
|
* @tc.desc: Verifying RemoveExpired with an expired time point.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, RemoveExpired001, TestSize.Level0)
|
|
{
|
|
SLOGD("RemoveExpired001 begin!");
|
|
std::list<std::chrono::system_clock::time_point> timeList;
|
|
auto now = std::chrono::system_clock::now();
|
|
int32_t timeThreshold = 5;
|
|
timeList.push_back(now - std::chrono::seconds(10));
|
|
avservice_->RemoveExpired(timeList, now, timeThreshold);
|
|
|
|
EXPECT_TRUE(timeList.empty());
|
|
SLOGD("RemoveExpired001 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: RemoveExpired002
|
|
* @tc.desc: Verifying RemoveExpired with a non-expired time point.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, RemoveExpired002, TestSize.Level0)
|
|
{
|
|
SLOGD("RemoveExpired002 begin!");
|
|
std::list<std::chrono::system_clock::time_point> timeList;
|
|
auto now = std::chrono::system_clock::now();
|
|
int32_t timeThreshold = 5;
|
|
timeList.push_back(now - std::chrono::seconds(3));
|
|
|
|
avservice_->RemoveExpired(timeList, now, timeThreshold);
|
|
EXPECT_EQ(timeList.size(), 1);
|
|
SLOGD("RemoveExpired002 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: RemoveExpired003
|
|
* @tc.desc: Verifying RemoveExpired with an empty time list.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, RemoveExpired003, TestSize.Level0)
|
|
{
|
|
SLOGD("RemoveExpired003 begin!");
|
|
std::list<std::chrono::system_clock::time_point> timeList;
|
|
auto now = std::chrono::system_clock::now();
|
|
int32_t timeThreshold = 5;
|
|
avservice_->RemoveExpired(timeList, now, timeThreshold);
|
|
EXPECT_TRUE(timeList.empty());
|
|
SLOGD("RemoveExpired003 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: NotifyFlowControl001
|
|
* @tc.desc: Verifying NotifyFlowControl with a full flow control list.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, NotifyFlowControl001, TestSize.Level0)
|
|
{
|
|
SLOGD("NotifyFlowControl001 begin!");
|
|
avservice_->flowControlPublishTimestampList_.clear();
|
|
const size_t count = 3;
|
|
for (size_t i = 0; i < count; ++i) {
|
|
avservice_->flowControlPublishTimestampList_.push_back(std::chrono::system_clock::now());
|
|
}
|
|
bool result = avservice_->NotifyFlowControl();
|
|
EXPECT_TRUE(result);
|
|
EXPECT_EQ(avservice_->flowControlPublishTimestampList_.size(), count);
|
|
SLOGD("NotifyFlowControl001 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: NotifyFlowControl002
|
|
* @tc.desc: Verifying NotifyFlowControl with a non-full flow control list.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, NotifyFlowControl002, TestSize.Level0)
|
|
{
|
|
SLOGD("NotifyFlowControl002 begin!");
|
|
const size_t count = 3;
|
|
avservice_->flowControlPublishTimestampList_.clear();
|
|
for (size_t i = 0; i < count - 1; ++i) {
|
|
avservice_->flowControlPublishTimestampList_.push_back(std::chrono::system_clock::now());
|
|
}
|
|
bool result = avservice_->NotifyFlowControl();
|
|
EXPECT_FALSE(result);
|
|
SLOGD("NotifyFlowControl002 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: NotifyRemoteDistributedSessionControllersChanged001
|
|
* @tc.desc: Verifying NotifyRemoteDistributedSessionControllersChanged with a valid session controller.
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, NotifyRemoteDistributedSessionControllersChanged001, TestSize.Level0)
|
|
{
|
|
SLOGD("NotifyRemoteDistributedSessionControllersChanged001 begin!");
|
|
std::vector<OHOS::sptr<IRemoteObject>> sessionControllers;
|
|
avservice_->NotifyRemoteDistributedSessionControllersChanged(sessionControllers);
|
|
OHOS::sptr<OHOS::ISystemAbilityManager> mgr =
|
|
OHOS::SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
|
|
EXPECT_TRUE(mgr != nullptr);
|
|
OHOS::sptr<IRemoteObject> obj = mgr->GetSystemAbility(OHOS::AVSESSION_SERVICE_ID);
|
|
sessionControllers.push_back(obj);
|
|
avservice_->NotifyRemoteDistributedSessionControllersChanged(sessionControllers);
|
|
EXPECT_TRUE(avservice_ != nullptr);
|
|
SLOGD("NotifyRemoteDistributedSessionControllersChanged001 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: SuperLauncher001
|
|
* @tc.desc: Verifying SuperLauncher with init state
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, SuperLauncher001, TestSize.Level0)
|
|
{
|
|
SLOGD("SuperLauncher001 begin!");
|
|
avservice_->SuperLauncher("adcdef", "SuperLauncher-Dual", R"({"mRoleType":"source"})", "CONNECT_SUCC");
|
|
EXPECT_EQ(avservice_->migrateAVSession_->supportCrossMediaPlay_, false);
|
|
SLOGD("SuperLauncher001 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: ReleaseSuperLauncher001
|
|
* @tc.desc: Verifying ReleaseSuperLauncher with SupportCrossMediaPlay state
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, ReleaseSuperLauncher001, TestSize.Level0)
|
|
{
|
|
SLOGD("ReleaseSuperLauncher001 begin!");
|
|
avservice_->ReleaseSuperLauncher("SuperLauncher-Dual");
|
|
EXPECT_EQ(avservice_->migrateAVSession_->supportCrossMediaPlay_, false);
|
|
SLOGD("ReleaseSuperLauncher001 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: ConnectSuperLauncher001
|
|
* @tc.desc: Verifying ConnectSuperLauncher001 with init state
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, ConnectSuperLauncher001, TestSize.Level0)
|
|
{
|
|
SLOGD("ConnectSuperLauncher001 begin!");
|
|
avservice_->ConnectSuperLauncher("adcdef", "SuperLauncher-Dual");
|
|
EXPECT_NE(avservice_->migrateAVSession_->servicePtr_, nullptr);
|
|
SLOGD("ConnectSuperLauncher001 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: SucceedSuperLauncher001
|
|
* @tc.desc: Verifying SucceedSuperLauncher001 with init state
|
|
* @tc.type: FUNC
|
|
* @tc.require: #I5Y4MZ
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, SucceedSuperLauncher001, TestSize.Level0)
|
|
{
|
|
SLOGD("SucceedSuperLauncher001 begin!");
|
|
avservice_->SucceedSuperLauncher("adcdef", "SuperLauncher-Dual");
|
|
EXPECT_EQ(avservice_->migrateAVSession_->supportCrossMediaPlay_, false);
|
|
SLOGD("SucceedSuperLauncher001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, IsCapsuleNeeded001, TestSize.Level0)
|
|
{
|
|
SLOGD("IsCapsuleNeeded001 begin!");
|
|
avservice_->topSession_ = nullptr;
|
|
bool result = avservice_->IsCapsuleNeeded();
|
|
EXPECT_EQ(result, false);
|
|
SLOGD("IsCapsuleNeeded001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, SetForwardTime001, TestSize.Level0)
|
|
{
|
|
SLOGD("SetForwardTime001 begin!");
|
|
int64_t test = -1;
|
|
auto avcommand_ = std::make_shared<AVControlCommand>();
|
|
int32_t ret = avcommand_->SetForwardTime(test);
|
|
EXPECT_EQ(ret, ERR_INVALID_PARAM);
|
|
SLOGD("SetForwardTime001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, SetRewindTime001, TestSize.Level0)
|
|
{
|
|
SLOGD("SetRewindTime001 begin!");
|
|
auto avcommand_ = std::make_shared<AVControlCommand>();
|
|
int64_t test = -1;
|
|
int32_t ret = avcommand_->SetRewindTime(test);
|
|
EXPECT_EQ(ret, ERR_INVALID_PARAM);
|
|
SLOGD("SetRewindTime001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, SetSeekTime001, TestSize.Level0)
|
|
{
|
|
SLOGD("SetSeekTime001 begin!");
|
|
auto avcommand_ = std::make_shared<AVControlCommand>();
|
|
int64_t test = -1;
|
|
int32_t ret = avcommand_->SetSeekTime(test);
|
|
EXPECT_EQ(ret, ERR_INVALID_PARAM);
|
|
SLOGD("SetSeekTime001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, SetPlayWithAssetId001, TestSize.Level0)
|
|
{
|
|
SLOGD("SetPlayWithAssetId001 begin!");
|
|
std::string test = "";
|
|
auto avcommand_ = std::make_shared<AVControlCommand>();
|
|
int32_t ret = avcommand_->SetPlayWithAssetId(test);
|
|
EXPECT_EQ(ret, ERR_INVALID_PARAM);
|
|
SLOGD("SetPlayWithAssetId001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, PlayParam001, TestSize.Level0)
|
|
{
|
|
SLOGD("PlayParam001 begin!");
|
|
std::string paramIn = "test";
|
|
AVControlCommand cmd;
|
|
int32_t ret = cmd.SetPlayParam(paramIn);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
std::string paramOut;
|
|
ret = cmd.GetPlayParam(paramOut);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
EXPECT_EQ(paramIn, paramOut);
|
|
SLOGD("PlayParam001 end!");
|
|
}
|
|
|
|
static HWTEST_F(AVSessionServiceTest, UpdateNtfEnable001, TestSize.Level0)
|
|
{
|
|
SLOGD("UpdateNtfEnable001 begin!");
|
|
avservice_->UpdateNtfEnable(false);
|
|
EXPECT_EQ(avservice_->isNtfEnabled_, false);
|
|
avservice_->UpdateNtfEnable(true);
|
|
EXPECT_EQ(avservice_->isNtfEnabled_, true);
|
|
SLOGD("UpdateNtfEnable001 end!");
|
|
}
|
|
|
|
#ifdef CAR_FEATURE_ENABLE
|
|
/**
|
|
* @tc.name: InitAudioZoneCallback001
|
|
* @tc.desc: Test InitAudioZoneCallback and DeinitAudioZoneCallback
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, InitAudioZoneCallback001, TestSize.Level0)
|
|
{
|
|
SLOGD("InitAudioZoneCallback001 begin!");
|
|
avservice_->InitAudioZoneCallback();
|
|
EXPECT_NE(avservice_->audioZoneCallback_, nullptr);
|
|
EXPECT_NE(avservice_->audioZoneChangeCallback_, nullptr);
|
|
|
|
avservice_->DeinitAudioZoneCallback();
|
|
EXPECT_EQ(avservice_->audioZoneCallback_, nullptr);
|
|
EXPECT_EQ(avservice_->audioZoneChangeCallback_, nullptr);
|
|
SLOGD("InitAudioZoneCallback001 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: InitAudioZoneCallback002
|
|
* @tc.desc: Test InitAudioZoneCallback called multiple times
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, InitAudioZoneCallback002, TestSize.Level0)
|
|
{
|
|
SLOGD("InitAudioZoneCallback002 begin!");
|
|
avservice_->InitAudioZoneCallback();
|
|
EXPECT_NE(avservice_->audioZoneCallback_, nullptr);
|
|
EXPECT_NE(avservice_->audioZoneChangeCallback_, nullptr);
|
|
|
|
avservice_->InitAudioZoneCallback();
|
|
EXPECT_NE(avservice_->audioZoneCallback_, nullptr);
|
|
EXPECT_NE(avservice_->audioZoneChangeCallback_, nullptr);
|
|
|
|
avservice_->DeinitAudioZoneCallback();
|
|
SLOGD("InitAudioZoneCallback002 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: GetSessionDescriptorsForAudioZone001
|
|
* @tc.desc: Test GetSessionDescriptorsForAudioZone with valid userId
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, GetSessionDescriptorsForAudioZone001, TestSize.Level0)
|
|
{
|
|
SLOGD("GetSessionDescriptorsForAudioZone001 begin!");
|
|
int32_t userId = 100;
|
|
std::vector<AVSessionDescriptor> descriptors;
|
|
|
|
int32_t ret = avservice_->GetSessionDescriptorsForAudioZone(userId, descriptors);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
SLOGD("GetSessionDescriptorsForAudioZone001 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: GetSessionDescriptorsForAudioZone002
|
|
* @tc.desc: Test GetSessionDescriptorsForAudioZone with invalid userId
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, GetSessionDescriptorsForAudioZone002, TestSize.Level0)
|
|
{
|
|
SLOGD("GetSessionDescriptorsForAudioZone002 begin!");
|
|
int32_t userId = -1;
|
|
std::vector<AVSessionDescriptor> descriptors;
|
|
|
|
int32_t ret = avservice_->GetSessionDescriptorsForAudioZone(userId, descriptors);
|
|
EXPECT_EQ(ret, AVSESSION_ERROR);
|
|
SLOGD("GetSessionDescriptorsForAudioZone002 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: RegisterSessionListenerForUser001
|
|
* @tc.desc: Test RegisterSessionListenerForUser with valid userId
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, RegisterSessionListenerForUser001, TestSize.Level0)
|
|
{
|
|
SLOGD("RegisterSessionListenerForUser001 begin!");
|
|
int32_t userId = 100;
|
|
OHOS::sptr<ISessionListener> listener = new ISessionListenerMock();
|
|
|
|
int32_t ret = avservice_->RegisterSessionListenerForUser(userId, listener);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
SLOGD("RegisterSessionListenerForUser001 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: RegisterSessionListenerForUser002
|
|
* @tc.desc: Test RegisterSessionListenerForUser with invalid userId
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, RegisterSessionListenerForUser002, TestSize.Level0)
|
|
{
|
|
SLOGD("RegisterSessionListenerForUser002 begin!");
|
|
int32_t userId = 0;
|
|
OHOS::sptr<ISessionListener> listener = new ISessionListenerMock();
|
|
|
|
int32_t ret = avservice_->RegisterSessionListenerForUser(userId, listener);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
SLOGD("RegisterSessionListenerForUser002 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: RegisterSessionListenerForUser003
|
|
* @tc.desc: Test RegisterSessionListenerForUser with nullptr listener
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, RegisterSessionListenerForUser003, TestSize.Level0)
|
|
{
|
|
SLOGD("RegisterSessionListenerForUser003 begin!");
|
|
int32_t userId = 100;
|
|
OHOS::sptr<ISessionListener> listener = nullptr;
|
|
|
|
int32_t ret = avservice_->RegisterSessionListenerForUser(userId, listener);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
SLOGD("RegisterSessionListenerForUser003 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: RegisterSessionListenerForUser004
|
|
* @tc.desc: Test RegisterSessionListenerForUser with multiple listeners for different users
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, RegisterSessionListenerForUser004, TestSize.Level0)
|
|
{
|
|
SLOGD("RegisterSessionListenerForUser004 begin!");
|
|
int32_t userId1 = 100;
|
|
int32_t userId2 = 101;
|
|
OHOS::sptr<ISessionListener> listener1 = new ISessionListenerMock();
|
|
OHOS::sptr<ISessionListener> listener2 = new ISessionListenerMock();
|
|
|
|
int32_t ret1 = avservice_->RegisterSessionListenerForUser(userId1, listener1);
|
|
int32_t ret2 = avservice_->RegisterSessionListenerForUser(userId2, listener2);
|
|
|
|
EXPECT_EQ(ret1, AVSESSION_SUCCESS);
|
|
EXPECT_EQ(ret2, AVSESSION_SUCCESS);
|
|
SLOGD("RegisterSessionListenerForUser004 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: RegisterSessionListenerForUser005
|
|
* @tc.desc: Test RegisterSessionListenerForUser with negative userId
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, RegisterSessionListenerForUser005, TestSize.Level0)
|
|
{
|
|
SLOGD("RegisterSessionListenerForUser005 begin!");
|
|
int32_t userId = -1;
|
|
OHOS::sptr<ISessionListener> listener = new ISessionListenerMock();
|
|
|
|
int32_t ret = avservice_->RegisterSessionListenerForUser(userId, listener);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
SLOGD("RegisterSessionListenerForUser005 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: NotifySessionAddForAudioZone001
|
|
* @tc.desc: Test NotifySessionAddForAudioZone with valid descriptor
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, NotifySessionAddForAudioZone001, TestSize.Level0)
|
|
{
|
|
SLOGD("NotifySessionAddForAudioZone001 begin!");
|
|
AVSessionDescriptor descriptor;
|
|
descriptor.sessionId_ = "test_session_001";
|
|
descriptor.userId_ = 100;
|
|
|
|
avservice_->NotifySessionAddForAudioZone(descriptor);
|
|
SLOGD("NotifySessionAddForAudioZone001 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: NotifySessionAddForAudioZone002
|
|
* @tc.desc: Test NotifySessionAddForAudioZone with multiple sessions
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, NotifySessionAddForAudioZone002, TestSize.Level0)
|
|
{
|
|
SLOGD("NotifySessionAddForAudioZone002 begin!");
|
|
AVSessionDescriptor descriptor1;
|
|
descriptor1.sessionId_ = "session_001";
|
|
descriptor1.userId_ = 100;
|
|
|
|
AVSessionDescriptor descriptor2;
|
|
descriptor2.sessionId_ = "session_002";
|
|
descriptor2.userId_ = 101;
|
|
|
|
avservice_->NotifySessionAddForAudioZone(descriptor1);
|
|
avservice_->NotifySessionAddForAudioZone(descriptor2);
|
|
SLOGD("NotifySessionAddForAudioZone002 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: NotifySessionAddForAudioZone003
|
|
* @tc.desc: Test NotifySessionAddForAudioZone with registered listener
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, NotifySessionAddForAudioZone003, TestSize.Level0)
|
|
{
|
|
SLOGD("NotifySessionAddForAudioZone003 begin!");
|
|
int32_t userId = 100;
|
|
OHOS::sptr<ISessionListener> listener = new ISessionListenerMock();
|
|
avservice_->RegisterSessionListenerForUser(userId, listener);
|
|
|
|
AVSessionDescriptor descriptor;
|
|
descriptor.sessionId_ = "test_session";
|
|
descriptor.userId_ = userId;
|
|
avservice_->NotifySessionAddForAudioZone(descriptor);
|
|
SLOGD("NotifySessionAddForAudioZone003 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: NotifySessionRemoveForAudioZone001
|
|
* @tc.desc: Test NotifySessionRemoveForAudioZone with valid descriptor
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, NotifySessionRemoveForAudioZone001, TestSize.Level0)
|
|
{
|
|
SLOGD("NotifySessionRemoveForAudioZone001 begin!");
|
|
AVSessionDescriptor descriptor;
|
|
descriptor.sessionId_ = "test_session_001";
|
|
descriptor.userId_ = 100;
|
|
|
|
avservice_->NotifySessionRemoveForAudioZone(descriptor);
|
|
SLOGD("NotifySessionRemoveForAudioZone001 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: NotifySessionRemoveForAudioZone002
|
|
* @tc.desc: Test NotifySessionRemoveForAudioZone with registered listener
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, NotifySessionRemoveForAudioZone002, TestSize.Level0)
|
|
{
|
|
SLOGD("NotifySessionRemoveForAudioZone002 begin!");
|
|
int32_t userId = 100;
|
|
OHOS::sptr<ISessionListener> listener = new ISessionListenerMock();
|
|
avservice_->RegisterSessionListenerForUser(userId, listener);
|
|
|
|
AVSessionDescriptor descriptor;
|
|
descriptor.sessionId_ = "test_session";
|
|
descriptor.userId_ = userId;
|
|
avservice_->NotifySessionRemoveForAudioZone(descriptor);
|
|
SLOGD("NotifySessionRemoveForAudioZone002 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: NotifySessionRemoveForAudioZone003
|
|
* @tc.desc: Test NotifySessionRemoveForAudioZone with multiple sessions
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, NotifySessionRemoveForAudioZone003, TestSize.Level0)
|
|
{
|
|
SLOGD("NotifySessionRemoveForAudioZone003 begin!");
|
|
AVSessionDescriptor descriptor1;
|
|
descriptor1.sessionId_ = "session_001";
|
|
descriptor1.userId_ = 100;
|
|
|
|
AVSessionDescriptor descriptor2;
|
|
descriptor2.sessionId_ = "session_002";
|
|
descriptor2.userId_ = 101;
|
|
|
|
avservice_->NotifySessionRemoveForAudioZone(descriptor1);
|
|
avservice_->NotifySessionRemoveForAudioZone(descriptor2);
|
|
SLOGD("NotifySessionRemoveForAudioZone003 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: HandleSessionStackChangeForAudioZone001
|
|
* @tc.desc: Test HandleSessionStackChangeForAudioZone basic functionality
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, HandleSessionStackChangeForAudioZone001, TestSize.Level0)
|
|
{
|
|
SLOGD("HandleSessionStackChangeForAudioZone001 begin!");
|
|
avservice_->InitAudioZoneCallback();
|
|
|
|
avservice_->HandleSessionStackChangeForAudioZone();
|
|
SLOGD("HandleSessionStackChangeForAudioZone001 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: HandleSessionStackChangeForAudioZone002
|
|
* @tc.desc: Test HandleSessionStackChangeForAudioZone with registered listeners
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, HandleSessionStackChangeForAudioZone002, TestSize.Level0)
|
|
{
|
|
SLOGD("HandleSessionStackChangeForAudioZone002 begin!");
|
|
avservice_->InitAudioZoneCallback();
|
|
|
|
int32_t userId1 = 100;
|
|
int32_t userId2 = 101;
|
|
OHOS::sptr<ISessionListener> listener1 = new ISessionListenerMock();
|
|
OHOS::sptr<ISessionListener> listener2 = new ISessionListenerMock();
|
|
|
|
avservice_->RegisterSessionListenerForUser(userId1, listener1);
|
|
avservice_->RegisterSessionListenerForUser(userId2, listener2);
|
|
|
|
avservice_->HandleSessionStackChangeForAudioZone();
|
|
SLOGD("HandleSessionStackChangeForAudioZone002 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: NotifySessionStackDiffForAudioZone001
|
|
* @tc.desc: Test NotifySessionStackDiffForAudioZone with session added
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, NotifySessionStackDiffForAudioZone001, TestSize.Level0)
|
|
{
|
|
SLOGD("NotifySessionStackDiffForAudioZone001 begin!");
|
|
int32_t userId = 100;
|
|
std::vector<AVSessionDescriptor> oldStack;
|
|
std::vector<AVSessionDescriptor> newStack;
|
|
|
|
AVSessionDescriptor newSession;
|
|
newSession.sessionId_ = "new_session";
|
|
newSession.userId_ = userId;
|
|
newStack.push_back(newSession);
|
|
|
|
avservice_->NotifySessionStackDiffForAudioZone(userId, oldStack, newStack);
|
|
SLOGD("NotifySessionStackDiffForAudioZone001 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: NotifySessionStackDiffForAudioZone002
|
|
* @tc.desc: Test NotifySessionStackDiffForAudioZone with session removed
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, NotifySessionStackDiffForAudioZone002, TestSize.Level0)
|
|
{
|
|
SLOGD("NotifySessionStackDiffForAudioZone002 begin!");
|
|
int32_t userId = 100;
|
|
std::vector<AVSessionDescriptor> oldStack;
|
|
std::vector<AVSessionDescriptor> newStack;
|
|
|
|
AVSessionDescriptor oldSession;
|
|
oldSession.sessionId_ = "old_session";
|
|
oldSession.userId_ = userId;
|
|
oldStack.push_back(oldSession);
|
|
|
|
avservice_->NotifySessionStackDiffForAudioZone(userId, oldStack, newStack);
|
|
SLOGD("NotifySessionStackDiffForAudioZone002 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: NotifySessionStackDiffForAudioZone003
|
|
* @tc.desc: Test NotifySessionStackDiffForAudioZone with top session change
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, NotifySessionStackDiffForAudioZone003, TestSize.Level0)
|
|
{
|
|
SLOGD("NotifySessionStackDiffForAudioZone003 begin!");
|
|
int32_t userId = 100;
|
|
std::vector<AVSessionDescriptor> oldStack;
|
|
std::vector<AVSessionDescriptor> newStack;
|
|
|
|
AVSessionDescriptor oldTopSession;
|
|
oldTopSession.sessionId_ = "old_top";
|
|
oldTopSession.userId_ = userId;
|
|
|
|
AVSessionDescriptor newTopSession;
|
|
newTopSession.sessionId_ = "new_top";
|
|
newTopSession.userId_ = userId;
|
|
|
|
oldStack.push_back(oldTopSession);
|
|
newStack.push_back(newTopSession);
|
|
|
|
avservice_->NotifySessionStackDiffForAudioZone(userId, oldStack, newStack);
|
|
SLOGD("NotifySessionStackDiffForAudioZone003 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: NotifySessionStackDiffForAudioZone004
|
|
* @tc.desc: Test NotifySessionStackDiffForAudioZone with multiple session changes
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, NotifySessionStackDiffForAudioZone004, TestSize.Level0)
|
|
{
|
|
SLOGD("NotifySessionStackDiffForAudioZone004 begin!");
|
|
int32_t userId = 100;
|
|
std::vector<AVSessionDescriptor> oldStack;
|
|
std::vector<AVSessionDescriptor> newStack;
|
|
|
|
AVSessionDescriptor oldSession1;
|
|
oldSession1.sessionId_ = "old_1";
|
|
oldSession1.userId_ = userId;
|
|
|
|
AVSessionDescriptor oldSession2;
|
|
oldSession2.sessionId_ = "old_2";
|
|
oldSession2.userId_ = userId;
|
|
|
|
AVSessionDescriptor newSession1;
|
|
newSession1.sessionId_ = "new_1";
|
|
newSession1.userId_ = userId;
|
|
|
|
AVSessionDescriptor newSession2;
|
|
newSession2.sessionId_ = "new_2";
|
|
newSession2.userId_ = userId;
|
|
|
|
oldStack.push_back(oldSession1);
|
|
oldStack.push_back(oldSession2);
|
|
newStack.push_back(newSession1);
|
|
newStack.push_back(newSession2);
|
|
|
|
avservice_->NotifySessionStackDiffForAudioZone(userId, oldStack, newStack);
|
|
SLOGD("NotifySessionStackDiffForAudioZone004 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: GetTargetPlayInfoForAudioZone001
|
|
* @tc.desc: Test GetTargetPlayInfoForAudioZone with empty session stack
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, GetTargetPlayInfoForAudioZone001, TestSize.Level0)
|
|
{
|
|
SLOGD("GetTargetPlayInfoForAudioZone001 begin!");
|
|
int32_t userId = 100;
|
|
std::string bundleName = "test_bundle";
|
|
|
|
auto targetInfo = avservice_->GetTargetPlayInfoForAudioZone(userId, bundleName);
|
|
SLOGD("GetTargetPlayInfoForAudioZone001 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: StartAVPlaybackForAudioZone001
|
|
* @tc.desc: Test StartAVPlaybackForAudioZone with valid parameters
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, StartAVPlaybackForAudioZone001, TestSize.Level0)
|
|
{
|
|
SLOGD("StartAVPlaybackForAudioZone001 begin!");
|
|
std::string bundleName = "test_bundle";
|
|
int32_t userId = 100;
|
|
std::string assetId = "test_asset_id";
|
|
CommandInfo info;
|
|
info.SetCallerDeviceId("test_device");
|
|
info.SetCallerBundleName("test_bundle");
|
|
info.SetCallerModuleName("test_module");
|
|
info.SetCallerType("test_type");
|
|
|
|
avservice_->StartAVPlaybackForAudioZone(bundleName, userId, assetId, info);
|
|
SLOGD("StartAVPlaybackForAudioZone001 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: StartAVPlaybackForAudioZone002
|
|
* @tc.desc: Test StartAVPlaybackForAudioZone with empty assetId
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, StartAVPlaybackForAudioZone002, TestSize.Level0)
|
|
{
|
|
SLOGD("StartAVPlaybackForAudioZone002 begin!");
|
|
std::string bundleName = "test_bundle";
|
|
int32_t userId = 100;
|
|
std::string assetId = "";
|
|
CommandInfo info;
|
|
info.SetCallerDeviceId("test_device");
|
|
info.SetCallerBundleName("test_bundle");
|
|
info.SetCallerModuleName("test_module");
|
|
info.SetCallerType("test_type");
|
|
|
|
avservice_->StartAVPlaybackForAudioZone(bundleName, userId, assetId, info);
|
|
SLOGD("StartAVPlaybackForAudioZone002 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: NotifyTopSessionChangeForAudioZone001
|
|
* @tc.desc: Test NotifyTopSessionChangeForAudioZone without registered listener
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, NotifyTopSessionChangeForAudioZone001, TestSize.Level0)
|
|
{
|
|
SLOGD("NotifyTopSessionChangeForAudioZone001 begin!");
|
|
AVSessionDescriptor descriptor;
|
|
descriptor.sessionId_ = "test_session";
|
|
descriptor.userId_ = 100;
|
|
|
|
avservice_->NotifyTopSessionChangeForAudioZone(descriptor);
|
|
SLOGD("NotifyTopSessionChangeForAudioZone001 end!");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: NotifyTopSessionChangeForAudioZone002
|
|
* @tc.desc: Test NotifyTopSessionChangeForAudioZone with registered listener
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionServiceTest, NotifyTopSessionChangeForAudioZone002, TestSize.Level0)
|
|
{
|
|
SLOGD("NotifyTopSessionChangeForAudioZone002 begin!");
|
|
int32_t userId = 100;
|
|
OHOS::sptr<ISessionListener> listener = new ISessionListenerMock();
|
|
avservice_->RegisterSessionListenerForUser(userId, listener);
|
|
|
|
auto& usersManager = avservice_->GetUsersManager();
|
|
usersManager.zoneToUserid_[1].push_back(userId);
|
|
|
|
AVSessionDescriptor descriptor;
|
|
descriptor.sessionId_ = "test_session";
|
|
descriptor.userId_ = userId;
|
|
|
|
avservice_->NotifyTopSessionChangeForAudioZone(descriptor);
|
|
SLOGD("NotifyTopSessionChangeForAudioZone002 end!");
|
|
}
|
|
#endif |