1 /*
2 * Copyright (c) 2021 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 "core/components/common/properties/page_transition_option.h"
17
18 #include "base/utils/device_type.h"
19 #include "base/utils/system_properties.h"
20 #include "core/animation/animator.h"
21 #include "core/animation/curve_animation.h"
22 #include "core/animation/property_animatable.h"
23
24 namespace OHOS::Ace {
25 namespace {
26
27 constexpr float TRANSITION_FACTOR = 0.8f;
28 constexpr float TRANSITION_FACTOR_IN = 0.5f;
29 constexpr float TRANSITION_FACTOR_OUT = 0.2f;
30 constexpr float BLACK_OPACITY = 0.3f;
31 constexpr float SHARED_TRANSITION_ENTER_START_OFFSET_X = 68.0f;
32
CreateSharedInOption(bool isRightToLeft,double deviceViewScale,double deviceWidth,TweenOption & option)33 void CreateSharedInOption(bool isRightToLeft, double deviceViewScale, double deviceWidth, TweenOption& option)
34 {
35 // opacity. parameters only have local meaning, no need to define const variables.
36 auto opacityKeyframe1 = AceType::MakeRefPtr<Keyframe<float>>(0.0f, 0.0f); // start with invisible
37 auto opacityKeyframe2 = AceType::MakeRefPtr<Keyframe<float>>(0.428f, 0.0f); // invisible at 42.8% of total duration
38 opacityKeyframe2->SetCurve(Curves::LINEAR);
39 auto opacityKeyframe3 = AceType::MakeRefPtr<Keyframe<float>>(1.0f, 1.0f); // finally visible
40 opacityKeyframe3->SetCurve(Curves::FRICTION);
41 auto opacityAnimation = AceType::MakeRefPtr<KeyframeAnimation<float>>();
42 opacityAnimation->AddKeyframe(opacityKeyframe1);
43 opacityAnimation->AddKeyframe(opacityKeyframe2);
44 opacityAnimation->AddKeyframe(opacityKeyframe3);
45 option.SetOpacityAnimation(opacityAnimation);
46 // translate. parameters only have local meaning, no need to define const variables.
47 double startX = SHARED_TRANSITION_ENTER_START_OFFSET_X / deviceViewScale - deviceWidth;
48 double endX = 0.0;
49 if (isRightToLeft) {
50 startX = -1.0 * startX;
51 endX = 0.0;
52 }
53 auto translateXKeyframe1 =
54 AceType::MakeRefPtr<Keyframe<DimensionOffset>>(0.0f, Offset(startX, 0)); // start with startX
55 auto translateXKeyframe2 =
56 AceType::MakeRefPtr<Keyframe<DimensionOffset>>(0.428f, Offset(startX, 0)); // start at 42.8% of total duration
57 translateXKeyframe2->SetCurve(Curves::LINEAR);
58 auto translateXKeyframe3 = AceType::MakeRefPtr<Keyframe<DimensionOffset>>(1.0f, Offset(endX, 0)); // finally at endX
59 translateXKeyframe3->SetCurve(Curves::FRICTION);
60 auto translateXAnimation = AceType::MakeRefPtr<KeyframeAnimation<DimensionOffset>>();
61 translateXAnimation->AddKeyframe(translateXKeyframe1);
62 translateXAnimation->AddKeyframe(translateXKeyframe2);
63 translateXAnimation->AddKeyframe(translateXKeyframe3);
64 option.SetTranslateAnimations(AnimationType::TRANSLATE_X, translateXAnimation);
65 }
66
CreateSharedOutOption(TweenOption & option)67 void CreateSharedOutOption(TweenOption& option)
68 {
69 // opacity. parameters only have local meaning, no need to define const variables.
70 auto opacityKeyframe1 = AceType::MakeRefPtr<Keyframe<float>>(0.0f, 1.0f); // start with invisible
71 auto opacityKeyframe2 = AceType::MakeRefPtr<Keyframe<float>>(0.714f, 0.0f); // invisible at 71.4% of total duration
72 opacityKeyframe2->SetCurve(Curves::FRICTION);
73 auto opacityKeyframe3 = AceType::MakeRefPtr<Keyframe<float>>(1.0f, 0.0f); // finally visible
74 opacityKeyframe3->SetCurve(Curves::LINEAR);
75 auto opacityAnimation = AceType::MakeRefPtr<KeyframeAnimation<float>>();
76 opacityAnimation->AddKeyframe(opacityKeyframe1);
77 opacityAnimation->AddKeyframe(opacityKeyframe2);
78 opacityAnimation->AddKeyframe(opacityKeyframe3);
79 option.SetOpacityAnimation(opacityAnimation);
80 }
81
82 // Follow Watch's UI Standard.
CreateSharedStaticOption(TweenOption & option)83 void CreateSharedStaticOption(TweenOption& option)
84 {
85 // opacity. parameters only have local meaning, no need to define const variables.
86 auto opacityKeyframe1 = AceType::MakeRefPtr<Keyframe<float>>(0.0f, 0.0f); // start with invisible
87 auto opacityKeyframe2 = AceType::MakeRefPtr<Keyframe<float>>(0.428f, 0.0f); // invisible at 42.8% of total duration
88 opacityKeyframe2->SetCurve(Curves::LINEAR);
89 auto opacityKeyframe3 = AceType::MakeRefPtr<Keyframe<float>>(1.0f, 1.0f); // finally visible
90 opacityKeyframe3->SetCurve(Curves::FRICTION);
91 auto opacityAnimation = AceType::MakeRefPtr<KeyframeAnimation<float>>();
92 opacityAnimation->AddKeyframe(opacityKeyframe1);
93 opacityAnimation->AddKeyframe(opacityKeyframe2);
94 opacityAnimation->AddKeyframe(opacityKeyframe3);
95 option.SetOpacityAnimation(opacityAnimation);
96 }
97
98 } // namespace
99
100 constexpr int32_t TRANSITION_PHONE_DURATION = 300; // 0.3s
101 constexpr int32_t TRANSITION_WATCH_DURATION = 300; // 0.3s
102 constexpr int32_t TRANSITION_TV_DURATION = 1000; // 1s
103 constexpr double TRANSITION_DEFAULT_WIDTH = 750.0;
104 constexpr double TRANSITION_DEFAULT_HEIGHT = 1900.0;
105 constexpr double TRANSITION_DEFAULT_CORNER_RADIUS = 0.0;
106
TransitionTweenOption(bool isRightToLeft,const WeakPtr<PipelineContext> & context)107 TransitionTweenOption::TransitionTweenOption(bool isRightToLeft, const WeakPtr<PipelineContext>& context)
108 {
109 auto pipelineContext = context.Upgrade();
110 if (pipelineContext) {
111 auto deviceWidth = pipelineContext->GetStageRect().Width();
112 deviceWidth_ = deviceWidth > 0.0 ? deviceWidth : deviceWidth_;
113 auto deviceHeight = pipelineContext->GetStageRect().Height();
114 deviceHeight_ = deviceHeight > 0.0 ? deviceHeight : deviceHeight_;
115 auto viewScale = pipelineContext->GetViewScale();
116 deviceViewScale_ = viewScale > 0.0 ? viewScale : deviceViewScale_;
117 isRightToLeft_ = isRightToLeft;
118 windowModal_ = pipelineContext->GetWindowModal();
119 }
120 }
121
GetTransitionContentInOption() const122 const TweenOption& TransitionTweenOption::GetTransitionContentInOption() const
123 {
124 return contentInOption_;
125 }
126
GetTransitionContentOutOption() const127 const TweenOption& TransitionTweenOption::GetTransitionContentOutOption() const
128 {
129 return contentOutOption_;
130 }
131
GetTransitionBackgroundInOption() const132 const TweenOption& TransitionTweenOption::GetTransitionBackgroundInOption() const
133 {
134 return backgroundInOption_;
135 }
136
GetTransitionBackgroundOutOption() const137 const TweenOption& TransitionTweenOption::GetTransitionBackgroundOutOption() const
138 {
139 return backgroundOutOption_;
140 }
141
GetTransitionFrontDecorationOption() const142 const TweenOption& TransitionTweenOption::GetTransitionFrontDecorationOption() const
143 {
144 return frontDecorationOption_;
145 }
146
GetSharedTransitionFrontDecorationOption() const147 const TweenOption& TransitionTweenOption::GetSharedTransitionFrontDecorationOption() const
148 {
149 return sharedFrontDecorationOption_;
150 }
151
GetSharedInOption() const152 const TweenOption& TransitionTweenOption::GetSharedInOption() const
153 {
154 return sharedTransitionInOption_;
155 }
156
GetSharedOutOption() const157 const TweenOption& TransitionTweenOption::GetSharedOutOption() const
158 {
159 return sharedTransitionOutOption_;
160 }
161
TransitionTvTweenOption(bool isRightToLeft,const WeakPtr<PipelineContext> & context)162 TransitionTvTweenOption::TransitionTvTweenOption(bool isRightToLeft, const WeakPtr<PipelineContext>& context)
163 : TransitionTweenOption(isRightToLeft, context)
164 {
165 CreateTransitionInOption();
166 CreateTransitionOutOption();
167 // Currently, Tv Do not have UI standard, no need to create special shared transition.
168 }
169
CreateTransitionInOption()170 void TransitionTvTweenOption::CreateTransitionInOption()
171 {
172 CreateTransitionInContentOption();
173 CreateTransitionInBackgroundOption();
174 }
175
CreateTransitionInContentOption()176 void TransitionTvTweenOption::CreateTransitionInContentOption()
177 {
178 // content opacity. parameters only have local meaning, no need to define const variables.
179 auto opacityKeyframe1 = AceType::MakeRefPtr<Keyframe<float>>(0.0f, 0.0f); // start with invisible
180 auto opacityKeyframe2 = AceType::MakeRefPtr<Keyframe<float>>(0.55f, 0.0f); // invisible at 55% of total duration
181 opacityKeyframe2->SetCurve(Curves::FRICTION);
182 auto opacityKeyframe3 = AceType::MakeRefPtr<Keyframe<float>>(1.0f, 1.0f); // finally visible
183 opacityKeyframe3->SetCurve(Curves::FRICTION);
184 auto opacityAnimation = AceType::MakeRefPtr<KeyframeAnimation<float>>();
185 opacityAnimation->AddKeyframe(opacityKeyframe1);
186 opacityAnimation->AddKeyframe(opacityKeyframe2);
187 opacityAnimation->AddKeyframe(opacityKeyframe3);
188 contentInOption_.SetOpacityAnimation(opacityAnimation);
189
190 // content scale. parameters only have local meaning, no need to define const variables.
191 auto scaleKeyframe1 = AceType::MakeRefPtr<Keyframe<float>>(0.0f, 0.0f); // start with invisible
192 auto scaleKeyframe2 = AceType::MakeRefPtr<Keyframe<float>>(0.55f, 0.9f); // 90% scale at 55% of total duration
193 scaleKeyframe2->SetCurve(Curves::FRICTION);
194 auto scaleKeyframe3 = AceType::MakeRefPtr<Keyframe<float>>(1.0f, 1.0f); // finally 100% scale
195 scaleKeyframe3->SetCurve(Curves::FRICTION);
196 auto scaleAnimation = AceType::MakeRefPtr<KeyframeAnimation<float>>();
197 scaleAnimation->AddKeyframe(scaleKeyframe1);
198 scaleAnimation->AddKeyframe(scaleKeyframe2);
199 scaleAnimation->AddKeyframe(scaleKeyframe3);
200 contentInOption_.SetTransformFloatAnimation(AnimationType::SCALE, scaleAnimation);
201 contentInOption_.SetDuration(TRANSITION_TV_DURATION);
202 }
203
CreateTransitionInBackgroundOption()204 void TransitionTvTweenOption::CreateTransitionInBackgroundOption()
205 {
206 // background opacity. parameters only have local meaning, no need to define const variables.
207 auto opacityKeyframe1 = AceType::MakeRefPtr<Keyframe<float>>(0.0f, 0.0f); // start with invisible
208 auto opacityKeyframe2 = AceType::MakeRefPtr<Keyframe<float>>(0.5f, 0.0f); // invisible at 50% of total duration
209 opacityKeyframe2->SetCurve(Curves::FRICTION);
210 auto opacityKeyframe3 = AceType::MakeRefPtr<Keyframe<float>>(0.95f, 1.0f); // visible at 95% of total duration
211 opacityKeyframe3->SetCurve(Curves::FRICTION);
212 auto opacityKeyframe4 = AceType::MakeRefPtr<Keyframe<float>>(1.0f, 1.0f); // finally visible
213 opacityKeyframe4->SetCurve(Curves::FRICTION);
214 auto opacityAnimation = AceType::MakeRefPtr<KeyframeAnimation<float>>();
215 opacityAnimation->AddKeyframe(opacityKeyframe1);
216 opacityAnimation->AddKeyframe(opacityKeyframe2);
217 opacityAnimation->AddKeyframe(opacityKeyframe3);
218 opacityAnimation->AddKeyframe(opacityKeyframe4);
219 backgroundInOption_.SetOpacityAnimation(opacityAnimation);
220
221 // background scale. parameters only have local meaning, no need to define const variables.
222 auto scaleKeyframe1 = AceType::MakeRefPtr<Keyframe<float>>(0.0f, 0.0f); // start with invisible
223 auto scaleKeyframe2 = AceType::MakeRefPtr<Keyframe<float>>(0.5f, 1.1f); // 110% scale at 50% of total duration
224 scaleKeyframe2->SetCurve(Curves::FRICTION);
225 auto scaleKeyframe3 = AceType::MakeRefPtr<Keyframe<float>>(0.95f, 1.0f); // 100% scale at 95% of total duration
226 scaleKeyframe3->SetCurve(Curves::FRICTION);
227 auto scaleKeyframe4 = AceType::MakeRefPtr<Keyframe<float>>(1.0f, 1.0f); // finally 100% scale
228 scaleKeyframe4->SetCurve(Curves::FRICTION);
229 auto scaleAnimation = AceType::MakeRefPtr<KeyframeAnimation<float>>();
230 scaleAnimation->AddKeyframe(scaleKeyframe1);
231 scaleAnimation->AddKeyframe(scaleKeyframe2);
232 scaleAnimation->AddKeyframe(scaleKeyframe3);
233 scaleAnimation->AddKeyframe(scaleKeyframe4);
234 backgroundInOption_.SetTransformFloatAnimation(AnimationType::SCALE, scaleAnimation);
235 }
236
CreateTransitionOutOption()237 void TransitionTvTweenOption::CreateTransitionOutOption()
238 {
239 CreateTransitionOutContentOption();
240 CreateTransitionOutBackgroundOption();
241 }
242
CreateTransitionOutContentOption()243 void TransitionTvTweenOption::CreateTransitionOutContentOption()
244 {
245 CreatTransitionOutOption(contentOutOption_);
246 }
247
CreateTransitionOutBackgroundOption()248 void TransitionTvTweenOption::CreateTransitionOutBackgroundOption()
249 {
250 CreatTransitionOutOption(backgroundOutOption_);
251 }
252
CreatTransitionOutOption(TweenOption & option)253 void TransitionTvTweenOption::CreatTransitionOutOption(TweenOption& option)
254 {
255 // out opacity. parameters only have local meaning, no need to define const variables.
256 auto opacityKeyframe1 = AceType::MakeRefPtr<Keyframe<float>>(0.0f, 1.0f); // start with visible
257 auto opacityKeyframe2 = AceType::MakeRefPtr<Keyframe<float>>(0.1f, 1.0f); // visible at 10% of total duration
258 opacityKeyframe2->SetCurve(Curves::FRICTION);
259 auto opacityKeyframe3 = AceType::MakeRefPtr<Keyframe<float>>(0.55f, 0.0f); // invisible at 55% of total duration
260 opacityKeyframe3->SetCurve(Curves::FRICTION);
261 auto opacityKeyframe4 = AceType::MakeRefPtr<Keyframe<float>>(1.0f, 0.0f); // finally invisible
262 opacityKeyframe4->SetCurve(Curves::FRICTION);
263 auto opacityAnimation = AceType::MakeRefPtr<KeyframeAnimation<float>>();
264 opacityAnimation->AddKeyframe(opacityKeyframe1);
265 opacityAnimation->AddKeyframe(opacityKeyframe2);
266 opacityAnimation->AddKeyframe(opacityKeyframe3);
267 opacityAnimation->AddKeyframe(opacityKeyframe4);
268 option.SetOpacityAnimation(opacityAnimation);
269
270 // out scale. parameters only have local meaning, no need to define const variables.
271 auto scaleKeyframe1 = AceType::MakeRefPtr<Keyframe<float>>(0.0f, 1.0f); // 100% scale at start
272 auto scaleKeyframe2 = AceType::MakeRefPtr<Keyframe<float>>(0.1f, 1.0f); // 100% scale at 10% of total duration
273 scaleKeyframe2->SetCurve(Curves::FRICTION);
274 auto scaleKeyframe3 = AceType::MakeRefPtr<Keyframe<float>>(0.55f, 1.1f); // 110% scale at 55% of total duration
275 scaleKeyframe3->SetCurve(Curves::FRICTION);
276 auto scaleKeyframe4 = AceType::MakeRefPtr<Keyframe<float>>(1.0f, 1.0f); // 100% scale at 100% of total duration
277 scaleKeyframe4->SetCurve(Curves::FRICTION);
278 auto scaleAnimation = AceType::MakeRefPtr<KeyframeAnimation<float>>();
279 scaleAnimation->AddKeyframe(scaleKeyframe1);
280 scaleAnimation->AddKeyframe(scaleKeyframe2);
281 scaleAnimation->AddKeyframe(scaleKeyframe3);
282 scaleAnimation->AddKeyframe(scaleKeyframe4);
283 option.SetTransformFloatAnimation(AnimationType::SCALE, scaleAnimation);
284 option.SetDuration(TRANSITION_TV_DURATION);
285 }
286
CreateTransitionTweenOption(DeviceType deviceType,TransitionEvent event,bool isRightToLeft,const RRect & rrect,const WeakPtr<PipelineContext> & context)287 RefPtr<TransitionTweenOption> TransitionTweenOptionFactory::CreateTransitionTweenOption(
288 DeviceType deviceType, TransitionEvent event, bool isRightToLeft, const RRect& rrect,
289 const WeakPtr<PipelineContext>& context)
290 {
291 switch (deviceType) {
292 case DeviceType::PHONE:
293 if (rrect.GetRect().IsValid()) {
294 return AceType::MakeRefPtr<TransitionPhoneTweenOption>(event, isRightToLeft, rrect, context);
295 }
296 return AceType::MakeRefPtr<TransitionPhoneTweenOption>(event, isRightToLeft, context);
297 case DeviceType::TV:
298 return AceType::MakeRefPtr<TransitionTvTweenOption>(isRightToLeft, context);
299 case DeviceType::WATCH:
300 return AceType::MakeRefPtr<TransitionWatchTweenOption>(event, isRightToLeft, context);
301 default:
302 LOGE("unknown transition type: %{public}d, use default type", deviceType);
303 return AceType::MakeRefPtr<TransitionPhoneTweenOption>(event, isRightToLeft, context);
304 }
305 }
306
CreateSharedTweenOption(SharedTransitionEffectType type,TweenOption & option)307 void TransitionTweenOptionFactory::CreateSharedTweenOption(SharedTransitionEffectType type, TweenOption& option)
308 {
309 if (type == SharedTransitionEffectType::SHARED_EFFECT_STATIC) {
310 CreateSharedStaticOption(option);
311 } else {
312 LOGW("Unsupported Shared transition effect type: %{public}d", type);
313 }
314 }
315
TransitionPhoneTweenOption(TransitionEvent event,bool isRightToLeft,const WeakPtr<PipelineContext> & context)316 TransitionPhoneTweenOption::TransitionPhoneTweenOption(
317 TransitionEvent event, bool isRightToLeft, const WeakPtr<PipelineContext>& context)
318 : TransitionTweenOption(isRightToLeft, context)
319 {
320 if (windowModal_ == WindowModal::DIALOG_MODAL) {
321 CreateDialogModalTransitionInOption(event);
322 CreateDialogModalTransitionOutOption(event);
323 } else {
324 CreateTransitionInOption(event);
325 CreateTransitionOutOption(event);
326 }
327 CreateSharedInOption(isRightToLeft_, deviceViewScale_, deviceWidth_, sharedTransitionInOption_);
328 CreateSharedOutOption(sharedTransitionOutOption_);
329 // extra options for phone
330 auto widthAnimation = AceType::MakeRefPtr<CurveAnimation<float>>(deviceWidth_, deviceWidth_, Curves::FRICTION);
331 sharedTransitionOutOption_.SetPropertyAnimationFloat(PropertyAnimatableType::PROPERTY_WIDTH, widthAnimation);
332
333 auto translateAnimation = AceType::MakeRefPtr<CurveAnimation<DimensionOffset>>(
334 DimensionOffset(Offset()), DimensionOffset(Offset()), Curves::LINEAR);
335 sharedTransitionOutOption_.SetTranslateAnimations(AnimationType::TRANSLATE_X, translateAnimation);
336
337 auto colorAnimation = AceType::MakeRefPtr<CurveAnimation<Color>>(
338 Color::FromRGBO(0, 0, 0, 0.0), Color::FromRGBO(0, 0, 0, 0.0), Curves::FRICTION);
339 sharedFrontDecorationOption_.SetColorAnimation(colorAnimation);
340 sharedFrontDecorationOption_.SetIsBackground(false);
341 }
342
TransitionPhoneTweenOption(TransitionEvent event,bool isRightToLeft,const RRect & rrect,const WeakPtr<PipelineContext> & context)343 TransitionPhoneTweenOption::TransitionPhoneTweenOption(
344 TransitionEvent event, bool isRightToLeft, const RRect& rrect, const WeakPtr<PipelineContext>& context)
345 : TransitionTweenOption(isRightToLeft, context)
346 {
347 CreateCardTransitionInOption(event, rrect);
348 CreateCardTransitionOutOption(event);
349
350 CreateSharedInOption(isRightToLeft_, deviceViewScale_, deviceWidth_, sharedTransitionInOption_);
351 CreateSharedOutOption(sharedTransitionOutOption_);
352 // extra options for phone
353 auto widthAnimation = AceType::MakeRefPtr<CurveAnimation<float>>(deviceWidth_, deviceWidth_, Curves::FRICTION);
354 sharedTransitionOutOption_.SetPropertyAnimationFloat(PropertyAnimatableType::PROPERTY_WIDTH, widthAnimation);
355
356 auto translateAnimation = AceType::MakeRefPtr<CurveAnimation<DimensionOffset>>(
357 DimensionOffset(Offset()), DimensionOffset(Offset()), Curves::LINEAR);
358 sharedTransitionOutOption_.SetTranslateAnimations(AnimationType::TRANSLATE_X, translateAnimation);
359
360 auto colorAnimation = AceType::MakeRefPtr<CurveAnimation<Color>>(
361 Color::FromRGBO(0, 0, 0, 0.0), Color::FromRGBO(0, 0, 0, 0.0), Curves::FRICTION);
362 sharedFrontDecorationOption_.SetColorAnimation(colorAnimation);
363 sharedFrontDecorationOption_.SetIsBackground(false);
364 }
365
CreateDialogModalTransitionInOption(TransitionEvent event)366 void TransitionPhoneTweenOption::CreateDialogModalTransitionInOption(TransitionEvent event)
367 {
368 RefPtr<CurveAnimation<DimensionOffset>> translateAnimation;
369 if (isRightToLeft_) {
370 translateAnimation = AceType::MakeRefPtr<CurveAnimation<DimensionOffset>>(
371 DimensionOffset(Dimension(-deviceWidth_, DimensionUnit::PX), Dimension()),
372 DimensionOffset(Dimension(), Dimension()), Curves::FRICTION);
373 } else {
374 translateAnimation = AceType::MakeRefPtr<CurveAnimation<DimensionOffset>>(
375 DimensionOffset(Dimension(deviceWidth_, DimensionUnit::PX), Dimension()),
376 DimensionOffset(Dimension(), Dimension()), Curves::FRICTION);
377 }
378 contentInOption_.SetTranslateAnimations(AnimationType::TRANSLATE_X, translateAnimation);
379 contentInOption_.SetDuration(TRANSITION_PHONE_DURATION);
380 }
381
CreateTransitionInOption(TransitionEvent event)382 void TransitionPhoneTweenOption::CreateTransitionInOption(TransitionEvent event)
383 {
384 if (isRightToLeft_) {
385 auto translateAnimation = AceType::MakeRefPtr<CurveAnimation<DimensionOffset>>(
386 DimensionOffset(Dimension(-deviceWidth_ * TRANSITION_FACTOR_IN, DimensionUnit::PX), Dimension()),
387 DimensionOffset(Dimension(), Dimension()), Curves::FRICTION);
388 auto widthAnimation = AceType::MakeRefPtr<CurveAnimation<float>>(
389 deviceWidth_ * TRANSITION_FACTOR_IN, deviceWidth_, Curves::FRICTION);
390 contentInOption_.SetPropertyAnimationFloat(PropertyAnimatableType::PROPERTY_WIDTH, widthAnimation);
391 contentInOption_.SetTranslateAnimations(AnimationType::TRANSLATE_X, translateAnimation);
392 } else {
393 auto translateAnimation = AceType::MakeRefPtr<CurveAnimation<DimensionOffset>>(
394 DimensionOffset(Dimension(deviceWidth_ * TRANSITION_FACTOR_IN, DimensionUnit::PX), Dimension()),
395 DimensionOffset(Dimension(), Dimension()), Curves::FRICTION);
396 auto offsetXAnimation =
397 AceType::MakeRefPtr<CurveAnimation<float>>(deviceWidth_ * TRANSITION_FACTOR_IN, 0.0f, Curves::FRICTION);
398 auto widthAnimation = AceType::MakeRefPtr<CurveAnimation<float>>(deviceWidth_, deviceWidth_, Curves::LINEAR);
399 contentInOption_.SetPropertyAnimationFloat(PropertyAnimatableType::PROPERTY_WIDTH, widthAnimation);
400 contentInOption_.SetPropertyAnimationFloat(PropertyAnimatableType::PROPERTY_OFFSET_X, offsetXAnimation);
401 contentInOption_.SetTranslateAnimations(AnimationType::TRANSLATE_X, translateAnimation);
402 }
403 if (event == TransitionEvent::POP_START) {
404 contentInOption_.SetCurve(Curves::FAST_OUT_SLOW_IN);
405 }
406 contentInOption_.SetDuration(TRANSITION_PHONE_DURATION);
407 }
408
CreateDialogModalTransitionOutOption(TransitionEvent event)409 void TransitionPhoneTweenOption::CreateDialogModalTransitionOutOption(TransitionEvent event)
410 {
411 RefPtr<CurveAnimation<DimensionOffset>> translateAnimation;
412 if (isRightToLeft_) {
413 translateAnimation = AceType::MakeRefPtr<CurveAnimation<DimensionOffset>>(DimensionOffset(Offset()),
414 DimensionOffset(Offset(deviceWidth_, 0)), Curves::FRICTION);
415 } else {
416 translateAnimation = AceType::MakeRefPtr<CurveAnimation<DimensionOffset>>(DimensionOffset(Offset()),
417 DimensionOffset(Offset(-deviceWidth_, 0)), Curves::FRICTION);
418 }
419 auto opacityAnimation = AceType::MakeRefPtr<CurveAnimation<float>>(1.0f, 1.0f, Curves::LINEAR);
420 contentOutOption_.SetOpacityAnimation(opacityAnimation);
421 contentOutOption_.SetTranslateAnimations(AnimationType::TRANSLATE_X, translateAnimation);
422 }
423
CreateTransitionOutOption(TransitionEvent event)424 void TransitionPhoneTweenOption::CreateTransitionOutOption(TransitionEvent event)
425 {
426 if (isRightToLeft_) {
427 auto translateAnimation = AceType::MakeRefPtr<CurveAnimation<DimensionOffset>>(DimensionOffset(Offset()),
428 DimensionOffset(Offset(deviceWidth_ * TRANSITION_FACTOR_OUT, 0)), Curves::FRICTION);
429 auto offsetXAnimation =
430 AceType::MakeRefPtr<CurveAnimation<float>>(0.0f, deviceWidth_ * TRANSITION_FACTOR, Curves::FRICTION);
431 contentOutOption_.SetPropertyAnimationFloat(PropertyAnimatableType::PROPERTY_OFFSET_X, offsetXAnimation);
432 contentOutOption_.SetTranslateAnimations(AnimationType::TRANSLATE_X, translateAnimation);
433 } else {
434 auto translateAnimation = AceType::MakeRefPtr<CurveAnimation<DimensionOffset>>(DimensionOffset(Offset()),
435 DimensionOffset(Offset(-deviceWidth_ * TRANSITION_FACTOR_OUT, 0)), Curves::FRICTION);
436 auto widthAnimation = AceType::MakeRefPtr<CurveAnimation<float>>(
437 deviceWidth_, deviceWidth_ * TRANSITION_FACTOR_OUT, Curves::FRICTION);
438 contentOutOption_.SetPropertyAnimationFloat(PropertyAnimatableType::PROPERTY_WIDTH, widthAnimation);
439 contentOutOption_.SetTranslateAnimations(AnimationType::TRANSLATE_X, translateAnimation);
440 }
441 auto opacityAnimation = AceType::MakeRefPtr<CurveAnimation<float>>(1.0f, 1.0f, Curves::LINEAR);
442 contentOutOption_.SetOpacityAnimation(opacityAnimation);
443
444 auto colorAnimation = AceType::MakeRefPtr<CurveAnimation<Color>>(
445 Color::FromRGBO(0, 0, 0, 0.0), Color::FromRGBO(0, 0, 0, BLACK_OPACITY), Curves::FRICTION);
446 frontDecorationOption_.SetColorAnimation(colorAnimation);
447 frontDecorationOption_.SetIsBackground(false);
448
449 if (event == TransitionEvent::POP_START) {
450 contentOutOption_.SetCurve(Curves::FAST_OUT_SLOW_IN);
451 frontDecorationOption_.SetCurve(Curves::FAST_OUT_SLOW_IN);
452 }
453 }
454
TransitionWatchTweenOption(TransitionEvent event,bool isRightToLeft,const WeakPtr<PipelineContext> & context)455 TransitionWatchTweenOption::TransitionWatchTweenOption(
456 TransitionEvent event, bool isRightToLeft, const WeakPtr<PipelineContext>& context)
457 : TransitionTweenOption(isRightToLeft, context)
458 {
459 CreateTransitionInOption(event);
460 CreateTransitionOutOption(event);
461 CreateSharedInOption(isRightToLeft_, deviceViewScale_, deviceWidth_, sharedTransitionInOption_);
462 CreateSharedOutOption(sharedTransitionOutOption_);
463 }
464
CreateTransitionInOption(TransitionEvent event)465 void TransitionWatchTweenOption::CreateTransitionInOption(TransitionEvent event)
466 {
467 RefPtr<CurveAnimation<DimensionOffset>> translateAnimation;
468 if (isRightToLeft_) {
469 translateAnimation = AceType::MakeRefPtr<CurveAnimation<DimensionOffset>>(
470 DimensionOffset(Dimension(-deviceWidth_, DimensionUnit::PX), Dimension()),
471 DimensionOffset(Dimension(), Dimension()), Curves::FRICTION);
472 } else {
473 translateAnimation = AceType::MakeRefPtr<CurveAnimation<DimensionOffset>>(
474 DimensionOffset(Dimension(deviceWidth_, DimensionUnit::PX), Dimension()),
475 DimensionOffset(Dimension(), Dimension()), Curves::FRICTION);
476 }
477 contentInOption_.SetTranslateAnimations(AnimationType::TRANSLATE_X, translateAnimation);
478 contentInOption_.SetDuration(TRANSITION_WATCH_DURATION);
479
480 if (event == TransitionEvent::POP_START) {
481 contentInOption_.SetCurve(Curves::SMOOTH);
482 }
483 }
484
CreateTransitionOutOption(TransitionEvent event)485 void TransitionWatchTweenOption::CreateTransitionOutOption(TransitionEvent event)
486 {
487 if (isRightToLeft_) {
488 auto offsetXAnimation = AceType::MakeRefPtr<CurveAnimation<float>>(0.0f, deviceWidth_, Curves::FRICTION);
489 contentOutOption_.SetPropertyAnimationFloat(PropertyAnimatableType::PROPERTY_OFFSET_X, offsetXAnimation);
490 } else {
491 auto widthAnimation = AceType::MakeRefPtr<CurveAnimation<float>>(deviceWidth_, 0.0f, Curves::FRICTION);
492 contentOutOption_.SetPropertyAnimationFloat(PropertyAnimatableType::PROPERTY_WIDTH, widthAnimation);
493 }
494 auto opacityAnimation = AceType::MakeRefPtr<CurveAnimation<float>>(1.0f, 1.0f, Curves::FRICTION);
495 contentOutOption_.SetOpacityAnimation(opacityAnimation);
496
497 if (event == TransitionEvent::POP_START) {
498 contentOutOption_.SetCurve(Curves::SMOOTH);
499 }
500 }
501
CreateCardTransitionOutOption(TransitionEvent event)502 void TransitionPhoneTweenOption::CreateCardTransitionOutOption(TransitionEvent event)
503 {
504 contentOutOption_.SetDuration(TRANSITION_PHONE_DURATION);
505 // blackening treatment
506 if (event == TransitionEvent::POP_START) {
507 auto colorAnimation = AceType::MakeRefPtr<CurveAnimation<Color>>(Color::FromRGBO(0, 0, 0, 0.2),
508 Color::FromRGBO(0, 0, 0, 0.0), Curves::FRICTION);
509 frontDecorationOption_.SetColorAnimation(colorAnimation);
510 } else {
511 auto colorAnimation = AceType::MakeRefPtr<KeyframeAnimation<Color>>();
512 auto colorKeyframe1 = AceType::MakeRefPtr<Keyframe<Color>>(0.0f, Color::FromRGBO(0, 0, 0, 0.0));
513 auto colorKeyframe2 = AceType::MakeRefPtr<Keyframe<Color>>(0.571f, Color::FromRGBO(0, 0, 0, 0.2));
514 auto colorKeyframe3 = AceType::MakeRefPtr<Keyframe<Color>>(1.0f, Color::FromRGBO(0, 0, 0, 0.2));
515 colorKeyframe2->SetCurve(Curves::SHARP);
516 colorAnimation->AddKeyframe(colorKeyframe1);
517 colorAnimation->AddKeyframe(colorKeyframe2);
518 colorAnimation->AddKeyframe(colorKeyframe3);
519 frontDecorationOption_.SetColorAnimation(colorAnimation);
520 }
521 frontDecorationOption_.SetIsBackground(false);
522 }
523
CreateCardTransitionInOption(TransitionEvent event,const RRect & rrect)524 void TransitionPhoneTweenOption::CreateCardTransitionInOption(TransitionEvent event, const RRect& rrect)
525 {
526 const Offset& position = rrect.GetRect().GetOffset();
527 const Size& size = rrect.GetRect().GetSize();
528 contentInOption_.SetTransformOrigin(Dimension(), Dimension());
529 if (event == TransitionEvent::POP_START) {
530 auto translateAnimation = AceType::MakeRefPtr<CurveAnimation<DimensionOffset>>(DimensionOffset(Offset()),
531 DimensionOffset(position), Curves::FRICTION);
532 auto heightAnimation = AceType::MakeRefPtr<CurveAnimation<float>>(deviceHeight_,
533 size.Height() * deviceWidth_ / size.Width(), Curves::FRICTION);
534 auto scaleAnimation = AceType::MakeRefPtr<CurveAnimation<float>>(1.0f, size.Width() / deviceWidth_,
535 Curves::FRICTION);
536 contentInOption_.SetPropertyAnimationFloat(PropertyAnimatableType::PROPERTY_HEIGHT, heightAnimation);
537 contentInOption_.SetTranslateAnimations(AnimationType::TRANSLATE, translateAnimation);
538 contentInOption_.SetTransformFloatAnimation(AnimationType::SCALE, scaleAnimation);
539 } else {
540 auto translateAnimation = AceType::MakeRefPtr<CurveAnimation<DimensionOffset>>(DimensionOffset(position),
541 DimensionOffset(Offset()), Curves::FRICTION);
542 auto heightAnimation = AceType::MakeRefPtr<CurveAnimation<float>>(size.Height() * deviceWidth_ / size.Width(),
543 deviceHeight_, Curves::FRICTION);
544 auto scaleAnimation = AceType::MakeRefPtr<CurveAnimation<float>>(size.Width() / deviceWidth_, 1.0f,
545 Curves::FRICTION);
546 contentInOption_.SetPropertyAnimationFloat(PropertyAnimatableType::PROPERTY_HEIGHT, heightAnimation);
547 contentInOption_.SetTranslateAnimations(AnimationType::TRANSLATE, translateAnimation);
548 contentInOption_.SetTransformFloatAnimation(AnimationType::SCALE, scaleAnimation);
549 }
550 CreateCornerAnimationInOption(event, rrect);
551 CreateCardOpacityAnimationInOption(event);
552 contentInOption_.SetDuration(TRANSITION_PHONE_DURATION);
553 }
554
CreateCornerAnimationInOption(TransitionEvent event,const RRect & rrect)555 void TransitionPhoneTweenOption::CreateCornerAnimationInOption(TransitionEvent event, const RRect& rrect)
556 {
557 auto cornerRadiusAnimation = AceType::MakeRefPtr<KeyframeAnimation<float>>();
558 auto cornerRadius = rrect.GetCorner().topLeftRadius.GetX().Value() * deviceWidth_ / rrect.Width();
559 if (event == TransitionEvent::POP_START) {
560 auto cornerKeyframe1 = AceType::MakeRefPtr<Keyframe<float>>(0.0f, TRANSITION_DEFAULT_CORNER_RADIUS);
561 auto cornerKeyframe2 = AceType::MakeRefPtr<Keyframe<float>>(0.428f, cornerRadius);
562 auto cornerKeyframe3 = AceType::MakeRefPtr<Keyframe<float>>(1.0f, cornerRadius);
563 cornerKeyframe2->SetCurve(Curves::FRICTION);
564 cornerRadiusAnimation->AddKeyframe(cornerKeyframe1);
565 cornerRadiusAnimation->AddKeyframe(cornerKeyframe2);
566 cornerRadiusAnimation->AddKeyframe(cornerKeyframe3);
567 } else {
568 auto cornerKeyframe1 = AceType::MakeRefPtr<Keyframe<float>>(0.0f, cornerRadius);
569 auto cornerKeyframe2 = AceType::MakeRefPtr<Keyframe<float>>(0.571f, cornerRadius);
570 auto cornerKeyframe3 = AceType::MakeRefPtr<Keyframe<float>>(1.0f, TRANSITION_DEFAULT_CORNER_RADIUS);
571 cornerKeyframe3->SetCurve(Curves::FRICTION);
572 cornerRadiusAnimation->AddKeyframe(cornerKeyframe1);
573 cornerRadiusAnimation->AddKeyframe(cornerKeyframe2);
574 cornerRadiusAnimation->AddKeyframe(cornerKeyframe3);
575 }
576 contentInOption_.SetPropertyAnimationFloat(PropertyAnimatableType::PROPERTY_BORDER_RADIUS, cornerRadiusAnimation);
577 }
578
CreateCardOpacityAnimationInOption(TransitionEvent event)579 void TransitionPhoneTweenOption::CreateCardOpacityAnimationInOption(TransitionEvent event)
580 {
581 auto opacityAnimation = AceType::MakeRefPtr<KeyframeAnimation<float>>();
582 if (event == TransitionEvent::POP_START) {
583 auto opacityKeyframe1 = AceType::MakeRefPtr<Keyframe<float>>(0.0f, 1.0f);
584 auto opacityKeyframe2 = AceType::MakeRefPtr<Keyframe<float>>(0.571f, 1.0f);
585 auto opacityKeyframe3 = AceType::MakeRefPtr<Keyframe<float>>(1.0f, 0.0f);
586 opacityKeyframe3->SetCurve(Curves::SHARP);
587 opacityAnimation->AddKeyframe(opacityKeyframe1);
588 opacityAnimation->AddKeyframe(opacityKeyframe2);
589 opacityAnimation->AddKeyframe(opacityKeyframe3);
590 } else {
591 auto opacityKeyframe1 = AceType::MakeRefPtr<Keyframe<float>>(0.0f, 0.0f);
592 auto opacityKeyframe2 = AceType::MakeRefPtr<Keyframe<float>>(0.286f, 1.0f);
593 auto opacityKeyframe3 = AceType::MakeRefPtr<Keyframe<float>>(1.0f, 1.0f);
594 opacityKeyframe2->SetCurve(Curves::SHARP);
595 opacityAnimation->AddKeyframe(opacityKeyframe1);
596 opacityAnimation->AddKeyframe(opacityKeyframe2);
597 opacityAnimation->AddKeyframe(opacityKeyframe3);
598 }
599 contentInOption_.SetOpacityAnimation(opacityAnimation);
600 }
601
CreateSlideEffectAnimation(TweenOption & tweenOption,SlideEffect effect,PageTransitionType type,TransitionDirection direction)602 void TransitionDeclarativeTweenOption::CreateSlideEffectAnimation(
603 TweenOption& tweenOption, SlideEffect effect, PageTransitionType type, TransitionDirection direction)
604 {
605 bool exitFlag = false;
606 if (type == PageTransitionType::EXIT || type == PageTransitionType::EXIT_POP ||
607 type == PageTransitionType::EXIT_PUSH) {
608 exitFlag = true;
609 }
610
611 if (effect == SlideEffect::LEFT) {
612 auto init = DimensionOffset(Dimension(-deviceWidth_, DimensionUnit::PX), Dimension());
613 auto target = DimensionOffset(Dimension(), Dimension());
614 if (exitFlag) {
615 std::swap(init, target);
616 }
617 auto translateAnimation =
618 AceType::MakeRefPtr<CurveAnimation<DimensionOffset>>(init, target, tweenOption.GetCurve());
619 tweenOption.SetTranslateAnimations(AnimationType::TRANSLATE_X, translateAnimation);
620 } else if (effect == SlideEffect::RIGHT) {
621 auto init = DimensionOffset(Dimension(deviceWidth_, DimensionUnit::PX), Dimension());
622 auto target = DimensionOffset(Dimension(), Dimension());
623 if (exitFlag) {
624 std::swap(init, target);
625 }
626 auto translateAnimation =
627 AceType::MakeRefPtr<CurveAnimation<DimensionOffset>>(init, target, tweenOption.GetCurve());
628 tweenOption.SetTranslateAnimations(AnimationType::TRANSLATE_X, translateAnimation);
629 } else if (effect == SlideEffect::TOP) {
630 auto init = DimensionOffset(Dimension(), Dimension(-deviceHeight_, DimensionUnit::PX));
631 auto target = DimensionOffset(Dimension(), Dimension());
632 if (exitFlag) {
633 std::swap(init, target);
634 }
635 auto translateAnimation =
636 AceType::MakeRefPtr<CurveAnimation<DimensionOffset>>(init, target, tweenOption.GetCurve());
637 tweenOption.SetTranslateAnimations(AnimationType::TRANSLATE_Y, translateAnimation);
638 } else if (effect == SlideEffect::BOTTOM) {
639 auto init = DimensionOffset(Dimension(), Dimension(deviceHeight_, DimensionUnit::PX));
640 auto target = DimensionOffset(Dimension(), Dimension());
641 if (exitFlag) {
642 std::swap(init, target);
643 }
644 auto translateAnimation =
645 AceType::MakeRefPtr<CurveAnimation<DimensionOffset>>(init, target, tweenOption.GetCurve());
646 tweenOption.SetTranslateAnimations(AnimationType::TRANSLATE_Y, translateAnimation);
647 }
648 }
649
650 } // namespace OHOS::Ace
651