如何用纯C++（ndk）开发安卓应用？

如何安装安卓的开发环境以及怎么设置ndk的环境变量等在前边的文章已经有了详细的讲解，在这里我就不再说明，如果有不会安装和设置环境的，请先参考安卓环境搭建的内容。

创新互联主营阜阳网站建设的网络公司,主营网站建设方案,成都App定制开发,阜阳h5成都微信小程序搭建,阜阳网站营销推广欢迎阜阳等地区企业咨询

好，假设以及安装好了ndk，使用纯c++开发安卓程序，下边是详细的步骤与说明：

1.编写入口函数

android_main为入口函数，和C++中的main函数是一样的。这里创建CELLAndroidApp的对象，直接调用main函数。

 
 
    
  
  
  1. void android_main(struct android_app* state)  
    2. 
  
  
  2. {  
    3. 
  
  
  3.     CELLAndroidApp    app(state);  
    4. 
  
  
  4.  
    5. 
  
  
  5.        app.main(0,0);  
    6. 
  
  
  6. }  
    7.

说明：其中的 CELLAndroidApp是我们设计的一个图形绘制类，稍后将对其做详细说明

2.绘制类的实现说明

2.1类的成员说明

 
 
    
  
  
  1. protected:  
    2. 
  
  
  2.     EGLConfig        _config;  
    3. 
  
  
  3.     EGLSurface       _surface;  
    4. 
  
  
  4.     EGLContext       _context;  
    5. 
  
  
  5.     EGLDisplay       _display;  
    6. 
  
  
  6.     android_app*     _app;  
    7. 
  
  
  7.     int              _width;  
    8. 
  
  
  8.     int              _height; 
    9.

部分参数说明：

_surface:用于绘制图形，相当于windows绘图中的位图

_context：可以看做是opengl对象

_display：用于绘图的设备上下文，类似于windows绘图中的dc

2.2 构造函数说明

 
 
    
  
  
  1. CELLAndroidApp(android_app* app):_app(app)  
    2. 
  
  
  2.     {  
    3. 
  
  
  3.         _surface    =    0;  
    4. 
  
  
  4.         _context    =    0;   
    5. 
  
  
  5.         _display    =    0;  
    6. 
  
  
  6.         _width        =    64;  
    7. 
  
  
  7.         _height        =    48;  
    8. 
  
  
  8.         app->userData        =    this; //用户数据  
    9. 
  
  
  9.         app->onAppCmd         =     handle_cmd; //窗口的创建销毁等  
    10. 
  
  
  10.         app->onInputEvent     =    handle_input; //回调函数  
    11. 
  
  
  11.     } 
    12.

值得注意的是，这里的app中的userData，传入用户数据，这里直接传入this，onAppCmd传入的handle_cmd回调函数，onInputEvent传入的事handle_input回调函数

2.3 类中函数main()说明

 
 
    
  
  
  1. virtual    void     main(int argc,char** argv)  
    2. 
  
  
  2.     {  
    3. 
  
  
  3.         int ident;  
    4. 
  
  
  4.         int    events;  
    5. 
  
  
  5.         android_poll_source* source;  
    6. 
  
  
  6.  
    7. 
  
  
  7.         while (true)  
    8. 
  
  
  8.         {          
    9. 
  
  
  9.             while ((ident = ALooper_pollAll(0, NULL, &events, (void**)&source)) >= 0)   
    10. 
  
  
  10.             {  
    11. 
  
  
  11.                 if (source != NULL)  
    12. 
  
  
  12.                     source->process(_app, source); //有触摸事件，调用input函数,相当于dispatchmessage  
    13. 
  
  
  13.  
    14. 
  
  
  14.                 if (_app->destroyRequested != 0)  
    15. 
  
  
  15.                     return;  
    16. 
  
  
  16.             }  
    17. 
  
  
  17.             render();  
    18. 
  
  
  18.         }  
    19. 
  
  
  19.     } 
    20.

其中的android_poll_source相当于windows中的消息队列，用于存放消息，这个函数中模拟了windows中的消息机制。

ALooper_pollAll()函数，用于获取消息。值得注意的是第一个参数，如果第一个参数传入0，则不等待，调用后直接返回，类似于windows消息机制中的pickMessage()函数，如果传入-1，则类似于windows消息机制中的SendMessage()函数。 返回值：如果返回值大于大于等于0表示获取到数据，如果为-1则表示失败，未获取到数据。

其中发source如果不为空，则表示有触摸事件，则调用process()函数，相当于windows中调用dispatchMessage()函数。

最后，调用render()函数，绘制图形。

2.4 初始化设备函数initDevice()

 
 
    
  
  
  1. virtual void     initDevice()  
    2. 
  
  
  2.     {  
    3. 
  
  
  3.         const EGLint attribs[] =  
    4. 
  
  
  4.         {  
    5. 
  
  
  5.             EGL_SURFACE_TYPE, EGL_WINDOW_BIT,  
    6. 
  
  
  6.             EGL_BLUE_SIZE, 8,   
    7. 
  
  
  7.             EGL_GREEN_SIZE, 8,  
    8. 
  
  
  8.             EGL_RED_SIZE, 8,  
    9. 
  
  
  9.             EGL_NONE  
    10. 
  
  
  10.         };  
    11. 
  
  
  11.         EGLint     format;  
    12. 
  
  
  12.         EGLint    numConfigs;  
    13. 
  
  
  13.  
    14. 
  
  
  14.         _display    =    eglGetDisplay(EGL_DEFAULT_DISPLAY);  
    15. 
  
  
  15.  
    16. 
  
  
  16.         eglInitialize(_display, 0, 0);  
    17. 
  
  
  17.  
    18. 
  
  
  18.         eglChooseConfig(_display, attribs, &_config, 1, &numConfigs);   
    19. 
  
  
  19.  
    20. 
  
  
  20.         eglGetConfigAttrib(_display, _config, EGL_NATIVE_VISUAL_ID, &format);  
    21. 
  
  
  21.  
    22. 
  
  
  22.         ANativeWindow_setBuffersGeometry(_app->window, 0, 0, format);   
    23. 
  
  
  23.  
    24. 
  
  
  24.         _surface    =     eglCreateWindowSurface(_display, _config, _app->window, NULL);  
    25. 
  
  
  25.  
    26. 
  
  
  26. #if 0  
    27. 
  
  
  27.         EGLint contextAtt[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE, EGL_NONE };  
    28. 
  
  
  28.  
    29. 
  
  
  29.         _context     =     eglCreateContext(_display, _config, 0, contextAtt);  
    30. 
  
  
  30. #else  
    31. 
  
  
  31.         _context     =     eglCreateContext(_display, _config, 0, 0);   
    32. 
  
  
  32. #endif  
    33. 
  
  
  33.  
    34. 
  
  
  34.         if (eglMakeCurrent(_display, _surface, _surface, _context) == EGL_FALSE)  
    35. 
  
  
  35.         {  
    36. 
  
  
  36.             LOGW("Unable to eglMakeCurrent");   
    37. 
  
  
  37.             return;  
    38. 
  
  
  38.         }  
    39. 
  
  
  39.  
    40. 
  
  
  40.         eglQuerySurface(_display, _surface, EGL_WIDTH, &_width);   
    41. 
  
  
  41.         eglQuerySurface(_display, _surface, EGL_HEIGHT, &_height);  
    42. 
  
  
  42.  
    43. 
  
  
  43.         onCreate();  
    44. 
  
  
  44.  
    45. 
  
  
  45.         // Initialize GL state.  
    46. 
  
  
  46.         glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);   
    47. 
  
  
  47.         glEnable(GL_CULL_FACE);  
    48. 
  
  
  48.         glShadeModel(GL_SMOOTH);  
    49. 
  
  
  49.         glDisable(GL_DEPTH_TEST);  
    50. 
  
  
  50.         glViewport(0,0,_width,_height);  
    51. 
  
  
  51.         glOrthof(0,_width,_height,0,-100,100);  
    52. 
  
  
  52.     } 
    53.

首先需要说明的是attribs数组，改数组中主要存储了绘制图形的一些属性信息，他们是成对出现的，如EGL_SURFACE_TYPE则表示绘制图形类型， EGL_WINDOW_BIT则表示绘制到窗口上。

eglGetDisplay()函数：表示获取一个显示设备

eglInitialize()：表示初始化获取到的显示设备

eglChooseConfig()：绘制属性的配置

eglGetConfigAttrib()：设置绘制格式

ANativeWindow_setBuffersGeometry()：将格式应用到窗口

eglCreateWindowSurface()：创建绘图窗口

eglCreateContext()：创建opengl的绘图上下文

eglMakeCurrent()：绑定到绘图设备上下文

eglQuerySurface()：获取图片的宽度和高度，具体获取哪一个根据最后一个参数确定

glHint()、glEnable()和glOrthof()等函数则是与绘图的投影相关的内容，包括初始化、设置模式等内容。

#p#

2.5 绘制函数render()

 
 
    
  
  
  1. virtual    void     render()  
    2. 
  
  
  2.     {  
    3. 
  
  
  3.         if(_display == 0)  
    4. 
  
  
  4.         {  
    5. 
  
  
  5.             return;  
    6. 
  
  
  6.         }  
    7. 
  
  
  7.         glClearColor(0,0,0, 1);   
    8. 
  
  
  8.         glClear(GL_COLOR_BUFFER_BIT);  
    9. 
  
  
  9.  
    10. 
  
  
  10.         glEnableClientState(GL_VERTEX_ARRAY);   
    11. 
  
  
  11.         if(g_arVertex.size() >= 2)  
    12. 
  
  
  12.         {  
    13. 
  
  
  13.             glColor4f(1,1,1,1);   
    14. 
  
  
  14.             glVertexPointer(3,GL_FLOAT,0,&g_arVertex[0]);   
    15. 
  
  
  15.             glDrawArrays(GL_LINE_STRIP,0,g_arVertex.size());  
    16. 
  
  
  16.         }  
    17. 
  
  
  17.  
    18. 
  
  
  18.         eglSwapBuffers(_display,_surface); //双缓存的交换缓冲区  
    19. 
  
  
  19.     } 
    20.

render()函数主要用于绘制点，对主要的几个函数做如下说明：

glClearColor()：用于将屏幕清为黑色

glClear()：清空颜色缓冲区

glEnableClientState()：启动定点数组

glVertexPointer()：制定定点缓冲区

glDrawArrays()：绘制点数组

eglSwapBuffers()：类似双缓存的交换缓冲区

2.6 handle_cmd()函数

 
 
    
  
  
  1. static void     handle_cmd(android_app* app, int32_t cmd)  
    2. 
  
  
  2.     {  
    3. 
  
  
  3.         CELLAndroidApp*    pThis    =    (CELLAndroidApp*)app->userData;  
    4. 
  
  
  4.         pThis->cmd(app,cmd);  
    5. 
  
  
  5.     }  
    6.

2.7 handle_input()函数

 
 
    
  
  
  1. static void     handle_input(android_app* app, AInputEvent* event)  
    2. 
  
  
  2.     {  
    3. 
  
  
  3.         CELLAndroidApp*    pThis    =    (CELLAndroidApp*)app->userData;  
    4. 
  
  
  4.         pThis->input(app,event);  
    5. 
  
  
  5.     }  
    6.

2.8 input()函数

 
 
    
  
  
  1. virtual    int     input(struct android_app* app, AInputEvent* event)  
    2. 
  
  
  2.     {  
    3. 
  
  
  3.         int32_t    evtType    =    AInputEvent_getType(event);  
    4. 
  
  
  4.         switch(evtType)  
    5. 
  
  
  5.         {  
    6. 
  
  
  6.         case AINPUT_EVENT_TYPE_KEY:   
    7. 
  
  
  7.             break;  
    8. 
  
  
  8.         case AINPUT_EVENT_TYPE_MOTION:   
    9. 
  
  
  9.             {  
    10. 
  
  
  10.                 int32_t    sourceId    =     AInputEvent_getSource(event);  
    11. 
  
  
  11.                 if(AINPUT_SOURCE_TOUCHSCREEN == sourceId)  
    12. 
  
  
  12.                 {  
    13. 
  
  
  13.                     int32_t id = AMotionEvent_getAction(event);   
    14. 
  
  
  14.                     switch(id)  
    15. 
  
  
  15.                     {  
    16. 
  
  
  16.                     case AMOTION_EVENT_ACTION_MOVE:  
    17. 
  
  
  17.                         {  
    18. 
  
  
  18.                             size_t    cnt = AMotionEvent_getPointerCount(event);   
    19. 
  
  
  19.                             for( int i = 0 ;i < cnt; ++ i )  
    20. 
  
  
  20.                             {  
    21. 
  
  
  21.                                 float x = AMotionEvent_getX(event,i);  
    22. 
  
  
  22.                                 float y = AMotionEvent_getY(event,i);  
    23. 
  
  
  23.                                 float3 pt;  
    24. 
  
  
  24.                                 pt.x = x;  
    25. 
  
  
  25.                                 pt.y = y;  
    26. 
  
  
  26.                                 pt.z = 0;  
    27. 
  
  
  27.                                 g_arVertex.push_back(pt);  
    28. 
  
  
  28.                             }  
    29. 
  
  
  29.  
    30. 
  
  
  30.                         }  
    31. 
  
  
  31.                         break;  
    32. 
  
  
  32.                     case AMOTION_EVENT_ACTION_DOWN:  
    33. 
  
  
  33.                         {  
    34. 
  
  
  34.                             size_t    cnt = AMotionEvent_getPointerCount(event);  
    35. 
  
  
  35.                             for( int i = 0 ;i < cnt; ++ i )  
    36. 
  
  
  36.                             {  
    37. 
  
  
  37.                                 float x = AMotionEvent_getX(event,i);  
    38. 
  
  
  38.                                 float y = AMotionEvent_getY(event,i);  
    39. 
  
  
  39.                             }  
    40. 
  
  
  40.                         }  
    41. 
  
  
  41.                         break;  
    42. 
  
  
  42.                     case AMOTION_EVENT_ACTION_UP:  
    43. 
  
  
  43.                         {  
    44. 
  
  
  44.                             size_t    cnt = AMotionEvent_getPointerCount(event);  
    45. 
  
  
  45.                             for( int i = 0 ;i < cnt; ++ i )  
    46. 
  
  
  46.                             {  
    47. 
  
  
  47.                                 float x = AMotionEvent_getX(event,i);  
    48. 
  
  
  48.                                 float y = AMotionEvent_getY(event,i);  
    49. 
  
  
  49.                             }  
    50. 
  
  
  50.                         }  
    51. 
  
  
  51.                         break;  
    52. 
  
  
  52.                     }  
    53. 
  
  
  53.                 }  
    54. 
  
  
  54.                 else if(AINPUT_SOURCE_TRACKBALL == sourceId)  
    55. 
  
  
  55.                 {  
    56. 
  
  
  56.                 }  
    57. 
  
  
  57.             }  
    58. 
  
  
  58.             break;  
    59. 
  
  
  59.         }  
    60. 
  
  
  60.         return    0;  
    61. 
  
  
  61.     } 
    62.

该函数主要用于对输入进行判断，以确定是吉键盘、鼠标或遥感等，根据具体输入做相应的操纵，这里就不再做过多的说明

AMotionEvent_getPointerCount()：如果是多点触控，则将各个点保存到vector中。

2.9 cmd()函数

 
 
    
  
  
  1. virtual int    cmd(struct android_app* app, int32_t cmd)  
    2. 
  
  
  2.     {  
    3. 
  
  
  3.         switch(cmd)  
    4. 
  
  
  4.         {  
    5. 
  
  
  5.         case APP_CMD_SAVE_STATE:  
    6. 
  
  
  6.             break;  
    7. 
  
  
  7.         case APP_CMD_INIT_WINDOW:  
    8. 
  
  
  8.             initDevice();  
    9. 
  
  
  9.             break;  
    10. 
  
  
  10.         case APP_CMD_TERM_WINDOW:  
    11. 
  
  
  11.             shutDownDevice();  
    12. 
  
  
  12.             break;  
    13. 
  
  
  13.         case APP_CMD_GAINED_FOCUS:  
    14. 
  
  
  14.             break;  
    15. 
  
  
  15.         case APP_CMD_LOST_FOCUS:  
    16. 
  
  
  16.             break;  
    17. 
  
  
  17.         }  
    18. 
  
  
  18.         return    0;  
    19. 
  
  
  19.     } 
    20.

根据传入的命令，对窗口做相应的处理。

APP_CMD_INIT_WINDOW：表示初始化窗口

2.10 shutDownDevice()函数

 
 
    
  
  
  1. virtual void     shutDownDevice()  
    2. 
  
  
  2.     {  
    3. 
  
  
  3.         onDestroy();  
    4. 
  
  
  4.  
    5. 
  
  
  5.         if (_display != EGL_NO_DISPLAY)  
    6. 
  
  
  6.         {  
    7. 
  
  
  7.             eglMakeCurrent(_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);  
    8. 
  
  
  8.             if (_context != EGL_NO_CONTEXT)  
    9. 
  
  
  9.             {  
    10. 
  
  
  10.                 eglDestroyContext(_display, _context);  
    11. 
  
  
  11.             }  
    12. 
  
  
  12.             if (_surface != EGL_NO_SURFACE)  
    13. 
  
  
  13.             {  
    14. 
  
  
  14.                 eglDestroySurface(_display, _surface);  
    15. 
  
  
  15.             }  
    16. 
  
  
  16.             eglTerminate(_display);  
    17. 
  
  
  17.         }  
    18. 
  
  
  18.         _display = EGL_NO_DISPLAY;  
    19. 
  
  
  19.         _context = EGL_NO_CONTEXT;  
    20. 
  
  
  20.         _surface = EGL_NO_SURFACE;  
    21. 
  
  
  21.     } 
    22.

关闭设备，主要是将与设备相关的绑定清除，释放绑定。

编写完上边的代码后，编译程序，将程序导入到模拟器中，最终运行的效果图如下：

好了，该说的基本都说玩了，下边附上源码地址，赶紧去尝试吧：

 示例程序下载

    原文链接：
http://www.cnblogs.com/zhanglitong/p/3766740.html

新闻标题：如何用纯C++（ndk）开发安卓应用？
网站网址：http://www.csdahua.cn/qtweb/news15/193365.html

网站建设、网络推广公司-快上网，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 快上网

成都快上网为您推荐相关内容

网站设计知识

分类信息网

企业邮箱　　 　电信服务器托管　　 　成都网站制作　　 　防护网厂　　 　APP定制　　 　成都做网站建设公司　　 　南充主机托管　　 　成都标志设计　　 　成都商务茶叶销售　　 　绵阳电信服务器托管　　 　成都网站建设　　 　内江托管服务器　　 　微信公众号开发　　 　艾名斯线缆　　 　华川商务　　 　邛崃做网站　　 　成都微信小程序开发　　 　租用服务器　　 　瑞杰企业管理　　 　电商网站建设方案