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 <cmath>
17 #include <media_errors.h>
18 #include <sstream>
19 #include <unordered_map>
20 #include "common/log.h"
21 #include "media_utils.h"
22 #include "iservice_registry.h"
23 #include "bundle_mgr_interface.h"
24 #include "system_ability_definition.h"
25 #include <unordered_set>
26 #include "media_log.h"
27 #include "parameter.h"
28 
29 namespace {
30 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = { LOG_CORE, LOG_DOMAIN_SYSTEM_PLAYER, "MediaUtils" };
31 }
32 
33 namespace OHOS {
34 namespace Media {
35 namespace {
36 const std::pair<Status, int> g_statusPair[] = {
37     {Status::OK, MSERR_OK},
38     {Status::ERROR_UNKNOWN, MSERR_UNKNOWN},
39     {Status::ERROR_AGAIN, MSERR_UNKNOWN},
40     {Status::ERROR_UNIMPLEMENTED, MSERR_UNSUPPORT},
41     {Status::ERROR_INVALID_PARAMETER, MSERR_INVALID_VAL},
42     {Status::ERROR_INVALID_OPERATION, MSERR_INVALID_OPERATION},
43     {Status::ERROR_UNSUPPORTED_FORMAT, MSERR_UNSUPPORT_CONTAINER_TYPE},
44     {Status::ERROR_NOT_EXISTED, MSERR_OPEN_FILE_FAILED},
45     {Status::ERROR_TIMED_OUT, MSERR_EXT_TIMEOUT},
46     {Status::ERROR_NO_MEMORY, MSERR_EXT_NO_MEMORY},
47     {Status::ERROR_INVALID_STATE, MSERR_INVALID_STATE},
48 };
49 const std::array<std::pair<PlaybackRateMode, float>, 10> PLAY_RATE_REFS = {
50     std::make_pair(PlaybackRateMode::SPEED_FORWARD_0_75_X, 0.75),
51     std::make_pair(PlaybackRateMode::SPEED_FORWARD_1_00_X, 1.0),
52     std::make_pair(PlaybackRateMode::SPEED_FORWARD_1_25_X, 1.25),
53     std::make_pair(PlaybackRateMode::SPEED_FORWARD_1_75_X, 1.75),
54     std::make_pair(PlaybackRateMode::SPEED_FORWARD_2_00_X, 2.00),
55     std::make_pair(PlaybackRateMode::SPEED_FORWARD_0_50_X, 0.50),
56     std::make_pair(PlaybackRateMode::SPEED_FORWARD_1_50_X, 1.50),
57     std::make_pair(PlaybackRateMode::SPEED_FORWARD_3_00_X, 3.00),
58     std::make_pair(PlaybackRateMode::SPEED_FORWARD_0_25_X, 0.25),
59     std::make_pair(PlaybackRateMode::SPEED_FORWARD_0_125_X, 0.125),
60 };
61 
62 static int g_readSysParaIdx = 0;
63 static std::unordered_map<std::string, std::string> g_readSysParaMap;
64 }  // namespace
65 
GetClientBundleName(int32_t uid, bool shouldLog)66 std::string __attribute__((visibility("default"))) GetClientBundleName(int32_t uid, bool shouldLog)
67 {
68     if (uid == 1003) { // 1003 is bootanimation uid
69         return "bootanimation";
70     }
71     std::string bundleName = "";
72     auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
73     if (samgr == nullptr) {
74         MEDIA_LOG_E("Get ability manager failed");
75         return bundleName;
76     }
77 
78     sptr<IRemoteObject> object = samgr->GetSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID);
79     if (object == nullptr) {
80         MEDIA_LOG_E("object is NULL.");
81         return bundleName;
82     }
83 
84     sptr<OHOS::AppExecFwk::IBundleMgr> bms = iface_cast<OHOS::AppExecFwk::IBundleMgr>(object);
85     if (bms == nullptr) {
86         MEDIA_LOG_E("bundle manager service is NULL.");
87         return bundleName;
88     }
89 
90     auto result = bms->GetNameForUid(uid, bundleName);
91     if (result != ERR_OK) {
92         MEDIA_LOG_E("Error GetBundleNameForUid fail");
93         return "";
94     }
95     MEDIA_LOG_I("bundle name is %{public}s ", bundleName.c_str());
96 
97     return bundleName;
98 }
99 
GetBundleResourceLabel(std::string bundleName)100 std::string __attribute__((visibility("default"))) GetBundleResourceLabel(std::string bundleName)
101 {
102     auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
103     if (samgr == nullptr) {
104         MEDIA_LOG_E("Get ability manager failed");
105         return bundleName;
106     }
107 
108     sptr<IRemoteObject> object = samgr->GetSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID);
109     if (object == nullptr) {
110         MEDIA_LOG_E("object is NULL.");
111         return bundleName;
112     }
113 
114     sptr<OHOS::AppExecFwk::IBundleMgr> bms = iface_cast<OHOS::AppExecFwk::IBundleMgr>(object);
115     if (bms == nullptr) {
116         MEDIA_LOG_E("bundle manager service is NULL.");
117         return bundleName;
118     }
119 
120     auto bundleResourceProxy = bms->GetBundleResourceProxy();
121     if (bundleResourceProxy == nullptr) {
122         MEDIA_LOG_E("GetBundleResourceProxy fail");
123         return bundleName;
124     }
125     AppExecFwk::BundleResourceInfo resourceInfo;
126     auto result = bundleResourceProxy->GetBundleResourceInfo(bundleName,
127         static_cast<uint32_t>(OHOS::AppExecFwk::ResourceFlag::GET_RESOURCE_INFO_ALL), resourceInfo);
128     if (result != ERR_OK) {
129         MEDIA_LOG_E("GetBundleResourceInfo failed");
130         return bundleName;
131     }
132     MEDIA_LOG_I("bundle resource label is %{public}s ", (resourceInfo.label).c_str());
133     return resourceInfo.label;
134 }
135 
136 
TransStatus(Status status)137 int __attribute__((visibility("default"))) TransStatus(Status status)
138 {
139     for (const auto& errPair : g_statusPair) {
140         if (errPair.first == status) {
141             return errPair.second;
142         }
143     }
144     return MSERR_UNKNOWN;
145 }
146 
TransStateId2PlayerState(PlayerStateId state)147 PlayerStates __attribute__((visibility("default"))) TransStateId2PlayerState(PlayerStateId state)
148 {
149     PlayerStates playerState = PLAYER_STATE_ERROR;
150     switch (state) {
151         case PlayerStateId::IDLE:
152             playerState = PLAYER_IDLE;
153             break;
154         case PlayerStateId::INIT:
155             playerState = PLAYER_INITIALIZED;
156             break;
157         case PlayerStateId::PREPARING:
158             playerState = PLAYER_PREPARING;
159             break;
160         case PlayerStateId::READY:
161             playerState = PLAYER_PREPARED;
162             break;
163         case PlayerStateId::PAUSE:
164             playerState = PLAYER_PAUSED;
165             break;
166         case PlayerStateId::PLAYING:
167             playerState = PLAYER_STARTED;
168             break;
169         case PlayerStateId::STOPPED:
170             playerState = PLAYER_STOPPED;
171             break;
172         case PlayerStateId::EOS:
173             playerState = PLAYER_PLAYBACK_COMPLETE;
174             break;
175         default:
176             break;
177     }
178     return playerState;
179 }
180 
Transform2SeekMode(PlayerSeekMode mode)181 Plugins::SeekMode __attribute__((visibility("default"))) Transform2SeekMode(PlayerSeekMode mode)
182 {
183     switch (mode) {
184         case PlayerSeekMode::SEEK_NEXT_SYNC:
185             return Plugins::SeekMode::SEEK_NEXT_SYNC;
186         case PlayerSeekMode::SEEK_PREVIOUS_SYNC:
187             return Plugins::SeekMode::SEEK_PREVIOUS_SYNC;
188         case PlayerSeekMode::SEEK_CLOSEST_SYNC:
189             return Plugins::SeekMode::SEEK_CLOSEST_SYNC;
190         case PlayerSeekMode::SEEK_CLOSEST:
191         default:
192             return Plugins::SeekMode::SEEK_CLOSEST;
193     }
194 }
StringnessPlayerState(PlayerStates state)195 const std::string& __attribute__((visibility("default"))) StringnessPlayerState(PlayerStates state)
196 {
197     using StateString = std::pair<PlayerStates, std::string>;
198     const static std::array<StateString, 9> maps = { // array size
199         std::make_pair(PlayerStates::PLAYER_STATE_ERROR, "state error"),
200         std::make_pair(PlayerStates::PLAYER_IDLE, "idle"),
201         std::make_pair(PlayerStates::PLAYER_INITIALIZED, "init"),
202         std::make_pair(PlayerStates::PLAYER_PREPARING, "preparing"),
203         std::make_pair(PlayerStates::PLAYER_PREPARED, "prepared"),
204         std::make_pair(PlayerStates::PLAYER_STARTED, "started"),
205         std::make_pair(PlayerStates::PLAYER_PAUSED, "paused"),
206         std::make_pair(PlayerStates::PLAYER_STOPPED, "stopped"),
207         std::make_pair(PlayerStates::PLAYER_PLAYBACK_COMPLETE, "completed"),
208     };
209     const static std::string UNKNOWN = "unknown";
210     auto ite = std::find_if(maps.begin(), maps.end(), [&] (const StateString& item) -> bool {
211         return item.first == state;
212     });
213     if (ite == maps.end()) {
214         return UNKNOWN;
215     }
216     return ite->second;
217 }
TransformPlayRate2Float(PlaybackRateMode rateMode)218 float __attribute__((visibility("default"))) TransformPlayRate2Float(PlaybackRateMode rateMode)
219 {
220     auto ite = std::find_if(PLAY_RATE_REFS.begin(), PLAY_RATE_REFS.end(), [&](const auto& pair) ->bool {
221         return pair.first == rateMode;
222     });
223     if (ite == PLAY_RATE_REFS.end()) {
224         return 1.0f;
225     }
226     return ite->second;
227 }
TransformFloat2PlayRate(float rate)228 PlaybackRateMode __attribute__((visibility("default"))) TransformFloat2PlayRate(float rate)
229 {
230     auto ite = std::find_if(PLAY_RATE_REFS.begin(), PLAY_RATE_REFS.end(), [&](const auto& pair) ->bool {
231         return std::fabs(rate - pair.second) < 1e-3;
232     });
233     if (ite == PLAY_RATE_REFS.end()) {
234         return PlaybackRateMode::SPEED_FORWARD_1_00_X;
235     }
236     return ite->first;
237 }
238 
IsEnableOptimizeDecode()239 bool __attribute__((visibility("default"))) IsEnableOptimizeDecode()
240 {
241     char useOptimizeDecode[10] = {0}; // 10: system param usage
242     auto res = GetParameter("debug.media_service.optimize_decode", "1", useOptimizeDecode, sizeof(useOptimizeDecode));
243     return res == 1 && useOptimizeDecode[0] == '1';
244 }
245 
IsAppEnableRenderFirstFrame(int32_t uid)246 bool __attribute__((visibility("default"))) IsAppEnableRenderFirstFrame(int32_t uid)
247 {
248     return uid != 1003; // 1003 is bootanimation uid
249 }
250 
GetPackageName(const char *key, std::string &value)251 bool __attribute__((visibility("default"))) GetPackageName(const char *key, std::string &value)
252 {
253     CHECK_AND_RETURN_RET_LOG(key != nullptr, false, "key is nullptr");
254     char paraValue[100] = {0};   // 100 for system parameter
255     auto res = GetParameter(key, "-1", paraValue, sizeof(paraValue));
256 
257     CHECK_AND_RETURN_RET_LOG(res > 0, false, "GetSysPara fail, key:%{public}s res:%{public}d", key, res);
258     std::stringstream valueStr;
259     valueStr << paraValue;
260     valueStr >> value;
261     MEDIA_LOG_I("Config parameter %{public}s : %{public}s", key, value.c_str());
262     return true;
263 }
264 
GetScreenCaptureSystemParam()265 std::unordered_map<std::string, std::string> __attribute__((visibility("default"))) GetScreenCaptureSystemParam()
266 {
267     if (g_readSysParaIdx == 0) {
268         GetPackageName("const.multimedia.screencapture.dialogconnectionbundlename",
269             g_readSysParaMap["const.multimedia.screencapture.dialogconnectionbundlename"]);
270         GetPackageName("const.multimedia.screencapture.dialogconnectionabilityname",
271             g_readSysParaMap["const.multimedia.screencapture.dialogconnectionabilityname"]);
272         GetPackageName("const.multimedia.screencapture.screenrecorderbundlename",
273             g_readSysParaMap["const.multimedia.screencapture.screenrecorderbundlename"]);
274         GetPackageName("const.multimedia.screencapture.screenrecorderabilityname",
275             g_readSysParaMap["const.multimedia.screencapture.screenrecorderabilityname"]);
276         GetPackageName("const.multimedia.screencapture.hiviewcarebundlename",
277             g_readSysParaMap["const.multimedia.screencapture.hiviewcarebundlename"]);
278         g_readSysParaIdx++;
279     }
280     return g_readSysParaMap;
281 }
282 }  // namespace Media
283 }  // namespace OHOS
284