1 /*
2  * Copyright (c) 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 #ifndef TEMP_PERMISSION_OBSERVER_H
17 #define TEMP_PERMISSION_OBSERVER_H
18 
19 #include <mutex>
20 #include <vector>
21 #include <string>
22 
23 #include "access_token.h"
24 #ifdef EVENTHANDLER_ENABLE
25 #include "access_event_handler.h"
26 #endif
27 #include "app_manager_death_callback.h"
28 #include "app_manager_death_recipient.h"
29 #include "app_status_change_callback.h"
30 #ifdef BGTASKMGR_CONTINUOUS_TASK_ENABLE
31 #include "continuous_task_change_callback.h"
32 #endif
33 #include "form_status_change_callback.h"
34 #include "permission_manager.h"
35 
36 namespace OHOS {
37 namespace Security {
38 namespace AccessToken {
39 class PermissionAppStateObserver : public ApplicationStateObserverStub {
40 public:
41     PermissionAppStateObserver() = default;
42     ~PermissionAppStateObserver() = default;
43 
44     void OnAppStopped(const AppStateData &appStateData) override;
45     void OnAppStateChanged(const AppStateData &appStateData) override;
46 
47     DISALLOW_COPY_AND_MOVE(PermissionAppStateObserver);
48 };
49 
50 class PermissionFormStateObserver : public FormStateObserverStub {
51 public:
52     PermissionFormStateObserver() = default;
53     ~PermissionFormStateObserver() = default;
54 
55     int32_t NotifyWhetherFormsVisible(const FormVisibilityType visibleType,
56         const std::string &bundleName, std::vector<FormInstance> &formInstances) override;
57     DISALLOW_COPY_AND_MOVE(PermissionFormStateObserver);
58 };
59 #ifdef BGTASKMGR_CONTINUOUS_TASK_ENABLE
60 class PermissionBackgroundTaskObserver : public BackgroundTaskSubscriberStub {
61 public:
62     PermissionBackgroundTaskObserver() = default;
63     ~PermissionBackgroundTaskObserver() = default;
64 
65     void OnContinuousTaskStart(const std::shared_ptr<ContinuousTaskCallbackInfo> &continuousTaskCallbackInfo) override;
66     void OnContinuousTaskStop(const std::shared_ptr<ContinuousTaskCallbackInfo> &continuousTaskCallbackInfo) override;
67 
68     DISALLOW_COPY_AND_MOVE(PermissionBackgroundTaskObserver);
69 };
70 #endif
71 class PermissionAppManagerDeathCallback : public AppManagerDeathCallback {
72 public:
73     PermissionAppManagerDeathCallback() = default;
74     ~PermissionAppManagerDeathCallback() = default;
75 
76     void NotifyAppManagerDeath() override;
77     DISALLOW_COPY_AND_MOVE(PermissionAppManagerDeathCallback);
78 };
79 
80 class TempPermissionObserver {
81 public:
82     static TempPermissionObserver& GetInstance();
83     TempPermissionObserver();
84     virtual ~TempPermissionObserver();
85 
86     void OnAppMgrRemoteDiedHandle();
87 
88     bool IsAllowGrantTempPermission(AccessTokenID tokenID, const std::string& permissionName);
89     void AddTempPermTokenToList(AccessTokenID tokenID,
90         const std::string& bundleName, const std::string& permissionName, const std::vector<bool>& list);
91     void RevokeAllTempPermission(AccessTokenID tokenID);
92     bool GetPermissionStateFull(AccessTokenID tokenID, std::vector<PermissionStateFull>& permissionStateFullList);
93     bool GetAppStateListByTokenID(AccessTokenID tokenID, std::vector<bool>& list);
94     void ModifyAppState(AccessTokenID tokenID, int32_t index, bool flag);
95     bool GetTokenIDByBundle(const std::string &bundleName, AccessTokenID& tokenID);
96 #ifdef EVENTHANDLER_ENABLE
97     void InitEventHandler(const std::shared_ptr<AccessEventHandler>& eventHandler);
98     void GetConfigValue();
99 #endif
100     bool DelayRevokePermission(AccessToken::AccessTokenID tokenId, const std::string& taskName);
101     bool CancleTaskOfPermissionRevoking(const std::string& taskName);
102     void RegisterCallback();
103     void RegisterAppStatusListener();
104     void UnRegisterCallback();
105     int32_t NotifyWhetherFormsVisible(const FormVisibilityType visibleType,
106         const std::string &bundleName, std::vector<FormInstance> &formInstances);
107 #ifdef BGTASKMGR_CONTINUOUS_TASK_ENABLE
108     void OnContinuousTaskStart(const std::shared_ptr<ContinuousTaskCallbackInfo> &continuousTaskCallbackInfo);
109     void OnContinuousTaskStop(const std::shared_ptr<ContinuousTaskCallbackInfo> &continuousTaskCallbackInfo);
110 #endif
111 
112 private:
113 #ifdef EVENTHANDLER_ENABLE
114     std::shared_ptr<AccessEventHandler> eventHandler_;
115 #endif
116     int32_t cancleTimes_;
117     std::mutex tempPermissionMutex_;
118     std::map<AccessTokenID, std::vector<bool>> tempPermTokenMap_;
119 
120     // appState
121     std::mutex appStateCallbackMutex_;
122     sptr<PermissionAppStateObserver> appStateCallback_ = nullptr;
123 #ifdef BGTASKMGR_CONTINUOUS_TASK_ENABLE
124     // backgroundTask
125     std::mutex backgroundTaskCallbackMutex_;
126     sptr<PermissionBackgroundTaskObserver> backgroundTaskCallback_ = nullptr;
127 #endif
128     // formState
129     std::mutex formStateCallbackMutex_;
130     sptr<PermissionFormStateObserver> formVisibleCallback_ = nullptr;
131     sptr<PermissionFormStateObserver> formInvisibleCallback_ = nullptr;
132     std::mutex formTokenMutex_;
133     std::map<std::string, AccessTokenID> formTokenMap_;
134 
135     // app manager death
136     std::mutex appManagerDeathMutex_;
137     std::shared_ptr<PermissionAppManagerDeathCallback> appManagerDeathCallback_ = nullptr;
138     DISALLOW_COPY_AND_MOVE(TempPermissionObserver);
139 };
140 } // namespace AccessToken
141 } // namespace Security
142 } // namespace OHOS
143 #endif // TEMP_PERMISSION_OBSERVER_H
144