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

update SF binder protocol to support setting display attributes 

no change of functionality -- the old behavior is implemented
on top of this new protocol.
this new protocol will allow, eventually, to pass informations
about displays and layer stacks.

Change-Id: Ic6c2295e61ec8ecbc8ce01ab7664e35d928202fc
This commit is contained in:
Mathias Agopian 2012-07-24 20:43:54 -07:00
parent 921e6ac4b7
commit 8b33f03232
7 changed files with 91 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
include/gui/ISurfaceComposer.h
View File

@ -34,6 +34,7 @@ namespace android {
// ----------------------------------------------------------------------------
class ComposerState;
class DisplayState;
class IDisplayEventConnection;
class IMemoryHeap;
@ -104,8 +105,10 @@ public:
virtual sp<IMemoryHeap> getCblk() const = 0;
/* open/close transactions. requires ACCESS_SURFACE_FLINGER permission */
virtual void setTransactionState(const Vector<ComposerState>& state,
int orientation, uint32_t flags) = 0;
virtual void setTransactionState(
const Vector<ComposerState>& state,
const Vector<DisplayState>& displays,
uint32_t flags) = 0;
/* signal that we're done booting.
* Requires ACCESS_SURFACE_FLINGER permission

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

@ -77,6 +77,17 @@ struct ComposerState {
status_t read(const Parcel& input);
};
struct DisplayState {
int32_t displayId;
sp<ISurfaceTexture> surface;
uint32_t layerStack;
uint32_t orientation;
Rect viewport;
Rect frame;
status_t write(Parcel& output) const;
status_t read(const Parcel& input);
};
}; // namespace android
#endif // ANDROID_SF_LAYER_STATE_H

38
libs/gui/ISurfaceComposer.cpp
View File

@ -76,18 +76,29 @@ public:
return interface_cast<IMemoryHeap>(reply.readStrongBinder());
}
virtual void setTransactionState(const Vector<ComposerState>& state,
int orientation, uint32_t flags)
virtual void setTransactionState(
const Vector<ComposerState>& state,
const Vector<DisplayState>& displays,
uint32_t flags)
{
Parcel data, reply;
data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
Vector<ComposerState>::const_iterator b(state.begin());
Vector<ComposerState>::const_iterator e(state.end());
data.writeInt32(state.size());
for ( ; b != e ; ++b ) {
b->write(data);
{
Vector<ComposerState>::const_iterator b(state.begin());
Vector<ComposerState>::const_iterator e(state.end());
data.writeInt32(state.size());
for ( ; b != e ; ++b ) {
b->write(data);
}
}
{
Vector<DisplayState>::const_iterator b(displays.begin());
Vector<DisplayState>::const_iterator e(displays.end());
data.writeInt32(displays.size());
for ( ; b != e ; ++b ) {
b->write(data);
}
}
data.writeInt32(orientation);
data.writeInt32(flags);
remote()->transact(BnSurfaceComposer::SET_TRANSACTION_STATE, data, &reply);
}
@ -244,9 +255,16 @@ status_t BnSurfaceComposer::onTransact(
s.read(data);
state.add(s);
}
int orientation = data.readInt32();
count = data.readInt32();
DisplayState d;
Vector<DisplayState> displays;
displays.setCapacity(count);
for (size_t i=0 ; i<count ; i++) {
d.read(data);
displays.add(d);
}
uint32_t flags = data.readInt32();
setTransactionState(state, orientation, flags);
setTransactionState(state, displays, flags);
} break;
case BOOT_FINISHED: {
CHECK_INTERFACE(ISurfaceComposer, data, reply);

23
libs/gui/LayerState.cpp
View File

@ -17,6 +17,7 @@
#include <utils/Errors.h>
#include <binder/Parcel.h>
#include <gui/ISurfaceComposerClient.h>
#include <gui/ISurfaceTexture.h>
#include <private/gui/LayerState.h>
namespace android {
@ -69,4 +70,26 @@ status_t ComposerState::read(const Parcel& input) {
return state.read(input);
}
status_t DisplayState::write(Parcel& output) const {
output.writeStrongBinder(surface->asBinder());
output.writeInt32(displayId);
output.writeInt32(layerStack);
output.writeInt32(orientation);
memcpy(output.writeInplace(sizeof(Rect)), &viewport, sizeof(Rect));
memcpy(output.writeInplace(sizeof(Rect)), &frame, sizeof(Rect));
return NO_ERROR;
}
status_t DisplayState::read(const Parcel& input) {
surface = interface_cast<ISurfaceTexture>(input.readStrongBinder());
displayId = input.readInt32();
layerStack = input.readInt32();
orientation = input.readInt32();
memcpy(&viewport, input.readInplace(sizeof(Rect)), sizeof(Rect));
memcpy(&frame, input.readInplace(sizeof(Rect)), sizeof(Rect));
return NO_ERROR;
}
}; // namespace android

10
libs/gui/SurfaceComposerClient.cpp
View File

@ -138,7 +138,7 @@ void Composer::closeGlobalTransactionImpl(bool synchronous) {
sp<ISurfaceComposer> sm(getComposerService());
Vector<ComposerState> transaction;
int orientation;
Vector<DisplayState> displayTransaction;
uint32_t flags = 0;
{ // scope for the lock
@ -146,7 +146,11 @@ void Composer::closeGlobalTransactionImpl(bool synchronous) {
transaction = mStates;
mStates.clear();
orientation = mOrientation;
// FIXME: this should be the displays transaction state here
DisplayState item;
item.orientation = mOrientation;
displayTransaction.add(item);
mOrientation = ISurfaceComposer::eOrientationUnchanged;
if (synchronous || mForceSynchronous) {
@ -155,7 +159,7 @@ void Composer::closeGlobalTransactionImpl(bool synchronous) {
mForceSynchronous = false;
}
sm->setTransactionState(transaction, orientation, flags);
sm->setTransactionState(transaction, displayTransaction, flags);
}
layer_state_t* Composer::getLayerStateLocked(

19
services/surfaceflinger/SurfaceFlinger.cpp
View File

@ -143,7 +143,11 @@ void SurfaceFlinger::binderDied(const wp<IBinder>& who)
// reset screen orientation
Vector<ComposerState> state;
setTransactionState(state, eOrientationDefault, 0);
Vector<DisplayState> displays;
DisplayState d;
d.orientation = eOrientationDefault;
displays.add(d);
setTransactionState(state, displays, 0);
// restart the boot-animation
startBootAnim();
@ -1325,10 +1329,19 @@ uint32_t SurfaceFlinger::setTransactionFlags(uint32_t flags)
}
void SurfaceFlinger::setTransactionState(const Vector<ComposerState>& state,
int orientation, uint32_t flags) {
void SurfaceFlinger::setTransactionState(
const Vector<ComposerState>& state,
const Vector<DisplayState>& displays,
uint32_t flags)
{
Mutex::Autolock _l(mStateLock);
int orientation = eOrientationUnchanged;
if (displays.size()) {
// TODO: handle all displays
orientation = displays[0].orientation;
}
uint32_t transactionFlags = 0;
if (mCurrentState.orientation != orientation) {
if (uint32_t(orientation)<=eOrientation270 || orientation==42) {

2
services/surfaceflinger/SurfaceFlinger.h
View File

@ -165,7 +165,7 @@ private:
virtual sp<IMemoryHeap> getCblk() const;
virtual void bootFinished();
virtual void setTransactionState(const Vector<ComposerState>& state,
int orientation, uint32_t flags);
const Vector<DisplayState>& displays, uint32_t flags);
virtual bool authenticateSurfaceTexture(
const sp<ISurfaceTexture>& surface) const;
virtual sp<IDisplayEventConnection> createDisplayEventConnection();