static int lpc_cmd_speak(LinphoneCore *lc, char *args);
static int lpc_cmd_codec(LinphoneCore *lc, char *args);
static int lpc_cmd_echocancellation(LinphoneCore *lc, char *args);
+static int lpc_cmd_pause(LinphoneCore *lc, char *args);
+static int lpc_cmd_resume(LinphoneCore *lc, char *args);
/* Command handler helpers */
static void linphonec_proxy_add(LinphoneCore *lc);
LPC_COMMAND commands[] = {
{ "help", lpc_cmd_help, "Print commands help", NULL },
{ "call", lpc_cmd_call, "Call a SIP uri",
- "'call <sip-url>' "
- ": initiate a call to the specified destination."
+ "'call <sip-url>' \t: initiate a call to the specified destination.\n"
+ "'call show' \t: show all the current calls status.\n"
},
{ "chat", lpc_cmd_chat, "Chat with a SIP uri",
"'chat <sip-url> \"message\"' "
": send a chat message \"message\" to the specified destination."
},
- { "terminate", lpc_cmd_terminate, "Terminate the current call",
- NULL },
+ { "terminate", lpc_cmd_terminate, "Terminate a call",
+ "'terminate' : Terminate the current call\n"
+ "'terminate <sip:XXX@XXX.XXX.XXX.XXX>' : Terminate the call with remote address\n"
+ "'terminate <all>' : Terminate all the current calls\n"
+ },
{ "answer", lpc_cmd_answer, "Answer a call",
- "Accept an incoming call."
+ "'answer' : Answer the current incoming call\n"
+ "'answer <sip:XXX@XXX.XXX.XXX.XXX>' : Answer the call with remote address\n"
},
{ "autoanswer", lpc_cmd_autoanswer, "Show/set auto-answer mode",
"'autoanswer' \t: show current autoanswer mode\n"
"'ec on [<delay>] [<tail>] [<framesize>]' : turn EC on with given delay, tail length and framesize\n"
"'ec off' : turn echo cancellation (EC) off\n"
"'ec show' : show EC status" },
- { (char *)NULL, (lpc_cmd_handler)NULL, (char *)NULL, (char *)NULL }
+ { "pause", lpc_cmd_pause, "pause a call",
+ "'pause' : pause the current call\n"},
+ { "resume", lpc_cmd_resume, "resume a call",
+ "'resume' : resume the unique call\n"
+ "'resume <sip:XXX@XXX.XXX.XXX.XXX>' : hold off the call with cid <cid>\n"},
+ { (char *)NULL, (lpc_cmd_handler)NULL, (char *)NULL, (char *)NULL }
};
/***************************************************************************
{
return 0;
}
-
- if ( lc->call != NULL )
+ if(!strcmp(args,"show"))
{
- linphonec_out("Terminate current call first.\n");
+ MSList *calls = linphone_core_get_calls(lc);
+ if(calls)
+ {
+ MSList *p_calls = calls;
+ linphonec_out("<remote>\t\t\t\t<status>\r\n");
+ while(p_calls != NULL)
+ {
+ linphonec_out("%s\t\t\t%s\r\n",
+ linphone_call_get_remote_address_as_string(p_calls->data),
+ (((LinphoneCall *)p_calls->data)==linphone_core_get_current_call(lc))?"yes":"no");
+ p_calls = p_calls->next;
+ }
+ ms_list_free(calls);
+ }
+ else
+ {
+ linphonec_out("No active call.\n");
+ }
}
else
{
+ if ( linphone_core_in_call(lc) )
+ {
+ linphonec_out("Terminate or hold on the current call first.\n");
+ return 1;
+ }
if ( NULL == linphone_core_invite(lc, args) )
{
linphonec_out("Error from linphone_core_invite.\n");
static int
lpc_cmd_terminate(LinphoneCore *lc, char *args)
{
- if ( -1 == linphone_core_terminate_call(lc, NULL) )
+ char *arg1 = args;
+ char *arg2 = NULL;
+ char *ptr = args;
+
+ if (!args)
{
- linphonec_out("No active call.\n");
+ if(linphone_core_in_call(lc))
+ {
+ if ( -1 == linphone_core_terminate_call(lc, linphone_core_get_current_call(lc)) )
+ {
+ linphonec_out("Could not stop the active call.\n");
+ }
+ }
+ else
+ {
+ linphonec_out("No active call.\n");
+ }
+ return 1;
}
- return 1;
+
+ /* Isolate first and second arg */
+ while(*ptr && !isspace(*ptr)) ++ptr;
+ if ( *ptr )
+ {
+ *ptr='\0';
+ arg2=ptr+1;
+ while(*arg2 && isspace(*arg2)) ++arg2;
+ }
+ if (arg1 != 0)
+ {
+ if(strcmp(arg1,"all")==0)
+ {
+ linphonec_out("We are going to stop all the calls.\n");
+ return (linphone_core_terminate_all_calls(lc)==0)?1:0;
+ }
+ else
+ {
+ char the_remote_address[255];
+ int n = sscanf(arg1, "%s", the_remote_address);
+ if (n == 1)
+ {
+ if ( -1 == linphone_core_terminate_call(lc,linphone_core_get_call_by_remote_address(lc,the_remote_address)))
+ {
+ linphonec_out("Cannot stop the call with %s.\n",the_remote_address);
+ }
+ return 1;
+ }
+ }
+ }
+ return 0;
+
}
static int
lpc_cmd_answer(LinphoneCore *lc, char *args)
{
- if ( -1 == linphone_core_accept_call(lc, NULL) )
+ char *arg1 = args;
+ char *arg2 = NULL;
+ char *ptr = args;
+
+ if (!args)
{
- linphonec_out("No incoming call.\n");
+ //TODO if just one call is present answer the only one ...
+ if ( -1 == linphone_core_accept_call(lc, linphone_core_get_current_call(lc)) )//TODO is there any current call here=> nope
+ {
+ linphonec_out("No incoming call.\n");
+ }
+ return 1;
}
- return 1;
+
+ // Isolate first and second arg
+ while(*ptr && !isspace(*ptr)) ++ptr;
+ if ( *ptr )
+ {
+ *ptr='\0';
+ arg2=ptr+1;
+ while(*arg2 && isspace(*arg2)) ++arg2;
+ }
+ if (arg1 != 0)
+ {
+ char the_remote_address[256];
+ int n = sscanf(arg1, "%s", the_remote_address);
+ if (n == 1)
+ {
+ if ( -1 == linphone_core_accept_call(lc, linphone_core_get_call_by_remote_address(lc,the_remote_address)) )
+ {
+ linphonec_out("Cannot answer the call from %s.\n",the_remote_address);
+ }
+ return 1;
+ }
+ }
+ return 0;
}
static int
return 0; /* Syntax error */
}
+static int lpc_cmd_pause(LinphoneCore *lc, char *args){
+ if(linphone_core_in_call(lc))
+ {
+ linphone_core_pause_call(lc,linphone_core_get_current_call(lc));
+ return 1;
+ }
+ linphonec_out("you can only pause when a call is in process\n");
+ return 0;
+}
+
+static int lpc_cmd_resume(LinphoneCore *lc, char *args){
+
+ if(linphone_core_in_call(lc))
+ {
+ linphonec_out("There is already a call in process pause or stop it first");
+ }
+ if (args)
+ {
+ char the_remote_address[255];
+ int n = sscanf(args, "%s", the_remote_address);
+ if (n == 1)
+ {
+ if(linphone_core_resume_call(lc,linphone_core_get_call_by_remote_address(lc,the_remote_address)) < 0)
+ {
+ linphonec_out("There was a problem to resume the call check the remote address you gave %s\n",args);
+ return 0;
+ }
+ else
+ {
+ return 1;
+ }
+ }
+ }
+ else
+ {
+ int returned = 0;
+ MSList *calls = linphone_core_get_calls(lc);
+ if(ms_list_size(calls) == 1)
+ {
+ if(linphone_core_resume_call(lc,calls->data) < 0)
+ {
+ linphonec_out("There was a problem to resume the unique call \n");
+ returned = 0;
+ }
+ else
+ {
+ returned = 1;
+ }
+ ms_list_free(calls);
+ return returned;
+ }
+ }
+ return 0;
+
+}
/***************************************************************************
*
// printing this is unneeded as we'd get a "Communication ended"
// message trough display_status callback anyway
- //printf("Bye received from %s\n", from);
+ char *from=linphone_call_get_remote_address_as_string(call);
+ printf("Bye received from %s\n", from);
+ ms_free(from);
}
/*
ring_stop(lc->ringstream);
lc->ringstream=NULL;
}
- linphone_core_start_media_streams(lc,call);
+ if(call == linphone_core_get_current_call(lc))
+ linphone_core_start_media_streams(lc,call);
}
static void call_received(SalOp *h){
sal_op_release(h);
return;
}
- if (lc->call!=NULL){/*busy*/
+ if (!linphone_core_can_we_add_call(lc)){/*busy*/
sal_call_decline(h,SalReasonBusy,NULL);
sal_op_release(h);
return;
to=sal_op_get_to(h);
call=linphone_call_new_incoming(lc,linphone_address_new(from),linphone_address_new(to),h);
- lc->call=call;
+ if(linphone_core_add_call(lc,call)!= 0)
+ {
+ ms_warning("we cannot have more calls\n");
+ sal_call_decline(h,SalReasonMedia,NULL);
+ linphone_call_unref(call);
+ return;
+ }
+ if(linphone_core_get_current_call(lc)!=NULL) //we are already in call just inform that an incoming call is going on
+ {
+ char temp[256];
+ snprintf(temp,sizeof(temp),"A new incoming call from %s during call",from);
+ lc->vtable.display_status(lc,temp);
+ }
sal_call_set_local_media_description(h,call->localdesc);
call->resultdesc=sal_call_get_final_media_description(h);
if (call->resultdesc)
if (call->resultdesc && sal_media_description_empty(call->resultdesc)){
sal_call_decline(h,SalReasonMedia,NULL);
linphone_call_unref(call);
- lc->call=NULL;
return;
}
lc->vtable.display_status(lc,barmesg);
/* play the ring */
- if (lc->sound_conf.ring_sndcard!=NULL){
+ if (lc->sound_conf.ring_sndcard!=NULL && !linphone_core_in_call(lc)){
ms_message("Starting local ring...");
lc->ringstream=ring_start(lc->sound_conf.local_ring,2000,lc->sound_conf.ring_sndcard);
}
call->state=LinphoneCallRinging;
sal_call_notify_ringing(h);
- linphone_core_init_media_streams(lc,lc->call);
+ linphone_core_init_media_streams(lc,call);
if (lc->vtable.inv_recv) lc->vtable.inv_recv(lc,call);
ms_free(barmesg);
ms_free(tmp);
static void call_ringing(SalOp *h){
LinphoneCore *lc=(LinphoneCore *)sal_get_user_pointer(sal_op_get_sal(h));
- LinphoneCall *call=lc->call;
+ LinphoneCall *call=(LinphoneCall*)sal_op_get_user_pointer(h);
SalMediaDescription *md;
if (call==NULL) return;
if (lc->vtable.display_status)
lc->ringstream=NULL;
}
ms_message("Doing early media...");
- linphone_core_start_media_streams(lc,call);
+ if(call == linphone_core_get_current_call(lc))
+ linphone_core_start_media_streams(lc,call);
call->media_pending=TRUE;
}
call->state=LinphoneCallRinging;
static void call_accepted(SalOp *op){
LinphoneCore *lc=(LinphoneCore *)sal_get_user_pointer(sal_op_get_sal(op));
- LinphoneCall *call=lc->call;
+ LinphoneCall *call=(LinphoneCall*)sal_op_get_user_pointer(op);
if (call==NULL){
ms_warning("No call to accept.");
return ;
}
- if (sal_op_get_user_pointer(op)!=lc->call){
- ms_warning("call_accepted: ignoring.");
- return;
- }
if (call->state==LinphoneCallAVRunning){
return ; /*already accepted*/
}
- if (lc->audiostream->ticker!=NULL){
+ if ((lc->audiostream!=NULL) && (lc->audiostream->ticker!=NULL)){
/*case where we accepted early media */
- linphone_core_stop_media_streams(lc,call);
- linphone_core_init_media_streams(lc,call);
+ if(call == linphone_core_get_current_call(lc))
+ {
+ linphone_core_stop_media_streams(lc,call);
+ linphone_core_init_media_streams(lc,call);
+ }
}
if (call->resultdesc)
sal_media_description_unref(call->resultdesc);
static void call_ack(SalOp *op){
LinphoneCore *lc=(LinphoneCore *)sal_get_user_pointer(sal_op_get_sal(op));
- LinphoneCall *call=lc->call;
+ LinphoneCall *call=(LinphoneCall*)sal_op_get_user_pointer(op);
if (call==NULL){
ms_warning("No call to be ACK'd");
return ;
}
- if (sal_op_get_user_pointer(op)!=lc->call){
- ms_warning("call_ack: ignoring.");
- return;
- }
if (call->media_pending){
if (lc->audiostream->ticker!=NULL){
/*case where we accepted early media */
- linphone_core_stop_media_streams(lc,call);
- linphone_core_init_media_streams(lc,call);
+ if(call == linphone_core_get_current_call(lc))
+ {
+ linphone_core_stop_media_streams(lc,call);
+ linphone_core_init_media_streams(lc,call);
+ }
}
if (call->resultdesc)
sal_media_description_unref(call->resultdesc);
static void call_updated(SalOp *op){
LinphoneCore *lc=(LinphoneCore *)sal_get_user_pointer(sal_op_get_sal(op));
LinphoneCall *call=(LinphoneCall*)sal_op_get_user_pointer(op);
- linphone_core_stop_media_streams(lc,call);
- linphone_core_init_media_streams(lc,call);
+ if(call == linphone_core_get_current_call(lc))
+ {
+ linphone_core_stop_media_streams(lc,call);
+ linphone_core_init_media_streams(lc,call);
+ }
if (call->resultdesc)
sal_media_description_unref(call->resultdesc);
call->resultdesc=sal_call_get_final_media_description(op);
ring_stop(lc->ringstream);
lc->ringstream=NULL;
}
- linphone_core_stop_media_streams(lc,lc->call);
+ if(call == linphone_core_get_current_call(lc))
+ linphone_core_stop_media_streams(lc,call);
lc->vtable.show(lc);
lc->vtable.display_status(lc,_("Call terminated."));
linphone_call_set_terminated(call);
linphone_address_destroy(addr);
}
linphone_call_unref(call);
- lc->call=NULL;
}
static void call_failure(SalOp *op, SalError error, SalReason sr, const char *details){
char *msg600=_("User does not want to be disturbed.");
char *msg603=_("Call declined.");
char *msg=NULL;
- LinphoneCall *call=lc->call;
+ LinphoneCall *call=(LinphoneCall*)sal_op_get_user_pointer(op);
- if (sal_op_get_user_pointer(op)!=lc->call){
- ms_warning("call_failure: ignoring.");
- return;
- }
if (lc->vtable.show) lc->vtable.show(lc);
if (error==SalErrorNoResponse){
ring_stop(lc->ringstream);
lc->ringstream=NULL;
}
- linphone_core_stop_media_streams(lc,call);
+ if(call == linphone_core_get_current_call(lc))
+ linphone_core_stop_media_streams(lc,call);
if (call!=NULL) {
linphone_call_set_terminated(call);
+ linphone_call_unref(call);//TODO not an unref here ???//AUREL
if (sr!=SalReasonDeclined) gstate_new_state(lc, GSTATE_CALL_ERROR, msg);
else gstate_new_state(lc, GSTATE_CALL_END, NULL);
- lc->call=NULL;
}
}
if(linphone_core_is_in_communication_with(cr->lc,cr->peer))
{
ms_message("send SIP message into the call\n");
- op = cr->lc->call->op;
+ op = (linphone_core_get_current_call(cr->lc))->op;
}
else
{
if (obj->ping_op) {
sal_op_release(obj->ping_op);
}
+ if(linphone_core_del_call(obj->core,obj) != 0)
+ {
+ ms_error("could not remove the call from the list !!!");
+ }
+ if(obj == linphone_core_get_current_call(obj->core))
+ {
+ ms_message("destroying the current call\n");
+ linphone_core_unset_the_current_call(obj->core);
+ }
ms_free(obj);
}
return FALSE;
}
-int linphone_core_get_current_call_duration(const LinphoneCore *lc){
- LinphoneCall *call=lc->call;
+int linphone_core_get_call_duration(LinphoneCall *call){
if (call==NULL) return 0;
if (call->media_start_time==0) return 0;
return time(NULL)-call->media_start_time;
}
-const LinphoneAddress *linphone_core_get_remote_address(LinphoneCore *lc){
- LinphoneCall *call=lc->call;
+int linphone_core_get_current_call_duration(const LinphoneCore *lc){
+ LinphoneCall *call=linphone_core_get_current_call((LinphoneCore *)lc);
+ return linphone_core_get_call_duration(call);
+}
+
+const LinphoneAddress *linphone_core_get_current_call_remote_address(struct _LinphoneCore *lc){
+ LinphoneCall *call=linphone_core_get_current_call(lc);
if (call==NULL) return 0;
return linphone_call_get_remote_address(call);
}
if (lc->auto_net_state_mon) monitor_network_state(lc,curtime);
proxy_update(lc);
-
- if (lc->call!=NULL){
- LinphoneCall *call=lc->call;
+ LinphoneCall *call = linphone_core_get_current_call(lc);
+ if(call){
if (call->state==LinphoneCallPreEstablishing && (curtime-call->start_time>=2)){
/*start the call even if the OPTIONS reply did not arrive*/
linphone_core_start_invite(lc,call,NULL);
{
char *tmp;
bool_t returned;
- const LinphoneAddress *la=linphone_core_get_remote_address(lc);
+ const LinphoneAddress *la=linphone_core_get_current_call_remote_address(lc);
if(la == NULL)
{
return FALSE;
if (call->op && sal_op_get_contact(call->op)!=NULL){
return NULL;
}
-
/* if the ping OPTIONS request succeeded use the contact guessed from the
received, rport*/
if (call->ping_op){
ms_free(contact);
}
call->state=LinphoneCallInit;
- linphone_core_init_media_streams(lc,lc->call);
+ linphone_core_init_media_streams(lc,call);
if (!lc->sip_conf.sdp_200_ack){
call->media_pending=TRUE;
sal_call_set_local_media_description(call->op,call->localdesc);
if (err<0){
ms_warning("Could not initiate call.");
lc->vtable.display_status(lc,_("could not call"));
- linphone_core_stop_media_streams(lc,call);
+ if(call == linphone_core_get_current_call(lc))
+ linphone_core_stop_media_streams(lc,call);
linphone_call_unref(call);
- lc->call=NULL;
}else gstate_new_state(lc, GSTATE_CALL_OUT_INVITE, real_url);
ms_free(real_url);
ms_free(from);
LinphoneProxyConfig *dest_proxy=NULL;
LinphoneCall *call;
- if (lc->call!=NULL){
- lc->vtable.display_warning(lc,_("Sorry, having multiple simultaneous calls is not supported yet !"));
+ if (linphone_core_in_call(lc)){
+ lc->vtable.display_warning(lc,_("Sorry, you have to pause or stop the current call first !"));
+ return NULL;
+ }
+ if(!linphone_core_can_we_add_call(lc)){
+ lc->vtable.display_warning(lc,_("Sorry, we have reached the maximum number of simultaneous calls"));
return NULL;
}
-
linphone_core_get_default_proxy(lc,&proxy);
route=linphone_core_get_route(lc);
call=linphone_call_new_outgoing(lc,parsed_url2,linphone_address_clone(real_parsed_url));
sal_op_set_route(call->op,route);
- lc->call=call;
+ if(linphone_core_add_call(lc,call)!= 0)
+ {
+ ms_warning("we had a problem in adding the call into the invite ... weird\n");
+ linphone_call_unref(call);
+ return NULL;
+ }
+ linphone_core_set_as_current_call(lc,call);
if (dest_proxy!=NULL || lc->sip_conf.ping_with_options==FALSE){
err=linphone_core_start_invite(lc,call,dest_proxy);
}else{
}
/**
- * Returns true if in incoming call is pending, ie waiting for being answered or declined.
+ * Returns true if an incoming call is pending, ie waiting for being answered or declined.
*
* @ingroup call_control
**/
bool_t linphone_core_inc_invite_pending(LinphoneCore*lc){
- if (lc->call!=NULL && lc->call->dir==LinphoneCallIncoming){
- return TRUE;
+ LinphoneCall *call = linphone_core_get_current_call(lc);
+ if(call != NULL)
+ {
+ if(call->dir==LinphoneCallIncoming)
+ return TRUE;
}
return FALSE;
}
end:
ms_free(cname);
linphone_address_destroy(me);
- lc->call->state=LinphoneCallAVRunning;
+ call->state=LinphoneCallAVRunning;
}
void linphone_core_stop_media_streams(LinphoneCore *lc, LinphoneCall *call){
ms_message("ring stopped");
lc->ringstream=NULL;
}
-
+ if(linphone_core_set_as_current_call(lc,call)!=0)
+ {
+ ms_message("another call is already in process\n");
+ }
+
linphone_core_get_default_proxy(lc,&cfg);
/*try to be best-effort in giving real local or routable contact address*/
contact=get_fixed_contact(lc,call,cfg);
call->resultdesc=sal_call_get_final_media_description(call->op);
if (call->resultdesc){
sal_media_description_ref(call->resultdesc);
- linphone_core_start_media_streams(lc, call);
+ if(call == linphone_core_get_current_call(lc))
+ linphone_core_start_media_streams(lc, call);
}else call->media_pending=TRUE;
ms_message("call answered.");
return 0;
* @param url the destination of the call to be terminated, use NULL if there is
* only one call (which is case in this version of liblinphone).
**/
-int linphone_core_terminate_call(LinphoneCore *lc, LinphoneCall *call)
+int linphone_core_terminate_call(LinphoneCore *lc, LinphoneCall *the_call)
{
- if (call==NULL){
- return -1;
+ LinphoneCall *call;
+ if (the_call == NULL){
+ call = linphone_core_get_current_call(lc);
+ if(call == NULL)
+ {
+ return -1;
+ }
+ }
+ else
+ {
+ call = the_call;
}
- lc->call=NULL;
sal_call_terminate(call->op);
/*stop ringing*/
ring_stop(lc->ringstream);
lc->ringstream=NULL;
}
- linphone_core_stop_media_streams(lc,call);
+ if(call == linphone_core_get_current_call(lc))
+ linphone_core_stop_media_streams(lc,call);
lc->vtable.display_status(lc,_("Call ended") );
gstate_new_state(lc, GSTATE_CALL_END, NULL);
linphone_call_set_terminated(call);
return 0;
}
-
+/**
+ * Terminates all the calls.
+ *
+ * @ingroup call_control
+ * @param lc The LinphoneCore
+**/
int linphone_core_terminate_all_calls(LinphoneCore *lc){
- /* TODO */
+ MSList *calls;
+
+ calls = lc->calls;
+ while(calls->next != NULL)
+ {
+ linphone_core_terminate_call(lc,(LinphoneCall *)calls->data);
+ calls = calls->next;
+ }
+ ms_list_free(lc->calls);
return -1;
}
+/**
+ * Returns the calls MSList
+ *
+ * @ingroup call_control
+**/
+MSList *linphone_core_get_calls(LinphoneCore *lc)
+{
+ return ms_list_copy(lc->calls);
+}
+
/**
* Returns TRUE if there is a call running or pending.
*
* @ingroup call_control
**/
bool_t linphone_core_in_call(const LinphoneCore *lc){
- return lc->call!=NULL;
+ return linphone_core_get_current_call((LinphoneCore *)lc)!=NULL;
}
/**
*
* @ingroup call_control
**/
-struct _LinphoneCall *linphone_core_get_current_call(LinphoneCore *lc)
+LinphoneCall *linphone_core_get_current_call(LinphoneCore *lc)
{
- if(linphone_core_in_call(lc))
- return lc->call;
- else
- return NULL;
+ if(lc->current_call != NULL)
+ return lc->current_call;
+ return NULL;
}
-int linphone_core_pause_call(LinphoneCore *lc, LinphoneCall *call){
- /* TODO */
- return -1;
+/**
+ * Permits to pause the call
+ *
+ * @ingroup call_control
+**/
+int linphone_core_pause_call(LinphoneCore *lc, LinphoneCall *the_call)
+{
+ LinphoneCall *call = the_call;
+ if(lc == NULL)
+ {
+ ms_error("LinphoneCore was null\n");
+ return -1;
+ }
+ if(call == NULL)
+ {
+ if(linphone_core_in_call(lc))
+ {
+ call = linphone_core_get_current_call(lc);
+ }
+ else
+ {
+ ms_error("LinphoneCall was null\n");
+ return -2;
+ }
+ }
+ if(linphone_core_get_current_call(lc) != call)
+ {
+ ms_error("The call asked to be paused was not the current on\n");
+ return -3;
+ }
+ sal_call_hold(call->op,TRUE);
+ call->state = LinphoneCallPaused;
+ linphone_core_unset_the_current_call(lc);
+ linphone_core_stop_media_streams(lc,call);
+ lc->vtable.display_status(lc,_("Pause the current call"));
+ return 0;
}
-int linphone_core_resume_call(LinphoneCore *lc, LinphoneCall *call){
- /* TODO */
- return -1;
+/**
+ * Permits to resume the call
+ *
+ * @ingroup call_control
+**/
+int linphone_core_resume_call(LinphoneCore *lc, LinphoneCall *the_call)
+{
+ char temp[255];
+ LinphoneCall *call = the_call;
+ if(lc == NULL)
+ {
+ ms_error("LinphoneCore was null\n");
+ return -1;
+ }
+ if(call == NULL)
+ {
+ MSList *calls = linphone_core_get_calls(lc);
+ if(ms_list_size(calls) == 1)
+ {
+ call = ((LinphoneCall *)calls->data);
+ ms_list_free(calls);
+ }
+ else
+ {
+ ms_error("LinphoneCall was null\n");
+ ms_list_free(calls);
+ return -2;
+ }
+ }
+ if(linphone_core_get_current_call(lc) != NULL)
+ {
+ ms_error("There is already a call in process pause or stop it first\n");
+ return -3;
+ }
+ linphone_core_init_media_streams(lc,call);
+ sal_call_hold(call->op,FALSE);
+ call->state = LinphoneCallAVRunning;
+ linphone_core_set_as_current_call(lc,call);
+ linphone_core_start_media_streams(lc,call);
+ snprintf(temp,sizeof(temp),"Resume the call with %s",linphone_call_get_remote_address_as_string(call));
+ lc->vtable.display_status(lc,temp);
+
+ return 0;
}
-LinphoneCall *linphone_core_get_call_by_remote_address(LinphoneCore *lc){
- /* TODO */
+/**
+ * Compare the remote address with the one in call
+ *
+ * @param a the call
+ * @param b the remote address to compare with
+ * @return 0 if it's the good call else 1
+ */
+static int linphone_call_remote_address_compare(const void * a, const void * b)
+{
+ if(b == NULL || a ==NULL)
+ return 1;
+ char *the_remote_address = ((char *)b);
+ LinphoneCall *call = ((LinphoneCall *)a);
+#ifdef DEBUG
+ ms_message("the remote address:%s\n",the_remote_address);
+ ms_message("the call:%p => %s\n",call,linphone_call_get_remote_address_as_string(call));
+#endif
+ if(!strcmp(linphone_call_get_remote_address_as_string(call),the_remote_address))
+ {
+ return 0;
+ }
+ return 1;
+}
+
+/**
+ * Get the call with the remote_address specified
+ * @param lc
+ * @param remote_address
+ * @return the LinphoneCall of the call if found
+ */
+LinphoneCall *linphone_core_get_call_by_remote_address(LinphoneCore *lc, const char *remote_address){
+
+ MSList *the_call = ms_list_find_custom(lc->calls,linphone_call_remote_address_compare,(void *)remote_address);
+ if(the_call != NULL)
+ {
+ return ((LinphoneCall *)the_call->data);
+ }
return NULL;
}
}
if (linphone_core_get_use_info_for_dtmf(lc)!=0){
/* Out of Band DTMF (use INFO method) */
- LinphoneCall *call=lc->call;
+ LinphoneCall *call=linphone_core_get_current_call(lc);
if (call==NULL){
return;
}
static void linphone_core_uninit(LinphoneCore *lc)
{
- if (lc->call){
+ if(linphone_core_get_calls_nb(lc)){
int i;
- linphone_core_terminate_call(lc,NULL);
+ linphone_core_terminate_all_calls(lc);
for(i=0;i<10;++i){
#ifndef WIN32
usleep(50000);
linphone_core_uninit(lc);
ms_free(lc);
}
+/**
+ * Get the number of Call
+ *
+ * @ingroup call_control
+**/
+int linphone_core_get_calls_nb(const LinphoneCore *lc)
+{
+ int returned;
+ if(lc->calls == NULL)
+ {
+ returned = 0;
+ }
+ else
+ {
+ returned = ms_list_size(lc->calls);
+ }
+ return returned;
+}
+/**
+ * Check if we do not have exceed the number of simultaneous call
+ *
+ * @ingroup call_control
+**/
+bool_t linphone_core_can_we_add_call(LinphoneCore *lc)
+{
+ if(linphone_core_get_calls_nb(lc) < NB_MAX_CALLS)
+ return TRUE;
+ return FALSE;
+}
+
+/**
+ * Unset the current call
+ *
+ * @ingroup call_control
+**/
+int linphone_core_unset_the_current_call(LinphoneCore *lc)
+{
+ if(lc->current_call == NULL)
+ return -1;
+ lc->current_call = NULL;
+ ms_message("Current call unset\n");
+ return 0;
+}
+
+/**
+ * Set the call in parameter as the new current call
+ *
+ * @ingroup call_control
+**/
+int linphone_core_set_as_current_call(LinphoneCore *lc, LinphoneCall *call)
+{
+ if(lc->current_call != NULL)
+ return -1;
+ lc->current_call = call;
+ return 0;
+}
+
+/**
+ * Add the call in the LinphoneCall list
+ *
+ * @ingroup call_control
+**/
+int linphone_core_add_call( LinphoneCore *lc, LinphoneCall *call)
+{
+ if(linphone_core_can_we_add_call(lc))
+ {
+ MSList *the_calls = lc->calls;
+ the_calls = ms_list_append(the_calls,(void *)call);
+ lc->calls = the_calls;
+ return 0;
+ }
+ return -1;
+}
+
+/**
+ * Add the call in the LinphoneCall list
+ *
+ * @ingroup call_control
+**/
+int linphone_core_del_call( LinphoneCore *lc, LinphoneCall *call)
+{
+ MSList *it;
+
+ MSList *the_calls = lc->calls;
+ if(call == linphone_core_get_current_call(lc))
+ {
+ linphone_core_unset_the_current_call(lc);
+ }
+ it=ms_list_find(the_calls,call);
+ if (it)
+ {
+ the_calls = ms_list_remove_link(the_calls,it);
+ }
+ else
+ {
+ ms_warning("could not find the call into the list\n");
+ return -1;
+ }
+ lc->calls = the_calls;
+ return 0;
+}
LinphoneCallState linphone_call_get_state(const LinphoneCall *call);
bool_t linphone_call_asked_to_autoanswer(LinphoneCall *call);
bool_t linphone_call_paused(LinphoneCall *call);
+const LinphoneAddress * linphone_core_get_current_call_remote_address(struct _LinphoneCore *lc);
const LinphoneAddress * linphone_call_get_remote_address(const LinphoneCall *call);
char *linphone_call_get_remote_address_as_string(const LinphoneCall *call);
void linphone_call_ref(LinphoneCall *call);
int linphone_core_resume_call(LinphoneCore *lc, LinphoneCall *call);
-LinphoneCall *linphone_core_get_call_by_remote_address(LinphoneCore *lc);
+LinphoneCall *linphone_core_get_call_by_remote_address(LinphoneCore *lc, const char *remote_address);
void linphone_core_send_dtmf(LinphoneCore *lc,char dtmf);
#ifdef __cplusplus
}
#endif
-
+MSList *linphone_core_get_calls(LinphoneCore *lc);
#endif
MSList *auth_info;
struct _RingStream *ringstream;
LCCallbackObj preview_finished_cb;
- struct _LinphoneCall *call; /* the current call, in the future it will be a list of calls (conferencing)*/
+ LinphoneCall *current_call; /* the current call */
+ MSList *calls; /* all the processed calls */
MSList *queued_calls; /* used by the autoreplier */
MSList *call_logs;
MSList *chatrooms;
bool_t network_reachable;
};
+bool_t linphone_core_can_we_add_call(LinphoneCore *lc);
+int linphone_core_add_call( LinphoneCore *lc, LinphoneCall *call);
+int linphone_core_del_call( LinphoneCore *lc, LinphoneCall *call);
+int linphone_core_set_as_current_call(LinphoneCore *lc, LinphoneCall *call);
+int linphone_core_unset_the_current_call(LinphoneCore *lc);
+int linphone_core_get_calls_nb(const LinphoneCore *lc);
+
+#define HOLD_OFF (0)
+#define HOLD_ON (1)
+
+#ifndef NB_MAX_CALLS
+#define NB_MAX_CALLS (10)
+#endif
+
#endif /* _PRIVATE_H */
int bandwidth;
int ptime;
SalEndpointCandidate candidates[SAL_ENDPOINT_CANDIDATE_MAX];
+ bool_t notsending;
} SalStreamDescription;
#define SAL_MEDIA_DESCRIPTION_MAX_STREAMS 4
int nstreams;
int bandwidth;
SalStreamDescription streams[SAL_MEDIA_DESCRIPTION_MAX_STREAMS];
+ bool_t notsending;
} SalMediaDescription;
SalMediaDescription *sal_media_description_new();
int sal_call_notify_ringing(SalOp *h);
int sal_call_accept(SalOp*h);
int sal_call_decline(SalOp *h, SalReason reason, const char *redirection /*optional*/);
+int sal_call_hold(SalOp *h, bool_t holdon);
SalMediaDescription * sal_call_get_final_media_description(SalOp *h);
int sal_refer(SalOp *h, const char *refer_to);
int sal_refer_accept(SalOp *h);
void __sal_op_set_network_origin(SalOp *op, const char *origin /*a sip uri*/);
void __sal_op_free(SalOp *b);
-
#endif
osip_free(sdp);
}
+static void set_hold_status_to_desc(SalMediaDescription *desc, bool_t holdon)
+{
+ int i;
+ if(desc == NULL)
+ return;
+ desc->notsending = holdon;
+ for(i = 0; i < SAL_MEDIA_DESCRIPTION_MAX_STREAMS; i++)
+ {
+ if(desc->streams != NULL)
+ desc->streams[i].notsending = holdon;//Audio
+ }
+}
+
static void set_sdp_from_desc(osip_message_t *sip, const SalMediaDescription *desc){
sdp_message_t *msg=media_description_to_sdp(desc);
if (msg==NULL) {
osip_from_free((osip_from_t*)u);
}
+/**
+ * Send a re-Invite used to hold the current call
+ *
+ * @ingroup call_control
+ * @param lc the LinphoneCore object
+ * @param url the destination of the call (sip address).
+**/
+int sal_call_hold(SalOp *h, bool_t holdon)
+{
+ int err=0;
+
+ osip_message_t *reinvite;
+ eXosip_call_build_request(h->did,"INVITE",&reinvite);
+ osip_message_set_subject(reinvite,osip_strdup("Phone Call Hold"));
+ osip_message_set_allow(reinvite, "INVITE, ACK, CANCEL, OPTIONS, BYE, REFER, NOTIFY, MESSAGE, SUBSCRIBE, INFO");
+ if (h->base.root->session_expires!=0){
+ osip_message_set_header(reinvite, "Session-expires", "200");
+ osip_message_set_supported(reinvite, "timer");
+ }
+ //add something to say that the distant sip phone will be in sendonly/sendrecv mode
+ if (h->base.local_media){
+ h->sdp_offering=TRUE;
+ set_hold_status_to_desc(h->base.local_media,holdon);
+ set_sdp_from_desc(reinvite,h->base.local_media);
+ }else h->sdp_offering=FALSE;
+ eXosip_lock();
+ err = eXosip_call_send_request(h->did, reinvite);
+ eXosip_unlock();
+
+ return err;
+}
+
osip_strdup ("IN"), inet6 ? osip_strdup("IP6") : osip_strdup ("IP4"),
osip_strdup (desc->addr));
sdp_message_s_name_set (local, osip_strdup ("A conversation"));
- sdp_message_c_connection_add (local, -1,
- osip_strdup ("IN"), inet6 ? osip_strdup ("IP6") : osip_strdup ("IP4"),
- osip_strdup (desc->addr), NULL, NULL);
+ if(!desc->notsending)
+ {
+ sdp_message_c_connection_add (local, -1,
+ osip_strdup ("IN"), inet6 ? osip_strdup ("IP6") : osip_strdup ("IP4"),
+ osip_strdup (desc->addr), NULL, NULL);
+ }
+ else
+ {
+ sdp_message_c_connection_add (local, -1,
+ osip_strdup ("IN"), inet6 ? osip_strdup ("IP6") : osip_strdup ("IP4"),
+ inet6 ? osip_strdup ("0.0.0.0.0.0") : osip_strdup ("0.0.0.0"), NULL, NULL);
+ }
sdp_message_t_time_descr_add (local, osip_strdup ("0"), osip_strdup ("0"));
if (desc->bandwidth>0) sdp_message_b_bandwidth_add (local, -1, osip_strdup ("AS"),
- int_2char(desc->bandwidth));
+ int_2char(desc->bandwidth));
return local;
}
for(elem=desc->payloads;elem!=NULL;elem=elem->next){
add_payload(msg, lineno, (PayloadType*)elem->data);
}
+ if(desc->notsending)//to hold the distant SIP endpoint
+ sdp_message_a_attribute_add (msg, lineno, osip_strdup ("sendonly"),NULL);
+ else
+ sdp_message_a_attribute_add (msg, lineno, osip_strdup ("sendrecv"),NULL);
}
sdp_message_t *media_description_to_sdp(const SalMediaDescription *desc){
GtkWidget *duration=linphone_gtk_get_widget(main_window,"in_call_duration");
GtkWidget *animation=linphone_gtk_get_widget(main_window,"in_call_animation");
GdkPixbufAnimation *pbuf=create_pixbuf_animation("incall_anim.gif");
- const LinphoneAddress *uri=linphone_core_get_remote_address(lc);
+ const LinphoneAddress *uri=linphone_core_get_current_call_remote_address(lc);
char *tmp=linphone_address_as_string(uri);
display_peer_name_in_label(callee,tmp);
ms_free(tmp);
g_object_unref(G_OBJECT(pbuf));
}else gtk_image_set_from_stock(GTK_IMAGE(animation),GTK_STOCK_INFO,GTK_ICON_SIZE_DIALOG);
linphone_gtk_enable_mute_button(
- GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(main_window,"incall_mute")),TRUE);
+ GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(main_window,"incall_mute")),TRUE);
+ linphone_gtk_enable_hold_button(
+ GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(main_window,"hold_call")),TRUE);
}
void linphone_gtk_in_call_view_update_duration(int duration){
}
linphone_gtk_enable_mute_button(
GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(main_window,"incall_mute")),FALSE);
+ linphone_gtk_enable_hold_button(
+ GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(main_window,"hold_call")),FALSE);
g_timeout_add_seconds(2,(GSourceFunc)in_call_view_terminated,NULL);
}
linphone_gtk_draw_mute_button(button,active);
}
-void linphone_gtk_enable_mute_button(GtkToggleButton *button, gboolean sensitive){
+void linphone_gtk_enable_mute_button(GtkToggleButton *button, gboolean sensitive)
+{
gtk_widget_set_sensitive(GTK_WIDGET(button),sensitive);
linphone_gtk_draw_mute_button(button,FALSE);
}
+
+void linphone_gtk_draw_hold_button(GtkToggleButton *button, gboolean active){
+ GtkWidget *status=linphone_gtk_get_widget(linphone_gtk_get_main_window(),"in_call_status");
+ if (active){
+ GtkWidget *image=create_pixmap("hold_off.png");
+ gtk_button_set_label(GTK_BUTTON(button),_("HoldOff"));
+ gtk_label_set_markup(GTK_LABEL(status),_("<b>In call holded with</b>"));
+ if (image!=NULL) {
+ gtk_button_set_image(GTK_BUTTON(button),image);
+ gtk_widget_show(image);
+ }
+ }else{
+ GtkWidget *image=create_pixmap("hold_on.png");
+ gtk_button_set_label(GTK_BUTTON(button),_("HoldOn"));
+ gtk_label_set_markup(GTK_LABEL(status),_("<b>In call with</b>"));
+ if (image!=NULL) {
+ gtk_button_set_image(GTK_BUTTON(button),image);
+ gtk_widget_show(image);
+ }
+ }
+}
+
+void linphone_gtk_hold_toggled(GtkToggleButton *button){
+ GtkWidget *mw=linphone_gtk_get_main_window();
+ gboolean active=gtk_toggle_button_get_active(button);
+ if(active)
+ {
+ linphone_core_pause_call(linphone_gtk_get_core(),NULL);
+ gtk_widget_set_sensitive(linphone_gtk_get_widget(mw,"terminate_call"),FALSE);
+ }
+ else
+ {
+ linphone_core_resume_call(linphone_gtk_get_core(),NULL);
+ gtk_widget_set_sensitive(linphone_gtk_get_widget(mw,"terminate_call"),TRUE);
+ }
+ linphone_gtk_draw_hold_button(button,active);
+}
+
+void linphone_gtk_enable_hold_button(GtkToggleButton *button, gboolean sensitive){
+ gtk_widget_set_sensitive(GTK_WIDGET(button),sensitive);
+ linphone_gtk_hold_toggled(button);
+}
void linphone_gtk_in_call_view_update_duration(int duration);
void linphone_gtk_in_call_view_terminate(const char *error_msg);
void linphone_gtk_enable_mute_button(GtkToggleButton *button, gboolean sensitive);
+void linphone_gtk_enable_hold_button(GtkToggleButton *button, gboolean sensitive);
void linphone_gtk_show_login_frame(LinphoneProxyConfig *cfg);
gdk_window_set_keep_above(w, FALSE);
}else{
LinphoneAddress *uri =
- linphone_address_clone(linphone_core_get_remote_address(linphone_gtk_get_core()));
+ linphone_address_clone(linphone_core_get_current_call_remote_address(linphone_gtk_get_core()));
char *display_name;
linphone_address_clean(uri);
static gboolean linphone_gtk_start_call_do(GtkWidget *uri_bar){
const char *entered=gtk_entry_get_text(GTK_ENTRY(uri_bar));
- if (linphone_core_invite(linphone_gtk_get_core(),entered)==0) {
+ if (linphone_core_invite(linphone_gtk_get_core(),entered)!=NULL) {
completion_add_text(GTK_ENTRY(uri_bar),entered);
}else{
linphone_gtk_call_terminated(NULL);
"main_mute")),FALSE);
linphone_gtk_enable_mute_button(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(main_window,
"incall_mute")),FALSE);
+ linphone_gtk_enable_hold_button(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(main_window,
+ "hold_call")),FALSE);
if (!linphone_gtk_use_in_call_view()) {
gtk_widget_show(linphone_gtk_get_widget(main_window, "main_mute"));
}
<child>
<widget class="GtkHButtonBox" id="hbuttonbox4">
<property name="visible">True</property>
+ <property name="layout_style">spread</property>
<child>
<widget class="GtkToggleButton" id="incall_mute">
<property name="label" translatable="yes">Mute</property>
<property name="position">0</property>
</packing>
</child>
+ <child>
+ <widget class="GtkToggleButton" id="hold_call">
+ <property name="label" translatable="yes">HoldOn</property>
+ <property name="visible">True</property>
+ <property name="sensitive">False</property>
+ <property name="can_focus">True</property>
+ <property name="receives_default">True</property>
+ <signal name="toggled" handler="linphone_gtk_hold_toggled"/>
+ </widget>
+ <packing>
+ <property name="expand">False</property>
+ <property name="fill">False</property>
+ <property name="position">1</property>
+ </packing>
+ </child>
</widget>
<packing>
<property name="expand">False</property>
pixmapdir=$(datadir)/pixmaps/linphone
pixmap_DATA= \
+hold_on.png hold_off.png \
mic_muted.png mic_active.png \
linphone-3-250x130.png linphone-3.png linphone2-57x57.png \
linphone.png linphone-banner.png \
projects / linphone / commitdiff