在iPhone应用程序中,我从现有的本机UDP套接字创建一个CFSocket对象,并在套接字收到一些数据时设置数据回调。然后我将它添加到我的主程序循环中:
parseInt(totalPrice / 4 * 0.3 * 100) + '%'
我每隔5 mS从一个单独的Mac服务器应用程序通过WiFi发送1024字节的数据报,并通过我的 getSocketDataCallBack 例程在我的iPhone上接收它们。
我希望每5 mS调用 getSocketDataCallBack (以匹配从Mac发送的数据报的周期),这种情况大多数时间都会发生。但是,呼叫通常会延迟10秒或100秒的mS。之后,我得到一个快速的回调序列(mS的分数)来检索在该延迟上堆积的多个数据报。
由于iOS显然保留了延迟的数据报,
有没有办法从系统中获取所有延迟的数据报 一次而不是一遍又一遍地调用 getSocketDataCallBack 快速连续?
[我确实查询了回调ala中可用的字节数:
//Set socket descriptor field
cbData.s = udpSocket.getSocketDescriptor();
CFSocketContext udpSocketContext;
memset(&udpSocketContext, 0, sizeof(udpSocketContext));
udpSocketContext.info = &cbData;
cbData.socketRef = CFSocketCreateWithNative(NULL, cbData.s, kCFSocketDataCallBack, &getSocketDataCallBack, &udpSocketContext);
cbData.runLoopSourceRef = CFSocketCreateRunLoopSource( NULL, cbData.socketRef, 0);
CFRunLoopAddSource(CFRunLoopGetMain(), cbData.runLoopSourceRef, kCFRunLoopCommonModes);
但'numBytesReceived'始终报告为1024。]
答案 0 :(得分:1)
我正在使用套接字回调进行与UNIX套接字的进程间通信(实际上是线程间通信)。我们如何使用套接字与TCP / UDP相同。
下面的代码用c / obj-c编写并使用posix线程。将它翻译成Swift / NSThread并不困难。
请注意,下面的程序可用作服务器端,这意味着程序会创建客户端连接的套接字。一旦客户端连接到套接字,系统将自动接受连接并分配 另一个要读/写的文件描述符。套接字回调反映了这两个阶段的操作。最初我们创建套接字,然后我们添加为运行循环源,以便系统可以在客户端尝试连接时调用回调。系统接受,然后分配并告知回叫 用于与客户端读/写的文件描述符。然后,我们从读/写fd创建另一个运行循环源并添加到运行循环。当rx / tx数据准备就绪时,将调用第二个回调。
MAIN THREAD:
主线程创建UNIX套接字和工作线程。套接字fd作为工作线程的参数传递。
#import <stdio.h>
#import <string.h>
#import <stdlib.h>
#import <unistd.h>
#import <pthread.h>
#import <sys/socket.h>
#import <sys/un.h>
#import <sys/stat.h>
#import <sys/types.h>
#import <UIKit/UIKit.h>
#import <Foundation/Foundation.h>
int setup(const char *ipcNode) {
int sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
if (sockfd == -1) {
return -1;
}
struct sockaddr_un sa = {0};
sa.sun_len = sizeof(sa);
sa.sun_family = AF_UNIX;
strcpy(sa.sun_path, ipcNode);
remove(sa.sun_path);
if (bind(sockfd, (struct sockaddr*)&sa, sizeof(struct sockaddr_un)) == -1) {
close(sockfd);
return -1;
}
// start up worker thread
pthread_attr_t at;
pthread_attr_init(&at);
pthread_attr_setdetachstate(&at, PTHREAD_CREATE_DETACHED);
pthread_t th;
pthread_create(&th, &at, workerThread, (void *)(long)(sockfd));
return 1;
}
WORKER THREAD:
该程序用作服务器。因此,它等待客户端连接(通过connect())。一旦连接,系统自动调用accept()并分配读/写fd与客户端通信。这个fd被传递给accept-call back例程socketDataCallback()。然后我们用read / write fd。
创建另一个回调clientDataCallback()// worker thread
//
void *workerThread(void *tprm) {
int sockfd = (int)tprm;
int retval = listen(sockfd, 1); // mark as "server" side. here, accept only 1 connection request at a time
if (retval != 0) {
return NULL;
}
// create CFSocket and register it as data source.
CFSocketRef socket = CFSocketCreateWithNative(kCFAllocatorDefault, sockfd, kCFSocketAcceptCallBack, socketDataCallback, nil);
// don't close native fd on CFSocketInvalidate
CFSocketSetSocketFlags(socket, CFSocketGetSocketFlags(socket) & ~kCFSocketCloseOnInvalidate);
// create run loop source
CFRunLoopSourceRef socketRunLoop = CFSocketCreateRunLoopSource(kCFAllocatorDefault, socket, 0);
// add to run loop
CFRunLoopAddSource(CFRunLoopGetCurrent(), socketRunLoop, kCFRunLoopCommonModes);
CFRelease(socketRunLoop);
CFRelease(socket);
CFRunLoopRun();
// not return here untill run loop stops
close(sockfd);
return NULL;
}
// socket connection w/ client side. create another data source and add to run-loop
//
void socketDataCallback(CFSocketRef s, CFSocketCallBackType callbackType, CFDataRef address, const void *data, void *info) {
CFSocketContext socketContext;
memset(&socketContext, 0, sizeof(CFSocketContext));
int clientfd = *((int *)data); // get file descriptor (fd)
socketContext.info = (void *)((long)clientfd); // set fd at info of socketContext
// create CFSocket for tx/rx w/ connected client
CFSocketRef socket = CFSocketCreateWithNative(kCFAllocatorDefault, clientfd, kCFSocketReadCallBack | kCFSocketWriteCallBack, clientDataCallback, &socketContext);
CFSocketDisableCallBacks(socket, kCFSocketWriteCallBack);
CFRunLoopSourceRef socketRunLoop = CFSocketCreateRunLoopSource(kCFAllocatorDefault, socket, 0);
CFRunLoopAddSource(CFRunLoopGetCurrent(), socketRunLoop, kCFRunLoopCommonModes);
CFRelease(socket);
CFRelease(socketRunLoop);
}
// data to/from client
//
void clientDataCallback(CFSocketRef s, CFSocketCallBackType callbackType, CFDataRef address, const void *data, void *info) {
if (callbackType & kCFSocketWriteCallBack) {
// your own tx data prcess here
// txDataCallback(s, callbackType, address, data, info);
}
if (!(callbackType & kCFSocketReadCallBack)) return;
// extract fd
int fd = (int)((long)info);
// read data, and do some work
uint8_t rxdata[1024];
size_t nr = read(fd, rxdata, 1024);
if (!nr) {
// socket closed
handleSocketClosed(s);
return;
}
// your own rx process here
}
// socket closed
//
void handleSocketClosed(CFSocketRef s) {
// any clean up process here, then
CFSocketInvalidate(s);
// stop run loop if necessary
// CFRunLoopStop(CFRunLoopGetCurrent());
}
如果您在客户端工作,事情会变得容易一些。你通过connect()调用得到一个读/写fd。然后创建CFSockeRef并使用fd。
添加到run-loop希望这有帮助。
编辑:如何使用POSIX select()等待。在工作线程中使用POSIX select()等待比socket回调更简单。如果您在客户端,那么:
int sockfd = socket(...);
bind(sockfd, ...)
connect(sockfd, ...);
while (1) {
int nfds = sockfd+1;
fd_set rfds;
FD_ZERO(&rfds);
FD_SET(sockfd, &rfds);
int retval = select(nfds, &rfds, NULL, NULL, NULL);
if (retval == -1) break;
if (retval > 0) {
uint8_t rxdata[1024];
size_t nr = read(sockfd, rxdata, 1024);
if (!nr) {
// socket closed.
break;
}
// do your rx process here
}
}
在工作线程上运行上面的代码。