1 /* 2 ** 3 ** Copyright 2015, The Android Open Source Project 4 ** 5 ** Licensed under the Apache License, Version 2.0 (the "License"); 6 ** you may not use this file except in compliance with the License. 7 ** You may obtain a copy of the License at 8 ** 9 ** http://www.apache.org/licenses/LICENSE-2.0 10 ** 11 ** Unless required by applicable law or agreed to in writing, software 12 ** distributed under the License is distributed on an "AS IS" BASIS, 13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 ** See the License for the specific language governing permissions and 15 ** limitations under the License. 16 */ 17 18 #ifndef ANDROID_RESOURCEMANAGERSERVICE_H 19 #define ANDROID_RESOURCEMANAGERSERVICE_H 20 21 #include <arpa/inet.h> 22 #include <binder/BinderService.h> 23 #include <utils/Errors.h> 24 #include <utils/KeyedVector.h> 25 #include <utils/String8.h> 26 #include <utils/threads.h> 27 #include <utils/Vector.h> 28 29 #include <media/IResourceManagerService.h> 30 31 namespace android { 32 33 class ServiceLog; 34 struct ProcessInfoInterface; 35 36 struct ResourceInfo { 37 int64_t clientId; 38 sp<IResourceManagerClient> client; 39 sp<IBinder::DeathRecipient> deathNotifier; 40 Vector<MediaResource> resources; 41 bool cpuBoost; 42 }; 43 44 typedef Vector<ResourceInfo> ResourceInfos; 45 typedef KeyedVector<int, ResourceInfos> PidResourceInfosMap; 46 47 class ResourceManagerService 48 : public BinderService<ResourceManagerService>, 49 public BnResourceManagerService 50 { 51 public: getServiceName()52 static char const *getServiceName() { return "media.resource_manager"; } 53 54 virtual status_t dump(int fd, const Vector<String16>& args); 55 56 ResourceManagerService(); 57 explicit ResourceManagerService(sp<ProcessInfoInterface> processInfo); 58 59 // IResourceManagerService interface 60 virtual void config(const Vector<MediaResourcePolicy> &policies); 61 62 virtual void addResource( 63 int pid, 64 int64_t clientId, 65 const sp<IResourceManagerClient> client, 66 const Vector<MediaResource> &resources); 67 68 virtual void removeResource(int pid, int64_t clientId); 69 70 // Tries to reclaim resource from processes with lower priority than the calling process 71 // according to the requested resources. 72 // Returns true if any resource has been reclaimed, otherwise returns false. 73 virtual bool reclaimResource(int callingPid, const Vector<MediaResource> &resources); 74 75 void removeResource(int pid, int64_t clientId, bool checkValid); 76 77 protected: 78 virtual ~ResourceManagerService(); 79 80 private: 81 friend class ResourceManagerServiceTest; 82 83 // Gets the list of all the clients who own the specified resource type. 84 // Returns false if any client belongs to a process with higher priority than the 85 // calling process. The clients will remain unchanged if returns false. 86 bool getAllClients_l(int callingPid, MediaResource::Type type, 87 Vector<sp<IResourceManagerClient>> *clients); 88 89 // Gets the client who owns specified resource type from lowest possible priority process. 90 // Returns false if the calling process priority is not higher than the lowest process 91 // priority. The client will remain unchanged if returns false. 92 bool getLowestPriorityBiggestClient_l(int callingPid, MediaResource::Type type, 93 sp<IResourceManagerClient> *client); 94 95 // Gets lowest priority process that has the specified resource type. 96 // Returns false if failed. The output parameters will remain unchanged if failed. 97 bool getLowestPriorityPid_l(MediaResource::Type type, int *pid, int *priority); 98 99 // Gets the client who owns biggest piece of specified resource type from pid. 100 // Returns false if failed. The client will remain unchanged if failed. 101 bool getBiggestClient_l(int pid, MediaResource::Type type, sp<IResourceManagerClient> *client); 102 103 bool isCallingPriorityHigher_l(int callingPid, int pid); 104 105 // A helper function basically calls getLowestPriorityBiggestClient_l and add the result client 106 // to the given Vector. 107 void getClientForResource_l( 108 int callingPid, const MediaResource *res, Vector<sp<IResourceManagerClient>> *clients); 109 110 mutable Mutex mLock; 111 sp<ProcessInfoInterface> mProcessInfo; 112 sp<ServiceLog> mServiceLog; 113 PidResourceInfosMap mMap; 114 bool mSupportsMultipleSecureCodecs; 115 bool mSupportsSecureWithNonSecureCodec; 116 int32_t mCpuBoostCount; 117 }; 118 119 // ---------------------------------------------------------------------------- 120 121 }; // namespace android 122 123 #endif // ANDROID_RESOURCEMANAGERSERVICE_H 124