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
31namespace android {
32
33class ServiceLog;
34struct ProcessInfoInterface;
35
36struct ResourceInfo {
37    int64_t clientId;
38    sp<IResourceManagerClient> client;
39    sp<IBinder::DeathRecipient> deathNotifier;
40    Vector<MediaResource> resources;
41};
42
43typedef Vector<ResourceInfo> ResourceInfos;
44typedef KeyedVector<int, ResourceInfos> PidResourceInfosMap;
45
46class ResourceManagerService
47    : public BinderService<ResourceManagerService>,
48      public BnResourceManagerService
49{
50public:
51    static char const *getServiceName() { return "media.resource_manager"; }
52
53    virtual status_t dump(int fd, const Vector<String16>& args);
54
55    ResourceManagerService();
56    explicit ResourceManagerService(sp<ProcessInfoInterface> processInfo);
57
58    // IResourceManagerService interface
59    virtual void config(const Vector<MediaResourcePolicy> &policies);
60
61    virtual void addResource(
62            int pid,
63            int64_t clientId,
64            const sp<IResourceManagerClient> client,
65            const Vector<MediaResource> &resources);
66
67    virtual void removeResource(int pid, int64_t clientId);
68
69    // Tries to reclaim resource from processes with lower priority than the calling process
70    // according to the requested resources.
71    // Returns true if any resource has been reclaimed, otherwise returns false.
72    virtual bool reclaimResource(int callingPid, const Vector<MediaResource> &resources);
73
74    void removeResource(int pid, int64_t clientId, bool checkValid);
75
76protected:
77    virtual ~ResourceManagerService();
78
79private:
80    friend class ResourceManagerServiceTest;
81
82    // Gets the list of all the clients who own the specified resource type.
83    // Returns false if any client belongs to a process with higher priority than the
84    // calling process. The clients will remain unchanged if returns false.
85    bool getAllClients_l(int callingPid, MediaResource::Type type,
86            Vector<sp<IResourceManagerClient>> *clients);
87
88    // Gets the client who owns specified resource type from lowest possible priority process.
89    // Returns false if the calling process priority is not higher than the lowest process
90    // priority. The client will remain unchanged if returns false.
91    bool getLowestPriorityBiggestClient_l(int callingPid, MediaResource::Type type,
92            sp<IResourceManagerClient> *client);
93
94    // Gets lowest priority process that has the specified resource type.
95    // Returns false if failed. The output parameters will remain unchanged if failed.
96    bool getLowestPriorityPid_l(MediaResource::Type type, int *pid, int *priority);
97
98    // Gets the client who owns biggest piece of specified resource type from pid.
99    // Returns false if failed. The client will remain unchanged if failed.
100    bool getBiggestClient_l(int pid, MediaResource::Type type, sp<IResourceManagerClient> *client);
101
102    bool isCallingPriorityHigher_l(int callingPid, int pid);
103
104    // A helper function basically calls getLowestPriorityBiggestClient_l and add the result client
105    // to the given Vector.
106    void getClientForResource_l(
107        int callingPid, const MediaResource *res, Vector<sp<IResourceManagerClient>> *clients);
108
109    mutable Mutex mLock;
110    sp<ProcessInfoInterface> mProcessInfo;
111    sp<ServiceLog> mServiceLog;
112    PidResourceInfosMap mMap;
113    bool mSupportsMultipleSecureCodecs;
114    bool mSupportsSecureWithNonSecureCodec;
115};
116
117// ----------------------------------------------------------------------------
118
119}; // namespace android
120
121#endif // ANDROID_RESOURCEMANAGERSERVICE_H
122