ADHOC
/
replicant-frameworks_native
3
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

libgui includes refactoring 

Change-Id: I1d24ec17f5003ec2abab5f7472daaff4cc4cc2d3
This commit is contained in:
Mathias Agopian 2012-08-08 19:42:09 -07:00
parent 1e26087493
commit 3165cc21cf
9 changed files with 114 additions and 161 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

70
include/gui/ISurfaceComposer.h
View File

@ -39,54 +39,13 @@ class DisplayInfo;
class IDisplayEventConnection; class IDisplayEventConnection;
class IMemoryHeap; class IMemoryHeap;
class ISurfaceComposer : public IInterface class ISurfaceComposer: public IInterface {
{
public: public:
DECLARE_META_INTERFACE(SurfaceComposer); DECLARE_META_INTERFACE(SurfaceComposer);
enum { // (keep in sync with Surface.java) // flags for setTransactionState()
eHidden = 0x00000004,
eDestroyBackbuffer = 0x00000020,
eSecure = 0x00000080,
eNonPremultiplied = 0x00000100,
eOpaque = 0x00000400,
eProtectedByApp = 0x00000800,
eProtectedByDRM = 0x00001000,
eFXSurfaceNormal = 0x00000000,
eFXSurfaceBlur = 0x00010000,
eFXSurfaceDim = 0x00020000,
eFXSurfaceScreenshot= 0x00030000,
eFXSurfaceMask = 0x000F0000,
};
enum { enum {
ePositionChanged = 0x00000001, eSynchronous = 0x01,
eLayerChanged = 0x00000002,
eSizeChanged = 0x00000004,
eAlphaChanged = 0x00000008,
eMatrixChanged = 0x00000010,
eTransparentRegionChanged = 0x00000020,
eVisibilityChanged = 0x00000040,
eLayerStackChanged = 0x00000080,
eCropChanged = 0x00000100,
};
enum {
eLayerHidden = 0x01,
};
enum {
eOrientationDefault = 0,
eOrientation90 = 1,
eOrientation180 = 2,
eOrientation270 = 3,
eOrientationUnchanged = 4,
eOrientationSwapMask = 0x01
};
enum {
eSynchronous = 0x01,
}; };
/* create connection with surface flinger, requires /* create connection with surface flinger, requires
@ -99,10 +58,8 @@ public:
virtual sp<IGraphicBufferAlloc> createGraphicBufferAlloc() = 0; virtual sp<IGraphicBufferAlloc> createGraphicBufferAlloc() = 0;
/* open/close transactions. requires ACCESS_SURFACE_FLINGER permission */ /* open/close transactions. requires ACCESS_SURFACE_FLINGER permission */
virtual void setTransactionState( virtual void setTransactionState(const Vector<ComposerState>& state,
const Vector<ComposerState>& state, const Vector<DisplayState>& displays, uint32_t flags) = 0;
const Vector<DisplayState>& displays,
uint32_t flags) = 0;
/* signal that we're done booting. /* signal that we're done booting.
* Requires ACCESS_SURFACE_FLINGER permission * Requires ACCESS_SURFACE_FLINGER permission
@ -112,11 +69,10 @@ public:
/* Capture the specified screen. requires READ_FRAME_BUFFER permission /* Capture the specified screen. requires READ_FRAME_BUFFER permission
* This function will fail if there is a secure window on screen. * This function will fail if there is a secure window on screen.
*/ */
virtual status_t captureScreen(DisplayID dpy, virtual status_t captureScreen(DisplayID dpy, sp<IMemoryHeap>* heap,
sp<IMemoryHeap>* heap,
uint32_t* width, uint32_t* height, PixelFormat* format, uint32_t* width, uint32_t* height, PixelFormat* format,
uint32_t reqWidth, uint32_t reqHeight, uint32_t reqWidth, uint32_t reqHeight, uint32_t minLayerZ,
uint32_t minLayerZ, uint32_t maxLayerZ) = 0; uint32_t maxLayerZ) = 0;
/* verify that an ISurfaceTexture was created by SurfaceFlinger. /* verify that an ISurfaceTexture was created by SurfaceFlinger.
*/ */
@ -142,8 +98,7 @@ public:
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class BnSurfaceComposer : public BnInterface<ISurfaceComposer> class BnSurfaceComposer: public BnInterface<ISurfaceComposer> {
{
public: public:
enum { enum {
// Note: BOOT_FINISHED must remain this value, it is called from // Note: BOOT_FINISHED must remain this value, it is called from
@ -153,7 +108,6 @@ public:
CREATE_GRAPHIC_BUFFER_ALLOC, CREATE_GRAPHIC_BUFFER_ALLOC,
GET_DISPLAY_INFO, GET_DISPLAY_INFO,
SET_TRANSACTION_STATE, SET_TRANSACTION_STATE,
SET_ORIENTATION,
CAPTURE_SCREEN, CAPTURE_SCREEN,
AUTHENTICATE_SURFACE, AUTHENTICATE_SURFACE,
CREATE_DISPLAY_EVENT_CONNECTION, CREATE_DISPLAY_EVENT_CONNECTION,
@ -162,10 +116,8 @@ public:
CONNECT_DISPLAY, CONNECT_DISPLAY,
}; };
virtual status_t onTransact( uint32_t code, virtual status_t onTransact(uint32_t code, const Parcel& data,
const Parcel& data, Parcel* reply, uint32_t flags = 0);
Parcel* reply,
uint32_t flags = 0);
}; };
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------

42
include/gui/ISurfaceComposerClient.h
View File

@ -42,9 +42,26 @@ class ISurfaceComposerClient : public IInterface
public: public:
DECLARE_META_INTERFACE(SurfaceComposerClient); DECLARE_META_INTERFACE(SurfaceComposerClient);
// flags for createSurface()
enum { // (keep in sync with Surface.java)
eHidden = 0x00000004,
eDestroyBackbuffer = 0x00000020,
eSecure = 0x00000080,
eNonPremultiplied = 0x00000100,
eOpaque = 0x00000400,
eProtectedByApp = 0x00000800,
eProtectedByDRM = 0x00001000,
eFXSurfaceNormal = 0x00000000,
eFXSurfaceBlur = 0x00010000, // deprecated, same as Dim
eFXSurfaceDim = 0x00020000,
eFXSurfaceScreenshot= 0x00030000,
eFXSurfaceMask = 0x000F0000,
};
struct surface_data_t { struct surface_data_t {
int32_t token; int32_t token;
int32_t identity; int32_t identity;
status_t readFromParcel(const Parcel& parcel); status_t readFromParcel(const Parcel& parcel);
status_t writeToParcel(Parcel* parcel) const; status_t writeToParcel(Parcel* parcel) const;
}; };
@ -52,29 +69,22 @@ public:
/* /*
* Requires ACCESS_SURFACE_FLINGER permission * Requires ACCESS_SURFACE_FLINGER permission
*/ */
virtual sp<ISurface> createSurface( surface_data_t* data, virtual sp<ISurface> createSurface(surface_data_t* data,
const String8& name, const String8& name, DisplayID display, uint32_t w, uint32_t h,
DisplayID display, PixelFormat format, uint32_t flags) = 0;
uint32_t w,
uint32_t h,
PixelFormat format,
uint32_t flags) = 0;
/* /*
* Requires ACCESS_SURFACE_FLINGER permission * Requires ACCESS_SURFACE_FLINGER permission
*/ */
virtual status_t destroySurface(SurfaceID sid) = 0; virtual status_t destroySurface(SurfaceID sid) = 0;
}; };
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class BnSurfaceComposerClient : public BnInterface<ISurfaceComposerClient> class BnSurfaceComposerClient: public BnInterface<ISurfaceComposerClient> {
{
public: public:
virtual status_t onTransact( uint32_t code, virtual status_t onTransact(uint32_t code, const Parcel& data,
const Parcel& data, Parcel* reply, uint32_t flags = 0);
Parcel* reply,
uint32_t flags = 0);
}; };
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------

27
include/private/gui/LayerState.h
View File

@ -33,6 +33,23 @@ class ISurfaceComposerClient;
struct layer_state_t { struct layer_state_t {
enum {
eLayerHidden = 0x01,
};
enum {
ePositionChanged = 0x00000001,
eLayerChanged = 0x00000002,
eSizeChanged = 0x00000004,
eAlphaChanged = 0x00000008,
eMatrixChanged = 0x00000010,
eTransparentRegionChanged = 0x00000020,
eVisibilityChanged = 0x00000040,
eLayerStackChanged = 0x00000080,
eCropChanged = 0x00000100,
};
layer_state_t() layer_state_t()
: surface(0), what(0), : surface(0), what(0),
x(0), y(0), z(0), w(0), h(0), layerStack(0), x(0), y(0), z(0), w(0), h(0), layerStack(0),
@ -79,6 +96,16 @@ struct ComposerState {
}; };
struct DisplayState { struct DisplayState {
enum {
eOrientationDefault = 0,
eOrientation90 = 1,
eOrientation180 = 2,
eOrientation270 = 3,
eOrientationUnchanged = 4,
eOrientationSwapMask = 0x01
};
int32_t displayId; int32_t displayId;
sp<ISurfaceTexture> surface; sp<ISurfaceTexture> surface;
uint32_t layerStack; uint32_t layerStack;

28
libs/gui/SurfaceComposerClient.cpp
View File

@ -83,7 +83,7 @@ class Composer : public Singleton<Composer>
uint32_t mForceSynchronous; uint32_t mForceSynchronous;
Composer() : Singleton<Composer>(), Composer() : Singleton<Composer>(),
mOrientation(ISurfaceComposer::eOrientationUnchanged), mOrientation(DisplayState::eOrientationUnchanged),
mForceSynchronous(0) mForceSynchronous(0)
{ } { }
@ -141,7 +141,7 @@ void Composer::closeGlobalTransactionImpl(bool synchronous) {
item.orientation = mOrientation; item.orientation = mOrientation;
displayTransaction.add(item); displayTransaction.add(item);
mOrientation = ISurfaceComposer::eOrientationUnchanged; mOrientation = DisplayState::eOrientationUnchanged;
if (synchronous || mForceSynchronous) { if (synchronous || mForceSynchronous) {
flags |= ISurfaceComposer::eSynchronous; flags |= ISurfaceComposer::eSynchronous;
@ -175,7 +175,7 @@ status_t Composer::setPosition(const sp<SurfaceComposerClient>& client,
layer_state_t* s = getLayerStateLocked(client, id); layer_state_t* s = getLayerStateLocked(client, id);
if (!s) if (!s)
return BAD_INDEX; return BAD_INDEX;
s->what |= ISurfaceComposer::ePositionChanged; s->what |= layer_state_t::ePositionChanged;
s->x = x; s->x = x;
s->y = y; s->y = y;
return NO_ERROR; return NO_ERROR;
@ -187,7 +187,7 @@ status_t Composer::setSize(const sp<SurfaceComposerClient>& client,
layer_state_t* s = getLayerStateLocked(client, id); layer_state_t* s = getLayerStateLocked(client, id);
if (!s) if (!s)
return BAD_INDEX; return BAD_INDEX;
s->what |= ISurfaceComposer::eSizeChanged; s->what |= layer_state_t::eSizeChanged;
s->w = w; s->w = w;
s->h = h; s->h = h;
@ -203,7 +203,7 @@ status_t Composer::setLayer(const sp<SurfaceComposerClient>& client,
layer_state_t* s = getLayerStateLocked(client, id); layer_state_t* s = getLayerStateLocked(client, id);
if (!s) if (!s)
return BAD_INDEX; return BAD_INDEX;
s->what |= ISurfaceComposer::eLayerChanged; s->what |= layer_state_t::eLayerChanged;
s->z = z; s->z = z;
return NO_ERROR; return NO_ERROR;
} }
@ -215,7 +215,7 @@ status_t Composer::setFlags(const sp<SurfaceComposerClient>& client,
layer_state_t* s = getLayerStateLocked(client, id); layer_state_t* s = getLayerStateLocked(client, id);
if (!s) if (!s)
return BAD_INDEX; return BAD_INDEX;
s->what |= ISurfaceComposer::eVisibilityChanged; s->what |= layer_state_t::eVisibilityChanged;
s->flags &= ~mask; s->flags &= ~mask;
s->flags |= (flags & mask); s->flags |= (flags & mask);
s->mask |= mask; s->mask |= mask;
@ -229,7 +229,7 @@ status_t Composer::setTransparentRegionHint(
layer_state_t* s = getLayerStateLocked(client, id); layer_state_t* s = getLayerStateLocked(client, id);
if (!s) if (!s)
return BAD_INDEX; return BAD_INDEX;
s->what |= ISurfaceComposer::eTransparentRegionChanged; s->what |= layer_state_t::eTransparentRegionChanged;
s->transparentRegion = transparentRegion; s->transparentRegion = transparentRegion;
return NO_ERROR; return NO_ERROR;
} }
@ -240,7 +240,7 @@ status_t Composer::setAlpha(const sp<SurfaceComposerClient>& client,
layer_state_t* s = getLayerStateLocked(client, id); layer_state_t* s = getLayerStateLocked(client, id);
if (!s) if (!s)
return BAD_INDEX; return BAD_INDEX;
s->what |= ISurfaceComposer::eAlphaChanged; s->what |= layer_state_t::eAlphaChanged;
s->alpha = alpha; s->alpha = alpha;
return NO_ERROR; return NO_ERROR;
} }
@ -251,7 +251,7 @@ status_t Composer::setLayerStack(const sp<SurfaceComposerClient>& client,
layer_state_t* s = getLayerStateLocked(client, id); layer_state_t* s = getLayerStateLocked(client, id);
if (!s) if (!s)
return BAD_INDEX; return BAD_INDEX;
s->what |= ISurfaceComposer::eLayerStackChanged; s->what |= layer_state_t::eLayerStackChanged;
s->layerStack = layerStack; s->layerStack = layerStack;
return NO_ERROR; return NO_ERROR;
} }
@ -263,7 +263,7 @@ status_t Composer::setMatrix(const sp<SurfaceComposerClient>& client,
layer_state_t* s = getLayerStateLocked(client, id); layer_state_t* s = getLayerStateLocked(client, id);
if (!s) if (!s)
return BAD_INDEX; return BAD_INDEX;
s->what |= ISurfaceComposer::eMatrixChanged; s->what |= layer_state_t::eMatrixChanged;
layer_state_t::matrix22_t matrix; layer_state_t::matrix22_t matrix;
matrix.dsdx = dsdx; matrix.dsdx = dsdx;
matrix.dtdx = dtdx; matrix.dtdx = dtdx;
@ -289,7 +289,7 @@ status_t Composer::setCrop(const sp<SurfaceComposerClient>& client,
layer_state_t* s = getLayerStateLocked(client, id); layer_state_t* s = getLayerStateLocked(client, id);
if (!s) if (!s)
return BAD_INDEX; return BAD_INDEX;
s->what |= ISurfaceComposer::eCropChanged; s->what |= layer_state_t::eCropChanged;
s->crop = crop; s->crop = crop;
return NO_ERROR; return NO_ERROR;
} }
@ -420,14 +420,14 @@ status_t SurfaceComposerClient::setLayer(SurfaceID id, int32_t z) {
status_t SurfaceComposerClient::hide(SurfaceID id) { status_t SurfaceComposerClient::hide(SurfaceID id) {
return getComposer().setFlags(this, id, return getComposer().setFlags(this, id,
ISurfaceComposer::eLayerHidden, layer_state_t::eLayerHidden,
ISurfaceComposer::eLayerHidden); layer_state_t::eLayerHidden);
} }
status_t SurfaceComposerClient::show(SurfaceID id, int32_t) { status_t SurfaceComposerClient::show(SurfaceID id, int32_t) {
return getComposer().setFlags(this, id, return getComposer().setFlags(this, id,
0, 0,
ISurfaceComposer::eLayerHidden); layer_state_t::eLayerHidden);
} }
status_t SurfaceComposerClient::setFlags(SurfaceID id, uint32_t flags, status_t SurfaceComposerClient::setFlags(SurfaceID id, uint32_t flags,

45
services/surfaceflinger/DisplayDevice.cpp
View File

@ -59,39 +59,6 @@ void checkGLErrors()
} while(true); } while(true);
} }
static __attribute__((noinline))
void checkEGLErrors(const char* token)
{
struct EGLUtils {
static const char *strerror(EGLint err) {
switch (err){
case EGL_SUCCESS: return "EGL_SUCCESS";
case EGL_NOT_INITIALIZED: return "EGL_NOT_INITIALIZED";
case EGL_BAD_ACCESS: return "EGL_BAD_ACCESS";
case EGL_BAD_ALLOC: return "EGL_BAD_ALLOC";
case EGL_BAD_ATTRIBUTE: return "EGL_BAD_ATTRIBUTE";
case EGL_BAD_CONFIG: return "EGL_BAD_CONFIG";
case EGL_BAD_CONTEXT: return "EGL_BAD_CONTEXT";
case EGL_BAD_CURRENT_SURFACE: return "EGL_BAD_CURRENT_SURFACE";
case EGL_BAD_DISPLAY: return "EGL_BAD_DISPLAY";
case EGL_BAD_MATCH: return "EGL_BAD_MATCH";
case EGL_BAD_NATIVE_PIXMAP: return "EGL_BAD_NATIVE_PIXMAP";
case EGL_BAD_NATIVE_WINDOW: return "EGL_BAD_NATIVE_WINDOW";
case EGL_BAD_PARAMETER: return "EGL_BAD_PARAMETER";
case EGL_BAD_SURFACE: return "EGL_BAD_SURFACE";
case EGL_CONTEXT_LOST: return "EGL_CONTEXT_LOST";
default: return "UNKNOWN";
}
}
};
EGLint error = eglGetError();
if (error && error != EGL_SUCCESS) {
ALOGE("%s: EGL error 0x%04x (%s)",
token, int(error), EGLUtils::strerror(error));
}
}
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
/* /*
@ -220,7 +187,7 @@ void DisplayDevice::init(EGLConfig config)
mPageFlipCount = 0; mPageFlipCount = 0;
// initialize the display orientation transform. // initialize the display orientation transform.
DisplayDevice::setOrientation(ISurfaceComposer::eOrientationDefault); DisplayDevice::setOrientation(DisplayState::eOrientationDefault);
} }
uint32_t DisplayDevice::getPageFlipCount() const { uint32_t DisplayDevice::getPageFlipCount() const {
@ -325,16 +292,16 @@ status_t DisplayDevice::orientationToTransfrom(
{ {
uint32_t flags = 0; uint32_t flags = 0;
switch (orientation) { switch (orientation) {
case ISurfaceComposer::eOrientationDefault: case DisplayState::eOrientationDefault:
flags = Transform::ROT_0; flags = Transform::ROT_0;
break; break;
case ISurfaceComposer::eOrientation90: case DisplayState::eOrientation90:
flags = Transform::ROT_90; flags = Transform::ROT_90;
break; break;
case ISurfaceComposer::eOrientation180: case DisplayState::eOrientation180:
flags = Transform::ROT_180; flags = Transform::ROT_180;
break; break;
case ISurfaceComposer::eOrientation270: case DisplayState::eOrientation270:
flags = Transform::ROT_270; flags = Transform::ROT_270;
break; break;
default: default:
@ -350,7 +317,7 @@ status_t DisplayDevice::setOrientation(int orientation) {
DisplayDevice::orientationToTransfrom( DisplayDevice::orientationToTransfrom(
orientation, w, h, &mGlobalTransform); orientation, w, h, &mGlobalTransform);
if (orientation & ISurfaceComposer::eOrientationSwapMask) { if (orientation & DisplayState::eOrientationSwapMask) {
int tmp = w; int tmp = w;
w = h; w = h;
h = tmp; h = tmp;

6
services/surfaceflinger/Layer.cpp
View File

@ -182,9 +182,9 @@ status_t Layer::setBuffers( uint32_t w, uint32_t h,
mFormat = format; mFormat = format;
mSecure = (flags & ISurfaceComposer::eSecure) ? true : false; mSecure = (flags & ISurfaceComposerClient::eSecure) ? true : false;
mProtectedByApp = (flags & ISurfaceComposer::eProtectedByApp) ? true : false; mProtectedByApp = (flags & ISurfaceComposerClient::eProtectedByApp) ? true : false;
mOpaqueLayer = (flags & ISurfaceComposer::eOpaque); mOpaqueLayer = (flags & ISurfaceComposerClient::eOpaque);
mCurrentOpacity = getOpacityForFormat(format); mCurrentOpacity = getOpacityForFormat(format);
mSurfaceTexture->setDefaultBufferSize(w, h); mSurfaceTexture->setDefaultBufferSize(w, h);

6
services/surfaceflinger/LayerBase.cpp
View File

@ -66,10 +66,10 @@ String8 LayerBase::getName() const {
void LayerBase::initStates(uint32_t w, uint32_t h, uint32_t flags) void LayerBase::initStates(uint32_t w, uint32_t h, uint32_t flags)
{ {
uint32_t layerFlags = 0; uint32_t layerFlags = 0;
if (flags & ISurfaceComposer::eHidden) if (flags & ISurfaceComposerClient::eHidden)
layerFlags = ISurfaceComposer::eLayerHidden; layerFlags = layer_state_t::eLayerHidden;
if (flags & ISurfaceComposer::eNonPremultiplied) if (flags & ISurfaceComposerClient::eNonPremultiplied)
mPremultipliedAlpha = false; mPremultipliedAlpha = false;
mCurrentState.active.w = w; mCurrentState.active.w = w;

8
services/surfaceflinger/LayerScreenshot.cpp
View File

@ -80,7 +80,7 @@ void LayerScreenshot::initTexture(GLfloat u, GLfloat v) {
void LayerScreenshot::initStates(uint32_t w, uint32_t h, uint32_t flags) { void LayerScreenshot::initStates(uint32_t w, uint32_t h, uint32_t flags) {
LayerBaseClient::initStates(w, h, flags); LayerBaseClient::initStates(w, h, flags);
if (!(flags & ISurfaceComposer::eHidden)) { if (!(flags & ISurfaceComposerClient::eHidden)) {
capture(); capture();
} }
} }
@ -90,15 +90,15 @@ uint32_t LayerScreenshot::doTransaction(uint32_t flags)
const LayerBase::State& draw(drawingState()); const LayerBase::State& draw(drawingState());
const LayerBase::State& curr(currentState()); const LayerBase::State& curr(currentState());
if (draw.flags & ISurfaceComposer::eLayerHidden) { if (draw.flags & layer_state_t::eLayerHidden) {
if (!(curr.flags & ISurfaceComposer::eLayerHidden)) { if (!(curr.flags & layer_state_t::eLayerHidden)) {
// we're going from hidden to visible // we're going from hidden to visible
status_t err = captureLocked(); status_t err = captureLocked();
if (err != NO_ERROR) { if (err != NO_ERROR) {
ALOGW("createScreenshotSurface failed (%s)", strerror(-err)); ALOGW("createScreenshotSurface failed (%s)", strerror(-err));
} }
} }
} else if (curr.flags & ISurfaceComposer::eLayerHidden) { } else if (curr.flags & layer_state_t::eLayerHidden) {
// we're going from visible to hidden // we're going from visible to hidden
if (mTextureName) { if (mTextureName) {
glDeleteTextures(1, &mTextureName); glDeleteTextures(1, &mTextureName);

43
services/surfaceflinger/SurfaceFlinger.cpp
View File

@ -142,7 +142,7 @@ void SurfaceFlinger::binderDied(const wp<IBinder>& who)
Vector<ComposerState> state; Vector<ComposerState> state;
Vector<DisplayState> displays; Vector<DisplayState> displays;
DisplayState d; DisplayState d;
d.orientation = eOrientationDefault; d.orientation = DisplayState::eOrientationDefault;
displays.add(d); displays.add(d);
setTransactionState(state, displays, 0); setTransactionState(state, displays, 0);
@ -970,7 +970,7 @@ void SurfaceFlinger::computeVisibleRegions(
// handle hidden surfaces by setting the visible region to empty // handle hidden surfaces by setting the visible region to empty
if (CC_LIKELY(!(s.flags & ISurfaceComposer::eLayerHidden) && s.alpha)) { if (CC_LIKELY(!(s.flags & layer_state_t::eLayerHidden) && s.alpha)) {
const bool translucent = !layer->isOpaque(); const bool translucent = !layer->isOpaque();
Rect bounds(layer->computeBounds()); Rect bounds(layer->computeBounds());
visibleRegion.set(bounds); visibleRegion.set(bounds);
@ -1366,7 +1366,7 @@ void SurfaceFlinger::setTransactionState(
{ {
Mutex::Autolock _l(mStateLock); Mutex::Autolock _l(mStateLock);
int orientation = eOrientationUnchanged; int orientation = DisplayState::eOrientationUnchanged;
if (displays.size()) { if (displays.size()) {
// TODO: handle all displays // TODO: handle all displays
orientation = displays[0].orientation; orientation = displays[0].orientation;
@ -1375,10 +1375,10 @@ void SurfaceFlinger::setTransactionState(
uint32_t transactionFlags = 0; uint32_t transactionFlags = 0;
// FIXME: don't hardcode display id here // FIXME: don't hardcode display id here
if (mCurrentState.displays.valueFor(0).orientation != orientation) { if (mCurrentState.displays.valueFor(0).orientation != orientation) {
if (uint32_t(orientation)<=eOrientation270 || orientation==42) { if (uint32_t(orientation) <= DisplayState::eOrientation270) {
mCurrentState.displays.editValueFor(0).orientation = orientation; mCurrentState.displays.editValueFor(0).orientation = orientation;
transactionFlags |= eTransactionNeeded; transactionFlags |= eTransactionNeeded;
} else if (orientation != eOrientationUnchanged) { } else if (orientation != DisplayState::eOrientationUnchanged) {
ALOGW("setTransactionState: ignoring unrecognized orientation: %d", ALOGW("setTransactionState: ignoring unrecognized orientation: %d",
orientation); orientation);
} }
@ -1430,17 +1430,15 @@ sp<ISurface> SurfaceFlinger::createLayer(
} }
//ALOGD("createLayer for (%d x %d), name=%s", w, h, name.string()); //ALOGD("createLayer for (%d x %d), name=%s", w, h, name.string());
switch (flags & eFXSurfaceMask) { switch (flags & ISurfaceComposerClient::eFXSurfaceMask) {
case eFXSurfaceNormal: case ISurfaceComposerClient::eFXSurfaceNormal:
layer = createNormalLayer(client, d, w, h, flags, format); layer = createNormalLayer(client, d, w, h, flags, format);
break; break;
case eFXSurfaceBlur: case ISurfaceComposerClient::eFXSurfaceBlur:
// for now we treat Blur as Dim, until we can implement it case ISurfaceComposerClient::eFXSurfaceDim:
// efficiently.
case eFXSurfaceDim:
layer = createDimLayer(client, d, w, h, flags); layer = createDimLayer(client, d, w, h, flags);
break; break;
case eFXSurfaceScreenshot: case ISurfaceComposerClient::eFXSurfaceScreenshot:
layer = createScreenshotLayer(client, d, w, h, flags); layer = createScreenshotLayer(client, d, w, h, flags);
break; break;
} }
@ -1564,11 +1562,11 @@ uint32_t SurfaceFlinger::setClientStateLocked(
sp<LayerBaseClient> layer(client->getLayerUser(s.surface)); sp<LayerBaseClient> layer(client->getLayerUser(s.surface));
if (layer != 0) { if (layer != 0) {
const uint32_t what = s.what; const uint32_t what = s.what;
if (what & ePositionChanged) { if (what & layer_state_t::ePositionChanged) {
if (layer->setPosition(s.x, s.y)) if (layer->setPosition(s.x, s.y))
flags |= eTraversalNeeded; flags |= eTraversalNeeded;
} }
if (what & eLayerChanged) { if (what & layer_state_t::eLayerChanged) {
// NOTE: index needs to be calculated before we update the state // NOTE: index needs to be calculated before we update the state
ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer); ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
if (layer->setLayer(s.z)) { if (layer->setLayer(s.z)) {
@ -1579,32 +1577,32 @@ uint32_t SurfaceFlinger::setClientStateLocked(
flags |= eTransactionNeeded|eTraversalNeeded; flags |= eTransactionNeeded|eTraversalNeeded;
} }
} }
if (what & eSizeChanged) { if (what & layer_state_t::eSizeChanged) {
if (layer->setSize(s.w, s.h)) { if (layer->setSize(s.w, s.h)) {
flags |= eTraversalNeeded; flags |= eTraversalNeeded;
} }
} }
if (what & eAlphaChanged) { if (what & layer_state_t::eAlphaChanged) {
if (layer->setAlpha(uint8_t(255.0f*s.alpha+0.5f))) if (layer->setAlpha(uint8_t(255.0f*s.alpha+0.5f)))
flags |= eTraversalNeeded; flags |= eTraversalNeeded;
} }
if (what & eMatrixChanged) { if (what & layer_state_t::eMatrixChanged) {
if (layer->setMatrix(s.matrix)) if (layer->setMatrix(s.matrix))
flags |= eTraversalNeeded; flags |= eTraversalNeeded;
} }
if (what & eTransparentRegionChanged) { if (what & layer_state_t::eTransparentRegionChanged) {
if (layer->setTransparentRegionHint(s.transparentRegion)) if (layer->setTransparentRegionHint(s.transparentRegion))
flags |= eTraversalNeeded; flags |= eTraversalNeeded;
} }
if (what & eVisibilityChanged) { if (what & layer_state_t::eVisibilityChanged) {
if (layer->setFlags(s.flags, s.mask)) if (layer->setFlags(s.flags, s.mask))
flags |= eTraversalNeeded; flags |= eTraversalNeeded;
} }
if (what & eCropChanged) { if (what & layer_state_t::eCropChanged) {
if (layer->setCrop(s.crop)) if (layer->setCrop(s.crop))
flags |= eTraversalNeeded; flags |= eTraversalNeeded;
} }
if (what & eLayerStackChanged) { if (what & layer_state_t::eLayerStackChanged) {
// NOTE: index needs to be calculated before we update the state // NOTE: index needs to be calculated before we update the state
ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer); ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
if (layer->setLayerStack(s.layerStack)) { if (layer->setLayerStack(s.layerStack)) {
@ -1907,7 +1905,6 @@ status_t SurfaceFlinger::onTransact(
switch (code) { switch (code) {
case CREATE_CONNECTION: case CREATE_CONNECTION:
case SET_TRANSACTION_STATE: case SET_TRANSACTION_STATE:
case SET_ORIENTATION:
case BOOT_FINISHED: case BOOT_FINISHED:
case BLANK: case BLANK:
case UNBLANK: case UNBLANK:
@ -2162,7 +2159,7 @@ status_t SurfaceFlinger::captureScreenImplLocked(DisplayID dpy,
for (size_t i=0 ; i<count ; ++i) { for (size_t i=0 ; i<count ; ++i) {
const sp<LayerBase>& layer(layers[i]); const sp<LayerBase>& layer(layers[i]);
const uint32_t flags = layer->drawingState().flags; const uint32_t flags = layer->drawingState().flags;
if (!(flags & ISurfaceComposer::eLayerHidden)) { if (!(flags & layer_state_t::eLayerHidden)) {
const uint32_t z = layer->drawingState().z; const uint32_t z = layer->drawingState().z;
if (z >= minLayerZ && z <= maxLayerZ) { if (z >= minLayerZ && z <= maxLayerZ) {
if (filtering) layer->setFiltering(true); if (filtering) layer->setFiltering(true);