mirror of
https://gitlab.linphone.org/BC/public/linphone-iphone.git
synced 2026-01-18 11:38:08 +00:00
733 lines
No EOL
22 KiB
C
733 lines
No EOL
22 KiB
C
/***************************************************************************
|
|
* friend.c
|
|
*
|
|
* Sat May 15 15:25:16 2004
|
|
* Copyright 2004-2009 Simon Morlat
|
|
* Email
|
|
****************************************************************************/
|
|
|
|
/*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Library General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
*/
|
|
|
|
#include "linphonecore.h"
|
|
#include "private.h"
|
|
#include "lpconfig.h"
|
|
|
|
const char *linphone_online_status_to_string(LinphoneOnlineStatus ss){
|
|
const char *str=NULL;
|
|
switch(ss){
|
|
case LinphoneStatusOnline:
|
|
str=_("Online");
|
|
break;
|
|
case LinphoneStatusBusy:
|
|
str=_("Busy");
|
|
break;
|
|
case LinphoneStatusBeRightBack:
|
|
str=_("Be right back");
|
|
break;
|
|
case LinphoneStatusAway:
|
|
str=_("Away");
|
|
break;
|
|
case LinphoneStatusOnThePhone:
|
|
str=_("On the phone");
|
|
break;
|
|
case LinphoneStatusOutToLunch:
|
|
str=_("Out to lunch");
|
|
break;
|
|
case LinphoneStatusDoNotDisturb:
|
|
str=_("Do not disturb");
|
|
break;
|
|
case LinphoneStatusMoved:
|
|
str=_("Moved");
|
|
break;
|
|
case LinphoneStatusAltService:
|
|
str=_("Using another messaging service");
|
|
break;
|
|
case LinphoneStatusOffline:
|
|
str=_("Offline");
|
|
break;
|
|
case LinphoneStatusPending:
|
|
str=_("Pending");
|
|
break;
|
|
case LinphoneStatusVacation:
|
|
str=_("Vacation");
|
|
default:
|
|
str=_("Unknown status");
|
|
}
|
|
return str;
|
|
}
|
|
|
|
static int friend_compare(const void * a, const void * b){
|
|
LinphoneAddress *fa=((LinphoneFriend*)a)->uri;
|
|
LinphoneAddress *fb=((LinphoneFriend*)b)->uri;
|
|
if (linphone_address_weak_equal(fa,fb)) return 0;
|
|
return 1;
|
|
}
|
|
|
|
|
|
MSList *linphone_find_friend_by_address(MSList *fl, const LinphoneAddress *addr, LinphoneFriend **lf){
|
|
MSList *res=NULL;
|
|
LinphoneFriend dummy;
|
|
if (lf!=NULL) *lf=NULL;
|
|
dummy.uri=(LinphoneAddress*)addr;
|
|
res=ms_list_find_custom(fl,friend_compare,&dummy);
|
|
if (lf!=NULL && res!=NULL) *lf=(LinphoneFriend*)res->data;
|
|
return res;
|
|
}
|
|
|
|
void __linphone_friend_do_subscribe(LinphoneFriend *fr){
|
|
LinphoneCore *lc=fr->lc;
|
|
|
|
if (fr->outsub==NULL){
|
|
/* people for which we don't have yet an answer should appear as offline */
|
|
fr->presence=NULL;
|
|
/*
|
|
if (fr->lc->vtable.notify_recv)
|
|
fr->lc->vtable.notify_recv(fr->lc,(LinphoneFriend*)fr);
|
|
*/
|
|
}else{
|
|
sal_op_release(fr->outsub);
|
|
fr->outsub=NULL;
|
|
}
|
|
fr->outsub=sal_op_new(lc->sal);
|
|
linphone_configure_op(lc,fr->outsub,fr->uri,NULL,TRUE);
|
|
sal_subscribe_presence(fr->outsub,NULL,NULL,lp_config_get_int(lc->config,"sip","subscribe_expires",600));
|
|
fr->subscribe_active=TRUE;
|
|
}
|
|
|
|
LinphoneFriend * linphone_friend_new(){
|
|
LinphoneFriend *obj=belle_sip_object_new(LinphoneFriend);
|
|
obj->pol=LinphoneSPAccept;
|
|
obj->presence=NULL;
|
|
obj->subscribe=TRUE;
|
|
return obj;
|
|
}
|
|
|
|
LinphoneFriend *linphone_friend_new_with_address(const char *addr){
|
|
LinphoneAddress* linphone_address = linphone_address_new(addr);
|
|
LinphoneFriend *fr;
|
|
|
|
if (linphone_address == NULL) {
|
|
ms_error("Cannot create friend for address [%s]",addr?addr:"null");
|
|
return NULL;
|
|
}
|
|
fr=linphone_friend_new();
|
|
linphone_friend_set_address(fr,linphone_address);
|
|
linphone_address_destroy(linphone_address);
|
|
return fr;
|
|
}
|
|
|
|
void linphone_friend_set_user_data(LinphoneFriend *lf, void *data){
|
|
lf->user_data=data;
|
|
}
|
|
|
|
void* linphone_friend_get_user_data(const LinphoneFriend *lf){
|
|
return lf->user_data;
|
|
}
|
|
|
|
bool_t linphone_friend_in_list(const LinphoneFriend *lf){
|
|
return lf->in_list;
|
|
}
|
|
|
|
void linphone_core_interpret_friend_uri(LinphoneCore *lc, const char *uri, char **result){
|
|
LinphoneAddress *fr=NULL;
|
|
*result=NULL;
|
|
fr=linphone_address_new(uri);
|
|
if (fr==NULL){
|
|
char *tmp=NULL;
|
|
if (strchr(uri,'@')!=NULL){
|
|
LinphoneAddress *u;
|
|
/*try adding sip:*/
|
|
tmp=ms_strdup_printf("sip:%s",uri);
|
|
u=linphone_address_new(tmp);
|
|
if (u!=NULL){
|
|
*result=tmp;
|
|
}
|
|
}else if (lc->default_proxy!=NULL){
|
|
/*try adding domain part from default current proxy*/
|
|
LinphoneAddress * id=linphone_address_new(linphone_core_get_identity(lc));
|
|
if ((id!=NULL) && (uri[0] != '\0')){
|
|
linphone_address_set_display_name(id,NULL);
|
|
linphone_address_set_username(id,uri);
|
|
*result=linphone_address_as_string(id);
|
|
linphone_address_destroy(id);
|
|
}
|
|
}
|
|
if (*result){
|
|
/*looks good */
|
|
ms_message("%s interpreted as %s",uri,*result);
|
|
}else{
|
|
ms_warning("Fail to interpret friend uri %s",uri);
|
|
}
|
|
}else {
|
|
*result=linphone_address_as_string(fr);
|
|
linphone_address_destroy(fr);
|
|
}
|
|
}
|
|
|
|
int linphone_friend_set_address(LinphoneFriend *lf, const LinphoneAddress *addr){
|
|
LinphoneAddress *fr=linphone_address_clone(addr);
|
|
linphone_address_clean(fr);
|
|
if (lf->uri!=NULL) linphone_address_destroy(lf->uri);
|
|
lf->uri=fr;
|
|
return 0;
|
|
}
|
|
|
|
int linphone_friend_set_name(LinphoneFriend *lf, const char *name){
|
|
LinphoneAddress *fr=lf->uri;
|
|
if (fr==NULL){
|
|
ms_error("linphone_friend_set_sip_addr() must be called before linphone_friend_set_name().");
|
|
return -1;
|
|
}
|
|
linphone_address_set_display_name(fr,name);
|
|
return 0;
|
|
}
|
|
|
|
int linphone_friend_enable_subscribes(LinphoneFriend *fr, bool_t val){
|
|
fr->subscribe=val;
|
|
return 0;
|
|
}
|
|
|
|
int linphone_friend_set_inc_subscribe_policy(LinphoneFriend *fr, LinphoneSubscribePolicy pol)
|
|
{
|
|
fr->pol=pol;
|
|
return 0;
|
|
}
|
|
|
|
void linphone_friend_notify(LinphoneFriend *lf, LinphonePresenceModel *presence){
|
|
MSList *elem;
|
|
if (lf->insubs){
|
|
char *addr=linphone_address_as_string(linphone_friend_get_address(lf));
|
|
ms_message("Want to notify %s",addr);
|
|
ms_free(addr);
|
|
}
|
|
for(elem=lf->insubs; elem!=NULL; elem=elem->next){
|
|
SalOp *op = (SalOp*)elem->data;
|
|
sal_notify_presence(op,(SalPresenceModel *)presence);
|
|
}
|
|
}
|
|
|
|
void linphone_friend_add_incoming_subscription(LinphoneFriend *lf, SalOp *op){
|
|
/*ownership of the op is transfered from sal to the LinphoneFriend*/
|
|
lf->insubs = ms_list_append(lf->insubs, op);
|
|
}
|
|
|
|
void linphone_friend_remove_incoming_subscription(LinphoneFriend *lf, SalOp *op){
|
|
if (ms_list_find(lf->insubs, op)){
|
|
sal_op_release(op);
|
|
lf->insubs = ms_list_remove(lf->insubs, op);
|
|
}
|
|
|
|
}
|
|
|
|
static void linphone_friend_unsubscribe(LinphoneFriend *lf){
|
|
if (lf->outsub!=NULL) {
|
|
sal_unsubscribe(lf->outsub);
|
|
lf->subscribe_active=FALSE;
|
|
}
|
|
}
|
|
|
|
void linphone_friend_invalidate_subscription(LinphoneFriend *lf){
|
|
LinphoneCore *lc=lf->lc;
|
|
|
|
if (lf->outsub!=NULL) {
|
|
sal_op_release(lf->outsub);
|
|
lf->outsub=NULL;
|
|
lf->subscribe_active=FALSE;
|
|
}
|
|
|
|
/* Notify application that we no longer know the presence activity */
|
|
if (lf->presence != NULL) {
|
|
linphone_presence_model_unref(lf->presence);
|
|
}
|
|
lf->presence = linphone_presence_model_new_with_activity(LinphonePresenceActivityOffline,"unknown activity");
|
|
linphone_core_notify_notify_presence_received(lc,lf);
|
|
|
|
lf->initial_subscribes_sent=FALSE;
|
|
}
|
|
|
|
void linphone_friend_close_subscriptions(LinphoneFriend *lf){
|
|
linphone_friend_unsubscribe(lf);
|
|
ms_list_for_each(lf->insubs, (MSIterateFunc) sal_notify_presence_close);
|
|
lf->insubs = ms_list_free_with_data(lf->insubs, (MSIterateFunc)sal_op_release);
|
|
}
|
|
|
|
static void _linphone_friend_release_ops(LinphoneFriend *lf){
|
|
lf->insubs = ms_list_free_with_data(lf->insubs, (MSIterateFunc) sal_op_release);
|
|
if (lf->outsub){
|
|
sal_op_release(lf->outsub);
|
|
lf->outsub=NULL;
|
|
}
|
|
}
|
|
|
|
static void _linphone_friend_destroy(LinphoneFriend *lf){
|
|
_linphone_friend_release_ops(lf);
|
|
if (lf->presence != NULL) linphone_presence_model_unref(lf->presence);
|
|
if (lf->uri!=NULL) linphone_address_destroy(lf->uri);
|
|
if (lf->info!=NULL) buddy_info_free(lf->info);
|
|
}
|
|
|
|
static belle_sip_error_code _linphone_friend_marshall(belle_sip_object_t *obj, char* buff, size_t buff_size, size_t *offset) {
|
|
LinphoneFriend *lf = (LinphoneFriend*)obj;
|
|
belle_sip_error_code err = BELLE_SIP_OK;
|
|
if (lf->uri){
|
|
char *tmp = linphone_address_as_string(lf->uri);
|
|
err = belle_sip_snprintf(buff, buff_size, offset, "%s", tmp);
|
|
ms_free(tmp);
|
|
}
|
|
return err;
|
|
}
|
|
|
|
const LinphoneAddress *linphone_friend_get_address(const LinphoneFriend *lf){
|
|
return lf->uri;
|
|
}
|
|
|
|
const char * linphone_friend_get_name(const LinphoneFriend *lf) {
|
|
LinphoneAddress *fr = lf->uri;
|
|
if (fr == NULL) return NULL;
|
|
return linphone_address_get_display_name(fr);
|
|
}
|
|
|
|
bool_t linphone_friend_get_send_subscribe(const LinphoneFriend *lf){
|
|
return lf->subscribe;
|
|
}
|
|
|
|
LinphoneSubscribePolicy linphone_friend_get_inc_subscribe_policy(const LinphoneFriend *lf){
|
|
return lf->pol;
|
|
}
|
|
|
|
LinphoneOnlineStatus linphone_friend_get_status(const LinphoneFriend *lf){
|
|
LinphoneOnlineStatus online_status = LinphoneStatusOffline;
|
|
LinphonePresenceBasicStatus basic_status = LinphonePresenceBasicStatusClosed;
|
|
LinphonePresenceActivity *activity = NULL;
|
|
unsigned int nb_activities = 0;
|
|
|
|
if (lf->presence != NULL) {
|
|
basic_status = linphone_presence_model_get_basic_status(lf->presence);
|
|
nb_activities = linphone_presence_model_get_nb_activities(lf->presence);
|
|
online_status = (basic_status == LinphonePresenceBasicStatusOpen) ? LinphoneStatusOnline : LinphoneStatusOffline;
|
|
if (nb_activities > 1) {
|
|
char *tmp = NULL;
|
|
const LinphoneAddress *addr = linphone_friend_get_address(lf);
|
|
if (addr) tmp = linphone_address_as_string(addr);
|
|
ms_warning("Friend %s has several activities, get status from the first one", tmp ? tmp : "unknown");
|
|
if (tmp) ms_free(tmp);
|
|
nb_activities = 1;
|
|
}
|
|
if (nb_activities == 1) {
|
|
activity = linphone_presence_model_get_activity(lf->presence);
|
|
switch (linphone_presence_activity_get_type(activity)) {
|
|
case LinphonePresenceActivityBreakfast:
|
|
case LinphonePresenceActivityDinner:
|
|
case LinphonePresenceActivityLunch:
|
|
case LinphonePresenceActivityMeal:
|
|
online_status = LinphoneStatusOutToLunch;
|
|
break;
|
|
case LinphonePresenceActivityAppointment:
|
|
case LinphonePresenceActivityMeeting:
|
|
case LinphonePresenceActivityPerformance:
|
|
case LinphonePresenceActivityPresentation:
|
|
case LinphonePresenceActivitySpectator:
|
|
case LinphonePresenceActivityWorking:
|
|
case LinphonePresenceActivityWorship:
|
|
online_status = LinphoneStatusDoNotDisturb;
|
|
break;
|
|
case LinphonePresenceActivityAway:
|
|
case LinphonePresenceActivitySleeping:
|
|
online_status = LinphoneStatusAway;
|
|
break;
|
|
case LinphonePresenceActivityHoliday:
|
|
case LinphonePresenceActivityTravel:
|
|
case LinphonePresenceActivityVacation:
|
|
online_status = LinphoneStatusVacation;
|
|
break;
|
|
case LinphonePresenceActivityBusy:
|
|
case LinphonePresenceActivityLookingForWork:
|
|
case LinphonePresenceActivityPlaying:
|
|
case LinphonePresenceActivityShopping:
|
|
case LinphonePresenceActivityTV:
|
|
online_status = LinphoneStatusBusy;
|
|
break;
|
|
case LinphonePresenceActivityInTransit:
|
|
case LinphonePresenceActivitySteering:
|
|
online_status = LinphoneStatusBeRightBack;
|
|
break;
|
|
case LinphonePresenceActivityOnThePhone:
|
|
online_status = LinphoneStatusOnThePhone;
|
|
break;
|
|
case LinphonePresenceActivityOther:
|
|
case LinphonePresenceActivityPermanentAbsence:
|
|
online_status = LinphoneStatusMoved;
|
|
break;
|
|
case LinphonePresenceActivityUnknown:
|
|
/* Rely on the basic status information. */
|
|
break;
|
|
case LinphonePresenceActivityOnline:
|
|
/* Should not happen! */
|
|
/*ms_warning("LinphonePresenceActivityOnline should not happen here!");*/
|
|
break;
|
|
case LinphonePresenceActivityOffline:
|
|
online_status = LinphoneStatusOffline;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return online_status;
|
|
}
|
|
|
|
const LinphonePresenceModel * linphone_friend_get_presence_model(LinphoneFriend *lf) {
|
|
return lf->presence;
|
|
}
|
|
|
|
void linphone_friend_set_presence_model(LinphoneFriend *lf, LinphonePresenceModel *presence) {
|
|
if (lf->presence != NULL) {
|
|
linphone_presence_model_unref(lf->presence);
|
|
}
|
|
lf->presence = presence;
|
|
}
|
|
|
|
bool_t linphone_friend_is_presence_received(const LinphoneFriend *lf) {
|
|
return lf->presence_received;
|
|
}
|
|
|
|
BuddyInfo * linphone_friend_get_info(const LinphoneFriend *lf){
|
|
return lf->info;
|
|
}
|
|
|
|
/*
|
|
* updates the subscriptions.
|
|
* If only_when_registered is TRUE, subscribe will be sent only if the friend's corresponding proxy config is in registered.
|
|
* Otherwise if the proxy config goes to unregistered state, the subscription refresh will be suspended.
|
|
* An optional proxy whose state has changed can be passed to optimize the processing.
|
|
**/
|
|
void linphone_friend_update_subscribes(LinphoneFriend *fr, LinphoneProxyConfig *proxy, bool_t only_when_registered){
|
|
int can_subscribe=1;
|
|
|
|
if (only_when_registered && (fr->subscribe || fr->subscribe_active)){
|
|
LinphoneProxyConfig *cfg=linphone_core_lookup_known_proxy(fr->lc,fr->uri);
|
|
if (proxy && proxy!=cfg) return;
|
|
if (cfg && cfg->state!=LinphoneRegistrationOk){
|
|
char *tmp=linphone_address_as_string(fr->uri);
|
|
ms_message("Friend [%s] belongs to proxy config with identity [%s], but this one isn't registered. Subscription is suspended.",
|
|
tmp,linphone_proxy_config_get_identity(cfg));
|
|
ms_free(tmp);
|
|
can_subscribe=0;
|
|
}
|
|
}
|
|
if (can_subscribe && fr->subscribe && fr->subscribe_active==FALSE){
|
|
ms_message("Sending a new SUBSCRIBE");
|
|
__linphone_friend_do_subscribe(fr);
|
|
}else if (can_subscribe && fr->subscribe_active && !fr->subscribe){
|
|
linphone_friend_unsubscribe(fr);
|
|
}else if (!can_subscribe && fr->outsub){
|
|
fr->subscribe_active=FALSE;
|
|
sal_op_stop_refreshing(fr->outsub);
|
|
}
|
|
}
|
|
|
|
void linphone_friend_apply(LinphoneFriend *fr, LinphoneCore *lc){
|
|
LinphonePresenceModel *model;
|
|
|
|
if (fr->uri==NULL) {
|
|
ms_warning("No sip url defined.");
|
|
return;
|
|
}
|
|
|
|
linphone_core_write_friends_config(lc);
|
|
|
|
if (fr->inc_subscribe_pending){
|
|
switch(fr->pol){
|
|
case LinphoneSPWait:
|
|
model = linphone_presence_model_new_with_activity(LinphonePresenceActivityOther, "Waiting for user acceptance");
|
|
linphone_friend_notify(fr,model);
|
|
linphone_presence_model_unref(model);
|
|
break;
|
|
case LinphoneSPAccept:
|
|
if (fr->lc!=NULL)
|
|
linphone_friend_notify(fr,fr->lc->presence_model);
|
|
break;
|
|
case LinphoneSPDeny:
|
|
linphone_friend_notify(fr,NULL);
|
|
break;
|
|
}
|
|
fr->inc_subscribe_pending=FALSE;
|
|
}
|
|
if (fr->lc) {
|
|
linphone_friend_list_update_subscriptions(fr->lc->friendlist, NULL, linphone_core_should_subscribe_friends_only_when_registered(fr->lc));
|
|
}
|
|
ms_message("linphone_friend_apply() done.");
|
|
lc->bl_refresh=TRUE;
|
|
fr->commit=FALSE;
|
|
}
|
|
|
|
void linphone_friend_edit(LinphoneFriend *fr){
|
|
}
|
|
|
|
void linphone_friend_done(LinphoneFriend *fr){
|
|
ms_return_if_fail(fr!=NULL);
|
|
if (fr->lc == NULL || !fr->in_list) return;
|
|
linphone_friend_apply(fr,fr->lc);
|
|
}
|
|
|
|
LinphoneFriend * linphone_core_create_friend(LinphoneCore *lc) {
|
|
return linphone_friend_new();
|
|
}
|
|
|
|
LinphoneFriend * linphone_core_create_friend_with_address(LinphoneCore *lc, const char *address) {
|
|
return linphone_friend_new_with_address(address);
|
|
}
|
|
|
|
void linphone_core_add_friend(LinphoneCore *lc, LinphoneFriend *lf) {
|
|
if ((lc->friendlist == NULL) || (linphone_friend_list_add_friend(lc->friendlist, lf) != LinphoneFriendListOK)) return;
|
|
if (ms_list_find(lc->subscribers, lf)) {
|
|
/*if this friend was in the pending subscriber list, now remove it from this list*/
|
|
lc->subscribers = ms_list_remove(lc->subscribers, lf);
|
|
linphone_friend_unref(lf);
|
|
}
|
|
lf->lc = lc; /*I would prefer this to be done in linphone_friend_list_add_friend()*/
|
|
if (linphone_core_ready(lc)) linphone_friend_apply(lf, lc);
|
|
else lf->commit = TRUE;
|
|
}
|
|
|
|
void linphone_core_remove_friend(LinphoneCore *lc, LinphoneFriend *lf) {
|
|
if (linphone_friend_list_remove_friend(lc->friendlist, lf) == LinphoneFriendListNonExistentFriend) {
|
|
ms_error("linphone_core_remove_friend(): friend [%p] is not part of core's list.", lf);
|
|
}
|
|
}
|
|
|
|
void linphone_core_update_friends_subscriptions(LinphoneCore *lc, LinphoneProxyConfig *cfg, bool_t only_when_registered){
|
|
if (lc->friendlist != NULL)
|
|
linphone_friend_list_update_subscriptions(lc->friendlist, cfg, only_when_registered);
|
|
}
|
|
|
|
bool_t linphone_core_should_subscribe_friends_only_when_registered(const LinphoneCore *lc){
|
|
return lp_config_get_int(lc->config,"sip","subscribe_presence_only_when_registered",1);
|
|
}
|
|
|
|
void linphone_core_send_initial_subscribes(LinphoneCore *lc){
|
|
bool_t proxy_config_for_rls_presence_uri_domain = FALSE;
|
|
LinphoneAddress *rls_address = NULL;
|
|
const MSList *elem;
|
|
|
|
if (lc->initial_subscribes_sent) return;
|
|
lc->initial_subscribes_sent=TRUE;
|
|
if (lc->friendlist->rls_uri != NULL) {
|
|
rls_address = linphone_core_create_address(lc, lc->friendlist->rls_uri);
|
|
}
|
|
if (rls_address != NULL) {
|
|
const char *rls_domain = linphone_address_get_domain(rls_address);
|
|
if (rls_domain != NULL) {
|
|
for (elem = linphone_core_get_proxy_config_list(lc); elem != NULL; elem = elem->next) {
|
|
LinphoneProxyConfig *cfg = (LinphoneProxyConfig *)elem->data;
|
|
const char *proxy_domain = linphone_proxy_config_get_domain(cfg);
|
|
if (strcmp(rls_domain, proxy_domain) == 0) {
|
|
proxy_config_for_rls_presence_uri_domain = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
linphone_address_unref(rls_address);
|
|
}
|
|
if (proxy_config_for_rls_presence_uri_domain == TRUE) {
|
|
ms_message("Presence list activated so do not send initial subscribes it will be done when registered");
|
|
} else {
|
|
linphone_core_update_friends_subscriptions(lc,NULL,linphone_core_should_subscribe_friends_only_when_registered(lc));
|
|
}
|
|
}
|
|
|
|
void linphone_core_invalidate_friend_subscriptions(LinphoneCore *lc){
|
|
if (lc->friendlist != NULL)
|
|
linphone_friend_list_invalidate_subscriptions(lc->friendlist);
|
|
lc->initial_subscribes_sent=FALSE;
|
|
}
|
|
|
|
void linphone_friend_set_ref_key(LinphoneFriend *lf, const char *key){
|
|
if (lf->refkey!=NULL){
|
|
ms_free(lf->refkey);
|
|
lf->refkey=NULL;
|
|
}
|
|
if (key)
|
|
lf->refkey=ms_strdup(key);
|
|
if (lf->lc)
|
|
linphone_core_write_friends_config(lf->lc);
|
|
}
|
|
|
|
const char *linphone_friend_get_ref_key(const LinphoneFriend *lf){
|
|
return lf->refkey;
|
|
}
|
|
|
|
LinphoneFriend *linphone_core_find_friend(const LinphoneCore *lc, const LinphoneAddress *addr){
|
|
return linphone_friend_list_find_friend_by_address(lc->friendlist, addr);
|
|
}
|
|
|
|
LinphoneFriend *linphone_core_get_friend_by_address(const LinphoneCore *lc, const char *uri){
|
|
return linphone_friend_list_find_friend_by_uri(lc->friendlist, uri);
|
|
}
|
|
|
|
LinphoneFriend *linphone_core_get_friend_by_ref_key(const LinphoneCore *lc, const char *key){
|
|
return linphone_friend_list_find_friend_by_ref_key(lc->friendlist, key);
|
|
}
|
|
|
|
#define key_compare(s1,s2) strcmp(s1,s2)
|
|
|
|
LinphoneSubscribePolicy __policy_str_to_enum(const char* pol){
|
|
if (key_compare("accept",pol)==0){
|
|
return LinphoneSPAccept;
|
|
}
|
|
if (key_compare("deny",pol)==0){
|
|
return LinphoneSPDeny;
|
|
}
|
|
if (key_compare("wait",pol)==0){
|
|
return LinphoneSPWait;
|
|
}
|
|
ms_warning("Unrecognized subscribe policy: %s",pol);
|
|
return LinphoneSPWait;
|
|
}
|
|
|
|
LinphoneProxyConfig *__index_to_proxy(LinphoneCore *lc, int index){
|
|
if (index>=0) return (LinphoneProxyConfig*)ms_list_nth_data(lc->sip_conf.proxies,index);
|
|
else return NULL;
|
|
}
|
|
|
|
LinphoneFriend * linphone_friend_new_from_config_file(LinphoneCore *lc, int index){
|
|
const char *tmp;
|
|
char item[50];
|
|
int a;
|
|
LinphoneFriend *lf;
|
|
LpConfig *config=lc->config;
|
|
|
|
sprintf(item,"friend_%i",index);
|
|
|
|
if (!lp_config_has_section(config,item)){
|
|
return NULL;
|
|
}
|
|
|
|
tmp=lp_config_get_string(config,item,"url",NULL);
|
|
if (tmp==NULL) {
|
|
return NULL;
|
|
}
|
|
lf=linphone_friend_new_with_address(tmp);
|
|
if (lf==NULL) {
|
|
return NULL;
|
|
}
|
|
tmp=lp_config_get_string(config,item,"pol",NULL);
|
|
if (tmp==NULL) linphone_friend_set_inc_subscribe_policy(lf,LinphoneSPWait);
|
|
else{
|
|
linphone_friend_set_inc_subscribe_policy(lf,__policy_str_to_enum(tmp));
|
|
}
|
|
a=lp_config_get_int(config,item,"subscribe",0);
|
|
linphone_friend_send_subscribe(lf,a);
|
|
a = lp_config_get_int(config, item, "presence_received", 0);
|
|
lf->presence_received = (bool_t)a;
|
|
|
|
linphone_friend_set_ref_key(lf,lp_config_get_string(config,item,"refkey",NULL));
|
|
return lf;
|
|
}
|
|
|
|
const char *__policy_enum_to_str(LinphoneSubscribePolicy pol){
|
|
switch(pol){
|
|
case LinphoneSPAccept:
|
|
return "accept";
|
|
break;
|
|
case LinphoneSPDeny:
|
|
return "deny";
|
|
break;
|
|
case LinphoneSPWait:
|
|
return "wait";
|
|
break;
|
|
}
|
|
ms_warning("Invalid policy enum value.");
|
|
return "wait";
|
|
}
|
|
|
|
void linphone_friend_write_to_config_file(LpConfig *config, LinphoneFriend *lf, int index){
|
|
char key[50];
|
|
char *tmp;
|
|
const char *refkey;
|
|
|
|
sprintf(key,"friend_%i",index);
|
|
|
|
if (lf==NULL){
|
|
lp_config_clean_section(config,key);
|
|
return;
|
|
}
|
|
if (lf->uri!=NULL){
|
|
tmp=linphone_address_as_string(lf->uri);
|
|
if (tmp==NULL) {
|
|
return;
|
|
}
|
|
lp_config_set_string(config,key,"url",tmp);
|
|
ms_free(tmp);
|
|
}
|
|
lp_config_set_string(config,key,"pol",__policy_enum_to_str(lf->pol));
|
|
lp_config_set_int(config,key,"subscribe",lf->subscribe);
|
|
lp_config_set_int(config, key, "presence_received", lf->presence_received);
|
|
|
|
refkey=linphone_friend_get_ref_key(lf);
|
|
if (refkey){
|
|
lp_config_set_string(config,key,"refkey",refkey);
|
|
}
|
|
}
|
|
|
|
void linphone_core_write_friends_config(LinphoneCore* lc)
|
|
{
|
|
MSList *elem;
|
|
int i;
|
|
int store_friends;
|
|
if (! linphone_core_ready(lc)) return; /*dont write config when reading it !*/
|
|
store_friends = lp_config_get_int(lc->config, "misc", "store_friends", 1);
|
|
if (store_friends) {
|
|
for (elem=lc->friendlist->friends,i=0; elem!=NULL; elem=ms_list_next(elem),i++){
|
|
linphone_friend_write_to_config_file(lc->config,(LinphoneFriend*)elem->data,i);
|
|
}
|
|
linphone_friend_write_to_config_file(lc->config,NULL,i); /* set the end */
|
|
}
|
|
}
|
|
|
|
LinphoneCore *linphone_friend_get_core(const LinphoneFriend *fr){
|
|
return fr->lc;
|
|
}
|
|
|
|
LinphoneFriend *linphone_friend_ref(LinphoneFriend *lf) {
|
|
belle_sip_object_ref(lf);
|
|
return lf;
|
|
}
|
|
|
|
void linphone_friend_unref(LinphoneFriend *lf) {
|
|
belle_sip_object_unref(lf);
|
|
}
|
|
|
|
/* DEPRECATED */
|
|
void linphone_friend_destroy(LinphoneFriend *lf) {
|
|
linphone_friend_unref(lf);
|
|
}
|
|
|
|
/*drops all references to the core and unref*/
|
|
void _linphone_friend_release(LinphoneFriend *lf){
|
|
lf->lc = NULL;
|
|
_linphone_friend_release_ops(lf);
|
|
linphone_friend_unref(lf);
|
|
}
|
|
|
|
BELLE_SIP_DECLARE_NO_IMPLEMENTED_INTERFACES(LinphoneFriend);
|
|
|
|
BELLE_SIP_INSTANCIATE_VPTR(LinphoneFriend, belle_sip_object_t,
|
|
(belle_sip_object_destroy_t) _linphone_friend_destroy,
|
|
NULL, // clone
|
|
_linphone_friend_marshall,
|
|
FALSE
|
|
); |