1 /*
2 * Copyright (c) 2022-2023 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_AVCALL_TOGGLE_CALL_MUTE:
60 result->SetAVCallMuted(data.ReadBool());
61 break;
62 case SESSION_CMD_PLAY_FROM_ASSETID:
63 result->SetPlayFromAssetId(data.ReadInt64());
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 default:
111 break;
112 }
113 return true;
114 }
115
IsValid() const116 bool AVControlCommand::IsValid() const
117 {
118 return cmd_ > SESSION_CMD_INVALID && cmd_ < SESSION_CMD_MAX;
119 }
120
SetCommand(int32_t cmd)121 int32_t AVControlCommand::SetCommand(int32_t cmd)
122 {
123 if (cmd <= SESSION_CMD_INVALID || cmd >= SESSION_CMD_MAX) {
124 return ERR_INVALID_PARAM;
125 }
126 cmd_ = cmd;
127 return AVSESSION_SUCCESS;
128 }
129
GetCommand() const130 int32_t AVControlCommand::GetCommand() const
131 {
132 return cmd_;
133 }
134
SetSpeed(double speed)135 int32_t AVControlCommand::SetSpeed(double speed)
136 {
137 if (speed <= 0) {
138 return ERR_INVALID_PARAM;
139 }
140 param_ = speed;
141 return AVSESSION_SUCCESS;
142 }
143
144 // LCOV_EXCL_START
GetSpeed(double & speed) const145 int32_t AVControlCommand::GetSpeed(double& speed) const
146 {
147 if (!std::holds_alternative<double>(param_)) {
148 return AVSESSION_ERROR;
149 }
150 speed = std::get<double>(param_);
151 return AVSESSION_SUCCESS;
152 }
153 // LCOV_EXCL_STOP
154
SetForwardTime(int64_t forwardTime)155 int32_t AVControlCommand::SetForwardTime(int64_t forwardTime)
156 {
157 SLOGD("SetForwardTime with time %{public}jd", static_cast<int64_t>(forwardTime));
158 if (forwardTime <= 0) {
159 SLOGE("SetForwardTime error");
160 return ERR_INVALID_PARAM;
161 }
162 param_ = forwardTime;
163 return AVSESSION_SUCCESS;
164 }
165
166 // LCOV_EXCL_START
GetForwardTime(int64_t & forwardTime) const167 int32_t AVControlCommand::GetForwardTime(int64_t& forwardTime) const
168 {
169 if (!std::holds_alternative<int64_t>(param_)) {
170 SLOGE("GetForwardTime error");
171 return AVSESSION_ERROR;
172 }
173 forwardTime = std::get<int64_t>(param_);
174 SLOGE("GetForwardTime with time %{public}jd", static_cast<int64_t>(forwardTime));
175 return AVSESSION_SUCCESS;
176 }
177 // LCOV_EXCL_STOP
178
SetRewindTime(int64_t rewindTime)179 int32_t AVControlCommand::SetRewindTime(int64_t rewindTime)
180 {
181 SLOGE("SetRewindTime with time %{public}jd", static_cast<int64_t>(rewindTime));
182 if (rewindTime < 0) {
183 SLOGE("SetRewindTime error");
184 return ERR_INVALID_PARAM;
185 }
186 param_ = rewindTime;
187 return AVSESSION_SUCCESS;
188 }
189
190 // LCOV_EXCL_START
GetRewindTime(int64_t & rewindTime) const191 int32_t AVControlCommand::GetRewindTime(int64_t& rewindTime) const
192 {
193 if (!std::holds_alternative<int64_t>(param_)) {
194 SLOGE("GetRewindTime error");
195 return AVSESSION_ERROR;
196 }
197 rewindTime = std::get<int64_t>(param_);
198 SLOGE("GetRewindTime with time %{public}jd", static_cast<int64_t>(rewindTime));
199 return AVSESSION_SUCCESS;
200 }
201 // LCOV_EXCL_STOP
202
SetSeekTime(int64_t time)203 int32_t AVControlCommand::SetSeekTime(int64_t time)
204 {
205 if (time < 0) {
206 return ERR_INVALID_PARAM;
207 }
208 param_ = time;
209 return AVSESSION_SUCCESS;
210 }
211
212 // LCOV_EXCL_START
GetSeekTime(int64_t & time) const213 int32_t AVControlCommand::GetSeekTime(int64_t& time) const
214 {
215 if (!std::holds_alternative<int64_t>(param_)) {
216 return AVSESSION_ERROR;
217 }
218 time = std::get<int64_t>(param_);
219 return AVSESSION_SUCCESS;
220 }
221 // LCOV_EXCL_STOP
222
SetLoopMode(int32_t mode)223 int32_t AVControlCommand::SetLoopMode(int32_t mode)
224 {
225 if (mode < AVPlaybackState::LOOP_MODE_UNDEFINED || mode > AVPlaybackState::LOOP_MODE_CUSTOM) {
226 return ERR_INVALID_PARAM;
227 }
228 param_ = mode;
229 return AVSESSION_SUCCESS;
230 }
231
232 // LCOV_EXCL_START
GetLoopMode(int32_t & mode) const233 int32_t AVControlCommand::GetLoopMode(int32_t& mode) const
234 {
235 if (!std::holds_alternative<int32_t>(param_)) {
236 return AVSESSION_ERROR;
237 }
238 mode = std::get<int32_t>(param_);
239 return AVSESSION_SUCCESS;
240 }
241 // LCOV_EXCL_STOP
242
243 // LCOV_EXCL_START
SetTargetLoopMode(int32_t targetMode)244 int32_t AVControlCommand::SetTargetLoopMode(int32_t targetMode)
245 {
246 if (targetMode < AVPlaybackState::LOOP_MODE_UNDEFINED || targetMode > AVPlaybackState::LOOP_MODE_CUSTOM) {
247 return ERR_INVALID_PARAM;
248 }
249 param_ = targetMode;
250 return AVSESSION_SUCCESS;
251 }
252
GetTargetLoopMode(int32_t & targetMode) const253 int32_t AVControlCommand::GetTargetLoopMode(int32_t& targetMode) const
254 {
255 if (!std::holds_alternative<int32_t>(param_)) {
256 return AVSESSION_ERROR;
257 }
258 targetMode = std::get<int32_t>(param_);
259 return AVSESSION_SUCCESS;
260 }
261 // LCOV_EXCL_STOP
262
SetAssetId(const std::string & assetId)263 int32_t AVControlCommand::SetAssetId(const std::string& assetId)
264 {
265 if (assetId.empty()) {
266 return ERR_INVALID_PARAM;
267 }
268 param_ = assetId;
269 return AVSESSION_SUCCESS;
270 }
271
272 // LCOV_EXCL_START
GetAssetId(std::string & assetId) const273 int32_t AVControlCommand::GetAssetId(std::string& assetId) const
274 {
275 if (!std::holds_alternative<std::string>(param_)) {
276 return AVSESSION_ERROR;
277 }
278 assetId = std::get<std::string>(param_);
279 return AVSESSION_SUCCESS;
280 }
281 // LCOV_EXCL_STOP
282
SetAVCallMuted(const bool isAVCallMuted)283 int32_t AVControlCommand::SetAVCallMuted(const bool isAVCallMuted)
284 {
285 param_ = isAVCallMuted;
286 return AVSESSION_SUCCESS;
287 }
288
289 // LCOV_EXCL_START
IsAVCallMuted(bool & isAVCallMuted) const290 int32_t AVControlCommand::IsAVCallMuted(bool& isAVCallMuted) const
291 {
292 if (!std::holds_alternative<bool>(param_)) {
293 return AVSESSION_ERROR;
294 }
295 isAVCallMuted = std::get<bool>(param_);
296 return AVSESSION_SUCCESS;
297 }
298 // LCOV_EXCL_STOP
299
SetPlayFromAssetId(int64_t playFromAssetId)300 int32_t AVControlCommand::SetPlayFromAssetId(int64_t playFromAssetId)
301 {
302 param_ = playFromAssetId;
303 return AVSESSION_SUCCESS;
304 }
305
306 // LCOV_EXCL_START
GetPlayFromAssetId(int64_t & playFromAssetId) const307 int32_t AVControlCommand::GetPlayFromAssetId(int64_t& playFromAssetId) const
308 {
309 if (!std::holds_alternative<int64_t>(param_)) {
310 return AVSESSION_ERROR;
311 }
312 playFromAssetId = std::get<int64_t>(param_);
313 return AVSESSION_SUCCESS;
314 }
315 // LCOV_EXCL_STOP
316 } // namespace OHOS::AVSession
317