http://blog.csdn.net/lewif/article/details/50817821
这里的底层不牵扯内核以下的分析,主要是内核亮屏后,HAL层以上各层是如何联系起来的,通过层层转交,将displays的信息从内核填充到上层。这里主要涉及framework中的HWComposer,surfaceflinger,HAL层的Hwcomposer,为了便于区分,framework层记为HWC,HAL层记为Hwc,HWC相当于是Hwc的wrapper。
SurfaceFlinger::init()—>初始化HWC
mHwc = new HWComposer(this,
*static_cast<HWComposer::EventHandler *>(this));
HWComposer::HWComposer(
constsp<SurfaceFlinger>& flinger,
EventHandler& handler)
:mFlinger(flinger),
mFbDev(0), mHwc(0), mNumDisplays(1),
mCBContext(new cb_context),
mEventHandler(handler),
mDebugForceFakeVSync(false)
{
for (size_t i =0 ;i<MAX_HWC_DISPLAYS ; i++) {
mLists[i] =0;
}
for (size_t i=0 ;i<HWC_NUM_PHYSICAL_DISPLAY_TYPES ; i++) {
mLastHwVSync[i] = 0;
mVSyncCounts[i]= 0;
}
// Note: some devices may insist thatthe FB HAL be opened before HWC.
int fberr =loadFbHalModule();
loadHwcModule();
//如果有Hwc,即HWComposer的hal层,则关闭fb
if (mFbDev&& mHwc && hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1)){
// close FB HAL if we don't needed it.
// FIXME: this is temporary until we'renot forced to open FB HAL
// before HWC.
framebuffer_close(mFbDev);
mFbDev =NULL;
}
// these display IDs are always reserved
// NUM_BUILTIN_DISPLAYS 2
for (size_t i=0 ;i<NUM_BUILTIN_DISPLAYS ; i++) {
mAllocatedDisplayIDs.markBit(i);
}
if (mHwc) {
ALOGI("Using %s version %u.%u",HWC_HARDWARE_COMPOSER,
(hwcApiVersion(mHwc) >> 24) & 0xff,
(hwcApiVersion(mHwc) >> 16) & 0xff);
//把HWC中,即framework中的回调函数注册到HAL中,用来在HAL中回调
if(mHwc->registerProcs) {
mCBContext->hwc = this;
mCBContext->procs.invalidate = &hook_invalidate;
mCBContext->procs.vsync = &hook_vsync;
if(hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1))
mCBContext->procs.hotplug = &hook_hotplug;
else
mCBContext->procs.hotplug = NULL;
memset(mCBContext->procs.zero,0, sizeof(mCBContext->procs.zero));
mHwc->registerProcs(mHwc, &mCBContext->procs);
}
// don't need a vsync thread if we havea hardware composer
needVSyncThread = false;
// always turn vsync off when we start
eventControl(HWC_DISPLAY_PRIMARY, HWC_EVENT_VSYNC, 0);
// the number of displays we actuallyhave depends on the
// hw composer version
// 1.3版本,已经支持虚拟display,3个
if(hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_3)) {
// 1.3 adds support for virtual displays
mNumDisplays = MAX_HWC_DISPLAYS;
} elseif(hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1)) {
// 1.1 adds support for multipledisplays
mNumDisplays = NUM_BUILTIN_DISPLAYS;
} else {
mNumDisplays = 1;
}
}
//fb已经关闭
if (mFbDev) {
} elseif (mHwc) {
// here we're guaranteed to have atleast HWC 1.1
//HWC获取display信息的地方,填充mDisplayData[3]
//DisplayData mDisplayData[MAX_HWC_DISPLAYS];
for (size_t i =0 ;i<NUM_BUILTIN_DISPLAYS ; i++) {
queryDisplayProperties(i);
}
}
//vsync软件模拟线程
if(needVSyncThread) {
// we don't have VSYNC support, we needto fake it
mVSyncThread = new VSyncThread(*this);
}
}
//调用HAL层接口,获取屏幕的参数,HAL会和驱动打交道
//这样就相当于在上层把display的参数初始化了,
//主要填充DisplayData mDisplayData[MAX_HWC_DISPLAYS];
status_t HWComposer::queryDisplayProperties(int disp) {
int32_tvalues[NUM_DISPLAY_ATTRIBUTES - 1];
memset(values, 0, sizeof(values));
uint32_tconfig;
size_tnumConfigs = 1;
status_t err =mHwc->getDisplayConfigs(mHwc, disp, &config, &numConfigs);
err =mHwc->getDisplayAttributes(mHwc, disp, config, DISPLAY_ATTRIBUTES, values);
int32_t w = 0, h = 0;
for (size_t i = 0; i <NUM_DISPLAY_ATTRIBUTES - 1; i++) {
switch(DISPLAY_ATTRIBUTES[i]) {
caseHWC_DISPLAY_VSYNC_PERIOD:
mDisplayData[disp].refresh = nsecs_t(values[i]);
break;
caseHWC_DISPLAY_WIDTH:
mDisplayData[disp].width = values[i];
break;
caseHWC_DISPLAY_HEIGHT:
mDisplayData[disp].height = values[i];
break;
caseHWC_DISPLAY_DPI_X:
mDisplayData[disp].xdpi = values[i] / 1000.0f;
break;
case HWC_DISPLAY_DPI_Y:
mDisplayData[disp].ydpi = values[i] / 1000.0f;
break;
default:
ALOG_ASSERT(false, "unknown display attribute[%d]%#x",
i, DISPLAY_ATTRIBUTES[i]);
break;
}
}
// FIXME: what should we set the formatto?
mDisplayData[disp].format = HAL_PIXEL_FORMAT_RGBA_8888;
mDisplayData[disp].connected = true;
if(mDisplayData[disp].xdpi == 0.0f || mDisplayData[disp].ydpi == 0.0f) {
float dpi = getDefaultDensity(h);
mDisplayData[disp].xdpi = dpi;
mDisplayData[disp].ydpi = dpi;
}
return NO_ERROR;
}
SurfaceFlinger::init()—>
// initialize ournon-virtual displays
// 初始化物理屏幕,NUM_BUILTIN_DISPLAY_TYPES2
// 目前除了默认屏幕,还支持一个hdmi的物理屏幕
for (size_t i=0 ; i<DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES ; i++) {
DisplayDevice::DisplayTypetype((DisplayDevice::DisplayType)i);
// set-upthe displays that are already connected
// 屏幕是否连接,即HWC中已经成功获取到这个屏幕的信息
if(mHwc->isConnected(i) || type==DisplayDevice::DISPLAY_PRIMARY) {
// All non-virtual displays are currently consideredsecure.
bool isSecure = true;
// 创建显示器在surface flinger中的代表,new BBinder,
// 将new BBinder和DisplayDeviceState保存在mCurrentState.displays中
createBuiltinDisplayLocked(type);
//取出上面的BBinder
wp<IBinder> token = mBuiltinDisplays[i];
//新建BufferQueue,FramebufferSurface,DisplayDevice
sp<BufferQueue> bq = new BufferQueue(new GraphicBufferAlloc());
sp<FramebufferSurface> fbs = new FramebufferSurface(*mHwc, i, bq);
sp<DisplayDevice> hw = new DisplayDevice(this,
type, allocateHwcDisplayId(type),isSecure, token,
fbs, bq,
mEGLConfig);
if (i > DisplayDevice::DISPLAY_PRIMARY) {
// FIXME: currently we don't get blank/unblank requests
// for displays other than the maindisplay, so we always
// assume a connected display isunblanked.
ALOGD("marking display %d as acquired/unblanked",i);
hw->acquireScreen();
}
// DefaultKeyedVector< wp<IBinder>, sp<DisplayDevice> >mDisplays;
mDisplays.add(token, hw);
}
}
boolHWComposer::isConnected(int disp) const {
returnmDisplayData[disp].connected;
}
struct State {
LayerVectorlayersSortedByZ;
DefaultKeyedVector< wp<IBinder>, DisplayDeviceState>displays;
};
structDisplayDeviceState {
DisplayDeviceState();
DisplayDeviceState(DisplayDevice::DisplayType type);
boolisValid() const { returntype >=0; }
boolisMainDisplay() const { returntype ==DisplayDevice::DISPLAY_PRIMARY; }
boolisVirtualDisplay() const { returntype >=DisplayDevice::DISPLAY_VIRTUAL; }
DisplayDevice::DisplayType type;
sp<IGraphicBufferProducer>surface;
uint32_tlayerStack;
Rectviewport;
Rect frame;
uint8_torientation;
String8displayName;
boolisSecure;
};
voidSurfaceFlinger::createBuiltinDisplayLocked(DisplayDevice::DisplayType type) {
ALOGW_IF(mBuiltinDisplays[type],
"Overwriting display token fordisplay type %d", type);
//sp<IBinder> mBuiltinDisplays[2];就是new BBinder,
mBuiltinDisplays[type] =new BBinder();
DisplayDeviceState info(type);
// All non-virtual displays arecurrently considered secure.
// 非virtual display都是secure的
info.isSecure =true;
// State mCurrentState;
mCurrentState.displays.add(mBuiltinDisplays[type], info);
}
SurfaceFlinger::DisplayDeviceState::DisplayDeviceState(DisplayDevice::DisplayTypetype)
: type(type), layerStack(DisplayDevice::NO_LAYER_STACK), orientation(0) {
viewport.makeInvalid();
frame.makeInvalid();
}
通过上面的步骤,主要填充了HWComposer的mDisplayDate[3]、surface flinger的mCurrentState.displays(token,DisplayDeviceState),mDisplays(token,DisplayDevice),mBuiltinDisplays[2](BBinder),
// initializeour drawing state
mDrawingState =mCurrentState;
// set initial conditions (e.g. unblank default device)
initializeDisplays();
voidSurfaceFlinger::initializeDisplays() {
classMessageScreenInitialized : public MessageBase {
SurfaceFlinger* flinger;
public:
MessageScreenInitialized(SurfaceFlinger*flinger) : flinger(flinger) { }
virtualbool handler() {
flinger->onInitializeDisplays();
returntrue;
}
};
sp<MessageBase> msg = new MessageScreenInitialized(this);
postMessageAsync(msg); // we may be called from main thread, use async message
}
void SurfaceFlinger::onInitializeDisplays() {
// reset screenorientation and use primarylayer stack
Vector<ComposerState>state;
Vector<DisplayState> displays;
//新建一个DisplayState
DisplayState d;
d.what =DisplayState::eDisplayProjectionChanged |
DisplayState::eLayerStackChanged;
//默认屏幕的token
d.token =mBuiltinDisplays[DisplayDevice::DISPLAY_PRIMARY];
//layerStack 为0,orientation 为默认的eOrientationDefault
d.layerStack = 0;
d.orientation =DisplayState::eOrientationDefault;
d.frame.makeInvalid();
d.viewport.makeInvalid();
displays.add(d);
//利用displays的信息,设置mCurrentState.displays的状态
setTransactionState(state, displays, 0);
onScreenAcquired(getDefaultDisplayDevice());
const nsecs_tperiod =
getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY);
mAnimFrameTracker.setDisplayRefreshPeriod(period);
}
voidSurfaceFlinger::setTransactionState(
constVector<ComposerState>& state,
constVector<DisplayState>& displays,
uint32_tflags)
{
ATRACE_CALL();
Mutex::Autolock_l(mStateLock);
uint32_ttransactionFlags = 0;
size_t count =displays.size();
for (size_t i=0 ; i<count ;i++) {
const DisplayState&s(displays[i]);
transactionFlags |= setDisplayStateLocked(s);
}
}
//根据DisplayState的信息更新mCurrentState.displays的信息
uint32_t SurfaceFlinger::setDisplayStateLocked(constDisplayState& s)
{
ssize_t dpyIdx= mCurrentState.displays.indexOfKey(s.token);
if (dpyIdx <0)
return 0;
uint32_t flags= 0;
DisplayDeviceState& disp(mCurrentState.displays.editValueAt(dpyIdx));
if (disp.isValid()) {
constuint32_t what = s.what;
if (what& DisplayState::eSurfaceChanged) {
if(disp.surface->asBinder()!= s.surface->asBinder()){
disp.surface = s.surface;
flags |= eDisplayTransactionNeeded;
}
}
if (what& DisplayState::eLayerStackChanged) {
if(disp.layerStack != s.layerStack) {
disp.layerStack = s.layerStack;
flags |= eDisplayTransactionNeeded;
}
}
if (what& DisplayState::eDisplayProjectionChanged) {
if(disp.orientation != s.orientation) {
disp.orientation = s.orientation;
flags |= eDisplayTransactionNeeded;
}
if(disp.frame != s.frame) {
disp.frame = s.frame;
flags |= eDisplayTransactionNeeded;
}
if(disp.viewport != s.viewport) {
disp.viewport = s.viewport;
flags |=eDisplayTransactionNeeded;
}
}
}
return flags;
}
// returns the default Display
// 返回默认屏幕的DisplayDevice
sp<constDisplayDevice> getDefaultDisplayDevice() const {
return getDisplayDevice(mBuiltinDisplays[DisplayDevice::DISPLAY_PRIMARY]);
}
sp<DisplayDevice> getDisplayDevice(constwp<IBinder>& dpy) {
returnmDisplays.valueFor(dpy);
}
void SurfaceFlinger::onScreenAcquired(const sp<constDisplayDevice>& hw) {
ALOGD("Screen acquired, type=%dflinger=%p", hw->getDisplayType(), this);
if (hw->isScreenAcquired()){
// this is expected, e.g. when powermanager wakes up during boot
ALOGD(" screen was previouslyacquired");
return;
}
hw->acquireScreen();
int32_t type= hw->getDisplayType();
if (type< DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) {
// built-in display, tell the HWC
getHwComposer().acquire(type);
if (type== DisplayDevice::DISPLAY_PRIMARY) {
// FIXME: eventthread only knows aboutthe main display right now
mEventThread->onScreenAcquired();
//开启vsync开关
resyncToHardwareVsync(true);
}
}
mVisibleRegionsDirty =true;
repaintEverything();
}
voidDisplayDevice::acquireScreen() const {
mScreenAcquired= true;
}
//acquire就是调用Hwc HAL的blank函数,
status_t HWComposer::acquire(int disp) {
LOG_FATAL_IF(disp >=VIRTUAL_DISPLAY_ID_BASE);
if (mHwc) {
return(status_t)mHwc->blank(mHwc, disp, 0);
}
return NO_ERROR;
}
通过上面的分析,在底层,即surfaceflinger、HWC、Hwc中已经填充了系统displays的基本信息,后续分析surfaceflinger之上是如何初始化和使用displays的,上下联系起来。