1 /*
2 * Copyright (c) 2022-2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "avcontrol_command.h"
17 #include "avplayback_state.h"
18 #include "avsession_errors.h"
19 #include "avsession_log.h"
20
21 namespace OHOS::AVSession {
AVControlCommand()22 AVControlCommand::AVControlCommand()
23 : cmd_(SESSION_CMD_INVALID)
24 {
25 }
26
~AVControlCommand()27 AVControlCommand::~AVControlCommand()
28 {
29 }
30
Unmarshalling(Parcel & data)31 AVControlCommand *AVControlCommand::Unmarshalling(Parcel& data)
32 {
33 auto result = new (std::nothrow) AVControlCommand();
34 if (result != nullptr) {
35 int32_t cmd = data.ReadInt32();
36 result->SetCommand(cmd);
37 switch (cmd) {
38 case SESSION_CMD_FAST_FORWARD:
39 result->SetForwardTime(data.ReadInt64());
40 break;
41 case SESSION_CMD_REWIND:
42 result->SetRewindTime(data.ReadInt64());
43 break;
44 case SESSION_CMD_SEEK:
45 result->SetSeekTime(data.ReadInt64());
46 break;
47 case SESSION_CMD_SET_SPEED:
48 result->SetSpeed(data.ReadDouble());
49 break;
50 case SESSION_CMD_SET_LOOP_MODE:
51 result->SetLoopMode(data.ReadInt32());
52 break;
53 case SESSION_CMD_SET_TARGET_LOOP_MODE:
54 result->SetTargetLoopMode(data.ReadInt32());
55 break;
56 case SESSION_CMD_TOGGLE_FAVORITE:
57 result->SetAssetId(data.ReadString());
58 break;
59 case SESSION_CMD_PLAY_FROM_ASSETID:
60 result->SetPlayFromAssetId(data.ReadInt64());
61 break;
62 case SESSION_CMD_PLAY_WITH_ASSETID:
63 result->SetPlayWithAssetId(data.ReadString());
64 break;
65 default:
66 break;
67 }
68 }
69 return result;
70 }
71
Marshalling(Parcel & parcel) const72 bool AVControlCommand::Marshalling(Parcel& parcel) const
73 {
74 if (!parcel.WriteInt32(cmd_)) {
75 return false;
76 }
77 switch (cmd_) {
78 case SESSION_CMD_FAST_FORWARD:
79 CHECK_AND_RETURN_RET_LOG(std::holds_alternative<int64_t>(param_) &&
80 parcel.WriteInt64(std::get<int64_t>(param_)), false, "write fast forward time failed");
81 break;
82 case SESSION_CMD_REWIND:
83 CHECK_AND_RETURN_RET_LOG(std::holds_alternative<int64_t>(param_) &&
84 parcel.WriteInt64(std::get<int64_t>(param_)), false, "write rewind time failed");
85 break;
86 case SESSION_CMD_SEEK:
87 CHECK_AND_RETURN_RET_LOG(std::holds_alternative<int64_t>(param_) &&
88 parcel.WriteInt64(std::get<int64_t>(param_)), false, "write seek time failed");
89 break;
90 case SESSION_CMD_SET_SPEED:
91 CHECK_AND_RETURN_RET_LOG(std::holds_alternative<double>(param_) &&
92 parcel.WriteDouble(std::get<double>(param_)), false, "write speed failed");
93 break;
94 case SESSION_CMD_SET_LOOP_MODE:
95 CHECK_AND_RETURN_RET_LOG(std::holds_alternative<int32_t>(param_) &&
96 parcel.WriteInt32(std::get<int32_t>(param_)), false, "write loop mode failed");
97 break;
98 case SESSION_CMD_SET_TARGET_LOOP_MODE:
99 CHECK_AND_RETURN_RET_LOG(std::holds_alternative<int32_t>(param_) &&
100 parcel.WriteInt32(std::get<int32_t>(param_)), false, "write target loop mode failed");
101 break;
102 case SESSION_CMD_TOGGLE_FAVORITE:
103 CHECK_AND_RETURN_RET_LOG(std::holds_alternative<std::string>(param_) &&
104 parcel.WriteString(std::get<std::string>(param_)), false, "write toggle favorite failed");
105 break;
106 case SESSION_CMD_PLAY_FROM_ASSETID:
107 CHECK_AND_RETURN_RET_LOG(std::holds_alternative<int64_t>(param_) &&
108 parcel.WriteInt64(std::get<int64_t>(param_)), false, "write play from assetId failed");
109 break;
110 case SESSION_CMD_PLAY_WITH_ASSETID:
111 CHECK_AND_RETURN_RET_LOG(std::holds_alternative<std::string>(param_) &&
112 parcel.WriteString(std::get<std::string>(param_)), false, "write play with assetId failed");
113 break;
114 default:
115 break;
116 }
117 return true;
118 }
119
IsValid() const120 bool AVControlCommand::IsValid() const
121 {
122 return cmd_ > SESSION_CMD_INVALID && cmd_ < SESSION_CMD_MAX;
123 }
124
SetCommand(int32_t cmd)125 int32_t AVControlCommand::SetCommand(int32_t cmd)
126 {
127 if (cmd <= SESSION_CMD_INVALID || cmd >= SESSION_CMD_MAX) {
128 return ERR_INVALID_PARAM;
129 }
130 cmd_ = cmd;
131 return AVSESSION_SUCCESS;
132 }
133
GetCommand() const134 int32_t AVControlCommand::GetCommand() const
135 {
136 return cmd_;
137 }
138
SetSpeed(double speed)139 int32_t AVControlCommand::SetSpeed(double speed)
140 {
141 if (speed <= 0) {
142 return ERR_INVALID_PARAM;
143 }
144 param_ = speed;
145 return AVSESSION_SUCCESS;
146 }
147
148 // LCOV_EXCL_START
GetSpeed(double & speed) const149 int32_t AVControlCommand::GetSpeed(double& speed) const
150 {
151 if (!std::holds_alternative<double>(param_)) {
152 return AVSESSION_ERROR;
153 }
154 speed = std::get<double>(param_);
155 return AVSESSION_SUCCESS;
156 }
157 // LCOV_EXCL_STOP
158
SetForwardTime(int64_t forwardTime)159 int32_t AVControlCommand::SetForwardTime(int64_t forwardTime)
160 {
161 SLOGD("SetForwardTime with time %{public}jd", static_cast<int64_t>(forwardTime));
162 if (forwardTime <= 0) {
163 SLOGE("SetForwardTime error");
164 return ERR_INVALID_PARAM;
165 }
166 param_ = forwardTime;
167 return AVSESSION_SUCCESS;
168 }
169
170 // LCOV_EXCL_START
GetForwardTime(int64_t & forwardTime) const171 int32_t AVControlCommand::GetForwardTime(int64_t& forwardTime) const
172 {
173 if (!std::holds_alternative<int64_t>(param_)) {
174 SLOGE("GetForwardTime error");
175 return AVSESSION_ERROR;
176 }
177 forwardTime = std::get<int64_t>(param_);
178 SLOGE("GetForwardTime with time %{public}jd", static_cast<int64_t>(forwardTime));
179 return AVSESSION_SUCCESS;
180 }
181 // LCOV_EXCL_STOP
182
SetRewindTime(int64_t rewindTime)183 int32_t AVControlCommand::SetRewindTime(int64_t rewindTime)
184 {
185 SLOGE("SetRewindTime with time %{public}jd", static_cast<int64_t>(rewindTime));
186 if (rewindTime < 0) {
187 SLOGE("SetRewindTime error");
188 return ERR_INVALID_PARAM;
189 }
190 param_ = rewindTime;
191 return AVSESSION_SUCCESS;
192 }
193
194 // LCOV_EXCL_START
GetRewindTime(int64_t & rewindTime) const195 int32_t AVControlCommand::GetRewindTime(int64_t& rewindTime) const
196 {
197 if (!std::holds_alternative<int64_t>(param_)) {
198 SLOGE("GetRewindTime error");
199 return AVSESSION_ERROR;
200 }
201 rewindTime = std::get<int64_t>(param_);
202 SLOGE("GetRewindTime with time %{public}jd", static_cast<int64_t>(rewindTime));
203 return AVSESSION_SUCCESS;
204 }
205 // LCOV_EXCL_STOP
206
SetSeekTime(int64_t time)207 int32_t AVControlCommand::SetSeekTime(int64_t time)
208 {
209 if (time < 0) {
210 return ERR_INVALID_PARAM;
211 }
212 param_ = time;
213 return AVSESSION_SUCCESS;
214 }
215
216 // LCOV_EXCL_START
GetSeekTime(int64_t & time) const217 int32_t AVControlCommand::GetSeekTime(int64_t& time) const
218 {
219 if (!std::holds_alternative<int64_t>(param_)) {
220 return AVSESSION_ERROR;
221 }
222 time = std::get<int64_t>(param_);
223 return AVSESSION_SUCCESS;
224 }
225 // LCOV_EXCL_STOP
226
SetLoopMode(int32_t mode)227 int32_t AVControlCommand::SetLoopMode(int32_t mode)
228 {
229 if (mode < AVPlaybackState::LOOP_MODE_UNDEFINED || mode > AVPlaybackState::LOOP_MODE_CUSTOM) {
230 return ERR_INVALID_PARAM;
231 }
232 param_ = mode;
233 return AVSESSION_SUCCESS;
234 }
235
236 // LCOV_EXCL_START
GetLoopMode(int32_t & mode) const237 int32_t AVControlCommand::GetLoopMode(int32_t& mode) const
238 {
239 if (!std::holds_alternative<int32_t>(param_)) {
240 return AVSESSION_ERROR;
241 }
242 mode = std::get<int32_t>(param_);
243 return AVSESSION_SUCCESS;
244 }
245 // LCOV_EXCL_STOP
246
247 // LCOV_EXCL_START
SetTargetLoopMode(int32_t targetMode)248 int32_t AVControlCommand::SetTargetLoopMode(int32_t targetMode)
249 {
250 if (targetMode < AVPlaybackState::LOOP_MODE_UNDEFINED || targetMode > AVPlaybackState::LOOP_MODE_CUSTOM) {
251 return ERR_INVALID_PARAM;
252 }
253 param_ = targetMode;
254 return AVSESSION_SUCCESS;
255 }
256
GetTargetLoopMode(int32_t & targetMode) const257 int32_t AVControlCommand::GetTargetLoopMode(int32_t& targetMode) const
258 {
259 if (!std::holds_alternative<int32_t>(param_)) {
260 return AVSESSION_ERROR;
261 }
262 targetMode = std::get<int32_t>(param_);
263 return AVSESSION_SUCCESS;
264 }
265 // LCOV_EXCL_STOP
266
SetAssetId(const std::string & assetId)267 int32_t AVControlCommand::SetAssetId(const std::string& assetId)
268 {
269 if (assetId.empty()) {
270 return ERR_INVALID_PARAM;
271 }
272 param_ = assetId;
273 return AVSESSION_SUCCESS;
274 }
275
276 // LCOV_EXCL_START
GetAssetId(std::string & assetId) const277 int32_t AVControlCommand::GetAssetId(std::string& assetId) const
278 {
279 if (!std::holds_alternative<std::string>(param_)) {
280 return AVSESSION_ERROR;
281 }
282 assetId = std::get<std::string>(param_);
283 return AVSESSION_SUCCESS;
284 }
285 // LCOV_EXCL_STOP
286
SetPlayFromAssetId(int64_t playFromAssetId)287 int32_t AVControlCommand::SetPlayFromAssetId(int64_t playFromAssetId)
288 {
289 param_ = playFromAssetId;
290 return AVSESSION_SUCCESS;
291 }
292
293 // LCOV_EXCL_START
GetPlayFromAssetId(int64_t & playFromAssetId) const294 int32_t AVControlCommand::GetPlayFromAssetId(int64_t& playFromAssetId) const
295 {
296 if (!std::holds_alternative<int64_t>(param_)) {
297 return AVSESSION_ERROR;
298 }
299 playFromAssetId = std::get<int64_t>(param_);
300 return AVSESSION_SUCCESS;
301 }
302 // LCOV_EXCL_STOP
303
SetPlayWithAssetId(const std::string & playWithAssetId)304 int32_t AVControlCommand::SetPlayWithAssetId(const std::string& playWithAssetId)
305 {
306 if (playWithAssetId.empty()) {
307 return ERR_INVALID_PARAM;
308 }
309 param_ = playWithAssetId;
310 return AVSESSION_SUCCESS;
311 }
312
313 // LCOV_EXCL_START
GetPlayWithAssetId(std::string & playWithAssetId) const314 int32_t AVControlCommand::GetPlayWithAssetId(std::string& playWithAssetId) const
315 {
316 if (!std::holds_alternative<std::string>(param_)) {
317 return AVSESSION_ERROR;
318 }
319 playWithAssetId = std::get<std::string>(param_);
320 return AVSESSION_SUCCESS;
321 }
322 // LCOV_EXCL_STOP
323 } // namespace OHOS::AVSession
324