2009-03-04 03:31:44 +00:00
|
|
|
/*
|
|
|
|
* 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_SURFACE_FLINGER_H
|
|
|
|
#define ANDROID_SURFACE_FLINGER_H
|
|
|
|
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <sys/types.h>
|
|
|
|
|
2011-12-15 17:51:17 +00:00
|
|
|
#include <cutils/compiler.h>
|
|
|
|
|
2009-03-04 03:31:44 +00:00
|
|
|
#include <utils/Atomic.h>
|
|
|
|
#include <utils/Errors.h>
|
2011-06-27 23:05:52 +00:00
|
|
|
#include <utils/KeyedVector.h>
|
2009-04-10 21:24:30 +00:00
|
|
|
#include <utils/RefBase.h>
|
2011-06-27 23:05:52 +00:00
|
|
|
#include <utils/SortedVector.h>
|
|
|
|
#include <utils/threads.h>
|
2009-03-04 03:31:44 +00:00
|
|
|
|
2010-07-15 01:41:18 +00:00
|
|
|
#include <binder/BinderService.h>
|
2011-06-27 23:05:52 +00:00
|
|
|
#include <binder/IMemory.h>
|
2009-06-16 01:24:59 +00:00
|
|
|
|
2009-03-04 03:31:44 +00:00
|
|
|
#include <ui/PixelFormat.h>
|
2012-02-26 02:48:35 +00:00
|
|
|
#include <gui/IGraphicBufferAlloc.h>
|
|
|
|
#include <gui/ISurfaceComposer.h>
|
|
|
|
#include <gui/ISurfaceComposerClient.h>
|
2009-03-04 03:31:44 +00:00
|
|
|
|
|
|
|
#include "Barrier.h"
|
|
|
|
#include "Layer.h"
|
|
|
|
|
2009-04-21 02:39:12 +00:00
|
|
|
#include "MessageQueue.h"
|
|
|
|
|
2009-03-04 03:31:44 +00:00
|
|
|
namespace android {
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
class Client;
|
|
|
|
class DisplayHardware;
|
2011-11-18 01:49:17 +00:00
|
|
|
class DisplayEventConnection;
|
|
|
|
class EventThread;
|
2009-03-04 03:31:44 +00:00
|
|
|
class Layer;
|
2010-06-01 22:12:58 +00:00
|
|
|
class LayerDim;
|
2011-10-13 23:02:48 +00:00
|
|
|
class LayerScreenshot;
|
2011-04-20 21:20:59 +00:00
|
|
|
struct surface_flinger_cblk_t;
|
2009-03-04 03:31:44 +00:00
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
|
2010-06-03 06:28:45 +00:00
|
|
|
class Client : public BnSurfaceComposerClient
|
2009-03-04 03:31:44 +00:00
|
|
|
{
|
2010-06-03 06:28:45 +00:00
|
|
|
public:
|
|
|
|
Client(const sp<SurfaceFlinger>& flinger);
|
|
|
|
~Client();
|
2009-03-04 03:31:44 +00:00
|
|
|
|
2010-06-03 06:28:45 +00:00
|
|
|
status_t initCheck() const;
|
|
|
|
|
|
|
|
// protected by SurfaceFlinger::mStateLock
|
2011-05-03 23:21:41 +00:00
|
|
|
size_t attachLayer(const sp<LayerBaseClient>& layer);
|
2010-06-01 22:12:58 +00:00
|
|
|
void detachLayer(const LayerBaseClient* layer);
|
2010-06-03 06:28:45 +00:00
|
|
|
sp<LayerBaseClient> getLayerUser(int32_t i) const;
|
2009-03-04 03:31:44 +00:00
|
|
|
|
|
|
|
private:
|
2010-06-03 06:28:45 +00:00
|
|
|
// ISurfaceComposerClient interface
|
|
|
|
virtual sp<ISurface> createSurface(
|
2011-04-20 21:19:32 +00:00
|
|
|
surface_data_t* params, const String8& name,
|
2010-06-03 06:28:45 +00:00
|
|
|
DisplayID display, uint32_t w, uint32_t h,PixelFormat format,
|
|
|
|
uint32_t flags);
|
|
|
|
virtual status_t destroySurface(SurfaceID surfaceId);
|
2011-04-20 21:20:59 +00:00
|
|
|
virtual status_t onTransact(
|
|
|
|
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags);
|
2010-06-03 06:28:45 +00:00
|
|
|
|
2011-05-03 23:21:41 +00:00
|
|
|
// constant
|
2010-06-01 22:12:58 +00:00
|
|
|
sp<SurfaceFlinger> mFlinger;
|
2011-05-03 23:21:41 +00:00
|
|
|
|
|
|
|
// protected by mLock
|
|
|
|
DefaultKeyedVector< size_t, wp<LayerBaseClient> > mLayers;
|
|
|
|
size_t mNameGenerator;
|
|
|
|
|
|
|
|
// thread-safe
|
|
|
|
mutable Mutex mLock;
|
2010-06-01 22:12:58 +00:00
|
|
|
};
|
|
|
|
|
2011-01-13 02:30:40 +00:00
|
|
|
class GraphicBufferAlloc : public BnGraphicBufferAlloc
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
GraphicBufferAlloc();
|
|
|
|
virtual ~GraphicBufferAlloc();
|
|
|
|
virtual sp<GraphicBuffer> createGraphicBuffer(uint32_t w, uint32_t h,
|
2011-07-01 21:53:49 +00:00
|
|
|
PixelFormat format, uint32_t usage, status_t* error);
|
2011-01-13 02:30:40 +00:00
|
|
|
};
|
|
|
|
|
2009-03-04 03:31:44 +00:00
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
class GraphicPlane
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
static status_t orientationToTransfrom(int orientation, int w, int h,
|
|
|
|
Transform* tr);
|
|
|
|
|
|
|
|
GraphicPlane();
|
|
|
|
~GraphicPlane();
|
|
|
|
|
|
|
|
bool initialized() const;
|
|
|
|
|
|
|
|
void setDisplayHardware(DisplayHardware *);
|
|
|
|
status_t setOrientation(int orientation);
|
2009-03-28 00:58:20 +00:00
|
|
|
int getOrientation() const { return mOrientation; }
|
2010-02-08 23:49:35 +00:00
|
|
|
int getWidth() const;
|
|
|
|
int getHeight() const;
|
2009-03-04 03:31:44 +00:00
|
|
|
|
|
|
|
const DisplayHardware& displayHardware() const;
|
2010-10-11 19:37:43 +00:00
|
|
|
DisplayHardware& editDisplayHardware();
|
2009-03-04 03:31:44 +00:00
|
|
|
const Transform& transform() const;
|
2009-04-10 21:24:30 +00:00
|
|
|
EGLDisplay getEGLDisplay() const;
|
|
|
|
|
2009-03-04 03:31:44 +00:00
|
|
|
private:
|
|
|
|
GraphicPlane(const GraphicPlane&);
|
|
|
|
GraphicPlane operator = (const GraphicPlane&);
|
|
|
|
|
|
|
|
DisplayHardware* mHw;
|
|
|
|
Transform mGlobalTransform;
|
2010-02-08 23:49:35 +00:00
|
|
|
Transform mDisplayTransform;
|
2009-03-28 00:58:20 +00:00
|
|
|
int mOrientation;
|
2010-02-08 23:49:35 +00:00
|
|
|
float mDisplayWidth;
|
|
|
|
float mDisplayHeight;
|
|
|
|
int mWidth;
|
|
|
|
int mHeight;
|
2009-03-04 03:31:44 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
enum {
|
|
|
|
eTransactionNeeded = 0x01,
|
|
|
|
eTraversalNeeded = 0x02
|
|
|
|
};
|
|
|
|
|
2010-07-15 01:41:18 +00:00
|
|
|
class SurfaceFlinger :
|
|
|
|
public BinderService<SurfaceFlinger>,
|
|
|
|
public BnSurfaceComposer,
|
2011-07-02 00:08:43 +00:00
|
|
|
public IBinder::DeathRecipient,
|
2010-07-15 01:41:18 +00:00
|
|
|
protected Thread
|
2009-03-04 03:31:44 +00:00
|
|
|
{
|
|
|
|
public:
|
2010-07-15 01:41:18 +00:00
|
|
|
static char const* getServiceName() { return "SurfaceFlinger"; }
|
2009-03-04 03:31:44 +00:00
|
|
|
|
|
|
|
SurfaceFlinger();
|
|
|
|
virtual ~SurfaceFlinger();
|
|
|
|
void init();
|
|
|
|
|
|
|
|
virtual status_t onTransact(
|
|
|
|
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags);
|
|
|
|
|
|
|
|
virtual status_t dump(int fd, const Vector<String16>& args);
|
|
|
|
|
|
|
|
// ISurfaceComposer interface
|
2010-05-28 21:22:23 +00:00
|
|
|
virtual sp<ISurfaceComposerClient> createConnection();
|
2011-01-13 02:30:40 +00:00
|
|
|
virtual sp<IGraphicBufferAlloc> createGraphicBufferAlloc();
|
2009-07-03 01:11:53 +00:00
|
|
|
virtual sp<IMemoryHeap> getCblk() const;
|
2009-03-04 03:31:44 +00:00
|
|
|
virtual void bootFinished();
|
2011-10-10 22:48:06 +00:00
|
|
|
virtual void setTransactionState(const Vector<ComposerState>& state,
|
2011-10-13 00:39:00 +00:00
|
|
|
int orientation, uint32_t flags);
|
2011-08-18 01:19:00 +00:00
|
|
|
virtual bool authenticateSurfaceTexture(const sp<ISurfaceTexture>& surface) const;
|
2011-11-18 01:49:17 +00:00
|
|
|
virtual sp<IDisplayEventConnection> createDisplayEventConnection();
|
2010-12-11 00:22:31 +00:00
|
|
|
|
|
|
|
virtual status_t captureScreen(DisplayID dpy,
|
|
|
|
sp<IMemoryHeap>* heap,
|
|
|
|
uint32_t* width, uint32_t* height,
|
|
|
|
PixelFormat* format, uint32_t reqWidth, uint32_t reqHeight,
|
|
|
|
uint32_t minLayerZ, uint32_t maxLayerZ);
|
|
|
|
|
2010-10-11 19:37:43 +00:00
|
|
|
virtual status_t turnElectronBeamOff(int32_t mode);
|
2010-10-12 23:05:48 +00:00
|
|
|
virtual status_t turnElectronBeamOn(int32_t mode);
|
2009-03-04 03:31:44 +00:00
|
|
|
|
2012-04-11 05:09:54 +00:00
|
|
|
|
|
|
|
// called when screen needs to turn off
|
|
|
|
void screenReleased();
|
|
|
|
// called when screen is turning back on
|
|
|
|
void screenAcquired();
|
|
|
|
|
|
|
|
// called on the main thread in response to screenReleased()
|
|
|
|
void onScreenReleased();
|
|
|
|
// called on the main thread in response to screenAcquired()
|
|
|
|
void onScreenAcquired();
|
|
|
|
|
2009-03-04 03:31:44 +00:00
|
|
|
|
2011-10-13 23:02:48 +00:00
|
|
|
status_t renderScreenToTexture(DisplayID dpy,
|
|
|
|
GLuint* textureName, GLfloat* uOut, GLfloat* vOut);
|
2011-11-01 21:39:06 +00:00
|
|
|
status_t renderScreenToTextureLocked(DisplayID dpy,
|
|
|
|
GLuint* textureName, GLfloat* uOut, GLfloat* vOut);
|
2011-10-13 23:02:48 +00:00
|
|
|
|
2012-02-01 02:24:27 +00:00
|
|
|
void onMessageReceived(int32_t what);
|
|
|
|
|
2011-10-13 23:02:48 +00:00
|
|
|
status_t postMessageAsync(const sp<MessageBase>& msg,
|
|
|
|
nsecs_t reltime=0, uint32_t flags = 0);
|
|
|
|
|
|
|
|
status_t postMessageSync(const sp<MessageBase>& msg,
|
|
|
|
nsecs_t reltime=0, uint32_t flags = 0);
|
|
|
|
|
2009-04-10 21:24:30 +00:00
|
|
|
status_t removeLayer(const sp<LayerBase>& layer);
|
|
|
|
status_t addLayer(const sp<LayerBase>& layer);
|
|
|
|
status_t invalidateLayerVisibility(const sp<LayerBase>& layer);
|
2011-01-14 01:53:01 +00:00
|
|
|
void invalidateHwcGeometry();
|
2010-06-01 22:12:58 +00:00
|
|
|
|
|
|
|
sp<Layer> getLayer(const sp<ISurface>& sur) const;
|
|
|
|
|
2011-10-07 21:51:16 +00:00
|
|
|
GLuint getProtectedTexName() const { return mProtectedTexName; }
|
|
|
|
|
2011-10-13 23:02:48 +00:00
|
|
|
|
|
|
|
class MessageDestroyGLTexture : public MessageBase {
|
|
|
|
GLuint texture;
|
|
|
|
public:
|
|
|
|
MessageDestroyGLTexture(GLuint texture) : texture(texture) { }
|
|
|
|
virtual bool handler() {
|
|
|
|
glDeleteTextures(1, &texture);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2011-07-02 00:08:43 +00:00
|
|
|
private:
|
|
|
|
// DeathRecipient interface
|
|
|
|
virtual void binderDied(const wp<IBinder>& who);
|
|
|
|
|
2009-03-04 03:31:44 +00:00
|
|
|
private:
|
2010-06-03 06:28:45 +00:00
|
|
|
friend class Client;
|
2011-11-18 01:49:17 +00:00
|
|
|
friend class DisplayEventConnection;
|
2009-03-04 03:31:44 +00:00
|
|
|
friend class LayerBase;
|
|
|
|
friend class LayerBaseClient;
|
|
|
|
friend class Layer;
|
|
|
|
|
2011-04-20 21:19:32 +00:00
|
|
|
sp<ISurface> createSurface(
|
2010-05-28 21:22:23 +00:00
|
|
|
ISurfaceComposerClient::surface_data_t* params,
|
2011-04-20 21:19:32 +00:00
|
|
|
const String8& name,
|
|
|
|
const sp<Client>& client,
|
2009-03-04 03:31:44 +00:00
|
|
|
DisplayID display, uint32_t w, uint32_t h, PixelFormat format,
|
|
|
|
uint32_t flags);
|
|
|
|
|
2010-06-01 22:12:58 +00:00
|
|
|
sp<Layer> createNormalSurface(
|
2009-06-20 00:00:27 +00:00
|
|
|
const sp<Client>& client, DisplayID display,
|
2010-06-03 06:28:45 +00:00
|
|
|
uint32_t w, uint32_t h, uint32_t flags,
|
2009-08-20 00:46:26 +00:00
|
|
|
PixelFormat& format);
|
2009-03-04 03:31:44 +00:00
|
|
|
|
2010-06-01 22:12:58 +00:00
|
|
|
sp<LayerDim> createDimSurface(
|
2009-06-20 00:00:27 +00:00
|
|
|
const sp<Client>& client, DisplayID display,
|
2010-06-03 06:28:45 +00:00
|
|
|
uint32_t w, uint32_t h, uint32_t flags);
|
2009-03-04 03:31:44 +00:00
|
|
|
|
2011-10-13 23:02:48 +00:00
|
|
|
sp<LayerScreenshot> createScreenshotSurface(
|
|
|
|
const sp<Client>& client, DisplayID display,
|
|
|
|
uint32_t w, uint32_t h, uint32_t flags);
|
|
|
|
|
2010-06-03 06:28:45 +00:00
|
|
|
status_t removeSurface(const sp<Client>& client, SurfaceID sid);
|
2011-05-19 22:38:14 +00:00
|
|
|
status_t destroySurface(const wp<LayerBaseClient>& layer);
|
2011-06-29 02:09:31 +00:00
|
|
|
uint32_t setClientStateLocked(const sp<Client>& client, const layer_state_t& s);
|
2009-03-04 03:31:44 +00:00
|
|
|
|
2010-08-11 01:09:09 +00:00
|
|
|
class LayerVector : public SortedVector< sp<LayerBase> > {
|
2009-03-04 03:31:44 +00:00
|
|
|
public:
|
2010-08-11 01:09:09 +00:00
|
|
|
LayerVector() { }
|
|
|
|
LayerVector(const LayerVector& rhs) : SortedVector< sp<LayerBase> >(rhs) { }
|
|
|
|
virtual int do_compare(const void* lhs, const void* rhs) const {
|
|
|
|
const sp<LayerBase>& l(*reinterpret_cast<const sp<LayerBase>*>(lhs));
|
|
|
|
const sp<LayerBase>& r(*reinterpret_cast<const sp<LayerBase>*>(rhs));
|
|
|
|
// sort layers by Z order
|
|
|
|
uint32_t lz = l->currentState().z;
|
|
|
|
uint32_t rz = r->currentState().z;
|
|
|
|
// then by sequence, so we get a stable ordering
|
|
|
|
return (lz != rz) ? (lz - rz) : (l->sequence - r->sequence);
|
|
|
|
}
|
2009-03-04 03:31:44 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct State {
|
2012-04-04 00:48:03 +00:00
|
|
|
State()
|
|
|
|
: orientation(ISurfaceComposer::eOrientationDefault),
|
|
|
|
orientationFlags(0) {
|
2009-03-04 03:31:44 +00:00
|
|
|
}
|
|
|
|
LayerVector layersSortedByZ;
|
|
|
|
uint8_t orientation;
|
Handle orientation changes more systematically.
Bug: 4981385
Simplify the orientation changing code path in the
WindowManager. Instead of the policy calling setRotation()
when the sensor determined orientation changes, it calls
updateRotation(), which figures everything out. For the most
part, the rotation actually passed to setRotation() was
more or less ignored and just added confusion, particularly
when handling deferred orientation changes.
Ensure that 180 degree rotations are disallowed even when
the application specifies SCREEN_ORIENTATION_SENSOR_*.
These rotations are only enabled when docked upside-down for
some reason or when the application specifies
SCREEN_ORIENTATION_FULL_SENSOR.
Ensure that special modes like HDMI connected, lid switch,
dock and rotation lock all cause the sensor to be ignored
even when the application asks for sensor-based orientation
changes. The sensor is not relevant in these modes because
some external factor (or the user) is determining the
preferred rotation.
Currently, applications can still override the preferred
rotation even when there are special modes in play that
might say otherwise. We could tweak this so that some
special modes trump application choices completely
(resulting in a letter-boxed application, perhaps).
I tested this sort of tweak (not included in the patch)
and it seems to work fine, including transitions between
applications with varying orientation.
Delete dead code related to animFlags.
Handle pausing/resuming orientation changes more precisely.
Ensure that a deferred orientation change is performed when
a drag completes, even if endDragLw() is not called because the
drag was aborted before the drop happened. We pause
the orientation change in register() and resume in unregister()
because those methods appear to always be called as needed.
Change-Id: If0a31de3d057251e581fdee64819f2b19e676e9a
2011-09-20 22:08:29 +00:00
|
|
|
uint8_t orientationFlags;
|
2009-03-04 03:31:44 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
virtual bool threadLoop();
|
|
|
|
virtual status_t readyToRun();
|
|
|
|
virtual void onFirstRef();
|
|
|
|
|
2009-10-29 17:19:34 +00:00
|
|
|
public: // hack to work around gcc 4.0.3 bug
|
2009-03-04 03:31:44 +00:00
|
|
|
const GraphicPlane& graphicPlane(int dpy) const;
|
|
|
|
GraphicPlane& graphicPlane(int dpy);
|
2012-02-01 02:24:27 +00:00
|
|
|
|
|
|
|
void signalTransaction();
|
|
|
|
void signalLayerUpdate();
|
|
|
|
void signalRefresh();
|
2011-10-05 22:00:22 +00:00
|
|
|
void repaintEverything();
|
2009-03-04 03:31:44 +00:00
|
|
|
|
2009-09-21 21:33:20 +00:00
|
|
|
private:
|
2011-10-05 22:00:22 +00:00
|
|
|
void waitForEvent();
|
2009-03-04 03:31:44 +00:00
|
|
|
void handleTransaction(uint32_t transactionFlags);
|
2011-05-19 22:38:14 +00:00
|
|
|
void handleTransactionLocked(uint32_t transactionFlags);
|
2009-03-04 03:31:44 +00:00
|
|
|
|
|
|
|
void computeVisibleRegions(
|
2011-03-12 00:54:47 +00:00
|
|
|
const LayerVector& currentLayers,
|
2009-03-04 03:31:44 +00:00
|
|
|
Region& dirtyRegion,
|
|
|
|
Region& wormholeRegion);
|
|
|
|
|
|
|
|
void handlePageFlip();
|
|
|
|
bool lockPageFlip(const LayerVector& currentLayers);
|
|
|
|
void unlockPageFlip(const LayerVector& currentLayers);
|
2012-02-01 02:24:27 +00:00
|
|
|
void handleRefresh();
|
2010-08-11 00:14:02 +00:00
|
|
|
void handleWorkList();
|
2009-03-04 03:31:44 +00:00
|
|
|
void handleRepaint();
|
|
|
|
void postFramebuffer();
|
2011-09-21 00:21:56 +00:00
|
|
|
void setupHardwareComposer(Region& dirtyInOut);
|
2009-03-04 03:31:44 +00:00
|
|
|
void composeSurfaces(const Region& dirty);
|
|
|
|
|
|
|
|
|
2011-10-21 22:18:28 +00:00
|
|
|
void setInvalidateRegion(const Region& reg);
|
|
|
|
Region getAndClearInvalidateRegion();
|
|
|
|
|
2010-06-03 06:28:45 +00:00
|
|
|
ssize_t addClientLayer(const sp<Client>& client,
|
|
|
|
const sp<LayerBaseClient>& lbc);
|
2009-04-10 21:24:30 +00:00
|
|
|
status_t addLayer_l(const sp<LayerBase>& layer);
|
|
|
|
status_t removeLayer_l(const sp<LayerBase>& layer);
|
2009-04-18 02:36:26 +00:00
|
|
|
status_t purgatorizeLayer_l(const sp<LayerBase>& layer);
|
2009-03-04 03:31:44 +00:00
|
|
|
|
|
|
|
uint32_t getTransactionFlags(uint32_t flags);
|
2011-05-04 00:04:02 +00:00
|
|
|
uint32_t peekTransactionFlags(uint32_t flags);
|
2010-05-19 00:06:55 +00:00
|
|
|
uint32_t setTransactionFlags(uint32_t flags);
|
2009-03-04 03:31:44 +00:00
|
|
|
void commitTransaction();
|
|
|
|
|
|
|
|
|
2010-09-29 20:02:36 +00:00
|
|
|
status_t captureScreenImplLocked(DisplayID dpy,
|
|
|
|
sp<IMemoryHeap>* heap,
|
|
|
|
uint32_t* width, uint32_t* height, PixelFormat* format,
|
2010-12-11 00:22:31 +00:00
|
|
|
uint32_t reqWidth, uint32_t reqHeight,
|
|
|
|
uint32_t minLayerZ, uint32_t maxLayerZ);
|
2010-09-29 20:02:36 +00:00
|
|
|
|
2010-10-14 21:54:06 +00:00
|
|
|
status_t turnElectronBeamOffImplLocked(int32_t mode);
|
|
|
|
status_t turnElectronBeamOnImplLocked(int32_t mode);
|
2010-10-12 23:05:48 +00:00
|
|
|
status_t electronBeamOffAnimationImplLocked();
|
|
|
|
status_t electronBeamOnAnimationImplLocked();
|
2010-10-11 19:37:43 +00:00
|
|
|
|
2009-03-04 03:31:44 +00:00
|
|
|
void debugFlashRegions();
|
|
|
|
void drawWormhole() const;
|
|
|
|
|
2012-01-29 06:31:55 +00:00
|
|
|
void listLayersLocked(const Vector<String16>& args, size_t& index,
|
|
|
|
String8& result, char* buffer, size_t SIZE) const;
|
2012-01-20 02:34:40 +00:00
|
|
|
void dumpStatsLocked(const Vector<String16>& args, size_t& index,
|
|
|
|
String8& result, char* buffer, size_t SIZE) const;
|
2012-01-29 06:31:55 +00:00
|
|
|
void clearStatsLocked(const Vector<String16>& args, size_t& index,
|
|
|
|
String8& result, char* buffer, size_t SIZE) const;
|
2012-01-20 02:34:40 +00:00
|
|
|
void dumpAllLocked(String8& result, char* buffer, size_t SIZE) const;
|
2009-04-21 02:39:12 +00:00
|
|
|
|
|
|
|
mutable MessageQueue mEventQueue;
|
2010-05-19 00:06:55 +00:00
|
|
|
|
2009-03-04 03:31:44 +00:00
|
|
|
// access must be protected by mStateLock
|
|
|
|
mutable Mutex mStateLock;
|
|
|
|
State mCurrentState;
|
|
|
|
volatile int32_t mTransactionFlags;
|
|
|
|
Condition mTransactionCV;
|
2011-01-15 01:37:42 +00:00
|
|
|
SortedVector< sp<LayerBase> > mLayerPurgatory;
|
2011-10-13 00:39:00 +00:00
|
|
|
bool mTransationPending;
|
2011-12-02 18:00:00 +00:00
|
|
|
Vector< sp<LayerBase> > mLayersPendingRemoval;
|
2010-06-03 06:28:45 +00:00
|
|
|
|
2009-03-04 03:31:44 +00:00
|
|
|
// protected by mStateLock (but we could use another lock)
|
2010-06-03 06:28:45 +00:00
|
|
|
GraphicPlane mGraphicPlanes[1];
|
|
|
|
bool mLayersRemoved;
|
2010-06-01 22:12:58 +00:00
|
|
|
DefaultKeyedVector< wp<IBinder>, wp<Layer> > mLayerMap;
|
2009-03-04 03:31:44 +00:00
|
|
|
|
2011-10-21 22:18:28 +00:00
|
|
|
// access must be protected by mInvalidateLock
|
|
|
|
mutable Mutex mInvalidateLock;
|
|
|
|
Region mInvalidateRegion;
|
|
|
|
|
2009-03-04 03:31:44 +00:00
|
|
|
// constant members (no synchronization needed for access)
|
2009-07-03 01:11:53 +00:00
|
|
|
sp<IMemoryHeap> mServerHeap;
|
2009-03-04 03:31:44 +00:00
|
|
|
surface_flinger_cblk_t* mServerCblk;
|
|
|
|
GLuint mWormholeTexName;
|
2011-10-07 21:51:16 +00:00
|
|
|
GLuint mProtectedTexName;
|
2009-03-04 03:31:44 +00:00
|
|
|
nsecs_t mBootTime;
|
2011-11-18 01:49:17 +00:00
|
|
|
sp<EventThread> mEventThread;
|
2011-06-27 23:05:52 +00:00
|
|
|
|
2009-03-04 03:31:44 +00:00
|
|
|
// Can only accessed from the main thread, these members
|
|
|
|
// don't need synchronization
|
2011-03-12 00:54:47 +00:00
|
|
|
State mDrawingState;
|
2009-03-04 03:31:44 +00:00
|
|
|
Region mDirtyRegion;
|
2009-07-28 17:57:27 +00:00
|
|
|
Region mDirtyRegionRemovedLayer;
|
2011-09-21 00:22:44 +00:00
|
|
|
Region mSwapRegion;
|
2009-03-04 03:31:44 +00:00
|
|
|
Region mWormholeRegion;
|
|
|
|
bool mVisibleRegionsDirty;
|
2010-08-11 00:14:02 +00:00
|
|
|
bool mHwWorkListDirty;
|
2010-10-14 21:54:06 +00:00
|
|
|
int32_t mElectronBeamAnimationMode;
|
2010-08-11 00:19:56 +00:00
|
|
|
Vector< sp<LayerBase> > mVisibleLayersSortedByZ;
|
|
|
|
|
2009-03-04 03:31:44 +00:00
|
|
|
|
|
|
|
// don't use a lock for these, we don't care
|
|
|
|
int mDebugRegion;
|
|
|
|
int mDebugBackground;
|
2011-08-16 03:44:40 +00:00
|
|
|
int mDebugDDMS;
|
2010-09-23 01:58:01 +00:00
|
|
|
int mDebugDisableHWC;
|
2011-08-24 01:03:18 +00:00
|
|
|
int mDebugDisableTransformHint;
|
2009-08-26 23:36:26 +00:00
|
|
|
volatile nsecs_t mDebugInSwapBuffers;
|
|
|
|
nsecs_t mLastSwapBufferTime;
|
|
|
|
volatile nsecs_t mDebugInTransaction;
|
|
|
|
nsecs_t mLastTransactionTime;
|
2009-10-06 00:07:12 +00:00
|
|
|
bool mBootFinished;
|
2009-03-04 03:31:44 +00:00
|
|
|
|
|
|
|
// these are thread safe
|
|
|
|
mutable Barrier mReadyToRunBarrier;
|
|
|
|
|
2011-05-19 22:38:14 +00:00
|
|
|
|
|
|
|
// protected by mDestroyedLayerLock;
|
|
|
|
mutable Mutex mDestroyedLayerLock;
|
|
|
|
Vector<LayerBase const *> mDestroyedLayers;
|
|
|
|
|
2009-03-04 03:31:44 +00:00
|
|
|
// only written in the main thread, only read in other threads
|
|
|
|
volatile int32_t mSecureFrameBuffer;
|
|
|
|
};
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
}; // namespace android
|
|
|
|
|
|
|
|
#endif // ANDROID_SURFACE_FLINGER_H
|