1 /*
2  * Copyright (C) 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 #include "core/common/ai/image_analyzer_manager.h"
17 
18 #include "core/common/ai/image_analyzer_adapter.h"
19 #include "core/common/ai/image_analyzer_mgr.h"
20 #include "core/components_ng/pattern/image/image_pattern.h"
21 #include "core/components_ng/pattern/video/video_layout_property.h"
22 
23 namespace OHOS::Ace {
24 
ImageAnalyzerManager(const RefPtr<NG::FrameNode>& frameNode, ImageAnalyzerHolder holder)25 ImageAnalyzerManager::ImageAnalyzerManager(const RefPtr<NG::FrameNode>& frameNode, ImageAnalyzerHolder holder)
26     : frameNode_(frameNode), holder_(holder)
27 {
28     imageAnalyzerAdapter_ = std::shared_ptr<ImageAnalyzerAdapter>(CreateImageAnalyzerAdapter());
29 }
30 
CreateAnalyzerOverlay(const RefPtr<OHOS::Ace::PixelMap>& pixelMap, const NG::OffsetF& offset)31 void ImageAnalyzerManager::CreateAnalyzerOverlay(const RefPtr<OHOS::Ace::PixelMap>& pixelMap,
32     const NG::OffsetF& offset)
33 {
34     CHECK_NULL_VOID(imageAnalyzerAdapter_);
35     void* pixelmapNapiVal = nullptr;
36     if (pixelMap) {
37         pixelmapNapiVal = imageAnalyzerAdapter_->ConvertPixmapNapi(pixelMap);
38     }
39 
40     analyzerUIConfig_.holder = holder_;
41     if (holder_ != ImageAnalyzerHolder::IMAGE && holder_ != ImageAnalyzerHolder::WEB) {
42         analyzerUIConfig_.contentWidth = pixelMap->GetWidth();
43         analyzerUIConfig_.contentHeight = pixelMap->GetHeight();
44     }
45 
46     if (holder_ == ImageAnalyzerHolder::VIDEO_CUSTOM) {
47         analyzerUIConfig_.pixelMapWidth = pixelMap->GetWidth();
48         analyzerUIConfig_.pixelMapHeight = pixelMap->GetHeight();
49         analyzerUIConfig_.overlayOffset = offset;
50     }
51 
52     RefPtr<NG::UINode> customNode;
53     {
54         NG::ScopedViewStackProcessor builderViewStackProcessor;
55         auto analyzerConfig = imageAnalyzerAdapter_->GetImageAnalyzerConfig();
56         ImageAnalyzerMgr::GetInstance().BuildNodeFunc(
57             pixelmapNapiVal, analyzerConfig, &analyzerUIConfig_, &overlayData_);
58         customNode = NG::ViewStackProcessor::GetInstance()->Finish();
59     }
60     auto overlayNode = AceType::DynamicCast<NG::FrameNode>(customNode);
61     CHECK_NULL_VOID(overlayNode);
62     auto node = frameNode_.Upgrade();
63     CHECK_NULL_VOID(node);
64     node->SetOverlayNode(overlayNode);
65     overlayNode->SetParent(AceType::WeakClaim(AceType::RawPtr(node)));
66     overlayNode->SetActive(true);
67     UpdateAnalyzerOverlayLayout();
68 
69     auto renderContext = overlayNode->GetRenderContext();
70     CHECK_NULL_VOID(renderContext);
71     renderContext->UpdateZIndex(INT32_MAX);
72     auto focusHub = overlayNode->GetOrCreateFocusHub();
73     CHECK_NULL_VOID(focusHub);
74     focusHub->SetFocusable(false);
75     overlayNode->MarkDirtyNode(NG::PROPERTY_UPDATE_MEASURE_SELF);
76 
77     isAnalyzerOverlayBuild_ = true;
78     CHECK_NULL_VOID(analyzerUIConfig_.onAnalyzed);
79     (analyzerUIConfig_.onAnalyzed.value())(ImageAnalyzerState::FINISHED);
80     analyzerUIConfig_.onAnalyzed = std::nullopt;
81 }
82 
CreateMovingPhotoAnalyzerOverlay(const RefPtr<OHOS::Ace::PixelMap>& pixelMap, MovingPhotoAnalyzerInfo info)83 void ImageAnalyzerManager::CreateMovingPhotoAnalyzerOverlay(const RefPtr<OHOS::Ace::PixelMap>& pixelMap,
84     MovingPhotoAnalyzerInfo info)
85 {
86     CHECK_NULL_VOID(imageAnalyzerAdapter_);
87     void* pixelmapNapiVal = nullptr;
88 
89     CHECK_NULL_VOID(pixelMap);
90     pixelmapNapiVal = imageAnalyzerAdapter_->ConvertPixmapNapi(pixelMap);
91     analyzerUIConfig_.holder = holder_;
92     analyzerUIConfig_.contentWidth = info.contentWidth;
93     analyzerUIConfig_.contentHeight = info.contentHeight;
94     analyzerUIConfig_.pixelMapWidth = pixelMap->GetWidth();
95     analyzerUIConfig_.pixelMapHeight = pixelMap->GetHeight();
96 
97     RefPtr<NG::UINode> customNode;
98     {
99         NG::ScopedViewStackProcessor builderViewStackProcessor;
100         auto analyzerConfig = imageAnalyzerAdapter_->GetImageAnalyzerConfig();
101         ImageAnalyzerMgr::GetInstance().BuildNodeFunc(info.uri, pixelmapNapiVal,
102             info.frameTimestamp, analyzerConfig, &analyzerUIConfig_, &overlayData_);
103         customNode = NG::ViewStackProcessor::GetInstance()->Finish();
104     }
105     auto overlayNode = AceType::DynamicCast<NG::FrameNode>(customNode);
106     CHECK_NULL_VOID(overlayNode);
107     auto node = frameNode_.Upgrade();
108     CHECK_NULL_VOID(node);
109     node->SetOverlayNode(overlayNode);
110     overlayNode->SetParent(AceType::WeakClaim(AceType::RawPtr(node)));
111     overlayNode->SetActive(true);
112     UpdateAnalyzerOverlayLayout();
113 
114     auto renderContext = overlayNode->GetRenderContext();
115     CHECK_NULL_VOID(renderContext);
116     renderContext->UpdateZIndex(INT32_MAX);
117     overlayNode->MarkDirtyNode(NG::PROPERTY_UPDATE_MEASURE_SELF);
118 
119     isAnalyzerOverlayBuild_ = true;
120     CHECK_NULL_VOID(analyzerUIConfig_.onAnalyzed);
121     (analyzerUIConfig_.onAnalyzed.value())(ImageAnalyzerState::FINISHED);
122     analyzerUIConfig_.onAnalyzed = std::nullopt;
123 }
124 
UpdateAnalyzerOverlay(const RefPtr<OHOS::Ace::PixelMap>& pixelMap, const NG::OffsetF& offset)125 void ImageAnalyzerManager::UpdateAnalyzerOverlay(const RefPtr<OHOS::Ace::PixelMap>& pixelMap,
126     const NG::OffsetF& offset)
127 {
128     if (!isAnalyzerOverlayBuild_) {
129         return;
130     }
131 
132     auto node = frameNode_.Upgrade();
133     CHECK_NULL_VOID(node);
134     if (holder_ == ImageAnalyzerHolder::IMAGE) {
135         auto imagePattern = AceType::DynamicCast<NG::ImagePattern>(node->GetPattern());
136         CHECK_NULL_VOID(imagePattern);
137         if (!imagePattern->hasSceneChanged()) {
138             return;
139         }
140     }
141 
142     CHECK_NULL_VOID(pixelMap);
143     if (holder_ == ImageAnalyzerHolder::VIDEO_CUSTOM) {
144         analyzerUIConfig_.pixelMapWidth = pixelMap->GetWidth();
145         analyzerUIConfig_.pixelMapHeight = pixelMap->GetHeight();
146         analyzerUIConfig_.overlayOffset = offset;
147     }
148 
149     if (holder_ != ImageAnalyzerHolder::IMAGE) {
150         analyzerUIConfig_.contentWidth = pixelMap->GetWidth();
151         analyzerUIConfig_.contentHeight = pixelMap->GetHeight();
152     }
153 
154     CHECK_NULL_VOID(imageAnalyzerAdapter_);
155     auto pixelmapNapiVal = imageAnalyzerAdapter_->ConvertPixmapNapi(pixelMap);
156     auto overlayNode = node->GetOverlayNode();
157     CHECK_NULL_VOID(overlayNode);
158     auto analyzerConfig = imageAnalyzerAdapter_->GetImageAnalyzerConfig();
159     ImageAnalyzerMgr::GetInstance().UpdateImage(&overlayData_, pixelmapNapiVal, analyzerConfig, &analyzerUIConfig_);
160     overlayNode->MarkDirtyNode(NG::PROPERTY_UPDATE_MEASURE_SELF);
161 }
162 
UpdateMovingPhotoAnalyzerOverlay(const RefPtr<OHOS::Ace::PixelMap>& pixelMap, MovingPhotoAnalyzerInfo info)163 void ImageAnalyzerManager::UpdateMovingPhotoAnalyzerOverlay(const RefPtr<OHOS::Ace::PixelMap>& pixelMap,
164     MovingPhotoAnalyzerInfo info)
165 {
166     if (!isAnalyzerOverlayBuild_) {
167         return;
168     }
169 
170     auto node = frameNode_.Upgrade();
171     CHECK_NULL_VOID(node);
172     if (holder_ == ImageAnalyzerHolder::IMAGE) {
173         auto imagePattern = AceType::DynamicCast<NG::ImagePattern>(node->GetPattern());
174         CHECK_NULL_VOID(imagePattern);
175         if (!imagePattern->hasSceneChanged()) {
176             return;
177         }
178     }
179 
180     CHECK_NULL_VOID(pixelMap);
181     analyzerUIConfig_.holder = holder_;
182     analyzerUIConfig_.contentWidth = info.contentWidth;
183     analyzerUIConfig_.contentHeight = info.contentHeight;
184     analyzerUIConfig_.pixelMapWidth = pixelMap->GetWidth();
185     analyzerUIConfig_.pixelMapHeight = pixelMap->GetHeight();
186 
187     CHECK_NULL_VOID(imageAnalyzerAdapter_);
188     auto pixelmapNapiVal = imageAnalyzerAdapter_->ConvertPixmapNapi(pixelMap);
189     auto overlayNode = node->GetOverlayNode();
190     CHECK_NULL_VOID(overlayNode);
191     auto analyzerConfig = imageAnalyzerAdapter_->GetImageAnalyzerConfig();
192     ImageAnalyzerMgr::GetInstance().UpdateImage(&overlayData_, info.uri, pixelmapNapiVal,
193         info.frameTimestamp, analyzerConfig, &analyzerUIConfig_);
194     overlayNode->MarkDirtyNode(NG::PROPERTY_UPDATE_MEASURE_SELF);
195 }
196 
DestroyAnalyzerOverlay()197 void ImageAnalyzerManager::DestroyAnalyzerOverlay()
198 {
199     ReleaseImageAnalyzer();
200 
201     if (!isAnalyzerOverlayBuild_) {
202         return;
203     }
204     auto node = frameNode_.Upgrade();
205     CHECK_NULL_VOID(node);
206     auto overlayNode = node->GetOverlayNode();
207     CHECK_NULL_VOID(overlayNode);
208     node->SetOverlayNode(RefPtr<NG::FrameNode>());
209 
210     isAnalyzerOverlayBuild_ = false;
211     CHECK_NULL_VOID(analyzerUIConfig_.onAnalyzed);
212     (analyzerUIConfig_.onAnalyzed.value())(ImageAnalyzerState::STOPPED);
213     analyzerUIConfig_.onAnalyzed = std::nullopt;
214 
215     napi_value nullValue = nullptr;
216     CHECK_NULL_VOID(imageAnalyzerAdapter_);
217     imageAnalyzerAdapter_->SetImageAnalyzerConfig(nullValue);
218 }
219 
IsSupportImageAnalyzerFeature()220 bool ImageAnalyzerManager::IsSupportImageAnalyzerFeature()
221 {
222     auto node = frameNode_.Upgrade();
223     CHECK_NULL_RETURN(node, false);
224     auto eventHub = node->GetEventHub<NG::EventHub>();
225     CHECK_NULL_RETURN(eventHub, false);
226     if (!eventHub->IsEnabled()) {
227         return false;
228     }
229 
230     bool hasObscured = false;
231     if (node->GetRenderContext()->GetObscured().has_value()) {
232         auto obscuredReasons = node->GetRenderContext()->GetObscured().value();
233         hasObscured = std::any_of(obscuredReasons.begin(), obscuredReasons.end(),
234             [](const auto& reason) { return reason == ObscuredReasons::PLACEHOLDER; });
235         if (hasObscured) {
236             return false;
237         }
238     }
239 
240     if (holder_ == ImageAnalyzerHolder::IMAGE) {
241         auto imageRenderProperty = node->GetPaintProperty<NG::ImageRenderProperty>();
242         CHECK_NULL_RETURN(imageRenderProperty, false);
243         ImageRepeat repeat = imageRenderProperty->GetImageRepeat().value_or(ImageRepeat::NO_REPEAT);
244         if (repeat != ImageRepeat::NO_REPEAT) {
245             return false;
246         }
247     }
248 
249     return ImageAnalyzerMgr::GetInstance().IsImageAnalyzerSupported();
250 }
251 
IsOverlayCreated()252 bool ImageAnalyzerManager::IsOverlayCreated()
253 {
254     return isAnalyzerOverlayBuild_;
255 }
256 
UpdateAnalyzerOverlayLayout()257 void ImageAnalyzerManager::UpdateAnalyzerOverlayLayout()
258 {
259     auto node = frameNode_.Upgrade();
260     CHECK_NULL_VOID(node);
261     auto layoutProperty = node->GetLayoutProperty();
262     CHECK_NULL_VOID(layoutProperty);
263     auto padding = layoutProperty->CreatePaddingAndBorder();
264     auto overlayNode = node->GetOverlayNode();
265     CHECK_NULL_VOID(overlayNode);
266     auto overlayLayoutProperty = overlayNode->GetLayoutProperty();
267     CHECK_NULL_VOID(overlayLayoutProperty);
268     overlayLayoutProperty->UpdateMeasureType(NG::MeasureType::MATCH_PARENT);
269     overlayLayoutProperty->UpdateAlignment(Alignment::TOP_LEFT);
270     if (NeedUpdateOverlayOffset()) {
271         overlayLayoutProperty->SetOverlayOffset(Dimension(padding.Offset().GetX()),
272                                                 Dimension(padding.Offset().GetY()));
273         if (holder_ == ImageAnalyzerHolder::IMAGE) {
274             auto renderContext = overlayNode->GetRenderContext();
275             CHECK_NULL_VOID(renderContext);
276             renderContext->SetRenderFrameOffset({ -padding.Offset().GetX(), -padding.Offset().GetY() });
277         }
278     }
279 }
280 
UpdateAnalyzerUIConfig(const RefPtr<NG::GeometryNode>& geometryNode, const PixelMapInfo& info)281 void ImageAnalyzerManager::UpdateAnalyzerUIConfig(const RefPtr<NG::GeometryNode>& geometryNode,
282     const PixelMapInfo& info)
283 {
284     CHECK_NULL_VOID(geometryNode);
285     auto node = frameNode_.Upgrade();
286     CHECK_NULL_VOID(node);
287     bool isUIConfigUpdate = false;
288 
289     auto layoutProps = node->GetLayoutProperty();
290     CHECK_NULL_VOID(layoutProps);
291     if (holder_ == ImageAnalyzerHolder::IMAGE) {
292         auto props = DynamicCast<NG::ImageLayoutProperty>(layoutProps);
293         CHECK_NULL_VOID(props);
294         if (analyzerUIConfig_.imageFit != props->GetImageFit().value_or(ImageFit::COVER)) {
295             analyzerUIConfig_.imageFit = props->GetImageFit().value_or(ImageFit::COVER);
296             isUIConfigUpdate = true;
297         }
298     }
299 
300     if (holder_ == ImageAnalyzerHolder::VIDEO_CUSTOM) {
301         isUIConfigUpdate = UpdateVideoConfig(info);
302     } else {
303         auto padding = layoutProps->CreatePaddingAndBorder();
304         float paddingWidth = 0.0f;
305         float paddingHeight = 0.0f;
306         if (holder_ == ImageAnalyzerHolder::IMAGE || holder_ == ImageAnalyzerHolder::XCOMPONENT) {
307             paddingWidth = padding.left.value_or(0) + padding.right.value_or(0);
308             paddingHeight = padding.top.value_or(0) + padding.bottom.value_or(0);
309         }
310         NG::SizeF frameSize = geometryNode->GetFrameSize();
311         bool shouldUpdateSize = analyzerUIConfig_.contentWidth != frameSize.Width() - paddingWidth ||
312                                 analyzerUIConfig_.contentHeight != frameSize.Height() - paddingHeight;
313         if (shouldUpdateSize) {
314             analyzerUIConfig_.contentWidth = frameSize.Width() - paddingWidth;
315             analyzerUIConfig_.contentHeight = frameSize.Height()- paddingHeight;
316             isUIConfigUpdate = true;
317         }
318     }
319 
320     auto renderContext = node->GetRenderContext();
321     CHECK_NULL_VOID(renderContext);
322     auto transformMat = renderContext->GetTransformMatrixValue(Matrix4::CreateIdentity());
323     if (!(analyzerUIConfig_.transformMat == transformMat)) {
324         analyzerUIConfig_.transformMat = transformMat;
325         isUIConfigUpdate = true;
326     }
327 
328     if (isUIConfigUpdate) {
329         ImageAnalyzerMgr::GetInstance().UpdateInnerConfig(&overlayData_, &analyzerUIConfig_);
330     }
331 }
332 
UpdateVideoConfig(const PixelMapInfo& info)333 bool ImageAnalyzerManager::UpdateVideoConfig(const PixelMapInfo& info)
334 {
335     bool shouldUpdateFit = false;
336     auto node = frameNode_.Upgrade();
337     CHECK_NULL_RETURN(node, false);
338     auto layoutProps = node->GetLayoutProperty();
339     CHECK_NULL_RETURN(layoutProps, false);
340     auto videoProps = DynamicCast<NG::VideoLayoutProperty>(layoutProps);
341     if (analyzerUIConfig_.imageFit != videoProps->GetObjectFitValue(ImageFit::COVER)) {
342         analyzerUIConfig_.imageFit = videoProps->GetObjectFitValue(ImageFit::COVER);
343         shouldUpdateFit = true;
344     }
345 
346     bool shouldUpdateSize = analyzerUIConfig_.contentWidth != info.width ||
347                             analyzerUIConfig_.contentHeight != info.height ||
348                             analyzerUIConfig_.overlayOffset != info.overlayOffset;
349     if (shouldUpdateSize) {
350         analyzerUIConfig_.UpdateFromInfo(info);
351     }
352     return shouldUpdateFit || shouldUpdateSize;
353 }
354 
SetImageAnalyzerConfig(void* config)355 void ImageAnalyzerManager::SetImageAnalyzerConfig(void* config)
356 {
357     CHECK_NULL_VOID(imageAnalyzerAdapter_);
358     bool hasConfig = imageAnalyzerAdapter_->HasImageAnalyzerConfig();
359     if (hasConfig) {
360         return;
361     }
362     imageAnalyzerAdapter_->SetImageAnalyzerConfig(config);
363     auto analyzerConfig = imageAnalyzerAdapter_->GetImageAnalyzerConfig();
364     if (isAnalyzerOverlayBuild_) {
365         ImageAnalyzerMgr::GetInstance().UpdateConfig(&overlayData_, analyzerConfig);
366     }
367 }
368 
SetImageAIOptions(void* options)369 void ImageAnalyzerManager::SetImageAIOptions(void* options)
370 {
371     CHECK_NULL_VOID(imageAnalyzerAdapter_);
372     imageAnalyzerAdapter_->SetImageAnalyzerConfig(options, true);
373     auto analyzerConfig = imageAnalyzerAdapter_->GetImageAnalyzerConfig();
374     if (isAnalyzerOverlayBuild_) {
375         ImageAnalyzerMgr::GetInstance().UpdateConfig(&overlayData_, analyzerConfig);
376     }
377 }
378 
SetImageAnalyzerCallback(OnAnalyzedCallback& callback)379 void ImageAnalyzerManager::SetImageAnalyzerCallback(OnAnalyzedCallback& callback)
380 {
381     analyzerUIConfig_.onAnalyzed = callback;
382 }
383 
ReleaseImageAnalyzer()384 void ImageAnalyzerManager::ReleaseImageAnalyzer()
385 {
386     if (isAnalyzerOverlayBuild_) {
387         ImageAnalyzerMgr::GetInstance().Release(&overlayData_);
388     }
389 }
390 
UpdatePressOverlay(const RefPtr<OHOS::Ace::PixelMap>& pixelMap, int offsetX, int offsetY, int rectWidth, int rectHeight, int pointX, int pointY, OnTextSelectedCallback callback)391 void ImageAnalyzerManager::UpdatePressOverlay(const RefPtr<OHOS::Ace::PixelMap>& pixelMap, int offsetX, int offsetY,
392     int rectWidth, int rectHeight, int pointX, int pointY, OnTextSelectedCallback callback)
393 {
394     analyzerUIConfig_.overlayOffset.SetX(offsetX);
395     analyzerUIConfig_.overlayOffset.SetY(offsetY);
396     if (rectWidth > 0 && rectHeight > 0) {
397         analyzerUIConfig_.touchInfo.touchPoint.x = 1.0 * pointX / rectWidth * pixelMap->GetWidth();
398         analyzerUIConfig_.touchInfo.touchPoint.y = 1.0 * pointY / rectHeight * pixelMap->GetHeight();
399     }
400     analyzerUIConfig_.touchInfo.touchType = TouchType::DOWN;
401     analyzerUIConfig_.selectedStatus = Status::SELECTED;
402     analyzerUIConfig_.menuStatus = Status::MENU_SHOW;
403     if (!analyzerUIConfig_.onTextSelected) {
404         analyzerUIConfig_.onTextSelected = std::move(callback);
405     }
406     if (pixelMap && imageAnalyzerAdapter_) {
407         analyzerUIConfig_.contentWidth = rectWidth;
408         analyzerUIConfig_.contentHeight = rectHeight;
409         analyzerUIConfig_.pixelMapWidth = pixelMap->GetWidth();
410         analyzerUIConfig_.pixelMapHeight = pixelMap->GetHeight();
411         analyzerUIConfig_.pixelmapNapiVal = imageAnalyzerAdapter_->ConvertPixmapNapi(pixelMap);
412     }
413     ImageAnalyzerMgr::GetInstance().UpdatePressOverlay(&overlayData_, &analyzerUIConfig_);
414     analyzerUIConfig_.pixelmapNapiVal = nullptr;
415 }
416 
UpdateOverlayTouchInfo(int touchPointX, int touchPointY, TouchType touchType)417 void ImageAnalyzerManager::UpdateOverlayTouchInfo(int touchPointX, int touchPointY, TouchType touchType)
418 {
419     analyzerUIConfig_.touchInfo.touchPoint.x = touchPointX - analyzerUIConfig_.overlayOffset.GetX();
420     analyzerUIConfig_.touchInfo.touchPoint.y = touchPointY - analyzerUIConfig_.overlayOffset.GetY();
421     analyzerUIConfig_.touchInfo.touchType = touchType;
422     ImageAnalyzerMgr::GetInstance().UpdatePressOverlay(&overlayData_, &analyzerUIConfig_);
423 }
424 
UpdateOverlayStatus(bool status, int offsetX, int offsetY, int rectWidth, int rectHeight)425 void ImageAnalyzerManager::UpdateOverlayStatus(bool status, int offsetX, int offsetY, int rectWidth, int rectHeight)
426 {
427     if (status) {
428         analyzerUIConfig_.overlayOffset.SetX(offsetX);
429         analyzerUIConfig_.overlayOffset.SetY(offsetY);
430         analyzerUIConfig_.contentWidth = rectWidth;
431         analyzerUIConfig_.contentHeight = rectHeight;
432         analyzerUIConfig_.selectedStatus = Status::SELECTED;
433         analyzerUIConfig_.menuStatus = Status::MENU_SHOW;
434     } else {
435         analyzerUIConfig_.selectedStatus = Status::UNSELECTED;
436         analyzerUIConfig_.menuStatus = Status::MENU_HIDE;
437     }
438     ImageAnalyzerMgr::GetInstance().UpdateOverlayStatus(&overlayData_, &analyzerUIConfig_);
439 }
440 
UpdateAIButtonConfig(AIButtonConfig config)441 void ImageAnalyzerManager::UpdateAIButtonConfig(AIButtonConfig config)
442 {
443     CHECK_NULL_VOID(isAnalyzerOverlayBuild_);
444     ImageAnalyzerMgr::GetInstance().UpdateAIButtonConfig(&overlayData_, &config);
445 }
446 
UpdateOverlayActiveStatus(bool status)447 void ImageAnalyzerManager::UpdateOverlayActiveStatus(bool status)
448 {
449     CHECK_NULL_VOID(isAnalyzerOverlayBuild_);
450     ImageAnalyzerMgr::GetInstance().UpdateOverlayActiveStatus(&overlayData_, status);
451 }
452 
NeedUpdateOverlayOffset()453 bool ImageAnalyzerManager::NeedUpdateOverlayOffset()
454 {
455     return holder_ == ImageAnalyzerHolder::IMAGE ||
456            holder_ == ImageAnalyzerHolder::VIDEO_CUSTOM ||
457            holder_ == ImageAnalyzerHolder::XCOMPONENT;
458 }
459 
SetNotifySelectedCallback( OnNotifySelectedStatusCallback&& callback)460 void ImageAnalyzerManager::SetNotifySelectedCallback(
461     OnNotifySelectedStatusCallback&& callback)
462 {
463     analyzerUIConfig_.onNotifySelectedStatus = std::move(callback);
464 }
465 
SetOnCanPlayCallback( OnCanPlayCallback&& onCanPlay)466 void ImageAnalyzerManager::SetOnCanPlayCallback(
467     OnCanPlayCallback&& onCanPlay)
468 {
469     analyzerUIConfig_.onCanPlay = std::move(onCanPlay);
470 }
471 } // namespace OHOS::Ace