1 /*
2 * Copyright (c) 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 "avcast_control_command.h"
17 #include "avplayback_state.h"
18 #include "avsession_errors.h"
19 #include "avsession_log.h"
20
21 namespace OHOS::AVSession {
AVCastControlCommand()22 AVCastControlCommand::AVCastControlCommand()
23 : cmd_(CAST_CONTROL_CMD_INVALID)
24 {
25 }
26
~AVCastControlCommand()27 AVCastControlCommand::~AVCastControlCommand()
28 {
29 }
30
Unmarshalling(Parcel & data)31 AVCastControlCommand *AVCastControlCommand::Unmarshalling(Parcel& data)
32 {
33 auto result = new (std::nothrow) AVCastControlCommand();
34 if (result != nullptr) {
35 int32_t cmd = data.ReadInt32();
36 result->SetCommand(cmd);
37 switch (cmd) {
38 case CAST_CONTROL_CMD_FAST_FORWARD:
39 result->SetForwardTime(data.ReadInt32());
40 break;
41 case CAST_CONTROL_CMD_REWIND:
42 result->SetRewindTime(data.ReadInt32());
43 break;
44 case CAST_CONTROL_CMD_SEEK:
45 result->SetSeekTime(data.ReadInt32());
46 break;
47 case CAST_CONTROL_CMD_SET_VOLUME:
48 result->SetVolume(data.ReadInt32());
49 break;
50 case CAST_CONTROL_CMD_SET_SPEED:
51 result->SetSpeed(data.ReadInt32());
52 break;
53 case CAST_CONTROL_CMD_SET_LOOP_MODE:
54 result->SetLoopMode(data.ReadInt32());
55 break;
56 default:
57 break;
58 }
59 }
60 return result;
61 }
62
Marshalling(Parcel & parcel) const63 bool AVCastControlCommand::Marshalling(Parcel& parcel) const
64 {
65 if (!parcel.WriteInt32(cmd_)) {
66 return false;
67 }
68 switch (cmd_) {
69 case CAST_CONTROL_CMD_FAST_FORWARD:
70 CHECK_AND_RETURN_RET_LOG(std::holds_alternative<int32_t>(param_)
71 && parcel.WriteInt32(std::get<int32_t>(param_)), false, "write fast forward time failed");
72 break;
73 case CAST_CONTROL_CMD_REWIND:
74 CHECK_AND_RETURN_RET_LOG(std::holds_alternative<int32_t>(param_)
75 && parcel.WriteInt32(std::get<int32_t>(param_)), false, "write rewind time failed");
76 break;
77 case CAST_CONTROL_CMD_SEEK:
78 CHECK_AND_RETURN_RET_LOG(std::holds_alternative<int32_t>(param_)
79 && parcel.WriteInt64(std::get<int32_t>(param_)), false, "write seek time failed");
80 break;
81 case CAST_CONTROL_CMD_SET_VOLUME:
82 CHECK_AND_RETURN_RET_LOG(std::holds_alternative<int32_t>(param_)
83 && parcel.WriteInt32(std::get<int32_t>(param_)), false, "write volume failed");
84 break;
85 case CAST_CONTROL_CMD_SET_SPEED:
86 CHECK_AND_RETURN_RET_LOG(std::holds_alternative<int32_t>(param_)
87 && parcel.WriteInt32(std::get<int32_t>(param_)), false, "write speed failed");
88 break;
89 case CAST_CONTROL_CMD_SET_LOOP_MODE:
90 CHECK_AND_RETURN_RET_LOG(std::holds_alternative<int32_t>(param_)
91 && parcel.WriteInt32(std::get<int32_t>(param_)), false, "write loop mode failed");
92 break;
93 default:
94 SLOGD("Param of AVCastCommand is not exist");
95 break;
96 }
97 return true;
98 }
99
IsValid() const100 bool AVCastControlCommand::IsValid() const
101 {
102 return cmd_ > CAST_CONTROL_CMD_INVALID && cmd_ < CAST_CONTROL_CMD_MAX;
103 }
104
SetCommand(int32_t cmd)105 int32_t AVCastControlCommand::SetCommand(int32_t cmd)
106 {
107 if (cmd <= CAST_CONTROL_CMD_INVALID || cmd >= CAST_CONTROL_CMD_MAX) {
108 return ERR_INVALID_PARAM;
109 }
110 cmd_ = cmd;
111 return AVSESSION_SUCCESS;
112 }
113
GetCommand() const114 int32_t AVCastControlCommand::GetCommand() const
115 {
116 return cmd_;
117 }
118
SetForwardTime(int32_t forwardTime)119 int32_t AVCastControlCommand::SetForwardTime(int32_t forwardTime)
120 {
121 if (forwardTime <= 0) {
122 return ERR_INVALID_PARAM;
123 }
124 param_ = forwardTime;
125 return AVSESSION_SUCCESS;
126 }
127
GetForwardTime(int32_t & forwardTime) const128 int32_t AVCastControlCommand::GetForwardTime(int32_t& forwardTime) const
129 {
130 if (!std::holds_alternative<int32_t>(param_)) {
131 return AVSESSION_ERROR;
132 }
133 forwardTime = std::get<int32_t>(param_);
134 return AVSESSION_SUCCESS;
135 }
136
SetRewindTime(int32_t rewindTime)137 int32_t AVCastControlCommand::SetRewindTime(int32_t rewindTime)
138 {
139 if (rewindTime < 0) {
140 return ERR_INVALID_PARAM;
141 }
142 param_ = rewindTime;
143 return AVSESSION_SUCCESS;
144 }
145
GetRewindTime(int32_t & rewindTime) const146 int32_t AVCastControlCommand::GetRewindTime(int32_t& rewindTime) const
147 {
148 if (!std::holds_alternative<int32_t>(param_)) {
149 return AVSESSION_ERROR;
150 }
151 rewindTime = std::get<int32_t>(param_);
152 return AVSESSION_SUCCESS;
153 }
154
SetSeekTime(int32_t seekTime)155 int32_t AVCastControlCommand::SetSeekTime(int32_t seekTime)
156 {
157 if (seekTime < 0) {
158 return ERR_INVALID_PARAM;
159 }
160 param_ = seekTime;
161 return AVSESSION_SUCCESS;
162 }
163
GetSeekTime(int32_t & seekTime) const164 int32_t AVCastControlCommand::GetSeekTime(int32_t& seekTime) const
165 {
166 if (!std::holds_alternative<int32_t>(param_)) {
167 return AVSESSION_ERROR;
168 }
169 seekTime = std::get<int32_t>(param_);
170 return AVSESSION_SUCCESS;
171 }
172
SetVolume(int32_t volume)173 int32_t AVCastControlCommand::SetVolume(int32_t volume)
174 {
175 param_ = volume;
176 return AVSESSION_SUCCESS;
177 }
178
GetVolume(int32_t & volume) const179 int32_t AVCastControlCommand::GetVolume(int32_t& volume) const
180 {
181 if (!std::holds_alternative<int32_t>(param_)) {
182 return AVSESSION_ERROR;
183 }
184 volume = std::get<int32_t>(param_);
185 return AVSESSION_SUCCESS;
186 }
187
SetSpeed(int32_t speed)188 int32_t AVCastControlCommand::SetSpeed(int32_t speed)
189 {
190 if (speed < 0) {
191 return ERR_INVALID_PARAM;
192 }
193 param_ = speed;
194 return AVSESSION_SUCCESS;
195 }
196
GetSpeed(int32_t & speed) const197 int32_t AVCastControlCommand::GetSpeed(int32_t& speed) const
198 {
199 if (!std::holds_alternative<int32_t>(param_)) {
200 return AVSESSION_ERROR;
201 }
202 speed = std::get<int32_t>(param_);
203 return AVSESSION_SUCCESS;
204 }
205
SetLoopMode(int32_t loopMode)206 int32_t AVCastControlCommand::SetLoopMode(int32_t loopMode)
207 {
208 if (loopMode < 0) {
209 return ERR_INVALID_PARAM;
210 }
211 param_ = loopMode;
212 return AVSESSION_SUCCESS;
213 }
214
GetLoopMode(int32_t & loopMode) const215 int32_t AVCastControlCommand::GetLoopMode(int32_t& loopMode) const
216 {
217 if (!std::holds_alternative<int32_t>(param_)) {
218 return AVSESSION_ERROR;
219 }
220 loopMode = std::get<int32_t>(param_);
221 return AVSESSION_SUCCESS;
222 }
223 } // namespace OHOS::AVSession
224