+++ /dev/null
-/*
- * Copyright (C) 2007 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef ANDROID_GUI_ISURFACE_H
-#define ANDROID_GUI_ISURFACE_H
-
-#include <stdint.h>
-#include <sys/types.h>
-
-#include <utils/Errors.h>
-#include <utils/RefBase.h>
-
-#include <binder/IInterface.h>
-
-#include <ui/PixelFormat.h>
-
-namespace android {
-
-class IGraphicBufferProducer;
-
-class ISurface : public IInterface
-{
-protected:
- enum {
- GET_SURFACE_TEXTURE = IBinder::FIRST_CALL_TRANSACTION,
- };
-
-public:
- DECLARE_META_INTERFACE(Surface);
-
- virtual sp<IGraphicBufferProducer> getSurfaceTexture() const = 0;
-};
-
-// ----------------------------------------------------------------------------
-
-class BnSurface : public BnInterface<ISurface>
-{
-public:
- virtual status_t onTransact( uint32_t code,
- const Parcel& data,
- Parcel* reply,
- uint32_t flags = 0);
-};
-
-// ----------------------------------------------------------------------------
-
-}; // namespace android
-
-#endif // ANDROID_GUI_ISURFACE_H
#include <ui/PixelFormat.h>
-#include <gui/ISurface.h>
-
namespace android {
// ----------------------------------------------------------------------------
+class IGraphicBufferProducer;
+
class ISurfaceComposerClient : public IInterface
{
public:
/*
* Requires ACCESS_SURFACE_FLINGER permission
*/
- virtual sp<ISurface> createSurface(
+ virtual status_t createSurface(
const String8& name, uint32_t w, uint32_t h,
- PixelFormat format, uint32_t flags) = 0;
+ PixelFormat format, uint32_t flags,
+ sp<IBinder>* handle,
+ sp<IGraphicBufferProducer>* gbp) = 0;
/*
* Requires ACCESS_SURFACE_FLINGER permission
#include <ui/PixelFormat.h>
#include <ui/Region.h>
-#include <gui/ISurface.h>
#include <gui/ISurfaceComposerClient.h>
namespace android {
static bool isValid(const sp<SurfaceControl>& surface) {
return (surface != 0) && surface->isValid();
}
+
bool isValid() {
- return mSurface!=0 && mClient!=0;
+ return mHandle!=0 && mClient!=0;
}
+
static bool isSameSurface(
const sp<SurfaceControl>& lhs, const sp<SurfaceControl>& rhs);
SurfaceControl(
const sp<SurfaceComposerClient>& client,
- const sp<ISurface>& surface);
+ const sp<IBinder>& handle,
+ const sp<IGraphicBufferProducer>& gbp);
~SurfaceControl();
void destroy();
sp<SurfaceComposerClient> mClient;
- sp<IBinder> mSurface;
+ sp<IBinder> mHandle;
sp<IGraphicBufferProducer> mGraphicBufferProducer;
mutable Mutex mLock;
mutable sp<Surface> mSurfaceData;
#include <ui/Region.h>
#include <ui/Rect.h>
-#include <gui/ISurface.h>
namespace android {
IGraphicBufferProducer.cpp \
ISensorEventConnection.cpp \
ISensorServer.cpp \
- ISurface.cpp \
ISurfaceComposer.cpp \
ISurfaceComposerClient.cpp \
LayerState.cpp \
+++ /dev/null
-/*
- * Copyright (C) 2007 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#define LOG_TAG "ISurface"
-
-#include <stdio.h>
-#include <stdint.h>
-#include <sys/types.h>
-
-#include <binder/Parcel.h>
-
-#include <gui/ISurface.h>
-#include <gui/IGraphicBufferProducer.h>
-
-namespace android {
-
-// ----------------------------------------------------------------------
-
-class BpSurface : public BpInterface<ISurface>
-{
-public:
- BpSurface(const sp<IBinder>& impl)
- : BpInterface<ISurface>(impl)
- {
- }
-
- virtual sp<IGraphicBufferProducer> getSurfaceTexture() const {
- Parcel data, reply;
- data.writeInterfaceToken(ISurface::getInterfaceDescriptor());
- remote()->transact(GET_SURFACE_TEXTURE, data, &reply);
- return interface_cast<IGraphicBufferProducer>(reply.readStrongBinder());
- }
-};
-
-IMPLEMENT_META_INTERFACE(Surface, "android.ui.ISurface");
-
-// ----------------------------------------------------------------------
-
-status_t BnSurface::onTransact(
- uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
-{
- switch(code) {
- case GET_SURFACE_TEXTURE: {
- CHECK_INTERFACE(ISurface, data, reply);
- reply->writeStrongBinder( getSurfaceTexture()->asBinder() );
- return NO_ERROR;
- }
- default:
- return BBinder::onTransact(code, data, reply, flags);
- }
-}
-
-}; // namespace android
#include <ui/Point.h>
#include <ui/Rect.h>
-#include <gui/ISurface.h>
+#include <gui/IGraphicBufferProducer.h>
#include <gui/ISurfaceComposerClient.h>
#include <private/gui/LayerState.h>
{
public:
BpSurfaceComposerClient(const sp<IBinder>& impl)
- : BpInterface<ISurfaceComposerClient>(impl)
- {
+ : BpInterface<ISurfaceComposerClient>(impl) {
}
- virtual sp<ISurface> createSurface( const String8& name,
- uint32_t w,
- uint32_t h,
- PixelFormat format,
- uint32_t flags)
- {
+ virtual status_t createSurface(const String8& name, uint32_t w,
+ uint32_t h, PixelFormat format, uint32_t flags,
+ sp<IBinder>* handle,
+ sp<IGraphicBufferProducer>* gbp) {
Parcel data, reply;
data.writeInterfaceToken(ISurfaceComposerClient::getInterfaceDescriptor());
data.writeString8(name);
data.writeInt32(format);
data.writeInt32(flags);
remote()->transact(CREATE_SURFACE, data, &reply);
- return interface_cast<ISurface>(reply.readStrongBinder());
+ *handle = reply.readStrongBinder();
+ *gbp = interface_cast<IGraphicBufferProducer>(reply.readStrongBinder());
+ return reply.readInt32();
}
- virtual status_t destroySurface(const sp<IBinder>& handle)
- {
+ virtual status_t destroySurface(const sp<IBinder>& handle) {
Parcel data, reply;
data.writeInterfaceToken(ISurfaceComposerClient::getInterfaceDescriptor());
data.writeStrongBinder(handle);
uint32_t h = data.readInt32();
PixelFormat format = data.readInt32();
uint32_t flags = data.readInt32();
- sp<ISurface> s = createSurface(name, w, h, format, flags);
- reply->writeStrongBinder(s->asBinder());
+ sp<IBinder> handle;
+ sp<IGraphicBufferProducer> gbp;
+ status_t result = createSurface(name, w, h, format, flags,
+ &handle, &gbp);
+ reply->writeStrongBinder(handle);
+ reply->writeStrongBinder(gbp->asBinder());
+ reply->writeInt32(result);
return NO_ERROR;
} break;
case DESTROY_SURFACE: {
#include <ui/DisplayInfo.h>
#include <gui/IGraphicBufferProducer.h>
-#include <gui/ISurface.h>
#include <gui/ISurfaceComposer.h>
#include <gui/ISurfaceComposerClient.h>
#include <gui/SurfaceComposerClient.h>
PixelFormat format,
uint32_t flags)
{
- sp<SurfaceControl> result;
+ sp<SurfaceControl> sur;
if (mStatus == NO_ERROR) {
- sp<ISurface> surface = mClient->createSurface(name, w, h, format, flags);
- if (surface != 0) {
- result = new SurfaceControl(this, surface);
+ sp<IBinder> handle;
+ sp<IGraphicBufferProducer> gbp;
+ status_t err = mClient->createSurface(name, w, h, format, flags,
+ &handle, &gbp);
+ ALOGE_IF(err, "SurfaceComposerClient::createSurface error %s", strerror(-err));
+ if (err == NO_ERROR) {
+ sur = new SurfaceControl(this, handle, gbp);
}
}
- return result;
+ return sur;
}
sp<IBinder> SurfaceComposerClient::createDisplay(const String8& displayName,
#include <ui/GraphicBuffer.h>
#include <ui/Rect.h>
-#include <gui/ISurface.h>
#include <gui/ISurfaceComposer.h>
#include <gui/Surface.h>
#include <gui/SurfaceComposerClient.h>
SurfaceControl::SurfaceControl(
const sp<SurfaceComposerClient>& client,
- const sp<ISurface>& surface)
- : mClient(client)
+ const sp<IBinder>& handle,
+ const sp<IGraphicBufferProducer>& gbp)
+ : mClient(client), mHandle(handle), mGraphicBufferProducer(gbp)
{
- if (surface != 0) {
- mSurface = surface->asBinder();
- mGraphicBufferProducer = surface->getSurfaceTexture();
- }
}
SurfaceControl::~SurfaceControl()
void SurfaceControl::destroy()
{
if (isValid()) {
- mClient->destroySurface(mSurface);
+ mClient->destroySurface(mHandle);
}
// clear all references and trigger an IPC now, to make sure things
// happen without delay, since these resources are quite heavy.
mClient.clear();
- mSurface.clear();
+ mHandle.clear();
mGraphicBufferProducer.clear();
IPCThreadState::self()->flushCommands();
}
{
if (lhs == 0 || rhs == 0)
return false;
- return lhs->mSurface == rhs->mSurface;
+ return lhs->mHandle == rhs->mHandle;
}
status_t SurfaceControl::setLayerStack(int32_t layerStack) {
status_t err = validate();
if (err < 0) return err;
const sp<SurfaceComposerClient>& client(mClient);
- return client->setLayerStack(mSurface, layerStack);
+ return client->setLayerStack(mHandle, layerStack);
}
status_t SurfaceControl::setLayer(int32_t layer) {
status_t err = validate();
if (err < 0) return err;
const sp<SurfaceComposerClient>& client(mClient);
- return client->setLayer(mSurface, layer);
+ return client->setLayer(mHandle, layer);
}
status_t SurfaceControl::setPosition(int32_t x, int32_t y) {
status_t err = validate();
if (err < 0) return err;
const sp<SurfaceComposerClient>& client(mClient);
- return client->setPosition(mSurface, x, y);
+ return client->setPosition(mHandle, x, y);
}
status_t SurfaceControl::setSize(uint32_t w, uint32_t h) {
status_t err = validate();
if (err < 0) return err;
const sp<SurfaceComposerClient>& client(mClient);
- return client->setSize(mSurface, w, h);
+ return client->setSize(mHandle, w, h);
}
status_t SurfaceControl::hide() {
status_t err = validate();
if (err < 0) return err;
const sp<SurfaceComposerClient>& client(mClient);
- return client->hide(mSurface);
+ return client->hide(mHandle);
}
status_t SurfaceControl::show() {
status_t err = validate();
if (err < 0) return err;
const sp<SurfaceComposerClient>& client(mClient);
- return client->show(mSurface);
+ return client->show(mHandle);
}
status_t SurfaceControl::setFlags(uint32_t flags, uint32_t mask) {
status_t err = validate();
if (err < 0) return err;
const sp<SurfaceComposerClient>& client(mClient);
- return client->setFlags(mSurface, flags, mask);
+ return client->setFlags(mHandle, flags, mask);
}
status_t SurfaceControl::setTransparentRegionHint(const Region& transparent) {
status_t err = validate();
if (err < 0) return err;
const sp<SurfaceComposerClient>& client(mClient);
- return client->setTransparentRegionHint(mSurface, transparent);
+ return client->setTransparentRegionHint(mHandle, transparent);
}
status_t SurfaceControl::setAlpha(float alpha) {
status_t err = validate();
if (err < 0) return err;
const sp<SurfaceComposerClient>& client(mClient);
- return client->setAlpha(mSurface, alpha);
+ return client->setAlpha(mHandle, alpha);
}
status_t SurfaceControl::setMatrix(float dsdx, float dtdx, float dsdy, float dtdy) {
status_t err = validate();
if (err < 0) return err;
const sp<SurfaceComposerClient>& client(mClient);
- return client->setMatrix(mSurface, dsdx, dtdx, dsdy, dtdy);
+ return client->setMatrix(mHandle, dsdx, dtdx, dsdy, dtdy);
}
status_t SurfaceControl::setCrop(const Rect& crop) {
status_t err = validate();
if (err < 0) return err;
const sp<SurfaceComposerClient>& client(mClient);
- return client->setCrop(mSurface, crop);
+ return client->setCrop(mHandle, crop);
}
status_t SurfaceControl::validate() const
{
- if (mSurface==0 || mClient==0) {
- ALOGE("invalid ISurface (%p) or client (%p)",
- mSurface.get(), mClient.get());
+ if (mHandle==0 || mClient==0) {
+ ALOGE("invalid handle (%p) or client (%p)",
+ mHandle.get(), mClient.get());
return NO_INIT;
}
return NO_ERROR;
}
-sp<ISurface> Client::createSurface(
+status_t Client::createSurface(
const String8& name,
- uint32_t w, uint32_t h, PixelFormat format,
- uint32_t flags)
+ uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
+ sp<IBinder>* handle,
+ sp<IGraphicBufferProducer>* gbp)
{
/*
* createSurface must be called from the GL thread so that it can
*/
class MessageCreateLayer : public MessageBase {
- sp<ISurface> result;
SurfaceFlinger* flinger;
Client* client;
+ sp<IBinder>* handle;
+ sp<IGraphicBufferProducer>* gbp;
+ status_t result;
const String8& name;
uint32_t w, h;
PixelFormat format;
public:
MessageCreateLayer(SurfaceFlinger* flinger,
const String8& name, Client* client,
- uint32_t w, uint32_t h, PixelFormat format,
- uint32_t flags)
- : flinger(flinger), client(client), name(name),
- w(w), h(h), format(format), flags(flags)
- {
+ uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
+ sp<IBinder>* handle,
+ sp<IGraphicBufferProducer>* gbp)
+ : flinger(flinger), client(client),
+ handle(handle), gbp(gbp),
+ name(name), w(w), h(h), format(format), flags(flags) {
}
- sp<ISurface> getResult() const { return result; }
+ status_t getResult() const { return result; }
virtual bool handler() {
- result = flinger->createLayer(name, client, w, h, format, flags);
+ result = flinger->createLayer(name, client, w, h, format, flags,
+ handle, gbp);
return true;
}
};
sp<MessageBase> msg = new MessageCreateLayer(mFlinger.get(),
- name, this, w, h, format, flags);
+ name, this, w, h, format, flags, handle, gbp);
mFlinger->postMessageSync(msg);
return static_cast<MessageCreateLayer*>( msg.get() )->getResult();
}
private:
// ISurfaceComposerClient interface
- virtual sp<ISurface> createSurface(
+ virtual status_t createSurface(
const String8& name,
- uint32_t w, uint32_t h,PixelFormat format,
- uint32_t flags);
+ uint32_t w, uint32_t h,PixelFormat format, uint32_t flags,
+ sp<IBinder>* handle,
+ sp<IGraphicBufferProducer>* gbp);
virtual status_t destroySurface(const sp<IBinder>& handle);
int32_t Layer::sSequence = 1;
-Layer::Layer(SurfaceFlinger* flinger, const sp<Client>& client)
+Layer::Layer(SurfaceFlinger* flinger, const sp<Client>& client,
+ const String8& name, uint32_t w, uint32_t h, uint32_t flags)
: contentDirty(false),
sequence(uint32_t(android_atomic_inc(&sSequence))),
mFlinger(flinger),
{
mCurrentCrop.makeInvalid();
glGenTextures(1, &mTextureName);
+
+ uint32_t layerFlags = 0;
+ if (flags & ISurfaceComposerClient::eHidden)
+ layerFlags = layer_state_t::eLayerHidden;
+
+ if (flags & ISurfaceComposerClient::eNonPremultiplied)
+ mPremultipliedAlpha = false;
+
+ mName = name;
+
+ mCurrentState.active.w = w;
+ mCurrentState.active.h = h;
+ mCurrentState.active.crop.makeInvalid();
+ mCurrentState.z = 0;
+ mCurrentState.alpha = 0xFF;
+ mCurrentState.layerStack = 0;
+ mCurrentState.flags = layerFlags;
+ mCurrentState.sequence = 0;
+ mCurrentState.transform.set(0, 0);
+ mCurrentState.requested = mCurrentState.active;
+
+ // drawing state & current state are identical
+ mDrawingState = mCurrentState;
}
void Layer::onFirstRef()
mSurfaceFlingerConsumer->setConsumerUsageBits(getEffectiveUsage(0));
mSurfaceFlingerConsumer->setFrameAvailableListener(this);
mSurfaceFlingerConsumer->setSynchronousMode(true);
+ mSurfaceFlingerConsumer->setName(mName);
#ifdef TARGET_DISABLE_TRIPLE_BUFFERING
#warning "disabling triple buffering"
updateTransformHint(hw);
}
-Layer::~Layer()
-{
+Layer::~Layer() {
sp<Client> c(mClientRef.promote());
if (c != 0) {
c->detachLayer(this);
// set-up
// ---------------------------------------------------------------------------
-void Layer::setName(const String8& name) {
- mName = name;
- mSurfaceFlingerConsumer->setName(name);
-}
-
String8 Layer::getName() const {
return mName;
}
-void Layer::initStates(uint32_t w, uint32_t h, uint32_t flags)
-{
- uint32_t layerFlags = 0;
- if (flags & ISurfaceComposerClient::eHidden)
- layerFlags = layer_state_t::eLayerHidden;
-
- if (flags & ISurfaceComposerClient::eNonPremultiplied)
- mPremultipliedAlpha = false;
-
- mCurrentState.active.w = w;
- mCurrentState.active.h = h;
- mCurrentState.active.crop.makeInvalid();
- mCurrentState.z = 0;
- mCurrentState.alpha = 0xFF;
- mCurrentState.layerStack = 0;
- mCurrentState.flags = layerFlags;
- mCurrentState.sequence = 0;
- mCurrentState.transform.set(0, 0);
- mCurrentState.requested = mCurrentState.active;
-
- // drawing state & current state are identical
- mDrawingState = mCurrentState;
-}
-
status_t Layer::setBuffers( uint32_t w, uint32_t h,
PixelFormat format, uint32_t flags)
{
return NO_ERROR;
}
-sp<ISurface> Layer::createSurface() {
+sp<IBinder> Layer::getHandle() {
+ Mutex::Autolock _l(mLock);
+
+ LOG_ALWAYS_FATAL_IF(mHasSurface,
+ "Layer::getHandle() has already been called");
+
+ mHasSurface = true;
+
/*
- * This class provides an implementation of BnSurface (the "native" or
- * "remote" side of the Binder IPC interface ISurface), and mixes in
- * LayerCleaner to ensure that mFlinger->onLayerDestroyed() is called for
- * this layer when the BSurface is destroyed.
- *
- * The idea is to provide a handle to the Layer through ISurface that
- * is cleaned up automatically when the last reference to the ISurface
- * goes away. (The references will be held on the "proxy" side, while
- * the Layer exists on the "native" side.)
+ * The layer handle is just a BBinder object passed to the client
+ * (remote process) -- we don't keep any reference on our side such that
+ * the dtor is called when the remote side let go of its reference.
*
- * The Layer has a reference to an instance of SurfaceFlinger's variant
- * of GLConsumer, which holds a reference to the BufferQueue. The
- * getSurfaceTexture() call returns a Binder interface reference for
- * the producer interface of the buffer queue associated with the Layer.
+ * LayerCleaner ensures that mFlinger->onLayerDestroyed() is called for
+ * this layer when the handle is destroyed.
*/
- class BSurface : public BnSurface, public LayerCleaner {
+
+ class Handle : public BBinder, public LayerCleaner {
wp<const Layer> mOwner;
- virtual sp<IGraphicBufferProducer> getSurfaceTexture() const {
- sp<IGraphicBufferProducer> res;
- sp<const Layer> that( mOwner.promote() );
- if (that != NULL) {
- res = that->mSurfaceFlingerConsumer->getBufferQueue();
- }
- return res;
- }
public:
- BSurface(const sp<SurfaceFlinger>& flinger,
- const sp<Layer>& layer)
- : LayerCleaner(flinger, layer), mOwner(layer) { }
+ Handle(const sp<SurfaceFlinger>& flinger, const sp<Layer>& layer)
+ : LayerCleaner(flinger, layer), mOwner(layer) {
+ }
};
- sp<ISurface> sur(new BSurface(mFlinger, this));
- return sur;
-}
-wp<IBinder> Layer::getSurfaceTextureBinder() const {
- return mSurfaceFlingerConsumer->getBufferQueue()->asBinder();
+ return new Handle(mFlinger, this);
}
-sp<ISurface> Layer::getSurface()
-{
- sp<ISurface> s;
- Mutex::Autolock _l(mLock);
-
- LOG_ALWAYS_FATAL_IF(mHasSurface,
- "Layer::getSurface() has already been called");
-
- mHasSurface = true;
- s = createSurface();
- return s;
+sp<BufferQueue> Layer::getBufferQueue() const {
+ return mSurfaceFlingerConsumer->getBufferQueue();
}
+//virtual sp<IGraphicBufferProducer> getSurfaceTexture() const {
+// sp<IGraphicBufferProducer> res;
+// sp<const Layer> that( mOwner.promote() );
+// if (that != NULL) {
+// res = that->mSurfaceFlingerConsumer->getBufferQueue();
+// }
+// return res;
+//}
+
// ---------------------------------------------------------------------------
// h/w composer set-up
// ---------------------------------------------------------------------------
// -----------------------------------------------------------------------
- Layer(SurfaceFlinger* flinger, const sp<Client>& client);
+ Layer(SurfaceFlinger* flinger, const sp<Client>& client,
+ const String8& name, uint32_t w, uint32_t h, uint32_t flags);
virtual ~Layer();
// the this layer's size and format
- status_t setBuffers(uint32_t w, uint32_t h,
- PixelFormat format, uint32_t flags=0);
-
- // Creates an ISurface associated with this object. This may only be
- // called once. to provide your own ISurface, override createSurface().
- sp<ISurface> getSurface();
+ status_t setBuffers(uint32_t w, uint32_t h, PixelFormat format, uint32_t flags);
// modify current state
bool setPosition(float x, float y);
void computeGeometry(const sp<const DisplayDevice>& hw, LayerMesh* mesh) const;
Rect computeBounds() const;
- // -----------------------------------------------------------------------
+ sp<IBinder> getHandle();
+ sp<BufferQueue> getBufferQueue() const;
+ String8 getName() const;
- /*
- * initStates - called just after construction
- */
- virtual void initStates(uint32_t w, uint32_t h, uint32_t flags);
+ // -----------------------------------------------------------------------
virtual const char* getTypeId() const { return "Layer"; }
- virtual void setName(const String8& name);
- String8 getName() const;
-
virtual void setGeometry(const sp<const DisplayDevice>& hw,
HWComposer::HWCLayerInterface& layer);
virtual void setPerFrameData(const sp<const DisplayDevice>& hw,
virtual void onRemoved();
- virtual wp<IBinder> getSurfaceTextureBinder() const;
-
// Updates the transform hint in our SurfaceFlingerConsumer to match
// the current orientation of the display device.
virtual void updateTransformHint(const sp<const DisplayDevice>& hw) const;
private:
- // Creates an instance of ISurface for this Layer.
- virtual sp<ISurface> createSurface();
-
// Interface implementation for SurfaceFlingerConsumer::FrameAvailableListener
virtual void onFrameAvailable();
// protected by mLock
mutable Mutex mLock;
- // Set to true if an ISurface has been associated with this object.
+ // Set to true once we've returned this surface's handle
mutable bool mHasSurface;
const wp<Client> mClientRef;
};
namespace android {
// ---------------------------------------------------------------------------
-LayerDim::LayerDim(SurfaceFlinger* flinger, const sp<Client>& client)
- : Layer(flinger, client) {
+LayerDim::LayerDim(SurfaceFlinger* flinger, const sp<Client>& client,
+ const String8& name, uint32_t w, uint32_t h, uint32_t flags)
+ : Layer(flinger, client, name, w, h, flags) {
}
LayerDim::~LayerDim() {
}
}
-sp<ISurface> LayerDim::createSurface()
-{
- class BSurface : public BnSurface, public LayerCleaner {
- virtual sp<IGraphicBufferProducer> getSurfaceTexture() const { return 0; }
- public:
- BSurface(const sp<SurfaceFlinger>& flinger,
- const sp<Layer>& layer)
- : LayerCleaner(flinger, layer) { }
- };
- sp<ISurface> sur(new BSurface(mFlinger, this));
- return sur;
-}
-
bool LayerDim::isVisible() const {
const Layer::State& s(drawingState());
return !(s.flags & layer_state_t::eLayerHidden) && s.alpha;
class LayerDim : public Layer
{
public:
- LayerDim(SurfaceFlinger* flinger, const sp<Client>& client);
+ LayerDim(SurfaceFlinger* flinger, const sp<Client>& client,
+ const String8& name, uint32_t w, uint32_t h, uint32_t flags);
virtual ~LayerDim();
virtual void onDraw(const sp<const DisplayDevice>& hw, const Region& clip) const;
virtual bool isFixedSize() const { return true; }
virtual bool isVisible() const;
- virtual sp<ISurface> createSurface();
};
// ---------------------------------------------------------------------------
size_t count = currentLayers.size();
for (size_t i=0 ; i<count ; i++) {
const sp<Layer>& layer(currentLayers[i]);
- // If this is an instance of Layer (as opposed to, say, LayerDim),
- // we will get the consumer interface of SurfaceFlingerConsumer's
+ // Get the consumer interface of SurfaceFlingerConsumer's
// BufferQueue. If it's the same Binder object as the graphic
// buffer producer interface, return success.
- wp<IBinder> lbcBinder = layer->getSurfaceTextureBinder();
+ sp<IBinder> lbcBinder = layer->getBufferQueue()->asBinder();
if (lbcBinder == surfaceTextureBinder) {
return true;
}
size_t purgatorySize = mLayerPurgatory.size();
for (size_t i=0 ; i<purgatorySize ; i++) {
const sp<Layer>& layer(mLayerPurgatory.itemAt(i));
- wp<IBinder> lbcBinder = layer->getSurfaceTextureBinder();
+ sp<IBinder> lbcBinder = layer->getBufferQueue()->asBinder();
if (lbcBinder == surfaceTextureBinder) {
return true;
}
// it's possible that we don't find a layer, because it might
// have been destroyed already -- this is not technically an error
// from the user because there is a race between Client::destroySurface(),
- // ~Client() and ~ISurface().
+ // ~Client() and ~LayerCleaner().
return (err == NAME_NOT_FOUND) ? status_t(NO_ERROR) : err;
}
return flags;
}
-sp<ISurface> SurfaceFlinger::createLayer(
+status_t SurfaceFlinger::createLayer(
const String8& name,
const sp<Client>& client,
- uint32_t w, uint32_t h, PixelFormat format,
- uint32_t flags)
+ uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
+ sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp)
{
- sp<Layer> layer;
- sp<ISurface> surfaceHandle;
-
+ //ALOGD("createLayer for (%d x %d), name=%s", w, h, name.string());
if (int32_t(w|h) < 0) {
ALOGE("createLayer() failed, w or h is negative (w=%d, h=%d)",
int(w), int(h));
- return surfaceHandle;
+ return BAD_VALUE;
}
- //ALOGD("createLayer for (%d x %d), name=%s", w, h, name.string());
+ status_t result = NO_ERROR;
+
+ sp<Layer> layer;
+
switch (flags & ISurfaceComposerClient::eFXSurfaceMask) {
case ISurfaceComposerClient::eFXSurfaceNormal:
- layer = createNormalLayer(client, w, h, flags, format);
+ result = createNormalLayer(client,
+ name, w, h, flags, format,
+ handle, gbp, &layer);
break;
case ISurfaceComposerClient::eFXSurfaceDim:
- layer = createDimLayer(client, w, h, flags);
+ result = createDimLayer(client,
+ name, w, h, flags,
+ handle, gbp, &layer);
+ break;
+ default:
+ result = BAD_VALUE;
break;
}
- if (layer != 0) {
- layer->initStates(w, h, flags);
- layer->setName(name);
- surfaceHandle = layer->getSurface();
- if (surfaceHandle != 0) {
- addClientLayer(client, surfaceHandle->asBinder(), layer);
- }
+ if (result == NO_ERROR) {
+ addClientLayer(client, *handle, layer);
setTransactionFlags(eTransactionNeeded);
}
-
- return surfaceHandle;
+ return result;
}
-sp<Layer> SurfaceFlinger::createNormalLayer(
- const sp<Client>& client,
- uint32_t w, uint32_t h, uint32_t flags,
- PixelFormat& format)
+status_t SurfaceFlinger::createNormalLayer(const sp<Client>& client,
+ const String8& name, uint32_t w, uint32_t h, uint32_t flags, PixelFormat& format,
+ sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp, sp<Layer>* outLayer)
{
// initialize the surfaces
switch (format) {
format = PIXEL_FORMAT_RGBA_8888;
#endif
- sp<Layer> layer = new Layer(this, client);
- status_t err = layer->setBuffers(w, h, format, flags);
- if (CC_LIKELY(err != NO_ERROR)) {
- ALOGE("createNormalLayer() failed (%s)", strerror(-err));
- layer.clear();
+ *outLayer = new Layer(this, client, name, w, h, flags);
+ status_t err = (*outLayer)->setBuffers(w, h, format, flags);
+ if (err == NO_ERROR) {
+ *handle = (*outLayer)->getHandle();
+ *gbp = (*outLayer)->getBufferQueue();
}
- return layer;
+
+ ALOGE_IF(err, "createNormalLayer() failed (%s)", strerror(-err));
+ return err;
}
-sp<LayerDim> SurfaceFlinger::createDimLayer(
- const sp<Client>& client,
- uint32_t w, uint32_t h, uint32_t flags)
+status_t SurfaceFlinger::createDimLayer(const sp<Client>& client,
+ const String8& name, uint32_t w, uint32_t h, uint32_t flags,
+ sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp, sp<Layer>* outLayer)
{
- sp<LayerDim> layer = new LayerDim(this, client);
- return layer;
+ *outLayer = new LayerDim(this, client, name, w, h, flags);
+ *handle = (*outLayer)->getHandle();
+ *gbp = (*outLayer)->getBufferQueue();
+ return NO_ERROR;
}
status_t SurfaceFlinger::onLayerRemoved(const sp<Client>& client, const sp<IBinder>& handle)
status_t SurfaceFlinger::onLayerDestroyed(const wp<Layer>& layer)
{
- // called by ~ISurface() when all references are gone
+ // called by ~LayerCleaner() when all references are gone
status_t err = NO_ERROR;
sp<Layer> l(layer.promote());
if (l != NULL) {
/* ------------------------------------------------------------------------
* Layer management
*/
- sp<ISurface> createLayer(const String8& name, const sp<Client>& client,
- uint32_t w, uint32_t h, PixelFormat format, uint32_t flags);
-
- sp<Layer> createNormalLayer(const sp<Client>& client,
- uint32_t w, uint32_t h, uint32_t flags, PixelFormat& format);
-
- sp<LayerDim> createDimLayer(const sp<Client>& client,
- uint32_t w, uint32_t h, uint32_t flags);
+ status_t createLayer(const String8& name, const sp<Client>& client,
+ uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
+ sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp);
+
+ status_t createNormalLayer(const sp<Client>& client, const String8& name,
+ uint32_t w, uint32_t h, uint32_t flags, PixelFormat& format,
+ sp<IBinder>* outHandle, sp<IGraphicBufferProducer>* outGbp,
+ sp<Layer>* outLayer);
+
+ status_t createDimLayer(const sp<Client>& client, const String8& name,
+ uint32_t w, uint32_t h, uint32_t flags, sp<IBinder>* outHandle,
+ sp<IGraphicBufferProducer>* outGbp, sp<Layer>* outLayer);
// called in response to the window-manager calling
// ISurfaceComposerClient::destroySurface()
OSDN Git Service
