cocos2d-x在Android的运行流程始末

由于Android的应用层是从Activity开始的，也就是创建完一个Cocos2dx后src文件夹下的Java文件。其中主要看Activity创建时的操作：

protected void onCreate(Bundle savedInstanceState){
super.onCreate(savedInstanceState);
}

这个方法很简单，就是调用父类的onCreate方法，也就是，这个自定义的Activity不做什么，把所有的动作都交给了它的父类Cocos2dxActivity去操作

@Override
protected void onCreate(final Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
sContext = this;
this.mHandler = new Cocos2dxHandler(this);

this.init();

Cocos2dxHelper.init(this, this);
}

在这个方法中主要看Cocos2dxActivity的初始化方法init，Cocos2dxHandler是工具辅助类，不是重点。

public void init() {
/*
Adnroid窗口布局参数的作用（从网上获取）
1）fill_parent
设置一个构件的布局为fill_parent将强制性地使构件扩展，以填充布局单元内尽可能多的空间。这跟Windows控件的dockstyle属性大体一致。设置一个顶部布局或控件为fill_parent将强制性让它布满整个屏幕。
2） wrap_content
设置一个视图的尺寸为wrap_content将强制性地使视图扩展以显示全部内容。以TextView和ImageView控件为例，设置为wrap_content将完整显示其内部的文本和图像。布局元素将根据内容更改大小。设置一个视图的尺寸为wrap_content大体等同于设置Windows控件的Autosize属性为True。
3）match_parent
Android2.2中match_parent和fill_parent是一个意思 .两个参数意思一样，match_parent更贴切，于是从2.2开始两个词都可以用。那么如果考虑低版本的使用情况你就需要用fill_parent了
*/

//初始化窗口布局
ViewGroup.LayoutParams framelayout_params =
new ViewGroup.LayoutParams(ViewGroup.LayoutParams.FILL_PARENT,
ViewGroup.LayoutParams.FILL_PARENT);
FrameLayout framelayout = new FrameLayout(this);
framelayout.setLayoutParams(framelayout_params);

//初始化Cocos2dx的文本编辑布局
ViewGroup.LayoutParams edittext_layout_params =
new ViewGroup.LayoutParams(ViewGroup.LayoutParams.FILL_PARENT,
ViewGroup.LayoutParams.WRAP_CONTENT);
Cocos2dxEditText edittext = new Cocos2dxEditText(this);
edittext.setLayoutParams(edittext_layout_params);
framelayout.addView(edittext);

//初始化Cocos2dx视图
this.mGLSurfaceView = this.onCreateView();

//把Cocos2dxGLSurfaceView加入到当前的窗口布局中
framelayout.addView(this.mGLSurfaceView);

// Switch to supported OpenGL (ARGB888) mode on emulator
//在模拟器中切换支持OpenGL模式的渲染(ARGB888)
if (isAndroidEmulator())
this.mGLSurfaceView.setEGLConfigChooser(8 , 8, 8, 8, 16, 0);
//设置Cocos2dx的渲染器
this.mGLSurfaceView.setCocos2dxRenderer(new Cocos2dxRenderer());
//设置Cocos2dx的文本编辑
this.mGLSurfaceView.setCocos2dxEditText(edittext);

//把显示布局（即Cocos2dx的视图）绑定到Activity上，建立显示窗口
setContentView(framelayout);
}

首先在init中先看this.mGLSurfaceView = this.onCreateView(); this.mGLSurfaceView是一个Cocos2dxGLSurfaceView类。在进入到Cocos2dxGLSurfaceView这个类中可以看到时继承于GLSurfaceView（可以把GLSurfaceView看成一个视图，里面有个方法设置了这个视图的渲染器，然后通过这个渲染器来进行画面的渲染）。

在Android中，GLSurfaceView是一个支持OpenGL的渲染视图，通过继承SurfaceView中的surface来渲染OpenGL

并提供了以下特性（来自于网上）

1> 管理一个surface，这个surface就是一块特殊的内存，能直接排版到android的视图view上。

2> 管理一个EGL display，它能让opengl把内容渲染到上述的surface上。

3> 用户自定义渲染器(render)。

4> 让渲染器在独立的线程里运作，和UI线程分离。

5> 支持按需渲染(on-demand)和连续渲染(continuous)。

6> 一些可选工具，如调试。

重点是自定义的渲染器，也就是Cocos2dx引擎封装的渲染器。进入Cocos2dxRenderer类，看到他是继承GLSurfaceView.Renderer接口，这个接口定义了三个方法：

onSurfaceCreated: 创建GLSurfaceView时被调用，只调用一次，做初始化工作

onSurfaceChanged: 当GLSurfaceView的几何体被改变时被调用

onDrawFrame: 绘制渲染GLSurfaceView

1. onSurfaceCreated:

@Override
public void onSurfaceCreated(final GL10 pGL10, final EGLConfig pEGLConfig) {
Cocos2dxRenderer.nativeInit(this.mScreenWidth, this.mScreenHeight);
this.mLastTickInNanoSeconds = System.nanoTime();
}

private static native void nativeInit(final int pWidth, final int pHeight);

这是一个用JNI调用了C++中的方法（这个C++函数在jni/hellocpp/main.cpp中），如下

void Java_org_cocos2dx_lib_Cocos2dxRenderer_nativeInit(JNIEnv*  env, jobject thiz, jint w, jint h)
{
if (!CCDirector::sharedDirector()->getOpenGLView())
{
CCEGLView *view = CCEGLView::sharedOpenGLView();
view->setFrameSize(w, h);

AppDelegate *pAppDelegate = new AppDelegate();
CCApplication::sharedApplication()->run();
}
else
{
ccGLInvalidateStateCache();
CCShaderCache::sharedShaderCache()->reloadDefaultShaders();
ccDrawInit();
CCTextureCache::reloadAllTextures();
CCNotificationCenter::sharedNotificationCenter()->postNotification(EVENT_COME_TO_FOREGROUND, NULL);
CCDirector::sharedDirector()->setGLDefaultValues();
}
}

首先这个方法会判断OpenGLView是否初始化

inline CCEGLView* getOpenGLView(void) { return m_pobOpenGLView; }

进入到CCDirector的构造函数中和init方法中。可以在init方法中找到m_pobOpenGLView = NULL;

接下来的两句是是设置窗口大小。而AppDelegate才是入口的重点。

执行完上面的步骤后开始初始化App然后初始化AppDelegate，AppDelegate的初始化过程也很简单。就实现了一个获取AppDelegate的单例。

AppDelegate的构造方法是个空方法

AppDelegate::AppDelegate() {

}

而AppDelegate的父类是CCApplication类。

class  AppDelegate : private cocos2d::CCApplication

进入到CCApplication的构造函数中（由于不同的平台CCApplication有着不同的实现类，这里要选中Android的实现类）

// sharedApplication pointer
CCApplication * CCApplication::sm_pSharedApplication = 0;

CCApplication::CCApplication()
{
CCAssert(! sm_pSharedApplication, "");
sm_pSharedApplication = this;
}

可以看到是CCApplication是一个单例，里面也没做多少动作。

创建完AppDelegate后开始run

int CCApplication::run()
{
// Initialize instance and cocos2d.
if (! applicationDidFinishLaunching())
{
return 0;
}

return -1;
}

可以看到里面调用了applicationDidFinishLaunching方法，这个方法被AppDelegate重写了，也就是在这里通过多态调用了AppDelegate的applicationDidFinishLaunching方法，然后就可以看到是cocos2dx的开发者很熟悉的Cocos2dx游戏的入口函数了：

bool AppDelegate::applicationDidFinishLaunching() {
// initialize director
CCDirector* pDirector = CCDirector::sharedDirector();
CCEGLView* pEGLView = CCEGLView::sharedOpenGLView();

pDirector->setOpenGLView(pEGLView);

// turn on display FPS
pDirector->setDisplayStats(true);

// set FPS. the default value is 1.0/60 if you don't call this
pDirector->setAnimationInterval(1.0 / 60);

// create a scene. it's an autorelease object
CCScene *pScene = HelloWorld::scene();

// run
pDirector->runWithScene(pScene);

return true;
}

第一步是在导演类中是在OpenGLView，这样在便能使CCDirector::sharedDirector()->getOpenGLView()返回true。然后又设置了是否显示FPS，帧率，并创建了一个场景。并把这个场景当初是游戏的初始场景，压入栈中（由一个CCArray来维护场景），最后运行该场景，整个游戏便开始由这个场景开始启动。

void CCDirector::runWithScene(CCScene *pScene)
{
CCAssert(pScene != NULL, "This command can only be used to start the CCDirector. There is already a scene present.");
CCAssert(m_pRunningScene == NULL, "m_pRunningScene should be null");

pushScene(pScene);
startAnimation();
}

由这个方法可以看下场景是如何运行的，进入pushScene方法中

void CCDirector::pushScene(CCScene *pScene)
{
CCAssert(pScene, "the scene should not null");

m_bSendCleanupToScene = false;

m_pobScenesStack->addObject(pScene);
m_pNextScene = pScene;
}

这里的关键是场景栈的实现也就是m_pobSceneStack变量的维护。

在CCDirector的init方法中可以找到m_pobScenesStack的创建。

m_pobScenesStack = new CCArray();
m_pobScenesStack->init();

这里发现一个很奇怪的写法，首先在new CCArray时肯定是会调用不带参数的构造函数，结果发现里面已经调用了init方法

CCArray::CCArray()
: data(NULL)
{
init();
}

而这里在初始化完CCArray后又调用了init方法，不知表达什么含义

由于调用了CCArray::init方法，所以只初始了存放一个场景的CCArray类

bool CCArray::init()
{
return initWithCapacity(1);
}

bool CCArray::initWithCapacity(unsigned int capacity)
{
ccArrayFree(data);
data = ccArrayNew(capacity);
return true;
}

这里看下CCArray的实现过程

在初始化这个CCArray时，先会清空这个CCArray的所有对象，然后创建ccArray这个结构体。

（

其实CCArray中的数据便是这个ccArray结构体中的一个指向CCObject*的数组

typedef struct _ccArray {
unsigned int num, max;
CCObject** arr;
} ccArray;

）

ccArray* ccArrayNew(unsigned int capacity)
{
if (capacity == 0)
capacity = 1;

ccArray *arr = (ccArray*)malloc( sizeof(ccArray) );
arr->num = 0;
arr->arr =  (CCObject**)calloc(capacity, sizeof(CCObject*));
arr->max = capacity;

return arr;
}

可以看到ccArrayNew的执行是一个C语言的写法，先动态申请一块内存，然后初始化内存空间为0，以下是百度百科的一句话：

calloc在动态分配完内存后，自动初始化该内存空间为零，而malloc不初始化，里边数据是随机的垃圾数据（注意：由于CCArray存放是CCObject指针，在调用calloc时会连续分配长度为sizeof(CCObject*)的内存大小）

最后把当前的场景存到m_pobScenesStack中，最后让m_pNextScene指向该场景

由此可以看到切换场景时不推荐使用pushScene，因为pushScene会不断的把新的场景加到m_pobScenesStack中，而不释放上一个场景的内存空间，导致内存会急剧增长，如果创建的场景很多的话。所以如果要使用pushScene一般的做法便是在创建完一个场景后插入到m_pobScenesStack的头部，然后调用popScene回收上一个场景的内存。（这样的做法会破坏掉栈的先进后出的原则，是不推荐的做法，因为popScene本来就是一个模拟出栈的方法）

void CCDirector::popScene(void)
{
CCAssert(m_pRunningScene != NULL, "running scene should not null");

m_pobScenesStack->removeLastObject();
unsigned int c = m_pobScenesStack->count();

if (c == 0)
{
end();//没有场景，游戏结束（设置一个参数，使Cocos2dx退出主循环来达到目的）
}
else
{
m_bSendCleanupToScene = true;
m_pNextScene = (CCScene*)m_pobScenesStack->objectAtIndex(c - 1);
}
}

再看下replaceScene

void CCDirector::replaceScene(CCScene *pScene)
{
CCAssert(m_pRunningScene, "Use runWithScene: instead to start the director");
CCAssert(pScene != NULL, "the scene should not be null");

unsigned int index = m_pobScenesStack->count();

m_bSendCleanupToScene = true;
m_pobScenesStack->replaceObjectAtIndex(index - 1, pScene);

m_pNextScene = pScene;
}
void CCArray::replaceObjectAtIndex(unsigned int index, CCObject* pObject, bool bReleaseObject/* = true*/)
{
ccArrayInsertObjectAtIndex(data, pObject, index);
ccArrayRemoveObjectAtIndex(data, index+1);
}

replaceScene的做法也很简单，就是用当前的场景替换掉上一个场景，这样便能把上一个场景的内存清掉。替换的做法也跟上面的类似，先插入新场景，再删除新场景。

先不扯那么多，执行完场景压栈后会调用startAnimation，这个从这个方法开始便会开始又切换到Java应用中

void CCDisplayLinkDirector::startAnimation(void)
{
if (CCTime::gettimeofdayCocos2d(m_pLastUpdate, NULL) != 0)
{
CCLOG("cocos2d: DisplayLinkDirector: Error on gettimeofday");
}

m_bInvalid = false;
#ifndef EMSCRIPTEN
CCApplication::sharedApplication()->setAnimationInterval(m_dAnimationInterval);
#endif // EMSCRIPTEN
}
void CCApplication::setAnimationInterval(double interval)
{
JniMethodInfo methodInfo;
if (! JniHelper::getStaticMethodInfo(methodInfo, "org/cocos2dx/lib/Cocos2dxRenderer", "setAnimationInterval",
"(D)V"))
{
CCLOG("%s %d: error to get methodInfo", __FILE__, __LINE__);
}
else
{
methodInfo.env->CallStaticVoidMethod(methodInfo.classID, methodInfo.methodID, interval);
}
}

可以看到从setAnimationInterval方法开始回调java中的org/cocos2dx/lib/Cocos2dxRenderer.setAnimationInterval方法，并传入一个帧率的大小，返回值为void

public static void setAnimationInterval(final double pAnimationInterval) {
Cocos2dxRenderer.sAnimationInterval = (long) (pAnimationInterval * Cocos2dxRenderer.NANOSECONDSPERSECOND);
}

这里只做了初始化渲染的帧率。

这样Cocos2dx的GLSurfaceView的创建边执行完毕了。（在创建过程并没有执行Cocos2dx的主循环）

2. onSurfaceChanged:

第二个方法是空实现，略过

@Override
public void onSurfaceChanged(final GL10 pGL10, final int pWidth, final int pHeight) {
}

3. onDrawFrame:

第三个方法是绘制方法。

@Override
public void onDrawFrame(final GL10 gl) {
Cocos2dxRenderer.nativeRender();
}
private static native void nativeRender();

这也是一个调用C++的方法（这个方法在cocos2dx/platform/android/jni/Java_org_cocos2dx_lib_Cocos2dxRenderer.cpp中）

JNIEXPORT void JNICALL Java_org_cocos2dx_lib_Cocos2dxRenderer_nativeRender(JNIEnv* env) {
cocos2d::CCDirector::sharedDirector()->mainLoop();
}

终于到了这个主循环了！！！可以看到这个渲染器的绘制方法不干别的，就是调用Cocos2dx的主循环。这里的主循环跟win32平台不太一样，是通过Render来渲染的，是一种间接的调用方式来实现。

这里借鉴上网络上的一段关于Android的渲染逻辑。

游戏引擎要兼顾UI事件和屏幕帧刷新。Android的OpenGL应用采用了UI线程(Main Thread) + 渲染线程(Render Thread)的模式。Activity活在Main Thread(主线程)中，也叫做UI线程。该线程负责捕获与用户交互的信息和事件，并与渲染(Render)线程交互。比如当用户接听电话、切换到其他 程序时，渲染线程必须知道发生了 这些事件，并作出即时的处理，而这些事件及处理方式都是由主线程中的Activity以及其装载的View传递给渲染线程的。

上面的那段话说明Android的渲染便是不断执行Cocos2dx的主函数，因为屏幕每时每刻都会在渲染，每渲染一次调用一次Cocos2dx主函数来绘制游戏的画面。

接下俩看下游戏的结束过程。

Cocos2dx的结束控制是放在主循环中判断：

void CCDisplayLinkDirector::mainLoop(void)
{
if (m_bPurgeDirecotorInNextLoop)//退出主循环的标志
{
m_bPurgeDirecotorInNextLoop = false;
purgeDirector();//清空导演类
}
else if (! m_bInvalid)
{
drawScene();//渲染节点树

// release the objects
CCPoolManager::sharedPoolManager()->pop();//内存管理
}
}

很明显，想让游戏结束，就要让m_bPurgeDirecotorInNextLoop变量为true。而当调用CCDirector::end()方法时便会触发此过程：

void CCDirector::end()
{
m_bPurgeDirecotorInNextLoop = true;
}

（也上面说过当没有导演类中的场景栈中没有场景时便会调用end方法。）

接下来便是purgeDirector方法：

void CCDirector::purgeDirector()
{
//清空定时器
getScheduler()->unscheduleAll();

// don't release the event handlers
// They are needed in case the director is run again
//清空触摸分发器
m_pTouchDispatcher->removeAllDelegates();

if (m_pRunningScene)//如果还有场景在运行，清空此场景
{
m_pRunningScene->onExitTransitionDidStart();
m_pRunningScene->onExit();
m_pRunningScene->cleanup();
m_pRunningScene->release();
}
//防止指向其他地址
m_pRunningScene = NULL;
m_pNextScene = NULL;

//清空场景栈
m_pobScenesStack->removeAllObjects();
//停止继续渲染
stopAnimation();
//清空显示左下角的显示文本
CC_SAFE_RELEASE_NULL(m_pFPSLabel);
CC_SAFE_RELEASE_NULL(m_pSPFLabel);
CC_SAFE_RELEASE_NULL(m_pDrawsLabel);

//清空CCLabelBMFont文本类的缓存数据
CCLabelBMFont::purgeCachedData();

//清空所有缓存
ccDrawFree();
CCAnimationCache::purgeSharedAnimationCache();
CCSpriteFrameCache::purgeSharedSpriteFrameCache();
CCTextureCache::purgeSharedTextureCache();
CCShaderCache::purgeSharedShaderCache();
CCFileUtils::purgeFileUtils();
CCConfiguration::purgeConfiguration();

//清空CCUserDefault和CCNotificationCenter
CCUserDefault::purgeSharedUserDefault();
CCNotificationCenter::purgeNotificationCenter();

ccGLInvalidateStateCache();

CHECK_GL_ERROR_DEBUG();

//清空视图
m_pobOpenGLView->end();
m_pobOpenGLView = NULL;

//删除导演
release();
}

其中主要看m_pobOpenGLView->end()的实现。这个方法每个平台都有自己不同的实现方式，这里选择Android平台。

void CCEGLView::end()
{
//终止进程
terminateProcessJNI();
}

#define  CLASS_NAME "org/cocos2dx/lib/Cocos2dxHelper"
void terminateProcessJNI() {
JniMethodInfo t;

if (JniHelper::getStaticMethodInfo(t, CLASS_NAME, "terminateProcess", "()V")) {
t.env->CallStaticVoidMethod(t.classID, t.methodID);
t.env->DeleteLocalRef(t.classID);
}
}

通过JNI调用org.cocos2dx.lib.Cocos2dxHelper类中的terminateProcess方法

public static void terminateProcess() {
android.os.Process.killProcess(android.os.Process.myPid());
}

可以看到，Android的结束方式便是Android系统自身杀死运行中的Cocos2dx游戏进程。

至此，整个Cocos2dx游戏在Android的运行始末便结束了。