cocos2d-x 10.1版本 http 链接

 1 /********************************************************************
 2  *  Copyright(C) 2012 Ambition( All rights reserved. )
 3  *    Created:    2012/09/18   11:21
 4  *    File base:    HSBaseHttp.h
 5  *    Author:        Ambition
 6  *    
 7  *    Purpose:    
 8 *********************************************************************/
 9 #ifndef __HSBaseHttp_H__
10 #define __HSBaseHttp_H__
11 #pragma once
12 #include "cocos2d.h"
13 #include "curl.h"
14 #include <queue>
15 #include <pthread.h>
16 #include <semaphore.h>
17 #include <errno.h>
18 #include "HSHttpRequest.h"
19 #include "HSHttpResponse.h"
20 using namespace cocos2d;
21 
22 #if WIN32
23 #pragma comment(lib,"libcurl_imp.lib")
24 #pragma comment(lib,"pthreadVCE2.lib")
25 #endif
26 
27 
28 class HSBaseHttp : public SelectorProtocol,public CCObject
29 {
30 
31 public:
32     HSBaseHttp();
33     virtual ~HSBaseHttp();
34 
35 private:
36     int iTimeoutForConnect;        //链接超时时间
37     int iTimeoutForRead;        //读取超时时间
38 public:
39     //得到一个实例
40     static HSBaseHttp* GetInstance();
41     //销毁实例
42     static void DestroyInstance();
43     //发送请求
44     void Send(HSHttpRequest* request);
45     void SetTimeoutForConnect(int value);
46     
47     int GetTimeoutForConnect();
48  
49     void SetTimeoutForRead(int value);
50 
51     int GetTimeoutForRead();
52     
53 
54 
55 private:
56     //销毁回调
57     void DispatchResponseCallbacks(float delta);
58     //线程信号初始化
59     bool LazyInitThreadSemphore();
60 };
61 
62 
63 #endif // __HSBaseHttp_H__

 1 #include "HSBaseHttp.h"  2  3  4 //static member  5 static HSBaseHttp* s_pBaseHttp = NULL; // pointer to singleton  6  7 //线程锁  8 static pthread_t s_networkThread;  9 static pthread_mutex_t s_requestQueueMutex;  10 static pthread_mutex_t s_responseQueueMutex;  11 static sem_t * s_pSem = NULL;  12 static unsigned long s_asyncRequestCount = 0;  13  14 static bool need_quit = false;  15 static CCArray* s_requestQueue = NULL; //请求队列  16 static CCArray* s_responseQueue = NULL; //响应队列  17  18 #if CC_TARGET_PLATFORM == CC_PLATFORM_IOS  19 #define CC_ASYNC_HTTPREQUEST_USE_NAMED_SEMAPHORE 1  20 #else  21 #define CC_ASYNC_HTTPREQUEST_USE_NAMED_SEMAPHORE 0  22 #endif  23  24 #if CC_ASYNC_HTTPREQUEST_USE_NAMED_SEMAPHORE  25 #define CC_ASYNC_HTTPREQUEST_SEMAPHORE "ccHttpAsync"  26 #else  27 static sem_t s_sem;  28 #endif  29  30 #if (CC_TARGET_PLATFORM == CC_PLATFORM_WIN32)  31 typedef int int32_t;  32 #endif  33  34 static char s_errorBuffer[CURL_ERROR_SIZE];  35  36 typedef size_t (*write_callback)(void *ptr, size_t size, size_t nmemb, void *stream);  37  38 //  39 // C 函数实现  40 //  41  42 size_t writeData(void *ptr, size_t size, size_t nmemb, void *stream)  43 {  44 std::vector<char> *recvBuffer = (std::vector<char>*)stream;  45 size_t sizes = size * nmemb;  46  47 recvBuffer->clear();  48 recvBuffer->assign((char*)ptr, (char*)ptr + sizes);  49 CCLog("...%s ... ",(char*)ptr);  50  51 return sizes;  52 }  53  54 bool ConfigureCURL(CURL *handle)  55 {  56 if (!handle) {  57 return false;  58  }  59  60  int32_t code;  61 code = curl_easy_setopt(handle, CURLOPT_ERRORBUFFER, s_errorBuffer);  62 if (code != CURLE_OK) {  63 return false;  64  }  65 //设置超时时间 防止一直等待  66 code = curl_easy_setopt(handle, CURLOPT_TIMEOUT, HSBaseHttp::GetInstance()->GetTimeoutForRead());  67 if (code != CURLE_OK) {  68 return false;  69  }  70 code = curl_easy_setopt(handle, CURLOPT_CONNECTTIMEOUT, HSBaseHttp::GetInstance()->GetTimeoutForConnect());  71 if (code != CURLE_OK) {  72 return false;  73  }  74  75 return true;  76 }  77  78 //Post 模式设置  79 int ProcessPostTask(HSHttpRequest *request, write_callback callback, void *stream, int32_t *responseCode)  80 {  81 CURLcode code = CURL_LAST;  82 CURL *curl = curl_easy_init();  83  84 do {  85 if (!ConfigureCURL(curl)) {  86 break;  87  }  88  89 code = curl_easy_setopt(curl, CURLOPT_URL, request->GetUrl());  90 if (code != CURLE_OK) {  91 break;  92  }  93 code = curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, callback);  94 if (code != CURLE_OK) {  95 break;  96  }  97 code = curl_easy_setopt(curl, CURLOPT_WRITEDATA, stream);  98 if (code != CURLE_OK) {  99 break; 100  } 101 code = curl_easy_setopt(curl, CURLOPT_POST, 1); 102 if (code != CURLE_OK) { 103 break; 104  } 105 code = curl_easy_setopt(curl, CURLOPT_POSTFIELDS, request->GetRequestData()); 106 if (code != CURLE_OK) { 107 break; 108  } 109 code = curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, request->GetRequestDataSize()); 110 if (code != CURLE_OK) { 111 break; 112  } 113 code = curl_easy_perform(curl); 114 if (code != CURLE_OK) { 115 break; 116  } 117 118 code = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, responseCode); 119 if (code != CURLE_OK || *responseCode != 200) { 120 code = CURLE_HTTP_RETURNED_ERROR; 121  } 122 } while (0); 123 if (curl) { 124  curl_easy_cleanup(curl); 125  } 126 127 return (code == CURLE_OK ? 0 : 1); 128 } 129 130 //Get模式设置 131 int ProcessGetTask(HSHttpRequest *request, write_callback callback, void *stream, int *responseCode) 132 { 133 CURLcode code = CURL_LAST; 134 CURL *curl = curl_easy_init(); 135 136 do { 137 if (!ConfigureCURL(curl)) 138  { 139 break; 140  } 141 142 code = curl_easy_setopt(curl, CURLOPT_URL, request->GetUrl()); 143 if (code != CURLE_OK) 144  { 145 break; 146  } 147 148 code = curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, callback); 149 if (code != CURLE_OK) 150  { 151 break; 152  } 153 154 code = curl_easy_setopt(curl, CURLOPT_WRITEDATA, stream); 155 if (code != CURLE_OK) 156  { 157 break; 158  } 159 160 code = curl_easy_perform(curl); 161 if (code != CURLE_OK) 162  { 163 break; 164  } 165 166 code = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, responseCode); 167 if (code != CURLE_OK || *responseCode != 200) 168  { 169 code = CURLE_HTTP_RETURNED_ERROR; 170  } 171 } while (0); 172 173 if (curl) { 174  curl_easy_cleanup(curl); 175  } 176 177 return (code == CURLE_OK ? 0 : 1); 178 } 179 180 181 static void* NetworkThread(void *data) 182 { 183 HSHttpRequest *request = NULL; 184 185 while (true) 186  { 187 // Wait for http request tasks from main thread 188 int semWaitRet = sem_wait(s_pSem); 189 if (semWaitRet < 0) { 190 CCLog("HSBaseHttp: HttpRequest async thread semaphore error: %s\n", strerror(errno)); 191 break; 192  } 193 194 if (need_quit) 195  { 196 break; 197  } 198 199 // step 1: send http request if the requestQueue isn't empty 200 request = NULL; 201 202 pthread_mutex_lock(&s_requestQueueMutex); //Get request task from queue 203 if (0 != s_requestQueue->count()) 204  { 205 request = dynamic_cast<HSHttpRequest*>(s_requestQueue->objectAtIndex(0)); 206 s_requestQueue->removeObjectAtIndex(0); 207 // request's refcount = 1 here 208  } 209 pthread_mutex_unlock(&s_requestQueueMutex); 210 211 if (NULL == request) 212  { 213 continue; 214  } 215 216 // step 2: libcurl sync access 217 218 // Create a HttpResponse object, the default setting is http access failed 219 HSHttpResponse *response = new HSHttpResponse(request); 220 221 // request's refcount = 2 here, it's retained by HttpRespose constructor 222 request->release(); 223 // ok, refcount = 1 now, only HttpResponse hold it. 224 225 int responseCode = -1; 226 int retValue = 0; 227 228 // Process the request -> get response packet 229 switch (request->GetRequestType()) 230  { 231 case HSHttpRequest::HTTP_MODE_GET: // HTTP GET 232 retValue = ProcessGetTask(request, writeData, response->GetResponseData(), &responseCode); 233 break; 234 235 case HSHttpRequest::HTTP_MODE_POST: // HTTP POST 236 retValue = ProcessPostTask(request, writeData, response->GetResponseData(), &responseCode); 237 break; 238 239 default: 240 CCAssert(true, "CCHttpClient: unkown request type, only GET and POSt are supported"); 241 break; 242  } 243 244 // write data to HttpResponse 245 response->SetResponseCode(responseCode); 246 247 if (retValue != 0) 248  { 249 response->SetSucceed(false); 250 response->SetErrorBuffer(s_errorBuffer); 251  } 252 else 253  { 254 response->SetSucceed(true); 255  } 256 257 258 // add response packet into queue 259 pthread_mutex_lock(&s_responseQueueMutex); 260 s_responseQueue->addObject(response); 261 pthread_mutex_unlock(&s_responseQueueMutex); 262 263 // resume dispatcher selector 264 CCScheduler::sharedScheduler()->resumeTarget(HSBaseHttp::GetInstance()); 265  } 266 267 // cleanup: if worker thread received quit signal, clean up un-completed request queue 268 pthread_mutex_lock(&s_requestQueueMutex); 269 s_requestQueue->removeAllObjects(); 270 pthread_mutex_unlock(&s_requestQueueMutex); 271 s_asyncRequestCount -= s_requestQueue->count(); 272 273 if (s_pSem != NULL) { 274 #if CC_ASYNC_HTTPREQUEST_USE_NAMED_SEMAPHORE 275  sem_unlink(CC_ASYNC_HTTPREQUEST_SEMAPHORE); 276  sem_close(s_pSem); 277 #else 278  sem_destroy(s_pSem); 279 #endif 280 281 s_pSem = NULL; 282 283 pthread_mutex_destroy(&s_requestQueueMutex); 284 pthread_mutex_destroy(&s_responseQueueMutex); 285 286 s_requestQueue->release(); 287 s_responseQueue->release(); 288  } 289 290  pthread_exit(NULL); 291 292 return 0; 293 } 294 295 HSBaseHttp::HSBaseHttp() 296 { 297 this->iTimeoutForConnect = 30; 298 this->iTimeoutForRead = 60; 299 CCScheduler::sharedScheduler()->scheduleSelector(schedule_selector(HSBaseHttp::DispatchResponseCallbacks), this, 0, false); 300 CCScheduler::sharedScheduler()->pauseTarget(this); 301 } 302 303 HSBaseHttp::~HSBaseHttp() 304 { 305 need_quit = true; 306 307 if (s_pSem != NULL) 308  { 309  sem_post(s_pSem); 310  } 311 CCScheduler::sharedScheduler()->unscheduleSelector(schedule_selector(HSBaseHttp::DispatchResponseCallbacks), this); 312 } 313 314 HSBaseHttp* HSBaseHttp::GetInstance() 315 { 316 if (s_pBaseHttp == NULL) 317  { 318 s_pBaseHttp = new HSBaseHttp(); 319  } 320 321 return s_pBaseHttp; 322 } 323 324 void HSBaseHttp::DestroyInstance() 325 { 326 CCScheduler::sharedScheduler()->unscheduleSelector(schedule_selector(HSBaseHttp::DispatchResponseCallbacks),HSBaseHttp::GetInstance()); 327  CC_SAFE_RELEASE_NULL(s_pBaseHttp); 328 } 329 330 void HSBaseHttp::DispatchResponseCallbacks(float delta) 331 { 332 HSHttpResponse* response = NULL; 333 334 pthread_mutex_lock(&s_responseQueueMutex); 335 if (s_responseQueue->count()) 336  { 337 response = dynamic_cast<HSHttpResponse*>(s_responseQueue->objectAtIndex(0)); 338 s_responseQueue->removeObjectAtIndex(0); 339  } 340 pthread_mutex_unlock(&s_responseQueueMutex); 341 342 if (response) 343  { 344 --s_asyncRequestCount; 345 346 HSHttpRequest* request = response->GetHttpRequest(); 347 SelectorProtocol* pTarget = request->GetTarget(); 348 SEL_CallFuncND pSelector = request->GetSelector(); 349 350 if (pTarget && pSelector) 351  { 352 (pTarget->*pSelector)((CCNode *)this, response); 353  } 354 355 response->release(); 356  } 357 358 if (0 == s_asyncRequestCount) 359  { 360 CCScheduler::sharedScheduler()->pauseTarget(this); 361  } 362 } 363 364 bool HSBaseHttp::LazyInitThreadSemphore() 365 { 366 if(s_pSem != NULL) 367 return false; 368 369 #if CC_ASYNC_HTTPREQUEST_USE_NAMED_SEMAPHORE 370 s_pSem = sem_open(CC_ASYNC_HTTPREQUEST_SEMAPHORE, O_CREAT, 0644, 0); 371 if (s_pSem == SEM_FAILED) { 372 CCLog("Open HttpRequest Semaphore failed"); 373 s_pSem = NULL; 374 return false; 375  } 376 #else 377 int semRet = sem_init(&s_sem, 0, 0); 378 if (semRet < 0) { 379 CCLog("Init HttpRequest Semaphore failed"); 380 return false; 381  } 382 383 s_pSem = &s_sem; 384 #endif 385 386 s_requestQueue = CCArray::array(); 387 s_requestQueue->init(); 388 s_requestQueue->retain(); 389 390 s_responseQueue = CCArray::array(); 391 s_responseQueue->init(); 392 s_responseQueue->retain(); 393 394 pthread_mutex_init(&s_requestQueueMutex, NULL); 395 pthread_mutex_init(&s_responseQueueMutex, NULL); 396 397 pthread_create(&s_networkThread, NULL, NetworkThread, NULL); 398  pthread_detach(s_networkThread); 399 400 need_quit = false; 401 402 return true; 403 404 } 405 406 void HSBaseHttp::Send(HSHttpRequest* request) 407 { 408 if (!LazyInitThreadSemphore() || !request) 409  { 410 return; 411  } 412 413 ++s_asyncRequestCount; 414 415 request->retain(); 416 417 pthread_mutex_lock(&s_requestQueueMutex); 418 s_requestQueue->addObject(request); 419 pthread_mutex_unlock(&s_requestQueueMutex); 420 421 // Notify thread start to work 422  sem_post(s_pSem); 423 } 424 425 void HSBaseHttp::SetTimeoutForConnect( int value ) 426 { 427 this->iTimeoutForConnect = value; 428 } 429 430 int HSBaseHttp::GetTimeoutForConnect() 431 { 432 return this->iTimeoutForConnect; 433 } 434 435 void HSBaseHttp::SetTimeoutForRead( int value ) 436 { 437 this->iTimeoutForRead = value; 438 } 439 440 int HSBaseHttp::GetTimeoutForRead() 441 { 442 return this->iTimeoutForRead; 443 }

 1 /********************************************************************  2  * Copyright(C) 2012 Ambition( All rights reserved. )  3  * Created: 2012/09/20 9:41  4  * File base: HSHttpRequest.h  5  * Author: Ambition  6  *  7  * Purpose: 请求消息发送和设置（不是发送的具体数据）  8 *********************************************************************/  9 #ifndef __HSHttpRequest_H__ 10 #define __HSHttpRequest_H__ 11 #pragma once 12 #include "cocos2d.h" 13 using namespace cocos2d; 14 15 class HSHttpRequest : public CCObject 16 { 17 public: 18 HSHttpRequest(void); 19 ~HSHttpRequest(void); 20 21 public: 22 typedef enum 23  { 24  HTTP_MODE_GET, 25  HTTP_MODE_POST, 26  HTTP_MODE_UNKOWN, 27  }HttpRequestType; 28 29 protected: 30 SelectorProtocol* pTarget; 31 SEL_CallFuncND pSelector; //回调选择器 32 HttpRequestType requestType; //请求类型 33 string strUrl; 34 vector<char> vRequestData; 35 string tag; 36 void* pUserData; //用语在请求前添加的标志 例(Ambition:xxxxxx) 37 38 public: 39 SelectorProtocol* GetTarget(); 40  SEL_CallFuncND GetSelector(); 41 void SetRequestType(HttpRequestType type); 42  HttpRequestType GetRequestType(); 43 44 void SetUrl(const char* url); 45 const char* GetUrl(); 46 47 void SetRequestData(const char* buffer, unsigned int len); 48 char* GetRequestData(); 49 50 int GetRequestDataSize(); 51 52 void SetResponseCallback(SelectorProtocol* pTarget, cocos2d::SEL_CallFuncND pSelector); 53 54 void SetTag(const char* tag); 55 const char* GetTag(); 56 57 void SetUserData(void* pUserData); 58 void* GetUserData(); 59 }; 60 61 62 #endif // __HSHttpRequest_H__

 1 #include "HSHttpRequest.h"  2  3 HSHttpRequest::HSHttpRequest(void)  4 {  5 this->requestType = HTTP_MODE_UNKOWN;  6 this->vRequestData.clear();  7 this->tag.clear();  8 this->pTarget = NULL;  9 this->pSelector = NULL; 10 this->pUserData = NULL; 11 } 12 13 HSHttpRequest::~HSHttpRequest(void) 14 { 15 } 16 17 SelectorProtocol* HSHttpRequest::GetTarget() 18 { 19 return this->pTarget; 20 } 21 22 cocos2d::SEL_CallFuncND HSHttpRequest::GetSelector() 23 { 24 return pSelector; 25 } 26 27 HSHttpRequest::HttpRequestType HSHttpRequest::GetRequestType() 28 { 29 return this->requestType; 30 } 31 32 void HSHttpRequest::SetUrl( const char* url ) 33 { 34 strUrl = url; 35 } 36 37 const char* HSHttpRequest::GetUrl() 38 { 39 return strUrl.c_str(); 40 } 41 42 void HSHttpRequest::SetRequestData( const char* buffer, unsigned int len ) 43 { 44 vRequestData.assign(buffer, buffer + len); 45 } 46 47 char* HSHttpRequest::GetRequestData() 48 { 49 return &(vRequestData.front()); 50 } 51 52 int HSHttpRequest::GetRequestDataSize() 53 { 54 return vRequestData.size(); 55 } 56 57 void HSHttpRequest::SetRequestType( HttpRequestType type ) 58 { 59 requestType = type; 60 } 61 62 void HSHttpRequest::SetResponseCallback( SelectorProtocol* pTarget, cocos2d::SEL_CallFuncND pSelector ) 63 { 64 this->pTarget = pTarget; 65 this->pSelector = pSelector; 66 67 if (this->pTarget) 68  { 69 //this->pTarget->retain(); 70 //如果有问题以后修改 71  } 72 } 73 74 void HSHttpRequest::SetTag( const char* tag ) 75 { 76 this->tag = tag; 77 } 78 79 const char* HSHttpRequest::GetTag() 80 { 81 return this->tag.c_str(); 82 } 83 84 void HSHttpRequest::SetUserData( void* pUserData ) 85 { 86 this->pUserData = pUserData; 87 } 88 89 void* HSHttpRequest::GetUserData() 90 { 91 return this->pUserData; 92 }

 1 /********************************************************************  2  * Copyright(C) 2012 Ambition( All rights reserved. )  3  * Created: 2012/09/20 9:42  4  * File base: HSHttpResponse.h  5  * Author: Ambition  6  *  7  * Purpose: 响应包含返回的具体数据，但是没有解析  8 *********************************************************************/  9 #ifndef __HSHttpResponse_H__ 10 #define __HSHttpResponse_H__ 11 #pragma once 12 #include "HSHttpRequest.h" 13 14 15 class HSHttpResponse : public CCObject 16 { 17 public: 18 HSHttpResponse(HSHttpRequest* request); 19 virtual ~HSHttpResponse(void); 20 21 protected: 22 HSHttpRequest* pHttpRequest; //对应的请求指针 23 bool isSucceed; //是否成功 24 vector<char> vResponseData; 25 int iResponseCode; //响应代码 26 string strErrorBuffer; //错误信息缓存 27 28 public: 29 HSHttpRequest* GetHttpRequest(); 30 31 void SetResponseData(std::vector<char>* data); 32 vector<char>* GetResponseData(); 33 34 void SetResponseCode(int value); 35 int GetResponseCode(); 36 37 void SetSucceed(bool value); 38 bool GetSucceed(); 39 40 void SetErrorBuffer(const char* value); 41 const char* GetErrorBuffer(); 42 43 }; 44 45 #endif // __HSHttpResponse_H__

 1 #include "HSHttpResponse.h"  2  3 HSHttpResponse::HSHttpResponse(HSHttpRequest* request)  4 {  5 this->pHttpRequest = request;  6 if (this->pHttpRequest)  7  {  8 this->pHttpRequest->retain();  9  } 10 this->isSucceed = false; 11 this->vResponseData.clear(); 12 this->strErrorBuffer.clear(); 13 } 14 15 HSHttpResponse::~HSHttpResponse(void) 16 { 17 if (this->pHttpRequest) 18  { 19 this->pHttpRequest->release(); 20  } 21 } 22 23 HSHttpRequest* HSHttpResponse::GetHttpRequest() 24 { 25 return this->pHttpRequest; 26 } 27 28 void HSHttpResponse::SetResponseData( std::vector<char>* data ) 29 { 30 vResponseData = *data; 31 } 32 33 vector<char>* HSHttpResponse::GetResponseData() 34 { 35 return &vResponseData; 36 } 37 38 void HSHttpResponse::SetResponseCode( int value ) 39 { 40 iResponseCode = value; 41 } 42 43 int HSHttpResponse::GetResponseCode() 44 { 45 return this->iResponseCode; 46 } 47 48 void HSHttpResponse::SetSucceed( bool value ) 49 { 50 isSucceed = value; 51 } 52 53 bool HSHttpResponse::GetSucceed() 54 { 55 return this->isSucceed; 56 } 57 58 void HSHttpResponse::SetErrorBuffer( const char* value ) 59 { 60  strErrorBuffer.clear(); 61  strErrorBuffer.assign(value); 62 } 63 64 const char* HSHttpResponse::GetErrorBuffer() 65 { 66 return strErrorBuffer.c_str(); 67 }

 1 HSHttpRequest* request = new HSHttpRequest();  2 request->SetUrl("http://220.194.62.22/wapgame/a.jsp");  3 request->SetRequestType(HSHttpRequest::HTTP_MODE_POST);  4 request->SetResponseCallback(this, callfuncND_selector(HelloWorld::onHttpRequestCompleted));  5  6 // write the post data  7 const char* postData = "visitor=cocos2d&TestSuite=Extensions Test/NetowrkTest";  8 request->SetRequestData(postData, strlen(postData));  9 request->SetTag("POST test"); 10 HSBaseHttp::GetInstance()->Send(request); 11 request->release();