sjero.net Git - linphone/blob - coreapi/chat.c

   1 /***************************************************************************
   2  *            chat.c
   3  *
   4  *  Sun Jun  5 19:34:18 2005
   5  *  Copyright  2005  Simon Morlat
   6  *  Email simon dot morlat at linphone dot org
   7  ****************************************************************************/
   8
   9 /*
  10  *  This program is free software; you can redistribute it and/or modify
  11  *  it under the terms of the GNU General Public License as published by
  12  *  the Free Software Foundation; either version 2 of the License, or
  13  *  (at your option) any later version.
  14  *
  15  *  This program is distributed in the hope that it will be useful,
  16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  *  GNU General Public License for more details.
  19  *
  20  *  You should have received a copy of the GNU General Public License
  21  *  along with this program; if not, write to the Free Software
  22  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  23  */
  24
  25  #include "linphonecore.h"
  26  #include "private.h"
  27
  28  LinphoneChatRoom * linphone_core_create_chat_room(LinphoneCore *lc, const char *to){
  29         LinphoneAddress *parsed_url=NULL;
  30
  31         if ((parsed_url=linphone_core_interpret_url(lc,to))!=NULL){
  32                 LinphoneChatRoom *cr=ms_new0(LinphoneChatRoom,1);
  33                 cr->lc=lc;
  34                 cr->peer=linphone_address_as_string(parsed_url);
  35                 cr->peer_url=parsed_url;
  36                 lc->chatrooms=ms_list_append(lc->chatrooms,(void *)cr);
  37                 return cr;
  38         }
  39         return NULL;
  40  }
  41
  42
  43  void linphone_chat_room_destroy(LinphoneChatRoom *cr){
  44         LinphoneCore *lc=cr->lc;
  45         lc->chatrooms=ms_list_remove(lc->chatrooms,(void *) cr);
  46         linphone_address_destroy(cr->peer_url);
  47         ms_free(cr->peer);
  48         if (cr->op)
  49                  sal_op_release(cr->op);
  50  }
  51
  52
  53 static void _linphone_chat_room_send_message(LinphoneChatRoom *cr, LinphoneChatMessage* msg){
  54         const char *route=NULL;
  55         const char *identity=linphone_core_find_best_identity(cr->lc,cr->peer_url,&route);
  56         SalOp *op=NULL;
  57         LinphoneCall *call;
  58         char* content_type;
  59         if((call = linphone_core_get_call_by_remote_address(cr->lc,cr->peer))!=NULL){
  60                 if (call->state==LinphoneCallConnected ||
  61                     call->state==LinphoneCallStreamsRunning ||
  62                     call->state==LinphoneCallPaused ||
  63                     call->state==LinphoneCallPausing ||
  64                     call->state==LinphoneCallPausedByRemote){
  65                         ms_message("send SIP message through the existing call.");
  66                         op = call->op;
  67                         call->pending_message=msg;
  68                 }
  69         }
  70         if (op==NULL){
  71                 /*sending out of calls*/
  72                 op = sal_op_new(cr->lc->sal);
  73                 sal_op_set_route(op,route);
  74                 if (cr->op!=NULL){
  75                         sal_op_release (cr->op);
  76                         cr->op=NULL;
  77                 }
  78                 cr->op=op;
  79                 sal_op_set_user_pointer(op, msg); /*if out of call, directly store msg*/
  80         }
  81         if (msg->external_body_url) {
  82                 content_type=ms_strdup_printf("message/external-body; access-type=URL; URL=\"%s\"",msg->external_body_url);
  83                 sal_message_send(op,identity,cr->peer,content_type,NULL);
  84                 ms_free(content_type);
  85         } else {
  86                 sal_text_send(op, identity, cr->peer, msg->message);
  87         }
  88
  89
  90 }
  91
  92 void linphone_chat_room_send_message(LinphoneChatRoom *cr, const char *msg) {
  93         _linphone_chat_room_send_message(cr,linphone_chat_room_create_message(cr,msg));
  94 }
  95 bool_t linphone_chat_room_matches(LinphoneChatRoom *cr, const LinphoneAddress *from){
  96         if (linphone_address_get_username(cr->peer_url) && linphone_address_get_username(from) &&
  97                 strcmp(linphone_address_get_username(cr->peer_url),linphone_address_get_username(from))==0) return TRUE;
  98         return FALSE;
  99 }
 100
 101 void linphone_chat_room_message_received(LinphoneChatRoom *cr, LinphoneCore *lc, LinphoneChatMessage *msg){
 102         if (msg->message)
 103                 //legacy API
 104                 if (lc->vtable.text_received!=NULL) lc->vtable.text_received(lc, cr, msg->from, msg->message);
 105         if (lc->vtable.message_received!=NULL) lc->vtable.message_received(lc, cr,msg);
 106
 107 }
 108
 109 void linphone_core_message_received(LinphoneCore *lc, const char *from, const char *raw_msg,const char* external_url){
 110         MSList *elem;
 111         LinphoneChatRoom *cr=NULL;
 112         LinphoneAddress *addr;
 113         char *cleanfrom;
 114         LinphoneChatMessage* msg;
 115         addr=linphone_address_new(from);
 116         linphone_address_clean(addr);
 117         for(elem=lc->chatrooms;elem!=NULL;elem=ms_list_next(elem)){
 118                 cr=(LinphoneChatRoom*)elem->data;
 119                 if (linphone_chat_room_matches(cr,addr)){
 120                         break;
 121                 }
 122                 cr=NULL;
 123         }
 124         cleanfrom=linphone_address_as_string(addr);
 125         if (cr==NULL){
 126                 /* create a new chat room */
 127                 cr=linphone_core_create_chat_room(lc,cleanfrom);
 128         }
 129         msg = linphone_chat_room_create_message(cr, raw_msg);
 130         linphone_chat_message_set_from(msg, cr->peer_url);
 131         if (external_url) {
 132                 linphone_chat_message_set_external_body_url(msg, external_url);
 133         }
 134         linphone_address_destroy(addr);
 135         linphone_chat_room_message_received(cr,lc,msg);
 136         ms_free(cleanfrom);
 137 }
 138
 139 LinphoneCore* linphone_chat_room_get_lc(LinphoneChatRoom *cr){
 140         return cr->lc;
 141 }
 142
 143 LinphoneChatRoom* linphone_chat_message_get_chat_room(LinphoneChatMessage *msg){
 144         return msg->chat_room;
 145 }
 146
 147 void linphone_chat_room_set_user_data(LinphoneChatRoom *cr, void * ud){
 148         cr->user_data=ud;
 149 }
 150 void * linphone_chat_room_get_user_data(LinphoneChatRoom *cr){
 151         return cr->user_data;
 152 }
 153 const LinphoneAddress* linphone_chat_room_get_peer_address(LinphoneChatRoom *cr) {
 154         return cr->peer_url;
 155 }
 156
 157 LinphoneChatMessage* linphone_chat_room_create_message(const LinphoneChatRoom *cr,const char* message) {
 158         LinphoneChatMessage* msg = ms_new0(LinphoneChatMessage,1);
 159         msg->chat_room=(LinphoneChatRoom*)cr;
 160         msg->message=message?ms_strdup(message):NULL;
 161         return msg;
 162 }
 163
 164 void linphone_chat_message_destroy(LinphoneChatMessage* msg) {
 165         if (msg->message) ms_free(msg->message);
 166         if (msg->external_body_url) ms_free(msg->external_body_url);
 167         if (msg->from) linphone_address_destroy(msg->from);
 168         ms_free(msg);
 169 }
 170
 171 void linphone_chat_room_send_message2(LinphoneChatRoom *cr, LinphoneChatMessage* msg,LinphoneChatMessageStateChangeCb status_cb,void* ud) {
 172         msg->cb=status_cb;
 173         msg->cb_ud=ud;
 174         _linphone_chat_room_send_message(cr, msg);
 175 }
 176
 177 const char* linphone_chat_message_state_to_string(const LinphoneChatMessageState state) {
 178         switch (state) {
 179                 case LinphoneChatMessageStateIdle:return "LinphoneChatMessageStateIdle";
 180                 case LinphoneChatMessageStateInProgress:return "LinphoneChatMessageStateInProgress";
 181                 case LinphoneChatMessageStateDelivered:return "LinphoneChatMessageStateDelivered";
 182                 case  LinphoneChatMessageStateNotDelivered:return "LinphoneChatMessageStateNotDelivered";
 183                 default: return "Unknown state";
 184         }
 185
 186 }
 187
 188 char* linphone_chat_message_get_message(LinphoneChatMessage* msg) {
 189         return msg->message;
 190 }
 191
 192 const LinphoneAddress* linphone_chat_message_get_peer_address(LinphoneChatMessage *msg) {
 193         return linphone_chat_room_get_peer_address(msg->chat_room);
 194 }
 195
 196 /**
 197  * user pointer set function
 198  */
 199 void linphone_chat_message_set_user_data(LinphoneChatMessage* message,void* ud) {
 200         message->message_userdata=ud;
 201 }
 202 /**
 203  * user pointer get function
 204  */
 205 void* linphone_chat_message_get_user_data(const LinphoneChatMessage* message) {
 206         return message->message_userdata;
 207 }
 208
 209 const char* linphone_chat_message_get_external_body_url(const LinphoneChatMessage* message) {
 210         return message->external_body_url;
 211 }
 212
 213 void linphone_chat_message_set_external_body_url(LinphoneChatMessage* message,const char* url) {
 214         if (message->external_body_url) {
 215                 ms_free(message->external_body_url);
 216         }
 217         message->external_body_url=url?ms_strdup(url):NULL;
 218 }
 219 void linphone_chat_message_set_from(LinphoneChatMessage* message, const LinphoneAddress* from) {
 220         if(message->from) linphone_address_destroy(message->from);
 221         message->from=linphone_address_clone(from);
 222
 223 }
 224 LinphoneAddress* linphone_chat_message_get_from(const LinphoneChatMessage* message) {
 225         return message->from;
 226 }
 227 const char * linphone_chat_message_get_text(const LinphoneChatMessage* message) {
 228         return message->message;
 229 }
 230 LinphoneChatMessage* linphone_chat_message_clone(const LinphoneChatMessage* msg) {
 231         /*struct _LinphoneChatMessage {
 232          char* message;
 233          LinphoneChatRoom* chat_room;
 234          LinphoneChatMessageStateChangeCb cb;
 235          void* cb_ud;
 236          void* message_userdata;
 237          char* external_body_url;
 238          LinphoneAddress* from;
 239          };*/
 240         LinphoneChatMessage* new_message = linphone_chat_room_create_message(msg->chat_room,msg->message);
 241         if (msg->external_body_url) new_message->external_body_url=ms_strdup(msg->external_body_url);
 242         new_message->cb=msg->cb;
 243         new_message->cb_ud=msg->cb_ud;
 244         new_message->message_userdata=msg->message_userdata;
 245         new_message->cb=msg->cb;
 246         if (msg->from) new_message->from=linphone_address_clone(msg->from);
 247         return new_message;
 248 }