• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2022-2024 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 #ifndef FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_PATTERNS_VIDEO_VIDEO_PATTERN_H
17 #define FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_PATTERNS_VIDEO_VIDEO_PATTERN_H
18 #include "base/geometry/dimension.h"
19 #include "base/geometry/size.h"
20 #include "base/memory/referenced.h"
21 #include "base/utils/noncopyable.h"
22 #include "core/components/video/video_controller_v2.h"
23 #include "core/components_ng/image_provider/image_loading_context.h"
24 #include "core/components_ng/pattern/pattern.h"
25 #include "core/components_ng/pattern/video/video_accessibility_property.h"
26 #include "core/components_ng/pattern/video/video_event_hub.h"
27 #include "core/components_ng/pattern/video/video_layout_algorithm.h"
28 #include "core/components_ng/pattern/video/video_layout_property.h"
29 #include "core/components_ng/property/property.h"
30 #include "core/components_ng/render/media_player.h"
31 #include "core/components_ng/render/render_surface.h"
32 #include "core/pipeline_ng/pipeline_context.h"
33 #include "frameworks/base/geometry/rect.h"
34 
35 namespace OHOS::Ace {
36 class ImageAnalyzerManager;
37 }
38 namespace OHOS::Ace::NG {
39 class VideoPattern : public Pattern {
40     DECLARE_ACE_TYPE(VideoPattern, Pattern);
41 
42 public:
43     using HiddenChangeEvent = std::function<void(bool)>;
44 
45     VideoPattern() = delete;
46     explicit VideoPattern(const RefPtr<VideoControllerV2>& videoController);
47     ~VideoPattern() override;
48 
IsEnableMatchParent()49     bool IsEnableMatchParent() override
50     {
51         return true;
52     }
53 
IsEnableFix()54     bool IsEnableFix() override
55     {
56         return true;
57     }
58 
CreateEventHub()59     RefPtr<EventHub> CreateEventHub() override
60     {
61         return MakeRefPtr<VideoEventHub>();
62     }
63 
CreateLayoutProperty()64     RefPtr<LayoutProperty> CreateLayoutProperty() override
65     {
66         return MakeRefPtr<VideoLayoutProperty>();
67     }
68 
CreateLayoutAlgorithm()69     RefPtr<LayoutAlgorithm> CreateLayoutAlgorithm() override
70     {
71         return MakeRefPtr<VideoLayoutAlgorithm>();
72     }
73 
CreateAccessibilityProperty()74     RefPtr<AccessibilityProperty> CreateAccessibilityProperty() override
75     {
76         return MakeRefPtr<VideoAccessibilityProperty>();
77     }
78 
IsSupportDrawModifier()79     bool IsSupportDrawModifier() const override
80     {
81         return false;
82     }
83 
UpdateMuted(bool muted)84     void UpdateMuted(bool muted)
85     {
86         muted_ = muted;
87     }
88 
GetMuted()89     bool GetMuted() const
90     {
91         return muted_;
92     }
93 
UpdateAutoPlay(bool autoPlay)94     void UpdateAutoPlay(bool autoPlay)
95     {
96         autoPlay_ = autoPlay;
97     }
98 
GetAutoPlay()99     bool GetAutoPlay() const
100     {
101         return autoPlay_;
102     }
103 
UpdateLoop(bool loop)104     void UpdateLoop(bool loop)
105     {
106         loop_ = loop;
107     }
108 
GetLoop()109     bool GetLoop() const
110     {
111         return loop_;
112     }
113 
114     void SetSurfaceBackgroundColor(Color color);
115 
116     virtual bool IsFullScreen() const;
117 
118     void OnColorConfigurationUpdate() override;
119 
UpdateShowFirstFrame(bool showFirstFrame)120     void UpdateShowFirstFrame(bool showFirstFrame)
121     {
122         showFirstFrame_ = showFirstFrame;
123     }
124 
UpdateProgressRate(double progressRate)125     void UpdateProgressRate(double progressRate)
126     {
127         progressRate_ = progressRate;
128     }
129 
GetProgressRate()130     double GetProgressRate() const
131     {
132         return progressRate_;
133     }
134 
GetFocusPattern()135     FocusPattern GetFocusPattern() const override
136     {
137         // Video focus type is scope, it is a container, inner focus is on slider now.
138         return { FocusType::SCOPE, true };
139     }
140 
141     RefPtr<FrameNode> CreateControlBar(int32_t nodeId = -1);
142 
SetHiddenChangeEvent(HiddenChangeEvent && hiddenChangeEvent)143     void SetHiddenChangeEvent(HiddenChangeEvent&& hiddenChangeEvent)
144     {
145         hiddenChangeEvent_ = std::move(hiddenChangeEvent);
146     }
147 
GetCurrentPos()148     uint32_t GetCurrentPos() const
149     {
150         return currentPos_;
151     }
152 
GetDuration()153     uint32_t GetDuration() const
154     {
155         return duration_;
156     }
157 
GetInitialState()158     bool GetInitialState() const
159     {
160         return isInitialState_;
161     }
162 
OnBackPressed()163     virtual bool OnBackPressed()
164     {
165         return false;
166     }
167 
168     void OnVisibleChange(bool isVisible) override;
169 
170     void OnAreaChangedInner() override;
171 
172     // It is used to init mediaplayer on background.
173     void UpdateMediaPlayerOnBg();
174     void ResetMediaPlayer();
175     void ResetMediaPlayerOnBg();
176 
SetIsStop(bool isStop)177     void SetIsStop(bool isStop)
178     {
179         isStop_ = isStop;
180     }
181 
GetIsStop()182     bool GetIsStop() const
183     {
184         return isStop_;
185     }
186 
IsInitialState()187     bool IsInitialState() const
188     {
189         return isInitialState_;
190     }
191 
GetSrc()192     const std::string& GetSrc() const
193     {
194         return videoSrcInfo_.src_;
195     }
196 
UpdateMediaParam(const RefPtr<MediaPlayer> & mediaPlayer,const RefPtr<RenderSurface> & renderSurface,const RefPtr<RenderContext> & renderContext)197     void UpdateMediaParam(const RefPtr<MediaPlayer>& mediaPlayer, const RefPtr<RenderSurface>& renderSurface,
198         const RefPtr<RenderContext>& renderContext)
199     {
200         mediaPlayer_ = AceType::Claim(AceType::RawPtr(mediaPlayer));
201         renderSurface_ = AceType::Claim(AceType::RawPtr(renderSurface));
202         renderContextForMediaPlayer_ = AceType::Claim(AceType::RawPtr(renderContext));
203     }
204 
ResetMediaParam()205     void ResetMediaParam()
206     {
207         mediaPlayer_.Reset();
208         renderSurface_.Reset();
209         RemoveMediaPlayerSurfaceNode();
210         renderContextForMediaPlayer_.Reset();
211     }
212 
213     void RemoveMediaPlayerSurfaceNode();
214 
215     void OnFullScreenChange(bool isFullScreen);
216 
217     void RecoverState(const RefPtr<VideoPattern>& videoPattern);
218 
219     bool NeedLift() const;
220 
GetFullScreenNode()221     RefPtr<FrameNode> GetFullScreenNode() const
222     {
223         if (!fullScreenNodeId_.has_value()) {
224             return nullptr;
225         }
226         return FrameNode::GetFrameNode(V2::VIDEO_ETS_TAG, fullScreenNodeId_.value());
227     }
228 
229     void OnPlayerStatus(PlaybackStatus status);
230 
231     void OnCurrentTimeChange(uint32_t currentPos);
232 
233     void OnError(const std::string& errorId);
234 
235     void OnError(int32_t code, const std::string& message);
236 
237     void OnResolutionChange() const;
238 
239     void OnStartRenderFrameCb();
240 
ResetLastBoundsRect()241     void ResetLastBoundsRect()
242     {
243         lastBoundsRect_.SetRect(0.0f, 0.0f, 0.0f, 0.0f);
244     }
245 
246     RefPtr<VideoPattern> GetTargetVideoPattern();
247     void EnableAnalyzer(bool enable);
248     void SetImageAnalyzerConfig(void* config);
249     void StartUpdateImageAnalyzer();
250     void SetImageAIOptions(void* options);
251     bool GetAnalyzerState();
UpdateAnalyzerState(bool isCreated)252     void UpdateAnalyzerState(bool isCreated)
253     {
254         isAnalyzerCreated_ = isCreated;
255     }
SetIsSeeking(bool isSeeking)256     void SetIsSeeking(bool isSeeking)
257     {
258         isSeeking_ = isSeeking;
259     }
GetIsSeeking()260     bool GetIsSeeking() const
261     {
262         return isSeeking_;
263     }
264 
SetIsPrepared(bool isPrepared)265     void SetIsPrepared(bool isPrepared)
266     {
267         isPrepared_ = isPrepared;
268     }
GetIsPrepared()269     bool GetIsPrepared() const
270     {
271         return isPrepared_;
272     }
273     static void RegisterMediaPlayerEvent(const WeakPtr<VideoPattern>& weak, const RefPtr<MediaPlayer>& mediaPlayer,
274         const std::string& videoSrc, int32_t instanceId);
275 
276     void SetShortcutKeyEnabled(bool isEnableShortcutKey);
277     bool GetShortcutKeyEnabled() const;
278 
279     void SetCurrentVolume(float currentVolume);
280     float GetCurrentVolume() const;
281     static bool ParseCommand(const std::string& command);
282     int32_t OnInjectionEvent(const std::string& command) override;
283 
284 #ifdef RENDER_EXTRACT_SUPPORTED
285     void OnTextureRefresh(void* surface);
286 #endif
287 
288     void SetVideoController(const RefPtr<VideoControllerV2>& videoController);
289     RefPtr<VideoControllerV2> GetVideoController();
290 
291 protected:
292     void OnUpdateTime(uint32_t time, int pos) const;
293 
294     RefPtr<MediaPlayer> mediaPlayer_ = MediaPlayer::Create();
295     RefPtr<RenderSurface> renderSurface_ = RenderSurface::Create();
296     RefPtr<RenderContext> renderContextForMediaPlayer_ = RenderContext::Create();
297 
298     int32_t instanceId_;
299 
300 #if defined(RENDER_EXTRACT_SUPPORTED) && defined(ENABLE_ROSEN_BACKEND)
301     WeakPtr<RenderSurface> renderSurfaceWeakPtr_;
302     WeakPtr<RenderContext> renderContextForMediaPlayerWeakPtr_;
303 #endif
304 
305 private:
306     void OnAttachToFrameNode() override;
307     void OnDetachFromFrameNode(FrameNode* frameNode) override;
308     void OnDetachFromMainTree() override;
309     void OnModifyDone() override;
310     bool OnDirtyLayoutWrapperSwap(const RefPtr<LayoutWrapper>& dirty, const DirtySwapConfig& config) override;
311     void OnRebuildFrame() override;
312     void OnWindowHide() override;
313     void InitKeyEvent();
314     bool OnKeyEvent(const KeyEvent& event);
315     bool HandleSliderKeyEvent(const KeyEventInfo& event);
316     void AddChild();
317 
318     // Set properties for media player.
319     void PrepareMediaPlayer();
320     void SetStartImpl(
321         const RefPtr<VideoController>& videoController, const SingleTaskExecutor& uiTaskExecutor);
322     void SetPausetImpl(
323         const RefPtr<VideoController>& videoController, const SingleTaskExecutor& uiTaskExecutor);
324     void SetStopImpl(
325         const RefPtr<VideoController>& videoController, const SingleTaskExecutor& uiTaskExecutor);
326     void SetSeekToImpl(
327         const RefPtr<VideoController>& videoController, const SingleTaskExecutor& uiTaskExecutor);
328     void SetRequestFullscreenImpl(
329         const RefPtr<VideoController>& videoController, const SingleTaskExecutor& uiTaskExecutor);
330     void SetExitFullscreenImpl(
331         const RefPtr<VideoController>& videoController, const SingleTaskExecutor& uiTaskExecutor);
332     void SetResetImpl(
333         const RefPtr<VideoController>& videoController, const SingleTaskExecutor& uiTaskExecutor);
334 
335     void SetMethodCall();
336 
337     bool SetSourceForMediaPlayer();
338     void UpdateLooping();
339     void UpdateSpeed();
340     void UpdateMuted();
341     void PrepareSurface();
342 
343     bool HasPlayer() const;
344 
345     // Functions for the video controller.
346     void Start();
347     void Pause();
348     void Stop();
349     void FullScreen();
350 
351     void SetCurrentTime(float currentPos, SeekMode seekMode = SeekMode::SEEK_PREVIOUS_SYNC);
352     void SetFullScreenButtonCallBack(RefPtr<FrameNode>& fullScreenBtn);
353 
354     void OnPrepared(uint32_t duration, uint32_t currentPos, bool needFireEvent);
355     void OnCompletion();
356     void OnSliderChange(float posTime, int32_t mode);
357 
358     void UpdatePreviewImage();
359     void UpdateControllerBar();
360     void UpdateVideoProperty();
361 
362     RefPtr<FrameNode> CreateSVG();
363     RefPtr<FrameNode> CreateText(uint32_t time);
364     RefPtr<FrameNode> CreateSlider();
365     void ChangePlayButtonTag();
366     void ChangePlayButtonTag(RefPtr<FrameNode>& playBtn);
367 
368     void ChangeFullScreenButtonTag(bool isFullScreen, RefPtr<FrameNode>& fullScreenBtn);
369     void ResetStatus();
370     void HiddenChange(bool hidden);
371 
372     void UpdateFsState();
373     void checkNeedAutoPlay();
374 
375     // Fire error manually, eg. src is not existed. It must run on ui.
376     void FireError(int32_t code, const std::string& message);
377 
378     HiddenChangeEvent CreateHiddenChangeEvent();
379 
SetMediaFullScreen(bool isFullScreen)380     void SetMediaFullScreen(bool isFullScreen)
381     {
382         mediaPlayer_->FullScreenChange(isFullScreen);
383         if (SystemProperties::GetExtSurfaceEnabled()) {
384             renderSurface_->SetIsFullScreen(isFullScreen);
385         }
386     }
387 
388 #ifdef RENDER_EXTRACT_SUPPORTED
389     void* GetNativeWindow(int32_t instanceId, int64_t textureId);
390 #endif
391 
392     void RegisterRenderContextCallBack();
393     void ChangePlayerStatus(const PlaybackStatus& status);
394 
395     bool IsSupportImageAnalyzer();
396     bool ShouldUpdateImageAnalyzer();
397     void StartImageAnalyzer();
398     void CreateAnalyzerOverlay();
399     void DestroyAnalyzerOverlay();
400     void UpdateAnalyzerOverlay();
401     void UpdateAnalyzerUIConfig(const RefPtr<NG::GeometryNode>& geometryNode);
402     void UpdateOverlayVisibility(VisibleType type);
403 
404     void OnKeySpaceEvent();
405     void MoveByStep(int32_t step);
406     void AdjustVolume(int32_t step);
407 
408     void ToJsonValue(std::unique_ptr<JsonValue>& json, const InspectorFilter& filter) const override;
409 
410     RefPtr<VideoControllerV2> videoControllerV2_;
411     RefPtr<FrameNode> controlBar_;
412 
413     GestureEventFunc playBtnCallBack_;
414     GestureEventFunc pauseBtnCallBack_;
415     HiddenChangeEvent hiddenChangeEvent_;
416 
417     // Video src.
418     VideoSourceInfo videoSrcInfo_;
419     bool showFirstFrame_ = false;
420     bool isInitialState_ = true; // Initial state is true. Play or seek will set it to false.
421     bool isPlaying_ = false;
422     bool isPrepared_ = false;
423 
424     bool isStop_ = false;
425 
426     bool muted_ = false;
427     bool autoPlay_ = false;
428     bool loop_ = false;
429 
430     bool pastPlayingStatus_ = false;
431 
432     bool isEnableAnalyzer_ = false;
433     bool isAnalyzerCreated_ = false;
434     bool isPaused_ = false;
435     bool isContentSizeChanged_ = false;
436     bool isSeeking_ = false;
437     bool isEnableShortcutKey_ = false;
438 
439     uint32_t currentPos_ = 0;
440     uint32_t duration_ = 0;
441     float currentVolume_ = 1.0f;
442 
443     // full screen node id
444     std::optional<int32_t> fullScreenNodeId_;
445     int32_t hostId_ = 0;
446 
447     // Video playback speed.
448     double progressRate_ = 1.0;
449 
450     Rect lastBoundsRect_;
451     Rect contentRect_;
452     std::shared_ptr<ImageAnalyzerManager> imageAnalyzerManager_;
453 
454     ACE_DISALLOW_COPY_AND_MOVE(VideoPattern);
455 };
456 } // namespace OHOS::Ace::NG
457 
458 #endif // FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_PATTERNS_VIDEO_VIDEO_PATTERN_H
459