1 /*
2 * Copyright (C) 2012 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 <stdint.h>
18 #include <sys/types.h>
19
20 #include <binder/PermissionCache.h>
21 #include <binder/IPCThreadState.h>
22
23 #include <private/android_filesystem_config.h>
24
25 #include "Client.h"
26 #include "Layer.h"
27 #include "SurfaceFlinger.h"
28
29 namespace android {
30
31 // ---------------------------------------------------------------------------
32
33 const String16 sAccessSurfaceFlinger("android.permission.ACCESS_SURFACE_FLINGER");
34
35 // ---------------------------------------------------------------------------
36
Client(const sp<SurfaceFlinger> & flinger)37 Client::Client(const sp<SurfaceFlinger>& flinger)
38 : mFlinger(flinger)
39 {
40 }
41
~Client()42 Client::~Client()
43 {
44 const size_t count = mLayers.size();
45 for (size_t i=0 ; i<count ; i++) {
46 sp<Layer> layer(mLayers.valueAt(i).promote());
47 if (layer != 0) {
48 mFlinger->removeLayer(layer);
49 }
50 }
51 }
52
initCheck() const53 status_t Client::initCheck() const {
54 return NO_ERROR;
55 }
56
attachLayer(const sp<IBinder> & handle,const sp<Layer> & layer)57 void Client::attachLayer(const sp<IBinder>& handle, const sp<Layer>& layer)
58 {
59 Mutex::Autolock _l(mLock);
60 mLayers.add(handle, layer);
61 }
62
detachLayer(const Layer * layer)63 void Client::detachLayer(const Layer* layer)
64 {
65 Mutex::Autolock _l(mLock);
66 // we do a linear search here, because this doesn't happen often
67 const size_t count = mLayers.size();
68 for (size_t i=0 ; i<count ; i++) {
69 if (mLayers.valueAt(i) == layer) {
70 mLayers.removeItemsAt(i, 1);
71 break;
72 }
73 }
74 }
getLayerUser(const sp<IBinder> & handle) const75 sp<Layer> Client::getLayerUser(const sp<IBinder>& handle) const
76 {
77 Mutex::Autolock _l(mLock);
78 sp<Layer> lbc;
79 wp<Layer> layer(mLayers.valueFor(handle));
80 if (layer != 0) {
81 lbc = layer.promote();
82 ALOGE_IF(lbc==0, "getLayerUser(name=%p) is dead", handle.get());
83 }
84 return lbc;
85 }
86
87
onTransact(uint32_t code,const Parcel & data,Parcel * reply,uint32_t flags)88 status_t Client::onTransact(
89 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
90 {
91 // these must be checked
92 IPCThreadState* ipc = IPCThreadState::self();
93 const int pid = ipc->getCallingPid();
94 const int uid = ipc->getCallingUid();
95 const int self_pid = getpid();
96 if (CC_UNLIKELY(pid != self_pid && uid != AID_GRAPHICS && uid != 0)) {
97 // we're called from a different process, do the real check
98 if (!PermissionCache::checkCallingPermission(sAccessSurfaceFlinger))
99 {
100 ALOGE("Permission Denial: "
101 "can't openGlobalTransaction pid=%d, uid=%d", pid, uid);
102 return PERMISSION_DENIED;
103 }
104 }
105 return BnSurfaceComposerClient::onTransact(code, data, reply, flags);
106 }
107
108
createSurface(const String8 & name,uint32_t w,uint32_t h,PixelFormat format,uint32_t flags,sp<IBinder> * handle,sp<IGraphicBufferProducer> * gbp)109 status_t Client::createSurface(
110 const String8& name,
111 uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
112 sp<IBinder>* handle,
113 sp<IGraphicBufferProducer>* gbp)
114 {
115 /*
116 * createSurface must be called from the GL thread so that it can
117 * have access to the GL context.
118 */
119
120 class MessageCreateLayer : public MessageBase {
121 SurfaceFlinger* flinger;
122 Client* client;
123 sp<IBinder>* handle;
124 sp<IGraphicBufferProducer>* gbp;
125 status_t result;
126 const String8& name;
127 uint32_t w, h;
128 PixelFormat format;
129 uint32_t flags;
130 public:
131 MessageCreateLayer(SurfaceFlinger* flinger,
132 const String8& name, Client* client,
133 uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
134 sp<IBinder>* handle,
135 sp<IGraphicBufferProducer>* gbp)
136 : flinger(flinger), client(client),
137 handle(handle), gbp(gbp),
138 name(name), w(w), h(h), format(format), flags(flags) {
139 }
140 status_t getResult() const { return result; }
141 virtual bool handler() {
142 result = flinger->createLayer(name, client, w, h, format, flags,
143 handle, gbp);
144 return true;
145 }
146 };
147
148 sp<MessageBase> msg = new MessageCreateLayer(mFlinger.get(),
149 name, this, w, h, format, flags, handle, gbp);
150 mFlinger->postMessageSync(msg);
151 return static_cast<MessageCreateLayer*>( msg.get() )->getResult();
152 }
153
destroySurface(const sp<IBinder> & handle)154 status_t Client::destroySurface(const sp<IBinder>& handle) {
155 return mFlinger->onLayerRemoved(this, handle);
156 }
157
clearLayerFrameStats(const sp<IBinder> & handle) const158 status_t Client::clearLayerFrameStats(const sp<IBinder>& handle) const {
159 sp<Layer> layer = getLayerUser(handle);
160 if (layer == NULL) {
161 return NAME_NOT_FOUND;
162 }
163 layer->clearFrameStats();
164 return NO_ERROR;
165 }
166
getLayerFrameStats(const sp<IBinder> & handle,FrameStats * outStats) const167 status_t Client::getLayerFrameStats(const sp<IBinder>& handle, FrameStats* outStats) const {
168 sp<Layer> layer = getLayerUser(handle);
169 if (layer == NULL) {
170 return NAME_NOT_FOUND;
171 }
172 layer->getFrameStats(outStats);
173 return NO_ERROR;
174 }
175
176 // ---------------------------------------------------------------------------
177 }; // namespace android
178