Method recvEvent

libapp2sys/src/main/cpp/server.h:43–112

    std::map<int, RecvCache *> mapRecvCache;

    int recvEvent(Event event, int fd, int pid, uid_t uid, const char *path, uint8_t *recvData, int recvDataLen) {
        if (event == EVENT_ERROR) {
            perr("LocalSocketServer EVENT_ERROR: uid:%d path:%s", uid, path);
            return 0;
        }
        if (event == EVENT_CONNECT) {
            pwrn("Connect By uid:%d  fd:%d" , uid, fd);
            return 0;
        }

        if (event == EVENT_DATA) {

            uint8_t *readPtr = recvData;
            while (const uint32_t readLeft = (recvDataLen - (readPtr - recvData))) {
                if (!mapRecvCache.count(fd)) {
                    mapRecvCache[fd] = new RecvCache();
                }
                RecvCache * const recvCache = mapRecvCache[fd];

                if (recvCache->reqHeaderOffset < sizeof(AMCReqHeader)) {  // fill header

                    const int shouldRead = MIN(sizeof(AMCReqHeader) - recvCache->reqHeaderOffset, readLeft );
                    memcpy(recvCache->reqHeaderBuf + recvCache->reqHeaderOffset, readPtr, shouldRead);

                    readPtr += shouldRead;
                    recvCache->reqHeaderOffset += shouldRead;

                    if (recvCache->reqHeaderOffset < sizeof(AMCReqHeader)) { // wait next event
                        break;
                    }
                }
                AMCReqHeader *pHeader = (AMCReqHeader *)(recvCache->reqHeaderBuf);
                if (pHeader->begin != HEADER_BEGIN) {
                    perr("Check Header BEGIN failed:0x%x server:0x%x", pHeader->begin, HEADER_BEGIN);
                    delete recvCache;
                    mapRecvCache.erase(fd);
                    return -1;
                }

                if (recvCache->reqPayloadOffset < pHeader->bodylen) {
                    if (recvCache->reqPayload == NULL) {
                        recvCache->reqPayload = new uint8_t[pHeader->bodylen];
                    }

                    const int shouldRead = std::min(pHeader->bodylen - recvCache->reqPayloadOffset, readLeft );
                    memcpy(recvCache->reqPayload + recvCache->reqPayloadOffset, readPtr, shouldRead);

                    readPtr += shouldRead;
                    recvCache->reqPayloadOffset += shouldRead;

                    if (recvCache->reqPayloadOffset < pHeader->bodylen) { // wait next event
                        break;
                    }
                }

                ServerDataWorker<int> *pp = new ServerDataWorker<int>();
                int64_t requestId = pp->processReceive(uid, &fd, pHeader, recvCache->reqPayload, pHeader->bodylen, inst);
                if (requestId < 0) {