Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

more splitting of Surface/SurfaceControl. Surface.java is now implemented in terms of Surface and SurfaceControl.

Browse Source 
The WindowManager side of Surface.java holds a SurfaceControl, while the client-side holds a Surface. When the client is in the system process, Surface.java holds both (which is a problem we'll try to fix later).
This commit is contained in:
Mathias Agopian
2009-04-16 20:04:08 -07:00
parent 6d2c0bc7bf
commit 17f638b39f
13 changed files with 338 additions and 683 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
core/java/android/view/Surface.java
View File

@@ -127,6 +127,8 @@ public class Surface implements Parcelable {
@SuppressWarnings("unused")
private int mSurface;
@SuppressWarnings("unused")
private int mSurfaceControl;
@SuppressWarnings("unused")
private int mSaveCount;
@SuppressWarnings("unused")
private Canvas mCanvas;
@@ -270,7 +272,7 @@ public class Surface implements Parcelable {
@Override
public String toString() {
return "Surface(native-token=" + mSurface + ")";
return "Surface(native-token=" + mSurfaceControl + ")";
}
private Surface(Parcel source) throws OutOfResourcesException {

210
core/jni/android_view_Surface.cpp
View File

@@ -45,6 +45,7 @@ struct sso_t {
static sso_t sso;
struct so_t {
jfieldID surfaceControl;
jfieldID surface;
jfieldID saveCount;
jfieldID canvas;
@@ -121,6 +122,27 @@ static void SurfaceSession_kill(JNIEnv* env, jobject clazz)
// ----------------------------------------------------------------------------
static sp<SurfaceControl> getSurfaceControl(JNIEnv* env, jobject clazz)
{
SurfaceControl* const p =
(SurfaceControl*)env->GetIntField(clazz, so.surfaceControl);
return sp<SurfaceControl>(p);
}
static void setSurfaceControl(JNIEnv* env, jobject clazz,
const sp<SurfaceControl>& surface)
{
SurfaceControl* const p =
(SurfaceControl*)env->GetIntField(clazz, so.surfaceControl);
if (surface.get()) {
surface->incStrong(clazz);
}
if (p) {
p->decStrong(clazz);
}
env->SetIntField(clazz, so.surfaceControl, (int)surface.get());
}
static sp<Surface> getSurface(JNIEnv* env, jobject clazz)
{
Surface* const p = (Surface*)env->GetIntField(clazz, so.surface);
@@ -153,12 +175,12 @@ static void Surface_init(
SurfaceComposerClient* client =
(SurfaceComposerClient*)env->GetIntField(session, sso.client);
sp<Surface> surface(client->createSurface(pid, dpy, w, h, format, flags));
sp<SurfaceControl> surface(client->createSurface(pid, dpy, w, h, format, flags));
if (surface == 0) {
doThrow(env, OutOfResourcesException);
return;
}
setSurface(env, clazz, surface);
setSurfaceControl(env, clazz, surface);
}
static void Surface_initParcel(JNIEnv* env, jobject clazz, jobject argParcel)
@@ -168,27 +190,33 @@ static void Surface_initParcel(JNIEnv* env, jobject clazz, jobject argParcel)
doThrow(env, "java/lang/NullPointerException", NULL);
return;
}
const sp<Surface>& rhs = Surface::readFromParcel(parcel);
sp<Surface> rhs = new Surface(*parcel);
setSurface(env, clazz, rhs);
}
static void Surface_clear(JNIEnv* env, jobject clazz, uintptr_t *ostack)
{
const sp<Surface>& surface = getSurface(env, clazz);
if (Surface::isValid(surface)) {
const sp<SurfaceControl>& surface(getSurfaceControl(env, clazz));
if (SurfaceControl::isValid(surface)) {
surface->clear();
}
setSurfaceControl(env, clazz, 0);
setSurface(env, clazz, 0);
}
static void Surface_release(JNIEnv* env, jobject clazz, uintptr_t *ostack)
{
setSurfaceControl(env, clazz, 0);
setSurface(env, clazz, 0);
}
static jboolean Surface_isValid(JNIEnv* env, jobject clazz)
{
const sp<Surface>& surface = getSurface(env, clazz);
const sp<SurfaceControl>& surfaceControl(getSurfaceControl(env, clazz));
if (surfaceControl != 0) {
return SurfaceControl::isValid(surfaceControl) ? JNI_TRUE : JNI_FALSE;
}
const sp<Surface>& surface(getSurface(env, clazz));
return Surface::isValid(surface) ? JNI_TRUE : JNI_FALSE;
}
@@ -209,7 +237,7 @@ static inline SkBitmap::Config convertPixelFormat(PixelFormat format)
static jobject Surface_lockCanvas(JNIEnv* env, jobject clazz, jobject dirtyRect)
{
const sp<Surface>& surface = getSurface(env, clazz);
const sp<Surface>& surface(getSurface(env, clazz));
if (!Surface::isValid(surface))
return 0;
@@ -278,7 +306,7 @@ static void Surface_unlockCanvasAndPost(
return;
}
const sp<Surface>& surface = getSurface(env, clazz);
const sp<Surface>& surface(getSurface(env, clazz));
if (!Surface::isValid(surface))
return;
@@ -345,138 +373,128 @@ static void Surface_unfreezeDisplay(
static void Surface_setLayer(
JNIEnv* env, jobject clazz, jint zorder)
{
const sp<Surface>& surface = getSurface(env, clazz);
if (Surface::isValid(surface)) {
if (surface->setLayer(zorder) < 0) {
doThrow(env, "java/lang/IllegalArgumentException", NULL);
}
}
const sp<SurfaceControl>& surface(getSurfaceControl(env, clazz));
if (surface == 0) return;
status_t err = surface->setLayer(zorder);
if (err<0 && err!=NO_INIT)
doThrow(env, "java/lang/IllegalArgumentException", NULL);
}
static void Surface_setPosition(
JNIEnv* env, jobject clazz, jint x, jint y)
{
const sp<Surface>& surface = getSurface(env, clazz);
if (Surface::isValid(surface)) {
if (surface->setPosition(x, y) < 0) {
doThrow(env, "java/lang/IllegalArgumentException", NULL);
}
}
const sp<SurfaceControl>& surface(getSurfaceControl(env, clazz));
if (surface == 0) return;
status_t err = surface->setPosition(x, y);
if (err<0 && err!=NO_INIT)
doThrow(env, "java/lang/IllegalArgumentException", NULL);
}
static void Surface_setSize(
JNIEnv* env, jobject clazz, jint w, jint h)
{
const sp<Surface>& surface = getSurface(env, clazz);
if (Surface::isValid(surface)) {
if (surface->setSize(w, h) < 0) {
doThrow(env, "java/lang/IllegalArgumentException", NULL);
}
}
const sp<SurfaceControl>& surface(getSurfaceControl(env, clazz));
if (surface == 0) return;
status_t err = surface->setSize(w, h);
if (err<0 && err!=NO_INIT)
doThrow(env, "java/lang/IllegalArgumentException", NULL);
}
static void Surface_hide(
JNIEnv* env, jobject clazz)
{
const sp<Surface>& surface = getSurface(env, clazz);
if (Surface::isValid(surface)) {
if (surface->hide() < 0) {
doThrow(env, "java/lang/IllegalArgumentException", NULL);
}
}
const sp<SurfaceControl>& surface(getSurfaceControl(env, clazz));
if (surface == 0) return;
status_t err = surface->hide();
if (err<0 && err!=NO_INIT)
doThrow(env, "java/lang/IllegalArgumentException", NULL);
}
static void Surface_show(
JNIEnv* env, jobject clazz)
{
const sp<Surface>& surface = getSurface(env, clazz);
if (Surface::isValid(surface)) {
if (surface->show() < 0) {
doThrow(env, "java/lang/IllegalArgumentException", NULL);
}
}
const sp<SurfaceControl>& surface(getSurfaceControl(env, clazz));
if (surface == 0) return;
status_t err = surface->show();
if (err<0 && err!=NO_INIT)
doThrow(env, "java/lang/IllegalArgumentException", NULL);
}
static void Surface_freeze(
JNIEnv* env, jobject clazz)
{
const sp<Surface>& surface = getSurface(env, clazz);
if (Surface::isValid(surface)) {
if (surface->freeze() < 0) {
doThrow(env, "java/lang/IllegalArgumentException", NULL);
}
}
const sp<SurfaceControl>& surface(getSurfaceControl(env, clazz));
if (surface == 0) return;
status_t err = surface->freeze();
if (err<0 && err!=NO_INIT)
doThrow(env, "java/lang/IllegalArgumentException", NULL);
}
static void Surface_unfreeze(
JNIEnv* env, jobject clazz)
{
const sp<Surface>& surface = getSurface(env, clazz);
if (Surface::isValid(surface)) {
if (surface->unfreeze() < 0) {
doThrow(env, "java/lang/IllegalArgumentException", NULL);
}
}
const sp<SurfaceControl>& surface(getSurfaceControl(env, clazz));
if (surface == 0) return;
status_t err = surface->unfreeze();
if (err<0 && err!=NO_INIT)
doThrow(env, "java/lang/IllegalArgumentException", NULL);
}
static void Surface_setFlags(
JNIEnv* env, jobject clazz, jint flags, jint mask)
{
const sp<Surface>& surface = getSurface(env, clazz);
if (Surface::isValid(surface)) {
if (surface->setFlags(flags, mask) < 0) {
doThrow(env, "java/lang/IllegalArgumentException", NULL);
}
}
const sp<SurfaceControl>& surface(getSurfaceControl(env, clazz));
if (surface == 0) return;
status_t err = surface->setFlags(flags, mask);
if (err<0 && err!=NO_INIT)
doThrow(env, "java/lang/IllegalArgumentException", NULL);
}
static void Surface_setTransparentRegion(
JNIEnv* env, jobject clazz, jobject argRegion)
{
const sp<Surface>& surface = getSurface(env, clazz);
if (Surface::isValid(surface)) {
SkRegion* nativeRegion = (SkRegion*)env->GetIntField(argRegion, no.native_region);
if (surface->setTransparentRegionHint(Region(*nativeRegion)) < 0) {
doThrow(env, "java/lang/IllegalArgumentException", NULL);
}
}
const sp<SurfaceControl>& surface(getSurfaceControl(env, clazz));
if (surface == 0) return;
SkRegion* nativeRegion = (SkRegion*)env->GetIntField(argRegion, no.native_region);
status_t err = surface->setTransparentRegionHint(Region(*nativeRegion));
if (err<0 && err!=NO_INIT)
doThrow(env, "java/lang/IllegalArgumentException", NULL);
}
static void Surface_setAlpha(
JNIEnv* env, jobject clazz, jfloat alpha)
{
const sp<Surface>& surface = getSurface(env, clazz);
if (Surface::isValid(surface)) {
if (surface->setAlpha(alpha) < 0) {
doThrow(env, "java/lang/IllegalArgumentException", NULL);
}
}
const sp<SurfaceControl>& surface(getSurfaceControl(env, clazz));
if (surface == 0) return;
status_t err = surface->setAlpha(alpha);
if (err<0 && err!=NO_INIT)
doThrow(env, "java/lang/IllegalArgumentException", NULL);
}
static void Surface_setMatrix(
JNIEnv* env, jobject clazz,
jfloat dsdx, jfloat dtdx, jfloat dsdy, jfloat dtdy)
{
const sp<Surface>& surface = getSurface(env, clazz);
if (Surface::isValid(surface)) {
if (surface->setMatrix(dsdx, dtdx, dsdy, dtdy) < 0) {
doThrow(env, "java/lang/IllegalArgumentException", NULL);
}
}
const sp<SurfaceControl>& surface(getSurfaceControl(env, clazz));
if (surface == 0) return;
status_t err = surface->setMatrix(dsdx, dtdx, dsdy, dtdy);
if (err<0 && err!=NO_INIT)
doThrow(env, "java/lang/IllegalArgumentException", NULL);
}
static void Surface_setFreezeTint(
JNIEnv* env, jobject clazz,
jint tint)
{
const sp<Surface>& surface = getSurface(env, clazz);
if (Surface::isValid(surface)) {
if (surface->setFreezeTint(tint) < 0) {
doThrow(env, "java/lang/IllegalArgumentException", NULL);
}
}
const sp<SurfaceControl>& surface(getSurfaceControl(env, clazz));
if (surface == 0) return;
status_t err = surface->setFreezeTint(tint);
if (err<0 && err!=NO_INIT)
doThrow(env, "java/lang/IllegalArgumentException", NULL);
}
// ----------------------------------------------------------------------------
static void Surface_copyFrom(
JNIEnv* env, jobject clazz, jobject other)
{
@@ -488,16 +506,23 @@ static void Surface_copyFrom(
return;
}
const sp<Surface>& surface = getSurface(env, clazz);
const sp<Surface>& rhs = getSurface(env, other);
if (!Surface::isSameSurface(surface, rhs)) {
/*
* This is used by the WindowManagerService just after constructing
* a Surface and is necessary for returning the Surface reference to
* the caller. At this point, we should only have a SurfaceControl.
*
*/
const sp<SurfaceControl>& surface = getSurfaceControl(env, clazz);
const sp<SurfaceControl>& rhs = getSurfaceControl(env, other);
if (!SurfaceControl::isSameSurface(surface, rhs)) {
// we reassign the surface only if it's a different one
// otherwise we would loose our client-side state.
setSurface(env, clazz, rhs);
setSurfaceControl(env, clazz, rhs);
setSurface(env, clazz, rhs->getSurface());
}
}
static void Surface_readFromParcel(
JNIEnv* env, jobject clazz, jobject argParcel)
{
@@ -507,9 +532,9 @@ static void Surface_readFromParcel(
return;
}
const sp<Surface>& surface = getSurface(env, clazz);
const sp<Surface>& rhs = Surface::readFromParcel(parcel);
if (!Surface::isSameSurface(surface, rhs)) {
const sp<Surface>& control(getSurface(env, clazz));
sp<Surface> rhs = new Surface(*parcel);
if (!Surface::isSameSurface(control, rhs)) {
// we reassign the surface only if it's a different one
// otherwise we would loose our client-side state.
setSurface(env, clazz, rhs);
@@ -527,8 +552,8 @@ static void Surface_writeToParcel(
return;
}
const sp<Surface>& surface = getSurface(env, clazz);
Surface::writeToParcel(surface, parcel);
const sp<SurfaceControl>& control(getSurfaceControl(env, clazz));
SurfaceControl::writeSurfaceToParcel(control, parcel);
}
// ----------------------------------------------------------------------------
@@ -579,7 +604,8 @@ static JNINativeMethod gSurfaceMethods[] = {
void nativeClassInit(JNIEnv* env, jclass clazz)
{
so.surface = env->GetFieldID(clazz, "mSurface", "I");
so.surface = env->GetFieldID(clazz, "mSurface", "I");
so.surfaceControl = env->GetFieldID(clazz, "mSurfaceControl", "I");
so.saveCount = env->GetFieldID(clazz, "mSaveCount", "I");
so.canvas = env->GetFieldID(clazz, "mCanvas", "Landroid/graphics/Canvas;");

101
include/ui/Surface.h
View File

@@ -75,13 +75,19 @@ private:
};
// ---------------------------------------------------------------------------
class Surface;
class SurfaceControl : public RefBase
{
public:
static bool isValid(const sp<SurfaceControl>& surface) {
return (surface != 0) && surface->mToken>=0 && surface->mClient!=0;
return (surface != 0) && surface->isValid();
}
bool isValid() {
return mToken>=0 && mClient!=0;
}
static bool isSameSurface(
const sp<SurfaceControl>& lhs, const sp<SurfaceControl>& rhs);
SurfaceID ID() const { return mToken; }
uint32_t getFlags() const { return mFlags; }
@@ -90,10 +96,6 @@ public:
// release surface data from java
void clear();
static sp<SurfaceControl> readFromParcel(Parcel* parcel);
static status_t writeToParcel(const sp<SurfaceControl>& surface, Parcel* parcel);
static bool isSameSurface(const sp<SurfaceControl>& lhs, const sp<SurfaceControl>& rhs);
status_t setLayer(int32_t layer);
status_t setPosition(int32_t x, int32_t y);
status_t setSize(uint32_t w, uint32_t h);
@@ -107,7 +109,17 @@ public:
status_t setMatrix(float dsdx, float dtdx, float dsdy, float dtdy);
status_t setFreezeTint(uint32_t tint);
static status_t writeSurfaceToParcel(
const sp<SurfaceControl>& control, Parcel* parcel);
sp<Surface> getSurface() const;
private:
// can't be copied
SurfaceControl& operator = (SurfaceControl& rhs);
SurfaceControl(const SurfaceControl& rhs);
friend class SurfaceComposerClient;
// camera and camcorder need access to the ISurface binder interface for preview
@@ -115,22 +127,22 @@ private:
friend class MediaRecorder;
// mediaplayer needs access to ISurface for display
friend class MediaPlayer;
// for testing
friend class Test;
const sp<ISurface>& getISurface() const { return mSurface; }
// can't be copied
SurfaceControl& operator = (SurfaceControl& rhs);
SurfaceControl(const SurfaceControl& rhs);
friend class Surface;
SurfaceControl(const sp<SurfaceComposerClient>& client,
SurfaceControl(
const sp<SurfaceComposerClient>& client,
const sp<ISurface>& surface,
const ISurfaceFlingerClient::surface_data_t& data,
uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
bool owner = true);
~SurfaceControl();
status_t validate(per_client_cblk_t const* cblk) const;
void destroy();
@@ -142,6 +154,8 @@ private:
uint32_t mFlags;
const bool mOwner;
mutable Mutex mLock;
mutable sp<Surface> mSurfaceData;
};
// ---------------------------------------------------------------------------
@@ -160,45 +174,40 @@ public:
uint32_t reserved[2];
};
static bool isValid(const sp<Surface>& surface) {
return (surface != 0) && surface->mToken>=0 && surface->mClient!=0;
}
SurfaceID ID() const { return mToken; }
Surface(const Parcel& data);
static bool isValid(const sp<Surface>& surface) {
return (surface != 0) && surface->isValid();
}
bool isValid() {
return mToken>=0 && mClient!=0;
}
static bool isSameSurface(
const sp<Surface>& lhs, const sp<Surface>& rhs);
SurfaceID ID() const { return mToken; }
uint32_t getFlags() const { return mFlags; }
uint32_t getIdentity() const { return mIdentity; }
// release surface data from java
void clear();
status_t lock(SurfaceInfo* info, bool blocking = true);
status_t lock(SurfaceInfo* info, Region* dirty, bool blocking = true);
status_t unlockAndPost();
uint32_t getFlags() const { return mFlags; }
// setSwapRectangle() is mainly used by EGL
void setSwapRectangle(const Rect& r);
const Rect& swapRectangle() const;
static sp<Surface> readFromParcel(Parcel* parcel);
static status_t writeToParcel(const sp<Surface>& surface, Parcel* parcel);
static bool isSameSurface(const sp<Surface>& lhs, const sp<Surface>& rhs);
status_t setLayer(int32_t layer);
status_t setPosition(int32_t x, int32_t y);
status_t setSize(uint32_t w, uint32_t h);
status_t hide();
status_t show(int32_t layer = -1);
status_t freeze();
status_t unfreeze();
status_t setFlags(uint32_t flags, uint32_t mask);
status_t setTransparentRegionHint(const Region& transparent);
status_t setAlpha(float alpha=1.0f);
status_t setMatrix(float dsdx, float dtdx, float dsdy, float dtdy);
status_t setFreezeTint(uint32_t tint);
uint32_t getIdentity() const { return mIdentity; }
private:
// can't be copied
Surface& operator = (Surface& rhs);
Surface(const Surface& rhs);
Surface(const sp<SurfaceControl>& control);
void init();
~Surface();
friend class SurfaceComposerClient;
friend class SurfaceControl;
// camera and camcorder need access to the ISurface binder interface for preview
friend class Camera;
@@ -210,22 +219,8 @@ private:
status_t getBufferLocked(int index);
// can't be copied
Surface& operator = (Surface& rhs);
Surface(const Surface& rhs);
Surface(const sp<SurfaceComposerClient>& client,
const sp<ISurface>& surface,
const ISurfaceFlingerClient::surface_data_t& data,
uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
bool owner = true);
Surface(Surface const* rhs);
~Surface();
void destroy();
Region dirtyRegion() const;
void setDirtyRegion(const Region& region) const;
@@ -262,8 +257,6 @@ private:
mutable Rect mSwapRectangle;
mutable uint8_t mBackbufferIndex;
mutable Mutex mSurfaceLock;
sp<SurfaceControl> mSurfaceControl;
};
}; // namespace android

2
include/ui/SurfaceComposerClient.h
View File

@@ -62,7 +62,7 @@ public:
// surface creation / destruction
//! Create a surface
sp<Surface> createSurface(
sp<SurfaceControl> createSurface(
int pid, //!< pid of the process the surfacec is for
DisplayID display, //!< Display to create this surface on
uint32_t w, //!< width in pixel

1
libs/surfaceflinger/Android.mk
View File

@@ -8,7 +8,6 @@ LOCAL_SRC_FILES:= \
BootAnimation.cpp \
BlurFilter.cpp.arm \
BufferAllocator.cpp \
CPUGauge.cpp \
Layer.cpp \
LayerBase.cpp \
LayerBuffer.cpp \

11
libs/surfaceflinger/BootAnimation.cpp
View File

@@ -128,12 +128,14 @@ status_t BootAnimation::readyToRun() {
return -1;
// create the native surface
sp<Surface> s = session()->createSurface(getpid(), 0, dinfo.w, dinfo.h,
PIXEL_FORMAT_RGB_565);
sp<SurfaceControl> control = session()->createSurface(
getpid(), 0, dinfo.w, dinfo.h, PIXEL_FORMAT_RGB_565);
session()->openTransaction();
s->setLayer(0x40000000);
control->setLayer(0x40000000);
session()->closeTransaction();
sp<Surface> s = control->getSurface();
// initialize opengl and egl
const EGLint attribs[] = { EGL_RED_SIZE, 5, EGL_GREEN_SIZE, 6,
EGL_BLUE_SIZE, 5, EGL_DEPTH_SIZE, 0, EGL_NONE };
@@ -156,6 +158,7 @@ status_t BootAnimation::readyToRun() {
mSurface = surface;
mWidth = w;
mHeight = h;
mFlingerSurfaceControl = control;
mFlingerSurface = s;
// initialize GL
@@ -176,7 +179,7 @@ bool BootAnimation::threadLoop() {
eglMakeCurrent(mDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
eglDestroyContext(mDisplay, mContext);
eglDestroySurface(mDisplay, mSurface);
mFlingerSurface.clear();
mFlingerSurfaceControl.clear();
return r;
}

1
libs/surfaceflinger/BootAnimation.h
View File

@@ -71,6 +71,7 @@ private:
EGLDisplay mDisplay;
EGLDisplay mContext;
EGLDisplay mSurface;
sp<SurfaceControl> mFlingerSurfaceControl;
sp<Surface> mFlingerSurface;
Barrier mBarrier;
};

169
libs/surfaceflinger/CPUGauge.cpp
View File

@@ -1,169 +0,0 @@
/*
* 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.
*/
#include <stdint.h>
#include <limits.h>
#include <sys/types.h>
#include <math.h>
#include <utils/threads.h>
#include <utils/Errors.h>
#include <utils/Log.h>
#include <ui/PixelFormat.h>
#include <ui/Rect.h>
#include <ui/Region.h>
#include <ui/DisplayInfo.h>
#include <ui/ISurfaceComposer.h>
#include <ui/ISurfaceFlingerClient.h>
#include <pixelflinger/pixelflinger.h>
#include "CPUGauge.h"
namespace android {
CPUGauge::CPUGauge( const sp<ISurfaceComposer>& composer,
nsecs_t interval,
int clock,
int refclock)
: Thread(false),
mInterval(interval), mClock(clock), mRefClock(refclock),
mReferenceTime(0),
mReferenceWorkingTime(0), mCpuUsage(0),
mRefIdleTime(0), mIdleTime(0)
{
mFd = fopen("/proc/stat", "r");
setvbuf(mFd, NULL, _IONBF, 0);
mSession = SurfaceComposerClient::clientForConnection(
composer->createConnection()->asBinder());
}
CPUGauge::~CPUGauge()
{
fclose(mFd);
}
const sp<SurfaceComposerClient>& CPUGauge::session() const
{
return mSession;
}
void CPUGauge::onFirstRef()
{
run("CPU Gauge");
}
status_t CPUGauge::readyToRun()
{
LOGI("Starting CPU gauge...");
return NO_ERROR;
}
bool CPUGauge::threadLoop()
{
DisplayInfo dinfo;
session()->getDisplayInfo(0, &dinfo);
sp<Surface> s(session()->createSurface(getpid(), 0, dinfo.w, 4, PIXEL_FORMAT_OPAQUE));
session()->openTransaction();
s->setLayer(INT_MAX);
session()->closeTransaction();
static const GGLfixed colors[4][4] = {
{ 0x00000, 0x10000, 0x00000, 0x10000 },
{ 0x10000, 0x10000, 0x00000, 0x10000 },
{ 0x10000, 0x00000, 0x00000, 0x10000 },
{ 0x00000, 0x00000, 0x00000, 0x10000 },
};
GGLContext* gl;
gglInit(&gl);
gl->activeTexture(gl, 0);
gl->disable(gl, GGL_TEXTURE_2D);
gl->disable(gl, GGL_BLEND);
const int w = dinfo.w;
while(!exitPending())
{
mLock.lock();
const float cpuUsage = this->cpuUsage();
const float totalCpuUsage = 1.0f - idle();
mLock.unlock();
Surface::SurfaceInfo info;
s->lock(&info);
GGLSurface fb;
fb.version = sizeof(GGLSurface);
fb.width = info.w;
fb.height = info.h;
fb.stride = info.s;
fb.format = info.format;
fb.data = (GGLubyte*)info.bits;
gl->colorBuffer(gl, &fb);
gl->color4xv(gl, colors[3]);
gl->recti(gl, 0, 0, w, 4);
gl->color4xv(gl, colors[2]); // red
gl->recti(gl, 0, 0, int(totalCpuUsage*w), 2);
gl->color4xv(gl, colors[0]); // green
gl->recti(gl, 0, 2, int(cpuUsage*w), 4);
s->unlockAndPost();
usleep(ns2us(mInterval));
}
gglUninit(gl);
return false;
}
void CPUGauge::sample()
{
if (mLock.tryLock() == NO_ERROR) {
const nsecs_t now = systemTime(mRefClock);
const nsecs_t referenceTime = now-mReferenceTime;
if (referenceTime >= mInterval) {
const float reftime = 1.0f / referenceTime;
const nsecs_t nowWorkingTime = systemTime(mClock);
char buf[256];
fgets(buf, 256, mFd);
rewind(mFd);
char *str = buf+5;
char const * const usermode = strsep(&str, " "); (void)usermode;
char const * const usernice = strsep(&str, " "); (void)usernice;
char const * const systemmode = strsep(&str, " ");(void)systemmode;
char const * const idle = strsep(&str, " ");
const nsecs_t nowIdleTime = atoi(idle) * 10000000LL;
mIdleTime = float(nowIdleTime - mRefIdleTime) * reftime;
mRefIdleTime = nowIdleTime;
const nsecs_t workingTime = nowWorkingTime - mReferenceWorkingTime;
const float newCpuUsage = float(workingTime) * reftime;
if (mCpuUsage != newCpuUsage) {
mCpuUsage = newCpuUsage;
mReferenceWorkingTime = nowWorkingTime;
mReferenceTime = now;
}
}
mLock.unlock();
}
}
}; // namespace android

74
libs/surfaceflinger/CPUGauge.h
View File

@@ -1,74 +0,0 @@
/*
* 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_CPUGAUGE_H
#define ANDROID_CPUGAUGE_H
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <sys/types.h>
#include <utils/Timers.h>
#include <ui/SurfaceComposerClient.h>
namespace android {
class CPUGauge : public Thread
{
public:
CPUGauge( const sp<ISurfaceComposer>& composer,
nsecs_t interval=s2ns(1),
int clock=SYSTEM_TIME_THREAD,
int refclock=SYSTEM_TIME_MONOTONIC);
~CPUGauge();
const sp<SurfaceComposerClient>& session() const;
void sample();
inline float cpuUsage() const { return mCpuUsage; }
inline float idle() const { return mIdleTime; }
private:
virtual void onFirstRef();
virtual status_t readyToRun();
virtual bool threadLoop();
Mutex mLock;
sp<SurfaceComposerClient> mSession;
const nsecs_t mInterval;
const int mClock;
const int mRefClock;
nsecs_t mReferenceTime;
nsecs_t mReferenceWorkingTime;
float mCpuUsage;
nsecs_t mRefIdleTime;
float mIdleTime;
FILE* mFd;
};
}; // namespace android
#endif // ANDROID_CPUGAUGE_H

38
libs/surfaceflinger/SurfaceFlinger.cpp
View File

@@ -45,7 +45,6 @@
#include "clz.h"
#include "BufferAllocator.h"
#include "CPUGauge.h"
#include "Layer.h"
#include "LayerBlur.h"
#include "LayerBuffer.h"
@@ -179,7 +178,6 @@ SurfaceFlinger::SurfaceFlinger()
mFreezeCount(0),
mFreezeDisplayTime(0),
mDebugRegion(0),
mDebugCpu(0),
mDebugFps(0),
mDebugBackground(0),
mDebugNoBootAnimation(0),
@@ -199,8 +197,6 @@ void SurfaceFlinger::init()
char value[PROPERTY_VALUE_MAX];
property_get("debug.sf.showupdates", value, "0");
mDebugRegion = atoi(value);
property_get("debug.sf.showcpu", value, "0");
mDebugCpu = atoi(value);
property_get("debug.sf.showbackground", value, "0");
mDebugBackground = atoi(value);
property_get("debug.sf.showfps", value, "0");
@@ -209,7 +205,6 @@ void SurfaceFlinger::init()
mDebugNoBootAnimation = atoi(value);
LOGI_IF(mDebugRegion, "showupdates enabled");
LOGI_IF(mDebugCpu, "showcpu enabled");
LOGI_IF(mDebugBackground, "showbackground enabled");
LOGI_IF(mDebugFps, "showfps enabled");
LOGI_IF(mDebugNoBootAnimation, "boot animation disabled");
@@ -413,10 +408,6 @@ status_t SurfaceFlinger::readyToRun()
mOrientationAnimation = new OrientationAnimation(this);
// start CPU gauge display
if (mDebugCpu)
mCpuGauge = new CPUGauge(this, ms2ns(500));
// the boot animation!
if (mDebugNoBootAnimation == false)
mBootAnimation = new BootAnimation(this);
@@ -509,11 +500,6 @@ bool SurfaceFlinger::threadLoop()
unlockClients();
executeScheduledBroadcasts();
// sample the cpu gauge
if (UNLIKELY(mDebugCpu)) {
handleDebugCpu();
}
postFramebuffer();
} else {
// pretend we did the post
@@ -905,13 +891,6 @@ void SurfaceFlinger::executeScheduledBroadcasts()
mLastScheduledBroadcast = 0;
}
void SurfaceFlinger::handleDebugCpu()
{
Mutex::Autolock _l(mDebugLock);
if (mCpuGauge != 0)
mCpuGauge->sample();
}
void SurfaceFlinger::debugFlashRegions()
{
if (UNLIKELY(!mDirtyRegion.isRect())) {
@@ -1502,20 +1481,7 @@ status_t SurfaceFlinger::onTransact(
}
int n;
switch (code) {
case 1000: // SHOW_CPU
n = data.readInt32();
mDebugCpu = n ? 1 : 0;
if (mDebugCpu) {
if (mCpuGauge == 0) {
mCpuGauge = new CPUGauge(this, ms2ns(500));
}
} else {
if (mCpuGauge != 0) {
mCpuGauge->requestExitAndWait();
Mutex::Autolock _l(mDebugLock);
mCpuGauge.clear();
}
}
case 1000: // SHOW_CPU, NOT SUPPORTED ANYMORE
return NO_ERROR;
case 1001: // SHOW_FPS
n = data.readInt32();
@@ -1540,7 +1506,7 @@ status_t SurfaceFlinger::onTransact(
mFreezeCount = data.readInt32();
return NO_ERROR;
case 1010: // interrogate.
reply->writeInt32(mDebugCpu);
reply->writeInt32(0);
reply->writeInt32(0);
reply->writeInt32(mDebugRegion);
reply->writeInt32(mDebugBackground);

7
libs/surfaceflinger/SurfaceFlinger.h
View File

@@ -38,7 +38,6 @@
#include "Barrier.h"
#include "BootAnimation.h"
#include "CPUGauge.h"
#include "Layer.h"
#include "Tokenizer.h"
@@ -277,7 +276,6 @@ private:
bool lockPageFlip(const LayerVector& currentLayers);
void unlockPageFlip(const LayerVector& currentLayers);
void handleRepaint();
void handleDebugCpu();
void scheduleBroadcast(Client* client);
void executeScheduledBroadcasts();
void postFramebuffer();
@@ -349,13 +347,8 @@ private:
friend class OrientationAnimation;
OrientationAnimation* mOrientationAnimation;
// access protected by mDebugLock
mutable Mutex mDebugLock;
sp<CPUGauge> mCpuGauge;
// don't use a lock for these, we don't care
int mDebugRegion;
int mDebugCpu;
int mDebugFps;
int mDebugBackground;
int mDebugNoBootAnimation;

397
libs/ui/Surface.cpp
View File

@@ -148,8 +148,8 @@ static void copyBlt(const android_native_buffer_t* dst,
// SurfaceControl
// ============================================================================
SurfaceControl::SurfaceControl(const sp<SurfaceComposerClient>& client,
SurfaceControl::SurfaceControl(
const sp<SurfaceComposerClient>& client,
const sp<ISurface>& surface,
const ISurfaceFlingerClient::surface_data_t& data,
uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
@@ -159,7 +159,6 @@ SurfaceControl::SurfaceControl(const sp<SurfaceComposerClient>& client,
mFormat(format), mFlags(flags), mOwner(owner)
{
}
SurfaceControl::~SurfaceControl()
{
destroy();
@@ -192,133 +191,6 @@ void SurfaceControl::clear()
destroy();
}
status_t SurfaceControl::setLayer(int32_t layer) {
const sp<SurfaceComposerClient>& client(mClient);
if (client == 0) return INVALID_OPERATION;
status_t err = validate(client->mControl);
if (err < 0) return err;
return client->setLayer(mToken, layer);
}
status_t SurfaceControl::setPosition(int32_t x, int32_t y) {
const sp<SurfaceComposerClient>& client(mClient);
if (client == 0) return INVALID_OPERATION;
status_t err = validate(client->mControl);
if (err < 0) return err;
return client->setPosition(mToken, x, y);
}
status_t SurfaceControl::setSize(uint32_t w, uint32_t h) {
const sp<SurfaceComposerClient>& client(mClient);
if (client == 0) return INVALID_OPERATION;
status_t err = validate(client->mControl);
if (err < 0) return err;
return client->setSize(mToken, w, h);
}
status_t SurfaceControl::hide() {
const sp<SurfaceComposerClient>& client(mClient);
if (client == 0) return INVALID_OPERATION;
status_t err = validate(client->mControl);
if (err < 0) return err;
return client->hide(mToken);
}
status_t SurfaceControl::show(int32_t layer) {
const sp<SurfaceComposerClient>& client(mClient);
if (client == 0) return INVALID_OPERATION;
status_t err = validate(client->mControl);
if (err < 0) return err;
return client->show(mToken, layer);
}
status_t SurfaceControl::freeze() {
const sp<SurfaceComposerClient>& client(mClient);
if (client == 0) return INVALID_OPERATION;
status_t err = validate(client->mControl);
if (err < 0) return err;
return client->freeze(mToken);
}
status_t SurfaceControl::unfreeze() {
const sp<SurfaceComposerClient>& client(mClient);
if (client == 0) return INVALID_OPERATION;
status_t err = validate(client->mControl);
if (err < 0) return err;
return client->unfreeze(mToken);
}
status_t SurfaceControl::setFlags(uint32_t flags, uint32_t mask) {
const sp<SurfaceComposerClient>& client(mClient);
if (client == 0) return INVALID_OPERATION;
status_t err = validate(client->mControl);
if (err < 0) return err;
return client->setFlags(mToken, flags, mask);
}
status_t SurfaceControl::setTransparentRegionHint(const Region& transparent) {
const sp<SurfaceComposerClient>& client(mClient);
if (client == 0) return INVALID_OPERATION;
status_t err = validate(client->mControl);
if (err < 0) return err;
return client->setTransparentRegionHint(mToken, transparent);
}
status_t SurfaceControl::setAlpha(float alpha) {
const sp<SurfaceComposerClient>& client(mClient);
if (client == 0) return INVALID_OPERATION;
status_t err = validate(client->mControl);
if (err < 0) return err;
return client->setAlpha(mToken, alpha);
}
status_t SurfaceControl::setMatrix(float dsdx, float dtdx, float dsdy, float dtdy) {
const sp<SurfaceComposerClient>& client(mClient);
if (client == 0) return INVALID_OPERATION;
status_t err = validate(client->mControl);
if (err < 0) return err;
return client->setMatrix(mToken, dsdx, dtdx, dsdy, dtdy);
}
status_t SurfaceControl::setFreezeTint(uint32_t tint) {
const sp<SurfaceComposerClient>& client(mClient);
if (client == 0) return INVALID_OPERATION;
status_t err = validate(client->mControl);
if (err < 0) return err;
return client->setFreezeTint(mToken, tint);
}
sp<SurfaceControl> SurfaceControl::readFromParcel(Parcel* parcel)
{
sp<SurfaceComposerClient> client;
ISurfaceFlingerClient::surface_data_t data;
sp<IBinder> clientBinder= parcel->readStrongBinder();
sp<ISurface> surface = interface_cast<ISurface>(parcel->readStrongBinder());
data.token = parcel->readInt32();
data.identity = parcel->readInt32();
PixelFormat format = parcel->readInt32();
uint32_t flags = parcel->readInt32();
if (clientBinder != NULL)
client = SurfaceComposerClient::clientForConnection(clientBinder);
return new SurfaceControl(client, surface, data, 0, 0, format, flags, false);
}
status_t SurfaceControl::writeToParcel(const sp<SurfaceControl>& surface, Parcel* parcel)
{
uint32_t flags=0;
uint32_t format=0;
SurfaceID token = -1;
uint32_t identity = 0;
sp<SurfaceComposerClient> client;
sp<ISurface> sur;
if (SurfaceControl::isValid(surface)) {
token = surface->mToken;
identity = surface->mIdentity;
client = surface->mClient;
sur = surface->mSurface;
format = surface->mFormat;
flags = surface->mFlags;
}
parcel->writeStrongBinder(client!=0 ? client->connection() : NULL);
parcel->writeStrongBinder(sur!=0 ? sur->asBinder() : NULL);
parcel->writeInt32(token);
parcel->writeInt32(identity);
parcel->writeInt32(format);
parcel->writeInt32(flags);
return NO_ERROR;
}
bool SurfaceControl::isSameSurface(
const sp<SurfaceControl>& lhs, const sp<SurfaceControl>& rhs)
{
@@ -327,6 +199,90 @@ bool SurfaceControl::isSameSurface(
return lhs->mSurface->asBinder() == rhs->mSurface->asBinder();
}
status_t SurfaceControl::setLayer(int32_t layer) {
const sp<SurfaceComposerClient>& client(mClient);
if (client == 0) return NO_INIT;
status_t err = validate(client->mControl);
if (err < 0) return err;
return client->setLayer(mToken, layer);
}
status_t SurfaceControl::setPosition(int32_t x, int32_t y) {
const sp<SurfaceComposerClient>& client(mClient);
if (client == 0) return NO_INIT;
status_t err = validate(client->mControl);
if (err < 0) return err;
return client->setPosition(mToken, x, y);
}
status_t SurfaceControl::setSize(uint32_t w, uint32_t h) {
const sp<SurfaceComposerClient>& client(mClient);
if (client == 0) return NO_INIT;
status_t err = validate(client->mControl);
if (err < 0) return err;
return client->setSize(mToken, w, h);
}
status_t SurfaceControl::hide() {
const sp<SurfaceComposerClient>& client(mClient);
if (client == 0) return NO_INIT;
status_t err = validate(client->mControl);
if (err < 0) return err;
return client->hide(mToken);
}
status_t SurfaceControl::show(int32_t layer) {
const sp<SurfaceComposerClient>& client(mClient);
if (client == 0) return NO_INIT;
status_t err = validate(client->mControl);
if (err < 0) return err;
return client->show(mToken, layer);
}
status_t SurfaceControl::freeze() {
const sp<SurfaceComposerClient>& client(mClient);
if (client == 0) return NO_INIT;
status_t err = validate(client->mControl);
if (err < 0) return err;
return client->freeze(mToken);
}
status_t SurfaceControl::unfreeze() {
const sp<SurfaceComposerClient>& client(mClient);
if (client == 0) return NO_INIT;
status_t err = validate(client->mControl);
if (err < 0) return err;
return client->unfreeze(mToken);
}
status_t SurfaceControl::setFlags(uint32_t flags, uint32_t mask) {
const sp<SurfaceComposerClient>& client(mClient);
if (client == 0) return NO_INIT;
status_t err = validate(client->mControl);
if (err < 0) return err;
return client->setFlags(mToken, flags, mask);
}
status_t SurfaceControl::setTransparentRegionHint(const Region& transparent) {
const sp<SurfaceComposerClient>& client(mClient);
if (client == 0) return NO_INIT;
status_t err = validate(client->mControl);
if (err < 0) return err;
return client->setTransparentRegionHint(mToken, transparent);
}
status_t SurfaceControl::setAlpha(float alpha) {
const sp<SurfaceComposerClient>& client(mClient);
if (client == 0) return NO_INIT;
status_t err = validate(client->mControl);
if (err < 0) return err;
return client->setAlpha(mToken, alpha);
}
status_t SurfaceControl::setMatrix(float dsdx, float dtdx, float dsdy, float dtdy) {
const sp<SurfaceComposerClient>& client(mClient);
if (client == 0) return NO_INIT;
status_t err = validate(client->mControl);
if (err < 0) return err;
return client->setMatrix(mToken, dsdx, dtdx, dsdy, dtdy);
}
status_t SurfaceControl::setFreezeTint(uint32_t tint) {
const sp<SurfaceComposerClient>& client(mClient);
if (client == 0) return NO_INIT;
status_t err = validate(client->mControl);
if (err < 0) return err;
return client->setFreezeTint(mToken, tint);
}
status_t SurfaceControl::validate(per_client_cblk_t const* cblk) const
{
@@ -353,22 +309,72 @@ status_t SurfaceControl::validate(per_client_cblk_t const* cblk) const
return NO_ERROR;
}
status_t SurfaceControl::writeSurfaceToParcel(
const sp<SurfaceControl>& control, Parcel* parcel)
{
uint32_t flags = 0;
uint32_t format = 0;
SurfaceID token = -1;
uint32_t identity = 0;
sp<SurfaceComposerClient> client;
sp<ISurface> sur;
if (SurfaceControl::isValid(control)) {
token = control->mToken;
identity = control->mIdentity;
client = control->mClient;
sur = control->mSurface;
format = control->mFormat;
flags = control->mFlags;
}
parcel->writeStrongBinder(client!=0 ? client->connection() : NULL);
parcel->writeStrongBinder(sur!=0 ? sur->asBinder() : NULL);
parcel->writeInt32(token);
parcel->writeInt32(identity);
parcel->writeInt32(format);
parcel->writeInt32(flags);
return NO_ERROR;
}
sp<Surface> SurfaceControl::getSurface() const
{
Mutex::Autolock _l(mLock);
if (mSurfaceData == 0) {
mSurfaceData = new Surface(const_cast<SurfaceControl*>(this));
}
return mSurfaceData;
}
// ============================================================================
// Surface
// ============================================================================
Surface::Surface(const sp<SurfaceComposerClient>& client,
const sp<ISurface>& surface,
const ISurfaceFlingerClient::surface_data_t& data,
uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
bool owner)
: mClient(client), mSurface(surface),
mToken(data.token), mIdentity(data.identity),
mFormat(format), mFlags(flags), mOwner(owner)
Surface::Surface(const sp<SurfaceControl>& surface)
: mClient(surface->mClient), mSurface(surface->mSurface),
mToken(surface->mToken), mIdentity(surface->mIdentity),
mFormat(surface->mFormat), mFlags(surface->mFlags),
mOwner(surface->mOwner)
{
mSurfaceControl = new SurfaceControl(
client, surface, data, w, h, format, flags, owner);
init();
}
Surface::Surface(const Parcel& parcel)
: mOwner(false)
{
sp<IBinder> clientBinder = parcel.readStrongBinder();
mSurface = interface_cast<ISurface>(parcel.readStrongBinder());
mToken = parcel.readInt32();
mIdentity = parcel.readInt32();
mFormat = parcel.readInt32();
mFlags = parcel.readInt32();
if (clientBinder != NULL)
mClient = SurfaceComposerClient::clientForConnection(clientBinder);
init();
}
void Surface::init()
{
android_native_window_t::connect = connect;
android_native_window_t::disconnect = disconnect;
android_native_window_t::setSwapInterval = setSwapInterval;
@@ -389,6 +395,7 @@ Surface::Surface(const sp<SurfaceComposerClient>& client,
const_cast<uint32_t&>(android_native_window_t::flags) = 0;
}
Surface::~Surface()
{
// this is a client-side operation, the surface is destroyed, unmap
@@ -399,13 +406,6 @@ Surface::~Surface()
}
}
destroy();
}
void Surface::destroy()
{
mSurfaceControl->destroy();
// clear all references and trigger an IPC now, to make sure things
// happen without delay, since these resources are quite heavy.
mClient.clear();
@@ -413,11 +413,6 @@ void Surface::destroy()
IPCThreadState::self()->flushCommands();
}
void Surface::clear()
{
mSurfaceControl->clear();
}
status_t Surface::validate(per_client_cblk_t const* cblk) const
{
if (mToken<0 || mClient==0) {
@@ -443,6 +438,15 @@ status_t Surface::validate(per_client_cblk_t const* cblk) const
return NO_ERROR;
}
bool Surface::isSameSurface(
const sp<Surface>& lhs, const sp<Surface>& rhs)
{
if (lhs == 0 || rhs == 0)
return false;
return lhs->mSurface->asBinder() == rhs->mSurface->asBinder();
}
// ----------------------------------------------------------------------------
int Surface::setSwapRectangle(android_native_window_t* window,
@@ -681,55 +685,6 @@ void Surface::setSwapRectangle(const Rect& r) {
mSwapRectangle = r;
}
sp<Surface> Surface::readFromParcel(Parcel* parcel)
{
sp<SurfaceComposerClient> client;
ISurfaceFlingerClient::surface_data_t data;
sp<IBinder> clientBinder= parcel->readStrongBinder();
sp<ISurface> surface = interface_cast<ISurface>(parcel->readStrongBinder());
data.token = parcel->readInt32();
data.identity = parcel->readInt32();
PixelFormat format = parcel->readInt32();
uint32_t flags = parcel->readInt32();
if (clientBinder != NULL)
client = SurfaceComposerClient::clientForConnection(clientBinder);
return new Surface(client, surface, data, 0, 0, format, flags, false);
}
status_t Surface::writeToParcel(const sp<Surface>& surface, Parcel* parcel)
{
uint32_t flags=0;
uint32_t format=0;
SurfaceID token = -1;
uint32_t identity = 0;
sp<SurfaceComposerClient> client;
sp<ISurface> sur;
if (Surface::isValid(surface)) {
token = surface->mToken;
identity = surface->mIdentity;
client = surface->mClient;
sur = surface->mSurface;
format = surface->mFormat;
flags = surface->mFlags;
}
parcel->writeStrongBinder(client!=0 ? client->connection() : NULL);
parcel->writeStrongBinder(sur!=0 ? sur->asBinder() : NULL);
parcel->writeInt32(token);
parcel->writeInt32(identity);
parcel->writeInt32(format);
parcel->writeInt32(flags);
return NO_ERROR;
}
bool Surface::isSameSurface(const sp<Surface>& lhs, const sp<Surface>& rhs)
{
if (lhs == 0 || rhs == 0)
return false;
return lhs->mSurface->asBinder() == rhs->mSurface->asBinder();
}
status_t Surface::getBufferLocked(int index)
{
status_t err = NO_MEMORY;
@@ -750,45 +705,5 @@ status_t Surface::getBufferLocked(int index)
return err;
}
status_t Surface::setLayer(int32_t layer) {
return mSurfaceControl->setLayer(layer);
}
status_t Surface::setPosition(int32_t x, int32_t y) {
return mSurfaceControl->setPosition(x, y);
}
status_t Surface::setSize(uint32_t w, uint32_t h) {
return mSurfaceControl->setSize(w, h);
}
status_t Surface::hide() {
return mSurfaceControl->hide();
}
status_t Surface::show(int32_t layer) {
return mSurfaceControl->show(layer);
}
status_t Surface::freeze() {
return mSurfaceControl->freeze();
}
status_t Surface::unfreeze() {
return mSurfaceControl->unfreeze();
}
status_t Surface::setFlags(uint32_t flags, uint32_t mask) {
return mSurfaceControl->setFlags(flags, mask);
}
status_t Surface::setTransparentRegionHint(const Region& transparent) {
return mSurfaceControl->setTransparentRegionHint(transparent);
}
status_t Surface::setAlpha(float alpha) {
return mSurfaceControl->setAlpha(alpha);
}
status_t Surface::setMatrix(float dsdx, float dtdx, float dsdy, float dtdy) {
return mSurfaceControl->setMatrix(dsdx, dtdx, dsdy, dtdy);
}
status_t Surface::setFreezeTint(uint32_t tint) {
return mSurfaceControl->setFreezeTint(tint);
}
}; // namespace android

6
libs/ui/SurfaceComposerClient.cpp
View File

@@ -458,7 +458,7 @@ void SurfaceComposerClient::signalServer()
mSignalServer->signal();
}
sp<Surface> SurfaceComposerClient::createSurface(
sp<SurfaceControl> SurfaceComposerClient::createSurface(
int pid,
DisplayID display,
uint32_t w,
@@ -466,14 +466,14 @@ sp<Surface> SurfaceComposerClient::createSurface(
PixelFormat format,
uint32_t flags)
{
sp<Surface> result;
sp<SurfaceControl> result;
if (mStatus == NO_ERROR) {
ISurfaceFlingerClient::surface_data_t data;
sp<ISurface> surface = mClient->createSurface(&data, pid,
display, w, h, format, flags);
if (surface != 0) {
if (uint32_t(data.token) < NUM_LAYERS_MAX) {
result = new Surface(this, surface, data, w, h, format, flags);
result = new SurfaceControl(this, surface, data, w, h, format, flags);
}
}
}