1 /*
2 * Copyright (c) 2022 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 "rs_window_animation_stub.h"
17
18 #include "rs_iwindow_animation_finished_callback.h"
19 #include "rs_window_animation_log.h"
20 #include "rs_window_animation_target.h"
21
22 namespace OHOS {
23 namespace Rosen {
24 namespace {
25 static constexpr int MAX_FLOATING_WINDOW_NUMBER = 100;
26 }
27 const std::map<uint32_t, WindowAnimationStubFunc> RSWindowAnimationStub::stubFuncMap_{
28 std::make_pair(RSIWindowAnimationController::ON_START_APP, &RSWindowAnimationStub::StartApp),
29 std::make_pair(RSIWindowAnimationController::ON_APP_TRANSITION, &RSWindowAnimationStub::AppTransition),
30 std::make_pair(RSIWindowAnimationController::ON_APP_BACK_TRANSITION, &RSWindowAnimationStub::AppBackTransition),
31 std::make_pair(RSIWindowAnimationController::ON_MINIMIZE_WINDOW, &RSWindowAnimationStub::MinimizeWindow),
32 std::make_pair(RSIWindowAnimationController::ON_MINIMIZE_ALLWINDOW, &RSWindowAnimationStub::MinimizeAllWindow),
33 std::make_pair(RSIWindowAnimationController::ON_CLOSE_WINDOW, &RSWindowAnimationStub::CloseWindow),
34 std::make_pair(RSIWindowAnimationController::ON_SCREEN_UNLOCK, &RSWindowAnimationStub::ScreenUnlock),
35 std::make_pair(RSIWindowAnimationController::ON_WINDOW_ANIMATION_TARGETS_UPDATE,
36 &RSWindowAnimationStub::WindowAnimationTargetsUpdate),
37 std::make_pair(RSIWindowAnimationController::ON_WALLPAPER_UPDATE, &RSWindowAnimationStub::WallpaperUpdate)
38 };
39
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)40 int RSWindowAnimationStub::OnRemoteRequest(uint32_t code, MessageParcel& data,
41 MessageParcel& reply, MessageOption &option)
42 {
43 WALOGD("Window animation on remote request!");
44 if (data.ReadInterfaceToken() != GetDescriptor()) {
45 WALOGE("Failed to check interface token!");
46 return ERR_INVALID_STATE;
47 }
48
49 const auto func = stubFuncMap_.find(code);
50 if (func == stubFuncMap_.end()) {
51 WALOGE("Failed to find function handler!");
52 return ERR_UNKNOWN_TRANSACTION;
53 }
54
55 return (this->*(func->second))(data, reply);
56 }
57
StartApp(MessageParcel & data,MessageParcel & reply)58 int RSWindowAnimationStub::StartApp(MessageParcel& data, MessageParcel& reply)
59 {
60 WALOGD("Window animation start app!");
61 StartingAppType type = static_cast<StartingAppType>(data.ReadInt32());
62 sptr<RSWindowAnimationTarget> startingWindowTarget(data.ReadParcelable<RSWindowAnimationTarget>());
63 if (startingWindowTarget == nullptr) {
64 WALOGE("Failed to read starting window target!");
65 return ERR_INVALID_DATA;
66 }
67
68 sptr<IRemoteObject> finishcallbackObject = data.ReadRemoteObject();
69 sptr<RSIWindowAnimationFinishedCallback> finishedCallback =
70 iface_cast<RSIWindowAnimationFinishedCallback>(finishcallbackObject);
71 if (finishedCallback == nullptr) {
72 WALOGE("Failed to read animation finished callback!");
73 return ERR_INVALID_DATA;
74 }
75
76 OnStartApp(type, startingWindowTarget, finishedCallback);
77 return ERR_NONE;
78 }
79
AppTransition(MessageParcel & data,MessageParcel & reply)80 int RSWindowAnimationStub::AppTransition(MessageParcel& data, MessageParcel& reply)
81 {
82 WALOGD("Window animation transition!");
83 sptr<RSWindowAnimationTarget> fromWindowTarget(data.ReadParcelable<RSWindowAnimationTarget>());
84 if (fromWindowTarget == nullptr) {
85 WALOGE("Failed to read animation target from!");
86 return ERR_INVALID_DATA;
87 }
88
89 sptr<RSWindowAnimationTarget> toWindowTarget(data.ReadParcelable<RSWindowAnimationTarget>());
90 if (toWindowTarget == nullptr) {
91 WALOGE("Failed to read animation target to!");
92 return ERR_INVALID_DATA;
93 }
94
95 sptr<IRemoteObject> finishcallbackObject = data.ReadRemoteObject();
96 sptr<RSIWindowAnimationFinishedCallback> finishedCallback =
97 iface_cast<RSIWindowAnimationFinishedCallback>(finishcallbackObject);
98 if (finishedCallback == nullptr) {
99 WALOGE("Failed to read animation finished callback!");
100 return ERR_INVALID_DATA;
101 }
102
103 OnAppTransition(fromWindowTarget, toWindowTarget, finishedCallback);
104 return ERR_NONE;
105 }
106
AppBackTransition(MessageParcel & data,MessageParcel & reply)107 int RSWindowAnimationStub::AppBackTransition(MessageParcel& data, MessageParcel& reply)
108 {
109 WALOGD("Window animation back transition!");
110 sptr<RSWindowAnimationTarget> fromWindowTarget(data.ReadParcelable<RSWindowAnimationTarget>());
111 if (fromWindowTarget == nullptr) {
112 WALOGE("Failed to read animation target from!");
113 return ERR_INVALID_DATA;
114 }
115
116 sptr<RSWindowAnimationTarget> toWindowTarget(data.ReadParcelable<RSWindowAnimationTarget>());
117 if (toWindowTarget == nullptr) {
118 WALOGE("Failed to read animation target to!");
119 return ERR_INVALID_DATA;
120 }
121
122 sptr<IRemoteObject> finishcallbackObject = data.ReadRemoteObject();
123 sptr<RSIWindowAnimationFinishedCallback> finishedCallback =
124 iface_cast<RSIWindowAnimationFinishedCallback>(finishcallbackObject);
125 if (finishedCallback == nullptr) {
126 WALOGE("Failed to read animation finished callback!");
127 return ERR_INVALID_DATA;
128 }
129
130 OnAppBackTransition(fromWindowTarget, toWindowTarget, finishedCallback);
131 return ERR_NONE;
132 }
133
MinimizeWindow(MessageParcel & data,MessageParcel & reply)134 int RSWindowAnimationStub::MinimizeWindow(MessageParcel& data, MessageParcel& reply)
135 {
136 WALOGD("Window animation minimize window!");
137 sptr<RSWindowAnimationTarget> minimizingWindow(data.ReadParcelable<RSWindowAnimationTarget>());
138 if (minimizingWindow == nullptr) {
139 WALOGE("Failed to read minimizing window!");
140 return ERR_INVALID_DATA;
141 }
142
143 sptr<IRemoteObject> finishcallbackObject = data.ReadRemoteObject();
144 sptr<RSIWindowAnimationFinishedCallback> finishedCallback =
145 iface_cast<RSIWindowAnimationFinishedCallback>(finishcallbackObject);
146 if (finishedCallback == nullptr) {
147 WALOGE("Failed to read animation finished callback!");
148 return ERR_INVALID_DATA;
149 }
150
151 OnMinimizeWindow(minimizingWindow, finishedCallback);
152 return ERR_NONE;
153 }
154
MinimizeAllWindow(MessageParcel & data,MessageParcel & reply)155 int RSWindowAnimationStub::MinimizeAllWindow(MessageParcel& data, MessageParcel& reply)
156 {
157 WALOGD("Window animation minimize all window!");
158 size_t dataCount = data.ReadUint32();
159 std::vector<sptr<RSWindowAnimationTarget>> minimizingWindows;
160 for (size_t i = 0; i < dataCount; i++) {
161 sptr<RSWindowAnimationTarget> minimizingWindow(data.ReadParcelable<RSWindowAnimationTarget>());
162 if (minimizingWindow == nullptr) {
163 WALOGE("Failed to read minimizing window!");
164 return ERR_INVALID_DATA;
165 }
166 minimizingWindows.push_back(minimizingWindow);
167 }
168
169 sptr<IRemoteObject> finishcallbackObject = data.ReadRemoteObject();
170 sptr<RSIWindowAnimationFinishedCallback> finishedCallback =
171 iface_cast<RSIWindowAnimationFinishedCallback>(finishcallbackObject);
172 if (finishedCallback == nullptr) {
173 WALOGE("Failed to read animation finished callback!");
174 return ERR_INVALID_DATA;
175 }
176
177 OnMinimizeAllWindow(minimizingWindows, finishedCallback);
178 return ERR_NONE;
179 }
180
CloseWindow(MessageParcel & data,MessageParcel & reply)181 int RSWindowAnimationStub::CloseWindow(MessageParcel& data, MessageParcel& reply)
182 {
183 WALOGD("Window animation close window!");
184 sptr<RSWindowAnimationTarget> closingWindow(data.ReadParcelable<RSWindowAnimationTarget>());
185 if (closingWindow == nullptr) {
186 WALOGE("Failed to read closing window!");
187 return ERR_INVALID_DATA;
188 }
189
190 sptr<IRemoteObject> finishcallbackObject = data.ReadRemoteObject();
191 sptr<RSIWindowAnimationFinishedCallback> finishedCallback =
192 iface_cast<RSIWindowAnimationFinishedCallback>(finishcallbackObject);
193 if (finishedCallback == nullptr) {
194 WALOGE("Failed to read animation finished callback!");
195 return ERR_INVALID_DATA;
196 }
197
198 OnCloseWindow(closingWindow, finishedCallback);
199 return ERR_NONE;
200 }
201
ScreenUnlock(MessageParcel & data,MessageParcel & reply)202 int RSWindowAnimationStub::ScreenUnlock(MessageParcel& data, MessageParcel& reply)
203 {
204 WALOGD("Window animation screen unlock!");
205 sptr<IRemoteObject> finishcallbackObject = data.ReadRemoteObject();
206 sptr<RSIWindowAnimationFinishedCallback> finishedCallback =
207 iface_cast<RSIWindowAnimationFinishedCallback>(finishcallbackObject);
208 if (finishedCallback == nullptr) {
209 WALOGE("Failed to read animation finished callback!");
210 return ERR_INVALID_DATA;
211 }
212
213 OnScreenUnlock(finishedCallback);
214 return ERR_NONE;
215 }
216
WindowAnimationTargetsUpdate(MessageParcel & data,MessageParcel & reply)217 int RSWindowAnimationStub::WindowAnimationTargetsUpdate(MessageParcel& data, MessageParcel& reply)
218 {
219 WALOGD("Window animation targets update!");
220 sptr<RSWindowAnimationTarget> fullScreenWindowTarget = nullptr;
221 if (data.ReadBool()) {
222 fullScreenWindowTarget = data.ReadParcelable<RSWindowAnimationTarget>();
223 }
224
225 size_t floatWindowSize = data.ReadUint32();
226 if (floatWindowSize > MAX_FLOATING_WINDOW_NUMBER) {
227 WALOGE("Floating windows are too much!");
228 return ERR_INVALID_DATA;
229 }
230 std::vector<sptr<RSWindowAnimationTarget>> floatingWindowTargets;
231 for (size_t i = 0; i < floatWindowSize; i++) {
232 sptr<RSWindowAnimationTarget> floatingWindowTarget(data.ReadParcelable<RSWindowAnimationTarget>());
233 if (floatingWindowTarget == nullptr) {
234 WALOGE("Failed to read floating window animation window!");
235 return ERR_INVALID_DATA;
236 }
237 floatingWindowTargets.push_back(floatingWindowTarget);
238 }
239
240 OnWindowAnimationTargetsUpdate(fullScreenWindowTarget, floatingWindowTargets);
241 return ERR_NONE;
242 }
243
WallpaperUpdate(MessageParcel & data,MessageParcel & reply)244 int RSWindowAnimationStub::WallpaperUpdate(MessageParcel& data, MessageParcel& reply)
245 {
246 WALOGD("Window animation wallpaper update!");
247 sptr<RSWindowAnimationTarget> wallpaperTarget(data.ReadParcelable<RSWindowAnimationTarget>());
248 OnWallpaperUpdate(wallpaperTarget);
249 return ERR_NONE;
250 }
251 } // namespace Rosen
252 } // namespace OHOS
253