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
29namespace {
30constexpr OHOS::HiviewDFX::HiLogLabel LABEL = { LOG_CORE, LOG_DOMAIN_SYSTEM_PLAYER, "MediaUtils" };
31}
32
33namespace OHOS {
34namespace Media {
35namespace {
36const 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};
49const 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
62static int g_readSysParaIdx = 0;
63static std::unordered_map<std::string, std::string> g_readSysParaMap;
64}  // namespace
65
66std::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
100std::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
137int __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
147PlayerStates __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
181Plugins::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}
195const 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}
218float __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}
228PlaybackRateMode __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
239bool __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
246bool __attribute__((visibility("default"))) IsAppEnableRenderFirstFrame(int32_t uid)
247{
248    return uid != 1003; // 1003 is bootanimation uid
249}
250
251bool __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
265std::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