1 /* 2 * Copyright (C) 2015 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #include <base/format_macros.h> 18 #include <base/logging.h> 19 #include <base/strings/stringprintf.h> 20 #include <binderwrapper/binder_wrapper.h> 21 #include <nativepower/power_manager_stub.h> 22 #include <utils/String8.h> 23 24 #include "wake_lock_manager_stub.h" 25 26 namespace android { 27 28 PowerManagerStub::SuspendRequest::SuspendRequest(int64_t event_time_ms, 29 int reason, 30 int flags) 31 : event_time_ms(event_time_ms), 32 reason(reason), 33 flags(flags) {} 34 35 // static 36 std::string PowerManagerStub::ConstructWakeLockString( 37 const std::string& tag, 38 const std::string& package, 39 uid_t uid) { 40 return WakeLockManagerStub::ConstructRequestString(tag, package, uid); 41 } 42 43 // static 44 std::string PowerManagerStub::ConstructSuspendRequestString( 45 int64_t event_time_ms, 46 int reason, 47 int flags) { 48 return base::StringPrintf("%" PRId64 ",%d,%d", event_time_ms, reason, flags); 49 } 50 51 PowerManagerStub::PowerManagerStub() 52 : wake_lock_manager_(new WakeLockManagerStub()) {} 53 54 PowerManagerStub::~PowerManagerStub() = default; 55 56 int PowerManagerStub::GetNumWakeLocks() const { 57 return wake_lock_manager_->num_requests(); 58 } 59 60 std::string PowerManagerStub::GetWakeLockString( 61 const sp<IBinder>& binder) const { 62 return wake_lock_manager_->GetRequestString(binder); 63 } 64 65 std::string PowerManagerStub::GetSuspendRequestString(size_t index) const { 66 if (index >= suspend_requests_.size()) 67 return std::string(); 68 69 const SuspendRequest& request = suspend_requests_[index]; 70 return ConstructSuspendRequestString(request.event_time_ms, request.reason, 71 request.flags); 72 } 73 74 status_t PowerManagerStub::acquireWakeLock(int flags, 75 const sp<IBinder>& lock, 76 const String16& tag, 77 const String16& packageName, 78 bool isOneWay) { 79 CHECK(wake_lock_manager_->AddRequest(lock, String8(tag).string(), 80 String8(packageName).string(), 81 BinderWrapper::Get()->GetCallingUid())); 82 return OK; 83 } 84 85 status_t PowerManagerStub::acquireWakeLockWithUid(int flags, 86 const sp<IBinder>& lock, 87 const String16& tag, 88 const String16& packageName, 89 int uid, 90 bool isOneWay) { 91 CHECK(wake_lock_manager_->AddRequest(lock, String8(tag).string(), 92 String8(packageName).string(), 93 static_cast<uid_t>(uid))); 94 return OK; 95 } 96 97 status_t PowerManagerStub::releaseWakeLock(const sp<IBinder>& lock, 98 int flags, 99 bool isOneWay) { 100 CHECK(wake_lock_manager_->RemoveRequest(lock)); 101 return OK; 102 } 103 104 status_t PowerManagerStub::updateWakeLockUids(const sp<IBinder>& lock, 105 int len, 106 const int* uids, 107 bool isOneWay) { 108 return OK; 109 } 110 111 status_t PowerManagerStub::powerHint(int hintId, int data) { 112 return OK; 113 } 114 115 status_t PowerManagerStub::goToSleep(int64_t event_time_ms, 116 int reason, 117 int flags) { 118 suspend_requests_.emplace_back(event_time_ms, reason, flags); 119 return OK; 120 } 121 122 status_t PowerManagerStub::reboot(bool confirm, 123 const String16& reason, 124 bool wait) { 125 reboot_reasons_.push_back(String8(reason).string()); 126 return OK; 127 } 128 129 status_t PowerManagerStub::shutdown(bool confirm, 130 const String16& reason, 131 bool wait) { 132 shutdown_reasons_.push_back(String8(reason).string()); 133 return OK; 134 } 135 136 status_t PowerManagerStub::crash(const String16& message) { 137 return OK; 138 } 139 140 } // namespace android 141