归拢公共类

app/src/main/cpp/common/coomon_utils.h

@@ -0,0 +1,17 @@
+//
+// Created by 叶亮 on 2019/7/16.
+//
+
+#ifndef ANDROIDRECORDER_COOMON_UTILS_H
+#define ANDROIDRECORDER_COOMON_UTILS_H
+
+#include <sys/time.h>
+
+static inline long getCurrentTime()
+{
+    struct timeval tv;
+    gettimeofday(&tv, NULL);
+    return tv.tv_sec * 1000 + tv.tv_usec/1000;
+}
+
+#endif //ANDROIDRECORDER_COOMON_UTILS_H

app/src/main/cpp/common/message_handler.cpp

@@ -0,0 +1,21 @@
+//
+// Created by 叶亮 on 2019/7/15.
+//
+#include "message_handler.h"
+
+Handler::Handler(MessageQueue *queue) {
+    this->mQueue = queue;
+}
+
+Handler::~Handler() {
+
+}
+
+int Handler::postMessage(Message *msg) {
+    msg->handler = this;
+    return mQueue->enqueueMessage(msg);
+}
+
+int Handler::getQueueSize() {
+    return mQueue->size();
+}

app/src/main/cpp/common/message_handler.h

@@ -0,0 +1,26 @@
+//
+// Created by 叶亮 on 2019/7/15.
+//
+
+#ifndef ANDROIDRECORDER_HANDLER_H
+#define ANDROIDRECORDER_HANDLER_H
+
+#include "message_queue.h"
+class Message;
+class MessageQueue;
+
+class Handler{
+private:
+    MessageQueue* mQueue;
+
+public:
+    Handler(MessageQueue* mQueue);
+    ~Handler();
+
+    int postMessage(Message* msg);
+    int getQueueSize();
+    virtual void handleMessage(Message* msg){};
+
+};
+
+#endif //ANDROIDRECORDER_HANDLER_H

app/src/main/cpp/common/message_queue.cpp

@@ -0,0 +1,157 @@
+//
+// Created by 叶亮 on 2019/7/15.
+//
+
+#include "message_queue.h"
+#include "message_handler.h"
+
+MessageQueue::MessageQueue() {
+    init();
+}
+
+MessageQueue::MessageQueue(const char* queueNameParam){
+    init();
+    queueName = queueNameParam;
+}
+
+void MessageQueue::init(){
+    pthread_mutex_init(&mLock, NULL);
+    pthread_cond_init(&mCondition, NULL);
+    mNbPackets = 0;
+    mFirst = NULL;
+    mLast = NULL;
+    mAbortRequest = false;
+}
+
+MessageQueue::~MessageQueue() {
+    flush();
+    pthread_mutex_destroy(&mLock);
+    pthread_cond_destroy(&mCondition);
+}
+
+int MessageQueue::size() {
+    pthread_mutex_destroy(&mLock);
+    int size = mNbPackets;
+    pthread_mutex_unlock(&mLock);
+    return size;
+}
+
+void MessageQueue::flush() {
+    MessageNode *curNode, *nextNode;
+    Message *msg;
+    pthread_mutex_lock(&mLock);
+    for(curNode = mFirst; curNode != NULL; curNode = nextNode){
+        nextNode = curNode->next;
+        msg = curNode->msg;
+        if(NULL != msg){
+            delete msg;
+        }
+        delete curNode;
+        curNode = NULL;
+    }
+    mLast = NULL;
+    mFirst = NULL;
+    pthread_mutex_unlock(&mLock);
+}
+
+int MessageQueue::enqueueMessage(Message *msg) {
+    if(mAbortRequest){
+        delete msg;
+        return -1;
+    }
+
+    MessageNode *node = new MessageNode();
+    node->msg = msg;
+    node->next = NULL;
+
+    if(mLast == NULL){
+        mFirst = node;
+    }else{
+        mLast->next = node;
+    }
+    mLast = node;
+    mNbPackets++;
+    pthread_cond_signal(&mCondition);
+    pthread_mutex_unlock(&mLock);
+    return 0;
+}
+
+int MessageQueue::dequeueMessage(Message **msg, bool block) {
+    MessageNode *node;
+    int ret;
+    pthread_mutex_lock(&mLock);
+    for (;;) {
+        if (mAbortRequest) {
+            ret = -1;
+            break;
+        }
+        node = mFirst;
+        if (node) {
+            mFirst = node->next;
+            if (!mFirst)
+                mLast = NULL;
+            mNbPackets--;
+            *msg = node->msg;
+            delete node;
+            node = NULL;
+            ret = 1;
+            break;
+        } else if (!block) {
+            ret = 0;
+            break;
+        } else {
+            pthread_cond_wait(&mCondition, &mLock);
+        }
+    }
+    pthread_mutex_unlock(&mLock);
+    return ret;
+}
+
+void MessageQueue::abort() {
+    pthread_mutex_lock(&mLock);
+    mAbortRequest = true;
+    pthread_cond_signal(&mCondition);
+    pthread_mutex_unlock(&mLock);
+}
+
+
+/******************* Message class *******************/
+Message::Message() {
+    handler = NULL;
+}
+
+Message::Message(int what){
+    handler = NULL;
+    this->what = what;
+}
+Message::Message(int what, int arg1, int arg2) {
+    handler = NULL;
+    this->what = what;
+    this->arg1 = arg1;
+    this->arg2 = arg2;
+}
+Message::Message(int what, void* obj) {
+    handler = NULL;
+    this->what = what;
+    this->obj = obj;
+}
+Message::Message(int what, int arg1, int arg2, void* obj) {
+    handler = NULL;
+    this->what = what;
+    this->arg1 = arg1;
+    this->arg2 = arg2;
+    this->obj = obj;
+}
+Message::~Message() {
+}
+
+int Message::execute(){
+    if (MESSAGE_QUEUE_LOOP_QUIT_FLAG == what) {
+        return MESSAGE_QUEUE_LOOP_QUIT_FLAG;
+    } else if (handler) {
+        handler->handleMessage(this);
+        return 1;
+    }
+    return 0;
+};
+

app/src/main/cpp/common/message_queue.h

@@ -0,0 +1,84 @@
+//
+// Created by 叶亮 on 2019/7/15.
+//
+
+#ifndef ANDROIDRECORDER_MESSAGE_QUEUE_H
+#define ANDROIDRECORDER_MESSAGE_QUEUE_H
+
+#include <pthread.h>
+#include <sys/types.h>
+#include "message_handler.h"
+#include "../log_utils.h"
+
+#define MESSAGE_QUEUE_LOOP_QUIT_FLAG        19900909
+
+class Handler;
+
+class Message{
+private:
+    int what;
+    int arg1;
+    int arg2;
+    void *obj;
+
+public:
+    Message();
+    Message(int what);
+    Message(int what, int arg1, int arg2);
+    Message(int what, void *obj);
+    Message(int what, int arg1, int arg2, void *obj);
+    ~Message();
+
+    int execute();
+    int getWhat(){
+        return what;
+    }
+
+    int getArg1(){
+        return arg1;
+    }
+
+    int getArg2(){
+        return arg2;
+    }
+
+    void* getObj(){
+        return obj;
+    }
+
+    Handler *handler;
+};
+
+typedef struct MessageNode{
+    Message *msg;
+    struct MessageNode *next;
+    MessageNode(){
+        msg = NULL;
+        next = NULL;
+    }
+} MessageNode;
+
+class MessageQueue{
+private :
+    MessageNode* mFirst;
+    MessageNode* mLast;
+    int mNbPackets;
+    bool mAbortRequest;
+    pthread_mutex_t mLock;
+    pthread_cond_t mCondition;
+    const char * queueName;
+
+public:
+    MessageQueue();
+    MessageQueue(const char* queueNameParam);
+    ~MessageQueue();
+
+    void init();
+    void flush();
+    int enqueueMessage(Message* msg);
+    int dequeueMessage(Message **msg, bool block);
+    int size();
+    void abort();
+};
+
+#endif //ANDROIDRECORDER_MESSAGE_QUEUE_H