1 /*
2 * Copyright (c) 2023-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 "background_strategy.h"
17
18 #include "dp_log.h"
19 #include "dp_utils.h"
20
21 namespace OHOS {
22 namespace CameraStandard {
23
24 namespace {
25 constexpr int32_t DURATIONMS_25_SEC = 25 * 1000;
26 }
27
28 namespace DeferredProcessing {
BackgroundStrategy(const std::shared_ptr<PhotoJobRepository> & repository)29 BackgroundStrategy::BackgroundStrategy(const std::shared_ptr<PhotoJobRepository>& repository)
30 : repository_(repository)
31 {
32 DP_DEBUG_LOG("entered");
33 }
34
~BackgroundStrategy()35 BackgroundStrategy::~BackgroundStrategy()
36 {
37 DP_DEBUG_LOG("entered");
38 }
39
GetWork()40 DeferredPhotoWorkPtr BackgroundStrategy::GetWork()
41 {
42 DP_DEBUG_LOG("entered");
43 ExecutionMode mode = GetExecutionMode();
44 if (mode == ExecutionMode::DUMMY) {
45 return nullptr;
46 }
47 DeferredPhotoJobPtr jobPtr = GetJob();
48 if (jobPtr == nullptr) {
49 return nullptr;
50 }
51 return std::make_shared<DeferredPhotoWork>(jobPtr, mode);
52 }
53
GetJob()54 DeferredPhotoJobPtr BackgroundStrategy::GetJob()
55 {
56 DP_DEBUG_LOG("entered");
57 DeferredPhotoJobPtr jobPtr = nullptr;
58 jobPtr = repository_->GetNormalPriorityJob();
59 if (jobPtr == nullptr) {
60 jobPtr = repository_->GetLowPriorityJob();
61 }
62 return jobPtr;
63 }
64
GetExecutionMode()65 ExecutionMode BackgroundStrategy::GetExecutionMode()
66 {
67 DP_DEBUG_LOG("entered");
68 if (cameraSessionStatus_ == CameraSessionStatus::SYSTEM_CAMERA_OPEN
69 || cameraSessionStatus_ == CameraSessionStatus::NORMAL_CAMERA_OPEN
70 || !(hdiStatus_ == HdiStatus::HDI_READY || hdiStatus_ == HdiStatus::HDI_READY_SPACE_LIMIT_REACHED)
71 || mediaLibraryStatus_ != MediaLibraryStatus::MEDIA_LIBRARY_AVAILABLE) {
72 DP_INFO_LOG("DPS_PHOTO: cameraStatus: %{public}d, hdiStatus: %{public}d, mediaStatus: %{public}d",
73 cameraSessionStatus_, hdiStatus_, mediaLibraryStatus_);
74 return ExecutionMode::DUMMY;
75 }
76 FlashTrailingState();
77 DP_INFO_LOG("DPS_PHOTO: isInTrailing: %{public}d", isInTrailing_);
78 if (isInTrailing_) {
79 return ExecutionMode::LOAD_BALANCE;
80 }
81 DP_INFO_LOG("DPS_PHOTO: systemPressureLevel: %{public}d", systemPressureLevel_);
82 if (systemPressureLevel_ == SystemPressureLevel::NOMINAL) {
83 return ExecutionMode::LOAD_BALANCE;
84 }
85 return ExecutionMode::DUMMY;
86 }
87
GetHdiStatus()88 HdiStatus BackgroundStrategy::GetHdiStatus()
89 {
90 DP_INFO_LOG("hdiStatus_: %{public}d", hdiStatus_);
91 return hdiStatus_;
92 }
93
NotifyPressureLevelChanged(SystemPressureLevel level)94 void BackgroundStrategy::NotifyPressureLevelChanged(SystemPressureLevel level)
95 {
96 DP_INFO_LOG("previous system pressure level: %{public}d, new level: %{public}d", systemPressureLevel_, level);
97 systemPressureLevel_ = level;
98 }
99
NotifyHdiStatusChanged(HdiStatus status)100 void BackgroundStrategy::NotifyHdiStatusChanged(HdiStatus status)
101 {
102 DP_INFO_LOG("previous hdi status %{public}d, new status: %{public}d", hdiStatus_, status);
103 hdiStatus_ = status;
104 }
105
NotifyMediaLibStatusChanged(MediaLibraryStatus status)106 void BackgroundStrategy::NotifyMediaLibStatusChanged(MediaLibraryStatus status)
107 {
108 DP_INFO_LOG("previous media lib status %{public}d, new status: %{public}d", mediaLibraryStatus_, status);
109 mediaLibraryStatus_ = status;
110 }
111
NotifyCameraStatusChanged(CameraSessionStatus status)112 void BackgroundStrategy::NotifyCameraStatusChanged(CameraSessionStatus status)
113 {
114 DP_INFO_LOG("previous camera session status %{public}d, new status: %{public}d", cameraSessionStatus_, status);
115 cameraSessionStatus_ = status;
116 switch (status) {
117 case CameraSessionStatus::SYSTEM_CAMERA_CLOSED:
118 StartTrailing(DURATIONMS_25_SEC);
119 break;
120 case CameraSessionStatus::NORMAL_CAMERA_CLOSED:
121 StartTrailing(0);
122 break;
123 case CameraSessionStatus::SYSTEM_CAMERA_OPEN:
124 case CameraSessionStatus::NORMAL_CAMERA_OPEN:
125 StopTrailing();
126 break;
127 default:
128 break;
129 }
130 }
131
StartTrailing(uint64_t duration)132 void BackgroundStrategy::StartTrailing(uint64_t duration)
133 {
134 DP_INFO_LOG("entered, is in trailing: %{public}d", isInTrailing_);
135 if (duration <= 0) {
136 return;
137 }
138 if (isInTrailing_) {
139 auto passedTime = GetTimestampMilli() - trailingStartTimeStamp_;
140 if (passedTime >= remainingTrailingTime_) {
141 remainingTrailingTime_ = 0;
142 } else {
143 remainingTrailingTime_ = remainingTrailingTime_ - passedTime;
144 }
145 }
146 remainingTrailingTime_ = duration > remainingTrailingTime_ ? duration : remainingTrailingTime_;
147 trailingStartTimeStamp_ = GetTimestampMilli();
148 isInTrailing_ = true;
149 }
150
StopTrailing()151 void BackgroundStrategy::StopTrailing()
152 {
153 DP_INFO_LOG("entered, is in trailing: %{public}d", isInTrailing_);
154 if (isInTrailing_) {
155 auto passedTime = GetTimestampMilli() - trailingStartTimeStamp_;
156 if (passedTime >= remainingTrailingTime_) {
157 remainingTrailingTime_ = 0;
158 } else {
159 remainingTrailingTime_ = remainingTrailingTime_ - passedTime;
160 }
161 isInTrailing_ = false;
162 }
163 }
164
FlashTrailingState()165 void BackgroundStrategy::FlashTrailingState()
166 {
167 DP_INFO_LOG("entered, is in trailing: %{public}d", isInTrailing_);
168 if (isInTrailing_) {
169 auto passedTime = GetTimestampMilli() - trailingStartTimeStamp_;
170 if (passedTime >= remainingTrailingTime_) {
171 remainingTrailingTime_ = 0;
172 isInTrailing_ = false;
173 }
174 }
175 }
176 } // namespace DeferredProcessing
177 } // namespace CameraStandard
178 } // namespace OHOS