mirror of
https://github.com/openharmony/multimedia_av_session.git
synced 2026-08-25 06:18:12 -04:00
红袍小恶魔
618 lines
20 KiB
C++
618 lines
20 KiB
C++
/*
|
|
* Copyright (c) 2024-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 "avsession_callback_client.h"
|
|
#include "avsession_log.h"
|
|
#include "avsession_errors.h"
|
|
#include "iservice_registry.h"
|
|
#include "avmedia_description.h"
|
|
#include "av_file_descriptor.h"
|
|
#include "system_ability_definition.h"
|
|
#include "av_session_callback_proxy.h"
|
|
#include "avsession_controller_proxy.h"
|
|
#include "avsession_proxy.h"
|
|
#include "avsession_stub.h"
|
|
#include "avsession_service.h"
|
|
|
|
|
|
namespace OHOS::AVSession {
|
|
|
|
static std::shared_ptr<AVSessionService> g_AVSessionService;
|
|
static sptr<IAVSession> g_AVSessionProxy;
|
|
|
|
class AVSessionProxyTest : public testing::Test {
|
|
public:
|
|
static void SetUpTestCase(void);
|
|
static void TearDownTestCase(void);
|
|
void SetUp();
|
|
void TearDown();
|
|
};
|
|
|
|
void AVSessionProxyTest::SetUpTestCase()
|
|
{
|
|
g_AVSessionService = std::make_shared<AVSessionService>(OHOS::AVSESSION_SERVICE_ID);
|
|
std::string deviceId = "deviceId";
|
|
std::string bundleName = "testItem.ohos.avsession";
|
|
std::string abilityName = "testItem.ability";
|
|
std::string moduleName = "moduleName";
|
|
AppExecFwk::ElementName elementName(deviceId, bundleName, abilityName, moduleName);
|
|
sptr<IRemoteObject> obj = g_AVSessionService->CreateSessionInner("test",
|
|
AVSession::SESSION_TYPE_AUDIO, elementName);
|
|
g_AVSessionProxy = iface_cast<IAVSession>(obj);
|
|
g_AVSessionProxy->Activate();
|
|
}
|
|
|
|
void AVSessionProxyTest::TearDownTestCase()
|
|
{
|
|
g_AVSessionProxy->Deactivate();
|
|
g_AVSessionService->Close();
|
|
}
|
|
|
|
void AVSessionProxyTest::SetUp()
|
|
{
|
|
}
|
|
|
|
void AVSessionProxyTest::TearDown()
|
|
{
|
|
}
|
|
|
|
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 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 {};
|
|
};
|
|
|
|
|
|
/**
|
|
* @tc.name: GetSessionId001
|
|
* @tc.desc: Test GetSessionId
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionProxyTest, GetSessionId001, testing::ext::TestSize.Level1)
|
|
{
|
|
SLOGI("GetSessionId001, start");
|
|
std::string sessionId = g_AVSessionProxy->GetSessionId();
|
|
EXPECT_NE(sessionId, "");
|
|
SLOGI("GetSessionId001, end");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: GetSessionType001
|
|
* @tc.desc: Test GetSessionType
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionProxyTest, GetSessionType001, testing::ext::TestSize.Level1)
|
|
{
|
|
SLOGI("GetSessionType001, start");
|
|
std::string typeStr = g_AVSessionProxy->GetSessionType();
|
|
EXPECT_NE(typeStr, "");
|
|
SLOGI("GetSessionType001, end");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: SetAVCallMetaData001
|
|
* @tc.desc: Test SetAVCallMetaData
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionProxyTest, SetAVCallMetaData001, testing::ext::TestSize.Level1)
|
|
{
|
|
SLOGI("SetAVCallMetaData001, start");
|
|
AVCallMetaData avCallMetaData;
|
|
int32_t ret = g_AVSessionProxy->SetAVCallMetaData(avCallMetaData);
|
|
EXPECT_EQ(ret, AVSESSION_ERROR);
|
|
SLOGI("SetAVCallMetaData001, end");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: SetAVCallMetaData002
|
|
* @tc.desc: Test SetAVCallMetaData
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionProxyTest, SetAVCallMetaData002, testing::ext::TestSize.Level1)
|
|
{
|
|
SLOGI("SetAVCallMetaData002, start");
|
|
AVCallMetaData avCallMetaData;
|
|
avCallMetaData.SetName("name");
|
|
avCallMetaData.SetPhoneNumber("number");
|
|
int32_t ret = g_AVSessionProxy->SetAVCallMetaData(avCallMetaData);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
g_AVSessionService->OnStop();
|
|
SLOGI("SetAVCallMetaData002, end");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: SetAVCallState001
|
|
* @tc.desc: Test SetAVCallState
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionProxyTest, SetAVCallState001, testing::ext::TestSize.Level1)
|
|
{
|
|
SLOGI("SetAVCallState001, start");
|
|
AVCallState avCallState;
|
|
avCallState.SetAVCallState(AVCallState::AVCALL_STATE_IDLE);
|
|
int32_t ret = g_AVSessionProxy->SetAVCallState(avCallState);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
SLOGI("SetAVCallState001, end");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: SetAVCallState002
|
|
* @tc.desc: Test SetAVCallState
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionProxyTest, SetAVCallState002, testing::ext::TestSize.Level1)
|
|
{
|
|
SLOGI("SetAVCallState002, start");
|
|
AVCallState avCallState;
|
|
avCallState.SetAVCallState(-1);
|
|
int32_t ret = g_AVSessionProxy->SetAVCallState(avCallState);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
SLOGI("SetAVCallState002, end");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: SetAVMetaData001
|
|
* @tc.desc: Test SetAVMetaData
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionProxyTest, SetAVMetaData001, testing::ext::TestSize.Level1)
|
|
{
|
|
SLOGI("SetAVMetaData001, start");
|
|
AVMetaData meta;
|
|
std::string assetId = "assetId";
|
|
meta.SetAssetId(assetId);
|
|
std::shared_ptr<AVSessionPixelMap> mediaImage = std::make_shared<AVSessionPixelMap>();
|
|
std::vector<uint8_t> imgBuffer = {1, 2, 3, 4, 5, 6, 7, 8};
|
|
mediaImage->SetInnerImgBuffer(imgBuffer);
|
|
meta.SetMediaImage(mediaImage);
|
|
int32_t ret = g_AVSessionProxy->SetAVMetaData(meta);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
SLOGI("SetAVMetaData001, end");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: GetAVMetaData001
|
|
* @tc.desc: Test GetAVMetaData
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionProxyTest, GetAVMetaData001, testing::ext::TestSize.Level1)
|
|
{
|
|
SLOGI("GetAVMetaData001, start");
|
|
AVMetaData meta;
|
|
int32_t ret = g_AVSessionProxy->GetAVMetaData(meta);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
SLOGI("GetAVMetaData001, end");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: GetAVPlaybackState001
|
|
* @tc.desc: Test GetAVPlaybackState
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionProxyTest, GetAVPlaybackState001, testing::ext::TestSize.Level1)
|
|
{
|
|
SLOGI("GetAVPlaybackState001, start");
|
|
AVPlaybackState state;
|
|
int32_t ret = g_AVSessionProxy->GetAVPlaybackState(state);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
SLOGI("GetAVPlaybackState001, end");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: SetAVPlaybackState001
|
|
* @tc.desc: Test SetAVPlaybackState
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionProxyTest, SetAVPlaybackState001, testing::ext::TestSize.Level1)
|
|
{
|
|
SLOGI("SetAVPlaybackState001, start");
|
|
AVPlaybackState avPlaybackState;
|
|
AVPlaybackState::Position position;
|
|
position.elapsedTime_ = 1;
|
|
position.updateTime_ = 1;
|
|
avPlaybackState.SetState(1);
|
|
avPlaybackState.SetSpeed(1);
|
|
avPlaybackState.SetPosition(position);
|
|
avPlaybackState.SetBufferedTime(1);
|
|
avPlaybackState.SetLoopMode(1);
|
|
avPlaybackState.SetFavorite(1);
|
|
avPlaybackState.SetActiveItemId(1);
|
|
avPlaybackState.SetVolume(1);
|
|
avPlaybackState.SetMaxVolume(1);
|
|
avPlaybackState.SetMuted(1);
|
|
avPlaybackState.SetDuration(1);
|
|
avPlaybackState.SetVideoWidth(1);
|
|
avPlaybackState.SetVideoHeight(1);
|
|
int32_t ret = g_AVSessionProxy->SetAVPlaybackState(avPlaybackState);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
SLOGI("SetAVPlaybackState001, end");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: GetAVQueueItems001
|
|
* @tc.desc: Test GetAVQueueItems
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionProxyTest, GetAVQueueItems001, testing::ext::TestSize.Level1)
|
|
{
|
|
SLOGI("GetAVQueueItems001, start");
|
|
std::vector<AVQueueItem> items = {};
|
|
int32_t ret = g_AVSessionProxy->GetAVQueueItems(items);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
SLOGI("GetAVQueueItems001, end");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: SetAVQueueItems001
|
|
* @tc.desc: Test SetAVQueueItems
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionProxyTest, SetAVQueueItems001, testing::ext::TestSize.Level1)
|
|
{
|
|
SLOGI("SetAVQueueItems001, start");
|
|
std::vector<AVQueueItem> items = {};
|
|
int32_t ret = g_AVSessionProxy->SetAVQueueItems(items);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
SLOGI("SetAVQueueItems001, end");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: GetAVQueueTitle001
|
|
* @tc.desc: Test GetAVQueueTitle
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionProxyTest, GetAVQueueTitle001, testing::ext::TestSize.Level1)
|
|
{
|
|
SLOGI("GetAVQueueTitle001, start");
|
|
std::string title = "title";
|
|
int32_t ret = g_AVSessionProxy->GetAVQueueTitle(title);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
SLOGI("GetAVQueueTitle001, end");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: SetAVQueueTitle001
|
|
* @tc.desc: Test SetAVQueueTitle
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionProxyTest, SetAVQueueTitle001, testing::ext::TestSize.Level1)
|
|
{
|
|
SLOGI("SetAVQueueTitle001, start");
|
|
std::string title = "title";
|
|
int32_t ret = g_AVSessionProxy->SetAVQueueTitle(title);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
SLOGI("SetAVQueueTitle001, end");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: SetLaunchAbility001
|
|
* @tc.desc: Test SetLaunchAbility
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionProxyTest, SetLaunchAbility001, testing::ext::TestSize.Level1)
|
|
{
|
|
SLOGI("SetLaunchAbility001, start");
|
|
OHOS::AbilityRuntime::WantAgent::WantAgent ability;
|
|
int32_t ret = g_AVSessionProxy->SetLaunchAbility(ability);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
SLOGI("SetLaunchAbility001, end");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: GetExtras001
|
|
* @tc.desc: Test GetExtras
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionProxyTest, GetExtras001, testing::ext::TestSize.Level1)
|
|
{
|
|
SLOGI("GetExtras001, start");
|
|
OHOS::AAFwk::WantParams extras;
|
|
int32_t ret = g_AVSessionProxy->GetExtras(extras);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
SLOGI("GetExtras001, end");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: SetExtras001
|
|
* @tc.desc: Test SetExtras
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionProxyTest, SetExtras001, testing::ext::TestSize.Level1)
|
|
{
|
|
SLOGI("SetExtras001, start");
|
|
OHOS::AAFwk::WantParams extras;
|
|
int32_t ret = g_AVSessionProxy->SetExtras(extras);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
SLOGI("SetExtras001, end");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: isActivate001
|
|
* @tc.desc: Test Deactivate
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionProxyTest, isActivate001, testing::ext::TestSize.Level1)
|
|
{
|
|
SLOGI("isActivate001, start");
|
|
int32_t ret = g_AVSessionProxy->IsActive();
|
|
EXPECT_EQ(ret, true);
|
|
SLOGI("isActivate001, end");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: SetSessionEvent001
|
|
* @tc.desc: Test SetSessionEvent
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionProxyTest, SetSessionEvent001, testing::ext::TestSize.Level1)
|
|
{
|
|
SLOGI("SetSessionEvent001, start");
|
|
std::string event = "AVSessionCallback";
|
|
OHOS::AAFwk::WantParams args;
|
|
int32_t ret = g_AVSessionProxy->SetSessionEvent(event, args);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
SLOGI("SetSessionEvent001, end");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: AddSupportCommand001
|
|
* @tc.desc: Test AddSupportCommand
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionProxyTest, AddSupportCommand001, testing::ext::TestSize.Level1)
|
|
{
|
|
SLOGI("AddSupportCommand001, start");
|
|
int32_t cmd = AVControlCommand::SESSION_CMD_PLAY;
|
|
int32_t ret = g_AVSessionProxy->AddSupportCommand(cmd);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
SLOGI("AddSupportCommand001, end");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: DeleteSupportCommand001
|
|
* @tc.desc: Test DeleteSupportCommand
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionProxyTest, DeleteSupportCommand001, testing::ext::TestSize.Level1)
|
|
{
|
|
SLOGI("DeleteSupportCommand001, start");
|
|
int32_t cmd = AVControlCommand::SESSION_CMD_PLAY;
|
|
int32_t ret = g_AVSessionProxy->AddSupportCommand(cmd);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
ret = g_AVSessionProxy->DeleteSupportCommand(cmd);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
SLOGI("DeleteSupportCommand001, end");
|
|
}
|
|
|
|
/**
|
|
|
|
* @tc.name: GetController001
|
|
* @tc.desc: Test GetController
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionProxyTest, GetController001, testing::ext::TestSize.Level1)
|
|
{
|
|
SLOGI("GetController001, start");
|
|
std::string sessionId = g_AVSessionProxy->GetSessionId();
|
|
sptr<IRemoteObject> controllerInner;
|
|
int32_t ret = g_AVSessionService->CreateControllerInner(sessionId, controllerInner);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
|
|
std::shared_ptr<AVSessionController> avSessionController = g_AVSessionProxy->GetController();
|
|
EXPECT_EQ(avSessionController, nullptr);
|
|
SLOGI("GetController001, end");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: RegisterCallback001
|
|
* @tc.desc: Test RegisterCallback
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionProxyTest, RegisterCallback001, testing::ext::TestSize.Level1)
|
|
{
|
|
SLOGI("RegisterCallback001, start");
|
|
std::shared_ptr<AVSessionCallback> avSessionCallbackImpl = std::make_shared<AVSessionCallbackImpl>();
|
|
int32_t ret = g_AVSessionProxy->RegisterCallback(avSessionCallbackImpl);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
SLOGI("RegisterCallback001, end");
|
|
}
|
|
|
|
|
|
/**
|
|
* @tc.name: SetAVMetaData002
|
|
* @tc.desc: Test SetAVMetaData
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionProxyTest, SetAVMetaData002, testing::ext::TestSize.Level1)
|
|
{
|
|
SLOGI("SetAVMetaData002, start");
|
|
AVMetaData meta;
|
|
std::string assetId = "assetId";
|
|
meta.SetAssetId(assetId);
|
|
|
|
std::shared_ptr<AVSessionPixelMap> mediaImage = std::make_shared<AVSessionPixelMap>();
|
|
std::vector<uint8_t> imgBuffer = {1, 2, 3, 4};
|
|
mediaImage->SetInnerImgBuffer(imgBuffer);
|
|
meta.SetMediaImage(mediaImage);
|
|
|
|
std::shared_ptr<AVSessionPixelMap> avQueuePixel = std::make_shared<AVSessionPixelMap>();
|
|
std::vector<uint8_t> pixelBuffer = {1, 2, 3, 4};
|
|
avQueuePixel->SetInnerImgBuffer(pixelBuffer);
|
|
meta.SetAVQueueImage(avQueuePixel);
|
|
|
|
int32_t ret = g_AVSessionProxy->SetAVMetaData(meta);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
SLOGI("SetAVMetaData002, end");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: SetAVMetaData003
|
|
* @tc.desc: Test SetAVMetaData
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionProxyTest, SetAVMetaData003, testing::ext::TestSize.Level1)
|
|
{
|
|
SLOGI("SetAVMetaData003, start");
|
|
AVMetaData meta;
|
|
std::string assetId = "assetId";
|
|
meta.SetAssetId(assetId);
|
|
int32_t ret = g_AVSessionProxy->SetAVMetaData(meta);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
SLOGI("SetAVMetaData003, end");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: GetAVQueueItems002
|
|
* @tc.desc: Test GetAVQueueItems
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionProxyTest, GetAVQueueItems002, testing::ext::TestSize.Level1)
|
|
{
|
|
SLOGI("GetAVQueueItems002, start");
|
|
std::vector<AVQueueItem> setItems;
|
|
AVQueueItem item;
|
|
setItems.push_back(item);
|
|
g_AVSessionProxy->SetAVQueueItems(setItems);
|
|
|
|
std::vector<AVQueueItem> getItems;
|
|
int32_t ret = g_AVSessionProxy->GetAVQueueItems(getItems);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
SLOGI("GetAVQueueItems002, end");
|
|
}
|
|
|
|
#ifdef CASTPLUS_CAST_ENGINE_ENABLE
|
|
static constexpr int32_t ILLEGAL_DISPLAY_STATE = 999;
|
|
|
|
/**
|
|
* @tc.name: GetAVCastController001
|
|
* @tc.desc: Test GetAVCastController
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionProxyTest, GetAVCastController001, testing::ext::TestSize.Level1)
|
|
{
|
|
SLOGI("GetAVCastController001, start");
|
|
auto ret = g_AVSessionProxy->GetAVCastController();
|
|
EXPECT_EQ(ret, nullptr);
|
|
SLOGI("GetAVCastController001, end");
|
|
}
|
|
|
|
/**
|
|
* @tc.name: GetAllCastDisplays001
|
|
* @tc.desc: Test GetAllCastDisplays
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionProxyTest, GetAllCastDisplays001, testing::ext::TestSize.Level1)
|
|
{
|
|
SLOGI("GetAllCastDisplays001, start");
|
|
std::vector<CastDisplayInfo> castDisplays;
|
|
auto ret = g_AVSessionProxy->GetAllCastDisplays(castDisplays);
|
|
EXPECT_EQ(ret, AVSESSION_SUCCESS);
|
|
SLOGI("GetAllCastDisplays001, end");
|
|
}
|
|
|
|
class MockCastDisplayStub : public AVSessionStub {
|
|
public:
|
|
std::string GetSessionId() override { return ""; }
|
|
std::string GetSessionType() override { return ""; }
|
|
int32_t GetAVMetaData(AVMetaData &meta) override { return 0; }
|
|
int32_t SetAVMetaData(const AVMetaData &meta) override { return 0; }
|
|
int32_t SetAVCallMetaData(const AVCallMetaData &meta) override { return 0; }
|
|
int32_t SetAVCallState(const AVCallState &avCallState) override { return 0; }
|
|
int32_t GetAVPlaybackState(AVPlaybackState &state) override { return 0; }
|
|
int32_t SetAVPlaybackState(const AVPlaybackState &state) override { return 0; }
|
|
int32_t GetAVQueueItems(std::vector<AVQueueItem> &items) override { return 0; }
|
|
int32_t SetAVQueueItems(const std::vector<AVQueueItem> &items) override { return 0; }
|
|
int32_t GetAVQueueTitle(std::string &title) override { return 0; }
|
|
int32_t SetAVQueueTitle(const std::string &title) override { return 0; }
|
|
int32_t SetLaunchAbility(const OHOS::AbilityRuntime::WantAgent::WantAgent &ability) override { return 0; }
|
|
int32_t GetExtras(OHOS::AAFwk::WantParams &extras) override { return 0; }
|
|
int32_t SetExtras(const OHOS::AAFwk::WantParams &extras) override { return 0; }
|
|
std::shared_ptr<AVSessionController> GetController() override { return nullptr; }
|
|
int32_t RegisterCallback(const std::shared_ptr<AVSessionCallback> &callback) override { return 0; }
|
|
int32_t Activate() override { return 0; }
|
|
int32_t Deactivate() override { return 0; }
|
|
bool IsActive() override { return true; }
|
|
int32_t Destroy() override { return 0; }
|
|
int32_t AddSupportCommand(const int32_t cmd) override { return 0; }
|
|
int32_t DeleteSupportCommand(const int32_t cmd) override { return 0; }
|
|
int32_t SetSessionEvent(const std::string &event, const OHOS::AAFwk::WantParams &args) override { return 0; }
|
|
int32_t UpdateAVQueueInfo(const AVQueueInfo& info) override { return 0; }
|
|
int32_t SetMediaCenterControlType(const std::vector<int32_t>& controlTypes) override { return 0; }
|
|
int32_t SetSupportedPlaySpeeds(const std::vector<double>& speeds) override { return 0; }
|
|
int32_t SetSupportedLoopModes(const std::vector<int32_t>& loopModes) override { return 0; }
|
|
std::shared_ptr<AVCastController> GetAVCastController() override { return nullptr; }
|
|
int32_t ReleaseCast(bool continuePlay = false) override { return 0; }
|
|
int32_t StartCastDisplayListener() override { return 0; }
|
|
int32_t StopCastDisplayListener() override { return 0; }
|
|
int32_t GetAllCastDisplays(std::vector<CastDisplayInfo> &castDisplays) override { return 0; }
|
|
|
|
int32_t SendRequest(uint32_t code, OHOS::MessageParcel &data, OHOS::MessageParcel &reply,
|
|
OHOS::MessageOption &option) override
|
|
{
|
|
if (code == SESSION_CMD_GET_ALL_CAST_DISPLAYS) {
|
|
reply.WriteInt32(AVSESSION_SUCCESS);
|
|
reply.WriteInt32(1);
|
|
reply.WriteInt32(ILLEGAL_DISPLAY_STATE);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
protected:
|
|
int32_t RegisterCallbackInner(const OHOS::sptr<IAVSessionCallback> &callback) override { return 0; }
|
|
OHOS::sptr<IRemoteObject> GetControllerInner() override { return nullptr; }
|
|
OHOS::sptr<IRemoteObject> GetAVCastControllerInner() override { return nullptr; }
|
|
};
|
|
|
|
/**
|
|
* @tc.name: GetAllCastDisplays002
|
|
* @tc.desc: Test GetAllCastDisplays with illegal displayState returns ERR_MARSHALLING
|
|
* @tc.type: FUNC
|
|
*/
|
|
static HWTEST_F(AVSessionProxyTest, GetAllCastDisplays002, testing::ext::TestSize.Level1)
|
|
{
|
|
SLOGI("GetAllCastDisplays002, start");
|
|
sptr<IRemoteObject> remote = new MockCastDisplayStub();
|
|
AVSessionProxy proxy(remote);
|
|
std::vector<CastDisplayInfo> castDisplays;
|
|
auto ret = proxy.GetAllCastDisplays(castDisplays);
|
|
EXPECT_EQ(ret, ERR_MARSHALLING);
|
|
SLOGI("GetAllCastDisplays002, end");
|
|
}
|
|
#endif
|
|
|
|
} //OHOS::AVSESSION
|