mirrors/linphone-iphone
1
0
Fork 1
mirror of https://gitlab.linphone.org/BC/public/linphone-iphone.git synced 2026-01-17 11:08:06 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
linphone-iphone/Classes/LinphoneCoreSettingsStore.m
Jehan Monnier 696643b92b update liblinphone to fix 488 crashes
2013-11-06 17:44:40 +01:00

689 lines
30 KiB
Objective-C
Raw Blame History

/* LinphoneCoreSettingsStore.m
*
* Copyright (C) 2012 Belledonne Comunications, Grenoble, France
*
* 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 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.
*/
#import "LinphoneCoreSettingsStore.h"
#include "lpconfig.h"
extern void linphone_iphone_log_handler(int lev, const char *fmt, va_list args);
@implementation LinphoneCoreSettingsStore
- (id)init {
self = [super init];
if (self){
dict = [[NSMutableDictionary alloc] init];
changedDict = [[NSMutableDictionary alloc] init];
[self transformLinphoneCoreToKeys];
}
return self;
}
- (void)dealloc {
[dict release];
[changedDict release];
[super dealloc];
}
- (void)transformKeysToLinphoneCore {
//LinphoneCore *lc=[LinphoneManager getLc];
}
- (void)setString:(const char*)value forKey:(NSString*)key {
id obj=Nil;
if (value) obj=[[NSString alloc] initWithCString:value encoding:[NSString defaultCStringEncoding] ];
[self setObject: obj forKey:key];
}
- (NSString*)stringForKey:(NSString*) key {
return [self objectForKey: key];
}
- (void)transformCodecsToKeys: (const MSList *)codecs {
LinphoneCore *lc=[LinphoneManager getLc];
const MSList *elem=codecs;
for(;elem!=NULL;elem=elem->next){
PayloadType *pt=(PayloadType*)elem->data;
NSString *pref=[LinphoneManager getPreferenceForCodec:pt->mime_type withRate:pt->clock_rate];
if (pref){
bool_t value = linphone_core_payload_type_enabled(lc,pt);
[self setBool:value forKey: pref];
}else{
[LinphoneLogger logc:LinphoneLoggerWarning format:"Codec %s/%i supported by core is not shown in iOS app config view.",
pt->mime_type,pt->clock_rate];
}
}
}
- (void)transformLinphoneCoreToKeys {
LinphoneCore *lc=[LinphoneManager getLc];
LinphoneProxyConfig *cfg=NULL;
linphone_core_get_default_proxy(lc,&cfg);
if (cfg){
const char *identity=linphone_proxy_config_get_identity(cfg);
LinphoneAddress *addr=linphone_address_new(identity);
if (addr){
const char *proxy=linphone_proxy_config_get_addr(cfg);
LinphoneAddress *proxy_addr=linphone_address_new(proxy);
int port=linphone_address_get_port(proxy_addr);
[self setString: linphone_address_get_username(addr) forKey:@"username_preference"];
[self setString: linphone_address_get_domain(addr) forKey:@"domain_preference"];
[self setInteger: linphone_proxy_config_get_expires(cfg) forKey:@"expire_preference"];
[self setString: linphone_proxy_config_get_dial_prefix(cfg) forKey:@"prefix_preference"];
if (strcmp(linphone_address_get_domain(addr),linphone_address_get_domain(proxy_addr))!=0
|| port>0){
char tmp[256]={0};
if (port>0) {
snprintf(tmp,sizeof(tmp)-1,"%s:%i",linphone_address_get_domain(proxy_addr),port);
}else snprintf(tmp,sizeof(tmp)-1,"%s",linphone_address_get_domain(proxy_addr));
[self setString: tmp forKey:@"proxy_preference"];
}
linphone_address_destroy(addr);
linphone_address_destroy(proxy_addr);
[self setBool: (linphone_proxy_config_get_route(cfg)!=NULL) forKey:@"outbound_proxy_preference"];
[self setBool:linphone_proxy_config_get_dial_escape_plus(cfg) forKey:@"substitute_+_by_00_preference"];
}
} else {
[self setInteger: lp_config_get_int(linphone_core_get_config(lc),"default_values","reg_expires", 600) forKey:@"expire_preference"];
[self setObject:@"" forKey:@"username_preference"];
[self setObject:@"" forKey:@"domain_preference"];
[self setObject:@"" forKey:@"proxy_preference"];
[self setObject:@"" forKey:@"password_preference"];
[self setBool:FALSE forKey:@"outbound_proxy_preference"];
}
[self setBool:lp_config_get_int(linphone_core_get_config(lc), LINPHONERC_APPLICATION_KEY, "pushnotification_preference", 0) forKey:@"pushnotification_preference"];
{
LinphoneAddress *parsed = linphone_core_get_primary_contact_parsed(lc);
if(parsed != NULL) {
[self setString: linphone_address_get_display_name(parsed) forKey:@"primary_displayname_preference"];
[self setString: linphone_address_get_username(parsed) forKey:@"primary_username_preference"];
}
linphone_address_destroy(parsed);
}
{
{
int minPort, maxPort;
linphone_core_get_audio_port_range(lc, &minPort, &maxPort);
if(minPort != maxPort)
[self setObject:[NSString stringWithFormat:@"%d-%d", minPort, maxPort] forKey:@"audio_port_preference"];
else
[self setObject:[NSString stringWithFormat:@"%d", minPort] forKey:@"audio_port_preference"];
}
{
int minPort, maxPort;
linphone_core_get_video_port_range(lc, &minPort, &maxPort);
if(minPort != maxPort)
[self setObject:[NSString stringWithFormat:@"%d-%d", minPort, maxPort] forKey:@"video_port_preference"];
else
[self setObject:[NSString stringWithFormat:@"%d", minPort] forKey:@"video_port_preference"];
}
}
{
[self setInteger: linphone_core_get_upload_bandwidth(lc) forKey:@"upload_bandwidth_preference"];
[self setInteger: linphone_core_get_download_bandwidth(lc) forKey:@"download_bandwidth_preference"];
}
{
[self setFloat:linphone_core_get_playback_gain_db(lc) forKey:@"playback_gain_preference"];
[self setFloat:linphone_core_get_mic_gain_db(lc) forKey:@"microphone_gain_preference"];
}
{
LCSipTransports tp;
const char *tname = "udp";
int port = 5060;
linphone_core_get_sip_transports(lc, &tp);
if (tp.udp_port>0) {
tname = "udp";
port = tp.udp_port;
} else if (tp.tcp_port>0) {
tname = "tcp";
port = tp.tcp_port;
} else if (tp.tls_port>0) {
tname = "tls";
port = tp.tls_port;
}
[self setString:tname forKey:@"transport_preference"];
[self setInteger:port forKey:@"port_preference"];
[self setInteger:lp_config_get_int(linphone_core_get_config(lc),"sip","sip_random_port", 1) forKey:@"random_port_preference"];
}
{
LinphoneAuthInfo *ai;
const MSList *elem=linphone_core_get_auth_info_list(lc);
if (elem && (ai=(LinphoneAuthInfo*)elem->data)){
[self setString: linphone_auth_info_get_passwd(ai) forKey:@"password_preference"];
}
}
{
[self setString: linphone_core_get_stun_server(lc) forKey:@"stun_preference"];
[self
setBool:linphone_core_get_firewall_policy(lc)==LinphonePolicyUseIce forKey:@"ice_preference"];
}
{
[self transformCodecsToKeys: linphone_core_get_audio_codecs(lc)];
[self transformCodecsToKeys: linphone_core_get_video_codecs(lc)];
[self setBool:linphone_core_adaptive_rate_control_enabled(lc) forKey:@"adaptive_rate_control_preference"];
LpConfig *config = linphone_core_get_config(lc);
[self setInteger:lp_config_get_int(config, "audio", "codec_bitrate_limit", 32) forKey:@"audio_codec_bitrate_limit_preference"];
PayloadType *pt;
const MSList *elem;
for (elem=linphone_core_get_audio_codecs(lc);elem!=NULL;elem=elem->next){
pt=(PayloadType*)elem->data;
if ((strcmp(pt->mime_type, "opus") == 0) || (strcmp(pt->mime_type, "mpeg4-generic") == 0)) {
pt->normal_bitrate = [self integerForKey:@"audio_codec_bitrate_limit_preference"] * 1000;
}
}
}
{
LinphoneMediaEncryption menc=linphone_core_get_media_encryption(lc);
const char *val;
switch(menc){
case LinphoneMediaEncryptionSRTP:
val="SRTP";
break;
case LinphoneMediaEncryptionZRTP:
val="ZRTP";
break;
default:
val="None";
}
[self setString:val forKey:@"media_encryption_preference"];
}
[self setString: lp_config_get_string(linphone_core_get_config(lc), LINPHONERC_APPLICATION_KEY, "rotation_preference", "auto") forKey:@"rotation_preference"];
[self setBool: lp_config_get_int(linphone_core_get_config(lc), LINPHONERC_APPLICATION_KEY, "edge_opt_preference", 0) forKey:@"edge_opt_preference"];
[self setBool: lp_config_get_int(linphone_core_get_config(lc), LINPHONERC_APPLICATION_KEY, "enable_first_login_view_preference", 0) forKey:@"enable_first_login_view_preference"];
[self setBool: lp_config_get_int(linphone_core_get_config(lc), LINPHONERC_APPLICATION_KEY, "debugenable_preference", 0) forKey:@"debugenable_preference"];
[self setBool: lp_config_get_int(linphone_core_get_config(lc), LINPHONERC_APPLICATION_KEY, "animations_preference", 1) forKey:@"animations_preference"];
[self setBool: lp_config_get_int(linphone_core_get_config(lc), LINPHONERC_APPLICATION_KEY, "wifi_only_preference", 0) forKey:@"wifi_only_preference"];
[self setString: lp_config_get_string(linphone_core_get_config(lc), LINPHONERC_APPLICATION_KEY, "sharing_server_preference", NULL) forKey:@"sharing_server_preference"];
/*keep this one also in the standardUserDefaults so that it can be read before starting liblinphone*/
BOOL start_at_boot = TRUE;
if ([[NSUserDefaults standardUserDefaults] objectForKey:@"start_at_boot_preference"] != Nil)
start_at_boot = [[NSUserDefaults standardUserDefaults] boolForKey:@"start_at_boot_preference"];
[self setBool: start_at_boot forKey:@"start_at_boot_preference"];
BOOL background_mode = TRUE;
if ([[NSUserDefaults standardUserDefaults] objectForKey:@"backgroundmode_preference"] != Nil)
background_mode =[[NSUserDefaults standardUserDefaults] boolForKey:@"backgroundmode_preference"];
[self setBool: background_mode forKey:@"backgroundmode_preference"];
if (linphone_core_tunnel_available()){
/*FIXME: enhance linphonecore API to handle tunnel more easily in applications */
//LinphoneTunnel *tun=linphone_core_get_tunnel(lc);
//[self setString: linphone_tunnel_get_servers(tun) forKey:tunnel_address_preference];
//[self setInteger: blabla forKey:tunnel_port_preference];
//[self setString: forKey:@"tunnel_enabled_preference"];
}
{
const LinphoneVideoPolicy *pol;
[self setBool: linphone_core_video_enabled(lc) forKey:@"enable_video_preference"];
pol=linphone_core_get_video_policy(lc);
[self setBool:(pol->automatically_initiate) forKey:@"start_video_preference"];
[self setBool:(pol->automatically_accept) forKey:@"accept_video_preference"];
[self setBool:linphone_core_self_view_enabled(lc) forKey:@"self_video_preference"];
[self setBool:linphone_core_video_preview_enabled(lc) forKey:@"preview_preference"];
MSVideoSize vsize = linphone_core_get_preferred_video_size(lc);
int index;
if ((vsize.width == MS_VIDEO_SIZE_720P_W) && (vsize.height == MS_VIDEO_SIZE_720P_H)) {
index = 0;
} else if ((vsize.width == MS_VIDEO_SIZE_VGA_W) && (vsize.height == MS_VIDEO_SIZE_VGA_H)) {
index = 1;
} else {
index = 2;
}
[self setInteger:index forKey:@"video_preferred_size_preference"];
}
{
[self setBool:linphone_core_get_use_info_for_dtmf(lc) forKey:@"sipinfo_dtmf_preference"];
[self setBool:linphone_core_get_use_rfc2833_for_dtmf(lc) forKey:@"rfc_dtmf_preference"];
[self setInteger:linphone_core_get_inc_timeout(lc) forKey:@"incoming_call_timeout_preference"];
[self setInteger:linphone_core_get_in_call_timeout(lc) forKey:@"in_call_timeout_preference"];
}
[changedDict release];
changedDict = [[NSMutableDictionary alloc] init];
// Post event
NSDictionary *eventDic = [NSDictionary dictionaryWithObject:self forKey:@"settings"];
[[NSNotificationCenter defaultCenter] postNotificationName:kLinphoneLogsUpdate object:self userInfo:eventDic];
}
- (void)setObject:(id)value forKey:(NSString *)key {
[dict setValue:value forKey:key];
[changedDict setValue:[NSNumber numberWithBool:TRUE] forKey:key];
}
- (id)objectForKey:(NSString*)key {
return [dict valueForKey:key];
}
- (BOOL)valueChangedForKey:(NSString*)key {
return [[changedDict valueForKey:key] boolValue];
}
- (void)synchronizeAccount {
LinphoneCore *lc = [LinphoneManager getLc];
LinphoneManager* lLinphoneMgr = [LinphoneManager instance];
LinphoneProxyConfig* proxyCfg = NULL;
/* unregister before modifying any settings */
{
linphone_core_get_default_proxy(lc, &proxyCfg);
if (proxyCfg) {
// this will force unregister WITHOUT destorying the proxyCfg object
linphone_proxy_config_edit(proxyCfg);
int i=0;
while (linphone_proxy_config_get_state(proxyCfg)!=LinphoneRegistrationNone &&
linphone_proxy_config_get_state(proxyCfg)!=LinphoneRegistrationCleared &&
linphone_proxy_config_get_state(proxyCfg)!=LinphoneRegistrationFailed &&
i++<40 ) {
linphone_core_iterate(lc);
usleep(10000);
}
}
}
NSString* transport = [self stringForKey:@"transport_preference"];
int port_preference = [self integerForKey:@"port_preference"];
BOOL random_port_preference = [self boolForKey:@"random_port_preference"];
lp_config_set_int(linphone_core_get_config(lc),"sip","sip_random_port", random_port_preference);
lp_config_set_int(linphone_core_get_config(lc),"sip","sip_tcp_random_port", random_port_preference);
lp_config_set_int(linphone_core_get_config(lc),"sip","sip_tls_random_port", random_port_preference);
if(random_port_preference) {
port_preference = (0xDFFF&random())+1024;
[self setInteger:port_preference forKey:@"port_preference"]; // Update back preference
}
LCSipTransports transportValue={0};
if (transport!=nil) {
if (linphone_core_get_sip_transports(lc, &transportValue)) {
[LinphoneLogger logc:LinphoneLoggerError format:"cannot get current transport"];
}
// Only one port can be set at one time, the others's value is 0
if ([transport isEqualToString:@"tcp"]) {
transportValue.tcp_port=port_preference;
transportValue.udp_port=0;
transportValue.tls_port=0;
} else if ([transport isEqualToString:@"udp"]){
transportValue.udp_port=port_preference;
transportValue.tcp_port=0;
transportValue.tls_port=0;
} else if ([transport isEqualToString:@"tls"]){
transportValue.tls_port=port_preference;
transportValue.tcp_port=0;
transportValue.udp_port=0;
} else {
[LinphoneLogger logc:LinphoneLoggerError format:"unexpected transport [%s]",[transport cStringUsingEncoding:[NSString defaultCStringEncoding]]];
}
if (linphone_core_set_sip_transports(lc, &transportValue)) {
[LinphoneLogger logc:LinphoneLoggerError format:"cannot set transport"];
}
}
//configure sip account
//mandatory parameters
NSString* username = [self stringForKey:@"username_preference"];
NSString* domain = [self stringForKey:@"domain_preference"];
NSString* accountPassword = [self stringForKey:@"password_preference"];
bool isOutboundProxy= [self boolForKey:@"outbound_proxy_preference"];
//clear auth info list
linphone_core_clear_all_auth_info(lc);
//clear existing proxy config
linphone_core_clear_proxy_config(lc);
if (username && [username length] >0 && domain && [domain length]>0) {
NSString* proxyAddress = [self stringForKey:@"proxy_preference"];
if ((!proxyAddress || [proxyAddress length] <1 ) && domain) {
proxyAddress = [NSString stringWithFormat:@"sip:%@",domain] ;
} else {
proxyAddress = [NSString stringWithFormat:@"sip:%@",proxyAddress] ;
}
const char* proxy = [proxyAddress cStringUsingEncoding:[NSString defaultCStringEncoding]];
//possible valid config detected
proxyCfg = linphone_core_create_proxy_config(lc);
char normalizedUserName[256];
LinphoneAddress* linphoneAddress = linphone_address_new("sip:user@domain.com");
linphone_proxy_config_normalize_number(proxyCfg, [username cStringUsingEncoding:[NSString defaultCStringEncoding]], normalizedUserName, sizeof(normalizedUserName));
linphone_address_set_username(linphoneAddress, normalizedUserName);
linphone_address_set_domain(linphoneAddress, [domain cStringUsingEncoding:[NSString defaultCStringEncoding]]);
const char* identity = linphone_address_as_string_uri_only(linphoneAddress);
const char* password = [accountPassword cStringUsingEncoding:[NSString defaultCStringEncoding]];
// configure proxy entries
linphone_proxy_config_set_identity(proxyCfg, identity);
linphone_proxy_config_set_server_addr(proxyCfg, proxy);
linphone_proxy_config_enable_register(proxyCfg, true);
// add username password
LinphoneAddress *from = linphone_address_new(identity);
LinphoneAuthInfo *info;
if (from != 0){
info=linphone_auth_info_new(linphone_address_get_username(from),NULL,password,NULL,NULL,linphone_proxy_config_get_domain(proxyCfg));
linphone_core_add_auth_info(lc,info);
linphone_address_destroy(from);
}
int expire = [self integerForKey:@"expire_preference"];
linphone_proxy_config_expires(proxyCfg,expire);
BOOL isWifiOnly = [self boolForKey:@"wifi_only_preference"];
if (isWifiOnly && lLinphoneMgr.connectivity == wwan) {
linphone_proxy_config_expires(proxyCfg, 0);
} else {
linphone_proxy_config_expires(proxyCfg, expire);
}
if (isOutboundProxy)
linphone_proxy_config_set_route(proxyCfg, proxy);
if ([self objectForKey:@"prefix_preference"]) {
NSString* prefix = [self stringForKey:@"prefix_preference"];
if ([prefix length]>0) {
linphone_proxy_config_set_dial_prefix(proxyCfg, [prefix cStringUsingEncoding:[NSString defaultCStringEncoding]]);
}
}
if ([self objectForKey:@"substitute_+_by_00_preference"]) {
bool substitute_plus_by_00 = [self boolForKey:@"substitute_+_by_00_preference"];
linphone_proxy_config_set_dial_escape_plus(proxyCfg,substitute_plus_by_00);
}
BOOL pushnotification = [self boolForKey:@"pushnotification_preference"];
lp_config_set_int(linphone_core_get_config(lc), LINPHONERC_APPLICATION_KEY, "pushnotification_preference", pushnotification);
[[LinphoneManager instance] addPushTokenToProxyConfig:proxyCfg];
linphone_core_add_proxy_config(lc,proxyCfg);
//set to default proxy
linphone_core_set_default_proxy(lc,proxyCfg);
linphone_address_destroy(linphoneAddress);
}
[[[LinphoneManager instance] fastAddressBook] reload];
}
+ (int)validPort:(int)port {
if(port < 0) {
return 0;
}
if(port > 65535) {
return 65535;
}
return port;
}
+ (BOOL)parsePortRange:(NSString*)text minPort:(int*)minPort maxPort:(int*)maxPort {
NSError* error = nil;
*minPort = -1;
*maxPort = -1;
NSRegularExpression* regex = [NSRegularExpression regularExpressionWithPattern:@"([0-9]+)(([^0-9]+)([0-9]+))?" options:0 error:&error];
if(error != NULL)
return FALSE;
NSArray* matches = [regex matchesInString:text options:0 range:NSMakeRange(0, [text length])];
if([matches count] == 1) {
NSTextCheckingResult *match = [matches objectAtIndex:0];
bool range = [match rangeAtIndex:2].length > 0;
if(!range) {
NSRange rangeMinPort = [match rangeAtIndex:1];
*minPort = [LinphoneCoreSettingsStore validPort:[[text substringWithRange:rangeMinPort] integerValue]];
*maxPort = *minPort;
return TRUE;
} else {
NSRange rangeMinPort = [match rangeAtIndex:1];
*minPort = [LinphoneCoreSettingsStore validPort:[[text substringWithRange:rangeMinPort] integerValue]];
NSRange rangeMaxPort = [match rangeAtIndex:4];
*maxPort = [LinphoneCoreSettingsStore validPort:[[text substringWithRange:rangeMaxPort] integerValue]];
if(*minPort > *maxPort) {
*minPort = *maxPort;
}
return TRUE;
}
}
return FALSE;
}
- (BOOL)synchronize {
if (![LinphoneManager isLcReady]) return YES;
LinphoneCore *lc=[LinphoneManager getLc];
BOOL account_changed;
account_changed=[self valueChangedForKey:@"username_preference"]
|| [self valueChangedForKey:@"password_preference"]
|| [self valueChangedForKey:@"domain_preference"]
|| [self valueChangedForKey:@"expire_preference"]
|| [self valueChangedForKey:@"proxy_preference"]
|| [self valueChangedForKey:@"outbound_proxy_preference"]
|| [self valueChangedForKey:@"transport_preference"]
|| [self valueChangedForKey:@"port_preference"]
|| [self valueChangedForKey:@"random_port_preference"]
|| [self valueChangedForKey:@"prefix_preference"]
|| [self valueChangedForKey:@"substitute_+_by_00_preference"]
|| [self valueChangedForKey:@"pushnotification_preference"];
if (account_changed)
[self synchronizeAccount];
//Configure Codecs
PayloadType *pt;
const MSList *elem;
for (elem=linphone_core_get_audio_codecs(lc);elem!=NULL;elem=elem->next){
pt=(PayloadType*)elem->data;
NSString *pref=[LinphoneManager getPreferenceForCodec:pt->mime_type withRate:pt->clock_rate];
linphone_core_enable_payload_type(lc,pt,[self boolForKey: pref]);
if ((strcmp(pt->mime_type, "opus") == 0) || (strcmp(pt->mime_type, "mpeg4-generic") == 0)) {
pt->normal_bitrate = [self integerForKey:@"audio_codec_bitrate_limit_preference"] * 1000;
}
}
for (elem=linphone_core_get_video_codecs(lc);elem!=NULL;elem=elem->next){
pt=(PayloadType*)elem->data;
NSString *pref=[LinphoneManager getPreferenceForCodec:pt->mime_type withRate:pt->clock_rate];
linphone_core_enable_payload_type(lc,pt,[self boolForKey: pref]);
}
LpConfig *config = linphone_core_get_config(lc);
lp_config_set_int(config, "audio", "codec_bitrate_limit", [self integerForKey:@"audio_codec_bitrate_limit_preference"]);
linphone_core_enable_adaptive_rate_control(lc, [self boolForKey:@"adaptive_rate_control_preference"]);
linphone_core_set_use_info_for_dtmf(lc, [self boolForKey:@"sipinfo_dtmf_preference"]);
linphone_core_set_use_rfc2833_for_dtmf(lc, [self boolForKey:@"rfc_dtmf_preference"]);
linphone_core_set_inc_timeout(lc, [self integerForKey:@"incoming_call_timeout_preference"]);
linphone_core_set_in_call_timeout(lc, [self integerForKey:@"in_call_timeout_preference"]);
bool enableVideo = [self boolForKey:@"enable_video_preference"];
linphone_core_enable_video(lc, enableVideo, enableVideo);
NSString *menc = [self stringForKey:@"media_encryption_preference"];
if (menc && [menc compare:@"SRTP"] == NSOrderedSame)
linphone_core_set_media_encryption(lc, LinphoneMediaEncryptionSRTP);
else if (menc && [menc compare:@"ZRTP"] == NSOrderedSame)
linphone_core_set_media_encryption(lc, LinphoneMediaEncryptionZRTP);
else
linphone_core_set_media_encryption(lc, LinphoneMediaEncryptionNone);
NSString* stun_server = [self stringForKey:@"stun_preference"];
if ([stun_server length] > 0){
linphone_core_set_stun_server(lc, [stun_server UTF8String]);
BOOL ice_preference = [self boolForKey:@"ice_preference"];
if(ice_preference) {
linphone_core_set_firewall_policy(lc, LinphonePolicyUseIce);
} else {
linphone_core_set_firewall_policy(lc, LinphonePolicyUseStun);
}
} else {
linphone_core_set_stun_server(lc, NULL);
linphone_core_set_firewall_policy(lc, LinphonePolicyNoFirewall);
}
LinphoneVideoPolicy policy;
policy.automatically_accept = [self boolForKey:@"accept_video_preference"];
policy.automatically_initiate = [self boolForKey:@"start_video_preference"];
linphone_core_set_video_policy(lc, &policy);
linphone_core_enable_self_view(lc, [self boolForKey:@"self_video_preference"]);
linphone_core_enable_video_preview(lc, [self boolForKey:@"preview_preference"]);
MSVideoSize vsize;
int bw;
switch ([self integerForKey:@"video_preferred_size_preference"]) {
case 0:
MS_VIDEO_SIZE_ASSIGN(vsize, 720P);
bw = 1024 * 1024;
break;
case 1:
MS_VIDEO_SIZE_ASSIGN(vsize, VGA);
bw = 512 * 1024;
break;
case 2:
default:
MS_VIDEO_SIZE_ASSIGN(vsize, QVGA);
bw = 380 * 1024;
break;
}
linphone_core_set_preferred_video_size(lc, vsize);
[self setInteger: bw forKey:@"upload_bandwidth_preference"];
[self setInteger: bw forKey:@"download_bandwidth_preference"];
// Primary contact
NSString* displayname = [self stringForKey:@"primary_displayname_preference"];
NSString* username = [self stringForKey:@"primary_username_preference"];
LinphoneAddress *parsed = linphone_core_get_primary_contact_parsed(lc);
if(parsed != NULL) {
linphone_address_set_display_name(parsed,[displayname cStringUsingEncoding:[NSString defaultCStringEncoding]]);
linphone_address_set_username(parsed,[username cStringUsingEncoding:[NSString defaultCStringEncoding]]);
char *contact = linphone_address_as_string(parsed);
linphone_core_set_primary_contact(lc, contact);
ms_free(contact);
linphone_address_destroy(parsed);
}
// Audio & Video Port
{
NSString *audio_port_preference = [self stringForKey:@"audio_port_preference"];
int minPort, maxPort;
[LinphoneCoreSettingsStore parsePortRange:audio_port_preference minPort:&minPort maxPort:&maxPort];
linphone_core_set_audio_port_range(lc, minPort, maxPort);
}
{
NSString *video_port_preference = [self stringForKey:@"video_port_preference"];
int minPort, maxPort;
[LinphoneCoreSettingsStore parsePortRange:video_port_preference minPort:&minPort maxPort:&maxPort];
linphone_core_set_video_port_range(lc, minPort, maxPort);
}
int upload_bandwidth = [self integerForKey:@"upload_bandwidth_preference"];
linphone_core_set_upload_bandwidth(lc, upload_bandwidth);
int download_bandwidth = [self integerForKey:@"download_bandwidth_preference"];
linphone_core_set_download_bandwidth(lc, download_bandwidth);
float playback_gain = [self floatForKey:@"playback_gain_preference"];
linphone_core_set_playback_gain_db(lc, playback_gain);
float mic_gain = [self floatForKey:@"microphone_gain_preference"];
linphone_core_set_mic_gain_db(lc, mic_gain);
UIDevice* device = [UIDevice currentDevice];
bool backgroundSupported = false;
if ([device respondsToSelector:@selector(isMultitaskingSupported)])
backgroundSupported = [device isMultitaskingSupported];
BOOL isbackgroundModeEnabled;
if (backgroundSupported) {
isbackgroundModeEnabled = [self boolForKey:@"backgroundmode_preference"];
} else {
isbackgroundModeEnabled = false;
}
lp_config_set_int(linphone_core_get_config(lc), LINPHONERC_APPLICATION_KEY, "backgroundmode_preference", isbackgroundModeEnabled);
BOOL firstloginview = [self boolForKey:@"enable_first_login_view_preference"];
lp_config_set_int(linphone_core_get_config(lc), LINPHONERC_APPLICATION_KEY, "enable_first_login_view_preference", firstloginview);
BOOL edgeOpt = [self boolForKey:@"edge_opt_preference"];
lp_config_set_int(linphone_core_get_config(lc), LINPHONERC_APPLICATION_KEY, "edge_opt_preference", edgeOpt);
NSString *landscape = [self stringForKey:@"rotation_preference"];
lp_config_set_string(linphone_core_get_config(lc), LINPHONERC_APPLICATION_KEY, "rotation_preference", [landscape UTF8String]);
BOOL debugmode = [self boolForKey:@"debugenable_preference"];
lp_config_set_int(linphone_core_get_config(lc), LINPHONERC_APPLICATION_KEY, "debugenable_preference", debugmode);
if (debugmode) {
linphone_core_enable_logs_with_cb((OrtpLogFunc)linphone_iphone_log_handler);
ortp_set_log_level_mask(ORTP_DEBUG|ORTP_MESSAGE|ORTP_WARNING|ORTP_ERROR|ORTP_FATAL);
} else {
linphone_core_disable_logs();
}
[[NSUserDefaults standardUserDefaults] setBool:debugmode forKey:@"debugenable_preference"]; //to be used at linphone core startup
BOOL animations = [self boolForKey:@"animations_preference"];
lp_config_set_int(linphone_core_get_config(lc), LINPHONERC_APPLICATION_KEY, "animations_preference", animations);
BOOL wifiOnly = [self boolForKey:@"wifi_only_preference"];
lp_config_set_int(linphone_core_get_config(lc), LINPHONERC_APPLICATION_KEY, "wifi_only_preference", wifiOnly);
if([self valueChangedForKey:@"wifi_only_preference"]) {
[[LinphoneManager instance] setupNetworkReachabilityCallback];
}
NSString* sharing_server = [self stringForKey:@"sharing_server_preference"];
[[LinphoneManager instance] lpConfigSetString:sharing_server forKey:@"sharing_server_preference"];
/*keep this one also in the standardUserDefaults so that it can be read before starting liblinphone*/
BOOL start_at_boot = [self boolForKey:@"start_at_boot_preference"];
[[NSUserDefaults standardUserDefaults] setBool: start_at_boot forKey:@"start_at_boot_preference"];
BOOL background_mode = [self boolForKey:@"backgroundmode_preference"];
[[NSUserDefaults standardUserDefaults] setBool: background_mode forKey:@"backgroundmode_preference"];
// Force synchronize
[[NSUserDefaults standardUserDefaults] synchronize];
[changedDict release];
changedDict = [[NSMutableDictionary alloc] init];
// Post event
NSDictionary *eventDic = [NSDictionary dictionaryWithObject:self forKey:@"settings"];
[[NSNotificationCenter defaultCenter] postNotificationName:kLinphoneSettingsUpdate object:self userInfo:eventDic];
return YES;
}
@end
Reference in a new issue View git blame Copy permalink