程序性能提升者

这个屌丝很懒，什么也没留下！

热门标签

linphone-LinphoneChatRoomImpl文件对应的JNI层文件分析_belle_sip_object_cast+52

作者：程序性能提升者 | 2024-02-01 16:17:20

踩

belle_sip_object_cast+52

说明

这是个聊天内容的类，这里还对sqlite3数据库进行了操作，已经文件的传输也在这里。

native函数

private native long createLinphoneChatMessage(long ptr, String message);
private native long getPeerAddress(long ptr);
private native void sendMessage(long ptr, String message);
private native void sendMessage2(long ptr, Object msg, long messagePtr, StateListener listener);
private native long[] getHistoryRange(long ptr, int begin, int end);
private native long[] getHistory(long ptr, int limit);
private native void destroy(long ptr);
private native int getUnreadMessagesCount(long ptr);
private native int getHistorySize(long ptr);
private native void deleteHistory(long ptr);
private native void compose(long ptr);
private native boolean isRemoteComposing(long ptr);
private native void markAsRead(long ptr);
private native void deleteMessage(long room, long message);
private native long createLinphoneChatMessage2(long ptr, String message,
            String url, int state, long timestamp, boolean isRead,
            boolean isIncoming);
private native void sendChatMessage(long ptr, Object message, long messagePtr);
private native Object getCore(long nativePtr);
private native long createFileTransferMessage(long ptr, String name, String type, String subtype, int size);
private native Object getCall(long nativePtr);
private native long getChar(long nativePtr);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

createLinphoneChatMessage

extern "C" jlong Java_org_linphone_core_LinphoneChatRoomImpl_createLinphoneChatMessage(JNIEnv*  env
                                                                        ,jobject  thiz
                                                                        ,jlong ptr
                                                                        ,jstring jmessage) {
    const char* message = env->GetStringUTFChars(jmessage, NULL);
    LinphoneChatMessage *chatMessage = linphone_chat_room_create_message((LinphoneChatRoom *)ptr, message);
    env->ReleaseStringUTFChars(jmessage, message);

    return (jlong) chatMessage;
}1
2
3
4
5
6
7
8
9
10

linphone_chat_room_create_message

submodules/linphone/coreapi/chat.c:LinphoneChatMessage *linphone_chat_room_create_message(LinphoneChatRoom *cr, const char *message) {1

LinphoneChatMessage *linphone_chat_room_create_message(LinphoneChatRoom *cr, const char *message) {
    LinphoneChatMessage *msg = belle_sip_object_new(LinphoneChatMessage);
    msg->state = LinphoneChatMessageStateIdle;
    msg->callbacks = linphone_chat_message_cbs_new();
    msg->chat_room = (LinphoneChatRoom *)cr;
    msg->message = message ? ms_strdup(message) : NULL;
    msg->is_read = TRUE;
    msg->content_type = NULL;              /* this property is used only when transfering file */
    msg->file_transfer_information = NULL; /* this property is used only when transfering file */
    msg->http_request = NULL;
    msg->time = ms_time(0);
    return msg;
}1
2
3
4
5
6
7
8
9
10
11
12
13

LinphoneChatRoom

submodules/linphone/coreapi/private.h:struct _LinphoneChatRoom{1

struct _LinphoneChatRoom{
    belle_sip_object_t base;
    void *user_data;
    struct _LinphoneCore *lc;
    char  *peer;
    LinphoneAddress *peer_url;
    MSList *messages_hist;
    MSList *transient_messages;
    int unread_count;
    LinphoneIsComposingState remote_is_composing;
    LinphoneIsComposingState is_composing;
    belle_sip_source_t *remote_composing_refresh_timer;
    belle_sip_source_t *composing_idle_timer;
    belle_sip_source_t *composing_refresh_timer;
    LinphoneCall *call;
    LinphoneChatMessage *pending_message;
    MSList *received_rtt_characters;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

linphone_chat_message_cbs_new

LinphoneChatMessageCbs *linphone_chat_message_cbs_new(void) {
    return belle_sip_object_new(LinphoneChatMessageCbs);
}1
2
3

belle_sip_object_new

submodules/belle-sip/include/belle-sip/object.h:BELLESIP_EXPORT belle_sip_object_t * _belle_sip_object_new(size_t objsize, belle_sip_object_vptr_t *vptr);
submodules/belle-sip/include/belle-sip/object.h:#define belle_sip_object_new(_type) (_type*)_belle_sip_object_new(sizeof(_type),(belle_sip_object_vptr_t*)BELLE_SIP_OBJECT_GET_VPTR_FUNC(_type)())
1
2
3

getPeerAddress

extern "C" jlong Java_org_linphone_core_LinphoneChatMessageImpl_getPeerAddress(JNIEnv*  env
                                                                        ,jobject  thiz
                                                                        ,jlong ptr) {
    return (jlong) linphone_chat_message_get_peer_address((LinphoneChatMessage*)ptr);
}1
2
3
4
5

linphone_chat_message_get_peer_address

const LinphoneAddress *linphone_chat_message_get_peer_address(LinphoneChatMessage *msg) {
    return linphone_chat_room_get_peer_address(msg->chat_room);
}1
2
3

linphone_chat_room_get_peer_address

const LinphoneAddress *linphone_chat_room_get_peer_address(LinphoneChatRoom *cr) {
    return cr->peer_url;
}1
2
3

sendMessage

extern "C" void Java_org_linphone_core_LinphoneChatRoomImpl_sendMessage(JNIEnv*  env
                                                                        ,jobject  thiz
                                                                        ,jlong ptr
                                                                        ,jstring jmessage) {
    const char* message = env->GetStringUTFChars(jmessage, NULL);
    linphone_chat_room_send_message((LinphoneChatRoom*)ptr, message);
    env->ReleaseStringUTFChars(jmessage, message);
}1
2
3
4
5
6
7
8

linphone_chat_room_send_message

void linphone_chat_room_send_message2(LinphoneChatRoom *cr, LinphoneChatMessage *msg,
                                      LinphoneChatMessageStateChangedCb status_cb, void *ud) {
    msg->message_state_changed_cb = status_cb;
    msg->message_state_changed_user_data = ud;
    _linphone_chat_room_send_message(cr, msg);
}1
2
3
4
5
6

LinphoneChatMessageStateChangedCb

特像一个回调函数，先不管他了，这样吧。

_linphone_chat_room_send_message

oid _linphone_chat_room_send_message(LinphoneChatRoom *cr, LinphoneChatMessage *msg) {
    /*stubed rtt text*/
    if (cr->call && linphone_call_params_realtime_text_enabled(linphone_call_get_current_params(cr->call))) {
        uint32_t new_line = 0x2028;
        linphone_chat_message_put_char(msg, new_line); // New Line
        linphone_chat_message_set_state(msg, LinphoneChatMessageStateDelivered);
        linphone_chat_message_unref(msg);
        return;
    }

    msg->dir = LinphoneChatMessageOutgoing;

    // add to transient list
    cr->transient_messages = ms_list_append(cr->transient_messages, linphone_chat_message_ref(msg));

    /* Check if we shall upload a file to a server */
    if (msg->file_transfer_information != NULL && msg->content_type == NULL) {
        /* open a transaction with the server and send an empty request(RCS5.1 section 3.5.4.8.3.1) */
        linphone_chat_room_upload_file(msg);
    } else {
        SalOp *op = NULL;
        LinphoneCall *call;
        char *content_type;
        const char *identity = NULL;
        msg->time = ms_time(0);
        if (lp_config_get_int(cr->lc->config, "sip", "chat_use_call_dialogs", 0) != 0) {
            if ((call = linphone_core_get_call_by_remote_address(cr->lc, cr->peer)) != NULL) {
                if (call->state == LinphoneCallConnected || call->state == LinphoneCallStreamsRunning ||
                    call->state == LinphoneCallPaused || call->state == LinphoneCallPausing ||
                    call->state == LinphoneCallPausedByRemote) {
                    ms_message("send SIP msg through the existing call.");
                    op = call->op;
                    identity = linphone_core_find_best_identity(cr->lc, linphone_call_get_remote_address(call));
                }
            }
        }
        if (op == NULL) {
            LinphoneProxyConfig *proxy = linphone_core_lookup_known_proxy(cr->lc, cr->peer_url);
            if (proxy) {
                identity = linphone_proxy_config_get_identity(proxy);
            } else
                identity = linphone_core_get_primary_contact(cr->lc);
            /*sending out of calls*/
            msg->op = op = sal_op_new(cr->lc->sal);
            linphone_configure_op(cr->lc, op, cr->peer_url, msg->custom_headers,
                                  lp_config_get_int(cr->lc->config, "sip", "chat_msg_with_contact", 0));
            sal_op_set_user_pointer(op, msg); /*if out of call, directly store msg*/
        }

        if (msg->external_body_url) {
            content_type = ms_strdup_printf("message/external-body; access-type=URL; URL=\"%s\"", msg->external_body_url);
            sal_message_send(op, identity, cr->peer, content_type, NULL, NULL);
            ms_free(content_type);
        } else {
            char *peer_uri = linphone_address_as_string_uri_only(linphone_chat_room_get_peer_address(cr));
            const char *content_type;

            if (linphone_chat_room_lime_enabled(cr)) {
                /* ref the msg or it may be destroyed by callback if the encryption failed */
                if (msg->content_type && strcmp(msg->content_type, "application/vnd.gsma.rcs-ft-http+xml") == 0) {
                    /* it's a file transfer, content type shall be set to
                    application/cipher.vnd.gsma.rcs-ft-http+xml*/
                    content_type = "application/cipher.vnd.gsma.rcs-ft-http+xml";
                } else {
                    content_type = "xml/cipher";
                }
            } else {
                content_type = msg->content_type;
            }

            if (content_type == NULL) {
                sal_text_send(op, identity, cr->peer, msg->message);
            } else {
                sal_message_send(op, identity, cr->peer, content_type, msg->message, peer_uri);
            }
            ms_free(peer_uri);
        }

        if (msg->from){
            /*
             * BUG
             * the file transfer message constructor sets the from, but doesn't do it as well as here.
             */
            linphone_address_destroy(msg->from);
        }
        msg->from = linphone_address_new(identity);
        msg->storage_id = linphone_chat_message_store(msg);

        if (cr->unread_count >= 0 && !msg->is_read)
            cr->unread_count++;

        if (cr->is_composing == LinphoneIsComposingActive) {
            cr->is_composing = LinphoneIsComposingIdle;
        }
        linphone_chat_room_delete_composing_idle_timer(cr);
        linphone_chat_room_delete_composing_refresh_timer(cr);

    }
    // if operation failed, we should not change message state
    if (msg->dir == LinphoneChatMessageOutgoing) {
        linphone_chat_message_set_state(msg, LinphoneChatMessageStateInProgress);
    }
} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

遇见这个么长的一串，真的不知所错。

sendMessage2

extern "C" void Java_org_linphone_core_LinphoneChatRoomImpl_sendMessage2(JNIEnv*  env
                                                                        ,jobject  thiz
                                                                        ,jlong chatroom_ptr
                                                                        ,jobject message
                                                                        ,jlong messagePtr
                                                                        ,jobject jlistener) {
    jobject listener = env->NewGlobalRef(jlistener);
    message = env->NewGlobalRef(message);
    linphone_chat_message_ref((LinphoneChatMessage*)messagePtr);
    linphone_chat_message_set_user_data((LinphoneChatMessage*)messagePtr, message);
    linphone_chat_room_send_message2((LinphoneChatRoom*)chatroom_ptr, (LinphoneChatMessage*)messagePtr, chat_room_impl_callback, (void*)listener);
}1
2
3
4
5
6
7
8
9
10
11
12

linphone_chat_message_set_user_data

void linphone_chat_message_set_user_data(LinphoneChatMessage *msg, void *ud) {
    msg->message_userdata = ud;
}1
2
3

linphone_chat_room_send_message2

void linphone_chat_room_send_message2(LinphoneChatRoom *cr, LinphoneChatMessage *msg,
                                      LinphoneChatMessageStateChangedCb status_cb, void *ud) {
    msg->message_state_changed_cb = status_cb;
    msg->message_state_changed_user_data = ud;
    _linphone_chat_room_send_message(cr, msg);
}1
2
3
4
5
6

getHistoryRange

extern "C" jlongArray Java_org_linphone_core_LinphoneChatRoomImpl_getHistoryRange(JNIEnv*  env
                                                                        ,jobject  thiz
                                                                        ,jlong ptr
                                                                        ,jint start
                                                                        ,jint end) {
    MSList* history = linphone_chat_room_get_history_range((LinphoneChatRoom*)ptr, start, end);
    return _LinphoneChatRoomImpl_getHistory(env, thiz, ptr, history);
}1
2
3
4
5
6
7
8

_LinphoneChatRoomImpl_getHistory

submodules/linphone/coreapi/linphonecore_jni.cc:extern "C" jlongArray _LinphoneChatRoomImpl_getHistory(JNIEnv*  env1

getHistory

extern "C" jlongArray _LinphoneChatRoomImpl_getHistory(JNIEnv*  env
                                                                        ,jobject  thiz
                                                                        ,jlong ptr
                                                                        ,MSList* history) {
    int historySize = ms_list_size(history);
    jlongArray jHistory = env->NewLongArray(historySize);
    jlong *jInternalArray = env->GetLongArrayElements(jHistory, NULL);

    for (int i = 0; i < historySize; i++) {
        jInternalArray[i] = (unsigned long) (history->data);
        history = history->next;
    }

    ms_list_free(history);

    env->ReleaseLongArrayElements(jHistory, jInternalArray, 0);

    return jHistory;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

destroy

getUnreadMessagesCount

extern "C" jint Java_org_linphone_core_LinphoneChatRoomImpl_getUnreadMessagesCount(JNIEnv*  env
                                                                                  ,jobject  thiz
                                                                                  ,jlong ptr) {
    return (jint) linphone_chat_room_get_unread_messages_count((LinphoneChatRoom*)ptr);
}1
2
3
4
5

linphone_chat_room_get_unread_messages_count

submodules/linphone/coreapi/linphonecore.h:LINPHONE_PUBLIC int linphone_chat_room_get_unread_messages_count(LinphoneChatRoom *cr);

submodules/linphone/coreapi/message_storage.c:int linphone_chat_room_get_unread_messages_count(LinphoneChatRoom *cr){1
2
3

int linphone_chat_room_get_unread_messages_count(LinphoneChatRoom *cr){
    return linphone_chat_room_get_messages_count(cr, TRUE);
}1
2
3

linphone_chat_room_get_messages_count

static int linphone_chat_room_get_messages_count(LinphoneChatRoom *cr, bool_t unread_only){
    LinphoneCore *lc=linphone_chat_room_get_core(cr);
    int numrows=0;
    char *peer;
    char *buf;
    sqlite3_stmt *selectStatement;
    int returnValue;

    if (lc->db==NULL) return 0;

    // optimization: do not read database if the count is already available in memory
    if(unread_only && cr->unread_count >= 0) return cr->unread_count;

    peer=linphone_address_as_string_uri_only(linphone_chat_room_get_peer_address(cr));
    buf=sqlite3_mprintf("SELECT count(*) FROM history WHERE remoteContact = %Q %s;",peer,unread_only?"AND read = 0":"");
    returnValue = sqlite3_prepare_v2(lc->db,buf,-1,&selectStatement,NULL);
    if (returnValue == SQLITE_OK){
        if(sqlite3_step(selectStatement) == SQLITE_ROW){
            numrows= sqlite3_column_int(selectStatement, 0);
        }
    }
    sqlite3_finalize(selectStatement);
    sqlite3_free(buf);
    ms_free(peer);

    /* no need to test the sign of cr->unread_count here
     * because it has been tested above */
    if(unread_only) cr->unread_count = numrows;

    return numrows;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

啊哈，这里涉及到了sqlite3数据，太高兴了，但是怎么兴奋不起来呢。看完了之后我表示有点看不懂，也不是真的看不懂，就是不习惯这样用sqlite3数据库。

getHistorySize

extern "C" jint Java_org_linphone_core_LinphoneChatRoomImpl_getHistorySize      (JNIEnv*  env
                                                                                  ,jobject  thiz
                                                                                  ,jlong ptr) {
    return (jint) linphone_chat_room_get_history_size((LinphoneChatRoom*)ptr);
}1
2
3
4
5

linphone_chat_room_get_history_size

int linphone_chat_room_get_history_size(LinphoneChatRoom *cr){
    return linphone_chat_room_get_messages_count(cr, FALSE);
}1
2
3

linphone_chat_room_get_messages_count

static int linphone_chat_room_get_messages_count(LinphoneChatRoom *cr, bool_t unread_only){
    LinphoneCore *lc=linphone_chat_room_get_core(cr);
    int numrows=0;
    char *peer;
    char *buf;
    sqlite3_stmt *selectStatement;
    int returnValue;

    if (lc->db==NULL) return 0;

    // optimization: do not read database if the count is already available in memory
    if(unread_only && cr->unread_count >= 0) return cr->unread_count;

    peer=linphone_address_as_string_uri_only(linphone_chat_room_get_peer_address(cr));
    buf=sqlite3_mprintf("SELECT count(*) FROM history WHERE remoteContact = %Q %s;",peer,unread_only?"AND read = 0":"");
    returnValue = sqlite3_prepare_v2(lc->db,buf,-1,&selectStatement,NULL);
    if (returnValue == SQLITE_OK){
        if(sqlite3_step(selectStatement) == SQLITE_ROW){
            numrows= sqlite3_column_int(selectStatement, 0);
        }
    }
    sqlite3_finalize(selectStatement);
    sqlite3_free(buf);
    ms_free(peer);

    /* no need to test the sign of cr->unread_count here
     * because it has been tested above */
    if(unread_only) cr->unread_count = numrows;

    return numrows;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

突然发现，我所看见的这几个函数都是关于sqlite3数据库的，没有猜错的化，这里就是专门进行数据库存储的。

deleteHistory

extern "C" void Java_org_linphone_core_LinphoneChatRoomImpl_deleteHistory(JNIEnv*  env
                                                                    ,jobject  thiz
                                                                    ,jlong ptr) {
    linphone_chat_room_delete_history((LinphoneChatRoom*)ptr);
}1
2
3
4
5

linphone_chat_room_delete_history

void linphone_chat_room_delete_history(LinphoneChatRoom *cr){
    LinphoneCore *lc=cr->lc;
    char *peer;
    char *buf;

    if (lc->db==NULL) return ;

    peer=linphone_address_as_string_uri_only(linphone_chat_room_get_peer_address(cr));
    buf=sqlite3_mprintf("DELETE FROM history WHERE remoteContact = %Q;",peer);
    linphone_sql_request(lc->db,buf);
    sqlite3_free(buf);
    ms_free(peer);

    if(cr->unread_count > 0) cr->unread_count = 0;
}1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

linphone_sql_request

int linphone_sql_request(sqlite3* db,const char *stmt){
    char* errmsg=NULL;
    int ret;
    ret=sqlite3_exec(db,stmt,NULL,NULL,&errmsg);
    if(ret != SQLITE_OK) {
        ms_error("linphone_sql_request: statement %s -> error sqlite3_exec(): %s.", stmt, errmsg);
        sqlite3_free(errmsg);
    }
    return ret;
}1
2
3
4
5
6
7
8
9
10

compose

JNIEXPORT void JNICALL Java_org_linphone_core_LinphoneChatRoomImpl_compose(JNIEnv *env, jobject thiz, jlong ptr) {
    linphone_chat_room_compose((LinphoneChatRoom *)ptr);
}1
2
3

linphone_chat_room_compose

void linphone_chat_room_compose(LinphoneChatRoom *cr) {
    int idle_timeout =
        lp_config_get_int(cr->lc->config, "sip", "composing_idle_timeout", COMPOSING_DEFAULT_IDLE_TIMEOUT);
    int refresh_timeout =
        lp_config_get_int(cr->lc->config, "sip", "composing_refresh_timeout", COMPOSING_DEFAULT_REFRESH_TIMEOUT);
    if (cr->is_composing == LinphoneIsComposingIdle) {
        cr->is_composing = LinphoneIsComposingActive;
        linphone_chat_room_send_is_composing_notification(cr);
        if (!cr->composing_refresh_timer) {
            cr->composing_refresh_timer = sal_create_timer(cr->lc->sal, linphone_chat_room_refresh_composing, cr,
                                                           refresh_timeout * 1000, "composing refresh timeout");
        } else {
            belle_sip_source_set_timeout(cr->composing_refresh_timer, refresh_timeout * 1000);
        }
        if (!cr->composing_idle_timer) {
            cr->composing_idle_timer = sal_create_timer(cr->lc->sal, linphone_chat_room_stop_composing, cr,
                                                        idle_timeout * 1000, "composing idle timeout");
        }
    }
    belle_sip_source_set_timeout(cr->composing_idle_timer, idle_timeout * 1000);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

isRemoteComposing

JNIEXPORT jboolean JNICALL Java_org_linphone_core_LinphoneChatRoomImpl_isRemoteComposing(JNIEnv *env, jobject thiz, jlong ptr) {
    return (jboolean)linphone_chat_room_is_remote_composing((LinphoneChatRoom *)ptr);
}1
2
3

linphone_chat_room_is_remote_composing

bool_t linphone_chat_room_is_remote_composing(const LinphoneChatRoom *cr) {
    return (cr->remote_is_composing == LinphoneIsComposingActive) ? TRUE : FALSE;
}1
2
3

markAsRead

extern "C" void Java_org_linphone_core_LinphoneChatRoomImpl_markAsRead(JNIEnv*  env
                                                                       ,jobject  thiz
                                                                       ,jlong ptr) {
    linphone_chat_room_mark_as_read((LinphoneChatRoom*)ptr);
}1
2
3
4
5

linphone_chat_room_mark_as_read

void linphone_chat_room_mark_as_read(LinphoneChatRoom *cr){
    LinphoneCore *lc=linphone_chat_room_get_core(cr);
    int read=1;
    char *peer;
    char *buf;

    if (lc->db==NULL) return ;

    // optimization: do not modify the database if no message is marked as unread
    if(linphone_chat_room_get_unread_messages_count(cr) == 0) return;

    peer=linphone_address_as_string_uri_only(linphone_chat_room_get_peer_address(cr));
    buf=sqlite3_mprintf("UPDATE history SET read=%i WHERE remoteContact = %Q;",
                   read,peer);
    linphone_sql_request(lc->db,buf);
    sqlite3_free(buf);
    ms_free(peer);

    cr->unread_count = 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

deleteMessage

extern "C" void Java_org_linphone_core_LinphoneChatRoomImpl_deleteMessage(JNIEnv*  env
                                                                    ,jobject  thiz
                                                                    ,jlong room
                                                                    ,jlong msg) {
    linphone_chat_room_delete_message((LinphoneChatRoom*)room, (LinphoneChatMessage*)msg);
}1
2
3
4
5
6

linphone_chat_room_delete_message

void linphone_chat_room_delete_message(LinphoneChatRoom *cr, LinphoneChatMessage *msg) {
    LinphoneCore *lc=cr->lc;
    char *buf;

    if (lc->db==NULL) return ;

    buf=sqlite3_mprintf("DELETE FROM history WHERE id = %i;", msg->storage_id);
    linphone_sql_request(lc->db,buf);
    sqlite3_free(buf);

    /* Invalidate unread_count when we modify the database, so that next
     time we need it it will be recomputed from latest database state */
    cr->unread_count = -1;
}1
2
3
4
5
6
7
8
9
10
11
12
13
14

linphone_chat_room_delete_message

void linphone_chat_room_delete_message(LinphoneChatRoom *cr, LinphoneChatMessage *msg) {
    LinphoneCore *lc=cr->lc;
    char *buf;

    if (lc->db==NULL) return ;

    buf=sqlite3_mprintf("DELETE FROM history WHERE id = %i;", msg->storage_id);
    linphone_sql_request(lc->db,buf);
    sqlite3_free(buf);

    /* Invalidate unread_count when we modify the database, so that next
     time we need it it will be recomputed from latest database state */
    cr->unread_count = -1;
}1
2
3
4
5
6
7
8
9
10
11
12
13
14

createLinphoneChatMessage2

extern "C" jlong Java_org_linphone_core_LinphoneChatRoomImpl_createLinphoneChatMessage2(JNIEnv* env
                                                                        ,jobject thiz
                                                                        ,jlong ptr
                                                                        ,jstring jmessage
                                                                        ,jstring jurl
                                                                        ,jint state
                                                                        ,jlong time
                                                                        ,jboolean read
                                                                        ,jboolean incoming) {
    const char* message = jmessage?env->GetStringUTFChars(jmessage, NULL):NULL;
    const char* url = jurl?env->GetStringUTFChars(jurl, NULL):NULL;

    LinphoneChatMessage *chatMessage = linphone_chat_room_create_message_2(
                (LinphoneChatRoom *)ptr, message, url, (LinphoneChatMessageState)state,
                (time_t)time, read, incoming);

    if (jmessage != NULL)
        env->ReleaseStringUTFChars(jmessage, message);
    if (jurl != NULL)
        env->ReleaseStringUTFChars(jurl, url);

    return (jlong) chatMessage;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

linphone_chat_room_create_message_2

LinphoneChatMessage *linphone_chat_room_create_message_2(LinphoneChatRoom *cr, const char *message,
                                                         const char *external_body_url, LinphoneChatMessageState state,
                                                         time_t time, bool_t is_read, bool_t is_incoming) {
    LinphoneChatMessage *msg = linphone_chat_room_create_message(cr, message);
    LinphoneCore *lc = linphone_chat_room_get_core(cr);
    msg->external_body_url = external_body_url ? ms_strdup(external_body_url) : NULL;
    msg->time = time;
    msg->is_read = is_read;
    linphone_chat_message_set_state(msg, state);
    if (is_incoming) {
        msg->dir = LinphoneChatMessageIncoming;
        linphone_chat_message_set_from(msg, linphone_chat_room_get_peer_address(cr));
        msg->to = linphone_address_new(linphone_core_get_identity(lc)); /*direct assignment*/
    } else {
        msg->dir = LinphoneChatMessageOutgoing;
        linphone_chat_message_set_to(msg, linphone_chat_room_get_peer_address(cr));
        msg->from = linphone_address_new(linphone_core_get_identity(lc));/*direct assignment*/
    }
    return msg;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

sendChatMessage

extern "C" void Java_org_linphone_core_LinphoneChatRoomImpl_sendChatMessage(JNIEnv*  env
                                                                        ,jobject  thiz
                                                                        ,jlong chatroom_ptr
                                                                        ,jobject message
                                                                        ,jlong messagePtr) {
    message = env->NewGlobalRef(message);
    linphone_chat_message_ref((LinphoneChatMessage*)messagePtr);
    linphone_chat_message_set_user_data((LinphoneChatMessage*)messagePtr, message);
    linphone_chat_room_send_chat_message((LinphoneChatRoom*)chatroom_ptr, (LinphoneChatMessage*)messagePtr);
}1
2
3
4
5
6
7
8
9
10

linphone_chat_message_ref

LinphoneChatMessage *linphone_chat_message_ref(LinphoneChatMessage *msg) {
    belle_sip_object_ref(msg);
    return msg;
}1
2
3
4

linphone_chat_message_set_user_data

void linphone_chat_message_set_user_data(LinphoneChatMessage *msg, void *ud) {
    msg->message_userdata = ud;
}1
2
3

linphone_chat_room_send_chat_message

void linphone_chat_room_send_chat_message(LinphoneChatRoom *cr, LinphoneChatMessage *msg) {
    _linphone_chat_room_send_message(cr, msg);
}1
2
3

getCore

JNIEXPORT jobject JNICALL Java_org_linphone_core_LinphoneEventImpl_getCore(JNIEnv *env, jobject jobj, jlong evptr){
    LinphoneCore *lc=linphone_event_get_core((LinphoneEvent*)evptr);
    LinphoneJavaBindings *ljb = (LinphoneJavaBindings *)linphone_core_get_user_data(lc);
    jobject core = ljb->getCore();
    return core;
}1
2
3
4
5
6

linphone_event_get_core

submodules/linphone/coreapi/event.h:LINPHONE_PUBLIC LinphoneCore *linphone_event_get_core(const LinphoneEvent *lev);
submodules/linphone/coreapi/event.c:LinphoneCore *linphone_event_get_core(const LinphoneEvent *lev){1
2

linphone_core_get_user_data

submodules/linphone/coreapi/linphonecore.h:LINPHONE_PUBLIC  void *linphone_core_get_user_data(const LinphoneCore *lc);
submodules/linphone/coreapi/linphonecore.c:void *linphone_core_get_user_data(const LinphoneCore *lc){1
2

createFileTransferMessage

extern "C" jlong Java_org_linphone_core_LinphoneChatRoomImpl_createFileTransferMessage(JNIEnv* env, jobject thiz, jlong ptr, jstring jname, jstring jtype, jstring jsubtype, jint data_size) {
    LinphoneCore *lc = linphone_chat_room_get_core((LinphoneChatRoom*) ptr);
    LinphoneContent * content = linphone_core_create_content(lc);
    LinphoneChatMessage *message = NULL;
    const char *tmp;

    linphone_content_set_type(content, tmp = env->GetStringUTFChars(jtype, NULL));
    env->ReleaseStringUTFChars(jtype, tmp);

    linphone_content_set_subtype(content, tmp = env->GetStringUTFChars(jsubtype, NULL));
    env->ReleaseStringUTFChars(jsubtype, tmp);

    linphone_content_set_name(content, tmp = env->GetStringUTFChars(jname, NULL));
    env->ReleaseStringUTFChars(jname, tmp);

    linphone_content_set_size(content, data_size);

    message = linphone_chat_room_create_file_transfer_message((LinphoneChatRoom *)ptr, content);

    linphone_content_unref(content);

    return (jlong) message;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

linphone_chat_room_create_file_transfer_message

submodules/linphone/coreapi/linphonecore.h:LINPHONE_PUBLIC  LinphoneChatMessage* linphone_chat_room_create_file_transfer_message(LinphoneChatRoom *cr, const LinphoneContent* initial_content);
submodules/linphone/coreapi/chat_file_transfer.c:LinphoneChatMessage *linphone_chat_room_create_file_transfer_message(LinphoneChatRoom *cr,1
2

LinphoneChatMessage *linphone_chat_room_create_file_transfer_message(LinphoneChatRoom *cr,
                                                                     const LinphoneContent *initial_content) {
    LinphoneChatMessage *msg = belle_sip_object_new(LinphoneChatMessage);
    msg->callbacks = linphone_chat_message_cbs_new();
    msg->chat_room = (LinphoneChatRoom *)cr;
    msg->message = NULL;
    msg->is_read = TRUE;
    msg->file_transfer_information = linphone_content_copy(initial_content);
    msg->dir = LinphoneChatMessageOutgoing;
    linphone_chat_message_set_to(msg, linphone_chat_room_get_peer_address(cr));
    msg->from = linphone_address_new(linphone_core_get_identity(cr->lc)); /*direct assignment*/
    /* this will be set to application/vnd.gsma.rcs-ft-http+xml when we will transfer the xml reply from server to the peers */
    msg->content_type = NULL;
    /* this will store the http request during file upload to the server */
    msg->http_request = NULL;
    msg->time = ms_time(0);
    return msg;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

getCall

extern "C" jobject Java_org_linphone_core_LinphoneChatRoomImpl_getCall(JNIEnv* env ,jobject thiz, jlong ptr) {
    return getCall(env, linphone_chat_room_get_call((LinphoneChatRoom *)ptr));
}1
2
3

jobject getCall(JNIEnv *env, LinphoneCall *call){
    jobject jobj=0;

    if (call!=NULL){
        LinphoneCore *lc = linphone_call_get_core(call);
        LinphoneJavaBindings *ljb = (LinphoneJavaBindings *)linphone_core_get_user_data(lc);

        void *up=linphone_call_get_user_pointer(call);

        if (up==NULL){
            jobj=env->NewObject(ljb->callClass, ljb->callCtrId, (jlong)call);
            jobj=env->NewGlobalRef(jobj);
            linphone_call_set_user_pointer(call,(void*)jobj);
            linphone_call_ref(call);
        }else{
            jobj=(jobject)up;
        }
    }
    return jobj;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

linphone_call_get_user_pointer

submodules/linphone/coreapi/linphonecore.h:#define linphone_call_get_user_pointer(call) linphone_call_get_user_data(call)1

getChar

extern "C" jlong Java_org_linphone_core_LinphoneChatRoomImpl_getChar(JNIEnv* env ,jobject thiz, jlong ptr) {
    return linphone_chat_room_get_char((LinphoneChatRoom *)ptr);
}1
2
3

linphone_chat_room_get_char

uint32_t linphone_chat_room_get_char(const LinphoneChatRoom *cr) {
    if (cr && cr->received_rtt_characters) {
        MSList *characters = cr->received_rtt_characters;
        while (characters != NULL) {
            LinphoneChatMessageCharacter *cmc = (LinphoneChatMessageCharacter *)characters->data;
            if (!cmc->has_been_read) {
                cmc->has_been_read = TRUE;
                return cmc->value;
            }
            characters = ms_list_next(characters);
        }
    }
    return 0;
}1
2
3
4
5
6
7
8
9
10
11
12
13
14

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/article/detail/54224