void NetImpl::do_request(json_t* __msg)
{
// compose request
const char* __route = "connector.entryHandler.entry";
pc_request_t* __request = pc_request_new();
pc_request(client_, __request, __route, __msg, on_request_cb);
}
void login(const char *username, const char *Channel) {
const char *ip = GATE_HOST;
int port = GATE_PORT;
user = username;
channel = Channel;
pc_client_t *client = pc_client_new();
// add some event callback.
pc_add_listener(client, PC_EVENT_DISCONNECT, on_gate_close);
struct sockaddr_in address;
memset(&address, 0, sizeof(struct sockaddr_in));
address.sin_family = AF_INET;
address.sin_port = htons(port);
address.sin_addr.s_addr = inet_addr(ip);
printf("try to connect to gate server %s %d\n", ip, port);
// try to connect to server.
if (pc_client_connect(client, &address)) {
printf("fail to connect gate server.\n");
pc_client_destroy(client);
return;
}
const char *route = "gate.gateHandler.queryEntry";
json_t *msg = json_object();
json_t *str = json_string(username);
json_object_set_new(msg, "uid", str);
pc_request_t *request = pc_request_new();
pc_request(client, request, route, msg, on_request_gate_cb);
}
int CCPomelo::request(const char*route, json_t *msg, std::function<void(Node*, void*)> f)
{
pc_request_t *req = pc_request_new();
request_content[req] = f;
pc_request(client,req, route, msg, cc_pomelo_on_request_cb);
return 0;
}
void do_request(pc_client_t *client) {
const char *route = "connector.helloHandler.hi";
json_t *msg = json_object();
json_object_set(msg, "msg", json_string("hi~"));
pc_request_t *request = pc_request_new();
pc_request(client, request, route, msg, on_request_cb);
}
int CCPomelo::request(const char*route,json_t *msg,CCObject* pTarget, SEL_CallFuncND pSelector){
pc_request_t *req = pc_request_new();
CCPomeloContent_ *content = new CCPomeloContent_;
content->pTarget = pTarget;
content->pSelector = pSelector;
request_content[req] = content;
return pc_request(client,req, route, json_deep_copy(msg), cc_pomelo_on_request_cb);
}
void do_request(pc_client_t* client)
{
const char* route = "connector.entryHandler.entry";
json_t* msg = json_object();
json_t* str = json_string("zhuzhuowei");
json_object_set(msg, "msg", str);
json_decref(str);
pc_request_t* request = pc_request_new();
pc_request(client, request, route, msg, on_request_cb);
}
void msg_send(const char *message, const char *rid, const char *from, const char *target) {
const char *route = "chat.chatHandler.send";
json_t *msg = json_object();
json_t *str = json_string(message);
json_object_set_new(msg, "content", str);
json_object_set_new(msg, "rid", json_string(rid));
json_object_set_new(msg, "from", json_string(from));
json_object_set_new(msg, "target", json_string(target));
pc_request_t *request = pc_request_new();
pc_request(pomelo_client, request, route, msg, on_send_cb);
}
void on_request_gate_cb(pc_request_t *req, int status, json_t *resp) {
if (status == -1) {
printf("Fail to send request to server.\n");
} else if (status == 0) {
connectorHost = json_string_value(json_object_get(resp, "host"));
connectorPort = json_number_value(json_object_get(resp, "port"));
pc_client_t *client = pc_client_new();
struct sockaddr_in address;
memset(&address, 0, sizeof(struct sockaddr_in));
address.sin_family = AF_INET;
address.sin_port = htons(connectorPort);
address.sin_addr.s_addr = inet_addr(connectorHost);
// add pomelo events listener
pc_add_listener(client, "disconnect", on_disconnect);
pc_add_listener(client, "onChat", on_chat);
pc_add_listener(client, "onAdd", on_add);
pc_add_listener(client, "onLeave", on_leave);
printf("try to connect to connector server %s %d\n", connectorHost, connectorPort);
// try to connect to server.
if (pc_client_connect(client, &address)) {
printf("fail to connect connector server.\n");
pc_client_destroy(client);
return ;
}
const char *route = "connector.entryHandler.enter";
json_t *msg = json_object();
json_t *str = json_string(user);
json_t *channel_str = json_string(channel);
json_object_set_new(msg, "username", str);
json_object_set_new(msg, "rid", channel_str);
pc_request_t *request = pc_request_new();
printf("%s %s\n", user, channel);
pc_request(client, request, route, msg, on_request_connector_cb);
}
// release relative resource with pc_request_t
json_t *pc_msg = req->msg;
pc_client_t *pc_client = req->client;
json_decref(pc_msg);
pc_request_destroy(req);
pc_client_stop(pc_client);
}
int PomeloSocket::sendMsg(const char* route, json_t* json)
{
if(state != CONNECTED_OK){
log("socket has disconnected......");
return -1;
}
Loading::getInstance()->show();
pc_request_t *request = pc_request_new();
void (*request_cb)(pc_request_t *req, int status, json_t *resp )= &PomeloSocket::requstCallback;
int ret=pc_request(client, request, route, json, request_cb);
log("发送数据:route:%s,msg:%s",route,json_dumps(json,0));
return ret;
}
void Net::pomeloRequest(const char *route, const char *str)
{
pc_request_t *request = pc_request_new();
json_error_t error;
json_t *msg = json_loads(str, JSON_DECODE_ANY, &error);
if(!msg)
{
pushMsg(std::string(route), std::string("{\"error\":true}"));
pushMsg(std::string(PC_EVENT_REQUESTERR), std::string(""));
}
else
{
pc_request(client, request, route, msg, &Net::pomeloRequestCallBack);
//json_decref(msg);
}
}
void NetImpl::do_request_test()
{
// compose request
const char* __route = "connector.entryHandler.hi";
json_t* __msg = json_object();
json_t* __str_hi = json_string("hi~");
json_t* __str_your_name = json_string("machine");
json_object_set(__msg, "context1", __str_hi);
json_object_set(__msg, "context2", __str_your_name);
// decref for json object
json_decref(__str_hi);
json_decref(__str_your_name);
pc_request_t* __request = pc_request_new();
pc_request(client_, __request, __route, __msg, on_request_cb);
}
void Login::doLogin()
{
const char *ip = GATE_HOST;
int port = GATE_PORT;
pc_client_t *client = pc_client_new();
struct sockaddr_in address;
memset(&address, 0, sizeof(struct sockaddr_in));
address.sin_family = AF_INET;
address.sin_port = htons(port);
address.sin_addr.s_addr = inet_addr(ip);
// try to connect to server.
if(pc_client_connect(client, &address)) {
CCLOG("fail to connect server.\n");
pc_client_destroy(client);
return ;
}
// add some event callback.
pc_add_listener(client, PC_EVENT_DISCONNECT, on_close);
const char *route = "gate.gateHandler.queryEntry";
json_t *msg = json_object();
json_t *str = json_string(username.c_str());
json_object_set(msg, "uid", str);
// decref for json object
json_decref(str);
pc_request_t *request = pc_request_new();
void (*on_request_gate_cb)(pc_request_t *req, int status, json_t *resp) = &Login::requstGateCallback;
pc_request(client, request, route, msg, on_request_gate_cb);
// main thread has nothing to do and wait until child thread return.
pc_client_join(client);
// release the client
pc_client_destroy(client);
}
void Login::requstGateCallback(pc_request_t *req, int status, json_t *resp)
{
if(status == -1) {
CCLOG("Fail to send request to server.\n");
} else if(status == 0) {
connectorHost = json_string_value(json_object_get(resp, "host"));
connectorPort = json_number_value(json_object_get(resp, "port"));
CCLOG("%s %d", connectorHost,connectorPort);
pc_client_t *client = pc_client_new();
struct sockaddr_in address;
memset(&address, 0, sizeof(struct sockaddr_in));
address.sin_family = AF_INET;
address.sin_port = htons(connectorPort);
address.sin_addr.s_addr = inet_addr(connectorHost);
// add pomelo events listener
void (*on_disconnect)(pc_client_t *client, const char *event, void *data) = &Login::onDisconnectCallback;
void (*on_chat)(pc_client_t *client, const char *event, void *data) = &Login::onChatCallback;
void (*on_add)(pc_client_t *client, const char *event, void *data) = &Login::onAddCallback;
void (*on_leave)(pc_client_t *client, const char *event, void *data) = &Login::onLeaveCallback;
pc_add_listener(client, "disconnect", on_disconnect);
pc_add_listener(client, "onChat", on_chat);
pc_add_listener(client, "onAdd", on_add);
pc_add_listener(client, "onLeave", on_leave);
// try to connect to server.
if(pc_client_connect(client, &address)) {
CCLOG("fail to connect server.\n");
pc_client_destroy(client);
return ;
}
const char *route = "connector.entryHandler.enter";
json_t *msg = json_object();
json_t *str = json_string(username.c_str());
json_t *channel_str = json_string(channel.c_str());
json_object_set(msg, "username", str);
json_object_set(msg, "rid", channel_str);
// decref for json object
json_decref(str);
json_decref(channel_str);
pc_request_t *request = pc_request_new();
void (*connect_cb)(pc_request_t *req, int status, json_t *resp )= &Login::requstConnectorCallback;
pc_request(client, request, route, msg, connect_cb);
/*
char *json_str = json_dumps(resp, 0);
if(json_str != NULL) {
CCLOG("server response: %s %d\n", connectorHost, connectorPort);
free(json_str);
}
*/
}
// release relative resource with pc_request_t
json_t *pc_msg = req->msg;
pc_client_t *pc_client = req->client;
json_decref(pc_msg);
pc_request_destroy(req);
pc_client_stop(pc_client);
}
