1 /* 2 * Copyright (C) 2022 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 "screenlock_manager.h" 17 18 #include <hitrace_meter.h> 19 20 #include "if_system_ability_manager.h" 21 #include "iservice_registry.h" 22 #include "sclock_log.h" 23 #include "screenlock_common.h" 24 #include "system_ability_definition.h" 25 26 namespace OHOS { 27 namespace ScreenLock { 28 std::mutex ScreenLockManager::instanceLock_; 29 sptr<ScreenLockManager> ScreenLockManager::instance_; 30 sptr<ScreenLockSaDeathRecipient> ScreenLockManager::deathRecipient_; 31 ScreenLockManager()32ScreenLockManager::ScreenLockManager() 33 { 34 } 35 ~ScreenLockManager()36ScreenLockManager::~ScreenLockManager() 37 { 38 } 39 GetInstance()40sptr<ScreenLockManager> ScreenLockManager::GetInstance() 41 { 42 if (instance_ == nullptr) { 43 std::lock_guard<std::mutex> autoLock(instanceLock_); 44 if (instance_ == nullptr) { 45 instance_ = new ScreenLockManager; 46 std::lock_guard<std::mutex> guard(instance_->managerProxyLock_); 47 instance_->screenlockManagerProxy_ = GetScreenLockManagerProxy(); 48 } 49 } 50 return instance_; 51 } 52 IsScreenLocked()53bool ScreenLockManager::IsScreenLocked() 54 { 55 auto proxy = GetProxy(); 56 if (proxy == nullptr) { 57 SCLOCK_HILOGE("IsScreenLocked quit because redoing GetScreenLockManagerProxy failed."); 58 return false; 59 } 60 SCLOCK_HILOGD("ScreenLockManager IsScreenLocked succeeded."); 61 return proxy->IsScreenLocked(); 62 } 63 GetSecure()64bool ScreenLockManager::GetSecure() 65 { 66 auto proxy = GetProxy(); 67 if (proxy == nullptr) { 68 SCLOCK_HILOGE("GetSecure quit because redoing GetScreenLockManagerProxy failed."); 69 return false; 70 } 71 SCLOCK_HILOGD("ScreenLockManager GetSecure succeeded."); 72 return proxy->GetSecure(); 73 } 74 RequestUnlock(const sptr<ScreenLockSystemAbilityInterface> & listener)75int32_t ScreenLockManager::RequestUnlock(const sptr<ScreenLockSystemAbilityInterface> &listener) 76 { 77 auto proxy = GetProxy(); 78 if (proxy == nullptr) { 79 SCLOCK_HILOGE("RequestUnlock quit because redoing GetScreenLockManagerProxy failed."); 80 return E_SCREENLOCK_NULLPTR; 81 } 82 if (listener == nullptr) { 83 SCLOCK_HILOGE("listener is nullptr."); 84 return E_SCREENLOCK_NULLPTR; 85 } 86 SCLOCK_HILOGD("ScreenLockManager RequestUnlock succeeded."); 87 StartAsyncTrace(HITRACE_TAG_MISC, "ScreenLockManager RequestUnlock start", HITRACE_UNLOCKSCREEN); 88 return proxy->RequestUnlock(listener); 89 } 90 RequestLock(const sptr<ScreenLockSystemAbilityInterface> & listener)91int32_t ScreenLockManager::RequestLock(const sptr<ScreenLockSystemAbilityInterface> &listener) 92 { 93 auto proxy = GetProxy(); 94 if (proxy == nullptr) { 95 SCLOCK_HILOGE("RequestLock quit because redoing GetScreenLockManagerProxy failed."); 96 return E_SCREENLOCK_NULLPTR; 97 } 98 if (listener == nullptr) { 99 SCLOCK_HILOGE("listener is nullptr."); 100 return E_SCREENLOCK_NULLPTR; 101 } 102 SCLOCK_HILOGD("ScreenLockManager RequestLock succeeded."); 103 return proxy->RequestLock(listener); 104 } 105 GetScreenLockManagerProxy()106sptr<ScreenLockManagerInterface> ScreenLockManager::GetScreenLockManagerProxy() 107 { 108 sptr<ISystemAbilityManager> systemAbilityManager = 109 SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); 110 if (systemAbilityManager == nullptr) { 111 SCLOCK_HILOGE("Getting SystemAbilityManager failed."); 112 return nullptr; 113 } 114 auto systemAbility = systemAbilityManager->GetSystemAbility(SCREENLOCK_SERVICE_ID, ""); 115 if (systemAbility == nullptr) { 116 SCLOCK_HILOGE("Get SystemAbility failed."); 117 return nullptr; 118 } 119 deathRecipient_ = new ScreenLockSaDeathRecipient(); 120 systemAbility->AddDeathRecipient(deathRecipient_); 121 sptr<ScreenLockManagerInterface> screenlockServiceProxy = iface_cast<ScreenLockManagerInterface>(systemAbility); 122 if (screenlockServiceProxy == nullptr) { 123 SCLOCK_HILOGE("Get ScreenLockManagerProxy from SA failed."); 124 return nullptr; 125 } 126 SCLOCK_HILOGD("Getting ScreenLockManagerProxy succeeded."); 127 return screenlockServiceProxy; 128 } 129 OnRemoteSaDied(const wptr<IRemoteObject> & remote)130void ScreenLockManager::OnRemoteSaDied(const wptr<IRemoteObject> &remote) 131 { 132 std::lock_guard<std::mutex> autoLock(managerProxyLock_); 133 screenlockManagerProxy_ = GetScreenLockManagerProxy(); 134 } 135 GetProxy()136sptr<ScreenLockManagerInterface> ScreenLockManager::GetProxy() 137 { 138 if (screenlockManagerProxy_ != nullptr) { 139 return screenlockManagerProxy_; 140 } 141 std::lock_guard<std::mutex> autoLock(managerProxyLock_); 142 if (screenlockManagerProxy_ == nullptr) { 143 SCLOCK_HILOGW("Redo GetScreenLockManagerProxy"); 144 screenlockManagerProxy_ = GetScreenLockManagerProxy(); 145 } 146 return screenlockManagerProxy_; 147 } 148 ScreenLockSaDeathRecipient()149ScreenLockSaDeathRecipient::ScreenLockSaDeathRecipient() 150 { 151 } 152 OnRemoteDied(const wptr<IRemoteObject> & object)153void ScreenLockSaDeathRecipient::OnRemoteDied(const wptr<IRemoteObject> &object) 154 { 155 SCLOCK_HILOGE("ScreenLockSaDeathRecipient on remote systemAbility died."); 156 ScreenLockManager::GetInstance()->OnRemoteSaDied(object); 157 } 158 } // namespace ScreenLock 159 } // namespace OHOS 160