surfaceflinger的主要工作就是负责把上层传递下来的各个不同的layer进行composition。

这里，我们来讨论一下各个layer在surfaceflinger中的上下排序关系和相关的代码实现，代码基于android4.3

首先介绍一下两个类，SurfaceFlinger和Client。

简单的说，这两个类的关系可以这么理解：SurfaceFlinger实现了具体的composition的服务，而每一个有UI的程序都需要通过SurfaceFlinger去实现渲染。

这些程序可以通过Client的一些接口来调用SurfaceFlinger以实现这个目的。

Client类中有一个createSurface成员函数

  1. status_t Client::createSurface(
  2.         const String8& name,
  3.         uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
  4.         sp<IBinder>* handle,
  5.         sp<IGraphicBufferProducer>* gbp)
  6. {
  7.     /*
  8.      * createSurface must be called from the GL thread so that it can
  9.      * have access to the GL context.
  10.      */
  11.  
  12.     class MessageCreateLayer : public MessageBase {
  13.         SurfaceFlinger* flinger;
  14.         Client* client;
  15.         sp<IBinder>* handle;
  16.         sp<IGraphicBufferProducer>* gbp;
  17.         status_t result;
  18.         const String8& name;
  19.         uint32_t w, h;
  20.         PixelFormat format;
  21.         uint32_t flags;
  22.     public:
  23.         MessageCreateLayer(SurfaceFlinger* flinger,
  24.                 const String8& name, Client* client,
  25.                 uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
  26.                 sp<IBinder>* handle,
  27.                 sp<IGraphicBufferProducer>* gbp)
  28.             : flinger(flinger), client(client),
  29.               handle(handle), gbp(gbp),
  30.               name(name), w(w), h(h), format(format), flags(flags) {
  31.         }
  32.         status_t getResult() const { return result; }
  33.         virtual bool handler() {
  34.             result = flinger->createLayer(name, client, w, h, format, flags,
  35.                     handle, gbp);
  36.             return true;
  37.         }
  38.     };
  39.  
  40.     sp<MessageBase> msg = new MessageCreateLayer(mFlinger.get(),
  41.             name, this, w, h, format, flags, handle, gbp);
  42.     mFlinger->postMessageSync(msg);
  43.     return static_cast<MessageCreateLayer*>( msg.get() )->getResult();
  44. }

createLayer函数是SurfaceFlinger类的私有函数，但是因为Client是他的友元，所以可以直接调用来创建一个layer。

  1. private:
  2.     friend class Client;
  3.     friend class DisplayEventConnection;
  4.     friend class Layer;
  5.     friend class SurfaceTextureLayer;

看下createLayer的代码

  1. status_t SurfaceFlinger::createLayer(
  2.         const String8& name,
  3.         const sp<Client>& client,
  4.         uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
  5.         sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp)
  6. {
  7.     //ALOGD("createLayer for (%d x %d), name=%s", w, h, name.string());
  8.     if (int32_t(w|h) < 0) {
  9.         ALOGE("createLayer() failed, w or h is negative (w=%d, h=%d)",
  10.                 int(w), int(h));
  11.         return BAD_VALUE;
  12.     }
  13.  
  14.     status_t result = NO_ERROR;
  15.  
  16.     sp<Layer> layer;
  17.  
  18.     switch (flags & ISurfaceComposerClient::eFXSurfaceMask) {
  19.         case ISurfaceComposerClient::eFXSurfaceNormal:
  20.             result = createNormalLayer(client,
  21.                     name, w, h, flags, format,
  22.                     handle, gbp, &layer);
  23.             break;
  24.         case ISurfaceComposerClient::eFXSurfaceDim:
  25.             result = createDimLayer(client,
  26.                     name, w, h, flags,
  27.                     handle, gbp, &layer);
  28.             break;
  29.         default:
  30.             result = BAD_VALUE;
  31.             break;
  32.     }
  33.  
  34.     if (result == NO_ERROR) {
  35.         addClientLayer(client, *handle, *gbp, layer);
  36.         setTransactionFlags(eTransactionNeeded);
  37.     }
  38.     return result;
  39. }

这个函数很清晰，主要是调用createNormalLayer和createDimLayer去创建不同的layer。

我们先忽略createDimLayer，只看createNormalLayer的实现

  1. status_t SurfaceFlinger::createNormalLayer(const sp<Client>& client,
  2.         const String8& name, uint32_t w, uint32_t h, uint32_t flags, PixelFormat& format,
  3.         sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp, sp<Layer>* outLayer)
  4. {
  5.     // initialize the surfaces
  6.     switch (format) {
  7.     case PIXEL_FORMAT_TRANSPARENT:
  8.     case PIXEL_FORMAT_TRANSLUCENT:
  9.         format = PIXEL_FORMAT_RGBA_8888;
  10.         break;
  11.     case PIXEL_FORMAT_OPAQUE:
  12. #ifdef NO_RGBX_8888
  13.         format = PIXEL_FORMAT_RGB_565;
  14. #else
  15.         format = PIXEL_FORMAT_RGBX_8888;
  16. #endif
  17.         break;
  18.     }
  19.  
  20. #ifdef NO_RGBX_8888
  21.     if (format == PIXEL_FORMAT_RGBX_8888)
  22.         format = PIXEL_FORMAT_RGBA_8888;
  23. #endif
  24.  
  25.     *outLayer = new Layer(this, client, name, w, h, flags);
  26.     status_t err = (*outLayer)->setBuffers(w, h, format, flags);
  27.     if (err == NO_ERROR) {
  28.         *handle = (*outLayer)->getHandle();
  29.         *gbp = (*outLayer)->getBufferQueue();
  30.     }
  31.  
  32.     ALOGE_IF(err, "createNormalLayer() failed (%s)", strerror(-err));
  33.     return err;
  34. }

这里主要是创建了一个Layer对象。

  1. Layer::Layer(SurfaceFlinger* flinger, const sp<Client>& client,
  2.         const String8& name, uint32_t w, uint32_t h, uint32_t flags)
  3.     :   contentDirty(false),
  4.         sequence(uint32_t(android_atomic_inc(&sSequence))),
  5.         mFlinger(flinger),
  6.         mTextureName(-1U),
  7.         mPremultipliedAlpha(true),
  8.         mName("unnamed"),
  9.         mDebug(false),
  10.         mFormat(PIXEL_FORMAT_NONE),
  11.         mGLExtensions(GLExtensions::getInstance()),
  12.         mOpaqueLayer(true),
  13.         mTransactionFlags(0),
  14.         mQueuedFrames(0),
  15.         mCurrentTransform(0),
  16.         mCurrentScalingMode(NATIVE_WINDOW_SCALING_MODE_FREEZE),
  17.         mCurrentOpacity(true),
  18.         mRefreshPending(false),
  19.         mFrameLatencyNeeded(false),
  20.         mFiltering(false),
  21.         mNeedsFiltering(false),
  22.         mSecure(false),
  23.         mProtectedByApp(false),
  24.         mHasSurface(false),
  25.         mClientRef(client)
  26. {
  27.     mCurrentCrop.makeInvalid();
  28.     glGenTextures(1, &mTextureName);
  29.  
  30.     uint32_t layerFlags = 0;
  31.     if (flags & ISurfaceComposerClient::eHidden)
  32.         layerFlags = layer_state_t::eLayerHidden;
  33.  
  34.     if (flags & ISurfaceComposerClient::eNonPremultiplied)
  35.         mPremultipliedAlpha = false;
  36.  
  37.     mName = name;
  38.  
  39.     mCurrentState.active.w = w;
  40.     mCurrentState.active.h = h;
  41.     mCurrentState.active.crop.makeInvalid();
  42.     mCurrentState.z = 0;
  43.     mCurrentState.alpha = 0xFF;
  44.     mCurrentState.layerStack = 0;
  45.     mCurrentState.flags = layerFlags;
  46.     mCurrentState.sequence = 0;
  47.     mCurrentState.transform.set(0, 0);
  48.     mCurrentState.requested = mCurrentState.active;
  49.  
  50.     // drawing state & current state are identical
  51.     mDrawingState = mCurrentState;
  52. }

这里我们主要关注和layer顺序相关的信息

  1.     sequence(uint32_t(android_atomic_inc(&sSequence))),
  2.  
  3.     mCurrentState.z = 0;
  4.     mCurrentState.layerStack = 0;

这三个变量决定了layer之间的顺序，我来说明一下具体的含义。

首先是layerStack，大家可以把它理解为组的含义。也就是说属于不同组的layer之间互不干扰。

SurfaceFlinger中有一个DisplayDevice类，他表示用来显示的设备，譬如LCD或者是HDMI。

DisplayDevice里也有一个成员变量mLayerStack，在进行composition的时候，只有和这个device的layerstack相同的layer才可能被显示在这个设备上。

第二个是z，其实他就是z-order的意思，表示x,y,z轴的z轴上的顺序。数字越大，表示越在上面，数字越小，表示越在下面。

第三个是sequence，因为sSequence是一个static的变量，所以递加的效果就是为每一个layer设置一个唯一且递增的序列号。

概念介绍完了，我们继续看代码，看看到底是不是这样。

创建完layer之后，createLayer会调用addClientLayer把这个layer的信息添加到当前的状态信息里去。

  1. void SurfaceFlinger::addClientLayer(const sp<Client>& client,
  2.         const sp<IBinder>& handle,
  3.         const sp<IGraphicBufferProducer>& gbc,
  4.         const sp<Layer>& lbc)
  5. {
  6.     // attach this layer to the client
  7.     client->attachLayer(handle, lbc);
  8.  
  9.     // add this layer to the current state list
  10.     Mutex::Autolock _l(mStateLock);
  11.     mCurrentState.layersSortedByZ.add(lbc);
  12.     mGraphicBufferProducerList.add(gbc->asBinder());
  13. }

layersSortedByZ变量很重要，surfaceflinger真正渲染的时候就是靠它来知道哪个layer在上哪个在下的。

这里的add函数就负责把layer放进去

  1. ssize_t SortedVectorImpl::add(const void* item)
  2. {
  3.     size_t order;
  4.     ssize_t index = _indexOrderOf(item, &order);
  5.     if (index < 0) {
  6.         index = VectorImpl::insertAt(item, order, 1);
  7.     } else {
  8.         index = VectorImpl::replaceAt(item, index);
  9.     }
  10.     return index;
  11. }
  1. ssize_t SortedVectorImpl::_indexOrderOf(const void* item, size_t* order) const
  2. {
  3.     // binary search
  4.     ssize_t err = NAME_NOT_FOUND;
  5.     ssize_t l = 0;
  6.     ssize_t h = size()-1;
  7.     ssize_t mid;
  8.     const void* a = arrayImpl();
  9.     const size_t s = itemSize();
  10.     while (l <= h) {
  11.         mid = l + (h - l)/2;
  12.         const void* const curr = reinterpret_cast<const char *>(a) + (mid*s);
  13.         const int c = do_compare(curr, item);
  14.         if (c == 0) {
  15.             err = l = mid;
  16.             break;
  17.         } else if (c < 0) {
  18.             l = mid + 1;
  19.         } else {
  20.             h = mid - 1;
  21.         }
  22.     }
  23.     if (order) *order = l;
  24.     return err;
  25. }
  1. int SurfaceFlinger::LayerVector::do_compare(const void* lhs,
  2.     const void* rhs) const
  3. {
  4.     // sort layers per layer-stack, then by z-order and finally by sequence
  5.     const sp<Layer>& l(*reinterpret_cast<const sp<Layer>*>(lhs));
  6.     const sp<Layer>& r(*reinterpret_cast<const sp<Layer>*>(rhs));
  7.  
  8.     uint32_t ls = l->currentState().layerStack;
  9.     uint32_t rs = r->currentState().layerStack;
  10.     if (ls != rs)
  11.         return ls - rs;
  12.  
  13.     uint32_t lz = l->currentState().z;
  14.     uint32_t rz = r->currentState().z;
  15.     if (lz != rz)
  16.         return lz - rz;
  17.  
  18.     return l->sequence - r->sequence;
  19. }

连着贴了3个函数，其主要作用就是判断这个layer要插在layersSortedByZ的什么位置。

从do_compare我们可以看出，和我刚才分析的是一样的。

第一步是比较layerstack，不同的layerstack分开。

然后再比较z，最后假设这些都一样，就比较唯一的layer序列号。

但是至今为止，layerStack和z都还只是初始化时的0，所以在创建layer的时候，只是把他根据序列号放进layersSortedByZ而已，其实他的顺序还是没有设置的。

下面我们就要去找找看到底在哪里设置了这些。

大家应该都知道bootanimation吧，就是开机负责绘制闪啊闪的android字样的那个程序。

在里面我找到了这样的代码

  1.     // create the native surface
  2.     sp<SurfaceControl> control = session()->createSurface(String8("BootAnimation"),
  3.             dinfo.w, dinfo.h, PIXEL_FORMAT_RGB_565);
  4.  
  5.     SurfaceComposerClient::openGlobalTransaction();
  6.     control->setLayer(0x40000000);
  7.     SurfaceComposerClient::closeGlobalTransaction();

前面的createSurface我们在前面已经分析完成了。

下面就是setLayer了，这个0x40000000到底是设置了什么那？

我们一步步往下看

  1. status_t SurfaceControl::setLayer(int32_t layer) {
  2.     status_t err = validate();
  3.     if (err < 0) return err;
  4.     const sp<SurfaceComposerClient>& client(mClient);
  5.     return client->setLayer(mHandle, layer);
  6. }
  1. status_t SurfaceComposerClient::setLayer(const sp<IBinder>& id, int32_t z) {
  2.     return getComposer().setLayer(this, id, z);
  3. }
  1. status_t Composer::setLayer(const sp<SurfaceComposerClient>& client,
  2.         const sp<IBinder>& id, int32_t z) {
  3.     Mutex::Autolock _l(mLock);
  4.     layer_state_t* s = getLayerStateLocked(client, id);
  5.     if (!s)
  6.         return BAD_INDEX;
  7.     s->what |= layer_state_t::eLayerChanged;
  8.     s->z = z;
  9.     return NO_ERROR;
  10. }

可以看到，这个layer变量最终变成了z，存进了layer_state_t结构体内。

这个结构体是哪来的？在看看getLayerStateLocked

  1. layer_state_t* Composer::getLayerStateLocked(
  2.         const sp<SurfaceComposerClient>& client, const sp<IBinder>& id) {
  3.  
  4.     ComposerState s;
  5.     s.client = client->mClient;
  6.     s.state.surface = id;
  7.  
  8.     ssize_t index = mComposerStates.indexOf(s);
  9.     if (index < 0) {
  10.         // we don't have it, add an initialized layer_state to our list
  11.         index = mComposerStates.add(s);
  12.     }
  13.  
  14.     ComposerState* const out = mComposerStates.editArray();
  15.     return &(out[index].state);
  16. }

原来是从mComposerStates里找来的啊。

这些代码看上去是在做相关的操作，但是设置还没有具体生效。

下面我们看看SurfaceComposerClient::closeGlobalTransaction()的作用

  1. void SurfaceComposerClient::closeGlobalTransaction(bool synchronous) {
  2.     Composer::closeGlobalTransaction(synchronous);
  3. }
  1. void Composer::closeGlobalTransactionImpl(bool synchronous) {
  2.     sp<ISurfaceComposer> sm(ComposerService::getComposerService());
  3.  
  4.     Vector<ComposerState> transaction;
  5.     Vector<DisplayState> displayTransaction;
  6.     uint32_t flags = 0;
  7.  
  8.     { // scope for the lock
  9.         Mutex::Autolock _l(mLock);
  10.         mForceSynchronous |= synchronous;
  11.         if (!mTransactionNestCount) {
  12.             ALOGW("At least one call to closeGlobalTransaction() was not matched by a prior "
  13.                     "call to openGlobalTransaction().");
  14.         } else if (--mTransactionNestCount) {
  15.             return;
  16.         }
  17.  
  18.         transaction = mComposerStates;
  19.         mComposerStates.clear();
  20.  
  21.         displayTransaction = mDisplayStates;
  22.         mDisplayStates.clear();
  23.  
  24.         if (mForceSynchronous) {
  25.             flags |= ISurfaceComposer::eSynchronous;
  26.         }
  27.         if (mAnimation) {
  28.             flags |= ISurfaceComposer::eAnimation;
  29.         }
  30.         if (mTransition) {
  31.             flags |= ISurfaceComposer::eTransition;
  32.         }
  33.         if (mOrientationEnd) {
  34.             flags |= ISurfaceComposer::eOrientationEnd;
  35.         }
  36.         mForceSynchronous = false;
  37.         mAnimation = false;
  38.     }
  39.  
  40.    sm->setTransactionState(transaction, displayTransaction, flags);
  41. }

mComposerStates被赋值给transaction，然后通过sm->setTransactionState传递下去。

  1. void SurfaceFlinger::setTransactionState(
  2.         const Vector<ComposerState>& state,
  3.         const Vector<DisplayState>& displays,
  4.         uint32_t flags)
  5. {
  6.     ......
  7.     count = state.size();
  8.     for (size_t i=0 ; i<count ; i++) {
  9.         const ComposerState& s(state[i]);
  10.         // Here we need to check that the interface we're given is indeed
  11.         // one of our own. A malicious client could give us a NULL
  12.         // IInterface, or one of its own or even one of our own but a
  13.         // different type. All these situations would cause us to crash.
  14.         //
  15.         // NOTE: it would be better to use RTTI as we could directly check
  16.         // that we have a Client*. however, RTTI is disabled in Android.
  17.         if (s.client != NULL) {
  18.             sp<IBinder> binder = s.client->asBinder();
  19.             if (binder != NULL) {
  20.                 String16 desc(binder->getInterfaceDescriptor());
  21.                 if (desc == ISurfaceComposerClient::descriptor) {
  22.                     sp<Client> client( static_cast<Client *>(s.client.get()) );
  23.                     transactionFlags |= setClientStateLocked(client, s.state);
  24.                 }
  25.             }
  26.         }
  27.     }
  28.     ......
  29. }
  1. uint32_t SurfaceFlinger::setClientStateLocked(
  2.         const sp<Client>& client,
  3.         const layer_state_t& s)
  4. {
  5.     uint32_t flags = 0;
  6.     sp<Layer> layer(client->getLayerUser(s.surface));
  7.     if (layer != 0) {
  8.         const uint32_t what = s.what;
  9.         if (what & layer_state_t::ePositionChanged) {
  10.             if (layer->setPosition(s.x, s.y))
  11.                 flags |= eTraversalNeeded;
  12.         }
  13.         if (what & layer_state_t::eLayerChanged) {
  14.             // NOTE: index needs to be calculated before we update the state
  15.             ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
  16.             if (layer->setLayer(s.z)) {
  17.                 mCurrentState.layersSortedByZ.removeAt(idx);
  18.                 mCurrentState.layersSortedByZ.add(layer);
  19.                 // we need traversal (state changed)
  20.                 // AND transaction (list changed)
  21.                 flags |= eTransactionNeeded|eTraversalNeeded;
  22.             }
  23.         }
  24.     ......
  25.     }
  26. }
  1. bool Layer::setLayer(uint32_t z) {
  2.     if (mCurrentState.z == z)
  3.         return false;
  4.     mCurrentState.sequence++;
  5.     mCurrentState.z = z;
  6.     setTransactionFlags(eTransactionNeeded);
  7.     return true;
  8. }

可以看到，只要设置的z值和之前的不同，setLayer就会返回true。

然后mCurrentState.layersSortedByZ.removeAt和mCurrentState.layersSortedByZ.add就会被执行。

至此，layer的真正z-order就确定好了。

surfaceflinger中各个layer的排序的更多相关文章

  1. 回调函数及数组中sort()方法实现排序的原理

    1.回调函数:把一个方法A当一个参数值传递到另外一个函数B中,在B执行的过程当中我们随时根据需求让A方法执行:   什么是回调 :它是异步编程基本的方法,需要异步处理的时候一般采用后续传递的方式,将后 ...

  2. 【HOW】如何对Reporting Services表格中数据按字段排序

    Reporting Services中可以设置排序的地方非常多,有很多地方从其字面意思上好像是对表格数据的排序,但实际都不管用.在多次尝试后,得到如下的有效设置方式: 1. 鼠标右键单击要排序字段的内 ...

  3. Atitit.现实生活中最好使用的排序方法-----ati排序法总结

    Atitit.现实生活中最好使用的排序方法-----ati排序法总结 1. 现在的问题 1 2. 排序的类别::插入排序//交换排序//选择排序(每次最小/大排在相应的位置  )//归并排序//基数排 ...

  4. 2dx解析cocosbuilder中使用layer时的缺陷

    2dx解析cocosbuilder中使用layer时的缺陷 cocos2d-x 3.7 cocosbuilder中的layer通常会用到触摸属性: 但是在2dx解析布局文件的时候,却很多属性都没解析: ...

  5. OpenLayers中的Layer概念和实践--Openlayers调用WMS服务

    整理转自:http://hi.baidu.com/lixuweiok/item/c406a4e6a6d390e7fa42ba4b 本章我认为是这本书的真正开端,终于开始讲一些有意思的东西了.. 在这一 ...

  6. [原]Java面试题-将字符串中数字提取出来排序后输出

    [Title][原]Java面试题-将字符串中数字提取出来排序后输出 [Date]2013-09-15 [Abstract]很简单的面试题,要求现场在纸上写出来. [Keywords]面试.Java. ...

  7. 对list集合中的对象进行排序（转载）

    原文链接:http://blog.csdn.net/veryisjava/article/details/51675036 Collections对List集合中的数据进行排序 有时候需要对集合中的元 ...

  8. java 对list中对象按属性排序

    实体对象类 --略 排序类----实现Comparator接口,重写compare方法 package com.tang.list; import java.util.Comparator; publ ...

  9. C++ STL中Map的相关排序操作：按Key排序和按Value排序 - 编程小径 - 博客频道 - CSDN.NET

    C++ STL中Map的相关排序操作:按Key排序和按Value排序 - 编程小径 - 博客频道 - CSDN.NET C++ STL中Map的相关排序操作:按Key排序和按Value排序 分类: C ...

随机推荐

  1. BZOJ 3110([Zjoi2013]K大数查询-区间第k大[段修改,在线]-树状数组套函数式线段树)

    3110: [Zjoi2013]K大数查询 Time Limit: 20 Sec   Memory Limit: 512 MB Submit: 418   Solved: 235 [ Submit][ ...

  2. HTTP协议的请求和响应学习

    本篇作为学习servlet的前提,http协议是学习JavaWeb开发的基石,不深入了解http协议,就不能说掌握了JavaWeb开发. HTTP协议有两个版本:HTTP1.0和HTTP1.1,那么有 ...

  3. Oracle左连接、右连接示例

    建表: create table a ( id ), name ) ); create table b ( name ), age ) ); create table c ( name ), dept ...

  4. J2EE SSH学习（二）安装Eclipse插件和第一个Eclipse项目

    (一)安装Eclipse插件 Eclipse有很多功能很强大的插件,我现在作为一个菜鸟只知道插件的功能通常都很牛叉实用或者很有趣,那么该怎么安装Eclipse插件呢? 我使用的是Eclipse 4.3 ...

  5. 华为OJ培训主题 比赛统计

    题目例如以下: 比赛情况统计 有一个游戏平台,各个參赛队伍(以唯一的TeamID来标识)之间进行单循环的对抗赛,两个队伍之间仅仅举行一场比赛,比赛以得分的多少定胜负.须要完毕一个统计赛况的程序,可以随 ...

  6. Tomcat详细用法学习（一）

    在之前有关Tomcat的随笔<Tomcat免安装版的环境变量配置以及Eclipse下的Tomcat配置和测试>和<其他主机连接本地主机Tomcat会出现的防火墙问题>中已经详细 ...

  7. csdn发博文验证码缺陷

    csdn验证码的长处: 一,差点儿没有浪费人脑人力,却要花去机器人非常多cpu csdn发博文验证码却有非常大缺陷: 一.验证码的内容终于结果是简单的数字,能够穷举尽的,也就是说不怕被封号的话全然能够 ...

  8. UVA 11054 Wine trading in Gergovia 葡萄酒交易 贪心+模拟

    题意:一题街道上很多酒店,交易葡萄酒,正数为卖出葡萄酒,负数为需要葡萄酒,总需求量和总售出量是相等的,从一家店到另外一家店需要路费(路费=距离×运算量),假设每家店线性排列且相邻两店之间距离都是1,求 ...

  9. iOS高效开源类库

    因为iOS SDK相对比较底层,所以开发者就得受累多做一些体力活.不过幸运的是,有很多第三方的类库可以用来简化很多不必要的工作.笔者整理了一下在本人学习过程中用到的一些比较有用Objective-C开 ...

  10. ZOJ 3529 A Game Between Alice and Bob（博弈论-sg函数）

    ZOJ 3529 - A Game Between Alice and Bob Time Limit:5000MS     Memory Limit:262144KB     64bit IO For ...