cocos2d-x學習篇之網路（http）篇

Polaroid2007發表於2014-06-21
HTTP

轉載自：http://blog.csdn.net/duotianshi86/article/details/10216383


這段時間接觸到cocos2d-x，拜讀了csdn上很多大大的文章，尤其是小滿的專欄，感覺獲益不少，覺得像他們那樣，邊學習，邊總結經驗，並寫出來學習過程與大家分享，我覺得是一件很值得學習的事，所以也打算把自己學習的東西和經驗與大家分享，有不足之處或者錯誤的，還希望請大家能海涵並提出來，共同討論，共同進步。好了，廢話到此。

Cocos2dx 為我們封裝了在cocos2dx中http的網路框架，其檔案在cocos2dx引擎包的cocos2d-2.1rc0-x-2.1.2\extensions\network檔案下的 HttpClient、HttpRequest 、HttpResponse。但是真正的底層，用的還是cURL庫。。。

進行一次http互動，需要涉及的有三個類，HttpRequest用來描述一個請求。HttpResponse用來描述對應請求的響應。HttpClient是一個單例模式的類，它的職責就是負責將收到的HttpRequest物件push到傳送佇列中，併傳送一個訊號量驅動工作執行緒工作，工作執行緒再將收到的資料封裝成一個HttpResponse物件push接收佇列，並啟用排程來派送資料。具體的後面有說道。

1.首先建立一個類，繼承自cocos2d-x中的任何一個類都可以（有共同父類CCObject），並實現一個SEL_CallFuncND型別成員函式，用來做收到資料後的回撥函式，函式原型為void fun(CCNode*, void*)。

2.當我們需要一次http互動的時候，我們需要new 一個CCHttpRequest物件，並設定url和請求方式（get還是post，本文只說一下get的原理，post區別不大，可以自己看），並將上面說函式設定為收到資料後的回撥函式。

3.使用CCHttpClient::getInstance()單例物件，將前一步驟的CCHttpRequest物件作為引數,呼叫send()方法。

4.在回撥函式中，將第二個引數轉換成CCHttpResponse *型別，就可以通過CCHttpResponse類的方法來獲取返回狀態和資料等能容了。

我們先來看看具體的該怎麼用，以自帶的HttpClientTest.cpp為例。HttpClientTest.cpp:

[cpp] view plaincopy
  1. //get請求  
  2. void HttpClientTest::onMenuGetTestClicked(cocos2d::CCObject *sender)  
  3. {      
  4.     // test 1  
  5.     {  
  6.         CCHttpRequest* request = new CCHttpRequest();//建立request物件,這裡new出來的物件不能使用autorelease()，原因後述  
  7.         request->setUrl("http://just-make-this-request-failed.com");//設定url  
  8.         request->setRequestType(CCHttpRequest::kHttpGet);//設定請求方式  
  9.         request->setResponseCallback(this, callfuncND_selector(HttpClientTest::onHttpRequestCompleted));//這是回撥物件和回撥函式  
  10.         request->setTag("GET test1");//設定使用者標識，可以通過response獲取  
  11.         CCHttpClient::getInstance()->send(request);//使用CCHttpClient共享例項來傳送request  
  12.         request->release();//呼叫release()  
  13.     }  
  14.   
  15.     // waiting  
  16.     m_labelStatusCode->setString("waiting...");  
  17.    
  18. }  
  19. //這裡就是我們要處理接收到資料的回撥函式了，sender為CCHttpClient例項指標，data為接收到的response指標  
  20. void HttpClientTest::onHttpRequestCompleted(cocos2d::CCNode *sender, void *data)  
  21. {  
  22.     CCHttpResponse *response = (CCHttpResponse*)data;  
  23.   
  24.     if (!response)  
  25.     {  
  26.         return;  
  27.     }  
  28.       
  29.     // 獲取對應request的字串標識  
  30.     if (0 != strlen(response->getHttpRequest()->getTag()))   
  31.     {  
  32.         CCLog("%s completed", response->getHttpRequest()->getTag());  
  33.     }  
  34.     //獲取返回程式碼，比如200、404等  
  35.     int statusCode = response->getResponseCode();  
  36.     char statusString[64] = {};  
  37.     sprintf(statusString, "HTTP Status Code: %d, tag = %s", statusCode, response->getHttpRequest()->getTag());  
  38.     m_labelStatusCode->setString(statusString);  
  39.     CCLog("response code: %d", statusCode);  
  40.       
  41.     if (!response->isSucceed())   
  42.     {  
  43.         CCLog("response failed");  
  44.         CCLog("error buffer: %s", response->getErrorBuffer());//可以呼叫getErrorBuffer()來獲取錯誤原因  
  45.         return;  
  46.     }  
  47.       
  48.     // dump data  
  49.     std::vector<char> *buffer = response->getResponseData();//用來獲取接收到的資料  
  50.     printf("Http Test, dump data: ");  
  51.     for (unsigned int i = 0; i < buffer->size(); i++)  
  52.     {  
  53.         printf("%c", (*buffer)[i]);  
  54.     }  
  55.     printf("\n");  
  56. }  


基本上一個http互動就是這個樣子了，下面我們深入的看一下CCHttpClient是怎麼工作的，先來看一張圖，畫的不好或者不足之處，請勿拍磚

其實就是當我們第一次CCHttpClient::getInstance()時，CCHttpClient會將自己的成員函式dispathResponseCallbacks()掛載至CCScheduler(可以理解成一個排程者，它會定時呼叫所有掛載至上面的函式)，並將它初始設定為停止排程。在當我們第一次呼叫send()傳送資料時，CCHttpClient會建立一個工作執行緒（之後再呼叫send()就不會建立執行緒了），然後再將傳遞過來的CCHttpRequest物件push到傳送佇列s_requestQueue，併傳送一個訊號給工作執行緒，驅使其工作。工作執行緒首先從傳送佇列中取得一個CCHttpRequest物件，並new 一個CCHttpResponse物件，將引數設定給cURL，cURL會在獲取到資料的填充response，工作執行緒將填充後的response再放到接收佇列s_responseQueue中去，同時，啟用排程。下一次CCScheduler就會CCHttpClient::dispatchResponseCallbacks()了，在該函式中，它會呼叫我們在第二步中設定給request的回撥函式，並將response傳遞過去。基本過程就是這樣。下面來詳解相關的原始檔。HttpRequest.h，其實這個檔案沒什麼好說的，都有註釋

[cpp] view plaincopy
  1. class CCHttpRequest : public CCObject  
  2. {  
  3. public:  
  4.     /** 請求型別列舉，可以通過setReqeustType(param) 設定*/  
  5.     typedef enum  
  6.     {  
  7.         kHttpGet,  
  8.         kHttpPost,  
  9.         kHttpUnkown,  
  10.     } HttpRequestType;  
  11.       
  12.     /** Constructor  
  13.         Because HttpRequest object will be used between UI thead and network thread, 
  14.         requestObj->autorelease() is forbidden to avoid crashes in CCAutoreleasePool 
  15.         new/retain/release still works, which means you need to release it manually 
  16.         Please refer to HttpRequestTest.cpp to find its usage 
  17.     這裡是有註釋的，因為要跨執行緒，所以就不能用autorelease() 
  18.     我們在使用HttpRequest的時候，需要自己new，然後再release下就可以了 
  19.     當我們把HttpRequest傳遞給CCHttpClient的時候，CCHttpClient已經幫我們retain了 
  20.     工作執行緒中，需要使用CCHttpRequest物件new一個CCHttpResponse,CCHttprequest會retain一次，所以工作執行緒也會release一次 
  21.     具體的後文有 
  22.      */  
  23.     CCHttpRequest()  
  24.     {  
  25.         _requestType = kHttpUnkown;  
  26.         _url.clear();  
  27.         _requestData.clear();  
  28.         _tag.clear();  
  29.         _pTarget = NULL;  
  30.         _pSelector = NULL;  
  31.         _pUserData = NULL;  
  32.     };  
  33.       
  34.     virtual ~CCHttpRequest()  
  35.     {  
  36.         if (_pTarget)  
  37.         {  
  38.             _pTarget->release();  
  39.         }  
  40.     };  
  41.       
  42.     /** 過載autorelease函式，禁止呼叫 */  
  43.     CCObject* autorelease(void)  
  44.     {  
  45.         CCAssert(false, "HttpResponse is used between network thread and ui thread \  
  46.                  therefore, autorelease is forbidden here");  
  47.         return NULL;  
  48.     }  
  49.               
  50.     // setter/getters for properties  
  51.        
  52.     /** 設定請求型別 
  53.         目前支援kHttpGet 和 kHttpPost 
  54.      */  
  55.     inline void setRequestType(HttpRequestType type)  
  56.     {  
  57.         _requestType = type;  
  58.     };  
  59.     /** 返回請求型別 */  
  60.     inline HttpRequestType getRequestType()  
  61.     {  
  62.         return _requestType;  
  63.     };  
  64.       
  65.     /** 設定請求url 
  66.      */  
  67.     inline void setUrl(const char* url)  
  68.     {  
  69.         _url = url;  
  70.     };  
  71.     /** 獲取請求url */  
  72.     inline const char* getUrl()  
  73.     {  
  74.         return _url.c_str();  
  75.     };  
  76.       
  77.     /** 這個設定用於post方式的data資料 
  78.      */  
  79.     inline void setRequestData(const char* buffer, unsigned int len)  
  80.     {  
  81.         _requestData.assign(buffer, buffer + len);  
  82.     };  
  83.     /** Get the request data pointer back */  
  84.     inline char* getRequestData()  
  85.     {  
  86.         return &(_requestData.front());  
  87.     }  
  88.     /** Get the size of request data back */  
  89.     inline int getRequestDataSize()  
  90.     {  
  91.         return _requestData.size();  
  92.     }  
  93.       
  94.     /** 為每個請求設定一個字串標示，可以通過HttpResponse->getHttpRequest->getTag()獲取，因為HttpResponse會將對應的HttpRequest封裝在裡面 
  95.      */  
  96.     inline void setTag(const char* tag)  
  97.     {  
  98.         _tag = tag;  
  99.     };  
  100.     /** Get the string tag back to identify the request.  
  101.         The best practice is to use it in your MyClass::onMyHttpRequestCompleted(sender, HttpResponse*) callback 
  102.      */  
  103.     inline const char* getTag()  
  104.     {  
  105.         return _tag.c_str();  
  106.     };  
  107.       
  108.     /** Option field. You can attach a customed data in each request, and get it back in response callback. 
  109.         But you need to new/delete the data pointer manully 
  110.      */  
  111.     inline void setUserData(void* pUserData)  
  112.     {  
  113.         _pUserData = pUserData;  
  114.     };  
  115.     /** Get the pre-setted custom data pointer back. 
  116.         Don't forget to delete it. HttpClient/HttpResponse/HttpRequest will do nothing with this pointer 
  117.      */  
  118.     inline void* getUserData()  
  119.     {  
  120.         return _pUserData;  
  121.     };  
  122.       
  123.     /** 通過這個函式設定我們的資料處理回撥函式 
  124.      */  
  125.     inline void setResponseCallback(CCObject* pTarget, SEL_CallFuncND pSelector)  
  126.     {  
  127.         _pTarget = pTarget;  
  128.         _pSelector = pSelector;  
  129.           
  130.         if (_pTarget)  
  131.         {  
  132.             _pTarget->retain();  
  133.         }  
  134.     }      
  135.     /** Get the target of callback selector funtion, mainly used by CCHttpClient */  
  136.     inline CCObject* getTarget()  
  137.     {  
  138.         return _pTarget;  
  139.     }  
  140.     /** Get the selector function pointer, mainly used by CCHttpClient */  
  141.     inline SEL_CallFuncND getSelector()  
  142.     {  
  143.         return _pSelector;  
  144.     }  
  145.   
  146.     /** Set any custom headers **/  
  147.     inline void setHeaders(std::vector<std::string> pHeaders)  
  148.     {  
  149.         _headers=pHeaders;  
  150.     }  
  151.      
  152.     /** Get custom headers **/  
  153.     inline std::vector<std::string> getHeaders()  
  154.     {  
  155.         return _headers;  
  156.     }  
  157.   
  158.   
  159. protected:  
  160.     // properties  
  161.     HttpRequestType             _requestType;    /// 請求方式  
  162.     std::string                 _url;            /// 請求url  
  163.     std::vector<char>           _requestData;    /// 用於 POST  
  164.     std::string                 _tag;            /// 使用者自定義標識，可以用來在response回撥中區分request  
  165.     CCObject*          _pTarget;        /// 回撥物件  
  166.     SEL_CallFuncND     _pSelector;      /// 回撥函式例如 MyLayer::onHttpResponse(CCObject *sender, void *data)  
  167.     void*                       _pUserData;      /// 使用者自定義資料，和_tag用法一樣，只不過是用途不一樣  
  168.     std::vector<std::string>    _headers;           /// custom http headers  
  169. };  

HttpResponse.h,這個檔案和HttpRequest差不多，沒什麼好說的

[cpp] view plaincopy
  1. class CCHttpResponse : public CCObject  
  2. {  
  3. public:  
  4.     /** Constructor, it's used by CCHttpClient internal, users don't need to create HttpResponse manually 
  5.      @param request the corresponding HttpRequest which leads to this response  
  6.      */  
  7.     CCHttpResponse(CCHttpRequest* request)  
  8.     {  
  9.         _pHttpRequest = request;  
  10.         if (_pHttpRequest)  
  11.         {  
  12.             _pHttpRequest->retain();  
  13.         }  
  14.           
  15.         _succeed = false;  
  16.         _responseData.clear();  
  17.         _errorBuffer.clear();  
  18.     }  
  19.       
  20.     /** Destructor, it will be called in CCHttpClient internal, 
  21.      users don't need to desturct HttpResponse object manully  
  22.      */  
  23.     virtual ~CCHttpResponse()  
  24.     {  
  25.         if (_pHttpRequest)  
  26.         {  
  27.             _pHttpRequest->release();  
  28.         }  
  29.     }  
  30.       
  31.     /** Override autorelease method to prevent developers from calling it */  
  32.     CCObject* autorelease(void)  
  33.     {  
  34.         CCAssert(false, "HttpResponse is used between network thread and ui thread \  
  35.                         therefore, autorelease is forbidden here");  
  36.         return NULL;  
  37.     }  
  38.       
  39.     // getters, will be called by users  
  40.       
  41.     /** Get the corresponding HttpRequest object which leads to this response  
  42.         There's no paired setter for it, coz it's already setted in class constructor 
  43.      */  
  44.     inline CCHttpRequest* getHttpRequest()  
  45.     {  
  46.         return _pHttpRequest;  
  47.     }  
  48.           
  49.     /** To see if the http reqeust is returned successfully, 
  50.         Althrough users can judge if (http return code = 200), we want an easier way 
  51.         If this getter returns false, you can call getResponseCode and getErrorBuffer to find more details 
  52.      */  
  53.     inline bool isSucceed()  
  54.     {  
  55.         return _succeed;  
  56.     };  
  57.       
  58.     /** Get the http response raw data */  
  59.     inline std::vector<char>* getResponseData()  
  60.     {  
  61.         return &_responseData;  
  62.     }  
  63.   
  64.     /** Get the http response errorCode 
  65.      *  I know that you want to see http 200 :) 
  66.      */  
  67.     inline int getResponseCode()  
  68.     {  
  69.         return _responseCode;  
  70.     }  
  71.   
  72.     /** Get the rror buffer which will tell you more about the reason why http request failed 
  73.      */  
  74.     inline const char* getErrorBuffer()  
  75.     {  
  76.         return _errorBuffer.c_str();  
  77.     }  
  78.       
  79.     // setters, will be called by CCHttpClient  
  80.     // users should avoid invoking these methods  
  81.       
  82.       
  83.     /** Set if the http request is returned successfully, 
  84.      Althrough users can judge if (http code == 200), we want a easier way 
  85.      This setter is mainly used in CCHttpClient, users mustn't set it directly 
  86.      */  
  87.     inline void setSucceed(bool value)  
  88.     {  
  89.         _succeed = value;  
  90.     };  
  91.       
  92.       
  93.     /** Set the http response raw buffer, is used by CCHttpClient       
  94.      */  
  95.     inline void setResponseData(std::vector<char>* data)  
  96.     {  
  97.         _responseData = *data;  
  98.     }  
  99.       
  100.       
  101.     /** Set the http response errorCode 
  102.      */  
  103.     inline void setResponseCode(int value)  
  104.     {  
  105.         _responseCode = value;  
  106.     }  
  107.       
  108.       
  109.     /** Set the error buffer which will tell you more the reason why http request failed 
  110.      */  
  111.     inline void setErrorBuffer(const char* value)  
  112.     {  
  113.         _errorBuffer.clear();  
  114.         _errorBuffer.assign(value);  
  115.     };  
  116.       
  117. protected:  
  118.     bool initWithRequest(CCHttpRequest* request);  
  119.       
  120.     // properties  
  121.     //這裡要留意下，每個response中都會包含對應的request，所以能在資料處理回撥函式中，獲取我們在設定request的所有引數，比如像tag,userdata  
  122.     CCHttpRequest*        _pHttpRequest;  /// the corresponding HttpRequest pointer who leads to this response   
  123.     bool                _succeed;       /// to indecate if the http reqeust is successful simply  
  124.     std::vector<char>   _responseData;  /// the returned raw data. You can also dump it as a string  
  125.     int                 _responseCode;    /// the status code returned from libcurl, e.g. 200, 404  
  126.     std::string         _errorBuffer;   /// if _responseCode != 200, please read _errorBuffer to find the reason   
  127.       
  128. };  

說白了，CCHttpRequest和CCHttpResponse只不過是傳送佇列中的資料型別，和接收佇列中的資料型別，是執行緒之間傳遞的引數，下面來說說CCHttpClient

HttpClient.h

[cpp] view plaincopy
  1. //CCHttpClient是一個單例模式的類，整個程式共享一個例項物件  
  2. class CCHttpClient : public CCObject  
  3. {  
  4. public:  
  5.     /** 獲取共享的單例物件 **/  
  6.     static CCHttpClient *getInstance();  
  7.       
  8.     /** Relase the shared instance **/  
  9.     static void destroyInstance();  
  10.           
  11.     /** 
  12.      * Add a get request to task queue 
  13.      * @param request a CCHttpRequest object, which includes url, response callback etc. 
  14.                       please make sure request->_requestData is clear before calling "send" here. 
  15.      * @return NULL 
  16.      */  
  17.     void send(CCHttpRequest* request);  
  18.     
  19.       
  20.     /** 
  21.      * Change the connect timeout 
  22.      * @param timeout  
  23.      * @return NULL 
  24.      */  
  25.     inline void setTimeoutForConnect(int value) {_timeoutForConnect = value;};  
  26.       
  27.     /** 
  28.      * Get connect timeout 
  29.      * @return int 
  30.      * 
  31.      */  
  32.     inline int getTimeoutForConnect() {return _timeoutForConnect;}  
  33.       
  34.       
  35.     /** 
  36.      * Change the download timeout 
  37.      * @param value 
  38.      * @return NULL 
  39.      */  
  40.     inline void setTimeoutForRead(int value) {_timeoutForRead = value;};  
  41.       
  42.   
  43.     /** 
  44.      * Get download timeout 
  45.      * @return int 
  46.      */  
  47.     inline int getTimeoutForRead() {return _timeoutForRead;};  
  48.           
  49. private:  
  50.     CCHttpClient();  
  51.     virtual ~CCHttpClient();  
  52.     bool init(void);  
  53.       
  54.     /** 
  55.      * Init pthread mutex, semaphore, and create new thread for http requests 
  56.      * @return bool 
  57.      */  
  58.     bool lazyInitThreadSemphore();  
  59.     /** Poll function called from main thread to dispatch callbacks when http requests finished **/  
  60.     void dispatchResponseCallbacks(float delta);  
  61.       
  62. private:  
  63.     int _timeoutForConnect;//連線超時時間  
  64.     int _timeoutForRead;//接收資料超時時間  
  65.       
  66.     // std::string reqId;  
  67. };  


HttpClient.cpp

[cpp] view plaincopy
  1. static pthread_t        s_networkThread;//工作執行緒控制程式碼  
  2. static pthread_mutex_t  s_requestQueueMutex;//請求佇列互斥變數  
  3. static pthread_mutex_t  s_responseQueueMutex;//接收佇列互斥變數  
  4. static sem_t *          s_pSem = NULL;//用來驅動執行緒工作的訊號量  
  5. static unsigned long    s_asyncRequestCount = 0;//當前需要處理的request個數  
  6.   
  7. #if CC_TARGET_PLATFORM == CC_PLATFORM_IOS  
  8. #define CC_ASYNC_HTTPREQUEST_USE_NAMED_SEMAPHORE 1  
  9. #else  
  10. #define CC_ASYNC_HTTPREQUEST_USE_NAMED_SEMAPHORE 0  
  11. #endif  
  12.   
  13. #if CC_ASYNC_HTTPREQUEST_USE_NAMED_SEMAPHORE  
  14. #define CC_ASYNC_HTTPREQUEST_SEMAPHORE "ccHttpAsync"  
  15. #else  
  16. static sem_t s_sem;  
  17. #endif  
  18.   
  19. #if (CC_TARGET_PLATFORM == CC_PLATFORM_WIN32)  
  20. typedef int int32_t;  
  21. #endif  
  22.   
  23. static bool need_quit = false;      //退出標識  
  24.   
  25. static CCArray* s_requestQueue = NULL;  //請求佇列（下面都說request佇列）  
  26. static CCArray* s_responseQueue = NULL; //接收佇列（下面都說response佇列）  
  27.   
  28. static CCHttpClient *s_pHttpClient = NULL; // 全域性單例CCHttpClient物件  
  29.   
  30. static char s_errorBuffer[CURL_ERROR_SIZE];//錯誤提示buffer  
  31.   
  32. typedef size_t (*write_callback)(void *ptr, size_t size, size_t nmemb, void *stream);//這個是用於cURL收到資料的回撥函式  
  33.   
  34.   
  35. // 這個便是當cURL接收到資料回撥的函式，也就是在這裡對response進行填充，這裡的宣告方式和fwrite()函式一樣  
  36. size_t writeData(void *ptr, size_t size, size_t nmemb, void *stream)  
  37. {  
  38.     //ptr指向接受到的資料，sizes為位元組數  
  39.     //這裡傳過來的stream中儲存了CCHttpResponse::_responseData  
  40.     std::vector<char> *recvBuffer = (std::vector<char>*)stream;  
  41.     size_t sizes = size * nmemb;  
  42.       
  43.     // add data to the end of recvBuffer  
  44.     // 將接受到的資料寫到response中去  
  45.     recvBuffer->insert(recvBuffer->end(), (char*)ptr, (char*)ptr+sizes);  
  46.       
  47.     return sizes;  
  48. }  
  49.   
  50. // Prototypes  
  51. bool configureCURL(CURL *handle);  
  52. int processGetTask(CCHttpRequest *request, write_callback callback, void *stream, int32_t *errorCode);  
  53. int processPostTask(CCHttpRequest *request, write_callback callback, void *stream, int32_t *errorCode);  
  54. // int processDownloadTask(HttpRequest *task, write_callback callback, void *stream, int32_t *errorCode);  
  55.   
  56.   
  57. // 工作執行緒  
  58. static void* networkThread(void *data)  
  59. {      
  60.     CCHttpRequest *request = NULL;  
  61.       
  62.     while (true)   
  63.     {  
  64.         // 等待主執行緒傳送訊號，就是呼叫send()函式  
  65.         int semWaitRet = sem_wait(s_pSem);  
  66.         if (semWaitRet < 0) {  
  67.             CCLog("HttpRequest async thread semaphore error: %s\n", strerror(errno));  
  68.             break;  
  69.         }  
  70.         //退出  
  71.         if (need_quit)  
  72.         {  
  73.             break;  
  74.         }  
  75.           
  76.         // step 1: send http request if the requestQueue isn't empty  
  77.         request = NULL;  
  78.           
  79.         pthread_mutex_lock(&s_requestQueueMutex); //給request佇列上鎖  
  80.         if (0 != s_requestQueue->count())  
  81.         {  
  82.             request = dynamic_cast<CCHttpRequest*>(s_requestQueue->objectAtIndex(0));//取得第一個request  
  83.             s_requestQueue->removeObjectAtIndex(0);  //將其移除佇列  
  84.             // 這裡的request的引用次數為1，因為只有在send()函式中retain了一次  
  85.         }  
  86.         pthread_mutex_unlock(&s_requestQueueMutex);//request佇列解鎖  
  87.           
  88.         if (NULL == request)  
  89.         {  
  90.             continue;  
  91.         }  
  92.           
  93.         // 同步呼叫cURL庫  
  94.           
  95.         // 使用request來建立一個response  
  96.         CCHttpResponse *response = new CCHttpResponse(request);  
  97.           
  98.         // 在CCHttpTtpResponse構造中，會將request再retain一次  
  99.         request->release();  
  100.         // 這裡，只有response中有request的一次引用計數  
  101.           
  102.         int responseCode = -1;  
  103.         int retValue = 0;  
  104.   
  105.         // 根據請求型別設定cURL引數  
  106.         switch (request->getRequestType())  
  107.         {  
  108.             case CCHttpRequest::kHttpGet: // HTTP GET  
  109.                 retValue = processGetTask(request,   
  110.                                           writeData,   
  111.                                           response->getResponseData(),   
  112.                                           &responseCode);  
  113.                 break;  
  114.               
  115.             case CCHttpRequest::kHttpPost: // HTTP POST  
  116.                 retValue = processPostTask(request,   
  117.                                            writeData,   
  118.                                            response->getResponseData(),   
  119.                                            &responseCode);  
  120.                 break;  
  121.               
  122.             default:  
  123.                 CCAssert(true, "CCHttpClient: unkown request type, only GET and POSt are supported");  
  124.                 break;  
  125.         }  
  126.                   
  127.         // 設定返回程式碼  
  128.         response->setResponseCode(responseCode);  
  129.           
  130.         if (retValue != 0)   
  131.         {  
  132.             response->setSucceed(false);  
  133.             response->setErrorBuffer(s_errorBuffer);  
  134.         }  
  135.         else  
  136.         {  
  137.             response->setSucceed(true);  
  138.         }  
  139.   
  140.           
  141.         // 將response加入佇列  
  142.         pthread_mutex_lock(&s_responseQueueMutex);//給response加鎖  
  143.         s_responseQueue->addObject(response);  
  144.         pthread_mutex_unlock(&s_responseQueueMutex);//解鎖  
  145.           
  146.         // 啟動CCScheduler排程  
  147.         CCDirector::sharedDirector()->getScheduler()->resumeTarget(CCHttpClient::getInstance());  
  148.     }  
  149.       
  150.     // 執行緒退出，清理request佇列  
  151.     pthread_mutex_lock(&s_requestQueueMutex);  
  152.     s_requestQueue->removeAllObjects();  
  153.     pthread_mutex_unlock(&s_requestQueueMutex);  
  154.     s_asyncRequestCount -= s_requestQueue->count();  
  155.       
  156.     if (s_pSem != NULL) {  
  157. #if CC_ASYNC_HTTPREQUEST_USE_NAMED_SEMAPHORE  
  158.         sem_unlink(CC_ASYNC_HTTPREQUEST_SEMAPHORE);  
  159.         sem_close(s_pSem);  
  160. #else  
  161.         sem_destroy(s_pSem);  
  162. #endif  
  163.           
  164.         s_pSem = NULL;  
  165.         //釋放互斥變數  
  166.         pthread_mutex_destroy(&s_requestQueueMutex);  
  167.         pthread_mutex_destroy(&s_responseQueueMutex);  
  168.           
  169.         s_requestQueue->release();  
  170.         s_responseQueue->release();  
  171.     }  
  172.   
  173.     pthread_exit(NULL);  
  174.       
  175.     return 0;  
  176. }  
  177.   
  178. //設定cURL超時屬性  
  179. bool configureCURL(CURL *handle)  
  180. {  
  181.     if (!handle) {  
  182.         return false;  
  183.     }  
  184.       
  185.     int32_t code;  
  186.     //設定錯誤資訊緩衝  
  187.     code = curl_easy_setopt(handle, CURLOPT_ERRORBUFFER, s_errorBuffer);  
  188.     if (code != CURLE_OK) {  
  189.         return false;  
  190.     }  
  191.     //設定超時時間  
  192.     code = curl_easy_setopt(handle, CURLOPT_TIMEOUT, CCHttpClient::getInstance()->getTimeoutForRead());  
  193.     if (code != CURLE_OK) {  
  194.         return false;  
  195.     }  
  196.     code = curl_easy_setopt(handle, CURLOPT_CONNECTTIMEOUT, CCHttpClient::getInstance()->getTimeoutForConnect());  
  197.     if (code != CURLE_OK) {  
  198.         return false;  
  199.     }  
  200.       
  201.     return true;  
  202. }  
  203.   
  204. //處理get方式請求  
  205. //stream傳遞過來的是response->getResponseData()  
  206. //關於cURL的東西這裡就不多說了  
  207. int processGetTask(CCHttpRequest *request, write_callback callback, void *stream, int *responseCode)  
  208. {  
  209.     CURLcode code = CURL_LAST;  
  210.     //初始化cURL  
  211.     CURL *curl = curl_easy_init();  
  212.       
  213.     do {  
  214.         if (!configureCURL(curl)) //配置cURL  
  215.         {  
  216.             break;  
  217.         }  
  218.           
  219.         /* handle custom header data */  
  220.         /* create curl linked list */  
  221.         struct curl_slist *cHeaders=NULL;  
  222.         /* get custom header data (if set) */  
  223.         std::vector<std::string> headers=request->getHeaders();  
  224.             if(!headers.empty())  
  225.             {                 
  226.                     for(std::vector<std::string>::iterator it=headers.begin();it!=headers.end();it++)  
  227.                     {  
  228.               /* append custom headers one by one */  
  229.                         cHeaders=curl_slist_append(cHeaders,it->c_str());  
  230.                     }  
  231.            /* set custom headers for curl */  
  232.                     code = curl_easy_setopt(curl, CURLOPT_HTTPHEADER, cHeaders);  
  233.                     if (code != CURLE_OK) {  
  234.                         break;  
  235.                     }  
  236.             }  
  237.                 
  238.         code = curl_easy_setopt(curl, CURLOPT_URL, request->getUrl());  
  239.         if (code != CURLE_OK)   
  240.         {  
  241.             break;  
  242.         }  
  243.           
  244.         code = curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, request->getUrl());  
  245.         if (code != CURLE_OK)  
  246.         {  
  247.             break;  
  248.         }  
  249.   
  250.         code = curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, callback);  
  251.         if (code != CURLE_OK)   
  252.         {  
  253.             break;  
  254.         }  
  255.         //這裡將response->_responseData設定為cURL回撥函式中的stream引數  
  256.         code = curl_easy_setopt(curl, CURLOPT_WRITEDATA, stream);  
  257.         if (code != CURLE_OK)   
  258.         {  
  259.             break;  
  260.         }  
  261.           
  262.         code = curl_easy_perform(curl);  
  263.         if (code != CURLE_OK)   
  264.         {  
  265.             break;  
  266.         }  
  267.           
  268.         /* free the linked list for header data */  
  269.         curl_slist_free_all(cHeaders);  
  270.   
  271.         code = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, responseCode);   
  272.         if (code != CURLE_OK || *responseCode != 200)   
  273.         {  
  274.             code = CURLE_HTTP_RETURNED_ERROR;  
  275.         }  
  276.     } while (0);  
  277.       
  278.     if (curl) {  
  279.         curl_easy_cleanup(curl);  
  280.     }  
  281.       
  282.     return (code == CURLE_OK ? 0 : 1);  
  283. }  
  284.   
  285. //這個就不說了，其實都一樣的，cURL承擔了所有工作  
  286. int processPostTask(CCHttpRequest *request, write_callback callback, void *stream, int32_t *responseCode)  
  287. {  
  288.     CURLcode code = CURL_LAST;  
  289.     CURL *curl = curl_easy_init();  
  290.       
  291.     do {  
  292.         if (!configureCURL(curl)) {  
  293.             break;  
  294.         }  
  295.           
  296.         /* handle custom header data */  
  297.         /* create curl linked list */  
  298.         struct curl_slist *cHeaders=NULL;  
  299.         /* get custom header data (if set) */  
  300.             std::vector<std::string> headers=request->getHeaders();  
  301.             if(!headers.empty())  
  302.             {                 
  303.                     for(std::vector<std::string>::iterator it=headers.begin();it!=headers.end();it++)  
  304.                     {  
  305.               /* append custom headers one by one */  
  306.                         cHeaders=curl_slist_append(cHeaders,it->c_str());  
  307.                     }  
  308.            /* set custom headers for curl */  
  309.                     code = curl_easy_setopt(curl, CURLOPT_HTTPHEADER, cHeaders);  
  310.                     if (code != CURLE_OK) {  
  311.                         break;  
  312.                     }  
  313.             }  
  314.                 
  315.         code = curl_easy_setopt(curl, CURLOPT_URL, request->getUrl());  
  316.         if (code != CURLE_OK) {  
  317.             break;  
  318.         }  
  319.         code = curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, callback);  
  320.         if (code != CURLE_OK) {  
  321.             break;  
  322.         }  
  323.         code = curl_easy_setopt(curl, CURLOPT_WRITEDATA, stream);  
  324.         if (code != CURLE_OK) {  
  325.             break;  
  326.         }  
  327.         code = curl_easy_setopt(curl, CURLOPT_POST, 1);  
  328.         if (code != CURLE_OK) {  
  329.             break;  
  330.         }  
  331.         code = curl_easy_setopt(curl, CURLOPT_POSTFIELDS, request->getRequestData());  
  332.         if (code != CURLE_OK) {  
  333.             break;  
  334.         }  
  335.         code = curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, request->getRequestDataSize());  
  336.         if (code != CURLE_OK) {  
  337.             break;  
  338.         }  
  339.         code = curl_easy_perform(curl);  
  340.         if (code != CURLE_OK) {  
  341.             break;  
  342.         }  
  343.           
  344.         /* free the linked list for header data */  
  345.         curl_slist_free_all(cHeaders);  
  346.   
  347.         code = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, responseCode);   
  348.         if (code != CURLE_OK || *responseCode != 200) {  
  349.             code = CURLE_HTTP_RETURNED_ERROR;  
  350.         }  
  351.     } while (0);  
  352.     if (curl) {  
  353.         curl_easy_cleanup(curl);  
  354.     }  
  355.       
  356.     return (code == CURLE_OK ? 0 : 1);      
  357. }  
  358.   
  359. // 返回共享例項  
  360. CCHttpClient* CCHttpClient::getInstance()  
  361. {  
  362.     if (s_pHttpClient == NULL) {  
  363.         s_pHttpClient = new CCHttpClient();  
  364.     }  
  365.       
  366.     return s_pHttpClient;  
  367. }  
  368.   
  369. void CCHttpClient::destroyInstance()  
  370. {  
  371.     CCAssert(s_pHttpClient, "");  
  372.     //將CCHttpClient::dispatchResponseCallbacks()函式從CCShecduler中取消掛載  
  373.     CCDirector::sharedDirector()->getScheduler()->unscheduleSelector(schedule_selector(CCHttpClient::dispatchResponseCallbacks), s_pHttpClient);  
  374.     s_pHttpClient->release();  
  375. }  
  376.   
  377. CCHttpClient::CCHttpClient()  
  378. : _timeoutForConnect(30)  
  379. , _timeoutForRead(60)  
  380. {  
  381.     //將成員函式dispatchTesponseCallbacks()掛載至CCSheduler  
  382.     CCDirector::sharedDirector()->getScheduler()->scheduleSelector(  
  383.                     schedule_selector(CCHttpClient::dispatchResponseCallbacks), this, 0, false);  
  384.     //初始化為停止排程，由工作執行緒接收到了資料之後啟用排程  
  385.     CCDirector::sharedDirector()->getScheduler()->pauseTarget(this);  
  386. }  
  387.   
  388. CCHttpClient::~CCHttpClient()  
  389. {  
  390.     need_quit = true;  
  391.       
  392.     if (s_pSem != NULL) {  
  393.         sem_post(s_pSem);  
  394.     }  
  395.       
  396.     s_pHttpClient = NULL;  
  397. }  
  398.   
  399. //只有在第一次呼叫send()時呼叫，去初始化佇列、建立執行緒、初始化互斥變數等  
  400. bool CCHttpClient::lazyInitThreadSemphore()  
  401. {  
  402.     if (s_pSem != NULL) {  
  403.         return true;  
  404.     } else {  
  405. #if CC_ASYNC_HTTPREQUEST_USE_NAMED_SEMAPHORE  
  406.         s_pSem = sem_open(CC_ASYNC_HTTPREQUEST_SEMAPHORE, O_CREAT, 0644, 0);  
  407.         if (s_pSem == SEM_FAILED) {  
  408.             CCLog("Open HttpRequest Semaphore failed");  
  409.             s_pSem = NULL;  
  410.             return false;  
  411.         }  
  412. #else  
  413.         int semRet = sem_init(&s_sem, 0, 0);  
  414.         if (semRet < 0) {  
  415.             CCLog("Init HttpRequest Semaphore failed");  
  416.             return false;  
  417.         }  
  418.           
  419.         s_pSem = &s_sem;  
  420. #endif  
  421.           
  422.         s_requestQueue = new CCArray();  
  423.         s_requestQueue->init();  
  424.           
  425.         s_responseQueue = new CCArray();  
  426.         s_responseQueue->init();  
  427.           
  428.         pthread_mutex_init(&s_requestQueueMutex, NULL);  
  429.         pthread_mutex_init(&s_responseQueueMutex, NULL);  
  430.           
  431.         pthread_create(&s_networkThread, NULL, networkThread, NULL);  
  432.         pthread_detach(s_networkThread);  
  433.           
  434.         need_quit = false;  
  435.     }  
  436.       
  437.     return true;  
  438. }  
  439.   
  440. //Add a get task to queue  
  441. void CCHttpClient::send(CCHttpRequest* request)  
  442. {      
  443.     //第一次呼叫的時候初始化  
  444.     if (false == lazyInitThreadSemphore())   
  445.     {  
  446.         return;  
  447.     }  
  448.       
  449.     if (!request)  
  450.     {  
  451.         return;  
  452.     }  
  453.     //將當前需要處理的request個數++  
  454.     ++s_asyncRequestCount;  
  455.     //在這裡對request進行第一次retain，  
  456.     request->retain();  
  457.     //這裡request的引用次數為1  
  458.     pthread_mutex_lock(&s_requestQueueMutex);//request佇列加鎖  
  459.     s_requestQueue->addObject(request);//push到request佇列  
  460.     pthread_mutex_unlock(&s_requestQueueMutex);//解鎖  
  461.       
  462.     // 傳送訊號喚醒工作執行緒  
  463.     sem_post(s_pSem);  
  464. }  
  465.   
  466. // 將response佇列資料分發  
  467. void CCHttpClient::dispatchResponseCallbacks(float delta)  
  468. {  
  469.     // CCLog("CCHttpClient::dispatchResponseCallbacks is running");  
  470.       
  471.     CCHttpResponse* response = NULL;  
  472.       
  473.     pthread_mutex_lock(&s_responseQueueMutex);//給response佇列上鎖  
  474.     if (s_responseQueue->count())  
  475.     {  
  476.         response = dynamic_cast<CCHttpResponse*>(s_responseQueue->objectAtIndex(0));//取出response  
  477.         s_responseQueue->removeObjectAtIndex(0);//將其從response佇列移除  
  478.     }  
  479.     pthread_mutex_unlock(&s_responseQueueMutex);//解鎖  
  480.       
  481.     if (response)  
  482.     {  
  483.         --s_asyncRequestCount;  
  484.           
  485.         CCHttpRequest *request = response->getHttpRequest();  
  486.         CCObject *pTarget = request->getTarget();//獲取request回撥函式的物件  
  487.         SEL_CallFuncND pSelector = request->getSelector();//獲取回撥函式  
  488.   
  489.         if (pTarget && pSelector)   
  490.         {  
  491.             (pTarget->*pSelector)((CCNode *)this, response);//呼叫回撥函式，並把本單例物件和response傳遞給我們設定在request中的回撥函式  
  492.         }  
  493.           
  494.         response->release();  
  495.     }  
  496.       
  497.     if (0 == s_asyncRequestCount) //如果沒有沒有請求，停止排程  
  498.     {  
  499.         CCDirector::sharedDirector()->getScheduler()->pauseTarget(this);  
  500.     }  
  501.       
  502. }  


      花了大半天時間，終於寫的差不多了，其實我當初是想看看cocos2d-x是怎樣封裝socket這一塊的，結果是這樣，用的cURL庫。。。


相關文章