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_TOGGLE_FAVORITE:
54 result->SetAssetId(data.ReadString());
55 break;
56 case SESSION_CMD_AVCALL_TOGGLE_CALL_MUTE:
57 result->SetAVCallMuted(data.ReadBool());
58 break;
59 case SESSION_CMD_PLAY_FROM_ASSETID:
60 result->SetPlayFromAssetId(data.ReadInt64());
61 break;
62 default:
63 break;
64 }
65 }
66 return result;
67 }
68
Marshalling(Parcel & parcel) const69 bool AVControlCommand::Marshalling(Parcel& parcel) const
70 {
71 if (!parcel.WriteInt32(cmd_)) {
72 return false;
73 }
74 switch (cmd_) {
75 case SESSION_CMD_FAST_FORWARD:
76 CHECK_AND_RETURN_RET_LOG(std::holds_alternative<int64_t>(param_)
77 && parcel.WriteInt64(std::get<int64_t>(param_)), false, "write fast forward time failed");
78 break;
79 case SESSION_CMD_REWIND:
80 CHECK_AND_RETURN_RET_LOG(std::holds_alternative<int64_t>(param_)
81 && parcel.WriteInt64(std::get<int64_t>(param_)), false, "write rewind time failed");
82 break;
83 case SESSION_CMD_SEEK:
84 CHECK_AND_RETURN_RET_LOG(std::holds_alternative<int64_t>(param_)
85 && parcel.WriteInt64(std::get<int64_t>(param_)), false, "write seek time failed");
86 break;
87 case SESSION_CMD_SET_SPEED:
88 CHECK_AND_RETURN_RET_LOG(std::holds_alternative<double>(param_)
89 && parcel.WriteDouble(std::get<double>(param_)), false, "write speed failed");
90 break;
91 case SESSION_CMD_SET_LOOP_MODE:
92 CHECK_AND_RETURN_RET_LOG(std::holds_alternative<int32_t>(param_)
93 && parcel.WriteInt32(std::get<int32_t>(param_)), false, "write loop mode failed");
94 break;
95 case SESSION_CMD_TOGGLE_FAVORITE:
96 CHECK_AND_RETURN_RET_LOG(std::holds_alternative<std::string>(param_)
97 && parcel.WriteString(std::get<std::string>(param_)), false, "write toggle favorite failed");
98 break;
99 case SESSION_CMD_PLAY_FROM_ASSETID:
100 CHECK_AND_RETURN_RET_LOG(std::holds_alternative<int64_t>(param_)
101 && parcel.WriteInt64(std::get<int64_t>(param_)), false, "write play from assetId failed");
102 break;
103 default:
104 break;
105 }
106 return true;
107 }
108
IsValid() const109 bool AVControlCommand::IsValid() const
110 {
111 return cmd_ > SESSION_CMD_INVALID && cmd_ < SESSION_CMD_MAX;
112 }
113
SetCommand(int32_t cmd)114 int32_t AVControlCommand::SetCommand(int32_t cmd)
115 {
116 if (cmd <= SESSION_CMD_INVALID || cmd >= SESSION_CMD_MAX) {
117 return ERR_INVALID_PARAM;
118 }
119 cmd_ = cmd;
120 return AVSESSION_SUCCESS;
121 }
122
GetCommand() const123 int32_t AVControlCommand::GetCommand() const
124 {
125 return cmd_;
126 }
127
SetSpeed(double speed)128 int32_t AVControlCommand::SetSpeed(double speed)
129 {
130 if (speed <= 0) {
131 return ERR_INVALID_PARAM;
132 }
133 param_ = speed;
134 return AVSESSION_SUCCESS;
135 }
136
137 // LCOV_EXCL_START
GetSpeed(double & speed) const138 int32_t AVControlCommand::GetSpeed(double& speed) const
139 {
140 if (!std::holds_alternative<double>(param_)) {
141 return AVSESSION_ERROR;
142 }
143 speed = std::get<double>(param_);
144 return AVSESSION_SUCCESS;
145 }
146 // LCOV_EXCL_STOP
147
SetForwardTime(int64_t forwardTime)148 int32_t AVControlCommand::SetForwardTime(int64_t forwardTime)
149 {
150 SLOGD("SetForwardTime with time %{public}jd", static_cast<int64_t>(forwardTime));
151 if (forwardTime <= 0) {
152 SLOGE("SetForwardTime error");
153 return ERR_INVALID_PARAM;
154 }
155 param_ = forwardTime;
156 return AVSESSION_SUCCESS;
157 }
158
159 // LCOV_EXCL_START
GetForwardTime(int64_t & forwardTime) const160 int32_t AVControlCommand::GetForwardTime(int64_t& forwardTime) const
161 {
162 if (!std::holds_alternative<int64_t>(param_)) {
163 SLOGE("GetForwardTime error");
164 return AVSESSION_ERROR;
165 }
166 forwardTime = std::get<int64_t>(param_);
167 SLOGE("GetForwardTime with time %{public}jd", static_cast<int64_t>(forwardTime));
168 return AVSESSION_SUCCESS;
169 }
170 // LCOV_EXCL_STOP
171
SetRewindTime(int64_t rewindTime)172 int32_t AVControlCommand::SetRewindTime(int64_t rewindTime)
173 {
174 SLOGE("SetRewindTime with time %{public}jd", static_cast<int64_t>(rewindTime));
175 if (rewindTime < 0) {
176 SLOGE("SetRewindTime error");
177 return ERR_INVALID_PARAM;
178 }
179 param_ = rewindTime;
180 return AVSESSION_SUCCESS;
181 }
182
183 // LCOV_EXCL_START
GetRewindTime(int64_t & rewindTime) const184 int32_t AVControlCommand::GetRewindTime(int64_t& rewindTime) const
185 {
186 if (!std::holds_alternative<int64_t>(param_)) {
187 SLOGE("GetRewindTime error");
188 return AVSESSION_ERROR;
189 }
190 rewindTime = std::get<int64_t>(param_);
191 SLOGE("GetRewindTime with time %{public}jd", static_cast<int64_t>(rewindTime));
192 return AVSESSION_SUCCESS;
193 }
194 // LCOV_EXCL_STOP
195
SetSeekTime(int64_t time)196 int32_t AVControlCommand::SetSeekTime(int64_t time)
197 {
198 if (time < 0) {
199 return ERR_INVALID_PARAM;
200 }
201 param_ = time;
202 return AVSESSION_SUCCESS;
203 }
204
205 // LCOV_EXCL_START
GetSeekTime(int64_t & time) const206 int32_t AVControlCommand::GetSeekTime(int64_t& time) const
207 {
208 if (!std::holds_alternative<int64_t>(param_)) {
209 return AVSESSION_ERROR;
210 }
211 time = std::get<int64_t>(param_);
212 return AVSESSION_SUCCESS;
213 }
214 // LCOV_EXCL_STOP
215
SetLoopMode(int32_t mode)216 int32_t AVControlCommand::SetLoopMode(int32_t mode)
217 {
218 if (mode < AVPlaybackState::LOOP_MODE_UNDEFINED || mode > AVPlaybackState::LOOP_MODE_CUSTOM) {
219 return ERR_INVALID_PARAM;
220 }
221 param_ = mode;
222 return AVSESSION_SUCCESS;
223 }
224
225 // LCOV_EXCL_START
GetLoopMode(int32_t & mode) const226 int32_t AVControlCommand::GetLoopMode(int32_t& mode) const
227 {
228 if (!std::holds_alternative<int32_t>(param_)) {
229 return AVSESSION_ERROR;
230 }
231 mode = std::get<int32_t>(param_);
232 return AVSESSION_SUCCESS;
233 }
234 // LCOV_EXCL_STOP
235
SetAssetId(const std::string & assetId)236 int32_t AVControlCommand::SetAssetId(const std::string& assetId)
237 {
238 if (assetId.empty()) {
239 return ERR_INVALID_PARAM;
240 }
241 param_ = assetId;
242 return AVSESSION_SUCCESS;
243 }
244
245 // LCOV_EXCL_START
GetAssetId(std::string & assetId) const246 int32_t AVControlCommand::GetAssetId(std::string& assetId) const
247 {
248 if (!std::holds_alternative<std::string>(param_)) {
249 return AVSESSION_ERROR;
250 }
251 assetId = std::get<std::string>(param_);
252 return AVSESSION_SUCCESS;
253 }
254 // LCOV_EXCL_STOP
255
SetAVCallMuted(const bool isAVCallMuted)256 int32_t AVControlCommand::SetAVCallMuted(const bool isAVCallMuted)
257 {
258 param_ = isAVCallMuted;
259 return AVSESSION_SUCCESS;
260 }
261
262 // LCOV_EXCL_START
IsAVCallMuted(bool & isAVCallMuted) const263 int32_t AVControlCommand::IsAVCallMuted(bool& isAVCallMuted) const
264 {
265 if (!std::holds_alternative<bool>(param_)) {
266 return AVSESSION_ERROR;
267 }
268 isAVCallMuted = std::get<bool>(param_);
269 return AVSESSION_SUCCESS;
270 }
271 // LCOV_EXCL_STOP
272
SetPlayFromAssetId(int64_t playFromAssetId)273 int32_t AVControlCommand::SetPlayFromAssetId(int64_t playFromAssetId)
274 {
275 param_ = playFromAssetId;
276 return AVSESSION_SUCCESS;
277 }
278
279 // LCOV_EXCL_START
GetPlayFromAssetId(int64_t & playFromAssetId) const280 int32_t AVControlCommand::GetPlayFromAssetId(int64_t& playFromAssetId) const
281 {
282 if (!std::holds_alternative<int64_t>(param_)) {
283 return AVSESSION_ERROR;
284 }
285 playFromAssetId = std::get<int64_t>(param_);
286 return AVSESSION_SUCCESS;
287 }
288 // LCOV_EXCL_STOP
289 } // namespace OHOS::AVSession
290