| | |
|---|
| | | AEB7CC4C26C26EB2005DD19A /* HDLLinphoneAudioHelper.m in Sources */ = {isa = PBXBuildFile; fileRef = AEB7CC4B26C26EB2005DD19A /* HDLLinphoneAudioHelper.m */; }; |
|---|
| | | AEB7CC7C26C274E1005DD19A /* HDLLinphoneLog.m in Sources */ = {isa = PBXBuildFile; fileRef = AEB7CC7B26C274E1005DD19A /* HDLLinphoneLog.m */; }; |
|---|
| | | AEB7CC7F26C27512005DD19A /* HDLLinphoneProviderDelegate.m in Sources */ = {isa = PBXBuildFile; fileRef = AEB7CC7E26C27512005DD19A /* HDLLinphoneProviderDelegate.m */; }; |
|---|
| | | AEC00E11287403C10009221E /* bctoolbox-tester.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = AEC00E10287403C10009221E /* bctoolbox-tester.framework */; }; |
|---|
| | | AEC00E13287403E80009221E /* limetester.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = AEC00E12287403E80009221E /* limetester.framework */; }; |
|---|
| | | AEC00E15287403F90009221E /* linphonetester.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = AEC00E14287403F90009221E /* linphonetester.framework */; }; |
|---|
| | | AEF6AC05282B8E9B00C9FD36 /* bctoolbox-ios.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = AEF6AC04282B8E9B00C9FD36 /* bctoolbox-ios.framework */; }; |
|---|
| | | /* End PBXBuildFile section */ |
|---|
| | | |
|---|
| | | /* Begin PBXCopyFilesBuildPhase section */ |
|---|
| | |
|---|
| | | AEB7CC7B26C274E1005DD19A /* HDLLinphoneLog.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = HDLLinphoneLog.m; sourceTree = "<group>"; }; |
|---|
| | | AEB7CC7D26C27512005DD19A /* HDLLinphoneProviderDelegate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = HDLLinphoneProviderDelegate.h; sourceTree = "<group>"; }; |
|---|
| | | AEB7CC7E26C27512005DD19A /* HDLLinphoneProviderDelegate.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = HDLLinphoneProviderDelegate.m; sourceTree = "<group>"; }; |
|---|
| | | AEC00E10287403C10009221E /* bctoolbox-tester.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; path = "bctoolbox-tester.framework"; sourceTree = "<group>"; }; |
|---|
| | | AEC00E12287403E80009221E /* limetester.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; path = limetester.framework; sourceTree = "<group>"; }; |
|---|
| | | AEC00E14287403F90009221E /* linphonetester.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; path = linphonetester.framework; sourceTree = "<group>"; }; |
|---|
| | | AEF6AC04282B8E9B00C9FD36 /* bctoolbox-ios.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; path = "bctoolbox-ios.framework"; sourceTree = "<group>"; }; |
|---|
| | | /* End PBXFileReference section */ |
|---|
| | | |
|---|
| | | /* Begin PBXFrameworksBuildPhase section */ |
|---|
| | |
|---|
| | | AE996FC126C22F790000F1F9 /* mswebrtc.framework in Frameworks */, |
|---|
| | | AE996FBD26C22F790000F1F9 /* belr.framework in Frameworks */, |
|---|
| | | AE996FBE26C22F790000F1F9 /* mediastreamer2.framework in Frameworks */, |
|---|
| | | AEC00E15287403F90009221E /* linphonetester.framework in Frameworks */, |
|---|
| | | AEC00E11287403C10009221E /* bctoolbox-tester.framework in Frameworks */, |
|---|
| | | AE996FC826C22F7A0000F1F9 /* belcard.framework in Frameworks */, |
|---|
| | | AE996FCA26C22F7A0000F1F9 /* linphone.framework in Frameworks */, |
|---|
| | | AE996FC726C22F790000F1F9 /* lime.framework in Frameworks */, |
|---|
| | | AE996FC326C22F790000F1F9 /* belle-sip.framework in Frameworks */, |
|---|
| | | AE996FC026C22F790000F1F9 /* bctoolbox.framework in Frameworks */, |
|---|
| | | AEF6AC05282B8E9B00C9FD36 /* bctoolbox-ios.framework in Frameworks */, |
|---|
| | | AE996FC226C22F790000F1F9 /* msamr.framework in Frameworks */, |
|---|
| | | AEC00E13287403E80009221E /* limetester.framework in Frameworks */, |
|---|
| | | AE996FC426C22F790000F1F9 /* ortp.framework in Frameworks */, |
|---|
| | | AE996FC926C22F7A0000F1F9 /* msx264.framework in Frameworks */, |
|---|
| | | ); |
|---|
| | |
|---|
| | | AE996FAE26C22F790000F1F9 /* Frameworks */ = { |
|---|
| | | isa = PBXGroup; |
|---|
| | | children = ( |
|---|
| | | AEC00E14287403F90009221E /* linphonetester.framework */, |
|---|
| | | AEC00E12287403E80009221E /* limetester.framework */, |
|---|
| | | AEC00E10287403C10009221E /* bctoolbox-tester.framework */, |
|---|
| | | AEF6AC04282B8E9B00C9FD36 /* bctoolbox-ios.framework */, |
|---|
| | | AE996FAF26C22F790000F1F9 /* belr.framework */, |
|---|
| | | AE996FB026C22F790000F1F9 /* mediastreamer2.framework */, |
|---|
| | | AE996FB126C22F790000F1F9 /* msopenh264.framework */, |
|---|
| | |
|---|
| | | [self initData]; |
|---|
| | | [self initESVideo]; |
|---|
| | | [self StartMonitoring]; |
|---|
| | | // [HDLLinphoneManager.instance enableMicro:false]; |
|---|
| | | [HDLLinphoneManager.instance enableMicro:false]; |
|---|
| | | |
|---|
| | | // //ææ¶ä¸æ¯æå¼éåè½ |
|---|
| | | // [self setUnlock:NO]; |
|---|
| | |
|---|
| | | å¼å§çæ§ |
|---|
| | | */ |
|---|
| | | -(void)StartMonitoring{ |
|---|
| | | NSLog(@"å¼å§å¼å«ï¼@%@",self.userName); |
|---|
| | | NSLog(@"å¼å§å¼å«ï¼%@",self.userName); |
|---|
| | | [HDLLinphoneManager.instance startCall:self.userName]; |
|---|
| | | |
|---|
| | | } |
|---|
| | |
|---|
| | | */ |
|---|
| | | -(void)gotoHDLLinphoneIntercomVC:(NSString*)titleName; |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * 跳转èªç å¼å«é¡µé¢ |
|---|
| | | * |
|---|
| | | * @param titleName æ é¢ |
|---|
| | | * @param username ç¨æ·è´¦å· |
|---|
| | | |
|---|
| | | */ |
|---|
| | | -(void)gotoHDLSRLinphoneIntercomVC:(NSString*)titleName userName:(NSString*)username; |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * 注éç»å½ |
|---|
| | |
|---|
| | | UIViewController *topVC=[HDLLinPhoneCommon topMostController]; |
|---|
| | | if ([topVC isKindOfClass:[HDLLPOnMonitorViewController class]]) { |
|---|
| | | [topVC dismissViewControllerAnimated:NO completion:^{ |
|---|
| | | [weakSelf toLinphoneIntercomVC:titleName]; |
|---|
| | | [weakSelf toLinphoneIntercomVC:titleName deviceType:HDLLPType_Default userName:@""]; |
|---|
| | | }]; |
|---|
| | | }else if ([topVC isKindOfClass:[HDLLinphoneIntercomVC class]]) { |
|---|
| | | [topVC dismissViewControllerAnimated:NO completion:^{ |
|---|
| | | [weakSelf toLinphoneIntercomVC:titleName]; |
|---|
| | | [weakSelf toLinphoneIntercomVC:titleName deviceType:HDLLPType_Default userName:@""]; |
|---|
| | | }]; |
|---|
| | | } |
|---|
| | | }]; |
|---|
| | |
|---|
| | | return; |
|---|
| | | } |
|---|
| | | |
|---|
| | | [self toLinphoneIntercomVC:titleName]; |
|---|
| | | [self toLinphoneIntercomVC:titleName deviceType:HDLLPType_Default userName:@""]; |
|---|
| | | |
|---|
| | | // if (self.presentingIntercomVC) { |
|---|
| | | // __weak typeof(self) weakSelf = self; |
|---|
| | |
|---|
| | | // }]; |
|---|
| | | } |
|---|
| | | |
|---|
| | | -(void)toLinphoneIntercomVC:(NSString*)titleName{ |
|---|
| | | /** |
|---|
| | | * 跳转èªç å¼å«é¡µé¢ |
|---|
| | | * |
|---|
| | | * @param titleName æ é¢ |
|---|
| | | */ |
|---|
| | | -(void)gotoHDLSRLinphoneIntercomVC:(NSString*)titleName userName:(NSString*)username{ |
|---|
| | | if ([HDLLinPhoneCommon rootPresentVCContent:[HDLLinphoneIntercomVC class]]||[HDLLinPhoneCommon rootPresentVCContent:[HDLLPOnMonitorViewController class]]) { |
|---|
| | | if ([[HDLLinPhoneCommon topMostController] isKindOfClass:[UIAlertController class]]) { |
|---|
| | | NSLog(@"顶å±è§å¾æ¯è§é¢éè¯é¡µ"); |
|---|
| | | __weak typeof(self) weakSelf = self; |
|---|
| | | |
|---|
| | | [[HDLLinPhoneCommon topMostController] dismissViewControllerAnimated:NO completion:^{ |
|---|
| | | UIViewController *topVC=[HDLLinPhoneCommon topMostController]; |
|---|
| | | if ([topVC isKindOfClass:[HDLLPOnMonitorViewController class]]) { |
|---|
| | | [topVC dismissViewControllerAnimated:NO completion:^{ |
|---|
| | | [weakSelf toLinphoneIntercomVC:titleName deviceType:HDLLPType_HDLSR userName:username]; |
|---|
| | | }]; |
|---|
| | | }else if ([topVC isKindOfClass:[HDLLinphoneIntercomVC class]]) { |
|---|
| | | [topVC dismissViewControllerAnimated:NO completion:^{ |
|---|
| | | [weakSelf toLinphoneIntercomVC:titleName deviceType:HDLLPType_HDLSR userName:username]; |
|---|
| | | }]; |
|---|
| | | } |
|---|
| | | }]; |
|---|
| | | } |
|---|
| | | return; |
|---|
| | | } |
|---|
| | | |
|---|
| | | [self toLinphoneIntercomVC:titleName deviceType:HDLLPType_HDLSR userName:username]; |
|---|
| | | } |
|---|
| | | |
|---|
| | | -(void)toLinphoneIntercomVC:(NSString*)titleName deviceType:(HDLLPType)deviceType userName:(NSString *)userName{ |
|---|
| | | HDLLinphoneIntercomVC *vc=[[HDLLinphoneIntercomVC alloc]init]; |
|---|
| | | // vc.CallId=callId; |
|---|
| | | vc.hasVideo=YES; |
|---|
| | |
|---|
| | | if (titleName) { |
|---|
| | | vc.titleName=titleName; |
|---|
| | | } |
|---|
| | | vc.deviceType=deviceType; |
|---|
| | | vc.userName=userName; |
|---|
| | | vc.modalPresentationStyle = UIModalPresentationFullScreen; |
|---|
| | | // self.presentingIntercomVC=vc; |
|---|
| | | [[HDLLinPhoneCommon topMostController] presentViewController:vc animated:YES completion:^{ |
|---|
| | |
|---|
| | | #import <UIKit/UIKit.h> |
|---|
| | | #import "HDLLinphoneCallDelegate.h" |
|---|
| | | NS_ASSUME_NONNULL_BEGIN |
|---|
| | | |
|---|
| | | typedef enum { |
|---|
| | | HDLLPType_Default=0, //é»è®¤çç±»å |
|---|
| | | HDLLPType_HDLSR=1,//èªç ç±»å |
|---|
| | | }HDLLPType; |
|---|
| | | @interface HDLLinphoneIntercomVC : UIViewController |
|---|
| | | |
|---|
| | | #pragma mark HDLLinphoneCallDelegate |
|---|
| | |
|---|
| | | @property (assign, nonatomic) BOOL hasVideo;//æ¯å¦æ¯æè§é¢ |
|---|
| | | @property (strong, nonatomic) NSString *titleName;//æ é¢ |
|---|
| | | |
|---|
| | | @property (strong, nonatomic) NSString *userName;//ç¨æ·è´¦å· |
|---|
| | | @property(nonatomic,assign)HDLLPType deviceType;//é¨å£æºç±»å |
|---|
| | | |
|---|
| | | @end |
|---|
| | | |
|---|
| | | NS_ASSUME_NONNULL_END |
|---|
| | |
|---|
| | | [self stopPlaySystemSound]; |
|---|
| | | |
|---|
| | | // [[HDLCallManager instance] acceptCallByCallID:self.CallId hasVideo:self.hasVideo]; |
|---|
| | | [[HDLLinphoneManager instance] acceptCall]; |
|---|
| | | [HDLLinphoneManager.instance enableMicro:true]; |
|---|
| | | if (self.deviceType==HDLLPType_HDLSR) { |
|---|
| | | NSLog(@"åå¼"); |
|---|
| | | [HDLLinphoneManager.instance startCall:self.userName]; |
|---|
| | | }else{ |
|---|
| | | NSLog(@"æ¥å¬"); |
|---|
| | | [[HDLLinphoneManager instance] acceptCall]; |
|---|
| | | |
|---|
| | | } |
|---|
| | | /// å¼å¯å¯¹è®² |
|---|
| | | // [self startTalk]; |
|---|
| | | |
|---|
| | |
|---|
| | | /** å¼å¯åè®¡æ¶ */ |
|---|
| | | - (void)startCountdown { |
|---|
| | | |
|---|
| | | if (_callTimeout > 100) { |
|---|
| | | return; |
|---|
| | | } |
|---|
| | | // if (_callTimeout > 100) { |
|---|
| | | // return; |
|---|
| | | // } |
|---|
| | | _callTimeout = 0; |
|---|
| | | // GCDå®æ¶å¨ |
|---|
| | | dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); |
|---|
| | |
|---|
| | | |
|---|
| | | dispatch_source_set_event_handler(_countdownTimer, ^{ |
|---|
| | | WEAKSELF_AT |
|---|
| | | if(weakSelf_AT.callTimeout >= 100 ){// 计æ¶ç»æ |
|---|
| | | // å
³éå®æ¶å¨ |
|---|
| | | dispatch_source_cancel(weakSelf_AT.countdownTimer); |
|---|
| | | |
|---|
| | | dispatch_async(dispatch_get_main_queue(), ^{ |
|---|
| | | NSLog(@"è¶
æ¶"); |
|---|
| | | [weakSelf_AT backAction]; |
|---|
| | | |
|---|
| | | }); |
|---|
| | | |
|---|
| | | }else{// 计æ¶ä¸ |
|---|
| | | // if(weakSelf_AT.callTimeout >= 100 ){// 计æ¶ç»æ |
|---|
| | | // // å
³éå®æ¶å¨ |
|---|
| | | // dispatch_source_cancel(weakSelf_AT.countdownTimer); |
|---|
| | | // |
|---|
| | | // dispatch_async(dispatch_get_main_queue(), ^{ |
|---|
| | | // NSLog(@"è¶
æ¶"); |
|---|
| | | // [weakSelf_AT backAction]; |
|---|
| | | // |
|---|
| | | // }); |
|---|
| | | // |
|---|
| | | // }else{// 计æ¶ä¸ |
|---|
| | | weakSelf_AT.callTimeout++; |
|---|
| | | dispatch_async(dispatch_get_main_queue(), ^{ |
|---|
| | | [weakSelf_AT ShowTime:weakSelf_AT.callTimeout]; |
|---|
| | | }); |
|---|
| | | |
|---|
| | | |
|---|
| | | } |
|---|
| | | // } |
|---|
| | | }); |
|---|
| | | |
|---|
| | | // å¼å¯å®æ¶å¨ |
|---|
| | |
|---|
| | | name:AVAudioSessionRouteChangeNotification |
|---|
| | | object:nil]; |
|---|
| | | |
|---|
| | | NSString *path = [[NSBundle mainBundle] pathForResource:@"msg" ofType:@"wav"]; |
|---|
| | | NSString *path = [[NSBundle mainBundle] pathForResource:@"msg" ofType:@"caf"]; |
|---|
| | | self.messagePlayer = [[AVAudioPlayer alloc] initWithContentsOfURL:[NSURL URLWithString:path] error:nil]; |
|---|
| | | |
|---|
| | | _sounds.vibrate = kSystemSoundID_Vibrate; |
|---|
| | |
|---|
| | | withDefault:@"sip.linphone.org"] |
|---|
| | | .UTF8String) != 0) { |
|---|
| | | // LOGI(@"Migrating proxy config to use AVPF"); |
|---|
| | | linphone_proxy_config_enable_avpf(proxy, TRUE); |
|---|
| | | // linphone_proxy_config_enable_avpf(proxy, TRUE); |
|---|
| | | linphone_proxy_config_set_avpf_mode(proxy,LinphoneAVPFEnabled); |
|---|
| | | } |
|---|
| | | proxies = proxies->next; |
|---|
| | | } |
|---|
| | |
|---|
| | | NSError *err = nil; |
|---|
| | | |
|---|
| | | if (![audioSession setActive:NO error:&err] && err) { |
|---|
| | | |
|---|
| | | NSLog(@"audioå¯å¨å¤±è´¥"); |
|---|
| | | err = nil; |
|---|
| | | } |
|---|
| | | if (!bAudioInputAvailable) { |
|---|
| | | |
|---|
| | | NSLog(@"设å¤ä¸æ¯æaudio"); |
|---|
| | | |
|---|
| | | } |
|---|
| | | } |
|---|
| | | |
|---|
| | |
|---|
| | | |
|---|
| | | // set transport |
|---|
| | | NSString *type = @"UDP"; |
|---|
| | | // NSString *type = @"TCP"; |
|---|
| | | linphone_proxy_config_set_route( |
|---|
| | | config, |
|---|
| | | [NSString stringWithFormat:@"%s;transport=%s", domain.UTF8String, type.lowercaseString.UTF8String] |
|---|
| | |
|---|
| | | #pragma mark Debug functions |
|---|
| | | |
|---|
| | | + (void)dumpLcConfig { |
|---|
| | | if (theLinphoneCore) { |
|---|
| | | LpConfig *conf = HDLLinphoneManager.instance.configDb; |
|---|
| | | char *config = lp_config_dump(conf); |
|---|
| | | // LOGI(@"\n%s", config); |
|---|
| | | ms_free(config); |
|---|
| | | } |
|---|
| | | // if (theLinphoneCore) { |
|---|
| | | // LpConfig *conf = HDLLinphoneManager.instance.configDb; |
|---|
| | | // char *config = lp_config_dump(conf); |
|---|
| | | //// LOGI(@"\n%s", config); |
|---|
| | | // ms_free(config); |
|---|
| | | // } |
|---|
| | | } |
|---|
| | | |
|---|
| | | #pragma mark - Logs Functions handlers |
|---|
| | |
|---|
| | | // NSString *address = [FastAddressBook displayNameForAddress:addr]; |
|---|
| | | NSString *address=@""; |
|---|
| | | if (state == LinphoneCallIncomingReceived) { |
|---|
| | | |
|---|
| | | HDLLinPhoneSDK.instance.IsIncomingReceivedCallState=true; |
|---|
| | | [HDLLinphoneManager.instance enableMicro:true]; |
|---|
| | | |
|---|
| | | // LinphoneCallLog *callLog = linphone_call_get_call_log(call); |
|---|
| | | // NSString *callId = [NSString stringWithUTF8String:linphone_call_log_get_call_id(callLog)]; |
|---|
| | | // int index = [(NSNumber *)[_pushDict objectForKey:callId] intValue] - 1; |
|---|
| | |
|---|
| | | |
|---|
| | | if (state==LinphoneCallStateOutgoingProgress) { |
|---|
| | | NSLog(@"ç¦æ¢éº¦å
é£"); |
|---|
| | | [HDLLinphoneManager.instance enableMicro:false]; |
|---|
| | | // [HDLLinphoneManager.instance enableMicro:false]; |
|---|
| | | } |
|---|
| | | // Disable speaker when no more call |
|---|
| | | if ((state == LinphoneCallEnd || state == LinphoneCallError)) { |
|---|
| | |
|---|
| | | linphone_core_cbs_set_user_data(cbs, (__bridge void *)(self)); |
|---|
| | | // NSLog(@"Creating linphonecore1:%@",_configDb); |
|---|
| | | |
|---|
| | | lp_config_set_int(_configDb, [@"app" UTF8String], [@"random_port_preference" UTF8String], 1); |
|---|
| | | |
|---|
| | | // lp_config_set_int(_configDb, [@"app" UTF8String], [@"random_port_preference" UTF8String], 1); |
|---|
| | | linphone_config_set_int(_configDb, [@"app" UTF8String], [@"random_port_preference" UTF8String], 1); |
|---|
| | | |
|---|
| | | theLinphoneCore = linphone_factory_create_core_with_config_3(factory, _configDb, NULL); |
|---|
| | | linphone_core_add_callbacks(theLinphoneCore, cbs); |
|---|
| | | linphone_core_start(theLinphoneCore); |
|---|
| | | // linphone_core_start(theLinphoneCore); |
|---|
| | | //设置为éæºç«¯å£ |
|---|
| | | LinphoneSipTransports transportValue = {-1, -1, -1, -1}; |
|---|
| | | // will also update the sip_*_port section of the config |
|---|
| | | if (linphone_core_set_sip_transports(theLinphoneCore, &transportValue)) { |
|---|
| | | LOGE(@"cannot set transport"); |
|---|
| | | NSLog(@"cannot set transport"); |
|---|
| | | } |
|---|
| | | // |
|---|
| | | linphone_core_set_network_reachable(theLinphoneCore,TRUE); |
|---|
| | | // |
|---|
| | | // AudioStream*stream=audio_stream_new(ms_factory_new(), -1, -1, TRUE); |
|---|
| | | // audio_stream_enable_gain_control(stream, TRUE); |
|---|
| | | |
|---|
| | | linphone_core_start(theLinphoneCore); |
|---|
| | | |
|---|
| | | |
|---|
| | | [self removeAllAccounts]; |
|---|
| | | // Let the core handle cbs |
|---|
| | |
|---|
| | | // start scheduler |
|---|
| | | mIterateTimer = |
|---|
| | | [NSTimer scheduledTimerWithTimeInterval:0.02 target:self selector:@selector(iterate) userInfo:nil repeats:YES]; |
|---|
| | | |
|---|
| | | |
|---|
| | | // //èªå¨å¯å¨åæ¥æ¶video |
|---|
| | | // NSLog(@"设置èªå¨è®¾ç½®"); |
|---|
| | | // LinphoneVideoPolicy policy; |
|---|
| | | // policy.automatically_initiate = true; |
|---|
| | | // policy.automatically_accept =true; |
|---|
| | | // linphone_core_set_video_policy(theLinphoneCore, &policy); |
|---|
| | | // LinphoneVideoActivationPolicy policy; |
|---|
| | | // linphone_video_activation_policy_set_automatically_accept(&policy,true); |
|---|
| | | } |
|---|
| | | |
|---|
| | | //-(void)appWillTerminate{ |
|---|
| | |
|---|
| | | } |
|---|
| | | |
|---|
| | | - (void)migrateImportantFiles { |
|---|
| | | if ([HDLLinphoneManager copyFile:[HDLLinphoneManager documentFile:@"linphonerc"] destination:[HDLLinphoneManager preferenceFile:@"linphonerc"] override:TRUE ignore:TRUE]) |
|---|
| | | [NSFileManager.defaultManager |
|---|
| | | removeItemAtPath:[HDLLinphoneManager documentFile:@"linphonerc"] |
|---|
| | | error:nil]; |
|---|
| | | // if ([HDLLinphoneManager copyFile:[HDLLinphoneManager documentFile:@"linphonerc"] destination:[HDLLinphoneManager preferenceFile:@"linphonerc"] override:TRUE ignore:TRUE]) |
|---|
| | | // [NSFileManager.defaultManager |
|---|
| | | // removeItemAtPath:[HDLLinphoneManager documentFile:@"linphonerc"] |
|---|
| | | // error:nil]; |
|---|
| | | //ä¸ä½¿ç¨é
ç½®æ件çé
ç½® |
|---|
| | | NSFileManager *fileManager = NSFileManager.defaultManager; |
|---|
| | | NSError *error = nil; |
|---|
| | | [fileManager removeItemAtPath:[HDLLinphoneManager preferenceFile:@"linphonerc"] error:&error]; |
|---|
| | | |
|---|
| | | |
|---|
| | | if ([HDLLinphoneManager copyFile:[HDLLinphoneManager documentFile:@"linphone_chats.db"] destination:[HDLLinphoneManager dataFile:@"linphone_chats.db"] override:TRUE ignore:TRUE]) |
|---|
| | | [NSFileManager.defaultManager |
|---|
| | |
|---|
| | | LOGW(@"%@ already exists, simply removing %@ %@", dst, src, |
|---|
| | | fileError ? fileError.localizedDescription : @"successfully"); |
|---|
| | | } else { |
|---|
| | | [fileManager moveItemAtPath:src toPath:dst error:&fileError]; |
|---|
| | | // [fileManager moveItemAtPath:src toPath:dst error:&fileError]; |
|---|
| | | LOGI(@"%@ moving to %@ %@", dst, src, fileError ? fileError.localizedDescription : @"successfully"); |
|---|
| | | } |
|---|
| | | } |
|---|
| | |
|---|
| | | src = srcIpad; |
|---|
| | | } |
|---|
| | | NSString *dst = [HDLLinphoneManager preferenceFile:@"linphonerc"]; |
|---|
| | | [HDLLinphoneManager copyFile:src destination:dst override:FALSE ignore:FALSE]; |
|---|
| | | // [HDLLinphoneManager copyFile:src destination:dst override:FALSE ignore:FALSE]; |
|---|
| | | } |
|---|
| | | |
|---|
| | | - (void)overrideDefaultSettings { |
|---|
| | |
|---|
| | | // factory = factoryIpad; |
|---|
| | | // } |
|---|
| | | NSString *confiFileName = [HDLLinphoneManager preferenceFile:@"linphonerc"]; |
|---|
| | | _configDb = lp_config_new_with_factory([confiFileName UTF8String], [factory UTF8String]); |
|---|
| | | |
|---|
| | | _configDb = linphone_config_new_with_factory([confiFileName UTF8String], [factory UTF8String]); |
|---|
| | | |
|---|
| | | } |
|---|
| | | #pragma mark - Audio route Functions |
|---|
| | | |
|---|
| | |
|---|
| | | } |
|---|
| | | } |
|---|
| | | linphone_address_destroy(addr); |
|---|
| | | linphone_call_params_destroy(lcallParams); |
|---|
| | | // linphone_call_params_destroy(lcallParams); |
|---|
| | | linphone_call_params_unref(lcallParams); |
|---|
| | | |
|---|
| | | return TRUE; |
|---|
| | | } |
|---|
| | |
|---|
| | | } |
|---|
| | | |
|---|
| | | - (void)configureVbrCodecs { |
|---|
| | | PayloadType *pt; |
|---|
| | | int bitrate = lp_config_get_int( |
|---|
| | | _configDb, "audio", "codec_bitrate_limit", |
|---|
| | | kLinphoneAudioVbrCodecDefaultBitrate); /*default value is in linphonerc or linphonerc-factory*/ |
|---|
| | | const MSList *audio_codecs = linphone_core_get_audio_codecs(theLinphoneCore); |
|---|
| | | const MSList *codec = audio_codecs; |
|---|
| | | while (codec) { |
|---|
| | | pt = codec->data; |
|---|
| | | if (linphone_core_payload_type_is_vbr(theLinphoneCore, pt)) { |
|---|
| | | linphone_core_set_payload_type_bitrate(theLinphoneCore, pt, bitrate); |
|---|
| | | } |
|---|
| | | codec = codec->next; |
|---|
| | | } |
|---|
| | | // PayloadType *pt; |
|---|
| | | // int bitrate = linphone_config_get_int( |
|---|
| | | // _configDb, "audio", "codec_bitrate_limit", |
|---|
| | | // kLinphoneAudioVbrCodecDefaultBitrate); /*default value is in linphonerc or linphonerc-factory*/ |
|---|
| | | // const MSList *audio_codecs = linphone_core_get_audio_codecs(theLinphoneCore); |
|---|
| | | // const MSList *codec = audio_codecs; |
|---|
| | | // while (codec) { |
|---|
| | | // pt = codec->data; |
|---|
| | | // if (linphone_core_payload_type_is_vbr(theLinphoneCore, pt)) { |
|---|
| | | // linphone_core_set_payload_type_bitrate(theLinphoneCore, pt, bitrate); |
|---|
| | | // } |
|---|
| | | // codec = codec->next; |
|---|
| | | // } |
|---|
| | | |
|---|
| | | PayloadType *pt; |
|---|
| | | int bitrate = linphone_config_get_int( |
|---|
| | | _configDb, "audio", "codec_bitrate_limit", |
|---|
| | | kLinphoneAudioVbrCodecDefaultBitrate); /*default value is in linphonerc or linphonerc-factory*/ |
|---|
| | | const MSList *audio_codecs = linphone_core_get_audio_payload_types(theLinphoneCore); |
|---|
| | | const MSList *codec = audio_codecs; |
|---|
| | | while (codec) { |
|---|
| | | pt = codec->data; |
|---|
| | | if (linphone_core_payload_type_is_vbr(theLinphoneCore, pt)) { |
|---|
| | | linphone_core_set_payload_type_bitrate(theLinphoneCore, pt, bitrate); |
|---|
| | | } |
|---|
| | | codec = codec->next; |
|---|
| | | } |
|---|
| | | } |
|---|
| | | |
|---|
| | | + (id)getMessageAppDataForKey:(NSString *)key inMessage:(LinphoneChatMessage *)msg { |
|---|
| | |
|---|
| | | - (void)lpConfigSetString:(NSString *)value forKey:(NSString *)key inSection:(NSString *)section { |
|---|
| | | if (!key) |
|---|
| | | return; |
|---|
| | | lp_config_set_string(_configDb, [section UTF8String], [key UTF8String], value ? [value UTF8String] : NULL); |
|---|
| | | // lp_config_set_string(_configDb, [section UTF8String], [key UTF8String], value ? [value UTF8String] : NULL); |
|---|
| | | linphone_config_set_string(_configDb, [section UTF8String], [key UTF8String], value ? [value UTF8String] : NULL); |
|---|
| | | |
|---|
| | | } |
|---|
| | | - (NSString *)lpConfigStringForKey:(NSString *)key { |
|---|
| | | return [self lpConfigStringForKey:key withDefault:nil]; |
|---|
| | |
|---|
| | | - (NSString *)lpConfigStringForKey:(NSString *)key inSection:(NSString *)section withDefault:(NSString *)defaultValue { |
|---|
| | | if (!key) |
|---|
| | | return defaultValue; |
|---|
| | | const char *value = lp_config_get_string(_configDb, [section UTF8String], [key UTF8String], NULL); |
|---|
| | | // const char *value = lp_config_get_string(_configDb, [section UTF8String], [key UTF8String], NULL); |
|---|
| | | const char *value = linphone_config_get_string(_configDb, [section UTF8String], [key UTF8String], NULL); |
|---|
| | | return value ? [NSString stringWithUTF8String:value] : defaultValue; |
|---|
| | | } |
|---|
| | | |
|---|
| | |
|---|
| | | - (void)lpConfigSetInt:(int)value forKey:(NSString *)key inSection:(NSString *)section { |
|---|
| | | if (!key) |
|---|
| | | return; |
|---|
| | | lp_config_set_int(_configDb, [section UTF8String], [key UTF8String], (int)value); |
|---|
| | | linphone_config_set_int(_configDb, [section UTF8String], [key UTF8String], (int)value); |
|---|
| | | } |
|---|
| | | - (int)lpConfigIntForKey:(NSString *)key { |
|---|
| | | return [self lpConfigIntForKey:key withDefault:-1]; |
|---|
| | |
|---|
| | | - (int)lpConfigIntForKey:(NSString *)key inSection:(NSString *)section withDefault:(int)defaultValue { |
|---|
| | | if (!key) |
|---|
| | | return defaultValue; |
|---|
| | | return lp_config_get_int(_configDb, [section UTF8String], [key UTF8String], (int)defaultValue); |
|---|
| | | return linphone_config_get_int(_configDb, [section UTF8String], [key UTF8String], (int)defaultValue); |
|---|
| | | } |
|---|
| | | |
|---|
| | | - (void)lpConfigSetBool:(BOOL)value forKey:(NSString *)key { |
|---|
| | |
|---|
| | | /* |
|---|
| | | * charconv.h |
|---|
| | | * Copyright (C) 2010-2018 Belledonne Communications SARL |
|---|
| | | * Copyright (c) 2016-2020 Belledonne Communications SARL. |
|---|
| | | * |
|---|
| | | * 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 file is part of bctoolbox. |
|---|
| | | * |
|---|
| | | * 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 3 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 |
|---|
| | |
|---|
| | | * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. |
|---|
| | | * along with this program. If not, see <http://www.gnu.org/licenses/>. |
|---|
| | | */ |
|---|
| | | |
|---|
| | | #ifndef BCTBX_CHARCONV_H |
|---|
| | |
|---|
| | | * |
|---|
| | | * @return a pointer to a null-terminated string containing the default encoding. |
|---|
| | | */ |
|---|
| | | BCTBX_PUBLIC const char *bctbx_get_default_encoding (); |
|---|
| | | BCTBX_PUBLIC const char *bctbx_get_default_encoding (void); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Convert the given string from system locale to UTF8. |
|---|
| | |
|---|
| | | /* |
|---|
| | | * compiler.h |
|---|
| | | * Copyright (C) 2010-2018 Belledonne Communications SARL |
|---|
| | | * Copyright (c) 2016-2020 Belledonne Communications SARL. |
|---|
| | | * |
|---|
| | | * 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 file is part of bctoolbox. |
|---|
| | | * |
|---|
| | | * 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 3 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 |
|---|
| | |
|---|
| | | * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. |
|---|
| | | * along with this program. If not, see <http://www.gnu.org/licenses/>. |
|---|
| | | */ |
|---|
| | | |
|---|
| | | #ifndef COMPILER_H |
|---|
| | |
|---|
| | | /* |
|---|
| | | crypto.h |
|---|
| | | Copyright (C) 2017 Belledonne Communications SARL |
|---|
| | | |
|---|
| | | 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. |
|---|
| | | */ |
|---|
| | | * Copyright (c) 2016-2020 Belledonne Communications SARL. |
|---|
| | | * |
|---|
| | | * This file is part of bctoolbox. |
|---|
| | | * |
|---|
| | | * 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 3 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, see <http://www.gnu.org/licenses/>. |
|---|
| | | */ |
|---|
| | | #ifndef BCTBX_CRYPTO_H |
|---|
| | | #define BCTBX_CRYPTO_H |
|---|
| | | |
|---|
| | |
|---|
| | | * |
|---|
| | | * @return a pointer to a null terminated string containing the certificate in PEM format. This buffer must then be freed by caller. NULL on failure. |
|---|
| | | */ |
|---|
| | | BCTBX_PUBLIC char *bctbx_x509_certificates_chain_get_pem(bctbx_x509_certificate_t *cert); |
|---|
| | | BCTBX_PUBLIC char *bctbx_x509_certificates_chain_get_pem(const bctbx_x509_certificate_t *cert); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Return an informational string about the certificate |
|---|
| | |
|---|
| | | BCTBX_PUBLIC int32_t bctbx_ssl_config_set_authmode(bctbx_ssl_config_t *ssl_config, int authmode); |
|---|
| | | BCTBX_PUBLIC int32_t bctbx_ssl_config_set_rng(bctbx_ssl_config_t *ssl_config, int(*rng_function)(void *, unsigned char *, size_t), void *rng_context); |
|---|
| | | BCTBX_PUBLIC int32_t bctbx_ssl_config_set_callback_verify(bctbx_ssl_config_t *ssl_config, int(*callback_function)(void *, bctbx_x509_certificate_t *, int, uint32_t *), void *callback_data); |
|---|
| | | BCTBX_PUBLIC int32_t bctbx_ssl_config_set_callback_cli_cert(bctbx_ssl_config_t *ssl_config, int(*callback_function)(void *, bctbx_ssl_context_t *, unsigned char *, size_t), void *callback_data); |
|---|
| | | BCTBX_PUBLIC int32_t bctbx_ssl_config_set_callback_cli_cert(bctbx_ssl_config_t *ssl_config, int(*callback_function)(void *, bctbx_ssl_context_t *, const bctbx_list_t *), void *callback_data); |
|---|
| | | BCTBX_PUBLIC int32_t bctbx_ssl_config_set_ca_chain(bctbx_ssl_config_t *ssl_config, bctbx_x509_certificate_t *ca_chain); |
|---|
| | | BCTBX_PUBLIC int32_t bctbx_ssl_config_set_own_cert(bctbx_ssl_config_t *ssl_config, bctbx_x509_certificate_t *cert, bctbx_signing_key_t *key); |
|---|
| | | BCTBX_PUBLIC int32_t bctbx_ssl_config_set_ciphersuites(bctbx_ssl_config_t *ssl_config,const int *ciphersuites); |
|---|
| | |
|---|
| | | /***** DTLS-SRTP functions *****/ |
|---|
| | | BCTBX_PUBLIC bctbx_dtls_srtp_profile_t bctbx_ssl_get_dtls_srtp_protection_profile(bctbx_ssl_context_t *ssl_ctx); |
|---|
| | | BCTBX_PUBLIC int32_t bctbx_ssl_config_set_dtls_srtp_protection_profiles(bctbx_ssl_config_t *ssl_config, const bctbx_dtls_srtp_profile_t *profiles, size_t profiles_number); |
|---|
| | | BCTBX_PUBLIC int32_t bctbx_ssl_get_dtls_srtp_key_material(bctbx_ssl_context_t *ssl_ctx, char *output, size_t *output_length); |
|---|
| | | BCTBX_PUBLIC int32_t bctbx_ssl_get_dtls_srtp_key_material(bctbx_ssl_config_t *ssl_ctx, uint8_t *output, size_t *output_length); |
|---|
| | | BCTBX_PUBLIC uint8_t bctbx_dtls_srtp_supported(void); |
|---|
| | | BCTBX_PUBLIC void bctbx_ssl_set_mtu(bctbx_ssl_context_t *ssl_ctx, uint16_t mtu); |
|---|
| | | |
|---|
| | |
|---|
| | | * @Brief Conclude a AES-GCM encryption stream, generate tag if requested, free resources |
|---|
| | | * |
|---|
| | | * @param[in/out] context a context already initialized using bctbx_aes_gcm_context_new |
|---|
| | | * @param[out] tag a buffer to hold the authentication tag. Can be NULL if tagLength is 0 |
|---|
| | | * @param[in] tagLength length of reqested authentication tag, max 16 |
|---|
| | | * @param[out] tag a buffer to hold the authentication tag. Can be NULL if tagLength is 0 |
|---|
| | | * @param[in] tagLength length of requested authentication tag, max 16 |
|---|
| | | * |
|---|
| | | * @return 0 on success, crypto library error code otherwise |
|---|
| | | */ |
|---|
| | |
|---|
| | | /** |
|---|
| | | * @brief encrypt the file in input buffer for linphone encrypted file transfer |
|---|
| | | * |
|---|
| | | * @param[in/out] cryptoContext a context already initialized using bctbx_aes_gcm_context_new |
|---|
| | | * This function must be called with NULL in the plain text to conclude the encryption. |
|---|
| | | * At this last call, if a cipher buffer is provided with non 0 length, it will get an authentication tag of the requested size (max 16) |
|---|
| | | * |
|---|
| | | * @param[in/out] cryptoContext a context already initialized using bctbx_aes_gcm_context_new (created if NULL) |
|---|
| | | * @param[in] key encryption key |
|---|
| | | * @param[in] length buffer size |
|---|
| | | * @param[in] plain buffer holding the input data |
|---|
| | | * @param[out] cipher buffer to store the output data |
|---|
| | | * @param[out] cipher buffer to store the output data (cipher or authentication tag) |
|---|
| | | */ |
|---|
| | | BCTBX_PUBLIC int bctbx_aes_gcm_encryptFile(void **cryptoContext, unsigned char *key, size_t length, char *plain, char *cipher); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief decrypt the file in input buffer for linphone encrypted file transfer |
|---|
| | | * |
|---|
| | | * This function must be called with NULL in the cipher text to conclude the encryption. |
|---|
| | | * At this last call, if a plain buffer is provided with non 0 length, it will get the authentication tag of length bytes (max 16) |
|---|
| | | * |
|---|
| | | * @param[in/out] cryptoContext a context already initialized using bctbx_aes_gcm_context_new |
|---|
| | | * @param[in] key encryption key |
|---|
| | | * @param[in] length buffer size |
|---|
| | | * @param[out] plain buffer holding the output data |
|---|
| | | * @param[int] cipher buffer to store the input data |
|---|
| | | * @param[in] length input buffer size |
|---|
| | | * @param[out] plain buffer holding the output data (plain text or tag) |
|---|
| | | * @param[in] cipher buffer to store the input data. WARNING: size must be a multiple of 16 bytes |
|---|
| | | */ |
|---|
| | | BCTBX_PUBLIC int bctbx_aes_gcm_decryptFile(void **cryptoContext, unsigned char *key, size_t length, char *plain, char *cipher); |
|---|
| | | |
|---|
| New file |
| | |
|---|
| | | /* |
|---|
| | | * Copyright (c) 2020 Belledonne Communications SARL. |
|---|
| | | * |
|---|
| | | * This file is part of bctoolbox. |
|---|
| | | * |
|---|
| | | * 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 3 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, see <http://www.gnu.org/licenses/>. |
|---|
| | | */ |
|---|
| | | |
|---|
| | | #ifndef BCTBX_CRYPTO_HH |
|---|
| | | #define BCTBX_CRYPTO_HH |
|---|
| | | |
|---|
| | | #include <vector> |
|---|
| | | #include <memory> |
|---|
| | | |
|---|
| | | namespace bctoolbox { |
|---|
| | | /** |
|---|
| | | * @brief Random number generator interface |
|---|
| | | * |
|---|
| | | * This wrapper provides an interface to a RNG. |
|---|
| | | * Two ways to get some random numbers: |
|---|
| | | * - calling the static class functions(cRandomize) : do not use this to feed cryptographic functions |
|---|
| | | * - instanciate a RNG object and call the randomize method : use this one for cryptographic quality random |
|---|
| | | * |
|---|
| | | * Any call (including creation), may throw an exception if some error are detected on the random source |
|---|
| | | */ |
|---|
| | | class RNG { |
|---|
| | | public: |
|---|
| | | /** |
|---|
| | | * fill a buffer with random numbers |
|---|
| | | * @param[in,out] buffer The buffer to be filled with random (callers responsability to allocate memory) |
|---|
| | | * @param[in] size size in bytes of the random generated, buffer must be at least of this size |
|---|
| | | **/ |
|---|
| | | void randomize(uint8_t *buffer, const size_t size); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * return a random vector of given size |
|---|
| | | * @param[in] size size in bytes of the random generated |
|---|
| | | **/ |
|---|
| | | std::vector<uint8_t> randomize(const size_t size); |
|---|
| | | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * generates a 32 bits random unsigned number |
|---|
| | | **/ |
|---|
| | | uint32_t randomize(); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * fill a buffer with random numbers |
|---|
| | | * @param[in,out] buffer The buffer to be filled with random (callers responsability to allocate memory) |
|---|
| | | * @param[in] size size in bytes of the random generated, buffer must be at least of this size |
|---|
| | | * |
|---|
| | | * @note This function uses a shared RNG context, do not use it to generate sensitive material |
|---|
| | | **/ |
|---|
| | | static void cRandomize(uint8_t *buffer, size_t size); |
|---|
| | | /** |
|---|
| | | * generates a 32 bits random unsigned number |
|---|
| | | * |
|---|
| | | * @note This function uses a shared RNG context, do not use it to generate sensitive material |
|---|
| | | **/ |
|---|
| | | static uint32_t cRandomize(); |
|---|
| | | |
|---|
| | | RNG(); |
|---|
| | | ~RNG(); |
|---|
| | | private: |
|---|
| | | struct Impl; |
|---|
| | | std::unique_ptr<Impl> pImpl; |
|---|
| | | static std::unique_ptr<Impl> pImplClass; |
|---|
| | | }; //class RNG |
|---|
| | | |
|---|
| | | |
|---|
| | | /*****************************************************************************/ |
|---|
| | | /*** Hash related function ***/ |
|---|
| | | /*****************************************************************************/ |
|---|
| | | /** |
|---|
| | | * @brief SHA256 buffer size definition |
|---|
| | | */ |
|---|
| | | struct SHA256 { |
|---|
| | | /// maximum output size for SHA256 is 32 bytes |
|---|
| | | static constexpr size_t ssize() {return 32;} |
|---|
| | | }; |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief SHA384 buffer size definition |
|---|
| | | */ |
|---|
| | | struct SHA384 { |
|---|
| | | /// maximum output size for SHA384 is 48 bytes |
|---|
| | | static constexpr size_t ssize() {return 48;} |
|---|
| | | }; |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief SHA512 buffer size definition |
|---|
| | | */ |
|---|
| | | struct SHA512 { |
|---|
| | | /// maximum output size for SHA512 is 64 bytes |
|---|
| | | static constexpr size_t ssize() {return 64;} |
|---|
| | | }; |
|---|
| | | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief templated HMAC |
|---|
| | | * |
|---|
| | | * @tparam hashAlgo the hash algorithm used: SHA256, SHA384, SHA512 |
|---|
| | | * |
|---|
| | | * @param[in] key HMAC key |
|---|
| | | * @param[in] input HMAC input |
|---|
| | | * |
|---|
| | | * @return an array of size matching the selected hash algorithm output size |
|---|
| | | * |
|---|
| | | */ |
|---|
| | | template <typename hashAlgo> |
|---|
| | | std::vector<uint8_t> HMAC(const std::vector<uint8_t> &key, const std::vector<uint8_t> &input); |
|---|
| | | /* declare template specialisations */ |
|---|
| | | template <> std::vector<uint8_t> HMAC<SHA256>(const std::vector<uint8_t> &key, const std::vector<uint8_t> &input); |
|---|
| | | template <> std::vector<uint8_t> HMAC<SHA384>(const std::vector<uint8_t> &key, const std::vector<uint8_t> &input); |
|---|
| | | template <> std::vector<uint8_t> HMAC<SHA512>(const std::vector<uint8_t> &key, const std::vector<uint8_t> &input); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief HKDF as described in RFC5869 |
|---|
| | | * @par Compute: |
|---|
| | | * @code{.unparsed} |
|---|
| | | * PRK = HMAC-Hash(salt, IKM) |
|---|
| | | * |
|---|
| | | * N = ceil(L/HashLen) |
|---|
| | | * T = T(1) | T(2) | T(3) | ... | T(N) |
|---|
| | | * OKM = first L octets of T |
|---|
| | | * |
|---|
| | | * where: |
|---|
| | | * T(0) = empty string (zero length) |
|---|
| | | * T(1) = HMAC-Hash(PRK, T(0) | info | 0x01) |
|---|
| | | * T(2) = HMAC-Hash(PRK, T(1) | info | 0x02) |
|---|
| | | * T(3) = HMAC-Hash(PRK, T(2) | info | 0x03) |
|---|
| | | * ... |
|---|
| | | * @endcode |
|---|
| | | * |
|---|
| | | * @tparam hashAlgo the hash algorithm to use |
|---|
| | | * @tparam infoType the info parameter type : can be passed as a string or a std::vector<uint8_t> |
|---|
| | | * |
|---|
| | | * @param[in] salt salt |
|---|
| | | * @param[in] ikm input key material |
|---|
| | | * @param[in] info a info string or buffer |
|---|
| | | * @param[in] okmSize requested amount of data. (L in the RFC doc) |
|---|
| | | * |
|---|
| | | * @return the output key material |
|---|
| | | * |
|---|
| | | */ |
|---|
| | | template <typename hashAlgo> |
|---|
| | | std::vector<uint8_t> HKDF(const std::vector<uint8_t> &salt, const std::vector<uint8_t> &ikm, const std::vector<uint8_t> &info, size_t okmSize); |
|---|
| | | template <typename hashAlgo> |
|---|
| | | std::vector<uint8_t> HKDF(const std::vector<uint8_t> &salt, const std::vector<uint8_t> &ikm, const std::string &info, size_t okmSize); |
|---|
| | | /* declare template specialisations */ |
|---|
| | | template <> std::vector<uint8_t> HKDF<SHA256>(const std::vector<uint8_t> &salt, const std::vector<uint8_t> &ikm, const std::vector<uint8_t> &info, size_t outputSize); |
|---|
| | | template <> std::vector<uint8_t> HKDF<SHA256>(const std::vector<uint8_t> &salt, const std::vector<uint8_t> &ikm, const std::string &info, size_t outputSize); |
|---|
| | | template <> std::vector<uint8_t> HKDF<SHA512>(const std::vector<uint8_t> &salt, const std::vector<uint8_t> &ikm, const std::vector<uint8_t> &info, size_t outputSize); |
|---|
| | | template <> std::vector<uint8_t> HKDF<SHA512>(const std::vector<uint8_t> &salt, const std::vector<uint8_t> &ikm, const std::string &info, size_t outputSize); |
|---|
| | | |
|---|
| | | |
|---|
| | | /************************ AEAD interface *************************************/ |
|---|
| | | // AEAD function defines |
|---|
| | | /** |
|---|
| | | * @brief AES256GCM buffers size definition |
|---|
| | | */ |
|---|
| | | struct AES256GCM128 { |
|---|
| | | /// key size is 32 bytes |
|---|
| | | static constexpr size_t keySize(void) {return 32;}; |
|---|
| | | /// tag size is 16 bytes |
|---|
| | | static constexpr size_t tagSize(void) {return 16;}; |
|---|
| | | }; |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Encrypt and tag using scheme given as template parameter |
|---|
| | | * |
|---|
| | | * @param[in] key Encryption key |
|---|
| | | * @param[in] IV Initialisation vector |
|---|
| | | * @param[in] plain Plain text |
|---|
| | | * @param[in] AD Additional data used in tag computation |
|---|
| | | * @param[out] tag Generated authentication tag |
|---|
| | | * @return the cipher text |
|---|
| | | */ |
|---|
| | | template <typename AEADAlgo> |
|---|
| | | std::vector<uint8_t> AEADEncrypt(const std::vector<uint8_t> &key, const std::vector<uint8_t> IV, const std::vector<uint8_t> &plain, const std::vector<uint8_t> &AD, |
|---|
| | | std::vector<uint8_t> &tag); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Authenticate and Decrypt using scheme given as template parameter |
|---|
| | | * |
|---|
| | | * @param[in] key Encryption key |
|---|
| | | * @param[in] IV Initialisation vector |
|---|
| | | * @param[in] cipher Cipher text |
|---|
| | | * @param[in] AD Additional data used in tag computation |
|---|
| | | * @param[in] tag Authentication tag |
|---|
| | | * @param[out] plain A vector to store the plain text |
|---|
| | | * |
|---|
| | | * @return true if authentication tag match and decryption was successful |
|---|
| | | */ |
|---|
| | | template <typename AEADAlgo> |
|---|
| | | bool AEADDecrypt(const std::vector<uint8_t> &key, const std::vector<uint8_t> &IV, const std::vector<uint8_t> &cipher, const std::vector<uint8_t> &AD, |
|---|
| | | const std::vector<uint8_t> &tag, std::vector<uint8_t> &plain); |
|---|
| | | |
|---|
| | | /* declare AEAD template specialisations : AES256-GCM with 128 bits auth tag*/ |
|---|
| | | template <> std::vector<uint8_t> AEADEncrypt<AES256GCM128>(const std::vector<uint8_t> &key, const std::vector<uint8_t> IV, const std::vector<uint8_t> &plain, const std::vector<uint8_t> &AD, |
|---|
| | | std::vector<uint8_t> &tag); |
|---|
| | | |
|---|
| | | template <> bool AEADDecrypt<AES256GCM128>(const std::vector<uint8_t> &key, const std::vector<uint8_t> &IV, const std::vector<uint8_t> &cipher, const std::vector<uint8_t> &AD, |
|---|
| | | const std::vector<uint8_t> &tag, std::vector<uint8_t> &plain); |
|---|
| | | |
|---|
| | | } // namespace bctoolbox |
|---|
| | | #endif // BCTBX_CRYPTO_HH |
|---|
| | | |
|---|
| | | |
|---|
| | |
|---|
| | | /* |
|---|
| | | defs.h |
|---|
| | | Copyright (C) 2010-2017 Belledonne Communications SARL |
|---|
| | | |
|---|
| | | 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. |
|---|
| | | */ |
|---|
| | | * Copyright (c) 2016-2020 Belledonne Communications SARL. |
|---|
| | | * |
|---|
| | | * This file is part of bctoolbox. |
|---|
| | | * |
|---|
| | | * 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 3 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, see <http://www.gnu.org/licenses/>. |
|---|
| | | */ |
|---|
| | | |
|---|
| | | #ifndef BCTBX_DEFS_H_ |
|---|
| | | #define BCTBX_DEFS_H_ |
|---|
| New file |
| | |
|---|
| | | /* |
|---|
| | | * Copyright (c) 2010-2019 Belledonne Communications SARL. |
|---|
| | | * |
|---|
| | | * This file is part of Liblinphone. |
|---|
| | | * |
|---|
| | | * 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 3 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, see <http://www.gnu.org/licenses/>. |
|---|
| | | */ |
|---|
| | | |
|---|
| | | #pragma once |
|---|
| | | |
|---|
| | | #include <memory> |
|---|
| | | #include <functional> |
|---|
| | | |
|---|
| | | namespace bctoolbox { |
|---|
| | | |
|---|
| | | class IOSUtilsInterface { |
|---|
| | | public: |
|---|
| | | virtual unsigned long beginBackgroundTask(const char *name, std::function<void()> cb) = 0; |
|---|
| | | virtual void endBackgroundTask(unsigned long id) = 0; |
|---|
| | | virtual bool isApplicationStateActive() = 0; |
|---|
| | | |
|---|
| | | virtual ~IOSUtilsInterface() = default; |
|---|
| | | }; |
|---|
| | | |
|---|
| | | class IOSUtils { |
|---|
| | | public: |
|---|
| | | unsigned long beginBackgroundTask(const char *name, std::function<void()> cb); |
|---|
| | | void endBackgroundTask(unsigned long id); |
|---|
| | | bool isApplicationStateActive(); |
|---|
| | | static IOSUtils& getUtils(); |
|---|
| | | |
|---|
| | | IOSUtils(const IOSUtils&) = delete; |
|---|
| | | IOSUtils& operator=(const IOSUtils&) = delete; |
|---|
| | | ~IOSUtils(); |
|---|
| | | |
|---|
| | | private: |
|---|
| | | void *mHandle; |
|---|
| | | IOSUtilsInterface *mUtils; |
|---|
| | | static std::unique_ptr<IOSUtils> sInstance; |
|---|
| | | IOSUtils(); |
|---|
| | | |
|---|
| | | bool isApp(); |
|---|
| | | void openDynamicLib(); |
|---|
| | | void *loadSymbol(const char *symbol); |
|---|
| | | }; |
|---|
| | | |
|---|
| | | } //namespace bctoolbox |
|---|
| | |
|---|
| | | /* |
|---|
| | | bctoolbox |
|---|
| | | Copyright (C) 2016 Belledonne Communications SARL |
|---|
| | | |
|---|
| | | 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, see <http://www.gnu.org/licenses/>. |
|---|
| | | */ |
|---|
| | | * Copyright (c) 2016-2020 Belledonne Communications SARL. |
|---|
| | | * |
|---|
| | | * This file is part of bctoolbox. |
|---|
| | | * |
|---|
| | | * 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 3 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, see <http://www.gnu.org/licenses/>. |
|---|
| | | */ |
|---|
| | | |
|---|
| | | #ifndef BCTBX_LIST_H_ |
|---|
| | | #define BCTBX_LIST_H_ |
|---|
| | |
|---|
| | | /* |
|---|
| | | bctoolobx |
|---|
| | | Copyright (C) 2016 Belledonne Communications, France, Grenoble |
|---|
| | | |
|---|
| | | This library is free software; you can redistribute it and/or |
|---|
| | | modify it under the terms of the GNU Lesser General Public |
|---|
| | | License as published by the Free Software Foundation; either |
|---|
| | | version 2.1 of the License, or (at your option) any later version. |
|---|
| | | |
|---|
| | | This library 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 |
|---|
| | | Lesser General Public License for more details. |
|---|
| | | |
|---|
| | | You should have received a copy of the GNU Lesser General Public |
|---|
| | | License along with this library; if not, write to the Free Software |
|---|
| | | Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
|---|
| | | */ |
|---|
| | | * Copyright (c) 2016-2020 Belledonne Communications SARL. |
|---|
| | | * |
|---|
| | | * This file is part of bctoolbox. |
|---|
| | | * |
|---|
| | | * 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 3 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, see <http://www.gnu.org/licenses/>. |
|---|
| | | */ |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * \file logging.h |
|---|
| | |
|---|
| | | }; |
|---|
| | | |
|---|
| | | |
|---|
| | | #if (__GNUC__ == 4 && __GNUC_MINOR__ < 5 && __cplusplus > 199711L) |
|---|
| | | template <typename _Tp> inline pumpstream &operator<<(pumpstream &&__os, const _Tp &__x) { |
|---|
| | | (static_cast<std::ostringstream &>(__os)) << __x; |
|---|
| | | return __os; |
|---|
| | | } |
|---|
| | | #endif |
|---|
| | | |
|---|
| | | #define BCTBX_SLOG(domain, thelevel) pumpstream(domain, thelevel) |
|---|
| | | |
|---|
| | |
|---|
| | | /* |
|---|
| | | bctoolbox mmap |
|---|
| | | Copyright (C) 2016 Belledonne Communications SARL |
|---|
| | | |
|---|
| | | 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, see <http://www.gnu.org/licenses/>. |
|---|
| | | */ |
|---|
| | | * Copyright (c) 2016-2020 Belledonne Communications SARL. |
|---|
| | | * |
|---|
| | | * This file is part of bctoolbox. |
|---|
| | | * |
|---|
| | | * 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 3 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, see <http://www.gnu.org/licenses/>. |
|---|
| | | */ |
|---|
| | | |
|---|
| | | #ifndef BCTBX_MMAP_H_ |
|---|
| | | #define BCTBX_MMAP_H_ |
|---|
| | |
|---|
| | | BCTBX_PUBLIC bctbx_iterator_t *bctbx_map_cchar_end(const bctbx_map_t *map); |
|---|
| | | /*return a new allocated iterator or null*/ |
|---|
| | | #define bctbx_map_find_custom bctbx_map_ullong_find_custom |
|---|
| | | BCTBX_PUBLIC bctbx_iterator_t * bctbx_map_ullong_find_custom(bctbx_map_t *map, bctbx_compare_func compare_func, const void *user_data); |
|---|
| | | BCTBX_PUBLIC bctbx_iterator_t * bctbx_map_cchar_find_custom(bctbx_map_t *map, bctbx_compare_func compare_func, const void *user_data); |
|---|
| | | BCTBX_PUBLIC bctbx_iterator_t * bctbx_map_ullong_find_custom(const bctbx_map_t *map, bctbx_compare_func compare_func, const void *user_data); |
|---|
| | | BCTBX_PUBLIC bctbx_iterator_t * bctbx_map_cchar_find_custom(const bctbx_map_t *map, bctbx_compare_func compare_func, const void *user_data); |
|---|
| | | /*return the iterator associated to the key in the map or Null*/ |
|---|
| | | BCTBX_PUBLIC bctbx_iterator_t * bctbx_map_ullong_find_key(bctbx_map_t *map, unsigned long long key); |
|---|
| | | BCTBX_PUBLIC bctbx_iterator_t * bctbx_map_cchar_find_key(bctbx_map_t *map, const char * key); |
|---|
| | | BCTBX_PUBLIC bctbx_iterator_t * bctbx_map_ullong_find_key(const bctbx_map_t *map, unsigned long long key); |
|---|
| | | BCTBX_PUBLIC bctbx_iterator_t * bctbx_map_cchar_find_key(const bctbx_map_t *map, const char * key); |
|---|
| | | /* return the size of the map*/ |
|---|
| | | #define bctbx_map_size bctbx_map_ullong_size |
|---|
| | | BCTBX_PUBLIC size_t bctbx_map_ullong_size(const bctbx_map_t *map); |
|---|
| New file |
| | |
|---|
| | | /* |
|---|
| | | * Copyright (c) 2010-2020 Belledonne Communications SARL. |
|---|
| | | * |
|---|
| | | * This file is part of bctoolbox. |
|---|
| | | * |
|---|
| | | * 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 3 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, see <http://www.gnu.org/licenses/>. |
|---|
| | | */ |
|---|
| | | |
|---|
| | | #ifndef BCTBX_PARAM_STRING_H_ |
|---|
| | | #define BCTBX_PARAM_STRING_H_ |
|---|
| | | |
|---|
| | | #include "bctoolbox/port.h" |
|---|
| | | |
|---|
| | | // This file provides string manipulation utility when handling a parameter string of the from |
|---|
| | | // "param1;param2=120;param3=true" |
|---|
| | | |
|---|
| | | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Parses a fmtp string such as "profile=0;level=10", finds the value matching |
|---|
| | | * parameter param_name, and writes it into result. |
|---|
| | | * If a parameter name is found multiple times, only the value of the last occurence is returned. |
|---|
| | | * @param paramString the fmtp line (format parameters) |
|---|
| | | * @param param_name the parameter to search for |
|---|
| | | * @param result the value given for the parameter (if found) |
|---|
| | | * @param result_len the size allocated to hold the result string |
|---|
| | | * @return TRUE if the parameter was found, else FALSE. |
|---|
| | | **/ |
|---|
| | | BCTBX_PUBLIC bool_t bctbx_param_string_get_value(const char *paramString, const char *param_name, char *result, size_t result_len); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Parses a fmtp string such as "profile=0;level=10". If the value is "true" or "false", returns the corresponding boolean |
|---|
| | | * @param paramString the fmtp line (format parameters) |
|---|
| | | * @param param_name the parameter to search for |
|---|
| | | * @return FALSE if parameter was not found, else TRUE if the parameter value was "true", FALSE if it was "false" |
|---|
| | | **/ |
|---|
| | | BCTBX_PUBLIC bool_t bctbx_param_string_get_bool_value(const char *paramString, const char *param_name); |
|---|
| | | #endif /*BCTBX_PARAM_STRING_H_*/ |
|---|
| | | |
|---|
| | | |
|---|
| | | |
|---|
| | | |
|---|
| | |
|---|
| | | /* |
|---|
| | | bctoolbox |
|---|
| | | Copyright (C) 2017 Belledonne Communications SARL |
|---|
| | | |
|---|
| | | 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, see <http://www.gnu.org/licenses/>. |
|---|
| | | */ |
|---|
| | | * Copyright (c) 2016-2020 Belledonne Communications SARL. |
|---|
| | | * |
|---|
| | | * This file is part of bctoolbox. |
|---|
| | | * |
|---|
| | | * 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 3 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, see <http://www.gnu.org/licenses/>. |
|---|
| | | */ |
|---|
| | | |
|---|
| | | #ifndef BCTBX_PARSER_H_ |
|---|
| | | #define BCTBX_PARSER_H_ |
|---|
| | |
|---|
| | | */ |
|---|
| | | BCTBX_PUBLIC char* bctbx_unescaped_string(const char* buff); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Does the same as bctbx_unescaped_string() except it does it only for characters in unescape_rules |
|---|
| | | * @param buff NULL terminated input buffer. |
|---|
| | | * @param unescape_rules bctbx_noescape_rules_t characters to unescape, other will be kept escaped |
|---|
| | | * @return a newly allocated null terminated string with unescated values. |
|---|
| | | */ |
|---|
| | | BCTBX_PUBLIC char* bctbx_unescaped_string_only_chars_in_rules(const char* buff, const bctbx_noescape_rules_t unescape_rules); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | *Convert a single input "a" into unscaped output if need. |
|---|
| | |
|---|
| | | /* |
|---|
| | | The oRTP library is an RTP (Realtime Transport Protocol - rfc3550) stack. |
|---|
| | | Copyright (C) 2001 Simon MORLAT simon.morlat@linphone.org |
|---|
| | | |
|---|
| | | This library is free software; you can redistribute it and/or |
|---|
| | | modify it under the terms of the GNU Lesser General Public |
|---|
| | | License as published by the Free Software Foundation; either |
|---|
| | | version 2.1 of the License, or (at your option) any later version. |
|---|
| | | |
|---|
| | | This library 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 |
|---|
| | | Lesser General Public License for more details. |
|---|
| | | |
|---|
| | | You should have received a copy of the GNU Lesser General Public |
|---|
| | | License along with this library; if not, write to the Free Software |
|---|
| | | Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
|---|
| | | */ |
|---|
| | | * Copyright (c) 2016-2020 Belledonne Communications SARL. |
|---|
| | | * |
|---|
| | | * This file is part of bctoolbox. |
|---|
| | | * |
|---|
| | | * 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 3 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, see <http://www.gnu.org/licenses/>. |
|---|
| | | */ |
|---|
| | | /* this file is responsible of the portability of the stack */ |
|---|
| | | |
|---|
| | | #ifndef BCTBX_PORT_H |
|---|
| | |
|---|
| | | #include <string.h> |
|---|
| | | #include <wchar.h> |
|---|
| | | |
|---|
| | | #ifdef __linux |
|---|
| | | #ifdef __linux__ |
|---|
| | | #include <stdint.h> |
|---|
| | | #endif |
|---|
| | | |
|---|
| | |
|---|
| | | |
|---|
| | | #define getSocketError() strerror(errno) |
|---|
| | | #define getSocketErrorCode() (errno) |
|---|
| | | #define getSocketErrorWithCode(code) strerror(code) |
|---|
| | | #define bctbx_gettimeofday(tv,tz) gettimeofday(tv,tz) |
|---|
| | | #define bctbx_log10f(x) log10f(x) |
|---|
| | | |
|---|
| | |
|---|
| | | |
|---|
| | | #endif |
|---|
| | | |
|---|
| | | #ifdef __cplusplus |
|---|
| | | extern "C" { |
|---|
| | | #endif |
|---|
| | | |
|---|
| | | BCTBX_PUBLIC const char *__bctbx_getWinSocketError(int error); |
|---|
| | | |
|---|
| | | #ifdef __cplusplus |
|---|
| | | } |
|---|
| | | #endif |
|---|
| | | |
|---|
| | | #ifndef getSocketErrorCode |
|---|
| | | #define getSocketErrorCode() WSAGetLastError() |
|---|
| | | #define getSocketErrorCode() WSAGetLastError() |
|---|
| | | #endif |
|---|
| | | #ifndef getSocketError |
|---|
| | | #define getSocketError() __bctbx_getWinSocketError(WSAGetLastError()) |
|---|
| | | #define getSocketError() __bctbx_getWinSocketError(WSAGetLastError()) |
|---|
| | | #endif |
|---|
| | | #ifndef getSocketErrorWithCode |
|---|
| | | #define getSocketErrorWithCode(code) __bctbx_getWinSocketError(code) |
|---|
| | | #endif |
|---|
| | | |
|---|
| | | #ifndef snprintf |
|---|
| | |
|---|
| | | |
|---|
| | | BCTBX_PUBLIC int bctbx_socket_set_non_blocking(bctbx_socket_t sock); |
|---|
| | | |
|---|
| | | #ifdef __GNUC__ |
|---|
| | | # define BCTBX_PRINTF_LIKE(format_pos, args_pos) __attribute__ ((format (printf, format_pos, args_pos))) |
|---|
| | | #else |
|---|
| | | # define BCTBX_PRINTF_LIKE(format_pos, args_pos) |
|---|
| | | #endif |
|---|
| | | |
|---|
| | | BCTBX_PUBLIC char *bctbx_strndup(const char *str,int n); |
|---|
| | | BCTBX_PUBLIC char *bctbx_strdup_printf(const char *fmt,...); |
|---|
| | | BCTBX_PUBLIC char *bctbx_strdup_printf(const char *fmt,...) BCTBX_PRINTF_LIKE(1, 2); |
|---|
| | | BCTBX_PUBLIC char *bctbx_strdup_vprintf(const char *fmt, va_list ap); |
|---|
| | | BCTBX_PUBLIC char *bctbx_strcat_printf(char *dst, const char *fmt,...); |
|---|
| | | BCTBX_PUBLIC char *bctbx_strcat_printf(char *dst, const char *fmt,...) BCTBX_PRINTF_LIKE(2, 3); |
|---|
| | | BCTBX_PUBLIC char *bctbx_strcat_vprintf(char *dst, const char *fmt, va_list ap); |
|---|
| | | BCTBX_PUBLIC char *bctbx_concat(const char *str, ...); |
|---|
| | | BCTBX_PUBLIC char *bctbx_replace(char *str, char c, char n); |
|---|
| | |
|---|
| | | */ |
|---|
| | | BCTBX_PUBLIC uint32_t bctbx_time_string_to_sec(const char *timeString); |
|---|
| | | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Generate a non cryptographically usable alea |
|---|
| | | * |
|---|
| | | * @return a 32 bits unsigned random. DO NOT USE THIS RANDOM SOURCE FOR ANY CRYPTOGRAPHIC OPERATION |
|---|
| | | */ |
|---|
| | | BCTBX_PUBLIC unsigned int bctbx_random(void); |
|---|
| | | |
|---|
| | | |
|---|
| | |
|---|
| | | /* |
|---|
| | | bctoolbox |
|---|
| | | Copyright (C) 2016 Belledonne Communications SARL. |
|---|
| | | |
|---|
| | | This program is free software: you can redistribute it and/or modify |
|---|
| | | it under the terms of the GNU Affero General Public License as |
|---|
| | | published by the Free Software Foundation, either version 3 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 Affero General Public License for more details. |
|---|
| | | |
|---|
| | | You should have received a copy of the GNU Affero General Public License |
|---|
| | | along with this program. If not, see <http://www.gnu.org/licenses/>. |
|---|
| | | * Copyright (c) 2016-2020 Belledonne Communications SARL. |
|---|
| | | * |
|---|
| | | * This file is part of bctoolbox. |
|---|
| | | * |
|---|
| | | * 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 3 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, see <http://www.gnu.org/licenses/>. |
|---|
| | | */ |
|---|
| | | |
|---|
| | | #ifndef BCTBX_REGEX_H |
|---|
| | |
|---|
| | | /* |
|---|
| | | tester - liblinphone test suite |
|---|
| | | Copyright (C) 2013 Belledonne Communications SARL |
|---|
| | | |
|---|
| | | 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, see <http://www.gnu.org/licenses/>. |
|---|
| | | */ |
|---|
| | | * Copyright (c) 2016-2020 Belledonne Communications SARL. |
|---|
| | | * |
|---|
| | | * This file is part of bctoolbox. |
|---|
| | | * |
|---|
| | | * 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 3 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, see <http://www.gnu.org/licenses/>. |
|---|
| | | */ |
|---|
| | | |
|---|
| | | #ifndef BCTOOLBOX_TESTER_H |
|---|
| | | #define BCTOOLBOX_TESTER_H |
|---|
| | |
|---|
| | | |
|---|
| | | BCTBX_PUBLIC int bc_tester_register_suite_by_name(const char *suite_name); |
|---|
| | | BCTBX_PUBLIC void bc_tester_add_suite(test_suite_t *suite); |
|---|
| | | BCTBX_PUBLIC void bc_tester_set_max_parallel_suites(int max_parallel_suites); |
|---|
| | | BCTBX_PUBLIC void bc_tester_uninit(void); |
|---|
| | | BCTBX_PUBLIC void bc_tester_printf(int level, const char *fmt, ...); |
|---|
| | | BCTBX_PUBLIC const char * bc_tester_get_resource_dir_prefix(void); |
|---|
| | |
|---|
| | | /* |
|---|
| | | vconnect.h |
|---|
| | | Copyright (C) 2017 Belledonne Communications SARL |
|---|
| | | |
|---|
| | | 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. |
|---|
| | | */ |
|---|
| | | * Copyright (c) 2016-2020 Belledonne Communications SARL. |
|---|
| | | * |
|---|
| | | * This file is part of bctoolbox. |
|---|
| | | * |
|---|
| | | * 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 3 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, see <http://www.gnu.org/licenses/>. |
|---|
| | | */ |
|---|
| | | |
|---|
| | | #ifndef BCTBX_VCONNECT |
|---|
| | | #define BCTBX_VCONNECT |
|---|
| | |
|---|
| | | /* |
|---|
| | | vfs.h |
|---|
| | | Copyright (C) 2016 Belledonne Communications SARL |
|---|
| | | |
|---|
| | | 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. |
|---|
| | | */ |
|---|
| | | * Copyright (c) 2016-2020 Belledonne Communications SARL. |
|---|
| | | * |
|---|
| | | * This file is part of bctoolbox. |
|---|
| | | * |
|---|
| | | * 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 3 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, see <http://www.gnu.org/licenses/>. |
|---|
| | | */ |
|---|
| | | |
|---|
| | | #ifndef BCTBX_VFS_H |
|---|
| | | #define BCTBX_VFS_H |
|---|
| | |
|---|
| | | |
|---|
| | | #define BCTBX_VFS_ERROR -255 /* Some kind of disk I/O error occurred */ |
|---|
| | | |
|---|
| | | #define BCTBX_VFS_PRINTF_PAGE_SIZE 4096 /* Size of the page hold in memory by fprintf */ |
|---|
| | | #define BCTBX_VFS_GETLINE_PAGE_SIZE 17385 /* Size of the page hold in memory by getnextline */ |
|---|
| | | |
|---|
| | | #ifdef __cplusplus |
|---|
| | | extern "C"{ |
|---|
| | |
|---|
| | | const struct bctbx_io_methods_t *pMethods; /* Methods for an open file: all Developpers must supply this field at open step*/ |
|---|
| | | /*the fields below are used by the default implementation. Developpers are not required to supply them, but may use them if they find |
|---|
| | | * them useful*/ |
|---|
| | | void* pUserData; /*Developpers can store private data under this pointer */ |
|---|
| | | int fd; /* File descriptor */ |
|---|
| | | off_t offset; /*File offset used by lseek*/ |
|---|
| | | void* pUserData; /* Developpers can store private data under this pointer */ |
|---|
| | | off_t offset; /* File offset used by bctbx_file_fprintf and bctbx_file_get_nxtline */ |
|---|
| | | /* fprintf cache */ |
|---|
| | | char fPage[BCTBX_VFS_PRINTF_PAGE_SIZE]; /* Buffer storing the current page cached by fprintf */ |
|---|
| | | off_t fPageOffset; /* The original offset of the cached page */ |
|---|
| | | size_t fSize; /* number of bytes in cache */ |
|---|
| | | /* get_nxtline cache */ |
|---|
| | | char gPage[BCTBX_VFS_GETLINE_PAGE_SIZE+1]; /* Buffer storing the current page cachec by get_nxtline +1 to hold the \0 */ |
|---|
| | | off_t gPageOffset; /* The offset of the cached page */ |
|---|
| | | size_t gSize; /* actual size of the data in cache */ |
|---|
| | | }; |
|---|
| | | |
|---|
| | | |
|---|
| | |
|---|
| | | ssize_t (*pFuncWrite)(bctbx_vfs_file_t *pFile, const void* buf, size_t count, off_t offset); |
|---|
| | | int (*pFuncTruncate)(bctbx_vfs_file_t *pFile, int64_t size); |
|---|
| | | int64_t (*pFuncFileSize)(bctbx_vfs_file_t *pFile); |
|---|
| | | int (*pFuncSync)(bctbx_vfs_file_t *pFile); |
|---|
| | | int (*pFuncGetLineFromFd)(bctbx_vfs_file_t *pFile, char* s, int count); |
|---|
| | | off_t (*pFuncSeek)(bctbx_vfs_file_t *pFile, off_t offset, int whence); |
|---|
| | | bool_t (*pFuncIsEncrypted)(bctbx_vfs_file_t *pFile); |
|---|
| | | }; |
|---|
| | | |
|---|
| | | |
|---|
| | |
|---|
| | | const char *vfsName; /* Virtual file system name */ |
|---|
| | | int (*pFuncOpen)(bctbx_vfs_t *pVfs, bctbx_vfs_file_t *pFile, const char *fName, int openFlags); |
|---|
| | | }; |
|---|
| | | |
|---|
| | | |
|---|
| | | /* API to use the VFS */ |
|---|
| | | /* |
|---|
| | | * This function returns a pointer to the VFS implemented in this file. |
|---|
| | | */ |
|---|
| | | BCTBX_PUBLIC bctbx_vfs_t *bc_create_vfs(void); |
|---|
| | | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Attempts to read count bytes from the open file given by pFile, at the position starting at offset |
|---|
| | |
|---|
| | | BCTBX_PUBLIC int bctbx_file_get_nxtline(bctbx_vfs_file_t *pFile, char *s, int maxlen); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Wrapper to pFuncSeek VFS method call. Set the position to offset in the file. |
|---|
| | | * Simply sync the file contents given through the file handle |
|---|
| | | * to the persistent media. |
|---|
| | | * @param pFile File handle pointer. |
|---|
| | | * @return BCTBX_VFS_OK on success, BCTBX_VFS_ERROR otherwise |
|---|
| | | */ |
|---|
| | | BCTBX_PUBLIC int bctbx_file_sync(bctbx_vfs_file_t *pFile); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the position to offset in the file, this position is used only by the function |
|---|
| | | * bctbx_file_get_nxtline. Read and write give their own offset as param and won't modify this one |
|---|
| | | * @param pFile File handle pointer. |
|---|
| | | * @param offset File offset where to set the position to. |
|---|
| | | * @param whence Either SEEK_SET, SEEK_CUR,SEEK_END |
|---|
| | |
|---|
| | | */ |
|---|
| | | BCTBX_PUBLIC off_t bctbx_file_seek(bctbx_vfs_file_t *pFile, off_t offset, int whence); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the file encryption status |
|---|
| | | * @param pFile File handle pointer. |
|---|
| | | * @return true if the file is encrypted |
|---|
| | | */ |
|---|
| | | BCTBX_PUBLIC bool_t bctbx_file_is_encrypted(bctbx_vfs_file_t *pFile); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set default VFS pointer pDefault to my_vfs. |
|---|
| New file |
| | |
|---|
| | | /* |
|---|
| | | * Copyright (c) 2016-2020 Belledonne Communications SARL. |
|---|
| | | * |
|---|
| | | * This file is part of bctoolbox. |
|---|
| | | * |
|---|
| | | * 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 3 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, see <http://www.gnu.org/licenses/>. |
|---|
| | | */ |
|---|
| | | |
|---|
| | | #ifndef BCTBX_VFS_ENCRYPTED_HH |
|---|
| | | #define BCTBX_VFS_ENCRYPTED_HH |
|---|
| | | |
|---|
| | | #include "bctoolbox/vfs.h" |
|---|
| | | #include "bctoolbox/exception.hh" |
|---|
| | | #include <functional> |
|---|
| | | #include <vector> |
|---|
| | | #include <memory> |
|---|
| | | #include "bctoolbox/port.h" |
|---|
| | | |
|---|
| | | namespace bctoolbox { |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief This dedicated exception inherits \ref BctoolboxException. |
|---|
| | | * |
|---|
| | | */ |
|---|
| | | class EvfsException : public BctbxException { |
|---|
| | | public: |
|---|
| | | EvfsException() = default; |
|---|
| | | EvfsException(const std::string &message): BctbxException(message) {} |
|---|
| | | EvfsException(const char *message): BctbxException(message) {} |
|---|
| | | virtual ~EvfsException() throw() {} |
|---|
| | | EvfsException(const EvfsException &other): BctbxException(other) {} |
|---|
| | | |
|---|
| | | template <typename T> EvfsException &operator<<(const T &val) { |
|---|
| | | BctbxException::operator<<(val); |
|---|
| | | return *this; |
|---|
| | | } |
|---|
| | | }; |
|---|
| | | |
|---|
| | | #define EVFS_EXCEPTION EvfsException() << " " << __FILE__ << ":" << __LINE__ << " " |
|---|
| | | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Virtual File sytem provided |
|---|
| | | */ |
|---|
| | | extern BCTBX_PUBLIC bctbx_vfs_t bcEncryptedVfs; |
|---|
| | | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Provided encryption suites |
|---|
| | | */ |
|---|
| | | enum class EncryptionSuite : uint16_t { |
|---|
| | | unset = 0,/**< no encryption suite selected */ |
|---|
| | | dummy = 1, /**< a test suite, do not use other than for test */ |
|---|
| | | aes256gcm128_sha256 = 2, /**< This module encrypts blocks with AES256GCM and authenticate header using HMAC-sha256 */ |
|---|
| | | plain = 0xFFFF /**< no encryption activated, direct use of standard file system API */ |
|---|
| | | }; |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Helper function returning a string holding the suite name |
|---|
| | | * @param[in] suite the encryption suite as a c++ enum |
|---|
| | | * @return the suite name in a readable string |
|---|
| | | */ |
|---|
| | | const std::string encryptionSuiteString(const EncryptionSuite suite) noexcept; |
|---|
| | | |
|---|
| | | /* complete declaration follows, we need this one to define the callback type */ |
|---|
| | | class VfsEncryption; |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Define a function prototype to be called at each file opening. |
|---|
| | | * This function is a static class property, used to retrieve secretMaterial to encrypt/decrypt the file |
|---|
| | | */ |
|---|
| | | using EncryptedVfsOpenCb = std::function<void(VfsEncryption &settings)>; |
|---|
| | | |
|---|
| | | // forward declare this type, store all the encryption data and functions |
|---|
| | | class VfsEncryptionModule; |
|---|
| | | |
|---|
| | | /** Store in the bctbx_vfs_file_t userData field an object specific to encryption */ |
|---|
| | | class VfsEncryption { |
|---|
| | | /* Class properties and method */ |
|---|
| | | private: |
|---|
| | | static EncryptedVfsOpenCb s_openCallback; /**< a class callback to get secret material at file opening. Implemented as static as it is called by constructor */ |
|---|
| | | public: |
|---|
| | | /** |
|---|
| | | * at file opening a callback ask for crypto material, it is class property, set it using this class method |
|---|
| | | */ |
|---|
| | | static void openCallbackSet(EncryptedVfsOpenCb cb) noexcept; |
|---|
| | | static EncryptedVfsOpenCb openCallbackGet() noexcept; |
|---|
| | | |
|---|
| | | /* Object properties and methods */ |
|---|
| | | private: |
|---|
| | | uint16_t mVersionNumber; /**< version number of the encryption vfs */ |
|---|
| | | size_t mChunkSize; /**< size of the file chunks payload in bytes : default is 4kB */ |
|---|
| | | size_t rawChunkSizeGet() const noexcept; /** return the size of a chunk including its encryption header, as stored in the raw file */ |
|---|
| | | std::shared_ptr<VfsEncryptionModule> m_module; /**< one of the available encryption module : if nullptr, assume we deal with regular plain file */ |
|---|
| | | size_t mHeaderExtensionSize; /**< header extension size */ |
|---|
| | | const std::string mFilename; /**< the filename as given to the open function */ |
|---|
| | | uint64_t mFileSize; /**< size of the plaintext file */ |
|---|
| | | |
|---|
| | | uint64_t rawFileSizeGet() const noexcept; /**< return the size of the raw file */ |
|---|
| | | uint32_t getChunkIndex(uint64_t offset) const noexcept; /**< return the chunk index where to find the given offset */ |
|---|
| | | size_t getChunkOffset(uint32_t index) const noexcept; /**< return the offset in the actual file of the begining of the chunk */ |
|---|
| | | std::vector<uint8_t> r_header; /**< a cache of the header - without the encryption module data */ |
|---|
| | | /** flags use to communicate during differents functions involved at file opening **/ |
|---|
| | | bool mEncryptExistingPlainFile; /**< when opening a plain file, if the callback set an encryption suite and key material : migrate the file */ |
|---|
| | | bool mIntegrityFullCheck; /**< if the file size given in the header metadata is incorrect, full check the file integrity and revrite header */ |
|---|
| | | int mAccessMode; /**< the flags used to open the file, filtered on the access mode */ |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Parse the header of an encrypted file, check everything seems correct |
|---|
| | | * may perform integrity checking if the encryption module provides it |
|---|
| | | * |
|---|
| | | * @throw a EvfsException if something goes wrong |
|---|
| | | */ |
|---|
| | | void parseHeader(); |
|---|
| | | /** |
|---|
| | | * Write the encrypted file header to the actual file |
|---|
| | | * Create the needed structures if the file is actually empty |
|---|
| | | * @param[in] fp if a file pointer is given write to this one, otherwise use the pFileStp property |
|---|
| | | * |
|---|
| | | * @throw a EvfsException if something goes wrong |
|---|
| | | **/ |
|---|
| | | void writeHeader(bctbx_vfs_file_t *fp=nullptr); |
|---|
| | | |
|---|
| | | public: |
|---|
| | | bctbx_vfs_file_t *pFileStd; /**< The encrypted vfs encapsulate a standard one */ |
|---|
| | | |
|---|
| | | VfsEncryption(bctbx_vfs_file_t *stdFp, const std::string &filename, int openFlags, int accessMode); |
|---|
| | | ~VfsEncryption(); |
|---|
| | | |
|---|
| | | |
|---|
| | | /*** |
|---|
| | | * Plain version of the file related accessors |
|---|
| | | ***/ |
|---|
| | | /** |
|---|
| | | * @return the size of the plain text file |
|---|
| | | */ |
|---|
| | | int64_t fileSizeGet() const noexcept; |
|---|
| | | |
|---|
| | | /* Read from file at given offset the requested size */ |
|---|
| | | std::vector<uint8_t> read(size_t offset, size_t count) const; |
|---|
| | | |
|---|
| | | /* write to file at given offset the requested size */ |
|---|
| | | size_t write(const std::vector<uint8_t> &plainData, size_t offset); |
|---|
| | | |
|---|
| | | /* Truncate the file to the given size, if given size is greater than current, pad with 0 */ |
|---|
| | | void truncate(const uint64_t size); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the filename |
|---|
| | | * @return a string with the filename as given to the open function |
|---|
| | | */ |
|---|
| | | std::string filenameGet() const noexcept; |
|---|
| | | |
|---|
| | | |
|---|
| | | |
|---|
| | | /*** |
|---|
| | | * Encryption related API |
|---|
| | | ***/ |
|---|
| | | /** |
|---|
| | | * Set an encryption suite. |
|---|
| | | * When called at file creation, select the module to use for this file |
|---|
| | | * When called at the opening of an existing file, check it is the suite used at file creation, throw an exception if they differs |
|---|
| | | */ |
|---|
| | | void encryptionSuiteSet(const EncryptionSuite); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the secret Material in the encryption module |
|---|
| | | * This function cannot be called if a encryption suite was not set. |
|---|
| | | */ |
|---|
| | | void secretMaterialSet(const std::vector<uint8_t> &secretMaterial); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the encryption suite used for this file |
|---|
| | | * Can be return unset if the file is being created |
|---|
| | | */ |
|---|
| | | EncryptionSuite encryptionSuiteGet() const noexcept; |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the size of chunks in which the file is divided for encryption |
|---|
| | | */ |
|---|
| | | size_t chunkSizeGet() const noexcept; |
|---|
| | | /** |
|---|
| | | * Set the size, in bytes, of chunks in which the file is divided for encryption |
|---|
| | | * This size must be a multiple of 16, accepted values in range [16, (2^16-1)*16]. |
|---|
| | | * If the size is set on an existing file and differs from previous setting, an exception is generated |
|---|
| | | * Default chunk size at file creation is 4kB. |
|---|
| | | * A file holds a maximum of 2^32-1 chunks. 16 bytes chunks - not recommended smallest admissible value - limit the file size to 64GB |
|---|
| | | */ |
|---|
| | | void chunkSizeSet(const size_t size); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get raw header: encryption module might check integrity on header |
|---|
| | | * This function returns the raw header, without the encryption module part |
|---|
| | | */ |
|---|
| | | const std::vector<uint8_t>& rawHeaderGet() const noexcept; |
|---|
| | | |
|---|
| | | |
|---|
| | | }; |
|---|
| | | |
|---|
| | | |
|---|
| | | } // namespace bctoolbox |
|---|
| | | #endif /* BCTBX_VFS_STANDARD_HH */ |
|---|
| New file |
| | |
|---|
| | | /* |
|---|
| | | * Copyright (c) 2016-2020 Belledonne Communications SARL. |
|---|
| | | * |
|---|
| | | * This file is part of bctoolbox. |
|---|
| | | * |
|---|
| | | * 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 3 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, see <http://www.gnu.org/licenses/>. |
|---|
| | | */ |
|---|
| | | |
|---|
| | | #ifndef BCTBX_VFS_STANDARD_H |
|---|
| | | #define BCTBX_VFS_STANDARD_H |
|---|
| | | |
|---|
| | | #include "bctoolbox/vfs.h" |
|---|
| | | #include "bctoolbox/port.h" |
|---|
| | | |
|---|
| | | #ifdef __cplusplus |
|---|
| | | extern "C"{ |
|---|
| | | #endif |
|---|
| | | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Virtual File sytem provided |
|---|
| | | */ |
|---|
| | | extern BCTBX_PUBLIC bctbx_vfs_t bcStandardVfs; |
|---|
| | | |
|---|
| | | #ifdef __cplusplus |
|---|
| | | } |
|---|
| | | #endif |
|---|
| | | |
|---|
| | | #endif /* BCTBX_VFS_STANDARD_H */ |
|---|
| | |
|---|
| | | belle_sip_user_body_handler_stop_callback_t stop_cb, |
|---|
| | | void *data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Buffering user body handler creation |
|---|
| | | * Buffering file bodyhandler will buffer the received chunks to deliver only modulo(buffer_size) chunks. |
|---|
| | | * The bufferized part, if any, is prepended to the next chunk, |
|---|
| | | * what remains in buffer when the end function is called is delivered through a last call to rcv_chunk |
|---|
| | | * The original purpose of this is to be able to deliver modulo(16) size chunks to the file transfer decryption function |
|---|
| | | */ |
|---|
| | | BELLESIP_EXPORT belle_sip_user_body_handler_t *belle_sip_buffering_user_body_handler_new( |
|---|
| | | size_t total_size, |
|---|
| | | size_t buffer_size, |
|---|
| | | belle_sip_body_handler_progress_callback_t progress_cb, |
|---|
| | | belle_sip_user_body_handler_start_callback_t start_cb, |
|---|
| | | belle_sip_user_body_handler_recv_callback_t recv_cb, |
|---|
| | | belle_sip_user_body_handler_send_callback_t send_cb, |
|---|
| | | belle_sip_user_body_handler_stop_callback_t stop_cb, |
|---|
| | | void *data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Body handler that gets/puts data from/to a file. |
|---|
| | |
|---|
| | | #define BELLE_SIP_FILE_BODY_HANDLER(obj) BELLE_SIP_CAST(obj, belle_sip_file_body_handler_t) |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_file_body_handler_t *belle_sip_file_body_handler_new(const char *filepath, belle_sip_body_handler_progress_callback_t progress_cb, void *data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Buffering file body handler creation |
|---|
| | | * Buffering file bodyhandler will buffer the received chunks to deliver only modulo(buffer_size) chunks. |
|---|
| | | * The bufferized part, if any, is prepended to the next chunk, |
|---|
| | | * what remains in buffer when the end function is called is delivered through a last call to rcv_chunk |
|---|
| | | * The original purpose of this is to be able to deliver modulo(16) size chunks to the file transfer decryption function |
|---|
| | | */ |
|---|
| | | BELLESIP_EXPORT belle_sip_file_body_handler_t *belle_sip_buffering_file_body_handler_new(const char *filepath, const size_t buffer_size, belle_sip_body_handler_progress_callback_t progress_cb, void *data); |
|---|
| | | BELLESIP_EXPORT size_t belle_sip_file_body_handler_get_file_size(belle_sip_file_body_handler_t *file_bh); |
|---|
| | | BELLESIP_EXPORT void belle_sip_file_body_handler_set_user_body_handler(belle_sip_file_body_handler_t *file_bh, belle_sip_user_body_handler_t *user_bh); |
|---|
| | | |
|---|
| | |
|---|
| | | **/ |
|---|
| | | BELLESIP_EXPORT unsigned int belle_sip_dialog_get_local_seq_number(const belle_sip_dialog_t *dialog); |
|---|
| | | |
|---|
| | | unsigned int belle_sip_dialog_get_remote_seq_number(const belle_sip_dialog_t *dialog); |
|---|
| | | BELLESIP_EXPORT unsigned int belle_sip_dialog_get_remote_seq_number(const belle_sip_dialog_t *dialog); |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT const char *belle_sip_dialog_get_local_tag(const belle_sip_dialog_t *dialog); |
|---|
| | | |
|---|
| | |
|---|
| | | /* |
|---|
| | | * Copyright (c) 2012-2019 Belledonne Communications SARL. |
|---|
| | | * |
|---|
| | | * This file is part of belle-sip. |
|---|
| | | * |
|---|
| | | * 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 3 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, see <http://www.gnu.org/licenses/>. |
|---|
| | | */ |
|---|
| | |
|---|
| | | |
|---|
| | | BELLE_SIP_BEGIN_DECLS |
|---|
| | | |
|---|
| | | |
|---|
| | | /*************************************************************************************** |
|---|
| | | * header address |
|---|
| | | * |
|---|
| | | **************************************************************************************/ |
|---|
| | | |
|---|
| | | typedef struct _belle_sip_header_address belle_sip_header_address_t; |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_address_t* belle_sip_header_address_new(void); |
|---|
| | |
|---|
| | | * */ |
|---|
| | | BELLESIP_EXPORT belle_sip_header_address_t* belle_sip_header_address_create2(const char* display, belle_generic_uri_t* uri); |
|---|
| | | |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_address_t* belle_sip_header_address_parse (const char* address) ; |
|---|
| | | |
|---|
| | | /* |
|---|
| | | same as belle_sip_header_address_parse but with less syntax checking |
|---|
| | | */ |
|---|
| | | BELLESIP_EXPORT belle_sip_header_address_t* belle_sip_header_address_fast_parse (const char* address) ; |
|---|
| | | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * returns a sip uri. A header address cannot have both a sip uri and an absolute uri. |
|---|
| | |
|---|
| | | BELLESIP_EXPORT void belle_sip_header_address_set_absolute_uri(belle_sip_header_address_t* address, belle_generic_uri_t* uri); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Enable automatic filling of the contact ip, port and transport according to the channel that sends this message. |
|---|
| | | * Enable automatic filling of the contact ip, port and transport according to the channel that sends this message. |
|---|
| | | **/ |
|---|
| | | BELLESIP_EXPORT void belle_sip_header_address_set_automatic(belle_sip_header_address_t *address, int automatic); |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT int belle_sip_header_address_get_automatic(const belle_sip_header_address_t *address); |
|---|
| | | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * |
|---|
| | | */ |
|---|
| | | BELLESIP_EXPORT const char* belle_sip_header_address_get_displayname(const belle_sip_header_address_t* address); |
|---|
| | | /** |
|---|
| | | * |
|---|
| | | */ |
|---|
| | | BELLESIP_EXPORT void belle_sip_header_address_set_displayname(belle_sip_header_address_t* address, const char* uri); |
|---|
| | | |
|---|
| | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_address_t* belle_sip_header_address_clone(const belle_sip_header_address_t* orig); |
|---|
| | | |
|---|
| | | |
|---|
| | | |
|---|
| | | #define BELLE_SIP_HEADER_ADDRESS(t) BELLE_SIP_CAST(t,belle_sip_header_address_t) |
|---|
| | | |
|---|
| | | |
|---|
| | | |
|---|
| | | /*************************************************************************************** |
|---|
| | | * header common |
|---|
| | | * |
|---|
| | | **************************************************************************************/ |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_t* belle_sip_header_parse (const char* header); |
|---|
| | | BELLESIP_EXPORT belle_sip_header_t* belle_sip_header_create (const char* name,const char* value); |
|---|
| | | BELLESIP_EXPORT belle_sip_header_t* belle_http_header_create (const char* name,const char* value); |
|---|
| | |
|---|
| | | #define BELLE_SIP_HEADER(t) BELLE_SIP_CAST(t,belle_sip_header_t) |
|---|
| | | |
|---|
| | | /****************************** |
|---|
| | | * |
|---|
| | | * Allow header inherit from header |
|---|
| | | * |
|---|
| | | ******************************/ |
|---|
| | | typedef struct _belle_sip_header_allow belle_sip_header_allow_t; |
|---|
| | | |
|---|
| | |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_contact_t* belle_sip_header_contact_new(void); |
|---|
| | | |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_contact_t* belle_sip_header_contact_parse (const char* contact) ; |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_contact_t* belle_sip_header_contact_create (const belle_sip_header_address_t* contact) ; |
|---|
| | | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the value of the expires parameter or -1 if no expires parameter was specified or if the parameter value cannot be parsed as an int. |
|---|
| | | *@returns value of the expires parameter measured in delta-seconds, O implies removal of Registration specified in Contact Header. |
|---|
| | | * |
|---|
| | | */ |
|---|
| | | * Returns the value of the expires parameter or -1 if no expires parameter was specified or if the parameter value cannot be parsed as an int. |
|---|
| | | *@returns value of the expires parameter measured in delta-seconds, O implies removal of Registration specified in Contact Header. |
|---|
| | | */ |
|---|
| | | BELLESIP_EXPORT int belle_sip_header_contact_get_expires(const belle_sip_header_contact_t* contact); |
|---|
| | | /** |
|---|
| | | * Returns the value of the q-value parameter of this ContactHeader. The q-value parameter indicates the relative preference amongst a set of locations. q-values are decimal numbers from 0 to 1, with higher values indicating higher preference. |
|---|
| | |
|---|
| | | */ |
|---|
| | | BELLESIP_EXPORT float belle_sip_header_contact_get_qvalue(const belle_sip_header_contact_t* contact); |
|---|
| | | /** |
|---|
| | | * Returns a boolean value that indicates if the contact header has the format of Contact: *. |
|---|
| | | * @return true if this is a wildcard address, false otherwise. |
|---|
| | | */ |
|---|
| | | * Returns a boolean value that indicates if the contact header has the format of Contact: *. |
|---|
| | | * @return true if this is a wildcard address, false otherwise. |
|---|
| | | */ |
|---|
| | | BELLESIP_EXPORT unsigned int belle_sip_header_contact_is_wildcard(const belle_sip_header_contact_t* contact); |
|---|
| | | /** |
|---|
| | | * |
|---|
| | | */ |
|---|
| | | BELLESIP_EXPORT int belle_sip_header_contact_set_expires(belle_sip_header_contact_t* contact, int expires); |
|---|
| | | /** |
|---|
| | |
|---|
| | | BELLESIP_EXPORT int belle_sip_header_contact_set_qvalue(belle_sip_header_contact_t* contact, float qvalue); |
|---|
| | | /** |
|---|
| | | * Sets a wildcard on this contact address that is "*" is assigned to the contact header so that the header will have the format of Contact: *. |
|---|
| | | * |
|---|
| | | */ |
|---|
| | | BELLESIP_EXPORT void belle_sip_header_contact_set_wildcard(belle_sip_header_contact_t* contact,unsigned int is_wildcard); |
|---|
| | | |
|---|
| | | /** Contact header equality function |
|---|
| | | * @return 0 if not equals |
|---|
| | | * |
|---|
| | | * */ |
|---|
| | | * @return 0 if not equals |
|---|
| | | * */ |
|---|
| | | BELLESIP_EXPORT unsigned int belle_sip_header_contact_equals(const belle_sip_header_contact_t* a,const belle_sip_header_contact_t* b); |
|---|
| | | |
|---|
| | | /** Contact header equality function, same as #belle_sip_header_contact_equals but return 0 if equals, very useful with #belle_sip_list |
|---|
| | | * @return 0 if equals |
|---|
| | | * |
|---|
| | | * */ |
|---|
| | | * @return 0 if equals |
|---|
| | | * */ |
|---|
| | | BELLESIP_EXPORT unsigned int belle_sip_header_contact_not_equals(const belle_sip_header_contact_t* a,const belle_sip_header_contact_t* b); |
|---|
| | | |
|---|
| | | /** Contact header equality function |
|---|
| | | * @return 0 if not equals |
|---|
| | | * |
|---|
| | | * */ |
|---|
| | | * @return 0 if not equals |
|---|
| | | * */ |
|---|
| | | BELLESIP_EXPORT unsigned int belle_sip_header_contact_equals_with_uri_omitting(const belle_sip_header_contact_t* a,const belle_sip_header_contact_t* b); |
|---|
| | | |
|---|
| | | /** Contact header equality function, same as #belle_sip_header_contact_equals but return 0 if equals, very useful with #belle_sip_list |
|---|
| | | * @return 0 if equals |
|---|
| | | * |
|---|
| | | * */ |
|---|
| | | * @return 0 if equals |
|---|
| | | * */ |
|---|
| | | BELLESIP_EXPORT unsigned int belle_sip_header_contact_not_equals_with_uri_omitting(const belle_sip_header_contact_t* a,const belle_sip_header_contact_t* b); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Enable automatic filling of the contact ip, port and transport according to the channel that sends this message. |
|---|
| | | * @deprecated use belle_sip_header_address_set_automatic(); |
|---|
| | | * Enable automatic filling of the contact ip, port and transport according to the channel that sends this message. |
|---|
| | | * @deprecated use belle_sip_header_address_set_automatic(); |
|---|
| | | **/ |
|---|
| | | BELLESIP_EXPORT void belle_sip_header_contact_set_automatic(belle_sip_header_contact_t *a, int enabled); |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT int belle_sip_header_contact_get_automatic(const belle_sip_header_contact_t *a); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Indicates whether a contact in automatic mode (see belle_sip_header_contact_set_automatic()) could be filled properly when the message was sent. |
|---|
| | | * If a message is sent through a connection that has just been initiated, public IP and port are unknown, they will be learned after receiving the first response. |
|---|
| | | * This can be used by the upper layer to decide to resubmit the request. |
|---|
| | | * Indicates whether a contact in automatic mode (see belle_sip_header_contact_set_automatic()) could be filled properly when the message was sent. |
|---|
| | | * If a message is sent through a connection that has just been initiated, public IP and port are unknown, they will be learned after receiving the first response. |
|---|
| | | * This can be used by the upper layer to decide to resubmit the request. |
|---|
| | | **/ |
|---|
| | | BELLESIP_EXPORT int belle_sip_header_contact_is_unknown(const belle_sip_header_contact_t *a); |
|---|
| | | |
|---|
| | | #define BELLE_SIP_RANDOM_TAG ((const char*)-1) |
|---|
| | | #define BELLE_SIP_HEADER_CONTACT(t) BELLE_SIP_CAST(t,belle_sip_header_contact_t) |
|---|
| | | #define BELLE_SIP_CONTACT "Contact" |
|---|
| | | /****************************** |
|---|
| | | * From header object inherent from header_address |
|---|
| | | * |
|---|
| | | |
|---|
| | | /****************************** |
|---|
| | | * From header object inherit from header_address |
|---|
| | | ******************************/ |
|---|
| | | typedef struct _belle_sip_header_from belle_sip_header_from_t; |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_from_t* belle_sip_header_from_new(void); |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_from_t* belle_sip_header_from_create(const belle_sip_header_address_t* address, const char *tag); |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_from_t* belle_sip_header_from_create2(const char *address, const char *tag); |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_from_t* belle_sip_header_from_parse(const char* from) ; |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT void belle_sip_header_from_set_tag(belle_sip_header_from_t* from, const char* tag); |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT const char* belle_sip_header_from_get_tag(const belle_sip_header_from_t* from); |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT void belle_sip_header_from_set_random_tag(belle_sip_header_from_t *obj); |
|---|
| | | |
|---|
| | | #define BELLE_SIP_HEADER_FROM(t) BELLE_SIP_CAST(t,belle_sip_header_from_t) |
|---|
| | | #define BELLE_SIP_FROM "From" |
|---|
| | | /****************************** |
|---|
| | | * To header object inherent from header_address |
|---|
| | | * |
|---|
| | | |
|---|
| | | /****************************** |
|---|
| | | * To header object inherit from header_address |
|---|
| | | ******************************/ |
|---|
| | | typedef struct _belle_sip_header_to belle_sip_header_to_t; |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_to_t* belle_sip_header_to_new(void); |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_to_t* belle_sip_header_to_parse(const char* to) ; |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_to_t* belle_sip_header_to_create(const belle_sip_header_address_t *address, const char *tag); |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_to_t* belle_sip_header_to_create2(const char *address, const char *tag); |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT void belle_sip_header_to_set_tag(belle_sip_header_to_t* from, const char* tag); |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT const char* belle_sip_header_to_get_tag(const belle_sip_header_to_t* from); |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT void belle_sip_header_to_set_random_tag(belle_sip_header_to_t *obj); |
|---|
| | | |
|---|
| | | #define BELLE_SIP_HEADER_TO(t) BELLE_SIP_CAST(t,belle_sip_header_to_t) |
|---|
| | | #define BELLE_SIP_TO "To" |
|---|
| | | |
|---|
| | | /****************************** |
|---|
| | | * Diversion header object inherent from header_address |
|---|
| | | * |
|---|
| | | * Diversion header object inherit from header_address |
|---|
| | | ******************************/ |
|---|
| | | typedef struct _belle_sip_header_diversion belle_sip_header_diversion_t; |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_diversion_t* belle_sip_header_diversion_new(void); |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_diversion_t* belle_sip_header_diversion_parse(const char* diversion) ; |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_diversion_t* belle_sip_header_diversion_create(const belle_sip_header_address_t *address, const char *tag); |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_diversion_t* belle_sip_header_diversion_create2(const char *address, const char *tag); |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT void belle_sip_header_diversion_set_tag(belle_sip_header_diversion_t* diversion, const char* tag); |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT const char* belle_sip_header_diversion_get_tag(const belle_sip_header_diversion_t* from); |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT void belle_sip_header_diversion_set_random_tag(belle_sip_header_diversion_t *obj); |
|---|
| | | |
|---|
| | | #define BELLE_SIP_HEADER_DIVERSION(t) BELLE_SIP_CAST(t,belle_sip_header_diversion_t) |
|---|
| | | #define BELLE_SIP_DIVERSION "Diversion" |
|---|
| | | |
|---|
| | | /****************************** |
|---|
| | | * Via header object inherent from header_address |
|---|
| | | * |
|---|
| | | * Via header object inherit from header_address |
|---|
| | | ******************************/ |
|---|
| | | typedef struct _belle_sip_header_via belle_sip_header_via_t; |
|---|
| | | |
|---|
| | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_via_t* belle_sip_header_via_parse (const char* via) ; |
|---|
| | | BELLESIP_EXPORT const char* belle_sip_header_via_get_branch(const belle_sip_header_via_t* via); |
|---|
| | | BELLESIP_EXPORT const char* belle_sip_header_via_get_transport(const belle_sip_header_via_t* via); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get lower case version of the transport |
|---|
| | | * @return the lower case version of the transport if from tcp,udp,tls or dtls else, return the value from #belle_sip_header_via_get_transport |
|---|
| | |
|---|
| | | BELLESIP_EXPORT int belle_sip_header_via_set_rport(belle_sip_header_via_t* via,int rport); |
|---|
| | | BELLESIP_EXPORT void belle_sip_header_via_set_transport(belle_sip_header_via_t* via,const char* transport); |
|---|
| | | BELLESIP_EXPORT int belle_sip_header_via_set_ttl(belle_sip_header_via_t* via, int ttl); |
|---|
| | | |
|---|
| | | #define BELLE_SIP_HEADER_VIA(t) BELLE_SIP_CAST(t,belle_sip_header_via_t) |
|---|
| | | #define BELLE_SIP_VIA "Via" |
|---|
| | | |
|---|
| | | /****************************** |
|---|
| | | * Call id object inherent from object |
|---|
| | | * |
|---|
| | | * Call id object inherit from object |
|---|
| | | ******************************/ |
|---|
| | | typedef struct _belle_sip_header_call_id belle_sip_header_call_id_t; |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_call_id_t* belle_sip_header_call_id_new(void); |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_call_id_t* belle_sip_header_call_id_parse (const char* call_id) ; |
|---|
| | | BELLESIP_EXPORT const char* belle_sip_header_call_id_get_call_id(const belle_sip_header_call_id_t* call_id); |
|---|
| | | BELLESIP_EXPORT void belle_sip_header_call_id_set_call_id(belle_sip_header_call_id_t* call_id,const char* id); |
|---|
| | | unsigned int belle_sip_header_call_id_equals(const belle_sip_header_call_id_t* a,const belle_sip_header_call_id_t* b); |
|---|
| | | |
|---|
| | | #define BELLE_SIP_HEADER_CALL_ID(t) BELLE_SIP_CAST(t,belle_sip_header_call_id_t) |
|---|
| | | #define BELLE_SIP_CALL_ID "Call-ID" |
|---|
| | | |
|---|
| | | /****************************** |
|---|
| | | * Retry-After object inherent from object |
|---|
| | | * |
|---|
| | | * Retry-After object inherit from object |
|---|
| | | ******************************/ |
|---|
| | | typedef struct _belle_sip_header_retry_after belle_sip_header_retry_after_t; |
|---|
| | | |
|---|
| | |
|---|
| | | |
|---|
| | | #define BELLE_SIP_HEADER_RETRY_AFTER(t) BELLE_SIP_CAST(t,belle_sip_header_retry_after_t) |
|---|
| | | #define BELLE_SIP_RETRY_AFTER "Retry-After" |
|---|
| | | |
|---|
| | | /****************************** |
|---|
| | | * cseq object inherent from object |
|---|
| | | * |
|---|
| | | * cseq object inherit from object |
|---|
| | | ******************************/ |
|---|
| | | typedef struct _belle_sip_header_cseq belle_sip_header_cseq_t; |
|---|
| | | |
|---|
| | |
|---|
| | | BELLESIP_EXPORT void belle_sip_header_cseq_set_method(belle_sip_header_cseq_t* cseq,const char* method); |
|---|
| | | BELLESIP_EXPORT unsigned int belle_sip_header_cseq_get_seq_number(const belle_sip_header_cseq_t* cseq); |
|---|
| | | BELLESIP_EXPORT void belle_sip_header_cseq_set_seq_number(belle_sip_header_cseq_t* cseq,unsigned int seq_number); |
|---|
| | | |
|---|
| | | #define BELLE_SIP_HEADER_CSEQ(t) BELLE_SIP_CAST(t,belle_sip_header_cseq_t) |
|---|
| | | #define BELLE_SIP_CSEQ "CSeq" |
|---|
| | | |
|---|
| | | /****************************** |
|---|
| | | * content type object inherent from parameters |
|---|
| | | * |
|---|
| | | * content type object inherit from parameters |
|---|
| | | ******************************/ |
|---|
| | | typedef struct _belle_sip_header_content_type belle_sip_header_content_type_t; |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_content_type_t* belle_sip_header_content_type_new(void); |
|---|
| | | BELLESIP_EXPORT belle_sip_header_content_type_t* belle_sip_header_content_type_parse (const char* content_type) ; |
|---|
| | | BELLESIP_EXPORT belle_sip_header_content_type_t* belle_sip_header_content_type_create (const char* type,const char* sub_type) ; |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_content_type_t* belle_sip_header_content_type_parse (const char* content_type) ; |
|---|
| | | BELLESIP_EXPORT belle_sip_header_content_type_t* belle_sip_header_content_type_create (const char* type,const char* sub_type) ; |
|---|
| | | BELLESIP_EXPORT const char* belle_sip_header_content_type_get_type(const belle_sip_header_content_type_t* content_type); |
|---|
| | | BELLESIP_EXPORT void belle_sip_header_content_type_set_type(belle_sip_header_content_type_t* content_type,const char* type); |
|---|
| | | BELLESIP_EXPORT const char* belle_sip_header_content_type_get_subtype(const belle_sip_header_content_type_t* content_type); |
|---|
| | | BELLESIP_EXPORT void belle_sip_header_content_type_set_subtype(belle_sip_header_content_type_t* content_type,const char* sub_type); |
|---|
| | | |
|---|
| | | #define BELLE_SIP_HEADER_CONTENT_TYPE(t) BELLE_SIP_CAST(t,belle_sip_header_content_type_t) |
|---|
| | | #define BELLE_SIP_CONTENT_TYPE "Content-Type" |
|---|
| | | |
|---|
| | | /****************************** |
|---|
| | | * |
|---|
| | | * Session-Expires inherit from header |
|---|
| | | ******************************/ |
|---|
| | | typedef struct _belle_sip_header_session_expires belle_sip_header_session_expires_t; |
|---|
| | | typedef enum { |
|---|
| | | BELLE_SIP_HEADER_SESSION_EXPIRES_UNSPECIFIED, |
|---|
| | | BELLE_SIP_HEADER_SESSION_EXPIRES_UAS, |
|---|
| | | BELLE_SIP_HEADER_SESSION_EXPIRES_UAC |
|---|
| | | } belle_sip_header_session_expires_refresher_t; |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_session_expires_t* belle_sip_header_session_expires_new(void); |
|---|
| | | BELLESIP_EXPORT belle_sip_header_session_expires_t* belle_sip_header_session_expires_create( |
|---|
| | | int delta, |
|---|
| | | belle_sip_header_session_expires_refresher_t refresher |
|---|
| | | ); |
|---|
| | | BELLESIP_EXPORT belle_sip_header_session_expires_t* belle_sip_header_session_expires_parse (const char* session_expires) ; |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT int belle_sip_header_session_expires_get_delta(const belle_sip_header_session_expires_t* session_expires); |
|---|
| | | BELLESIP_EXPORT void belle_sip_header_session_expires_set_delta(belle_sip_header_session_expires_t* session_expires, int delta); |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_session_expires_refresher_t belle_sip_header_session_expires_get_refresher_value( |
|---|
| | | const belle_sip_header_session_expires_t* session_expires |
|---|
| | | ); |
|---|
| | | BELLESIP_EXPORT void belle_sip_header_session_expires_set_refresher_value( |
|---|
| | | belle_sip_header_session_expires_t* session_expires, |
|---|
| | | belle_sip_header_session_expires_refresher_t refresher |
|---|
| | | ); |
|---|
| | | |
|---|
| | | #define BELLE_SIP_HEADER_SESSION_EXPIRES(t) BELLE_SIP_CAST(t, belle_sip_header_session_expires_t) |
|---|
| | | #define BELLE_SIP_SESSION_EXPIRES "Session-Expires" |
|---|
| | | #define BELLE_SIP_SESSION_EXPIRES_MSE "Min-SE" |
|---|
| | | |
|---|
| | | /****************************** |
|---|
| | | * Expires inherit from header |
|---|
| | | * |
|---|
| | | ******************************/ |
|---|
| | | typedef struct _belle_sip_header_expires belle_sip_header_expires_t; |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_expires_t* belle_sip_header_expires_new(void); |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_expires_t* belle_sip_header_expires_parse (const char* expires) ; |
|---|
| | | BELLESIP_EXPORT int belle_sip_header_expires_get_expires(const belle_sip_header_expires_t* expires); |
|---|
| | | BELLESIP_EXPORT void belle_sip_header_expires_set_expires(belle_sip_header_expires_t* expires,int value); |
|---|
| | | BELLESIP_EXPORT int belle_sip_header_expires_decrement_expires(belle_sip_header_expires_t* expires); |
|---|
| | | BELLESIP_EXPORT belle_sip_header_expires_t* belle_sip_header_expires_create(int expires); |
|---|
| | | |
|---|
| | | #define BELLE_SIP_HEADER_EXPIRES(t) BELLE_SIP_CAST(t,belle_sip_header_expires_t) |
|---|
| | | #define BELLE_SIP_EXPIRES "Expires" |
|---|
| | | |
|---|
| | | /****************************** |
|---|
| | | * Route header object inherent from header_address |
|---|
| | | * |
|---|
| | | * Route header object inherit from header_address |
|---|
| | | ******************************/ |
|---|
| | | typedef struct _belle_sip_header_route belle_sip_header_route_t; |
|---|
| | | |
|---|
| | |
|---|
| | | |
|---|
| | | #define BELLE_SIP_HEADER_ROUTE(t) BELLE_SIP_CAST(t,belle_sip_header_route_t) |
|---|
| | | #define BELLE_SIP_ROUTE "Route" |
|---|
| | | |
|---|
| | | /****************************** |
|---|
| | | * Record route header object inherent from header_address |
|---|
| | | * |
|---|
| | | * Record route header object inherit from header_address |
|---|
| | | ******************************/ |
|---|
| | | typedef struct _belle_sip_header_record_route belle_sip_header_record_route_t; |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_record_route_t* belle_sip_header_record_route_new(void); |
|---|
| | | BELLESIP_EXPORT belle_sip_header_record_route_t* belle_sip_header_record_route_parse (const char* route); |
|---|
| | | BELLESIP_EXPORT belle_sip_header_record_route_t* belle_sip_header_record_route_new_auto_outgoing(void); |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT unsigned char belle_sip_header_record_route_get_auto_outgoing(const belle_sip_header_record_route_t *a); |
|---|
| | | |
|---|
| | | |
|---|
| | | |
|---|
| | | #define BELLE_SIP_HEADER_RECORD_ROUTE(t) BELLE_SIP_CAST(t,belle_sip_header_record_route_t) |
|---|
| | | #define BELLE_SIP_RECORD_ROUTE "Record-route" |
|---|
| | | /****************************** |
|---|
| | | * Service route header object inherent from header_address |
|---|
| | | * |
|---|
| | | ******************************/ |
|---|
| | | |
|---|
| | | /****************************** |
|---|
| | | * Service route header object inherit from header_address |
|---|
| | | ******************************/ |
|---|
| | | typedef struct _belle_sip_header_service_route belle_sip_header_service_route_t; |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_service_route_t* belle_sip_header_service_route_new(void); |
|---|
| | |
|---|
| | | |
|---|
| | | #define BELLE_SIP_HEADER_SERVICE_ROUTE(t) BELLE_SIP_CAST(t,belle_sip_header_service_route_t) |
|---|
| | | #define BELLE_SIP_SERVICE_ROUTE "Service-route" |
|---|
| | | /****************************** |
|---|
| | | * |
|---|
| | | * user-Agent header inherit from header |
|---|
| | | * |
|---|
| | | ******************************/ |
|---|
| | | |
|---|
| | | /****************************** |
|---|
| | | * user-Agent header inherit from header |
|---|
| | | ******************************/ |
|---|
| | | typedef struct _belle_sip_header_user_agent belle_sip_header_user_agent_t; |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_user_agent_t* belle_sip_header_user_agent_new(void); |
|---|
| | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_user_agent_t* belle_sip_header_user_agent_parse (const char* user_agent) ; |
|---|
| | | BELLESIP_EXPORT belle_sip_list_t* belle_sip_header_user_agent_get_products(const belle_sip_header_user_agent_t* user_agent); |
|---|
| | | /** |
|---|
| | | * concatenates products |
|---|
| | | * @param user_agent [in] user agent header |
|---|
| | | * @param value [out]buffer where to put result in |
|---|
| | | * @param value_size [in] size of the buffer |
|---|
| | | * @return number of written characters or -1 inca se of error; |
|---|
| | | */ |
|---|
| | | * concatenates products |
|---|
| | | * @param user_agent [in] user agent header |
|---|
| | | * @param value [out]buffer where to put result in |
|---|
| | | * @param value_size [in] size of the buffer |
|---|
| | | * @return number of written characters or -1 inca se of error; |
|---|
| | | */ |
|---|
| | | BELLESIP_EXPORT int belle_sip_header_user_agent_get_products_as_string(const belle_sip_header_user_agent_t* user_agent,char* value,unsigned int value_size); |
|---|
| | | BELLESIP_EXPORT void belle_sip_header_user_agent_set_products(belle_sip_header_user_agent_t* user_agent,belle_sip_list_t* value); |
|---|
| | | BELLESIP_EXPORT void belle_sip_header_user_agent_add_product(belle_sip_header_user_agent_t* user_agent,const char* product); |
|---|
| | | #define BELLE_SIP_HEADER_USER_AGENT(t) BELLE_SIP_CAST(t,belle_sip_header_user_agent_t) |
|---|
| | | #define BELLE_SIP_USER_AGENT "User-Agent" |
|---|
| | | |
|---|
| | | /****************************** |
|---|
| | | * Content length inherent from object |
|---|
| | | * |
|---|
| | | /****************************** |
|---|
| | | * Content length inherit from object |
|---|
| | | ******************************/ |
|---|
| | | typedef struct _belle_sip_header_content_length belle_sip_header_content_length_t; |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_content_length_t* belle_sip_header_content_length_new(void); |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_content_length_t* belle_sip_header_content_length_parse (const char* content_length) ; |
|---|
| | | BELLESIP_EXPORT belle_sip_header_content_length_t* belle_sip_header_content_length_create (size_t content_length) ; |
|---|
| | | BELLESIP_EXPORT size_t belle_sip_header_content_length_get_content_length(const belle_sip_header_content_length_t* content_length); |
|---|
| | | BELLESIP_EXPORT void belle_sip_header_content_length_set_content_length(belle_sip_header_content_length_t* content_length,size_t length); |
|---|
| | | |
|---|
| | | #define BELLE_SIP_HEADER_CONTENT_LENGTH(t) BELLE_SIP_CAST(t,belle_sip_header_content_length_t) |
|---|
| | | #define BELLE_SIP_CONTENT_LENGTH "Content-Length" |
|---|
| | | |
|---|
| | | /****************************** |
|---|
| | | * authorization header inherit from parameters |
|---|
| | | * |
|---|
| | | ******************************/ |
|---|
| | | typedef struct _belle_sip_header_authorization belle_sip_header_authorization_t; |
|---|
| | | |
|---|
| | |
|---|
| | | |
|---|
| | | /******************************* |
|---|
| | | * proxy_authorization inherit from Authorization |
|---|
| | | */ |
|---|
| | | *******************************/ |
|---|
| | | typedef struct _belle_sip_header_proxy_authorization belle_sip_header_proxy_authorization_t; |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_proxy_authorization_t* belle_sip_header_proxy_authorization_new(void); |
|---|
| | | BELLESIP_EXPORT belle_sip_header_proxy_authorization_t* belle_sip_header_proxy_authorization_parse(const char* proxy_authorization); |
|---|
| | | |
|---|
| | | #define BELLE_SIP_HEADER_PROXY_AUTHORIZATION(t) BELLE_SIP_CAST(t,belle_sip_header_proxy_authorization_t) |
|---|
| | | #define BELLE_SIP_PROXY_AUTHORIZATION "Proxy-Authorization" |
|---|
| | | |
|---|
| | | /******************************* |
|---|
| | | * http_authorization inherit from Authorization |
|---|
| | | */ |
|---|
| | | *******************************/ |
|---|
| | | typedef struct _belle_http_header_authorization belle_http_header_authorization_t; |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_http_header_authorization_t* belle_http_header_authorization_new(void); |
|---|
| | | /*cannot be parsed for now |
|---|
| | | BELLESIP_EXPORT belle_http_header_authorization_t* belle_http_header_authorization_parse(const char* proxy_authorization); |
|---|
| | | */ |
|---|
| | | BELLESIP_EXPORT void belle_http_header_authorization_set_uri(belle_http_header_authorization_t* authorization, belle_generic_uri_t* uri); |
|---|
| | | BELLESIP_EXPORT belle_generic_uri_t* belle_http_header_authorization_get_uri(const belle_http_header_authorization_t* authorization); |
|---|
| | | |
|---|
| | | #define BELLE_HTTP_HEADER_AUTHORIZATION(t) BELLE_SIP_CAST(t,belle_http_header_authorization_t) |
|---|
| | | #define BELLE_HTTP_AUTHORIZATION "Authorization" |
|---|
| | | |
|---|
| | | |
|---|
| | | /******************************* |
|---|
| | | * www_authenticate inherit from parameters |
|---|
| | | */ |
|---|
| | | *******************************/ |
|---|
| | | typedef struct _belle_sip_header_www_authenticate belle_sip_header_www_authenticate_t; |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_www_authenticate_t* belle_sip_header_www_authenticate_new(void); |
|---|
| | | BELLESIP_EXPORT belle_sip_header_www_authenticate_t* belle_sip_header_www_authenticate_parse(const char* www_authenticate); |
|---|
| | | BELLESIP_EXPORT const char* belle_sip_header_www_authenticate_get_algorithm(const belle_sip_header_www_authenticate_t* www_authenticate ); |
|---|
| | |
|---|
| | | BELLESIP_EXPORT void belle_sip_header_www_authenticate_set_scheme(belle_sip_header_www_authenticate_t* www_authenticate, const char* scheme); |
|---|
| | | BELLESIP_EXPORT void belle_sip_header_www_authenticate_set_domain(belle_sip_header_www_authenticate_t* www_authenticate,const char* domain); |
|---|
| | | BELLESIP_EXPORT void belle_sip_header_www_authenticate_set_stale(belle_sip_header_www_authenticate_t* www_authenticate, unsigned int enable); |
|---|
| | | |
|---|
| | | #define BELLE_SIP_HEADER_WWW_AUTHENTICATE(t) BELLE_SIP_CAST(t,belle_sip_header_www_authenticate_t) |
|---|
| | | #define BELLE_SIP_WWW_AUTHENTICATE "WWW-Authenticate" |
|---|
| | | |
|---|
| | | /******************************* |
|---|
| | | * proxy_authenticate inherit from www_authenticate |
|---|
| | | */ |
|---|
| | | *******************************/ |
|---|
| | | typedef struct _belle_sip_header_proxy_authenticate belle_sip_header_proxy_authenticate_t; |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_proxy_authenticate_t* belle_sip_header_proxy_authenticate_new(void); |
|---|
| | | BELLESIP_EXPORT belle_sip_header_proxy_authenticate_t* belle_sip_header_proxy_authenticate_parse(const char* proxy_authenticate); |
|---|
| | | |
|---|
| | | #define BELLE_SIP_HEADER_PROXY_AUTHENTICATE(t) BELLE_SIP_CAST(t,belle_sip_header_proxy_authenticate_t) |
|---|
| | | #define BELLE_SIP_PROXY_AUTHENTICATE "Proxy-Authenticate" |
|---|
| | | |
|---|
| | | /****************************** |
|---|
| | | * |
|---|
| | | * Max forward inherit from header |
|---|
| | | * |
|---|
| | | ******************************/ |
|---|
| | | typedef struct _belle_sip_header_max_forwards belle_sip_header_max_forwards_t; |
|---|
| | | |
|---|
| | |
|---|
| | | #define BELLE_SIP_MAX_FORWARDS "Max-Forwards" |
|---|
| | | |
|---|
| | | /****************************** |
|---|
| | | * |
|---|
| | | * Subscription state inherit from parameters |
|---|
| | | * |
|---|
| | | ******************************/ |
|---|
| | | typedef struct _belle_sip_header_subscription_state belle_sip_header_subscription_state_t; |
|---|
| | | |
|---|
| | |
|---|
| | | BELLESIP_EXPORT void belle_sip_header_subscription_state_set_reason(belle_sip_header_subscription_state_t* subscription_state, const char* reason); |
|---|
| | | BELLESIP_EXPORT void belle_sip_header_subscription_state_set_retry_after(belle_sip_header_subscription_state_t* subscription_state, int retry_after ); |
|---|
| | | |
|---|
| | | |
|---|
| | | #define BELLE_SIP_HEADER_SUBSCRIPTION_STATE(t) BELLE_SIP_CAST(t,belle_sip_header_subscription_state_t) |
|---|
| | | #define BELLE_SIP_SUBSCRIPTION_STATE "Subscription-State" |
|---|
| | | #define BELLE_SIP_SUBSCRIPTION_STATE_ACTIVE "active" |
|---|
| | |
|---|
| | | |
|---|
| | | /****************************** |
|---|
| | | * Refer-To header object inherits from header_address |
|---|
| | | * |
|---|
| | | ******************************/ |
|---|
| | | typedef struct _belle_sip_header_refer_to belle_sip_header_refer_to_t; |
|---|
| | | BELLESIP_EXPORT belle_sip_header_refer_to_t* belle_sip_header_refer_to_new(void); |
|---|
| | |
|---|
| | | #define BELLE_SIP_REFER_TO "Refer-To" |
|---|
| | | |
|---|
| | | /****************************** |
|---|
| | | * Referred-by header object inherits from header_address |
|---|
| | | * |
|---|
| | | ******************************/ |
|---|
| | | * Referred-by header object inherits from header_address |
|---|
| | | ******************************/ |
|---|
| | | typedef struct _belle_sip_header_referred_by belle_sip_header_referred_by_t; |
|---|
| | | BELLESIP_EXPORT belle_sip_header_referred_by_t* belle_sip_header_referred_by_new(void); |
|---|
| | | BELLESIP_EXPORT belle_sip_header_referred_by_t* belle_sip_header_referred_by_parse(const char* referred_by) ; |
|---|
| | |
|---|
| | | #define BELLE_SIP_REFERRED_BY "Referred-By" |
|---|
| | | |
|---|
| | | /****************************** |
|---|
| | | * Replace header object inherits from parameters |
|---|
| | | * |
|---|
| | | ******************************/ |
|---|
| | | * Replace header object inherits from parameters |
|---|
| | | ******************************/ |
|---|
| | | typedef struct _belle_sip_header_replaces belle_sip_header_replaces_t; |
|---|
| | | BELLESIP_EXPORT belle_sip_header_replaces_t* belle_sip_header_replaces_new(void); |
|---|
| | | BELLESIP_EXPORT belle_sip_header_replaces_t* belle_sip_header_replaces_parse(const char* replaces) ; |
|---|
| | |
|---|
| | | #define BELLE_SIP_HEADER_REPLACES(t) BELLE_SIP_CAST(t,belle_sip_header_replaces_t) |
|---|
| | | #define BELLE_SIP_REPLACES "Replaces" |
|---|
| | | |
|---|
| | | /******* |
|---|
| | | /****************************** |
|---|
| | | * Date header |
|---|
| | | *******/ |
|---|
| | | |
|---|
| | | ******************************/ |
|---|
| | | typedef struct belle_sip_header_date belle_sip_header_date_t; |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_date_t* belle_sip_header_date_new(void); |
|---|
| | | BELLESIP_EXPORT belle_sip_header_date_t* belle_sip_header_date_parse(const char* date) ; |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_date_t* belle_sip_header_date_create_from_time(const time_t *utc_time); |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT time_t belle_sip_header_date_get_time(belle_sip_header_date_t *obj); |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT void belle_sip_header_date_set_time(belle_sip_header_date_t *obj, const time_t *utc_time); |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT const char * belle_sip_header_date_get_date(const belle_sip_header_date_t *obj); |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT void belle_sip_header_date_set_date(belle_sip_header_date_t *obj, const char *date); |
|---|
| | | |
|---|
| | | #define BELLE_SIP_HEADER_DATE(obj) BELLE_SIP_CAST(obj,belle_sip_header_date_t) |
|---|
| | | #define BELLE_SIP_DATE "Date" |
|---|
| | | |
|---|
| | | /****************************** |
|---|
| | | * P-Preferred-Identity header object inherent from header_address |
|---|
| | | * |
|---|
| | | * P-Preferred-Identity header object inherit from header_address |
|---|
| | | ******************************/ |
|---|
| | | typedef struct _belle_sip_header_p_preferred_identity belle_sip_header_p_preferred_identity_t; |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_p_preferred_identity_t* belle_sip_header_p_preferred_identity_new(void); |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_p_preferred_identity_t* belle_sip_header_p_preferred_identity_parse(const char* p_preferred_identity) ; |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_p_preferred_identity_t* belle_sip_header_p_preferred_identity_create(const belle_sip_header_address_t *address); |
|---|
| | | |
|---|
| | | #define BELLE_SIP_HEADER_P_PREFERRED_IDENTITY(t) BELLE_SIP_CAST(t,belle_sip_header_p_preferred_identity_t) |
|---|
| | | #define BELLE_SIP_P_PREFERRED_IDENTITY "P-Preferred-Identity" |
|---|
| | | |
|---|
| | | /****************************** |
|---|
| | | * Privacy header object inherent from header |
|---|
| | | * |
|---|
| | | * Privacy header object inherit from header |
|---|
| | | ******************************/ |
|---|
| | | typedef struct _belle_sip_header_privacy belle_sip_header_privacy_t; |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_privacy_t* belle_sip_header_privacy_new(void); |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_privacy_t* belle_sip_header_privacy_parse(const char* privacy) ; |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_privacy_t* belle_sip_header_privacy_create(const char* privacy); |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT void belle_sip_header_privacy_add_privacy(belle_sip_header_privacy_t* privacy, const char* value); |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT void belle_sip_header_privacy_set_privacy(belle_sip_header_privacy_t* privacy, belle_sip_list_t* privacy_values); |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_list_t* belle_sip_header_privacy_get_privacy(const belle_sip_header_privacy_t* privacy); |
|---|
| | | |
|---|
| | | |
|---|
| | | #define BELLE_SIP_HEADER_PRIVACY(t) BELLE_SIP_CAST(t,belle_sip_header_privacy_t) |
|---|
| | | #define BELLE_SIP_PRIVACY "Privacy" |
|---|
| | | |
|---|
| | | |
|---|
| | | /****************************** |
|---|
| | | * Event header object inherent from parameters |
|---|
| | | * |
|---|
| | | * Event header object inherit from parameters |
|---|
| | | ******************************/ |
|---|
| | | typedef struct _belle_sip_header_event belle_sip_header_event_t; |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_event_t* belle_sip_header_event_new(void); |
|---|
| | | BELLESIP_EXPORT belle_sip_header_event_t* belle_sip_header_event_parse(const char* event) ; |
|---|
| | | BELLESIP_EXPORT belle_sip_header_event_t* belle_sip_header_event_create(const char* event); |
|---|
| | | BELLESIP_EXPORT const char* belle_sip_header_event_get_package_name(const belle_sip_header_event_t* event); |
|---|
| | | BELLESIP_EXPORT void belle_sip_header_event_set_package_name(belle_sip_header_event_t* event, const char* package_name); |
|---|
| | | BELLESIP_EXPORT const char* belle_sip_header_event_get_id(const belle_sip_header_event_t* event); |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT void belle_sip_header_event_set_id(belle_sip_header_event_t* event, const char* id); |
|---|
| | | #define BELLE_SIP_HEADER_EVENT(t) BELLE_SIP_CAST(t,belle_sip_header_event_t) |
|---|
| | | #define BELLE_SIP_EVENT "Event" |
|---|
| | | |
|---|
| | | |
|---|
| | | /****************************** |
|---|
| | | * Supported header object inherent from header |
|---|
| | | * |
|---|
| | | * Supported header object inherit from header |
|---|
| | | ******************************/ |
|---|
| | | typedef struct _belle_sip_header_supported belle_sip_header_supported_t; |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_supported_t* belle_sip_header_supported_new(void); |
|---|
| | | BELLESIP_EXPORT belle_sip_header_supported_t* belle_sip_header_supported_parse(const char* supported) ; |
|---|
| | | BELLESIP_EXPORT belle_sip_header_supported_t* belle_sip_header_supported_create(const char* supported); |
|---|
| | | BELLESIP_EXPORT void belle_sip_header_supported_add_supported(belle_sip_header_supported_t* supported, const char* value); |
|---|
| | | BELLESIP_EXPORT void belle_sip_header_supported_set_supported(belle_sip_header_supported_t* supported, belle_sip_list_t* supported_values); |
|---|
| | | BELLESIP_EXPORT belle_sip_list_t* belle_sip_header_supported_get_supported(const belle_sip_header_supported_t* supported); |
|---|
| | | |
|---|
| | | #define BELLE_SIP_HEADER_SUPPORTED(t) BELLE_SIP_CAST(t,belle_sip_header_supported_t) |
|---|
| | | #define BELLE_SIP_SUPPORTED "Supported" |
|---|
| | | |
|---|
| | | /****************************** |
|---|
| | | * Require header object inherent from header |
|---|
| | | * |
|---|
| | | ******************************/ |
|---|
| | | * Require header object inherit from header |
|---|
| | | ******************************/ |
|---|
| | | typedef struct _belle_sip_header_require belle_sip_header_require_t; |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_require_t* belle_sip_header_require_new(void); |
|---|
| | | BELLESIP_EXPORT belle_sip_header_require_t* belle_sip_header_require_parse(const char* require) ; |
|---|
| | | BELLESIP_EXPORT belle_sip_header_require_t* belle_sip_header_require_create(const char* require); |
|---|
| | | BELLESIP_EXPORT void belle_sip_header_require_add_require(belle_sip_header_require_t* require, const char* value); |
|---|
| | | BELLESIP_EXPORT void belle_sip_header_require_set_require(belle_sip_header_require_t* require, belle_sip_list_t* require_values); |
|---|
| | | BELLESIP_EXPORT belle_sip_list_t* belle_sip_header_require_get_require(const belle_sip_header_require_t* require); |
|---|
| | | |
|---|
| | | #define BELLE_SIP_HEADER_REQUIRE(t) BELLE_SIP_CAST(t,belle_sip_header_require_t) |
|---|
| | | #define BELLE_SIP_REQUIRE "Require" |
|---|
| | | |
|---|
| | | /****************************** |
|---|
| | | * Content Disposition header object inherent from header |
|---|
| | | * |
|---|
| | | * Content Disposition header object inherit from header |
|---|
| | | ******************************/ |
|---|
| | | typedef struct _belle_sip_header_content_disposition belle_sip_header_content_disposition_t; |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_content_disposition_t* belle_sip_header_content_disposition_new(void); |
|---|
| | | BELLESIP_EXPORT belle_sip_header_content_disposition_t* belle_sip_header_content_disposition_parse (const char* content_disposition) ; |
|---|
| | | BELLESIP_EXPORT belle_sip_header_content_disposition_t* belle_sip_header_content_disposition_create (const char* content_disposition); |
|---|
| | | BELLESIP_EXPORT const char* belle_sip_header_content_disposition_get_content_disposition(const belle_sip_header_content_disposition_t* content_disposition); |
|---|
| | | BELLESIP_EXPORT void belle_sip_header_content_disposition_set_content_disposition(belle_sip_header_content_disposition_t* obj,const char* content_disposition); |
|---|
| | | |
|---|
| | | #define BELLE_SIP_HEADER_CONTENT_DISPOSITION(t) BELLE_SIP_CAST(t,belle_sip_header_content_disposition_t) |
|---|
| | | #define BELLE_SIP_CONTENT_DISPOSITION "Content-Disposition" |
|---|
| | | |
|---|
| | | /****************************** |
|---|
| | | * Accept header object inherent from parameters |
|---|
| | | * |
|---|
| | | * Accept header object inherit from parameters |
|---|
| | | ******************************/ |
|---|
| | | typedef struct _belle_sip_header_accept belle_sip_header_accept_t; |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_accept_t* belle_sip_header_accept_new(void); |
|---|
| | | BELLESIP_EXPORT belle_sip_header_accept_t* belle_sip_header_accept_parse (const char* accept) ; |
|---|
| | | BELLESIP_EXPORT belle_sip_header_accept_t* belle_sip_header_accept_create (const char* type,const char* sub_type) ; |
|---|
| | |
|---|
| | | BELLESIP_EXPORT const char* belle_sip_header_accept_get_subtype(const belle_sip_header_accept_t* accept); |
|---|
| | | BELLESIP_EXPORT void belle_sip_header_accept_set_subtype(belle_sip_header_accept_t* accept,const char* sub_type); |
|---|
| | | #define BELLE_SIP_HEADER_ACCEPT(t) BELLE_SIP_CAST(t,belle_sip_header_accept_t) |
|---|
| | | |
|---|
| | | #define BELLE_SIP_ACCEPT "Accept" |
|---|
| | | |
|---|
| | | /****************************** |
|---|
| | | * Reason header object inherent from parameters |
|---|
| | | * |
|---|
| | | * Reason header object inherit from parameters |
|---|
| | | ******************************/ |
|---|
| | | typedef struct _belle_sip_header_reason belle_sip_header_reason_t; |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_reason_t* belle_sip_header_reason_new(void); |
|---|
| | | BELLESIP_EXPORT belle_sip_header_reason_t* belle_sip_header_reason_parse (const char* reason) ; |
|---|
| | | BELLESIP_EXPORT const char* belle_sip_header_reason_get_protocol(const belle_sip_header_reason_t* reason); |
|---|
| | |
|---|
| | | #define BELLE_SIP_HEADER_REASON(t) BELLE_SIP_CAST(t,belle_sip_header_reason_t) |
|---|
| | | #define BELLE_SIP_REASON "Reason" |
|---|
| | | |
|---|
| | | |
|---|
| | | /****************************** |
|---|
| | | * Authentication-Info header inherit from header |
|---|
| | | * |
|---|
| | | ******************************/ |
|---|
| | | typedef struct _belle_sip_header_authentication_info belle_sip_header_authentication_info_t; |
|---|
| | | |
|---|
| | |
|---|
| | | BELLESIP_EXPORT void belle_sip_header_authentication_info_set_nonce_count(belle_sip_header_authentication_info_t* authentication_info, int nonceCount); |
|---|
| | | BELLESIP_EXPORT int belle_sip_header_authentication_info_get_nonce_count(const belle_sip_header_authentication_info_t* authentication_info); |
|---|
| | | |
|---|
| | | |
|---|
| | | #define BELLE_SIP_HEADER_AUTHENTICATION_INFO(t) BELLE_SIP_CAST(t,belle_sip_header_authentication_info_t) |
|---|
| | | #define BELLE_SIP_AUTHENTICATION_INFO "Authentication-Info" |
|---|
| | | |
|---|
| | | BELLE_SIP_END_DECLS |
|---|
| | | |
|---|
| | | |
|---|
| | | #endif /* HEADERS_H_ */ |
|---|
| | |
|---|
| | | **/ |
|---|
| | | BELLESIP_EXPORT void belle_sip_listening_point_clean_channels(belle_sip_listening_point_t *lp); |
|---|
| | | |
|---|
| | | /* |
|---|
| | | * Clean unreliable channels. |
|---|
| | | * See belle_sip_provider_clean_unreliable_channels() for a detailed explanation. |
|---|
| | | */ |
|---|
| | | BELLESIP_EXPORT void belle_sip_listening_point_clean_unreliable_channels(belle_sip_listening_point_t *lp); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the number of channels managed by this listening point. |
|---|
| | | **/ |
|---|
| | |
|---|
| | | #ifndef BELLE_SIP_MAINLOOP_H |
|---|
| | | #define BELLE_SIP_MAINLOOP_H |
|---|
| | | |
|---|
| | | #include "defs.h" |
|---|
| | | #include "utils.h" |
|---|
| | | #include "types.h" |
|---|
| | | |
|---|
| | | #define BELLE_SIP_EVENT_READ 1 |
|---|
| | | #define BELLE_SIP_EVENT_WRITE (1<<1) |
|---|
| | | #define BELLE_SIP_EVENT_ERROR (1<<2) |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Schedule an arbitrary task at next main loop iteration. |
|---|
| | | * @note thread-safe |
|---|
| | | **/ |
|---|
| | | BELLESIP_EXPORT void belle_sip_main_loop_do_later(belle_sip_main_loop_t *ml, belle_sip_callback_t func, void *data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Same as #belle_sip_main_loop_do_later() but allow to give a name to the task. |
|---|
| | | * @param[in] timer_name The name of the task. If NULL, the task will be named as though |
|---|
| | | * #belle_sip_main_loop_do_later() was called. |
|---|
| | | * @note thread-safe |
|---|
| | | **/ |
|---|
| | | BELLESIP_EXPORT void belle_sip_main_loop_do_later_with_name( |
|---|
| | | belle_sip_main_loop_t *ml, |
|---|
| | | belle_sip_callback_t func, |
|---|
| | | void *data, |
|---|
| | | const char *timer_name |
|---|
| | | ); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates a timeout source, similarly to belle_sip_main_loop_add_timeout(). |
|---|
| | |
|---|
| | | **/ |
|---|
| | | BELLESIP_EXPORT belle_sip_source_t * belle_sip_timeout_source_new(belle_sip_source_func_t func, void *data, unsigned int timeout_value_ms); |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT void belle_sip_source_set_timeout(belle_sip_source_t *s, unsigned int value_ms); |
|---|
| | | /** |
|---|
| | | * Set the timeout duration. |
|---|
| | | * @param[in] s The source to modify. |
|---|
| | | * @param[in] value_ms The new timeout duration in milliseconds. Only values in [0;INT_MAX] are valid to define a new |
|---|
| | | * duration. Higher values will cause the timer to be disabled. |
|---|
| | | * @deprecated Since 2020-05-20 (SDK 4.4). Use belle_sip_source_set_timeout_int64() instead. |
|---|
| | | */ |
|---|
| | | BELLESIP_DEPRECATED BELLESIP_EXPORT void belle_sip_source_set_timeout(belle_sip_source_t *s, unsigned int value_ms); |
|---|
| | | /** |
|---|
| | | * Set the timeout duration. |
|---|
| | | * @param[in] s The source to modify. |
|---|
| | | * @param[in] value_ms Positive values willbe taken as the new duration to set. Negative values will cause the timer |
|---|
| | | * to be disabled. |
|---|
| | | */ |
|---|
| | | BELLESIP_EXPORT void belle_sip_source_set_timeout_int64(belle_sip_source_t *s, int64_t value_ms); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Cancel a source. Will be removed at next iterate. It is not freed. |
|---|
| | | **/ |
|---|
| | | BELLESIP_EXPORT void belle_sip_source_cancel(belle_sip_source_t * src); |
|---|
| | | |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT unsigned int belle_sip_source_get_timeout(const belle_sip_source_t *s); |
|---|
| | | BELLESIP_DEPRECATED BELLESIP_EXPORT unsigned int belle_sip_source_get_timeout(const belle_sip_source_t *s); |
|---|
| | | BELLESIP_EXPORT int64_t belle_sip_source_get_timeout_int64(const belle_sip_source_t *s); |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_source_t * belle_sip_socket_source_new(belle_sip_source_func_t func, void *data, belle_sip_socket_t fd, unsigned int events, unsigned int timeout_value_ms); |
|---|
| | | /* |
|---|
| | |
|---|
| | | BELLESIP_EXPORT void belle_sip_main_loop_cancel_source(belle_sip_main_loop_t *ml, unsigned long id); |
|---|
| | | |
|---|
| | | BELLE_SIP_END_DECLS |
|---|
| | | #ifndef BELLE_SIP_USE_STL |
|---|
| | | #define BELLE_SIP_USE_STL 1 |
|---|
| | | #endif |
|---|
| | | |
|---|
| | | #if ((defined(WIN32) && defined(__cplusplus)) || __cplusplus >= 201103L) && BELLE_SIP_USE_STL |
|---|
| | | #if (defined(WIN32) && defined(__cplusplus)) || __cplusplus >= 201103L |
|---|
| | | /*Only Visual Studio 2018 properly defines __cplusplus according to c++ level. */ |
|---|
| | | |
|---|
| | | #include <functional> |
|---|
| | | #include <memory> |
|---|
| | | |
|---|
| | | typedef std::function<int (unsigned int)> belle_sip_source_cpp_func_t; |
|---|
| | | /** |
|---|
| | | * A generic deleter for belle_sip_object_t objects that limits itself to decrementing the |
|---|
| | | * reference counter. This class is to be used by std::unique_ptr and std::shared_ptr maybe. |
|---|
| | | */ |
|---|
| | | template <typename T> |
|---|
| | | struct BelleSipObjectDeleter { |
|---|
| | | constexpr BelleSipObjectDeleter() noexcept = default; |
|---|
| | | void operator()(T *ptr) const noexcept {belle_sip_object_unref(ptr);} |
|---|
| | | }; |
|---|
| | | |
|---|
| | | using BelleSipSourcePtr = std::unique_ptr<belle_sip_source_t, BelleSipObjectDeleter<belle_sip_source_t>>; |
|---|
| | | using belle_sip_source_cpp_func_t = std::function<int(unsigned int)>; |
|---|
| | | using BelleSipDoLaterFunc = std::function<void()>; |
|---|
| | | |
|---|
| | | /*purpose of this function is to simplify c++ timer integration. |
|---|
| | | /** |
|---|
| | | * The purpose of this function is to simplify c++ timer integration. |
|---|
| | | * ex: |
|---|
| | | * std::string helloworld("Hello world): |
|---|
| | | * belle_sip_source_cpp_func_t *func = new belle_sip_source_cpp_func_t([helloworld](unsigned int events) { |
|---|
| | | * std::cout << helloworld << std::endl; |
|---|
| | | * return BELLE_SIP_STOP; |
|---|
| | | * }); |
|---|
| | | *create timer |
|---|
| | | *mTimer = belle_sip_main_loop_create_cpp_timeout( mainloop |
|---|
| | | * // create timer |
|---|
| | | * belle_sip_source_t *timer = belle_sip_main_loop_create_cpp_timeout( mainloop |
|---|
| | | * , func |
|---|
| | | * , 1000 |
|---|
| | | * ,"timer for c++"); |
|---|
| | | * [...] |
|---|
| | | * // Unref the timer when you doesn't need it anymore |
|---|
| | | * belle_sip_object_unref(timer); |
|---|
| | | * |
|---|
| | | * @warning Not thread-sfae |
|---|
| | | * @deprecated Since 2020-04-17. |
|---|
| | | */ |
|---|
| | | BELLESIP_DEPRECATED BELLESIP_EXPORT belle_sip_source_t *belle_sip_main_loop_create_cpp_timeout(belle_sip_main_loop_t *ml |
|---|
| | | , belle_sip_source_cpp_func_t *func |
|---|
| | | , unsigned int timeout_value_ms |
|---|
| | | , const char* timer_name); |
|---|
| | | |
|---|
| | | /* |
|---|
| | | * This variant does the same except that: |
|---|
| | | * - it does not require to pass the std::function as a pointer allocated with new() |
|---|
| | | * - the std::function shall return true/false instead of BELLE_SIP_CONTINUE/BELLE_SIP_STOP. |
|---|
| | | */ |
|---|
| | | BELLESIP_EXPORT belle_sip_source_t * belle_sip_main_loop_create_cpp_timeout_2(belle_sip_main_loop_t *ml, |
|---|
| | | const std::function<bool ()> &func, |
|---|
| | | unsigned int timeout_value_ms, |
|---|
| | | const std::string &timer_name); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * The purpose of this function is to simplify c++ timer integration. |
|---|
| | | * Unlike the deprecated overload of this function, there is no need to |
|---|
| | | * allocate anything with new and to unref the timer. |
|---|
| | | * |
|---|
| | | * ex: |
|---|
| | | * std::string helloworld{"Hello world}; |
|---|
| | | * auto func = [helloworld](unsigned int events) { |
|---|
| | | * std::cout << helloworld << std::endl; |
|---|
| | | * return BELLE_SIP_STOP; |
|---|
| | | * }); |
|---|
| | | * |
|---|
| | | * // create the timer |
|---|
| | | * auto timer = belle_sip_main_loop_create_cpp_timeout( mainloop |
|---|
| | | * , func |
|---|
| | | * , 1000 |
|---|
| | | * ,"timer for c++"); |
|---|
| | | * |
|---|
| | | */ |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_source_t * belle_sip_main_loop_create_cpp_timeout(belle_sip_main_loop_t *ml |
|---|
| | | , belle_sip_source_cpp_func_t *func |
|---|
| | | BELLESIP_EXPORT BelleSipSourcePtr belle_sip_main_loop_create_cpp_timeout(belle_sip_main_loop_t *ml |
|---|
| | | , const belle_sip_source_cpp_func_t &func |
|---|
| | | , unsigned int timeout_value_ms |
|---|
| | | , const char* timer_name); |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT void belle_sip_main_loop_cpp_do_later(belle_sip_main_loop_t *ml, const std::function<void (void)> &func); |
|---|
| | | /** |
|---|
| | | * C++ wrapper for #belle_sip_main_loop_do_later(). |
|---|
| | | * @note thread-safe |
|---|
| | | */ |
|---|
| | | BELLESIP_EXPORT void belle_sip_main_loop_cpp_do_later(belle_sip_main_loop_t *ml, const BelleSipDoLaterFunc &func); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Overload of the previous function that allow to give a name to the task. |
|---|
| | | * @note thread-safe |
|---|
| | | */ |
|---|
| | | BELLESIP_EXPORT void belle_sip_main_loop_cpp_do_later( |
|---|
| | | belle_sip_main_loop_t *ml, |
|---|
| | | const BelleSipDoLaterFunc &func, |
|---|
| | | const char *task_name |
|---|
| | | ); |
|---|
| | | |
|---|
| | | |
|---|
| | | #endif |
|---|
| | | #endif // C++ declarations |
|---|
| | | |
|---|
| | | #endif |
|---|
| | | #endif // #ifndef BELLE_SIP_MAINLOOP_H |
|---|
| | |
|---|
| | | BELLESIP_EXPORT belle_sip_message_t* belle_sip_message_parse_raw (const char* buff, size_t buff_length,size_t* message_length ); |
|---|
| | | |
|---|
| | | |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT int belle_sip_message_is_request(belle_sip_message_t *msg); |
|---|
| | | BELLESIP_EXPORT belle_sip_request_t* belle_sip_request_new(void); |
|---|
| | | BELLESIP_EXPORT belle_sip_request_t* belle_sip_request_parse(const char* raw); |
|---|
| | |
|---|
| | | belle_sip_header_to_t *to, |
|---|
| | | belle_sip_header_via_t *via, |
|---|
| | | int max_forwards); |
|---|
| | | |
|---|
| | | |
|---|
| | | |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_uri_t* belle_sip_request_get_uri(const belle_sip_request_t* request); |
|---|
| | |
|---|
| | | */ |
|---|
| | | BELLESIP_EXPORT void belle_sip_request_set_absolute_uri(belle_sip_request_t* req, belle_generic_uri_t* uri); |
|---|
| | | |
|---|
| | | |
|---|
| | | |
|---|
| | | |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT int belle_sip_message_is_response(const belle_sip_message_t *msg); |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_header_t *belle_sip_message_get_header(const belle_sip_message_t *msg, const char *header_name); |
|---|
| | | BELLESIP_EXPORT int belle_sip_header_supported_contains_tag(const belle_sip_header_supported_t* supported, const char* tag); |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_object_t *_belle_sip_message_get_header_by_type_id(const belle_sip_message_t *message, belle_sip_type_id_t id); |
|---|
| | | |
|---|
| | |
|---|
| | | |
|---|
| | | class ObjectCAccessors; |
|---|
| | | |
|---|
| | | class BELLESIP_EXPORT Object { |
|---|
| | | class BELLESIP_EXPORT Object{ |
|---|
| | | friend ObjectCAccessors; |
|---|
| | | public: |
|---|
| | | Object(); |
|---|
| | |
|---|
| | | const Object *ref() const; |
|---|
| | | void unref(); |
|---|
| | | //Overrides should keep the size of toString() lower than BELLE_SIP_MAX_TO_STRING_SIZE |
|---|
| | | virtual std::string toString() const; |
|---|
| | | virtual std::string toString() const; |
|---|
| | | virtual Object *clone()const; |
|---|
| | | belle_sip_cpp_object_t *getCObject(); |
|---|
| | | const belle_sip_cpp_object_t *getCObject()const; |
|---|
| | |
|---|
| | | * } |
|---|
| | | * The C object can be obtained with toC() method, directly casted in the expected type. |
|---|
| | | * The C++ object can be obtained from C object with static method toCpp(). |
|---|
| | | * The destructor MUST be kept protected so that no one can call delete operator on the object. Instead unref() must be used. |
|---|
| | | * make_shared<>() MUST NOT be used to instanciate an HybridObject, use create() instead. |
|---|
| | | * a shared_ptr<> can be obtained at any time from an HybridObject using getSharedFromThis(). |
|---|
| | | * |
|---|
| | | * VERY IMPORTANT USAGE RULES: |
|---|
| | | * - The destructor MUST be kept protected so that no one can call delete operator on the object. Instead unref() must be used. |
|---|
| | | * - make_shared<>() or shared_ptr<>(new ...) MUST NOT be used to instanciate an HybridObject, use create() instead. |
|---|
| | | * |
|---|
| | | * A shared_ptr<> can be obtained at any time from an HybridObject using getSharedFromThis(). |
|---|
| | | * The static getSharedFromThis(_Ctype*) method can be used to directly obtain a shared_ptr from the C object. |
|---|
| | | * |
|---|
| | | * |
|---|
| | | * The clone() method must be overriden to return a new _CppType contructed with copy contructor, |
|---|
| | | * or return nullptr if the object is defined to be not clonable. |
|---|
| | | * |
|---|
| | | * Rational for using this template: |
|---|
| | | * - You have an existing library in C where all C objects are inheriting from belle_sip_object_t (for refcounting, data_set etc...). |
|---|
| | | * - You want to use C++ in your library without making any disruption in the API. |
|---|
| | | * IMPORTANT: |
|---|
| | | * If you don't care about belle_sip_object_t inheritance in your C api, |
|---|
| | | * IMPORTANT: |
|---|
| | | * If you don't care about belle_sip_object_t inheritance in your C api, |
|---|
| | | * or if you don't need any C api associated to this object at all, DON'T USE THIS. |
|---|
| | | * An usage example is shown in tester/object_tester.cc . |
|---|
| | | **/ |
|---|
| | | template <typename _CType, typename _CppType> |
|---|
| | | class HybridObject : public Object { |
|---|
| | | public: |
|---|
| | | //Create the C++ object returned as a shared_ptr. Ref is managed by shared_ptr, unref will be called on last ref. |
|---|
| | | //Create the C++ object returned as a shared_ptr. Reference counting is managed by shared_ptr automatically. |
|---|
| | | template <typename... _Args> |
|---|
| | | static inline std::shared_ptr<_CppType> create(_Args&&... __args) { |
|---|
| | | return (new _CppType(std::forward<_Args>(__args)...))->toSharedPtr(); |
|---|
| | | } |
|---|
| | | //Convenience creator to get the C object object instead. Automatically aquires a ref. Consumers have the responsibility to unref |
|---|
| | | //Convenience creator to get the C object object instead. Automatically acquires a ref. Consumers have the responsibility to unref |
|---|
| | | template <typename... _Args> |
|---|
| | | static inline _CType *createCObject(_Args&&... __args) { |
|---|
| | | _CppType *obj = new _CppType(std::forward<_Args>(__args)...); |
|---|
| | | return obj->toC(); |
|---|
| | | return (new _CppType(std::forward<_Args>(__args)...))->toC(); |
|---|
| | | } |
|---|
| | | //Obtain the C object from this. |
|---|
| | | _CType *toC(){ |
|---|
| | |
|---|
| | | } |
|---|
| | | //Obtain a shared_ptr from the C++ object. |
|---|
| | | std::shared_ptr<_CppType> getSharedFromThis() { |
|---|
| | | this->ref(); |
|---|
| | | return std::shared_ptr<_CppType>(static_cast<_CppType *>(this), std::mem_fun(&Object::unref)); |
|---|
| | | return sharedFromThis(false); |
|---|
| | | } |
|---|
| | | //Obtain a shared_ptr from the C++ object in the const case. |
|---|
| | | std::shared_ptr<const _CppType> getSharedFromThis () const { |
|---|
| | | this->ref(); |
|---|
| | | return std::shared_ptr<const _CppType>(static_cast<const _CppType *>(this), std::mem_fun(&HybridObject<_CType,_CppType>::constUnref)); |
|---|
| | | return sharedFromThis(false); |
|---|
| | | } |
|---|
| | | //Convenience method for easy CType -> shared_ptr<CppType> conversion |
|---|
| | | static std::shared_ptr<_CppType> getSharedFromThis(_CType *ptr) { |
|---|
| | |
|---|
| | | // Use this method with caution as it will transfer the ownership of the object to the shared_ptr, unlike getSharedFromThis() that |
|---|
| | | // gives you a new reference to the object. |
|---|
| | | // This method should be only useful to transfer into a shared_ptr an object that was created as a normal pointer, for example |
|---|
| | | // by clone() method. |
|---|
| | | // There should be NO const variant of this method. |
|---|
| | | // by clone() or createCObject() methods. |
|---|
| | | // There should be NO public const variant of this method. |
|---|
| | | std::shared_ptr<_CppType> toSharedPtr(){ |
|---|
| | | return std::shared_ptr<_CppType>(static_cast<_CppType *>(this), std::mem_fun(&Object::unref)); |
|---|
| | | return sharedFromThis(true); |
|---|
| | | } |
|---|
| | | |
|---|
| | | |
|---|
| | | //Convenience method for easy bctbx_list(_Ctype) -> std::list<_CppType> conversion |
|---|
| | | static std::list<_CppType> getCppListFromCList(const bctbx_list_t *cList) { |
|---|
| | | std::list<_CppType> result; |
|---|
| | | for (auto it = cList; it; it = bctbx_list_next(it)) |
|---|
| | | result.push_back(toCpp(static_cast<_CType>(bctbx_list_get_data(it)))); |
|---|
| | | //It does not take ownership of the hybrid object, but takes a ref. |
|---|
| | | static std::list<std::shared_ptr<_CppType>> getCppListFromCList(const bctbx_list_t *cList) { |
|---|
| | | std::list<std::shared_ptr<_CppType>> result; |
|---|
| | | for (auto it = cList; it != nullptr; it = bctbx_list_next(it)) |
|---|
| | | result.push_back(toCpp(static_cast<_CType*>(bctbx_list_get_data(it)))->getSharedFromThis() ); |
|---|
| | | return result; |
|---|
| | | } |
|---|
| | | //Convenience method for easy bctbx_list(_Ctype) -> std::list<_CppType> conversion |
|---|
| | | //Applies 'func' to get _CppType from _CType. Used in case we do not want to call `toCpp` on _Ctype |
|---|
| | | static std::list<_CppType> getCppListFromCList(const bctbx_list_t *cList, const std::function<_CppType (_CType)> &func) { |
|---|
| | | std::list<_CppType> result; |
|---|
| | | for (auto it = cList; it; it = bctbx_list_next(it)) |
|---|
| | | result.push_back(func(static_cast<_CType>(bctbx_list_get_data(it)))); |
|---|
| | | static std::list<std::shared_ptr<_CppType>> getCppListFromCList(const bctbx_list_t *cList, const std::function<std::shared_ptr<_CppType> (_CType *)> &func) { |
|---|
| | | std::list<std::shared_ptr<_CppType>> result; |
|---|
| | | for (auto it = cList; it != nullptr; it = bctbx_list_next(it)) |
|---|
| | | result.push_back(func(static_cast<_CType*>(bctbx_list_get_data(it)))); |
|---|
| | | return result; |
|---|
| | | } |
|---|
| | | //Convenience method for easy std::list<shared_ptr<CppType>> -> bctbx_list(CType) conversion |
|---|
| | | //It does not take ownership of the hybrid object, but takes a ref. |
|---|
| | | static bctbx_list_t* getCListFromCppList(const std::list<std::shared_ptr<_CppType> > &cppList) { |
|---|
| | | bctbx_list_t *result = nullptr; |
|---|
| | | for (auto it = cppList.begin(); it != cppList.end(); it++) { |
|---|
| | |
|---|
| | | } |
|---|
| | | return result; |
|---|
| | | } |
|---|
| | | //Convenience method for easy std::list<CppType*> -> bctbx_list(CType) conversion |
|---|
| | | //It does not take ownership of the hybrid object, but takes a ref. |
|---|
| | | static bctbx_list_t* getCListFromCppList(const std::list<_CppType*> &cppList) { |
|---|
| | | bctbx_list_t *result = nullptr; |
|---|
| | | for (auto it = cppList.begin(); it != cppList.end(); it++) { |
|---|
| | | _CppType *cppPtr = static_cast<_CppType*>(*it); |
|---|
| | | cppPtr->ref(); |
|---|
| | | _CType *cptr = cppPtr->toC(); |
|---|
| | | result = bctbx_list_append(result, cptr); |
|---|
| | | } |
|---|
| | | return result; |
|---|
| | | } |
|---|
| | | |
|---|
| | | static const char * nullifyEmptyString(const std::string& cppString){ |
|---|
| | | if (cppString.empty()) return nullptr; |
|---|
| | | else return cppString.c_str(); |
|---|
| | | } |
|---|
| | | |
|---|
| | | protected: |
|---|
| | | virtual ~HybridObject() {} |
|---|
| | | virtual ~HybridObject() = default; |
|---|
| | | HybridObject() {} |
|---|
| | | HybridObject(const HybridObject<_CType, _CppType> &other) : Object(other) {} |
|---|
| | | private: |
|---|
| | | std::shared_ptr<_CppType> sharedFromThis(bool withTransfer)const{ |
|---|
| | | std::shared_ptr<_CppType> sp; |
|---|
| | | if ((sp = mSelf.lock()) == nullptr){ |
|---|
| | | sp = std::shared_ptr<_CppType>(static_cast<_CppType *>(const_cast<HybridObject<_CType, _CppType> *>(this)), |
|---|
| | | std::mem_fn(&HybridObject<_CType, _CppType>::constUnref)); |
|---|
| | | mSelf = sp; |
|---|
| | | if (!withTransfer){ |
|---|
| | | sp->ref(); |
|---|
| | | } |
|---|
| | | }else{ |
|---|
| | | if (withTransfer){ |
|---|
| | | belle_sip_fatal("This HybridObject already has shared_ptr<> instances pointing to it."); |
|---|
| | | } |
|---|
| | | } |
|---|
| | | return sp; |
|---|
| | | } |
|---|
| | | mutable std::weak_ptr<_CppType> mSelf; |
|---|
| | | }; |
|---|
| | | |
|---|
| | | |
|---|
| | | }//end of namespace |
|---|
| | | |
|---|
| | |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT void belle_sip_provider_clean_channels(belle_sip_provider_t *p); |
|---|
| | | |
|---|
| | | /* Close connections for which no data was received at all during last X seconds period of time. |
|---|
| | | * This is useful because some routers don't send ICMP or TCP connection reset when they reallocate a port. |
|---|
| | | * For the client, the connection is presumed to be alive, but in practice it is not and there will never be any error. |
|---|
| | | * As a workaround, simply close these connections, and let the stack re-establish new ones, while refreshing registration for example. |
|---|
| | | * The time period after which a channel is considered as "unreliable" is configured with |
|---|
| | | * belle_sip_stack_set_unreliable_connection_timeout(belle_sip_stack_t *stack); |
|---|
| | | */ |
|---|
| | | BELLESIP_EXPORT void belle_sip_provider_clean_unreliable_channels(belle_sip_provider_t *p); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Add auth info to the request if found |
|---|
| | | * @param p object |
|---|
| | |
|---|
| | | |
|---|
| | | BELLE_SIP_BEGIN_DECLS |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * This only affects the resolution of SIP URI in absence of port number, and in absence of SRV record for the SIP domain. The well known ports (udp/tcp and tls/dtls) are static. |
|---|
| | | * @param well known port value |
|---|
| | | **/ |
|---|
| | | BELLESIP_EXPORT void belle_sip_stack_set_well_known_port (int value); |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT void belle_sip_stack_set_well_known_port_tls (int value); |
|---|
| | | |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT int belle_sip_stack_get_well_known_port (void); |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT int belle_sip_stack_get_well_known_port_tls (void); |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_stack_t * belle_sip_stack_new(const char *properties); |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_listening_point_t *belle_sip_stack_create_listening_point(belle_sip_stack_t *s, const char *ipaddress, int port, const char *transport); |
|---|
| | |
|---|
| | | BELLESIP_EXPORT belle_sip_provider_t *belle_sip_stack_create_provider(belle_sip_stack_t *s, belle_sip_listening_point_t *lp); |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_http_provider_t * belle_sip_stack_create_http_provider(belle_sip_stack_t *s, const char *bind_ip); |
|---|
| | | |
|---|
| | | #define BELLE_SIP_HTTP_TRANSPORT_TCP 0x01 |
|---|
| | | #define BELLE_SIP_HTTP_TRANSPORT_TLS 0x02 |
|---|
| | | /** |
|---|
| | | * Create a HTTP provider attached to a given stack enabling specific transports |
|---|
| | | * @param[in] s The stack to attach the transport |
|---|
| | | * @param[in] bind_ip |
|---|
| | | * @param[in] transports a mask of authorized transports for this provider, availables are BELLE_SIP_HTTP_TRANSPORT_TCP and BELLE_SIP_HTTP_TRANSPORT_TLS |
|---|
| | | * |
|---|
| | | * @return The HTTP provider |
|---|
| | | * |
|---|
| | | */ |
|---|
| | | BELLESIP_EXPORT belle_http_provider_t * belle_sip_stack_create_http_provider_with_transports(belle_sip_stack_t *s, const char *bind_ip, const uint8_t transports); |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT belle_sip_main_loop_t* belle_sip_stack_get_main_loop(belle_sip_stack_t *stack); |
|---|
| | | |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the time interval in seconds after which a connection must be closed when inactive. |
|---|
| | | * By inactive, it is meant that the connection hasn't been used to send or recv data. |
|---|
| | | **/ |
|---|
| | | BELLESIP_EXPORT void belle_sip_stack_set_inactive_transport_timeout(belle_sip_stack_t *stack, int seconds); |
|---|
| | | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the time interval in seconds after which a connection is considered to be unreliable because |
|---|
| | | * no data was received over it. |
|---|
| | | * The special value 0 means that a connection will never be considered as unreliable. |
|---|
| | | * See belle_sip_provider_clean_unreliable_channels(). |
|---|
| | | */ |
|---|
| | | BELLESIP_EXPORT void belle_sip_stack_set_unreliable_connection_timeout(belle_sip_stack_t *stack, int seconds); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the time interval in seconds after which a connection is considered to be unreliable because |
|---|
| | | * no data was received over it. |
|---|
| | | * See belle_sip_provider_clean_unreliable_channels(). |
|---|
| | | */ |
|---|
| | | BELLESIP_EXPORT int belle_sip_stack_get_unreliable_connection_timeout(const belle_sip_stack_t *stack); |
|---|
| | | |
|---|
| | | |
|---|
| | | /** |
|---|
| | |
|---|
| | | **/ |
|---|
| | | BELLESIP_EXPORT void belle_sip_stack_set_client_bind_port(belle_sip_stack_t *stack, int port); |
|---|
| | | |
|---|
| | | #define BELLE_SIP_DNS_APPLE_DNS_SERVICE 0x01 |
|---|
| | | #define BELLE_SIP_DNS_DNS_C 0x02 |
|---|
| | | /** |
|---|
| | | * Set the dns engine to use. |
|---|
| | | * @param dns_engine Must be one of BELLE_SIP_DNS_APPLE_DNS_SERVICE or BELLE_SIP_DNS_DNS_C |
|---|
| | | **/ |
|---|
| | | BELLESIP_EXPORT void belle_sip_stack_set_dns_engine(belle_sip_stack_t *stack, unsigned char dns_engine); |
|---|
| | | /** |
|---|
| | | * Get the dns engine used |
|---|
| | | * @return BELLE_SIP_DNS_APPLE_DNS_SERVICE or BELLE_SIP_DNS_DNS_C |
|---|
| | | **/ |
|---|
| | | BELLESIP_EXPORT unsigned char belle_sip_stack_get_dns_engine(const belle_sip_stack_t *stack); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Requests the stack to simulate a router that doesn't respond to SRV requests. This is for test ONLY. |
|---|
| | | **/ |
|---|
| | | BELLESIP_EXPORT void belle_sip_stack_simulate_non_working_srv(belle_sip_stack_t *stack, int yesno); |
|---|
| | | |
|---|
| | | /* |
|---|
| | | * End of test functions. |
|---|
| | |
|---|
| | | BELLE_SIP_TYPE_ID(belle_sip_header_call_id_t), |
|---|
| | | BELLE_SIP_TYPE_ID(belle_sip_header_cseq_t), |
|---|
| | | BELLE_SIP_TYPE_ID(belle_sip_header_content_type_t), |
|---|
| | | BELLE_SIP_TYPE_ID(belle_sip_header_session_expires_t), |
|---|
| | | BELLE_SIP_TYPE_ID(belle_sip_header_route_t), |
|---|
| | | BELLE_SIP_TYPE_ID(belle_sip_header_record_route_t), |
|---|
| | | BELLE_SIP_TYPE_ID(belle_sip_header_user_agent_t), |
|---|
| | |
|---|
| | | */ |
|---|
| | | BELLESIP_EXPORT int belle_sip_mkdir(const char *path); |
|---|
| | | |
|---|
| | | BELLESIP_EXPORT char* belle_sip_uri_to_escaped_username(const char* buff); |
|---|
| | | BELLESIP_EXPORT char* belle_sip_username_unescape_unnecessary_characters(const char* buff); |
|---|
| | | BELLESIP_EXPORT char* belle_sip_to_unescaped_string(const char* buff); |
|---|
| | | |
|---|
| | | BELLE_SIP_END_DECLS |
|---|
| | | |
|---|
| | | #endif |
|---|
| | |
|---|
| | | lime::PeerDeviceStatus get_peerDeviceStatus(const std::string &peerDeviceId); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief checks if a device iD exists in the local users |
|---|
| | | * |
|---|
| | | * @param[in] deviceId The device Id to check |
|---|
| | | * |
|---|
| | | * @return true if the device Id exists in the local users table, false otherwise |
|---|
| | | */ |
|---|
| | | bool is_localUser(const std::string &deviceId); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief delete a peerDevice from local storage |
|---|
| | | * |
|---|
| | | * @param[in] peerDeviceId The device Id to be removed from local storage, shall be its GRUU |
|---|
| | |
|---|
| | | void delete_peerDevice(const std::string &peerDeviceId); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Stale all sessions between localDeviceId and peerDevice. |
|---|
| | | * If peerDevice keep using this session to encrypt and we decrypt with success, the session will be reactivated |
|---|
| | | * but to encrypt a message to this peerDevice, a new session will be created. |
|---|
| | | * If no session is active between the given device, this call has no effect |
|---|
| | | * |
|---|
| | | * @param[in] localDeviceId Identify the local user account, it must be unique and is also be used as Id on the X3DH key server, it shall be the GRUU |
|---|
| | | * @param[in] peerDeviceId The device Id of peer, shall be its GRUU |
|---|
| | | */ |
|---|
| | | void stale_sessions(const std::string &localDeviceId, const std::string &peerDeviceId); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Set the X3DH key server URL for this identified user |
|---|
| | | * |
|---|
| | | * @param[in] localDeviceId Identify the local user account, it must be unique and is also be used as Id on the X3DH key server, it shall be the GRUU |
|---|
| | |
|---|
| | | int lime_ffi_delete_peerDevice(lime_manager_t manager, const char *peerDeviceId); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Stale all sessions between localDeviceId and peerDevice. |
|---|
| | | * If peerDevice keep using this session to encrypt and we decrypt with success, the session will be reactivated |
|---|
| | | * but to encrypt a message to this peerDevice, a new session will be created. |
|---|
| | | * If no session is active between the given device, this call has no effect |
|---|
| | | * |
|---|
| | | * @param[in] manager pointer to the opaque structure used to interact with lime |
|---|
| | | * @param[in] localDeviceId Identify the local user account, it must be unique and is also be used as Id on the X3DH key server, it shall be the GRUU |
|---|
| | | * @param[in] peerDeviceId The device Id of peer, shall be its GRUU |
|---|
| | | */ |
|---|
| | | int lime_ffi_stale_sessions(lime_manager_t manager, const char *localDeviceId, const char *peerDeviceId); |
|---|
| | | /** |
|---|
| | | * @brief Update: shall be called once a day at least, performs checks, updates and cleaning operations |
|---|
| | | * |
|---|
| | | * - check if we shall update a new SPk to X3DH server(SPk lifetime is set in settings) |
|---|
| New file |
| | |
|---|
| | | /* |
|---|
| | | lime-tester-utils.hpp |
|---|
| | | @author Johan Pascal |
|---|
| | | @copyright Copyright (C) 2017 Belledonne Communications SARL |
|---|
| | | |
|---|
| | | 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 3 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, see <http://www.gnu.org/licenses/>. |
|---|
| | | */ |
|---|
| | | |
|---|
| | | #ifndef lime_tester_utils_hpp |
|---|
| | | #define lime_tester_utils_hpp |
|---|
| | | |
|---|
| | | #include "bctoolbox/crypto.h" |
|---|
| | | #include "lime_double_ratchet.hpp" |
|---|
| | | #include "lime_localStorage.hpp" |
|---|
| | | #include "belle-sip/belle-sip.h" |
|---|
| | | #include "lime_crypto_primitives.hpp" |
|---|
| | | |
|---|
| | | #include "soci/sqlite3/soci-sqlite3.h" |
|---|
| | | #include <random> |
|---|
| | | #include <mutex> |
|---|
| | | |
|---|
| | | using namespace::lime; |
|---|
| | | |
|---|
| | | namespace lime_tester { |
|---|
| | | // default url and ports of X3DH servers |
|---|
| | | extern std::string test_x3dh_server_url; |
|---|
| | | extern std::string test_x3dh_c25519_server_port; |
|---|
| | | extern std::string test_x3dh_c448_server_port; |
|---|
| | | extern std::string test_x3dh_domainA_server_port; |
|---|
| | | extern std::string test_x3dh_domainB_server_port; |
|---|
| | | extern std::string test_x3dh_domainC_server_port; |
|---|
| | | extern std::string test_x3dh_c25519_stop_on_request_limit_server_port; |
|---|
| | | extern std::string test_x3dh_c448_stop_on_request_limit_server_port; |
|---|
| | | |
|---|
| | | // messages pattern |
|---|
| | | extern std::string shortMessage; |
|---|
| | | extern std::string longMessage; |
|---|
| | | extern std::string veryLongMessage; |
|---|
| | | |
|---|
| | | extern std::vector<std::string> messages_pattern; |
|---|
| | | |
|---|
| | | // default value for the timeout |
|---|
| | | extern int wait_for_timeout; |
|---|
| | | |
|---|
| | | // bundle request limit as configured on test server |
|---|
| | | extern int bundle_request_limit; |
|---|
| | | // bundle request restriction timespan (as configured on stop on request limit server) |
|---|
| | | extern int bundle_request_limit_timespan; |
|---|
| | | |
|---|
| | | // default value for initial OPk batch size, keep it small so not too many OPks generated |
|---|
| | | extern uint16_t OPkInitialBatchSize; |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Simple RNG function, used to generate random values for testing purpose, they do not need to be real random |
|---|
| | | * so use directly std::random_device |
|---|
| | | * |
|---|
| | | * @param[in] buffer pointer to the begining of the buffer to be filled |
|---|
| | | * @param[in] size how many random bytes you want |
|---|
| | | */ |
|---|
| | | void randomize(uint8_t *buffer, const size_t size); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Create and initialise the two sessions given in parameter. Alice as sender session and Bob as receiver one |
|---|
| | | * Alice must then send the first message, once bob got it, sessions are fully initialised |
|---|
| | | * if fileName doesn't exists as a DB, it will be created, caller shall then delete it if needed |
|---|
| | | */ |
|---|
| | | template <typename Curve> |
|---|
| | | void dr_sessionsInit(std::shared_ptr<DR<Curve>> &alice, std::shared_ptr<DR<Curve>> &bob, std::shared_ptr<lime::Db> &localStorageAlice, std::shared_ptr<lime::Db> &localStorageBob, std::string dbFilenameAlice, std::shared_ptr<std::recursive_mutex> db_mutex_alice, std::string dbFilenameBob, std::shared_ptr<std::recursive_mutex> db_mutex_bob, bool initStorage, std::shared_ptr<RNG> RNG_context); |
|---|
| | | |
|---|
| | | |
|---|
| | | /* non efficient but used friendly structure to store all details about a session */ |
|---|
| | | /* the self_xx are redundants but it's for testing purpose */ |
|---|
| | | template <typename Curve> |
|---|
| | | struct sessionDetails { |
|---|
| | | std::string self_userId; |
|---|
| | | std::size_t self_userIndex; |
|---|
| | | std::size_t self_deviceIndex; |
|---|
| | | std::string peer_userId; |
|---|
| | | std::size_t peer_userIndex; |
|---|
| | | std::size_t peer_deviceIndex; |
|---|
| | | std::shared_ptr<DR<Curve>> DRSession; // Session to reach recipient |
|---|
| | | std::shared_ptr<lime::Db> localStorage; // db linked to device |
|---|
| | | sessionDetails() : self_userId{}, self_userIndex{0}, self_deviceIndex{0}, peer_userId{}, peer_userIndex{0}, peer_deviceIndex{0}, DRSession{}, localStorage{} {}; |
|---|
| | | sessionDetails(std::string &s_userId, size_t s_userIndex, size_t s_deviceIndex, std::string &p_userId, size_t p_userIndex, size_t p_deviceIndex) |
|---|
| | | : self_userId{s_userId}, self_userIndex{s_userIndex}, self_deviceIndex{s_deviceIndex}, peer_userId{p_userId}, peer_userIndex{p_userIndex}, peer_deviceIndex{p_deviceIndex}, DRSession{}, localStorage{} {}; |
|---|
| | | }; |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Create and initialise all requested DR sessions for specified number of devices between two or more users |
|---|
| | | * users is a vector of users(already sized to correct size, matching usernames size), each one holds a vector of devices(already sized for each device) |
|---|
| | | * This function will create and instanciate in each device a vector of vector of DR sessions towards all other devices: each device vector holds a bidimentionnal array indexed by userId and deviceId. |
|---|
| | | * Session init is done considering as initial sender the lowest id user and in it the lowest id device |
|---|
| | | * createdDBfiles is filled with all filenames of DB created to allow easy deletion |
|---|
| | | */ |
|---|
| | | template <typename Curve> |
|---|
| | | void dr_devicesInit(std::string dbBaseFilename, std::vector<std::vector<std::vector<std::vector<sessionDetails<Curve>>>>> &users, std::vector<std::string> &usernames, std::vector<std::string> &createdDBfiles, std::shared_ptr<RNG> RNG_context); |
|---|
| | | |
|---|
| | | /* return true if the message buffer is a DR message wiht the paylod direct encryption flag set */ |
|---|
| | | bool DR_message_payloadDirectEncrypt(std::vector<uint8_t> &message); |
|---|
| | | /* return true if the message buffer is a valid DR message holding a X3DH init one in its header */ |
|---|
| | | bool DR_message_holdsX3DHInit(std::vector<uint8_t> &message); |
|---|
| | | /* this version will set the OPk status in the given bool if a packet is found */ |
|---|
| | | bool DR_message_holdsX3DHInit(std::vector<uint8_t> &message, bool &haveOPk); |
|---|
| | | |
|---|
| | | /* return true if the message buffer is a valid DR message holding a X3DH init one in its header and copy the X3DH init message in the provided buffer */ |
|---|
| | | bool DR_message_extractX3DHInit(std::vector<uint8_t> &message, std::vector<uint8_t> &X3DH_initMessage); |
|---|
| | | |
|---|
| | | /* return true if the message buffer is a valid DR message holding an X3DH init message, copy its SPk id in the given parameter */ |
|---|
| | | bool DR_message_extractX3DHInit_SPkId(std::vector<uint8_t> &message, uint32_t &SPkId); |
|---|
| | | |
|---|
| | | /* Open provided DB and look for DRSessions established between selfDevice and peerDevice |
|---|
| | | * Populate the sessionsId vector with the Ids of sessions found |
|---|
| | | * return the id of the active session if one is found, 0 otherwise */ |
|---|
| | | long int get_DRsessionsId(const std::string &dbFilename, const std::string &selfDeviceId, const std::string &peerDeviceId, std::vector<long int> &sessionsId) noexcept; |
|---|
| | | |
|---|
| | | |
|---|
| | | /* Open provided DB, look for DRSessions established between selfDevice and peerDevice, count the stored message keys in all these sessions |
|---|
| | | * return 0 if no sessions found or no user found |
|---|
| | | */ |
|---|
| | | unsigned int get_StoredMessageKeyCount(const std::string &dbFilename, const std::string &selfDeviceId, const std::string &peerDeviceId) noexcept; |
|---|
| | | |
|---|
| | | /* For the given deviceId, count the number of associated SPk and return the Id of the active one(if any) |
|---|
| | | * return true if an active one was found |
|---|
| | | */ |
|---|
| | | bool get_SPks(const std::string &dbFilename, const std::string &selfDeviceId, size_t &count, uint32_t &activeId) noexcept; |
|---|
| | | |
|---|
| | | /* For the given deviceId, count the number of associated OPk |
|---|
| | | */ |
|---|
| | | size_t get_OPks(const std::string &dbFilename, const std::string &selfDeviceId) noexcept; |
|---|
| | | |
|---|
| | | /* Move back in time all timeStamps by the given amout of days |
|---|
| | | * DB holds timeStamps in DR_sessions and X3DH_SPK tables |
|---|
| | | */ |
|---|
| | | void forwardTime(const std::string &dbFilename, int days) noexcept; |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief append a random suffix to user name to avoid collision if test server is user by several tests runs |
|---|
| | | * |
|---|
| | | * @param[in] basename |
|---|
| | | * |
|---|
| | | * @return a shared ptr towards a string holding name+ 6 chars random suffix |
|---|
| | | */ |
|---|
| | | std::shared_ptr<std::string> makeRandomDeviceName(const char *basename); |
|---|
| | | |
|---|
| | | |
|---|
| | | // wait for a counter to reach a value or timeout to occur, gives ticks to the belle-sip stack every SLEEP_TIME |
|---|
| | | // structure used by callbacks to register events |
|---|
| | | struct events_counters_t { |
|---|
| | | int operation_success; |
|---|
| | | int operation_failed; |
|---|
| | | events_counters_t() : operation_success{0}, operation_failed{0} {}; |
|---|
| | | bool operator==(const events_counters_t &b) const {return this->operation_success==b.operation_success && this->operation_failed==b.operation_failed;} |
|---|
| | | }; |
|---|
| | | |
|---|
| | | // wait for a counter to reach a value or timeout to occur, gives ticks to the belle-sip stack every SLEEP_TIME |
|---|
| | | int wait_for(belle_sip_stack_t*s1,int* counter,int value,int timeout); |
|---|
| | | int wait_for_mutex(belle_sip_stack_t*s1,int* counter,int value,int timeout, std::shared_ptr<std::recursive_mutex> mutex); |
|---|
| | | |
|---|
| | | // template instanciation are done in lime-tester-utils.cpp |
|---|
| | | #ifdef EC25519_ENABLED |
|---|
| | | extern template void dr_sessionsInit<C255>(std::shared_ptr<DR<C255>> &alice, std::shared_ptr<DR<C255>> &bob, std::shared_ptr<lime::Db> &localStorageAlice, std::shared_ptr<lime::Db> &localStorageBob, std::string dbFilenameAlice, std::shared_ptr<std::recursive_mutex> db_mutex_alice, std::string dbFilenameBob, std::shared_ptr<std::recursive_mutex> db_mutex_bob, bool initStorage, std::shared_ptr<RNG> RNG_context); |
|---|
| | | extern template void dr_devicesInit<C255>(std::string dbBaseFilename, std::vector<std::vector<std::vector<std::vector<sessionDetails<C255>>>>> &users, std::vector<std::string> &usernames, std::vector<std::string> &createdDBfiles, std::shared_ptr<RNG> RNG_context); |
|---|
| | | #endif |
|---|
| | | #ifdef EC448_ENABLED |
|---|
| | | extern template void dr_sessionsInit<C448>(std::shared_ptr<DR<C448>> &alice, std::shared_ptr<DR<C448>> &bob, std::shared_ptr<lime::Db> &localStorageAlice, std::shared_ptr<lime::Db> &localStorageBob, std::string dbFilenameAlice, std::shared_ptr<std::recursive_mutex> db_mutex_alice, std::string dbFilenameBob, std::shared_ptr<std::recursive_mutex> db_mutex_bob, bool initStorage, std::shared_ptr<RNG> RNG_context); |
|---|
| | | extern template void dr_devicesInit<C448>(std::string dbBaseFilename, std::vector<std::vector<std::vector<std::vector<sessionDetails<C448>>>>> &users, std::vector<std::string> &usernames, std::vector<std::string> &createdDBfiles, std::shared_ptr<RNG> RNG_context); |
|---|
| | | #endif |
|---|
| | | } // namespace lime_tester |
|---|
| | | |
|---|
| | | extern "C" { |
|---|
| | | |
|---|
| | | |
|---|
| | | #ifdef FFI_ENABLED |
|---|
| | | /* some shared variable defined in lime_ff-tester, used only when FFI is enabled |
|---|
| | | * and they are duplicate of command line arguments variable already existing in C++ from lime_tester-utils.cpp |
|---|
| | | * but it's easier to read and implement this way */ |
|---|
| | | // ffi default url and ports of X3DH servers |
|---|
| | | extern char ffi_test_x3dh_server_url[512]; |
|---|
| | | extern char ffi_test_x3dh_c25519_server_port[16]; |
|---|
| | | extern char ffi_test_x3dh_c448_server_port[16]; |
|---|
| | | |
|---|
| | | // ffi default value for the timeout |
|---|
| | | extern int ffi_wait_for_timeout; |
|---|
| | | #endif |
|---|
| | | |
|---|
| | | } |
|---|
| | | |
|---|
| | | #endif //lime_tester_utils_hpp |
|---|
| New file |
| | |
|---|
| | | /* |
|---|
| | | lime-tester.hpp |
|---|
| | | @author Johan Pascal |
|---|
| | | @copyright Copyright (C) 2017 Belledonne Communications SARL |
|---|
| | | |
|---|
| | | 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 3 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, see <http://www.gnu.org/licenses/>. |
|---|
| | | */ |
|---|
| | | |
|---|
| | | #ifndef lime_tester_hpp |
|---|
| | | #define lime_tester_hpp |
|---|
| | | |
|---|
| | | #include <bctoolbox/tester.h> |
|---|
| | | |
|---|
| | | #include <string> |
|---|
| | | #include <memory> |
|---|
| | | #include <sstream> |
|---|
| | | #include <iostream> |
|---|
| | | |
|---|
| | | extern "C" { |
|---|
| | | extern bool cleanDatabase; |
|---|
| | | extern bool bench; |
|---|
| | | extern test_suite_t lime_double_ratchet_test_suite; |
|---|
| | | extern test_suite_t lime_lime_test_suite; |
|---|
| | | extern test_suite_t lime_helloworld_test_suite; |
|---|
| | | extern test_suite_t lime_crypto_test_suite; |
|---|
| | | extern test_suite_t lime_massive_group_test_suite; |
|---|
| | | #ifdef FFI_ENABLED |
|---|
| | | extern test_suite_t lime_ffi_test_suite; |
|---|
| | | #endif |
|---|
| | | extern test_suite_t lime_multidomains_test_suite; |
|---|
| | | extern test_suite_t lime_server_test_suite; |
|---|
| | | |
|---|
| | | void lime_tester_init(void(*ftester_printf)(int level, const char *fmt, va_list args)); |
|---|
| | | void lime_tester_uninit(void); |
|---|
| | | |
|---|
| | | }; |
|---|
| | | |
|---|
| | | #endif |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback to notify a response of server. |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object |
|---|
| | | * @param[in] status The status of the #LinphoneAccountCreator test existence operation that has just finished |
|---|
| | | * @param creator #LinphoneAccountCreator object @notnil |
|---|
| | | * @param status The status of the #LinphoneAccountCreator test existence operation that has just finished |
|---|
| | | * @param response The response has a string @maybenil |
|---|
| | | **/ |
|---|
| | | typedef void (*LinphoneAccountCreatorCbsStatusCb)(LinphoneAccountCreator *creator, LinphoneAccountCreatorStatus status, const char* resp); |
|---|
| | | typedef void (*LinphoneAccountCreatorCbsStatusCb)(LinphoneAccountCreator *creator, LinphoneAccountCreatorStatus status, const char* response); |
|---|
| | | |
|---|
| | | /************************** Start Account Creator data **************************/ |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Create a #LinphoneAccountCreator and set Linphone Request callbacks. |
|---|
| | | * @param[in] core The #LinphoneCore used for the XML-RPC communication |
|---|
| | | * @param[in] xmlrpc_url The URL to the XML-RPC server. Must be NON NULL. |
|---|
| | | * @return The new #LinphoneAccountCreator object. |
|---|
| | | * @param core The #LinphoneCore used for the XML-RPC communication @notnil |
|---|
| | | * @param xmlrpc_url The URL to the XML-RPC server. @maybenil |
|---|
| | | * @return The new #LinphoneAccountCreator object. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneAccountCreator * linphone_account_creator_new(LinphoneCore *core, const char *xmlrpc_url); |
|---|
| | | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Reset the account creator entries like username, password, phone number... |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object |
|---|
| | | * @param creator #LinphoneAccountCreator object @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_account_creator_reset(LinphoneAccountCreator *creator); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Send a request to know the existence of account on server. |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object |
|---|
| | | * @param creator #LinphoneAccountCreator object @notnil |
|---|
| | | * @return #LinphoneAccountCreatorStatusRequestOk if the request has been sent, #LinphoneAccountCreatorStatusRequestFailed otherwise |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneAccountCreatorStatus linphone_account_creator_is_account_exist(LinphoneAccountCreator *creator); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Send a request to create an account on server. |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object |
|---|
| | | * @param creator #LinphoneAccountCreator object @notnil |
|---|
| | | * @return #LinphoneAccountCreatorStatusRequestOk if the request has been sent, #LinphoneAccountCreatorStatusRequestFailed otherwise |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneAccountCreatorStatus linphone_account_creator_create_account(LinphoneAccountCreator *creator); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Send a request to know if an account is activated on server. |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object |
|---|
| | | * @param creator #LinphoneAccountCreator object @notnil |
|---|
| | | * @return #LinphoneAccountCreatorStatusRequestOk if the request has been sent, #LinphoneAccountCreatorStatusRequestFailed otherwise |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneAccountCreatorStatus linphone_account_creator_is_account_activated(LinphoneAccountCreator *creator); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Send a request to activate an account on server. |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object |
|---|
| | | * @param creator #LinphoneAccountCreator object @notnil |
|---|
| | | * @return #LinphoneAccountCreatorStatusRequestOk if the request has been sent, #LinphoneAccountCreatorStatusRequestFailed otherwise |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneAccountCreatorStatus linphone_account_creator_activate_account(LinphoneAccountCreator *creator); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Send a request to link an account to an alias. |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object |
|---|
| | | * @param creator #LinphoneAccountCreator object @notnil |
|---|
| | | * @return #LinphoneAccountCreatorStatusRequestOk if the request has been sent, #LinphoneAccountCreatorStatusRequestFailed otherwise |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneAccountCreatorStatus linphone_account_creator_link_account(LinphoneAccountCreator *creator); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Send a request to activate an alias. |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object |
|---|
| | | * @param creator #LinphoneAccountCreator object @notnil |
|---|
| | | * @return #LinphoneAccountCreatorStatusRequestOk if the request has been sent, #LinphoneAccountCreatorStatusRequestFailed otherwise |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneAccountCreatorStatus linphone_account_creator_activate_alias(LinphoneAccountCreator *creator); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Send a request to know if an alias is used. |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object |
|---|
| | | * @param creator #LinphoneAccountCreator object @notnil |
|---|
| | | * @return #LinphoneAccountCreatorStatusRequestOk if the request has been sent, #LinphoneAccountCreatorStatusRequestFailed otherwise |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneAccountCreatorStatus linphone_account_creator_is_alias_used(LinphoneAccountCreator *creator); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Send a request to know if an account is linked. |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object |
|---|
| | | * @param creator #LinphoneAccountCreator object @notnil |
|---|
| | | * @return #LinphoneAccountCreatorStatusRequestOk if the request has been sent, #LinphoneAccountCreatorStatusRequestFailed otherwise |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneAccountCreatorStatus linphone_account_creator_is_account_linked(LinphoneAccountCreator *creator); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Send a request to recover an account. |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object |
|---|
| | | * @param creator #LinphoneAccountCreator object @notnil |
|---|
| | | * @return #LinphoneAccountCreatorStatusRequestOk if the request has been sent, #LinphoneAccountCreatorStatusRequestFailed otherwise |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneAccountCreatorStatus linphone_account_creator_recover_account(LinphoneAccountCreator *creator); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Send a request to update an account. |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object |
|---|
| | | * @param creator #LinphoneAccountCreator object @notnil |
|---|
| | | * @return #LinphoneAccountCreatorStatusRequestOk if the request has been sent, #LinphoneAccountCreatorStatusRequestFailed otherwise |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneAccountCreatorStatus linphone_account_creator_update_account(LinphoneAccountCreator *creator); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Send a request to get the password & algorithm of an account using the confirmation key |
|---|
| | | * @param creator #LinphoneAccountCreator object @notnil |
|---|
| | | * @return #LinphoneAccountCreatorStatusRequestOk if everything is OK, or a specific error otherwise. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneAccountCreatorStatus linphone_account_creator_login_linphone_account(LinphoneAccountCreator *creator); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Acquire a reference to the LinphoneAccountCreator. |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object. |
|---|
| | | * @return The same #LinphoneAccountCreator object. |
|---|
| | | * @param creator #LinphoneAccountCreator object. @notnil |
|---|
| | | * @return The same #LinphoneAccountCreator object. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneAccountCreator * linphone_account_creator_ref(LinphoneAccountCreator *creator); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Release reference to the LinphoneAccountCreator. |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object. |
|---|
| | | * @param creator #LinphoneAccountCreator object. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_account_creator_unref(LinphoneAccountCreator *creator); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Retrieve the user pointer associated with the LinphoneAccountCreator. |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object. |
|---|
| | | * @return The user pointer associated with the LinphoneAccountCreator. |
|---|
| | | * @param creator #LinphoneAccountCreator object. @notnil |
|---|
| | | * @return The user pointer associated with the LinphoneAccountCreator. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void *linphone_account_creator_get_user_data(const LinphoneAccountCreator *creator); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user pointer to the LinphoneAccountCreator. |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object. |
|---|
| | | * @param[in] ud The user pointer to associate with the LinphoneAccountCreator. |
|---|
| | | * @param creator #LinphoneAccountCreator object. @notnil |
|---|
| | | * @param user_data The user pointer to associate with the LinphoneAccountCreator. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_account_creator_set_user_data(LinphoneAccountCreator *creator, void *ud); |
|---|
| | | LINPHONE_PUBLIC void linphone_account_creator_set_user_data(LinphoneAccountCreator *creator, void *user_data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a proxy config pointer to the LinphoneAccountCreator. |
|---|
| | | * @param[in] creator LinphoneAccountCreator object. |
|---|
| | | * @param[in] cfg The LinphoneProxyConfig to associate with the LinphoneAccountCreator. |
|---|
| | | * @param creator LinphoneAccountCreator object. @notnil |
|---|
| | | * @param cfg The LinphoneProxyConfig to associate with the LinphoneAccountCreator. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_account_creator_set_proxy_config(LinphoneAccountCreator *creator, LinphoneProxyConfig *cfg); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the username. |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object |
|---|
| | | * @param[in] username The username to set |
|---|
| | | * @param creator #LinphoneAccountCreator object @notnil |
|---|
| | | * @param username The username to set @maybenil |
|---|
| | | * @return #LinphoneAccountCreatorUsernameStatusOk if everything is OK, or a specific error otherwise. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneAccountCreatorUsernameStatus linphone_account_creator_set_username(LinphoneAccountCreator *creator, const char *username); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the username. |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object |
|---|
| | | * @return The username of the #LinphoneAccountCreator |
|---|
| | | * @param creator #LinphoneAccountCreator object @notnil |
|---|
| | | * @return The username of the #LinphoneAccountCreator. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_account_creator_get_username(const LinphoneAccountCreator *creator); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the phone number normalized. |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object |
|---|
| | | * @param[in] phone_number The phone number to set |
|---|
| | | * @param[in] country_code Country code to associate phone number with |
|---|
| | | * @param creator #LinphoneAccountCreator object @notnil |
|---|
| | | * @param phone_number The phone number to set @maybenil |
|---|
| | | * @param country_code Country code to associate phone number with @maybenil |
|---|
| | | * @return #LinphoneAccountCreatorPhoneNumberStatusOk if everything is OK, or specific(s) error(s) otherwise. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneAccountCreatorPhoneNumberStatusMask linphone_account_creator_set_phone_number(LinphoneAccountCreator *creator, const char *phone_number, const char *country_code); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the RFC 3966 normalized phone number. |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object |
|---|
| | | * @return The phone number of the #LinphoneAccountCreator |
|---|
| | | * @param creator #LinphoneAccountCreator object @notnil |
|---|
| | | * @return The phone number of the #LinphoneAccountCreator. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_account_creator_get_phone_number(const LinphoneAccountCreator *creator); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the password. |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object |
|---|
| | | * @param[in] password The password to set |
|---|
| | | * @param creator #LinphoneAccountCreator object @notnil |
|---|
| | | * @param password The password to set @maybenil |
|---|
| | | * @return #LinphoneAccountCreatorPasswordStatusOk if everything is OK, or specific(s) error(s) otherwise. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneAccountCreatorPasswordStatus linphone_account_creator_set_password(LinphoneAccountCreator *creator, const char *password); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the password. |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object |
|---|
| | | * @return The password of the #LinphoneAccountCreator |
|---|
| | | * @param creator #LinphoneAccountCreator object @notnil |
|---|
| | | * @return The password of the #LinphoneAccountCreator. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_account_creator_get_password(const LinphoneAccountCreator *creator); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the ha1. |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object |
|---|
| | | * @param[in] ha1 The ha1 to set |
|---|
| | | * @param creator #LinphoneAccountCreator object @notnil |
|---|
| | | * @param ha1 The ha1 to set @maybenil |
|---|
| | | * @return #LinphoneAccountCreatorPasswordStatusOk if everything is OK, or a specific error otherwise. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneAccountCreatorPasswordStatus linphone_account_creator_set_ha1(LinphoneAccountCreator *creator, const char *ha1); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the ha1. |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object |
|---|
| | | * @return The ha1 of the #LinphoneAccountCreator |
|---|
| | | * @param creator #LinphoneAccountCreator object @notnil |
|---|
| | | * @return The ha1 of the #LinphoneAccountCreator. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_account_creator_get_ha1(const LinphoneAccountCreator *creator); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the activation code. |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object |
|---|
| | | * @param[in] activation_code The activation code to set |
|---|
| | | * @param creator #LinphoneAccountCreator object @notnil |
|---|
| | | * @param activation_code The activation code to set @maybenil |
|---|
| | | * @return #LinphoneAccountCreatorActivationCodeStatusOk if everything is OK, or a specific error otherwise. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneAccountCreatorActivationCodeStatus linphone_account_creator_set_activation_code(LinphoneAccountCreator *creator, const char *activation_code); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the activation code. |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object |
|---|
| | | * @return The activation code of the #LinphoneAccountCreator |
|---|
| | | * @param creator #LinphoneAccountCreator object @notnil |
|---|
| | | * @return The activation code of the #LinphoneAccountCreator. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_account_creator_get_activation_code(const LinphoneAccountCreator *creator); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the language to use in email or SMS if supported. |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object |
|---|
| | | * @param[in] lang The language to use |
|---|
| | | * @param creator #LinphoneAccountCreator object @notnil |
|---|
| | | * @param lang The language to use @maybenil |
|---|
| | | * @return #LinphoneAccountCreatorLanguageStatusOk if everything is OK, or a specific error otherwise. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneAccountCreatorLanguageStatus linphone_account_creator_set_language(LinphoneAccountCreator *creator, const char *lang); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the language use in email of SMS. |
|---|
| | | * @param creator #LinphoneAccountCreator object @notnil |
|---|
| | | * @return The language of the #LinphoneAccountCreator. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_account_creator_get_language(const LinphoneAccountCreator *creator); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the supported algorithm. |
|---|
| | | * @param[in] creator LinphoneAccountCreator object |
|---|
| | | * @param[in] algorithm The algorithm to use |
|---|
| | | * @param creator LinphoneAccountCreator object @notnil |
|---|
| | | * @param algorithm The algorithm to use @maybenil |
|---|
| | | * @return LinphoneAccountCreatorAlgoStatusOk if everything is OK, or a specific error otherwise. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneAccountCreatorAlgoStatus linphone_account_creator_set_algorithm(LinphoneAccountCreator *creator, const char *algorithm); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the language use in email of SMS. |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object |
|---|
| | | * @return The language of the #LinphoneAccountCreator |
|---|
| | | * Get the algorithm configured in the account creator. |
|---|
| | | * @param creator #LinphoneAccountCreator object @notnil |
|---|
| | | * @return The algorithm of the #LinphoneAccountCreator. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_account_creator_get_language(const LinphoneAccountCreator *creator); |
|---|
| | | LINPHONE_PUBLIC const char * linphone_account_creator_get_algorithm(const LinphoneAccountCreator *creator); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the display name. |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object |
|---|
| | | * @param[in] display_name The display name to set |
|---|
| | | * @param creator #LinphoneAccountCreator object @notnil |
|---|
| | | * @param display_name The display name to set @maybenil |
|---|
| | | * @return #LinphoneAccountCreatorUsernameStatusOk if everything is OK, or a specific error otherwise. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneAccountCreatorUsernameStatus linphone_account_creator_set_display_name(LinphoneAccountCreator *creator, const char *display_name); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the display name. |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object |
|---|
| | | * @return The display name of the #LinphoneAccountCreator |
|---|
| | | * @param creator #LinphoneAccountCreator object @notnil |
|---|
| | | * @return The display name of the #LinphoneAccountCreator. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_account_creator_get_display_name(const LinphoneAccountCreator *creator); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the email. |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object |
|---|
| | | * @param[in] email The email to set |
|---|
| | | * @param creator #LinphoneAccountCreator object @notnil |
|---|
| | | * @param email The email to set @maybenil |
|---|
| | | * @return #LinphoneAccountCreatorEmailStatusOk if everything is OK, or a specific error otherwise. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneAccountCreatorEmailStatus linphone_account_creator_set_email(LinphoneAccountCreator *creator, const char *email); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the email. |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object |
|---|
| | | * @return The email of the #LinphoneAccountCreator |
|---|
| | | * @param creator #LinphoneAccountCreator object @notnil |
|---|
| | | * @return The email of the #LinphoneAccountCreator. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_account_creator_get_email(const LinphoneAccountCreator *creator); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the domain. |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object |
|---|
| | | * @param[in] domain The domain to set |
|---|
| | | * @param creator #LinphoneAccountCreator object @notnil |
|---|
| | | * @param domain The domain to set @maybenil |
|---|
| | | * @return #LinphoneAccountCreatorDomainOk if everything is OK, or a specific error otherwise. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneAccountCreatorDomainStatus linphone_account_creator_set_domain(LinphoneAccountCreator *creator, const char *domain); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the domain. |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object |
|---|
| | | * @return The domain of the #LinphoneAccountCreator |
|---|
| | | * @param creator #LinphoneAccountCreator object @notnil |
|---|
| | | * @return The domain of the #LinphoneAccountCreator. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_account_creator_get_domain(const LinphoneAccountCreator *creator); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set Transport |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object |
|---|
| | | * @param[in] transport The transport to set |
|---|
| | | * @param creator #LinphoneAccountCreator object @notnil |
|---|
| | | * @param transport The #LinphoneTransportType to set |
|---|
| | | * @return #LinphoneAccountCreatorTransportOk if everything is OK, or a specific error otherwise. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneAccountCreatorTransportStatus linphone_account_creator_set_transport(LinphoneAccountCreator *creator, LinphoneTransportType transport); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * get Transport |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object |
|---|
| | | * @return The transport of #LinphoneAccountCreator |
|---|
| | | * Get Transport |
|---|
| | | * @param creator #LinphoneAccountCreator object @notnil |
|---|
| | | * @return The #LinphoneTransportType of the creator. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneTransportType linphone_account_creator_get_transport(const LinphoneAccountCreator *creator); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the route. |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object |
|---|
| | | * @param[in] route The route to set |
|---|
| | | * @return #LinphoneAccountCreatorStatusRequestOk if everything is OK, or a specific error otherwise. |
|---|
| | | **/ |
|---|
| | | LINPHONE_DEPRECATED LINPHONE_PUBLIC LinphoneAccountCreatorStatus linphone_account_creator_set_route(LinphoneAccountCreator *creator, const char *route); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the route. |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object |
|---|
| | | * @return The route of the #LinphoneAccountCreator |
|---|
| | | **/ |
|---|
| | | LINPHONE_DEPRECATED LINPHONE_PUBLIC const char * linphone_account_creator_get_route(const LinphoneAccountCreator *creator); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the set_as_default property. |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object |
|---|
| | | * @param[in] set_as_default The set_as_default to set |
|---|
| | | * @param creator #LinphoneAccountCreator object @notnil |
|---|
| | | * @param set_as_default TRUE for the created proxy config to be set as default in #LinphoneCore, FALSE otherwise |
|---|
| | | * @return #LinphoneAccountCreatorStatusRequestOk if everything is OK, or a specific error otherwise. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneAccountCreatorStatus linphone_account_creator_set_as_default(LinphoneAccountCreator *creator, bool_t set_as_default); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the set_as_default property. |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object |
|---|
| | | * @return The set_as_default of the #LinphoneAccountCreator |
|---|
| | | * @param creator #LinphoneAccountCreator object @notnil |
|---|
| | | * @return TRUE if account will be set as default, FALSE otherwise. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_account_creator_get_set_as_default(const LinphoneAccountCreator *creator); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the #LinphoneAccountCreatorCbs object associated with a LinphoneAccountCreator. |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object |
|---|
| | | * @return The #LinphoneAccountCreatorCbs object associated with the LinphoneAccountCreator. |
|---|
| | | * @deprecated use add_callbacks / remove_callbacks instead |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneAccountCreatorCbs * linphone_account_creator_get_callbacks(const LinphoneAccountCreator *creator); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Add the #LinphoneAccountCreatorCbs object to a LinphoneAccountCreator. |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object |
|---|
| | | * @param[in] cbs The #LinphoneAccountCreatorCbs object to add to the LinphoneAccountCreator. |
|---|
| | | * @param creator #LinphoneAccountCreator object @notnil |
|---|
| | | * @param cbs The #LinphoneAccountCreatorCbs object to add to the LinphoneAccountCreator. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_account_creator_add_callbacks(LinphoneAccountCreator *creator, LinphoneAccountCreatorCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Removes the #LinphoneAccountCreatorCbs object from a LinphoneAccountCreator. |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object |
|---|
| | | * @param[in] cbs The #LinphoneAccountCreatorCbs object to remove from the LinphoneAccountCreator. |
|---|
| | | * @param creator #LinphoneAccountCreator object @notnil |
|---|
| | | * @param cbs The #LinphoneAccountCreatorCbs object to remove from the LinphoneAccountCreator. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_account_creator_remove_callbacks(LinphoneAccountCreator *creator, LinphoneAccountCreatorCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the current #LinphoneAccountCreatorCbs object associated with a LinphoneAccountCreator. |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object |
|---|
| | | * @return The current #LinphoneAccountCreatorCbs object associated with the LinphoneAccountCreator. |
|---|
| | | * @param creator #LinphoneAccountCreator object @notnil |
|---|
| | | * @return The current #LinphoneAccountCreatorCbs object associated with the LinphoneAccountCreator. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneAccountCreatorCbs *linphone_account_creator_get_current_callbacks(const LinphoneAccountCreator *creator); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the #LinphoneAccountCreatorService object associated with a LinphoneAccountCreator. |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object |
|---|
| | | * @param creator #LinphoneAccountCreator object @notnil |
|---|
| | | * @return The #LinphoneAccountCreatorService object associated with the LinphoneAccountCreator. |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Acquire a reference to a #LinphoneAccountCreatorCbs object. |
|---|
| | | * @param[in] cbs #LinphoneAccountCreatorCbs object. |
|---|
| | | * @return The same #LinphoneAccountCreatorCbs object. |
|---|
| | | * @param cbs #LinphoneAccountCreatorCbs object. @notnil |
|---|
| | | * @return The same #LinphoneAccountCreatorCbs object. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneAccountCreatorCbs * linphone_account_creator_cbs_ref(LinphoneAccountCreatorCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Release a reference to a #LinphoneAccountCreatorCbs object. |
|---|
| | | * @param[in] cbs #LinphoneAccountCreatorCbs object. |
|---|
| | | * @param cbs #LinphoneAccountCreatorCbs object. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_account_creator_cbs_unref(LinphoneAccountCreatorCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Retrieve the user pointer associated with a #LinphoneAccountCreatorCbs object. |
|---|
| | | * @param[in] cbs #LinphoneAccountCreatorCbs object. |
|---|
| | | * @return The user pointer associated with the #LinphoneAccountCreatorCbs object. |
|---|
| | | * @param cbs #LinphoneAccountCreatorCbs object. @notnil |
|---|
| | | * @return The user pointer associated with the #LinphoneAccountCreatorCbs object. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void *linphone_account_creator_cbs_get_user_data(const LinphoneAccountCreatorCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user pointer to a #LinphoneAccountCreatorCbs object. |
|---|
| | | * @param[in] cbs #LinphoneAccountCreatorCbs object. |
|---|
| | | * @param[in] ud The user pointer to associate with the #LinphoneAccountCreatorCbs object. |
|---|
| | | * @param cbs #LinphoneAccountCreatorCbs object. @notnil |
|---|
| | | * @param user_data The user pointer to associate with the #LinphoneAccountCreatorCbs object. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_account_creator_cbs_set_user_data(LinphoneAccountCreatorCbs *cbs, void *ud); |
|---|
| | | LINPHONE_PUBLIC void linphone_account_creator_cbs_set_user_data(LinphoneAccountCreatorCbs *cbs, void *user_data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the create account request. |
|---|
| | | * @param[in] cbs #LinphoneAccountCreatorCbs object. |
|---|
| | | * @param cbs #LinphoneAccountCreatorCbs object. @notnil |
|---|
| | | * @return The current create account request. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneAccountCreatorCbsStatusCb linphone_account_creator_cbs_get_create_account(const LinphoneAccountCreatorCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user pointer to a #LinphoneAccountCreatorCbs object. |
|---|
| | | * @param[in] cbs #LinphoneAccountCreatorCbs object. |
|---|
| | | * @param[in] cb The create account request to be used. |
|---|
| | | * @param cbs #LinphoneAccountCreatorCbs object. @notnil |
|---|
| | | * @param cb The create account request to be used. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_account_creator_cbs_set_create_account(LinphoneAccountCreatorCbs *cbs, LinphoneAccountCreatorCbsStatusCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the is account exist request. |
|---|
| | | * @param[in] cbs #LinphoneAccountCreatorCbs object. |
|---|
| | | * @param cbs #LinphoneAccountCreatorCbs object. @notnil |
|---|
| | | * @return The current is account exist request. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneAccountCreatorCbsStatusCb linphone_account_creator_cbs_get_is_account_exist(const LinphoneAccountCreatorCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user pointer to a #LinphoneAccountCreatorCbs object. |
|---|
| | | * @param[in] cbs #LinphoneAccountCreatorCbs object. |
|---|
| | | * @param[in] cb The is account exist request to be used. |
|---|
| | | * @param cbs #LinphoneAccountCreatorCbs object. @notnil |
|---|
| | | * @param cb The is account exist request to be used. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_account_creator_cbs_set_is_account_exist(LinphoneAccountCreatorCbs *cbs, LinphoneAccountCreatorCbsStatusCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the activate account request. |
|---|
| | | * @param[in] cbs #LinphoneAccountCreatorCbs object. |
|---|
| | | * @param cbs #LinphoneAccountCreatorCbs object. @notnil |
|---|
| | | * @return The current activate account request. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneAccountCreatorCbsStatusCb linphone_account_creator_cbs_get_activate_account(const LinphoneAccountCreatorCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user pointer to a #LinphoneAccountCreatorCbs object. |
|---|
| | | * @param[in] cbs #LinphoneAccountCreatorCbs object. |
|---|
| | | * @param[in] cb The activate account request to be used. |
|---|
| | | * @param cbs #LinphoneAccountCreatorCbs object. @notnil |
|---|
| | | * @param cb The activate account request to be used. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_account_creator_cbs_set_activate_account(LinphoneAccountCreatorCbs *cbs, LinphoneAccountCreatorCbsStatusCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the is account activated request. |
|---|
| | | * @param[in] cbs #LinphoneAccountCreatorCbs object. |
|---|
| | | * @param cbs #LinphoneAccountCreatorCbs object. @notnil |
|---|
| | | * @return The current is account activated request. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneAccountCreatorCbsStatusCb linphone_account_creator_cbs_get_is_account_activated(const LinphoneAccountCreatorCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user pointer to a #LinphoneAccountCreatorCbs object. |
|---|
| | | * @param[in] cbs #LinphoneAccountCreatorCbs object. |
|---|
| | | * @param[in] cb The is account activated request to be used. |
|---|
| | | * @param cbs #LinphoneAccountCreatorCbs object. @notnil |
|---|
| | | * @param cb The is account activated request to be used. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_account_creator_cbs_set_is_account_activated(LinphoneAccountCreatorCbs *cbs, LinphoneAccountCreatorCbsStatusCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the link account request. |
|---|
| | | * @param[in] cbs #LinphoneAccountCreatorCbs object. |
|---|
| | | * @param cbs #LinphoneAccountCreatorCbs object. @notnil |
|---|
| | | * @return The current link account request. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneAccountCreatorCbsStatusCb linphone_account_creator_cbs_get_link_account(const LinphoneAccountCreatorCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user pointer to a #LinphoneAccountCreatorCbs object. |
|---|
| | | * @param[in] cbs #LinphoneAccountCreatorCbs object. |
|---|
| | | * @param[in] cb The link account request to be used. |
|---|
| | | * @param cbs #LinphoneAccountCreatorCbs object. @notnil |
|---|
| | | * @param cb The link account request to be used. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_account_creator_cbs_set_link_account(LinphoneAccountCreatorCbs *cbs, LinphoneAccountCreatorCbsStatusCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the activate alias request. |
|---|
| | | * @param[in] cbs #LinphoneAccountCreatorCbs object. |
|---|
| | | * @param cbs #LinphoneAccountCreatorCbs object. @notnil |
|---|
| | | * @return The current link account request. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneAccountCreatorCbsStatusCb linphone_account_creator_cbs_get_activate_alias(const LinphoneAccountCreatorCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user pointer to a #LinphoneAccountCreatorCbs object. |
|---|
| | | * @param[in] cbs #LinphoneAccountCreatorCbs object. |
|---|
| | | * @param[in] cb The activate alias request to be used. |
|---|
| | | * @param cbs #LinphoneAccountCreatorCbs object. @notnil |
|---|
| | | * @param cb The activate alias request to be used. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_account_creator_cbs_set_activate_alias(LinphoneAccountCreatorCbs *cbs, LinphoneAccountCreatorCbsStatusCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the is alias used request. |
|---|
| | | * @param[in] cbs #LinphoneAccountCreatorCbs object. |
|---|
| | | * @param cbs #LinphoneAccountCreatorCbs object. @notnil |
|---|
| | | * @return The current is alias used request. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneAccountCreatorCbsStatusCb linphone_account_creator_cbs_get_is_alias_used(const LinphoneAccountCreatorCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user pointer to a #LinphoneAccountCreatorCbs object. |
|---|
| | | * @param[in] cbs #LinphoneAccountCreatorCbs object. |
|---|
| | | * @param[in] cb The is alias used request to be used. |
|---|
| | | * @param cbs #LinphoneAccountCreatorCbs object. @notnil |
|---|
| | | * @param cb The is alias used request to be used. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_account_creator_cbs_set_is_alias_used(LinphoneAccountCreatorCbs *cbs, LinphoneAccountCreatorCbsStatusCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the is account linked request. |
|---|
| | | * @param[in] cbs #LinphoneAccountCreatorCbs object. |
|---|
| | | * @param cbs #LinphoneAccountCreatorCbs object. @notnil |
|---|
| | | * @return The current is account linked request. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneAccountCreatorCbsStatusCb linphone_account_creator_cbs_get_is_account_linked(const LinphoneAccountCreatorCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user pointer to a #LinphoneAccountCreatorCbs object. |
|---|
| | | * @param[in] cbs #LinphoneAccountCreatorCbs object. |
|---|
| | | * @param[in] cb The is account linked request to be used. |
|---|
| | | * @param cbs #LinphoneAccountCreatorCbs object. @notnil |
|---|
| | | * @param cb The is account linked request to be used. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_account_creator_cbs_set_is_account_linked(LinphoneAccountCreatorCbs *cbs, LinphoneAccountCreatorCbsStatusCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the recover account request. |
|---|
| | | * @param[in] cbs #LinphoneAccountCreatorCbs object. |
|---|
| | | * @param cbs #LinphoneAccountCreatorCbs object. @notnil |
|---|
| | | * @return The current recover account request. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneAccountCreatorCbsStatusCb linphone_account_creator_cbs_get_recover_account(const LinphoneAccountCreatorCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user pointer to a #LinphoneAccountCreatorCbs object. |
|---|
| | | * @param[in] cbs #LinphoneAccountCreatorCbs object. |
|---|
| | | * @param[in] cb The recover account request to be used. |
|---|
| | | * @param cbs #LinphoneAccountCreatorCbs object. @notnil |
|---|
| | | * @param cb The recover account request to be used. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_account_creator_cbs_set_recover_account(LinphoneAccountCreatorCbs *cbs, LinphoneAccountCreatorCbsStatusCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the update account request. |
|---|
| | | * @param[in] cbs #LinphoneAccountCreatorCbs object. |
|---|
| | | * @param cbs #LinphoneAccountCreatorCbs object. @notnil |
|---|
| | | * @return The current update account request. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneAccountCreatorCbsStatusCb linphone_account_creator_cbs_get_update_account(const LinphoneAccountCreatorCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user pointer to a #LinphoneAccountCreatorCbs object. |
|---|
| | | * @param[in] cbs #LinphoneAccountCreatorCbs object. |
|---|
| | | * @param[in] cb The update account request to be used. |
|---|
| | | * @param cbs #LinphoneAccountCreatorCbs object. @notnil |
|---|
| | | * @param cb The update account request to be used. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_account_creator_cbs_set_update_account(LinphoneAccountCreatorCbs *cbs, LinphoneAccountCreatorCbsStatusCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the login linphone account request. |
|---|
| | | * @param cbs #LinphoneAccountCreatorCbs object. @notnil |
|---|
| | | * @return The current login linphone account request. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneAccountCreatorCbsStatusCb linphone_account_creator_cbs_get_login_linphone_account(const LinphoneAccountCreatorCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user pointer to a #LinphoneAccountCreatorCbs object. |
|---|
| | | * @param cbs #LinphoneAccountCreatorCbs object. @notnil |
|---|
| | | * @param cb The login linphone account request to be used. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_account_creator_cbs_set_login_linphone_account(LinphoneAccountCreatorCbs *cbs, LinphoneAccountCreatorCbsStatusCb cb); |
|---|
| | | |
|---|
| | | /************************** End Account Creator Cbs **************************/ |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Create and configure a proxy config and a authentication info for an account creator |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object |
|---|
| | | * @return A #LinphoneProxyConfig object if successful, NULL otherwise |
|---|
| | | * @param creator #LinphoneAccountCreator object @notnil |
|---|
| | | * @return A #LinphoneProxyConfig object if successful, NULL otherwise. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneProxyConfig * linphone_account_creator_create_proxy_config(const LinphoneAccountCreator *creator); |
|---|
| | | |
|---|
| | | /************ */ |
|---|
| | | /* DEPRECATED */ |
|---|
| | | /* ********** */ |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the #LinphoneAccountCreatorCbs object associated with a LinphoneAccountCreator. |
|---|
| | | * @param creator #LinphoneAccountCreator object @notnil |
|---|
| | | * @return The #LinphoneAccountCreatorCbs object associated with the LinphoneAccountCreator. @maybenil |
|---|
| | | * @deprecated 19/02/2019 use add_callbacks / remove_callbacks instead |
|---|
| | | **/ |
|---|
| | | LINPHONE_DEPRECATED LINPHONE_PUBLIC LinphoneAccountCreatorCbs * linphone_account_creator_get_callbacks(const LinphoneAccountCreator *creator); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the route. |
|---|
| | | * @param creator #LinphoneAccountCreator object @notnil |
|---|
| | | * @param route The route to set @maybenil |
|---|
| | | * @return #LinphoneAccountCreatorStatusRequestOk if everything is OK, or a specific error otherwise. |
|---|
| | | **/ |
|---|
| | | LINPHONE_DEPRECATED LINPHONE_PUBLIC LinphoneAccountCreatorStatus linphone_account_creator_set_route(LinphoneAccountCreator *creator, const char *route); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the route. |
|---|
| | | * @param creator #LinphoneAccountCreator object @notnil |
|---|
| | | * @return The route of the #LinphoneAccountCreator. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_DEPRECATED LINPHONE_PUBLIC const char * linphone_account_creator_get_route(const LinphoneAccountCreator *creator); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Configure an account (create a proxy config and authentication info for it). |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object |
|---|
| | | * @return A #LinphoneProxyConfig object if successful, NULL otherwise |
|---|
| | | * @deprecated Use linphone_account_creator_create_proxy_config instead |
|---|
| | | * @param creator #LinphoneAccountCreator object @notnil |
|---|
| | | * @return A #LinphoneProxyConfig object if successful, NULL otherwise @maybenil |
|---|
| | | * @deprecated 13/04/2017 Use linphone_account_creator_create_proxy_config() instead |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | | LINPHONE_DEPRECATED LINPHONE_PUBLIC LinphoneProxyConfig * linphone_account_creator_configure(const LinphoneAccountCreator *creator); |
|---|
| | | |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Function to set custom server request. |
|---|
| | | * @param[in] creator #LinphoneAccountCreator object |
|---|
| | | * @param creator #LinphoneAccountCreator object |
|---|
| | | */ |
|---|
| | | typedef LinphoneAccountCreatorStatus (*LinphoneAccountCreatorRequestFunc)(LinphoneAccountCreator *creator); |
|---|
| | | |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Acquire a reference to a #LinphoneAccountCreatorService object. |
|---|
| | | * @param[in] service #LinphoneAccountCreatorService object. |
|---|
| | | * @param service #LinphoneAccountCreatorService object. |
|---|
| | | * @return The same #LinphoneAccountCreatorService object. |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Release a reference to a #LinphoneAccountCreatorService object. |
|---|
| | | * @param[in] service #LinphoneAccountCreatorService object. |
|---|
| | | * @param service #LinphoneAccountCreatorService object. |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | | void linphone_account_creator_service_unref(LinphoneAccountCreatorService *service); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Retrieve the user pointer associated with a #LinphoneAccountCreatorService object. |
|---|
| | | * @param[in] service #LinphoneAccountCreatorService object. |
|---|
| | | * @param service #LinphoneAccountCreatorService object. |
|---|
| | | * @return The user pointer associated with the #LinphoneAccountCreatorService object. |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user pointer to a #LinphoneAccountCreatorService object. |
|---|
| | | * @param[in] service #LinphoneAccountCreatorService object. |
|---|
| | | * @param[in] ud The user pointer to associate with the #LinphoneAccountCreatorService object. |
|---|
| | | * @param service #LinphoneAccountCreatorService object. |
|---|
| | | * @param ud The user pointer to associate with the #LinphoneAccountCreatorService object. |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_account_creator_service_set_user_data(LinphoneAccountCreatorService *service, void *ud); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user pointer to a #LinphoneAccountCreatorService object. |
|---|
| | | * @param[in] service #LinphoneAccountCreatorService object. |
|---|
| | | * @param[in] cb The constructor of account creator requests. |
|---|
| | | * @param service #LinphoneAccountCreatorService object. |
|---|
| | | * @param cb The constructor of account creator requests. |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_account_creator_service_set_constructor_cb(LinphoneAccountCreatorService *service, LinphoneAccountCreatorRequestFunc cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the constructor of account creator requests. |
|---|
| | | * @param[in] service #LinphoneAccountCreatorService object. |
|---|
| | | * @param service #LinphoneAccountCreatorService object. |
|---|
| | | * @return The current constructor of create account request. |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user pointer to a #LinphoneAccountCreatorService object. |
|---|
| | | * @param[in] service #LinphoneAccountCreatorService object. |
|---|
| | | * @param[in] cb The destructor. |
|---|
| | | * @param service #LinphoneAccountCreatorService object. |
|---|
| | | * @param cb The destructor. |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_account_creator_service_set_destructor_cb(LinphoneAccountCreatorService *service, LinphoneAccountCreatorRequestFunc cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the destructor of create account request. |
|---|
| | | * @param[in] service #LinphoneAccountCreatorService object. |
|---|
| | | * @param service #LinphoneAccountCreatorService object. |
|---|
| | | * @return The current destructor of create account request. |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the create account request. |
|---|
| | | * @param[in] service #LinphoneAccountCreatorService object. |
|---|
| | | * @param service #LinphoneAccountCreatorService object. |
|---|
| | | * @return The current create account request. |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user pointer to a #LinphoneAccountCreatorService object. |
|---|
| | | * @param[in] service #LinphoneAccountCreatorService object. |
|---|
| | | * @param[in] cb The create account request to be used. |
|---|
| | | * @param service #LinphoneAccountCreatorService object. |
|---|
| | | * @param cb The create account request to be used. |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_account_creator_service_set_create_account_cb(LinphoneAccountCreatorService *service, LinphoneAccountCreatorRequestFunc cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the is account exist request. |
|---|
| | | * @param[in] service #LinphoneAccountCreatorService object. |
|---|
| | | * @param service #LinphoneAccountCreatorService object. |
|---|
| | | * @return The current is account exist request. |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user pointer to a #LinphoneAccountCreatorService object. |
|---|
| | | * @param[in] service #LinphoneAccountCreatorService object. |
|---|
| | | * @param[in] cb The is account exist request to be used. |
|---|
| | | * @param service #LinphoneAccountCreatorService object. |
|---|
| | | * @param cb The is account exist request to be used. |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_account_creator_service_set_is_account_exist_cb(LinphoneAccountCreatorService *service, LinphoneAccountCreatorRequestFunc cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the activate account request. |
|---|
| | | * @param[in] service #LinphoneAccountCreatorService object. |
|---|
| | | * @param service #LinphoneAccountCreatorService object. |
|---|
| | | * @return The current activate account request. |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user pointer to a #LinphoneAccountCreatorService object. |
|---|
| | | * @param[in] service #LinphoneAccountCreatorService object. |
|---|
| | | * @param[in] cb The activate account request to be used. |
|---|
| | | * @param service #LinphoneAccountCreatorService object. |
|---|
| | | * @param cb The activate account request to be used. |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_account_creator_service_set_activate_account_cb(LinphoneAccountCreatorService *service, LinphoneAccountCreatorRequestFunc cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the is account activated request. |
|---|
| | | * @param[in] service #LinphoneAccountCreatorService object. |
|---|
| | | * @param service #LinphoneAccountCreatorService object. |
|---|
| | | * @return The current is account activated request. |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user pointer to a #LinphoneAccountCreatorService object. |
|---|
| | | * @param[in] service #LinphoneAccountCreatorService object. |
|---|
| | | * @param[in] cb The is account activated request to be used. |
|---|
| | | * @param service #LinphoneAccountCreatorService object. |
|---|
| | | * @param cb The is account activated request to be used. |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_account_creator_service_set_is_account_activated_cb(LinphoneAccountCreatorService *service, LinphoneAccountCreatorRequestFunc cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the link account request. |
|---|
| | | * @param[in] service #LinphoneAccountCreatorService object. |
|---|
| | | * @param service #LinphoneAccountCreatorService object. |
|---|
| | | * @return The current link account request. |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user pointer to a #LinphoneAccountCreatorService object. |
|---|
| | | * @param[in] service #LinphoneAccountCreatorService object. |
|---|
| | | * @param[in] cb The link account request to be used. |
|---|
| | | * @param service #LinphoneAccountCreatorService object. |
|---|
| | | * @param cb The link account request to be used. |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_account_creator_service_set_link_account_cb(LinphoneAccountCreatorService *service, LinphoneAccountCreatorRequestFunc cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the activate alias request. |
|---|
| | | * @param[in] service #LinphoneAccountCreatorService object. |
|---|
| | | * @param service #LinphoneAccountCreatorService object. |
|---|
| | | * @return The current link account request. |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user pointer to a #LinphoneAccountCreatorService object. |
|---|
| | | * @param[in] service #LinphoneAccountCreatorService object. |
|---|
| | | * @param[in] cb The activate alias request to be used. |
|---|
| | | * @param service #LinphoneAccountCreatorService object. |
|---|
| | | * @param cb The activate alias request to be used. |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_account_creator_service_set_activate_alias_cb(LinphoneAccountCreatorService *service, LinphoneAccountCreatorRequestFunc cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the is alias used request. |
|---|
| | | * @param[in] service #LinphoneAccountCreatorService object. |
|---|
| | | * @param service #LinphoneAccountCreatorService object. |
|---|
| | | * @return The current is alias used request. |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user pointer to a #LinphoneAccountCreatorService object. |
|---|
| | | * @param[in] service #LinphoneAccountCreatorService object. |
|---|
| | | * @param[in] cb The is alias used request to be used. |
|---|
| | | * @param service #LinphoneAccountCreatorService object. |
|---|
| | | * @param cb The is alias used request to be used. |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_account_creator_service_set_is_alias_used_cb(LinphoneAccountCreatorService *service, LinphoneAccountCreatorRequestFunc cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the is account linked request. |
|---|
| | | * @param[in] service #LinphoneAccountCreatorService object. |
|---|
| | | * @param service #LinphoneAccountCreatorService object. |
|---|
| | | * @return The current is account linked request. |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user pointer to a #LinphoneAccountCreatorService object. |
|---|
| | | * @param[in] service #LinphoneAccountCreatorService object. |
|---|
| | | * @param[in] cb The is account linked request to be used. |
|---|
| | | * @param service #LinphoneAccountCreatorService object. |
|---|
| | | * @param cb The is account linked request to be used. |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_account_creator_service_set_is_account_linked_cb(LinphoneAccountCreatorService *service, LinphoneAccountCreatorRequestFunc cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the recover account request. |
|---|
| | | * @param[in] service #LinphoneAccountCreatorService object. |
|---|
| | | * @param service #LinphoneAccountCreatorService object. |
|---|
| | | * @return The current recover account request. |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user pointer to a #LinphoneAccountCreatorService object. |
|---|
| | | * @param[in] service #LinphoneAccountCreatorService object. |
|---|
| | | * @param[in] cb The recover account request to be used. |
|---|
| | | * @param service #LinphoneAccountCreatorService object. |
|---|
| | | * @param cb The recover account request to be used. |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_account_creator_service_set_recover_account_cb(LinphoneAccountCreatorService *service, LinphoneAccountCreatorRequestFunc cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the update account request. |
|---|
| | | * @param[in] service #LinphoneAccountCreatorService object. |
|---|
| | | * @param service #LinphoneAccountCreatorService object. |
|---|
| | | * @return The current update account request. |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user pointer to a #LinphoneAccountCreatorService object. |
|---|
| | | * @param[in] service #LinphoneAccountCreatorService object. |
|---|
| | | * @param[in] cb The update account request to be used. |
|---|
| | | * @param service #LinphoneAccountCreatorService object. |
|---|
| | | * @param cb The update account request to be used. |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_account_creator_service_set_update_account_cb(LinphoneAccountCreatorService *service, LinphoneAccountCreatorRequestFunc cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the login linphone account request. |
|---|
| | | * @param service #LinphoneAccountCreatorService object. |
|---|
| | | * @return The current login linphone account request. |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneAccountCreatorRequestFunc linphone_account_creator_service_get_login_linphone_account_cb(const LinphoneAccountCreatorService *service); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user pointer to a #LinphoneAccountCreatorService object. |
|---|
| | | * @param service #LinphoneAccountCreatorService object. |
|---|
| | | * @param cb The login linphone account request to be used. |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_account_creator_service_set_login_linphone_account_cb(LinphoneAccountCreatorService *service, LinphoneAccountCreatorRequestFunc cb); |
|---|
| | | |
|---|
| | | /************************** End Account Creator Requests **************************/ |
|---|
| | | |
|---|
| | | #ifdef __cplusplus |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | /** |
|---|
| | | * Constructs a #LinphoneAddress object by parsing the user supplied address, |
|---|
| | | * given as a string. |
|---|
| | | * @param address an address to parse. @notnil |
|---|
| | | * @return a LinphoneAddress if parsing is successful, NULL otherwise. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneAddress *linphone_address_new (const char *address); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Clones a #LinphoneAddress object. |
|---|
| | | * @param address a #LinphoneAddress object to clone. @notnil |
|---|
| | | * @return a new #LinphoneAddress object. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneAddress *linphone_address_clone (const LinphoneAddress *address); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Increment reference count of #LinphoneAddress object. |
|---|
| | | * @param address a #LinphoneAddress object. @notnil |
|---|
| | | * @return the same #LinphoneAddress object. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneAddress *linphone_address_ref (LinphoneAddress *address); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Decrement reference count of #LinphoneAddress object. When dropped to zero, memory is freed. |
|---|
| | | * @param address a #LinphoneAddress object. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_address_unref (LinphoneAddress *address); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the address scheme, normally "sip". |
|---|
| | | * @param address a #LinphoneAddress object. @notnil |
|---|
| | | * @return the scheme if any, NULL otherwise. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_address_get_scheme (const LinphoneAddress *address); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the display name. |
|---|
| | | * @param address a #LinphoneAddress object. @notnil |
|---|
| | | * @return the display name if any, NULL otherwise. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_address_get_display_name (const LinphoneAddress *address); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the display name. |
|---|
| | | * @param address a #LinphoneAddress object. @notnil |
|---|
| | | * @param display_name the display name to set. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_address_set_display_name (LinphoneAddress *address, const char *display_name); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the username. |
|---|
| | | * @param address a #LinphoneAddress object. @notnil |
|---|
| | | * @return the username name if any, NULL otherwise. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_address_get_username (const LinphoneAddress *address); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the username. |
|---|
| | | * @param address a #LinphoneAddress object. @notnil |
|---|
| | | * @param username the username to set. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_address_set_username (LinphoneAddress *address, const char *username); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the domain name. |
|---|
| | | * @param address a #LinphoneAddress object. @notnil |
|---|
| | | * @return the domain name if any, NULL otherwise. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_address_get_domain (const LinphoneAddress *address); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the domain. |
|---|
| | | * @param address a #LinphoneAddress object. @notnil |
|---|
| | | * @param domain the domain to set. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_address_set_domain (LinphoneAddress *address, const char *domain); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get port number as an integer value, 0 if not present. |
|---|
| | | * @param address a #LinphoneAddress object. @notnil |
|---|
| | | * @return the port set in the address or 0 if not present. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC int linphone_address_get_port (const LinphoneAddress *address); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the port number. |
|---|
| | | * @param address a #LinphoneAddress object. @notnil |
|---|
| | | * @param port the port to set in the address |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_address_set_port (LinphoneAddress *address, int port); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the transport. |
|---|
| | | * @param address a #LinphoneAddress object. @notnil |
|---|
| | | * @return a #LinphoneTransportType, default value if not set is UDP. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneTransportType linphone_address_get_transport (const LinphoneAddress *address); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set a transport. |
|---|
| | | * @param address a #LinphoneAddress object. @notnil |
|---|
| | | * @param transport a #LinphoneTransportType |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_address_set_transport (LinphoneAddress *address, LinphoneTransportType transport); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns true if address refers to a secure location (sips) |
|---|
| | | * Returns whether the address refers to a secure location (sips) or not |
|---|
| | | * @param address a #LinphoneAddress object. @notnil |
|---|
| | | * @return TRUE if address refers to a secure location, FALSE otherwise |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_address_get_secure (const LinphoneAddress *address); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Make the address refer to a secure location (sips scheme) |
|---|
| | | * @param[in] address A #LinphoneAddress object |
|---|
| | | * @param[in] enabled TRUE if address is requested to be secure. |
|---|
| | | * @param address A #LinphoneAddress object. @notnil |
|---|
| | | * @param enabled TRUE if address is requested to be secure. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_address_set_secure (LinphoneAddress *address, bool_t enabled); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * returns true if address is a routable sip address |
|---|
| | | * returns whether the address is a routable SIP address or not |
|---|
| | | * @param address a #LinphoneAddress object. @notnil |
|---|
| | | * @return TRUE if it is a routable SIP address, FALSE otherwise |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_address_is_sip (const LinphoneAddress *address); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the value of the method parameter |
|---|
| | | * @param address a #LinphoneAddress object. @notnil |
|---|
| | | * @return the value of the parameter or NULL. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_address_get_method_param (const LinphoneAddress *address); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the value of the method parameter |
|---|
| | | * @param address a #LinphoneAddress object. @notnil |
|---|
| | | * @param method_param the value to set to the method parameter. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_address_set_method_param (LinphoneAddress *address, const char *method_param); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the password encoded in the address. |
|---|
| | | * It is used for basic authentication (not recommended). |
|---|
| | | * @param address the address |
|---|
| | | * @return the password, if any, NULL otherwise. |
|---|
| | | * @param address a #LinphoneAddress object. @notnil |
|---|
| | | * @return the password if any, NULL otherwise. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_address_get_password (const LinphoneAddress *address); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the password encoded in the address. |
|---|
| | | * It is used for basic authentication (not recommended). |
|---|
| | | * @param address the #LinphoneAddress |
|---|
| | | * @param password the password to set. |
|---|
| | | * @param address a #LinphoneAddress object. @notnil |
|---|
| | | * @param password the password to set. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_address_set_password (LinphoneAddress *address, const char *password); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Removes address's tags and uri headers so that it is displayable to the user. |
|---|
| | | * @param address a #LinphoneAddress object. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_address_clean (LinphoneAddress *address); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the address as a string. |
|---|
| | | * The returned char * must be freed by the application. Use ms_free(). |
|---|
| | | * @param address a #LinphoneAddress object. @notnil |
|---|
| | | * @return a string representation of the address. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC char *linphone_address_as_string (const LinphoneAddress *address); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the SIP uri only as a string, that is display name is removed. |
|---|
| | | * The returned char * must be freed by the application. Use ms_free(). |
|---|
| | | * @param address a #LinphoneAddress object. @notnil |
|---|
| | | * @return a string representation of the address. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC char *linphone_address_as_string_uri_only (const LinphoneAddress *address); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Compare two #LinphoneAddress ignoring tags and headers, basically just domain, username, and port. |
|---|
| | | * @param[in] address1 #LinphoneAddress object |
|---|
| | | * @param[in] address2 #LinphoneAddress object |
|---|
| | | * @param address1 #LinphoneAddress object. @notnil |
|---|
| | | * @param address2 #LinphoneAddress object. @notnil |
|---|
| | | * @return Boolean value telling if the #LinphoneAddress objects are equal. |
|---|
| | | * @see linphone_address_equal() |
|---|
| | | **/ |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Compare two #LinphoneAddress taking the tags and headers into account. |
|---|
| | | * @param[in] address1 #LinphoneAddress object |
|---|
| | | * @param[in] address2 #LinphoneAddress object |
|---|
| | | * @param address1 #LinphoneAddress object. @notnil |
|---|
| | | * @param address2 #LinphoneAddress object. @notnil |
|---|
| | | * @return Boolean value telling if the #LinphoneAddress objects are equal. |
|---|
| | | * @see linphone_address_weak_equal() |
|---|
| | | */ |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the header encoded in the address. |
|---|
| | | * @param header_name the header name |
|---|
| | | * @param address a #LinphoneAddress object. @notnil |
|---|
| | | * @param header_name the header name. @notnil |
|---|
| | | * @return the header value or NULL if it doesn't exists. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_address_get_header (const LinphoneAddress *address, const char *header_name); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set a header into the address. |
|---|
| | | * Headers appear in the URI with '?', such as \<sip:test@linphone.org?SomeHeader=SomeValue\>. |
|---|
| | | * @param address the address |
|---|
| | | * @param header_name the header name |
|---|
| | | * @param header_value the header value |
|---|
| | | * @param address a #LinphoneAddress object. @notnil |
|---|
| | | * @param header_name the header name. @notnil |
|---|
| | | * @param header_value the header value. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_address_set_header (LinphoneAddress *address, const char *header_name, const char *header_value); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Tell whether a parameter is present in the address |
|---|
| | | * @param[in] address #LinphoneAddress object |
|---|
| | | * @param[in] param_name The name of the parameter |
|---|
| | | * @param address a #LinphoneAddress object. @notnil |
|---|
| | | * @param param_name The name of the parameter. @notnil |
|---|
| | | * @return A boolean value telling whether the parameter is present in the address |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_address_has_param (const LinphoneAddress *address, const char *param_name); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the value of a parameter of the address |
|---|
| | | * @param[in] address #LinphoneAddress object |
|---|
| | | * @param[in] param_name The name of the parameter |
|---|
| | | * @return The value of the parameter |
|---|
| | | * @param address a #LinphoneAddress object. @notnil |
|---|
| | | * @param param_name The name of the parameter. @notnil |
|---|
| | | * @return The value of the parameter or NULL if it doesn't exists. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_address_get_param (const LinphoneAddress *address, const char *param_name); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the value of a parameter of the address |
|---|
| | | * @param[in] address #LinphoneAddress object |
|---|
| | | * @param[in] param_name The name of the parameter |
|---|
| | | * @param[in] param_value The new value of the parameter |
|---|
| | | * @param address a #LinphoneAddress object. @notnil |
|---|
| | | * @param param_name The name of the parameter. @notnil |
|---|
| | | * @param param_value The new value of the parameter. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_address_set_param (LinphoneAddress *address, const char *param_name, const char *param_value); |
|---|
| | | |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Tell whether a parameter is present in the URI of the address |
|---|
| | | * @param[in] address #LinphoneAddress object |
|---|
| | | * @param[in] uri_param_name The name of the parameter |
|---|
| | | * @param address a #LinphoneAddress object. @notnil |
|---|
| | | * @param uri_param_name The name of the parameter. @notnil |
|---|
| | | * @return A boolean value telling whether the parameter is present in the URI of the address |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_address_has_uri_param (const LinphoneAddress *address, const char *uri_param_name); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the value of a parameter of the URI of the address |
|---|
| | | * @param[in] address #LinphoneAddress object |
|---|
| | | * @param[in] uri_param_name The name of the parameter |
|---|
| | | * @return The value of the parameter |
|---|
| | | * @param address a #LinphoneAddress object. @notnil |
|---|
| | | * @param uri_param_name The name of the parameter. @notnil |
|---|
| | | * @return The value of the parameter or NULL if it doesn't exists. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_address_get_uri_param (const LinphoneAddress *address, const char *uri_param_name); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the value of a parameter of the URI of the address |
|---|
| | | * @param[in] address #LinphoneAddress object |
|---|
| | | * @param[in] uri_param_name The name of the parameter |
|---|
| | | * @param[in] uri_param_value The new value of the parameter |
|---|
| | | * @param address a #LinphoneAddress object. @notnil |
|---|
| | | * @param uri_param_name The name of the parameter. @notnil |
|---|
| | | * @param uri_param_value The new value of the parameter. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_address_set_uri_param (LinphoneAddress *address, const char *uri_param_name, const char *uri_param_value); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the value of the parameters of the URI of the address |
|---|
| | | * @param[in] address #LinphoneAddress object |
|---|
| | | * @param[in] params The parameters string |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_address_set_uri_params (LinphoneAddress *address, const char *params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Removes the value of a parameter of the URI of the address |
|---|
| | | * @param[in] address #LinphoneAddress object |
|---|
| | | * @param[in] uri_param_name The name of the parameter |
|---|
| | | * @param address a #LinphoneAddress object. @notnil |
|---|
| | | * @param uri_param_name The name of the parameter. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_address_remove_uri_param (LinphoneAddress *address, const char *uri_param_name); |
|---|
| | | |
|---|
| | | /************ */ |
|---|
| | | /* DEPRECATED */ |
|---|
| | | /* ********** */ |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Destroys a #LinphoneAddress object (actually calls linphone_address_unref()). |
|---|
| | | * @deprecated Use linphone_address_unref() instead |
|---|
| | | * @deprecated 04/09/17 Use linphone_address_unref() instead |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | | LINPHONE_DEPRECATED LINPHONE_PUBLIC void linphone_address_destroy (LinphoneAddress *address); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns true if address refers to a secure location (sips) |
|---|
| | | * @deprecated use linphone_address_get_secure() |
|---|
| | | * @deprecated 04/09/17 use linphone_address_get_secure() |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | | LINPHONE_DEPRECATED LINPHONE_PUBLIC bool_t linphone_address_is_secure (const LinphoneAddress *address); |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | |
|---|
| | | #include "linphone/utils/general.h" |
|---|
| | | |
|---|
| | | #include "linphone/api/c-audio-device.h" |
|---|
| | | #include "linphone/api/c-auth-info.h" |
|---|
| | | #include "linphone/api/c-address.h" |
|---|
| | | #include "linphone/api/c-call-cbs.h" |
|---|
| | |
|---|
| | | #include "linphone/api/c-chat-message.h" |
|---|
| | | #include "linphone/api/c-chat-room-cbs.h" |
|---|
| | | #include "linphone/api/c-chat-room.h" |
|---|
| | | #include "linphone/api/c-conference.h" |
|---|
| | | #include "linphone/api/c-conference-cbs.h" |
|---|
| | | #include "linphone/api/c-content.h" |
|---|
| | | #include "linphone/api/c-dial-plan.h" |
|---|
| | | #include "linphone/api/c-event-log.h" |
|---|
| | |
|---|
| | | #include "linphone/api/c-participant.h" |
|---|
| | | #include "linphone/api/c-participant-device.h" |
|---|
| | | #include "linphone/api/c-participant-device-identity.h" |
|---|
| | | #include "linphone/api/c-push-notification-message.h" |
|---|
| | | #include "linphone/api/c-search-result.h" |
|---|
| | | #include "linphone/api/c-types.h" |
|---|
| | | |
|---|
| New file |
| | |
|---|
| | | /* |
|---|
| | | * Copyright (c) 2010-2020 Belledonne Communications SARL. |
|---|
| | | * |
|---|
| | | * This file is part of Liblinphone. |
|---|
| | | * |
|---|
| | | * 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 3 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, see <http://www.gnu.org/licenses/>. |
|---|
| | | */ |
|---|
| | | |
|---|
| | | #ifndef LINPHONE_AUDIO_DEVICE_H |
|---|
| | | #define LINPHONE_AUDIO_DEVICE_H |
|---|
| | | |
|---|
| | | #include "linphone/api/c-types.h" |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @addtogroup audio |
|---|
| | | * @{ |
|---|
| | | */ |
|---|
| | | |
|---|
| | | #ifdef __cplusplus |
|---|
| | | extern "C" { |
|---|
| | | #endif |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the id of the audio device |
|---|
| | | * @param audio_device the #LinphoneAudioDevice. @notnil |
|---|
| | | * @return the id of the audio device. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_audio_device_get_id(const LinphoneAudioDevice *audio_device); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the name of the audio device |
|---|
| | | * @param audio_device the #LinphoneAudioDevice. @notnil |
|---|
| | | * @return the name of the audio device. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_audio_device_get_device_name(const LinphoneAudioDevice *audio_device); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the driver name used by the device |
|---|
| | | * @param audio_device the #LinphoneAudioDevice. @notnil |
|---|
| | | * @returns the name of the driver used by this audio device. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_audio_device_get_driver_name(const LinphoneAudioDevice *audio_device); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the capabilities of the device |
|---|
| | | * @param audio_device the #LinphoneAudioDevice. @notnil |
|---|
| | | * @returns the #LinphoneAudioDeviceCapabilities of the audio device (RECORD, PLAY or both) as a bit mask |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneAudioDeviceCapabilities linphone_audio_device_get_capabilities(const LinphoneAudioDevice *audio_device); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the type of the device |
|---|
| | | * @param audio_device the #LinphoneAudioDevice. @notnil |
|---|
| | | * @returns the #LinphoneAudioDeviceType of the audio device (microphone, speaker, earpiece, bluetooth, etc...) |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneAudioDeviceType linphone_audio_device_get_type(const LinphoneAudioDevice *audio_device); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns whether or not the audio device has the given capability |
|---|
| | | * @param audio_device the #LinphoneAudioDevice. @notnil |
|---|
| | | * @param capability the #LinphoneAudioDeviceCapabilities to check |
|---|
| | | * @returns TRUE if the audio device has the capability, FALSE otherwise |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_audio_device_has_capability(const LinphoneAudioDevice *audio_device, const LinphoneAudioDeviceCapabilities capability); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Takes a reference on a #LinphoneAudioDevice. |
|---|
| | | * @param audio_device the #LinphoneAudioDevice. @notnil |
|---|
| | | * @return the same #LinphoneAudioDevice object |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneAudioDevice *linphone_audio_device_ref(LinphoneAudioDevice *audio_device); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Releases a #LinphoneAudioDevice. |
|---|
| | | * @param audio_device the #LinphoneAudioDevice. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_audio_device_unref(LinphoneAudioDevice *audio_device); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @} |
|---|
| | | */ |
|---|
| | | |
|---|
| | | #ifdef __cplusplus |
|---|
| | | } |
|---|
| | | #endif |
|---|
| | | |
|---|
| | | #endif |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | /* |
|---|
| | | * Copyright (c) 2010-2019 Belledonne Communications SARL. |
|---|
| | | * Copyright (c) 2010-2020 Belledonne Communications SARL. |
|---|
| | | * |
|---|
| | | * This file is part of Liblinphone. |
|---|
| | | * |
|---|
| | |
|---|
| | | const char *userid, |
|---|
| | | const char *passwd, |
|---|
| | | const char *ha1, |
|---|
| | | const char *rfealm, |
|---|
| | | const char *realm, |
|---|
| | | const char *domain); |
|---|
| | | |
|---|
| | | LINPHONE_PUBLIC LinphoneAuthInfo *linphone_auth_info_new_for_algorithm( |
|---|
| | |
|---|
| | | const char *realm, |
|---|
| | | const char *domain, |
|---|
| | | const char *algorithm); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Instantiates a new auth info with values from source. |
|---|
| | | * @param[in] source The #LinphoneAuthInfo object to be cloned |
|---|
| | | * @return The newly created #LinphoneAuthInfo object. |
|---|
| | | * @param auth_info The #LinphoneAuthInfo object to be cloned. @notnil |
|---|
| | | * @return The newly created #LinphoneAuthInfo object. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneAuthInfo *linphone_auth_info_clone(const LinphoneAuthInfo *source); |
|---|
| | | LINPHONE_PUBLIC LinphoneAuthInfo *linphone_auth_info_clone(const LinphoneAuthInfo *auth_info); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Take a reference on a #LinphoneAuthInfo. |
|---|
| | | * @param auth_info The #LinphoneAuthInfo object. @notnil |
|---|
| | | * @return the same #LinphoneAuthInfo object. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneAuthInfo *linphone_auth_info_ref(LinphoneAuthInfo *info); |
|---|
| | | LINPHONE_PUBLIC LinphoneAuthInfo *linphone_auth_info_ref(LinphoneAuthInfo *auth_info); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Release a #LinphoneAuthInfo. |
|---|
| | | * @param auth_info The #LinphoneAuthInfo object. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_auth_info_unref(LinphoneAuthInfo *info); |
|---|
| | | LINPHONE_PUBLIC void linphone_auth_info_unref(LinphoneAuthInfo *auth_info); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the password. |
|---|
| | | * @param[in] info The #LinphoneAuthInfo object |
|---|
| | | * @param[in] passwd The password. |
|---|
| | | * @deprecated, use linphone_auth_info_set_password instead |
|---|
| | | * @param auth_info The #LinphoneAuthInfo object. @notnil |
|---|
| | | * @param password The password. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_auth_info_set_passwd(LinphoneAuthInfo *info, const char *passwd); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the password. |
|---|
| | | * @param[in] info The #LinphoneAuthInfo object |
|---|
| | | * @param[in] passwd The password. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_auth_info_set_password(LinphoneAuthInfo *info, const char *passwd); |
|---|
| | | LINPHONE_PUBLIC void linphone_auth_info_set_password(LinphoneAuthInfo *auth_info, const char *password); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the username. |
|---|
| | | * @param[in] info The #LinphoneAuthInfo object |
|---|
| | | * @param[in] username The username. |
|---|
| | | * @param auth_info The #LinphoneAuthInfo object. @notnil |
|---|
| | | * @param username The username. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_auth_info_set_username(LinphoneAuthInfo *info, const char *username); |
|---|
| | | LINPHONE_PUBLIC void linphone_auth_info_set_username(LinphoneAuthInfo *auth_info, const char *username); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the algorithm. |
|---|
| | | * @param[in] info The #LinphoneAuthInfo object |
|---|
| | | * @param[in] algorithm The algorithm. |
|---|
| | | * Sets the algorithm to use. |
|---|
| | | * @param auth_info The #LinphoneAuthInfo object. @notnil |
|---|
| | | * @param algorithm The algorithm. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_auth_info_set_algorithm(LinphoneAuthInfo *info, const char *algorithm); |
|---|
| | | LINPHONE_PUBLIC void linphone_auth_info_set_algorithm(LinphoneAuthInfo *auth_info, const char *algorithm); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the userid. |
|---|
| | | * @param[in] info The #LinphoneAuthInfo object |
|---|
| | | * @param[in] userid The userid. |
|---|
| | | * Sets the available algorithms list without testing unicity |
|---|
| | | * @param auth_info The #LinphoneAuthInfo object. @notnil |
|---|
| | | * @param algorithms The available algorithms list. @bctbx_list{const char *} @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_auth_info_set_available_algorithms(LinphoneAuthInfo *auth_info, const bctbx_list_t *algorithms); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Add an unique algorithm in the the available algorithms list : Algorithms that already exist will not be added. |
|---|
| | | * @param auth_info The #LinphoneAuthInfo object. @notnil |
|---|
| | | * @param algorithm The algorithm to add. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_auth_info_set_userid(LinphoneAuthInfo *info, const char *userid); |
|---|
| | | LINPHONE_PUBLIC void linphone_auth_info_add_available_algorithm(LinphoneAuthInfo *auth_info, const char *algorithm); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the user ID. |
|---|
| | | * @param auth_info The #LinphoneAuthInfo object. @notnil |
|---|
| | | * @param user_id The userid.@maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_auth_info_set_userid(LinphoneAuthInfo *auth_info, const char *user_id); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the realm. |
|---|
| | | * @param[in] info The #LinphoneAuthInfo object |
|---|
| | | * @param[in] realm The realm. |
|---|
| | | * @param auth_info The #LinphoneAuthInfo object. @notnil |
|---|
| | | * @param realm The realm. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_auth_info_set_realm(LinphoneAuthInfo *info, const char *realm); |
|---|
| | | LINPHONE_PUBLIC void linphone_auth_info_set_realm(LinphoneAuthInfo *auth_info, const char *realm); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the domain for which this authentication is valid. |
|---|
| | | * @param[in] info The #LinphoneAuthInfo object |
|---|
| | | * @param[in] domain The domain. |
|---|
| | | * @param auth_info The #LinphoneAuthInfo object. @notnil |
|---|
| | | * @param domain The domain. @maybenil |
|---|
| | | * This should not be necessary because realm is supposed to be unique and sufficient. |
|---|
| | | * However, many SIP servers don't set realm correctly, then domain has to be used to distinguish between several SIP account bearing the same username. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_auth_info_set_domain(LinphoneAuthInfo *info, const char *domain); |
|---|
| | | LINPHONE_PUBLIC void linphone_auth_info_set_domain(LinphoneAuthInfo *auth_info, const char *domain); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the ha1. |
|---|
| | | * @param[in] info The #LinphoneAuthInfo object |
|---|
| | | * @param[in] ha1 The ha1. |
|---|
| | | * @param auth_info The #LinphoneAuthInfo object. @notnil |
|---|
| | | * @param ha1 The ha1. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_auth_info_set_ha1(LinphoneAuthInfo *info, const char *ha1); |
|---|
| | | LINPHONE_PUBLIC void linphone_auth_info_set_ha1(LinphoneAuthInfo *auth_info, const char *ha1); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the TLS certificate. |
|---|
| | | * @param[in] info The #LinphoneAuthInfo object |
|---|
| | | * @param[in] tls_cert The TLS certificate. |
|---|
| | | * @param auth_info The #LinphoneAuthInfo object. @notnil |
|---|
| | | * @param tls_cert The TLS certificate. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_auth_info_set_tls_cert(LinphoneAuthInfo *info, const char *tls_cert); |
|---|
| | | LINPHONE_PUBLIC void linphone_auth_info_set_tls_cert(LinphoneAuthInfo *auth_info, const char *tls_cert); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the TLS key. |
|---|
| | | * @param[in] info The #LinphoneAuthInfo object |
|---|
| | | * @param[in] tls_key The TLS key. |
|---|
| | | * @param auth_info The #LinphoneAuthInfo object. @notnil |
|---|
| | | * @param tls_key The TLS key. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_auth_info_set_tls_key(LinphoneAuthInfo *info, const char *tls_key); |
|---|
| | | LINPHONE_PUBLIC void linphone_auth_info_set_tls_key(LinphoneAuthInfo *auth_info, const char *tls_key); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the TLS certificate path. |
|---|
| | | * @param[in] info The #LinphoneAuthInfo object |
|---|
| | | * @param[in] tls_cert_path The TLS certificate path. |
|---|
| | | * @param auth_info The #LinphoneAuthInfo object. @notnil |
|---|
| | | * @param tls_cert_path The TLS certificate path. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_auth_info_set_tls_cert_path(LinphoneAuthInfo *info, const char *tls_cert_path); |
|---|
| | | LINPHONE_PUBLIC void linphone_auth_info_set_tls_cert_path(LinphoneAuthInfo *auth_info, const char *tls_cert_path); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the TLS key path. |
|---|
| | | * @param[in] info The #LinphoneAuthInfo object |
|---|
| | | * @param[in] tls_key_path The TLS key path. |
|---|
| | | * @param auth_info The #LinphoneAuthInfo object. @notnil |
|---|
| | | * @param tls_key_path The TLS key path. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_auth_info_set_tls_key_path(LinphoneAuthInfo *info, const char *tls_key_path); |
|---|
| | | LINPHONE_PUBLIC void linphone_auth_info_set_tls_key_path(LinphoneAuthInfo *auth_info, const char *tls_key_path); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Remove all algorithms from the available algorithms list. |
|---|
| | | * @param auth_info The #LinphoneAuthInfo object. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_auth_info_clear_available_algorithms(LinphoneAuthInfo *auth_info); |
|---|
| | | |
|---|
| | | /* |
|---|
| | | * Sets the TLS key password, this is only usefull is the TLS key is encrypted. |
|---|
| | | * @param auth_info The #LinphoneAuthInfo object. @notnil |
|---|
| | | * @param tls_key_password The TLS key password. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_auth_info_set_tls_key_password(LinphoneAuthInfo *auth_info, const char *tls_key_password); |
|---|
| | | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the username. |
|---|
| | | * @param[in] info The #LinphoneAuthInfo object |
|---|
| | | * @return The username. |
|---|
| | | * @param auth_info The #LinphoneAuthInfo object. @notnil |
|---|
| | | * @return The username. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_auth_info_get_username(const LinphoneAuthInfo *info); |
|---|
| | | LINPHONE_PUBLIC const char *linphone_auth_info_get_username(const LinphoneAuthInfo *auth_info); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the algorithm. |
|---|
| | | * @param[in] info The #LinphoneAuthInfo object |
|---|
| | | * @return The algorithm. |
|---|
| | | * @param auth_info The #LinphoneAuthInfo object. @notnil |
|---|
| | | * @return The algorithm. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_auth_info_get_algorithm(const LinphoneAuthInfo *info); |
|---|
| | | LINPHONE_PUBLIC const char *linphone_auth_info_get_algorithm(const LinphoneAuthInfo *auth_info); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets all available algorithms. |
|---|
| | | * @param auth_info The #LinphoneAuthInfo object. @notnil |
|---|
| | | * @return A list of available algorithms. @bctbx_list{const char *} @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bctbx_list_t * linphone_auth_info_get_available_algorithms(const LinphoneAuthInfo *auth_info); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the password. |
|---|
| | | * @param[in] info The #LinphoneAuthInfo object |
|---|
| | | * @return The password. |
|---|
| | | * @deprecated, use linphone_auth_info_get_password instead |
|---|
| | | * @param auth_info The #LinphoneAuthInfo object. @notnil |
|---|
| | | * @return The password. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_auth_info_get_passwd(const LinphoneAuthInfo *info); |
|---|
| | | LINPHONE_PUBLIC const char *linphone_auth_info_get_password(const LinphoneAuthInfo *auth_info); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the password. |
|---|
| | | * @param[in] info The #LinphoneAuthInfo object |
|---|
| | | * @return The password. |
|---|
| | | * Gets the user id. |
|---|
| | | * @param auth_info The #LinphoneAuthInfo object. @notnil |
|---|
| | | * @return The user id. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_auth_info_get_password(const LinphoneAuthInfo *info); |
|---|
| | | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the userid. |
|---|
| | | * @param[in] info The #LinphoneAuthInfo object |
|---|
| | | * @return The userid. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_auth_info_get_userid(const LinphoneAuthInfo *info); |
|---|
| | | LINPHONE_PUBLIC const char *linphone_auth_info_get_userid(const LinphoneAuthInfo *auth_info); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the realm. |
|---|
| | | * @param[in] info The #LinphoneAuthInfo object |
|---|
| | | * @return The realm. |
|---|
| | | * @param auth_info The #LinphoneAuthInfo object. @notnil |
|---|
| | | * @return The realm. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_auth_info_get_realm(const LinphoneAuthInfo *info); |
|---|
| | | LINPHONE_PUBLIC const char *linphone_auth_info_get_realm(const LinphoneAuthInfo *auth_info); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the domain. |
|---|
| | | * @param[in] info The #LinphoneAuthInfo object |
|---|
| | | * @return The domain. |
|---|
| | | * @param auth_info The #LinphoneAuthInfo object. @notnil |
|---|
| | | * @return The domain. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_auth_info_get_domain(const LinphoneAuthInfo *info); |
|---|
| | | LINPHONE_PUBLIC const char *linphone_auth_info_get_domain(const LinphoneAuthInfo *auth_info); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the ha1. |
|---|
| | | * @param[in] info The #LinphoneAuthInfo object |
|---|
| | | * @return The ha1. |
|---|
| | | * @param auth_info The #LinphoneAuthInfo object. @notnil |
|---|
| | | * @return The ha1. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_auth_info_get_ha1(const LinphoneAuthInfo *info); |
|---|
| | | LINPHONE_PUBLIC const char *linphone_auth_info_get_ha1(const LinphoneAuthInfo *auth_info); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the TLS certificate. |
|---|
| | | * @param[in] info The #LinphoneAuthInfo object |
|---|
| | | * @return The TLS certificate. |
|---|
| | | * @param auth_info The #LinphoneAuthInfo object. @notnil |
|---|
| | | * @return The TLS certificate. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_auth_info_get_tls_cert(const LinphoneAuthInfo *info); |
|---|
| | | LINPHONE_PUBLIC const char *linphone_auth_info_get_tls_cert(const LinphoneAuthInfo *auth_info); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the TLS key. |
|---|
| | | * @param[in] info The #LinphoneAuthInfo object |
|---|
| | | * @return The TLS key. |
|---|
| | | * @param auth_info The #LinphoneAuthInfo object. @notnil |
|---|
| | | * @return The TLS key. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_auth_info_get_tls_key(const LinphoneAuthInfo *info); |
|---|
| | | LINPHONE_PUBLIC const char *linphone_auth_info_get_tls_key(const LinphoneAuthInfo *auth_info); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the TLS certificate path. |
|---|
| | | * @param[in] info The #LinphoneAuthInfo object |
|---|
| | | * @return The TLS certificate path. |
|---|
| | | * @param auth_info The #LinphoneAuthInfo object. @notnil |
|---|
| | | * @return The TLS certificate path. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_auth_info_get_tls_cert_path(const LinphoneAuthInfo *info); |
|---|
| | | LINPHONE_PUBLIC const char *linphone_auth_info_get_tls_cert_path(const LinphoneAuthInfo *auth_info); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the TLS key path. |
|---|
| | | * @param[in] info The #LinphoneAuthInfo object |
|---|
| | | * @return The TLS key path. |
|---|
| | | * @param auth_info The #LinphoneAuthInfo object. @notnil |
|---|
| | | * @return The TLS key path. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_auth_info_get_tls_key_path(const LinphoneAuthInfo *info); |
|---|
| | | LINPHONE_PUBLIC const char *linphone_auth_info_get_tls_key_path(const LinphoneAuthInfo *auth_info); |
|---|
| | | |
|---|
| | | /* |
|---|
| | | * Gets the TLS key password. |
|---|
| | | * @param auth_info The #LinphoneAuthInfo object. @notnil |
|---|
| | | * @return The TLS key password. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_auth_info_get_tls_key_password(const LinphoneAuthInfo *auth_info); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Check if Authinfos are the same without taking account algorithms |
|---|
| | | * @param auth_info_1 The first #LinphoneAuthInfo object. @maybenil |
|---|
| | | * @param auth_info_2 The second #LinphoneAuthInfo object. @maybenil |
|---|
| | | * @return TRUE if all fields (Username, UserId, Realm, Domain) are the same. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_auth_info_is_equal_but_algorithms(const LinphoneAuthInfo *auth_info_1,const LinphoneAuthInfo *auth_info_2); |
|---|
| | | |
|---|
| | | /* you don't need those function*/ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED void linphone_auth_info_destroy(LinphoneAuthInfo *info); |
|---|
| | | |
|---|
| | | void linphone_auth_info_write_config(LpConfig *config, LinphoneAuthInfo *obj, int pos); |
|---|
| | | void linphone_auth_info_write_config(LpConfig *config, LinphoneAuthInfo *auth_info, int pos); |
|---|
| | | |
|---|
| | | LinphoneAuthInfo *linphone_auth_info_new_from_config_file(LpConfig *config, int pos); |
|---|
| | | |
|---|
| | | /************ */ |
|---|
| | | /* DEPRECATED */ |
|---|
| | | /* ********** */ |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the password. |
|---|
| | | * @param auth_info The #LinphoneAuthInfo object. @notnil |
|---|
| | | * @param passwd The password. |
|---|
| | | * @deprecated 13/10/2017 use linphone_auth_info_set_password instead |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED void linphone_auth_info_set_passwd(LinphoneAuthInfo *auth_info, const char *passwd); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the password. |
|---|
| | | * @param auth_info The #LinphoneAuthInfo object. @notnil |
|---|
| | | * @return The password. |
|---|
| | | * @deprecated 13/10/2017 use linphone_auth_info_get_password instead |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED const char *linphone_auth_info_get_passwd(const LinphoneAuthInfo *auth_info); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Destroys the auth info |
|---|
| | | * @param auth_info The #LinphoneAuthInfo object. @notnil |
|---|
| | | * @deprecated 13/10/2017 use linphone_auth_info_unref() instead |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED void linphone_auth_info_destroy(LinphoneAuthInfo *auth_info); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @} |
|---|
| | |
|---|
| | | } |
|---|
| | | #endif |
|---|
| | | |
|---|
| | | #endif /* LINPHONE_AUTH_INFO_H */ |
|---|
| | | #endif /* LINPHONE_AUTH_INFO_H */ |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Acquire a reference to the #LinphoneCallCbs object. |
|---|
| | | * @param[in] cbs #LinphoneCallCbs object. |
|---|
| | | * @param cbs #LinphoneCallCbs object. @notnil |
|---|
| | | * @return The same #LinphoneCallCbs object. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneCallCbs *linphone_call_cbs_ref (LinphoneCallCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Release reference to the #LinphoneCallCbs object. |
|---|
| | | * @param[in] cbs #LinphoneCallCbs object. |
|---|
| | | * @param cbs #LinphoneCallCbs object. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_cbs_unref (LinphoneCallCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Retrieve the user pointer associated with the #LinphoneCallCbs object. |
|---|
| | | * @param[in] cbs #LinphoneCallCbs object. |
|---|
| | | * @return The user pointer associated with the #LinphoneCallCbs object. |
|---|
| | | * @param cbs #LinphoneCallCbs object. @notnil |
|---|
| | | * @return The user pointer associated with the #LinphoneCallCbs object or NULL. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void *linphone_call_cbs_get_user_data (const LinphoneCallCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user pointer to the #LinphoneCallCbs object. |
|---|
| | | * @param[in] cbs #LinphoneCallCbs object. |
|---|
| | | * @param[in] ud The user pointer to associate with the #LinphoneCallCbs object. |
|---|
| | | * @param cbs #LinphoneCallCbs object. @notnil |
|---|
| | | * @param[in] user_data The user pointer to associate with the #LinphoneCallCbs object. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_cbs_set_user_data (LinphoneCallCbs *cbs, void *ud); |
|---|
| | | LINPHONE_PUBLIC void linphone_call_cbs_set_user_data (LinphoneCallCbs *cbs, void *user_data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the dtmf received callback. |
|---|
| | | * @param[in] cbs #LinphoneCallCbs object. |
|---|
| | | * @param cbs #LinphoneCallCbs object. @notnil |
|---|
| | | * @return The current dtmf received callback. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneCallCbsDtmfReceivedCb linphone_call_cbs_get_dtmf_received (LinphoneCallCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the dtmf received callback. |
|---|
| | | * @param[in] cbs #LinphoneCallCbs object. |
|---|
| | | * @param cbs #LinphoneCallCbs object. @notnil |
|---|
| | | * @param[in] cb The dtmf received callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_cbs_set_dtmf_received (LinphoneCallCbs *cbs, LinphoneCallCbsDtmfReceivedCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the encryption changed callback. |
|---|
| | | * @param[in] cbs #LinphoneCallCbs object. |
|---|
| | | * @param cbs #LinphoneCallCbs object. @notnil |
|---|
| | | * @return The current encryption changed callback. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneCallCbsEncryptionChangedCb linphone_call_cbs_get_encryption_changed (LinphoneCallCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the encryption changed callback. |
|---|
| | | * @param[in] cbs #LinphoneCallCbs object. |
|---|
| | | * @param cbs #LinphoneCallCbs object. @notnil |
|---|
| | | * @param[in] cb The encryption changed callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_cbs_set_encryption_changed (LinphoneCallCbs *cbs, LinphoneCallCbsEncryptionChangedCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the info message received callback. |
|---|
| | | * @param[in] cbs #LinphoneCallCbs object. |
|---|
| | | * @param cbs #LinphoneCallCbs object. @notnil |
|---|
| | | * @return The current info message received callback. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneCallCbsInfoMessageReceivedCb linphone_call_cbs_get_info_message_received (LinphoneCallCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the info message received callback. |
|---|
| | | * @param[in] cbs #LinphoneCallCbs object. |
|---|
| | | * @param cbs #LinphoneCallCbs object. @notnil |
|---|
| | | * @param[in] cb The info message received callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_cbs_set_info_message_received (LinphoneCallCbs *cbs, LinphoneCallCbsInfoMessageReceivedCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the state changed callback. |
|---|
| | | * @param[in] cbs #LinphoneCallCbs object. |
|---|
| | | * @param cbs #LinphoneCallCbs object. @notnil |
|---|
| | | * @return The current state changed callback. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneCallCbsStateChangedCb linphone_call_cbs_get_state_changed (LinphoneCallCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the state changed callback. |
|---|
| | | * @param[in] cbs #LinphoneCallCbs object. |
|---|
| | | * @param cbs #LinphoneCallCbs object. @notnil |
|---|
| | | * @param[in] cb The state changed callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_cbs_set_state_changed (LinphoneCallCbs *cbs, LinphoneCallCbsStateChangedCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the stats updated callback. |
|---|
| | | * @param[in] cbs #LinphoneCallCbs object. |
|---|
| | | * @param cbs #LinphoneCallCbs object. @notnil |
|---|
| | | * @return The current stats updated callback. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneCallCbsStatsUpdatedCb linphone_call_cbs_get_stats_updated (LinphoneCallCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the stats updated callback. |
|---|
| | | * @param[in] cbs #LinphoneCallCbs object. |
|---|
| | | * @param cbs #LinphoneCallCbs object. @notnil |
|---|
| | | * @param[in] cb The stats updated callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_cbs_set_stats_updated (LinphoneCallCbs *cbs, LinphoneCallCbsStatsUpdatedCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the transfer state changed callback. |
|---|
| | | * @param[in] cbs #LinphoneCallCbs object. |
|---|
| | | * @param cbs #LinphoneCallCbs object. @notnil |
|---|
| | | * @return The current transfer state changed callback. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneCallCbsTransferStateChangedCb linphone_call_cbs_get_transfer_state_changed (LinphoneCallCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the transfer state changed callback. |
|---|
| | | * @param[in] cbs #LinphoneCallCbs object. |
|---|
| | | * @param cbs #LinphoneCallCbs object. @notnil |
|---|
| | | * @param[in] cb The transfer state changed callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_cbs_set_transfer_state_changed (LinphoneCallCbs *cbs, LinphoneCallCbsTransferStateChangedCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the ACK processing callback. |
|---|
| | | * @param[in] cbs #LinphoneCallCbs object. |
|---|
| | | * @param cbs #LinphoneCallCbs object. @notnil |
|---|
| | | * @return The current ack processing callback. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneCallCbsAckProcessingCb linphone_call_cbs_get_ack_processing (LinphoneCallCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set ACK processing callback. |
|---|
| | | * @param[in] cbs #LinphoneCallCbs object. |
|---|
| | | * @param cbs #LinphoneCallCbs object. @notnil |
|---|
| | | * @param[in] cb The ack processing callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_cbs_set_ack_processing (LinphoneCallCbs *cbs, LinphoneCallCbsAckProcessingCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the TMMBR received callback. |
|---|
| | | * @param[in] cbs LinphoneCallCbs object. |
|---|
| | | * @param cbs The #LinphoneCallCbs object. @notnil |
|---|
| | | * @return The current TMMBR received callback. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneCallCbsTmmbrReceivedCb linphone_call_cbs_get_tmmbr_received(LinphoneCallCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the TMMBR received callback. |
|---|
| | | * @param[in] cbs LinphoneCallCbs object. |
|---|
| | | * @param cbs The #LinphoneCallCbs object. @notnil |
|---|
| | | * @param[in] cb The TMMBR received callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_cbs_set_tmmbr_received(LinphoneCallCbs *cbs, LinphoneCallCbsTmmbrReceivedCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the snapshot taken callback. |
|---|
| | | * @param[in] cbs LinphoneCallCbs object. |
|---|
| | | * @param cbs The #LinphoneCallCbs object. @notnil |
|---|
| | | * @return The current snapshot taken callback. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneCallCbsSnapshotTakenCb linphone_call_cbs_get_snapshot_taken(LinphoneCallCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the snapshot taken callback. |
|---|
| | | * @param[in] cbs LinphoneCallCbs object. |
|---|
| | | * @param cbs The #LinphoneCallCbs object. @notnil |
|---|
| | | * @param[in] cb The snapshot taken callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_cbs_set_snapshot_taken(LinphoneCallCbs *cbs, LinphoneCallCbsSnapshotTakenCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | /** |
|---|
| | | * Get the next video frame decoded callback. |
|---|
| | | * @param[in] cbs LinphoneCallCbs object. |
|---|
| | | * @param cbs The #LinphoneCallCbs object. @notnil |
|---|
| | | * @return The current next video frame decoded callback. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneCallCbsNextVideoFrameDecodedCb linphone_call_cbs_get_next_video_frame_decoded(LinphoneCallCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the next video frame decoded callback. |
|---|
| | | * @param[in] cbs LinphoneCallCbs object. |
|---|
| | | * @param cbs The #LinphoneCallCbs object. @notnil |
|---|
| | | * @param[in] cb The next video frame decoded callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_cbs_set_next_video_frame_decoded(LinphoneCallCbs *cbs, LinphoneCallCbsNextVideoFrameDecodedCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the camera not working callback. |
|---|
| | | * @param cbs The #LinphoneCallCbs object. @notnil |
|---|
| | | * @return The camera not working callback. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneCallCbsCameraNotWorkingCb linphone_call_cbs_get_camera_not_working(LinphoneCallCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the camera not working callback. |
|---|
| | | * @param cbs The #LinphoneCallCbs object. @notnil |
|---|
| | | * @param[in] cb The camera not working callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_cbs_set_camera_not_working(LinphoneCallCbs *cbs, LinphoneCallCbsCameraNotWorkingCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the audio device changed callback. |
|---|
| | | * @param cbs The #LinphoneCallCbs object. @notnil |
|---|
| | | * @return The audio device changed callback. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneCallCbsAudioDeviceChangedCb linphone_call_cbs_get_audio_device_changed(LinphoneCallCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the audio device changed callback. |
|---|
| | | * @param cbs The #LinphoneCallCbs object. @notnil |
|---|
| | | * @param[in] cb The audio device changedcallback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_cbs_set_audio_device_changed(LinphoneCallCbs *cbs, LinphoneCallCbsAudioDeviceChangedCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @} |
|---|
| | | */ |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Increment refcount. |
|---|
| | | * @param[in] stats #LinphoneCallStats object |
|---|
| | | * @param stats #LinphoneCallStats object @notnil |
|---|
| | | * @return the same #LinphoneCallStats object @notnil |
|---|
| | | * @ingroup misc |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneCallStats *linphone_call_stats_ref (LinphoneCallStats *stats); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Decrement refcount and possibly free the object. |
|---|
| | | * @param[in] stats #LinphoneCallStats object |
|---|
| | | * @param stats #LinphoneCallStats object @notnil |
|---|
| | | * @ingroup misc |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_stats_unref (LinphoneCallStats *stats); |
|---|
| | |
|---|
| | | /** |
|---|
| | | * Gets the user data in the #LinphoneCallStats object |
|---|
| | | * @param[in] stats the #LinphoneCallStats |
|---|
| | | * @return the user data |
|---|
| | | * @return the user data. @maybenil |
|---|
| | | * @ingroup misc |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void *linphone_call_stats_get_user_data (const LinphoneCallStats *stats); |
|---|
| | |
|---|
| | | /** |
|---|
| | | * Sets the user data in the #LinphoneCallStats object |
|---|
| | | * @param[in] stats the #LinphoneCallStats object |
|---|
| | | * @param[in] data the user data |
|---|
| | | * @param[in] data the user data. @maybenil |
|---|
| | | * @ingroup misc |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_stats_set_user_data (LinphoneCallStats *stats, void *data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the type of the stream the stats refer to. |
|---|
| | | * @param[in] stats #LinphoneCallStats object |
|---|
| | | * @return The type of the stream the stats refer to |
|---|
| | | * @param stats #LinphoneCallStats object @notnil |
|---|
| | | * @return The #LinphoneStreamType the stats refer to |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStreamType linphone_call_stats_get_type (const LinphoneCallStats *stats); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the local loss rate since last report |
|---|
| | | * @param stats #LinphoneCallStats object @notnil |
|---|
| | | * @return The sender loss rate |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC float linphone_call_stats_get_sender_loss_rate (const LinphoneCallStats *stats); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the remote reported loss rate since last report |
|---|
| | | * @param stats #LinphoneCallStats object @notnil |
|---|
| | | * @return The receiver loss rate |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC float linphone_call_stats_get_receiver_loss_rate (const LinphoneCallStats *stats); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the local loss rate since last report |
|---|
| | | * @param stats #LinphoneCallStats object @notnil |
|---|
| | | * @return The local loss rate |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC float linphone_call_stats_get_local_loss_rate (const LinphoneCallStats *stats); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the local late rate since last report |
|---|
| | | * @param stats #LinphoneCallStats object @notnil |
|---|
| | | * @return The local late rate |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC float linphone_call_stats_get_local_late_rate (const LinphoneCallStats *stats); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the local interarrival jitter |
|---|
| | | * @param[in] stats #LinphoneCallStats object |
|---|
| | | * @param stats #LinphoneCallStats object @notnil |
|---|
| | | * @return The interarrival jitter at last emitted sender report |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC float linphone_call_stats_get_sender_interarrival_jitter (const LinphoneCallStats *stats); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the remote reported interarrival jitter |
|---|
| | | * @param[in] stats #LinphoneCallStats object |
|---|
| | | * @param stats #LinphoneCallStats object @notnil |
|---|
| | | * @return The interarrival jitter at last received receiver report |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC float linphone_call_stats_get_receiver_interarrival_jitter (const LinphoneCallStats *stats); |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the cumulative number of late packets |
|---|
| | | * @param[in] stats #LinphoneCallStats object |
|---|
| | | * @param stats #LinphoneCallStats object @notnil |
|---|
| | | * @return The cumulative number of late packets |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC uint64_t linphone_call_stats_get_late_packets_cumulative_number (const LinphoneCallStats *stats); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the bandwidth measurement of the received stream, expressed in kbit/s, including IP/UDP/RTP headers. |
|---|
| | | * @param[in] stats #LinphoneCallStats object |
|---|
| | | * @param stats #LinphoneCallStats object @notnil |
|---|
| | | * @return The bandwidth measurement of the received stream in kbit/s. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC float linphone_call_stats_get_download_bandwidth (const LinphoneCallStats *stats); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the bandwidth measurement of the sent stream, expressed in kbit/s, including IP/UDP/RTP headers. |
|---|
| | | * @param[in] stats #LinphoneCallStats object |
|---|
| | | * @param stats #LinphoneCallStats object @notnil |
|---|
| | | * @return The bandwidth measurement of the sent stream in kbit/s. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC float linphone_call_stats_get_upload_bandwidth (const LinphoneCallStats *stats); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the bandwidth measurement of the received RTCP, expressed in kbit/s, including IP/UDP/RTP headers. |
|---|
| | | * @param[in] stats #LinphoneCallStats object |
|---|
| | | * @param stats #LinphoneCallStats object @notnil |
|---|
| | | * @return The bandwidth measurement of the received RTCP in kbit/s. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC float linphone_call_stats_get_rtcp_download_bandwidth (const LinphoneCallStats *stats); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the bandwidth measurement of the sent RTCP, expressed in kbit/s, including IP/UDP/RTP headers. |
|---|
| | | * @param[in] stats #LinphoneCallStats object |
|---|
| | | * @param stats #LinphoneCallStats object @notnil |
|---|
| | | * @return The bandwidth measurement of the sent RTCP in kbit/s. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC float linphone_call_stats_get_rtcp_upload_bandwidth( const LinphoneCallStats *stats); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the state of ICE processing. |
|---|
| | | * @param[in] stats #LinphoneCallStats object |
|---|
| | | * @return The state of ICE processing. |
|---|
| | | * @param stats #LinphoneCallStats object @notnil |
|---|
| | | * @return The #LinphoneIceState of ICE processing |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneIceState linphone_call_stats_get_ice_state (const LinphoneCallStats *stats); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the state of uPnP processing. |
|---|
| | | * @param[in] stats #LinphoneCallStats object |
|---|
| | | * @return The state of uPnP processing. |
|---|
| | | * @param stats #LinphoneCallStats object @notnil |
|---|
| | | * @return The #LinphoneUpnpState of uPnP processing. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneUpnpState linphone_call_stats_get_upnp_state (const LinphoneCallStats *stats); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the IP address family of the remote peer. |
|---|
| | | * @param[in] stats #LinphoneCallStats object |
|---|
| | | * @return The IP address family of the remote peer. |
|---|
| | | * @param stats #LinphoneCallStats object @notnil |
|---|
| | | * @return The IP address family #LinphoneAddressFamily of the remote peer. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneAddressFamily linphone_call_stats_get_ip_family_of_remote (const LinphoneCallStats *stats); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the jitter buffer size in ms. |
|---|
| | | * @param[in] stats #LinphoneCallStats object |
|---|
| | | * @param stats #LinphoneCallStats object @notnil |
|---|
| | | * @return The jitter buffer size in ms. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC float linphone_call_stats_get_jitter_buffer_size_ms (const LinphoneCallStats *stats); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the round trip delay in s. |
|---|
| | | * @param[in] stats #LinphoneCallStats object |
|---|
| | | * @param stats #LinphoneCallStats object @notnil |
|---|
| | | * @return The round trip delay in s. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC float linphone_call_stats_get_round_trip_delay (const LinphoneCallStats *stats); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the estimated bandwidth measurement of the received stream, expressed in kbit/s, including IP/UDP/RTP headers. |
|---|
| | | * @param[in] stats #LinphoneCallStats object |
|---|
| | | * @param stats #LinphoneCallStats object @notnil |
|---|
| | | * @return The estimated bandwidth measurement of the received stream in kbit/s. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC float linphone_call_stats_get_estimated_download_bandwidth(const LinphoneCallStats *stats); |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | * must use this function to unsure the pointer remains |
|---|
| | | * valid. Once the application no more needs this pointer, |
|---|
| | | * it must call linphone_call_unref(). |
|---|
| | | * @param[in] call The call. |
|---|
| | | * @return The same call. |
|---|
| | | * @param call The #LinphoneCall object. @notnil |
|---|
| | | * @return The same #LinphoneCall object. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneCall *linphone_call_ref (LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Release reference to the call. |
|---|
| | | * @param[in] call The call. |
|---|
| | | * @param call The #LinphoneCall object. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_unref (LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Retrieve the user pointer associated with the call. |
|---|
| | | * @param[in] call The call. |
|---|
| | | * @return The user pointer associated with the call. |
|---|
| | | * @param call The #LinphoneCall object. @notnil |
|---|
| | | * @return The user pointer associated with the call. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void *linphone_call_get_user_data (const LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user pointer to the call. |
|---|
| | | * @param[in] call The call. |
|---|
| | | * @param[in] ud The user pointer to associate with the call. |
|---|
| | | * @param call The #LinphoneCall object. @notnil |
|---|
| | | * @param user_data The user pointer to associate with the call. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_set_user_data (LinphoneCall *call, void *ud); |
|---|
| | | LINPHONE_PUBLIC void linphone_call_set_user_data (LinphoneCall *call, void *user_data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the core that has created the specified call. |
|---|
| | | * @param[in] call #LinphoneCall object |
|---|
| | | * @return The #LinphoneCore object that has created the specified call. |
|---|
| | | * @param call #LinphoneCall object. @notnil |
|---|
| | | * @return The #LinphoneCore object that has created the specified call. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneCore * linphone_call_get_core (const LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Retrieves the call's current state. |
|---|
| | | * @param call #LinphoneCall object. @notnil |
|---|
| | | * @return the current #LinphoneCallState of this call. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneCallState linphone_call_get_state (const LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Tell whether a call has been asked to autoanswer |
|---|
| | | * @param[in] call #LinphoneCall object |
|---|
| | | * @param call #LinphoneCall object. @notnil |
|---|
| | | * @return A boolean value telling whether the call has been asked to autoanswer |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_call_asked_to_autoanswer (LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the remote address associated to this call |
|---|
| | | * @param call #LinphoneCall object. @notnil |
|---|
| | | * @return The #LinphoneAddress of the remote end of the call. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress *linphone_call_get_remote_address (const LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the to address with its headers associated to this call |
|---|
| | | * @param call #LinphoneCall object. @notnil |
|---|
| | | * @return the #LinphoneAdress matching the TO of the call. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress *linphone_call_get_to_address (const LinphoneCall * call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the value of the header name |
|---|
| | | * @param call #LinphoneCall object. @notnil |
|---|
| | | * @param header_name the name of the header to check. @notnil |
|---|
| | | * @return the value of the header if exists. @maybenil |
|---|
| | | * @deprecated 27/10/2020. Use linphone_call_params_get_custom_header() on linphone_call_get_remote_params() instead. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_call_get_to_header (const LinphoneCall *call, const char *name); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the remote address associated to this call as a string. |
|---|
| | | * The result string must be freed by user using ms_free(). |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC char *linphone_call_get_remote_address_as_string (const LinphoneCall *call); |
|---|
| | | LINPHONE_PUBLIC const char *linphone_call_get_to_header (const LinphoneCall *call, const char *header_name); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the diversion address associated to this call |
|---|
| | | * @param call #LinphoneCall object. @notnil |
|---|
| | | * @return the diversion address as #LinphoneAddress or NULL. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress * linphone_call_get_diversion_address (const LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns direction of the call (incoming or outgoing). |
|---|
| | | * @param call #LinphoneCall object. @notnil |
|---|
| | | * @return the #LinphoneCallDir |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneCallDir linphone_call_get_dir (const LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the call log associated to this call. |
|---|
| | | * @param[in] call #LinphoneCall object |
|---|
| | | * @return The #LinphoneCallLog associated with the specified #LinphoneCall |
|---|
| | | * @param call #LinphoneCall object. @notnil |
|---|
| | | * @return The #LinphoneCallLog associated with the specified #LinphoneCall. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneCallLog *linphone_call_get_call_log (const LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the refer-to uri (if the call was transfered). |
|---|
| | | * @param[in] call #LinphoneCall object |
|---|
| | | * @return The refer-to uri of the call (if it was transfered) |
|---|
| | | * @param call #LinphoneCall object. @notnil |
|---|
| | | * @return The refer-to uri of the call (if it was transfered). @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_call_get_refer_to (const LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns true if this calls has received a transfer that has not been |
|---|
| | | * Returns if this calls has received a transfer that has not been |
|---|
| | | * executed yet. |
|---|
| | | * Pending transfers are executed when this call is being paused or closed, |
|---|
| | | * locally or by remote endpoint. |
|---|
| | | * If the call is already paused while receiving the transfer request, the |
|---|
| | | * transfer immediately occurs. |
|---|
| | | * @param call #LinphoneCall object. @notnil |
|---|
| | | * @return TRUE if transfer is pending, FALSE otherwise. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_call_has_transfer_pending (const LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the transferer if this call was started automatically as a result of an incoming transfer request. |
|---|
| | | * The call in which the transfer request was received is returned in this case. |
|---|
| | | * @param[in] call #LinphoneCall object |
|---|
| | | * @return The transferer call if the specified call was started automatically as a result of an incoming transfer request, NULL otherwise |
|---|
| | | * @param call #LinphoneCall object. @notnil |
|---|
| | | * @return The transferer #LinphoneCall if the specified call was started automatically as a result of an incoming transfer request, NULL otherwise. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneCall *linphone_call_get_transferer_call (const LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * When this call has received a transfer request, returns the new call that was automatically created as a result of the transfer. |
|---|
| | | * @param call #LinphoneCall object. @notnil |
|---|
| | | * @return the transfer #LinphoneCall created. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneCall *linphone_call_get_transfer_target_call (const LinphoneCall *call); |
|---|
| | | |
|---|
| | |
|---|
| | | * Call replacement can occur during call transfers. |
|---|
| | | * By default, the core automatically terminates the replaced call and accept the new one. |
|---|
| | | * This function allows the application to know whether a new incoming call is a one that replaces another one. |
|---|
| | | * @param call #LinphoneCall object. @notnil |
|---|
| | | * @return the #LinphoneCall object this call is replacing or NULL. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneCall *linphone_call_get_replaced_call (LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns call's duration in seconds. |
|---|
| | | * @param call #LinphoneCall object. @notnil |
|---|
| | | * @return the call's duration in seconds. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC int linphone_call_get_duration (const LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns current parameters associated to the call. |
|---|
| | | * @param call #LinphoneCall object. @notnil |
|---|
| | | * @return the current #LinphoneCallParams of this call. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const LinphoneCallParams *linphone_call_get_current_params (LinphoneCall *call); |
|---|
| | | |
|---|
| | |
|---|
| | | * |
|---|
| | | * This is useful when receiving an incoming call, to know whether the remote party |
|---|
| | | * supports video, encryption or whatever. |
|---|
| | | * |
|---|
| | | * @param call #LinphoneCall object. @notnil |
|---|
| | | * @return the #LinphoneCallParams suggested by the remote or NULL. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const LinphoneCallParams *linphone_call_get_remote_params (LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Indicate whether camera input should be sent to remote end. |
|---|
| | | * @param call #LinphoneCall object. @notnil |
|---|
| | | * @param enabled wether or not to send local video stream. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_enable_camera (LinphoneCall *lc, bool_t enabled); |
|---|
| | | LINPHONE_PUBLIC void linphone_call_enable_camera (LinphoneCall *call, bool_t enabled); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns TRUE if camera pictures are allowed to be sent to the remote party. |
|---|
| | | * Returns if camera pictures are allowed to be sent to the remote party. |
|---|
| | | * @param call #LinphoneCall object. @notnil |
|---|
| | | * @return TRUE if local video stream is being sent, FALSE otherwise. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_call_camera_enabled (const LinphoneCall *lc); |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_call_camera_enabled (const LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Take a photo of currently received video and write it into a jpeg file. |
|---|
| | | * Note that the snapshot is asynchronous, an application shall not assume that the file is created when the function returns. |
|---|
| | | * @param call a #LinphoneCall |
|---|
| | | * @param file a path where to write the jpeg content. |
|---|
| | | * @param call #LinphoneCall object. @notnil |
|---|
| | | * @param file_path a path where to write the jpeg content. @notnil |
|---|
| | | * @return 0 if successfull, -1 otherwise (typically if jpeg format is not supported). |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_call_take_video_snapshot (LinphoneCall *call, const char *file); |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_call_take_video_snapshot (LinphoneCall *call, const char *file_path); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Take a photo of currently captured video and write it into a jpeg file. |
|---|
| | | * Note that the snapshot is asynchronous, an application shall not assume that the file is created when the function returns. |
|---|
| | | * @param call a #LinphoneCall |
|---|
| | | * @param file a path where to write the jpeg content. |
|---|
| | | * @param call #LinphoneCall object. @notnil |
|---|
| | | * @param file_path a path where to write the jpeg content. @notnil |
|---|
| | | * @return 0 if successfull, -1 otherwise (typically if jpeg format is not supported). |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_call_take_preview_snapshot (LinphoneCall *call, const char *file); |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_call_take_preview_snapshot (LinphoneCall *call, const char *file_path); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the reason for a call termination (either error or normal termination) |
|---|
| | | * @param call #LinphoneCall object. @notnil |
|---|
| | | * @return the #LinphoneReason of the call termination. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneReason linphone_call_get_reason (const LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns full details about call errors or termination reasons. |
|---|
| | | * @param call #LinphoneCall object on which we want the information error |
|---|
| | | * @return #LinphoneErrorInfo object holding the reason error. |
|---|
| | | * @param call #LinphoneCall object. @notnil on which we want the information error |
|---|
| | | * @return #LinphoneErrorInfo object holding the reason error. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const LinphoneErrorInfo *linphone_call_get_error_info (const LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the far end's user agent description string, if available. |
|---|
| | | * @param call #LinphoneCall object. @notnil |
|---|
| | | * @return the remote user agent or NULL. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_call_get_remote_user_agent (LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the far end's sip contact as a string, if available. |
|---|
| | | * @param call #LinphoneCall object. @notnil |
|---|
| | | * @return the remote contact or NULL. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_call_get_remote_contact (LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the ZRTP authentication token to verify. |
|---|
| | | * @param call the #LinphoneCall |
|---|
| | | * @return the authentication token to verify. |
|---|
| | | * @param call The #LinphoneCall object @notnil |
|---|
| | | * @return the authentication token to verify or NULL if ZRTP isn't enabled. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_call_get_authentication_token (LinphoneCall *call); |
|---|
| | | |
|---|
| | |
|---|
| | | * Returns whether ZRTP authentication token is verified. |
|---|
| | | * If not, it must be verified by users as described in ZRTP procedure. |
|---|
| | | * Once done, the application must inform of the results with linphone_call_set_authentication_token_verified(). |
|---|
| | | * @param call the #LinphoneCall |
|---|
| | | * @param call The #LinphoneCall object @notnil |
|---|
| | | * @return TRUE if authentication token is verifed, false otherwise. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_call_get_authentication_token_verified (const LinphoneCall *call); |
|---|
| | |
|---|
| | | /** |
|---|
| | | * Set the result of ZRTP short code verification by user. |
|---|
| | | * If remote party also does the same, it will update the ZRTP cache so that user's verification will not be required for the two users. |
|---|
| | | * @param call the #LinphoneCall |
|---|
| | | * @param call The #LinphoneCall object @notnil |
|---|
| | | * @param verified whether the ZRTP SAS is verified. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_set_authentication_token_verified (LinphoneCall *call, bool_t verified); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Request remote side to send us a Video Fast Update. |
|---|
| | | * @param call #LinphoneCall object. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_send_vfu_request (LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Request the callback passed to linphone_call_cbs_set_next_video_frame_decoded() to be called the next time the video decoder properly decodes a video frame. |
|---|
| | | * @param call the #LinphoneCall |
|---|
| | | * @param call the #LinphoneCall @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_request_notify_next_video_frame_decoded(LinphoneCall *call); |
|---|
| | | |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED void linphone_call_set_next_video_frame_decoded_callback (LinphoneCall *call, LinphoneCallCbFunc cb, void *ud); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the current transfer state, if a transfer has been initiated from this call. |
|---|
| | | * @see linphone_core_transfer_call() , linphone_core_transfer_call_to_another() |
|---|
| | | * @param call #LinphoneCall object. @notnil |
|---|
| | | * @return the #LinphoneCallState. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneCallState linphone_call_get_transfer_state (LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Perform a zoom of the video displayed during a call. |
|---|
| | | * @param call the call. |
|---|
| | | * @param zoom_factor a floating point number describing the zoom factor. A value 1.0 corresponds to no zoom applied. |
|---|
| | | * @param cx a floating point number pointing the horizontal center of the zoom to be applied. This value should be between 0.0 and 1.0. |
|---|
| | | * @param cy a floating point number pointing the vertical center of the zoom to be applied. This value should be between 0.0 and 1.0. |
|---|
| | | * @deprecated use linphone_call_zoom instead |
|---|
| | | * cx and cy are updated in return in case their coordinates were too excentrated for the requested zoom factor. The zoom ensures that all the screen is fullfilled with the video. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_zoom_video (LinphoneCall *call, float zoom_factor, float *cx, float *cy); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Perform a zoom of the video displayed during a call. |
|---|
| | | * The zoom ensures that all the screen is fullfilled with the video. |
|---|
| | | * @param call the call. |
|---|
| | | * @param call The #LinphoneCall object @notnil |
|---|
| | | * @param zoom_factor a floating point number describing the zoom factor. A value 1.0 corresponds to no zoom applied. |
|---|
| | | * @param cx a floating point number pointing the horizontal center of the zoom to be applied. This value should be between 0.0 and 1.0. |
|---|
| | | * @param cy a floating point number pointing the vertical center of the zoom to be applied. This value should be between 0.0 and 1.0. |
|---|
| | |
|---|
| | | * Send the specified dtmf. |
|---|
| | | * |
|---|
| | | * The dtmf is automatically played to the user. |
|---|
| | | * @param call The #LinphoneCall object |
|---|
| | | * @param call The #LinphoneCall object @notnil |
|---|
| | | * @param dtmf The dtmf name specified as a char, such as '0', '#' etc... |
|---|
| | | * @return 0 if successful, -1 on error. |
|---|
| | | **/ |
|---|
| | |
|---|
| | | * |
|---|
| | | * The dtmfs are automatically sent to remote, separated by some needed customizable delay. |
|---|
| | | * Sending is canceled if the call state changes to something not LinphoneCallStreamsRunning. |
|---|
| | | * @param call The #LinphoneCall object |
|---|
| | | * @param dtmfs A dtmf sequence such as '123#123123' |
|---|
| | | * @param call The #LinphoneCall object @notnil |
|---|
| | | * @param dtmfs A dtmf sequence such as '123#123123' @notnil |
|---|
| | | * @return -2 if there is already a DTMF sequence, -1 if call is not ready, 0 otherwise. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_call_send_dtmfs (LinphoneCall *call, const char *dtmfs); |
|---|
| | |
|---|
| | | * Stop current DTMF sequence sending. |
|---|
| | | * |
|---|
| | | * Please note that some DTMF could be already sent, |
|---|
| | | * depending on when this function call is delayed from #linphone_call_send_dtmfs. This |
|---|
| | | * depending on when this function call is delayed from #linphone_call_send_dtmfs(). This |
|---|
| | | * function will be automatically called if call state change to anything but LinphoneCallStreamsRunning. |
|---|
| | | * @param call The #LinphoneCall object |
|---|
| | | * @param call The #LinphoneCall object @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_cancel_dtmfs (LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Return TRUE if this call is currently part of a conference |
|---|
| | | * @param call #LinphoneCall |
|---|
| | | * @return TRUE if part of a conference. |
|---|
| | | * @deprecated Use linphone_call_get_conference() instead. |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED bool_t linphone_call_is_in_conference (const LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Return the associated conference object |
|---|
| | | * @param call #LinphoneCall |
|---|
| | | * @return A pointer on #LinphoneConference or NULL if the call is not part of any conference. |
|---|
| | | * @param call The #LinphoneCall object @notnil |
|---|
| | | * @return A pointer on #LinphoneConference or NULL if the call is not part of any conference. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneConference *linphone_call_get_conference (const LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Change the playback output device (currently only used for blackberry) |
|---|
| | | * @param call |
|---|
| | | * @param route the wanted audio route (earpiece, speaker, ...) |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_set_audio_route (LinphoneCall *call, LinphoneAudioRoute route); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the number of stream for the given call. |
|---|
| | | * Currently there is only two (Audio, Video), but later there will be more. |
|---|
| | | * @param call |
|---|
| | | * @return 2 |
|---|
| | | * @param call The #LinphoneCall object @notnil |
|---|
| | | * @return the amount of streams for this call. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC int linphone_call_get_stream_count (const LinphoneCall *call); |
|---|
| | | |
|---|
| | |
|---|
| | | * Pauses the call. If a music file has been setup using linphone_core_set_play_file(), |
|---|
| | | * this file will be played to the remote user. |
|---|
| | | * The only way to resume a paused call is to call linphone_call_resume(). |
|---|
| | | * @param[in] call #LinphoneCall object |
|---|
| | | * @param call #LinphoneCall object. @notnil |
|---|
| | | * @return 0 on success, -1 on failure |
|---|
| | | * @see linphone_call_resume() |
|---|
| | | **/ |
|---|
| | |
|---|
| | | /** |
|---|
| | | * Resumes a call. |
|---|
| | | * The call needs to have been paused previously with linphone_call_pause(). |
|---|
| | | * @param[in] call #LinphoneCall object |
|---|
| | | * @param call #LinphoneCall object. @notnil |
|---|
| | | * @return 0 on success, -1 on failure |
|---|
| | | * @see linphone_call_pause() |
|---|
| | | **/ |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Terminates a call. |
|---|
| | | * @param[in] call #LinphoneCall object |
|---|
| | | * @param call #LinphoneCall object. @notnil |
|---|
| | | * @return 0 on success, -1 on failure |
|---|
| | | **/LINPHONE_PUBLIC LinphoneStatus linphone_call_terminate (LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Terminates a call. |
|---|
| | | * @param[in] call #LinphoneCall object |
|---|
| | | * @param[in] ei #LinphoneErrorInfo |
|---|
| | | * @param call The #LinphoneCall object @notnil |
|---|
| | | * @param ei #LinphoneErrorInfo @maybenil |
|---|
| | | * @return 0 on success, -1 on failure |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_call_terminate_with_error_info (LinphoneCall *call, const LinphoneErrorInfo *ei); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Redirect the specified call to the given redirect URI. |
|---|
| | | * @param[in] call A #LinphoneCall object |
|---|
| | | * @param[in] redirect_uri The URI to redirect the call to |
|---|
| | | * Redirect the specified call to the given redirect Address. |
|---|
| | | * @param call The #LinphoneCall object @notnil |
|---|
| | | * @param redirect_address The #LinphoneAddress to redirect the call to @notnil |
|---|
| | | * @return 0 if successful, -1 on error. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_call_redirect (LinphoneCall *call, const char *redirect_uri); |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_call_redirect_to (LinphoneCall *call, const LinphoneAddress *redirect_address); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Decline a pending incoming call, with a reason. |
|---|
| | | * @param[in] call A #LinphoneCall object that must be in the IncomingReceived state |
|---|
| | | * @param[in] reason The reason for rejecting the call: #LinphoneReasonDeclined or #LinphoneReasonBusy |
|---|
| | | * @param call A #LinphoneCall object that must be in the IncomingReceived state @notnil |
|---|
| | | * @param reason The reason for rejecting the call: #LinphoneReasonDeclined or #LinphoneReasonBusy |
|---|
| | | * @return 0 on success, -1 on failure |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_call_decline (LinphoneCall *call, LinphoneReason reason); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Decline a pending incoming call, with a #LinphoneErrorInfo object. |
|---|
| | | * @param[in] call A #LinphoneCall object that must be in the IncomingReceived state |
|---|
| | | * @param[in] ei #LinphoneErrorInfo containing more information on the call rejection. |
|---|
| | | * @param call A #LinphoneCall object that must be in the IncomingReceived state @notnil |
|---|
| | | * @param ei #LinphoneErrorInfo containing more information on the call rejection. @maybenil |
|---|
| | | * @return 0 on success, -1 on failure |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC int linphone_call_decline_with_error_info (LinphoneCall *call, const LinphoneErrorInfo *ei); |
|---|
| | |
|---|
| | | * call_state_changed callback of the #LinphoneCoreVTable structure, where it will receive |
|---|
| | | * a #LinphoneCallIncoming event with the associated #LinphoneCall object. |
|---|
| | | * The application can later accept the call using this method. |
|---|
| | | * @param[in] call A #LinphoneCall object |
|---|
| | | * @param call The #LinphoneCall object @notnil |
|---|
| | | * @return 0 on success, -1 on failure |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_call_accept (LinphoneCall *call); |
|---|
| | |
|---|
| | | * call_state_changed callback of the #LinphoneCoreVTable structure, where it will receive |
|---|
| | | * a #LinphoneCallIncoming event with the associated #LinphoneCall object. |
|---|
| | | * The application can later accept the call using this method. |
|---|
| | | * @param[in] call A #LinphoneCall object |
|---|
| | | * @param[in] params The specific parameters for this call, for example whether video is accepted or not. Use NULL to use default parameters |
|---|
| | | * @param call A #LinphoneCall object @notnil |
|---|
| | | * @param params The specific parameters for this call, for example whether video is accepted or not. Use NULL to use default parameters. @maybenil |
|---|
| | | * @return 0 on success, -1 on failure |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_call_accept_with_params (LinphoneCall *call, const LinphoneCallParams *params); |
|---|
| | |
|---|
| | | /** |
|---|
| | | * Accept an early media session for an incoming call. |
|---|
| | | * This is identical as calling linphone_call_accept_early_media_with_params() with NULL parameters. |
|---|
| | | * @param[in] call A #LinphoneCall object |
|---|
| | | * @param call A #LinphoneCall object @notnil |
|---|
| | | * @return 0 if successful, -1 otherwise |
|---|
| | | * @see linphone_call_accept_early_media_with_params() |
|---|
| | | **/ |
|---|
| | |
|---|
| | | * This means the call is not accepted but audio & video streams can be established if the remote party supports early media. |
|---|
| | | * However, unlike after call acceptance, mic and camera input are not sent during early-media, though received audio & video are played normally. |
|---|
| | | * The call can then later be fully accepted using linphone_call_accept() or linphone_call_accept_with_params(). |
|---|
| | | * @param[in] call A #LinphoneCall object |
|---|
| | | * @param[in] params The call parameters to use (can be NULL) |
|---|
| | | * @param call A #LinphoneCall object @notnil |
|---|
| | | * @param params The call parameters to use (can be NULL). @maybenil |
|---|
| | | * @return 0 if successful, -1 otherwise |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_call_accept_early_media_with_params (LinphoneCall *call, const LinphoneCallParams *params); |
|---|
| | |
|---|
| | | * WARNING: Updating a call in the #LinphoneCallPaused state will still result in a paused call even if the media directions set in the |
|---|
| | | * params are sendrecv. To resume a paused call, you need to call linphone_call_resume(). |
|---|
| | | * |
|---|
| | | * @param[in] call A #LinphoneCall object |
|---|
| | | * @param[in] params The new call parameters to use (may be NULL) |
|---|
| | | * @param call A #LinphoneCall object @notnil |
|---|
| | | * @param params The new call parameters to use (may be NULL). @maybenil |
|---|
| | | * @return 0 if successful, -1 otherwise. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_call_update (LinphoneCall *call, const LinphoneCallParams *params); |
|---|
| | |
|---|
| | | * in the 200Ok, and when the ACK containing the SDP answer is received, #LinphoneCallUpdatedByRemote is triggered to notify the application of possible |
|---|
| | | * changes in the media session. However in such case defering the update has no meaning since we just generating an offer. |
|---|
| | | * |
|---|
| | | * @param[in] call A #LinphoneCall object |
|---|
| | | * @param call A #LinphoneCall object @notnil |
|---|
| | | * @return 0 if successful, -1 if the linphone_call_defer_update() was done outside a valid #LinphoneCallUpdatedByRemote notification |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_call_defer_update (LinphoneCall *call); |
|---|
| | |
|---|
| | | * If params is not NULL, then the update will be accepted according to the parameters passed. |
|---|
| | | * Typical example is when a user accepts to start video, then params should indicate that video stream should be used |
|---|
| | | * (see linphone_call_params_enable_video()). |
|---|
| | | * @param[in] call A #LinphoneCall object |
|---|
| | | * @param[in] params A #LinphoneCallParams object describing the call parameters to accept |
|---|
| | | * @param call A #LinphoneCall object @notnil |
|---|
| | | * @param params A #LinphoneCallParams object describing the call parameters to accept. @maybenil |
|---|
| | | * @return 0 if successful, -1 otherwise (actually when this function call is performed outside ot #LinphoneCallUpdatedByRemote state) |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_call_accept_update (LinphoneCall *call, const LinphoneCallParams *params); |
|---|
| | |
|---|
| | | * It is possible to follow the progress of the transfer provided that transferee sends notification about it. |
|---|
| | | * In this case, the transfer_state_changed callback of the #LinphoneCoreVTable is invoked to notify of the state of the new call at the other party. |
|---|
| | | * The notified states are #LinphoneCallOutgoingInit , #LinphoneCallOutgoingProgress, #LinphoneCallOutgoingRinging and #LinphoneCallConnected. |
|---|
| | | * @param[in] call The call to be transfered |
|---|
| | | * @param[in] refer_to The destination the call is to be refered to |
|---|
| | | * @param call The call to be transfered @notnil |
|---|
| | | * @param refer_to The #LinphoneAddress the call is to be refered to. @notnil |
|---|
| | | * @return 0 on success, -1 on failure |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_call_transfer (LinphoneCall *call, const char *refer_to); |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_call_transfer_to (LinphoneCall *call, const LinphoneAddress *refer_to); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Transfers a call to destination of another running call. This is used for "attended transfer" scenarios. |
|---|
| | |
|---|
| | | * It is possible to follow the progress of the transfer provided that transferee sends notification about it. |
|---|
| | | * In this case, the transfer_state_changed callback of the #LinphoneCoreVTable is invoked to notify of the state of the new call at the other party. |
|---|
| | | * The notified states are #LinphoneCallOutgoingInit , #LinphoneCallOutgoingProgress, #LinphoneCallOutgoingRinging and #LinphoneCallConnected. |
|---|
| | | * @param[in] call A running call you want to transfer |
|---|
| | | * @param[in] dest A running call whose remote person will receive the transfer |
|---|
| | | * @param call A running call you want to transfer @notnil |
|---|
| | | * @param dest A running call whose remote person will receive the transfer @notnil |
|---|
| | | * @return 0 on success, -1 on failure |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_call_transfer_to_another (LinphoneCall *call, LinphoneCall *dest); |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the native window handle of the video window, casted as an unsigned long. |
|---|
| | | * @param call the #LinphoneCall object @notnil |
|---|
| | | * @return the native video window id (type may vary depending on platform). @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void * linphone_call_get_native_video_window_id(const LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the native video window id where the video is to be displayed. |
|---|
| | | * For MacOS, Linux, Windows: if not set or 0 a window will be automatically created, unless the special id -1 is given. |
|---|
| | | * @param call the #LinphoneCall object @notnil |
|---|
| | | * @param window_id the native video window id. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_set_native_video_window_id(LinphoneCall *call, void * id); |
|---|
| | | LINPHONE_PUBLIC void linphone_call_set_native_video_window_id(LinphoneCall *call, void *window_id); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Enables or disable echo cancellation for this call |
|---|
| | | * @param call |
|---|
| | | * @param val |
|---|
| | | * @param call the #LinphoneCall object @notnil |
|---|
| | | * @param enable wether to enable echo cancellation or not. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_enable_echo_cancellation(LinphoneCall *call, bool_t val) ; |
|---|
| | | LINPHONE_PUBLIC void linphone_call_enable_echo_cancellation(LinphoneCall *call, bool_t enable) ; |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns TRUE if echo cancellation is enabled. |
|---|
| | | * Returns if echo cancellation is enabled. |
|---|
| | | * @param call the #LinphoneCall object @notnil |
|---|
| | | * @return TRUE if echo cancellation is enabled, FALSE otherwise. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_call_echo_cancellation_enabled(const LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Enables or disable echo limiter for this call |
|---|
| | | * @param call |
|---|
| | | * @param val |
|---|
| | | * Enables or disable echo limiter for this call. |
|---|
| | | * @param call the #LinphoneCall object @notnil |
|---|
| | | * @param enable wether to enable echo limiter or not. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_enable_echo_limiter(LinphoneCall *call, bool_t val); |
|---|
| | | LINPHONE_PUBLIC void linphone_call_enable_echo_limiter(LinphoneCall *call, bool_t enable); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns TRUE if echo limiter is enabled. |
|---|
| | | * Returns if echo limiter is enabled. |
|---|
| | | * @param call the #LinphoneCall object @notnil |
|---|
| | | * @return TRUE if echo limiter is enabled, FALSE otherwise. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_call_echo_limiter_enabled(const LinphoneCall *call); |
|---|
| | | |
|---|
| | |
|---|
| | | */ |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Create a new chat room for messaging from a call if not already existing, else return existing one. |
|---|
| | | * Create a new chat room for real time messaging from a call if not already existing, else return existing one. |
|---|
| | | * No reference is given to the caller: the chat room will be deleted when the call is ended. |
|---|
| | | * @param call #LinphoneCall object |
|---|
| | | * @return #LinphoneChatRoom where messaging can take place. |
|---|
| | | * @param call #LinphoneCall object @notnil |
|---|
| | | * @return #LinphoneChatRoom where real time messaging can take place or NULL if chat room couldn't be created. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoom * linphone_call_get_chat_room(LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the mesured playback volume level (received from remote) in dbm0. |
|---|
| | | * @param call The call. |
|---|
| | | * @param call The call. @notnil |
|---|
| | | * @return float Volume level in percentage. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC float linphone_call_get_play_volume(const LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the mesured record volume level (sent to remote) in dbm0. |
|---|
| | | * @param call The call. |
|---|
| | | * @param call The call. @notnil |
|---|
| | | * @return float Volume level in percentage. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC float linphone_call_get_record_volume(const LinphoneCall *call); |
|---|
| | |
|---|
| | | * Get speaker volume gain. |
|---|
| | | * If the sound backend supports it, the returned gain is equal to the gain set |
|---|
| | | * with the system mixer. |
|---|
| | | * @param call The call. |
|---|
| | | * @param call The call. @notnil |
|---|
| | | * @return Percentage of the max supported volume gain. Valid values are in [ 0.0 : 1.0 ]. |
|---|
| | | * In case of failure, a negative value is returned |
|---|
| | | */ |
|---|
| | |
|---|
| | | /** |
|---|
| | | * Set speaker volume gain. |
|---|
| | | * If the sound backend supports it, the new gain will synchronized with the system mixer. |
|---|
| | | * @param call The call. |
|---|
| | | * @param call The call. @notnil |
|---|
| | | * @param volume Percentage of the max supported gain. Valid values are in [ 0.0 : 1.0 ]. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_set_speaker_volume_gain(LinphoneCall *call, float volume); |
|---|
| | |
|---|
| | | * Get microphone volume gain. |
|---|
| | | * If the sound backend supports it, the returned gain is equal to the gain set |
|---|
| | | * with the system mixer. |
|---|
| | | * @param call The #LinphoneCall object. |
|---|
| | | * @param call The #LinphoneCall object. @notnil |
|---|
| | | * @return double Percentage of the max supported volume gain. Valid values are in [ 0.0 : 1.0 ]. |
|---|
| | | * In case of failure, a negative value is returned |
|---|
| | | */ |
|---|
| | |
|---|
| | | /** |
|---|
| | | * Set microphone volume gain. |
|---|
| | | * If the sound backend supports it, the new gain will synchronized with the system mixer. |
|---|
| | | * @param call The #LinphoneCall object. |
|---|
| | | * @param call The #LinphoneCall object. @notnil |
|---|
| | | * @param volume Percentage of the max supported gain. Valid values are in [ 0.0 : 1.0 ]. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_set_microphone_volume_gain(LinphoneCall *call, float volume); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get speaker muted state. |
|---|
| | | * @param call The #LinphoneCall object. |
|---|
| | | * @param call The #LinphoneCall object. @notnil |
|---|
| | | * @return The speaker muted state. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_call_get_speaker_muted (const LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set speaker muted state. |
|---|
| | | * @param call The #LinphoneCall object. |
|---|
| | | * @param call The #LinphoneCall object. @notnil |
|---|
| | | * @param muted The speaker muted state. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_set_speaker_muted (LinphoneCall *call, bool_t muted); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get microphone muted state. |
|---|
| | | * @param call The #LinphoneCall object. |
|---|
| | | * @param call The #LinphoneCall object. @notnil |
|---|
| | | * @return The microphone muted state. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_call_get_microphone_muted (const LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set microphone muted state. |
|---|
| | | * @param call The #LinphoneCall object. |
|---|
| | | * @param call The #LinphoneCall object. @notnil |
|---|
| | | * @param muted The microphone muted state. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_set_microphone_muted (LinphoneCall *call, bool_t muted); |
|---|
| | |
|---|
| | | * 1-2 = very poor quality <br> |
|---|
| | | * 0-1 = can't be worse, mostly unusable <br> |
|---|
| | | * |
|---|
| | | * @param call The #LinphoneCall object. @notnil |
|---|
| | | * @return The function returns -1 if no quality measurement is available, for example if no |
|---|
| | | * active audio stream exist. Otherwise it returns the quality rating. |
|---|
| | | **/ |
|---|
| | |
|---|
| | | * Returns call quality averaged over all the duration of the call. |
|---|
| | | * |
|---|
| | | * See linphone_call_get_current_quality() for more details about quality measurement. |
|---|
| | | * @param call The #LinphoneCall object. @notnil |
|---|
| | | * @return the call average quality since tbe beginning of the call. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC float linphone_call_get_average_quality(const LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Start call recording. |
|---|
| | | * Starts call recording. |
|---|
| | | * Video record is only available if this function is called in state StreamRunning. |
|---|
| | | * The output file where audio is recorded must be previously specified with linphone_call_params_set_record_file(). |
|---|
| | | * @param call The #LinphoneCall object. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_start_recording(LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Stop call recording. |
|---|
| | | * Stops call recording. |
|---|
| | | * @param call The #LinphoneCall object. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_stop_recording(LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns whether or not the call is currently being recorded |
|---|
| | | * @param call LinphoneCall for which we can to know the recording state |
|---|
| | | * @return true if recording is in progress, false otherwise |
|---|
| | | * @param call #LinphoneCall for which we can to know the recording state @notnil |
|---|
| | | * @return TRUE if recording is in progress, FALSE otherwise |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_call_is_recording(LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get a player associated with the call to play a local file and stream it to the remote peer. |
|---|
| | | * @param[in] call #LinphoneCall object |
|---|
| | | * @return A #LinphonePlayer object |
|---|
| | | * Gets a player associated with the call to play a local file and stream it to the remote peer. |
|---|
| | | * @param call #LinphoneCall object. @notnil |
|---|
| | | * @return A #LinphonePlayer object @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphonePlayer * linphone_call_get_player(LinphoneCall *call); |
|---|
| | | |
|---|
| | |
|---|
| | | * the media is busy in establishing the connection (typically ICE connectivity checks). It can result in failures generating loss of time |
|---|
| | | * in future operations in the call. |
|---|
| | | * Applications are invited to check this function after each call state change to decide whether certain operations are permitted or not. |
|---|
| | | * @param call the call |
|---|
| | | * @param call the #LinphoneCall @notnil |
|---|
| | | * @return TRUE if media is busy in establishing the connection, FALSE otherwise. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_call_media_in_progress(const LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Call generic OpenGL render for a given call. |
|---|
| | | * @param call The call. |
|---|
| | | * Calls generic OpenGL render for a given call. |
|---|
| | | * @param call The #LinphoneCall. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_ogl_render(const LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Send a #LinphoneInfoMessage through an established call |
|---|
| | | * @param call the call |
|---|
| | | * @param info the info message |
|---|
| | | * Sends an info message through an established call |
|---|
| | | * @param call the #LinphoneCall @notnil |
|---|
| | | * @param info the #LinphoneInfoMessage to send @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_call_send_info_message(LinphoneCall *call, const LinphoneInfoMessage *info); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Return a copy of the call statistics for a particular stream type. |
|---|
| | | * @param call the call |
|---|
| | | * @param type the stream type |
|---|
| | | * Returns a copy of the call statistics for a particular stream type. |
|---|
| | | * @param call the #LinphoneCall @notnil |
|---|
| | | * @param type the #LinphoneStreamType |
|---|
| | | * @return a #LinphoneCallStats object for the given stream or NULL if stream isn't available. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneCallStats *linphone_call_get_stats(LinphoneCall *call, LinphoneStreamType type); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns a copy of the call statistics for the audio stream. |
|---|
| | | * @param call the #LinphoneCall @notnil |
|---|
| | | * @return a #LinphoneCallStats object for the audio stream or NULL if it isn't available. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneCallStats *linphone_call_get_audio_stats(LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns a copy of the call statistics for the video stream. |
|---|
| | | * @param call the #LinphoneCall @notnil |
|---|
| | | * @return a #LinphoneCallStats object for the video stream or NULL if it isn't available. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneCallStats *linphone_call_get_video_stats(LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns a copy of the call statistics for the text stream. |
|---|
| | | * @param call the #LinphoneCall @notnil |
|---|
| | | * @return a #LinphoneCallStats object for the text stream or NULL if it isn't available. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneCallStats *linphone_call_get_text_stats(LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Add a listener in order to be notified of #LinphoneCall events. Once an event is received, registred #LinphoneCallCbs are |
|---|
| | | * invoked sequencially. |
|---|
| | | * @param[in] call #LinphoneCall object to monitor. |
|---|
| | | * @param[in] cbs A #LinphoneCallCbs object holding the callbacks you need. A reference is taken by the #LinphoneCall until you invoke linphone_call_remove_callbacks(). |
|---|
| | | * @param call #LinphoneCall object. @notnil to monitor. |
|---|
| | | * @param cbs A #LinphoneCallCbs object holding the callbacks you need. A reference is taken by the #LinphoneCall until you invoke linphone_call_remove_callbacks(). @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_add_callbacks(LinphoneCall *call, LinphoneCallCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Remove a listener from a #LinphoneCall |
|---|
| | | * @param[in] call #LinphoneCall object |
|---|
| | | * @param[in] cbs #LinphoneCallCbs object to remove. |
|---|
| | | * @param call #LinphoneCall object. @notnil |
|---|
| | | * @param cbs #LinphoneCallCbs object to remove. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_remove_callbacks(LinphoneCall *call, LinphoneCallCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the current LinphoneCallCbs. |
|---|
| | | * This is meant only to be called from a callback to be able to get the user_data associated with the #LinphoneCallCbs that is calling the callback. |
|---|
| | | * @param[in] call #LinphoneCall object |
|---|
| | | * @return The #LinphoneCallCbs that has called the last callback |
|---|
| | | * @param call #LinphoneCall object. @notnil |
|---|
| | | * @return The #LinphoneCallCbs that has called the last callback @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneCallCbs *linphone_call_get_current_callbacks(const LinphoneCall *call); |
|---|
| | | |
|---|
| | |
|---|
| | | * However, in some cases it might be desirable from a software design standpoint to modify local parameters outside of the application layer, typically |
|---|
| | | * in the purpose of implementing a custom logic including special headers in INVITE or 200Ok requests, driven by a call_state_changed listener method. |
|---|
| | | * This function accepts to assign a new #LinphoneCallParams only in #LinphoneCallOutgoingInit and #LinphoneCallIncomingReceived states. |
|---|
| | | * @param call the #LinphoneCall object |
|---|
| | | * |
|---|
| | | * @param call the #LinphoneCall object @notnil |
|---|
| | | * @param params the #LinphoneCallParams object @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_set_params(LinphoneCall *call, const LinphoneCallParams *params); |
|---|
| | | |
|---|
| | |
|---|
| | | * Returns local parameters associated with the call. |
|---|
| | | * This is typically the parameters passed at call initiation to linphone_core_invite_address_with_params() or linphone_call_accept_with_params(), or some default |
|---|
| | | * parameters if no #LinphoneCallParams was explicitely passed during call initiation. |
|---|
| | | * @param call the #LinphoneCall object |
|---|
| | | * @return the call's local parameters. |
|---|
| | | * @param call the #LinphoneCall object @notnil |
|---|
| | | * @return the call's local parameters. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const LinphoneCallParams *linphone_call_get_params(LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the given #LinphoneAudioDevice as input for this call only. |
|---|
| | | * @param call The #LinphoneCall @notnil |
|---|
| | | * @param audio_device The #LinphoneAudioDevice. NULL does nothing. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_set_input_audio_device(LinphoneCall *call, LinphoneAudioDevice *audio_device); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the given #LinphoneAudioDevice as output for this call only. |
|---|
| | | * @param call The #LinphoneCall @notnil |
|---|
| | | * @param audio_device The #LinphoneAudioDevice. NULL does nothing. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_set_output_audio_device(LinphoneCall *call, LinphoneAudioDevice *audio_device); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the current input device for this call. |
|---|
| | | * @param call The #LinphoneCall @notnil |
|---|
| | | * @return the #LinphoneAudioDevice used by this call as input or NULL if there is currently no soundcard configured (depending on the state of the call) @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const LinphoneAudioDevice* linphone_call_get_input_audio_device(const LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the current output device for this call. |
|---|
| | | * @param call The #LinphoneCall @notnil |
|---|
| | | * @return the #LinphoneAudioDevice used by this call as output or NULL if there is currently no soundcard configured (depending on the state of the call) @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const LinphoneAudioDevice* linphone_call_get_output_audio_device(const LinphoneCall *call); |
|---|
| | | |
|---|
| | | /************ */ |
|---|
| | | /* DEPRECATED */ |
|---|
| | | /* ********** */ |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Redirect the specified call to the given redirect URI. |
|---|
| | | * @param call The #LinphoneCall object @notnil |
|---|
| | | * @param redirect_uri The URI to redirect the call to @notnil |
|---|
| | | * @return 0 if successful, -1 on error. |
|---|
| | | * @deprecated 27/10/2020. Use linphone_call_redirect_to() instead. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_call_redirect (LinphoneCall *call, const char *redirect_uri); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Performs a simple call transfer to the specified destination. |
|---|
| | | * The remote endpoint is expected to issue a new call to the specified destination. |
|---|
| | | * The current call remains active and thus can be later paused or terminated. |
|---|
| | | * It is possible to follow the progress of the transfer provided that transferee sends notification about it. |
|---|
| | | * In this case, the transfer_state_changed callback of the #LinphoneCoreVTable is invoked to notify of the state of the new call at the other party. |
|---|
| | | * The notified states are #LinphoneCallOutgoingInit , #LinphoneCallOutgoingProgress, #LinphoneCallOutgoingRinging and #LinphoneCallConnected. |
|---|
| | | * @param call The call to be transfered @notnil |
|---|
| | | * @param refer_to The destination the call is to be refered to. @notnil |
|---|
| | | * @return 0 on success, -1 on failure |
|---|
| | | * @deprecated 27/10/2020. Use linphone_call_transfer_to() instead. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_call_transfer (LinphoneCall *call, const char *refer_to); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the remote address associated to this call as a string. |
|---|
| | | * The result string must be freed by user using ms_free(). |
|---|
| | | * @param call #LinphoneCall object. @notnil |
|---|
| | | * @return the remote address as a string. @maybenil |
|---|
| | | * @deprecated 06/07/2020 use linphone_call_get_remote_address() instead. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED char *linphone_call_get_remote_address_as_string (const LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @deprecated 23/05/2018 |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED void linphone_call_set_next_video_frame_decoded_callback (LinphoneCall *call, LinphoneCallCbFunc cb, void *user_data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Perform a zoom of the video displayed during a call. |
|---|
| | | * @param call The #LinphoneCall object @notnil |
|---|
| | | * @param zoom_factor a floating point number describing the zoom factor. A value 1.0 corresponds to no zoom applied. |
|---|
| | | * @param cx a floating point number pointing the horizontal center of the zoom to be applied. This value should be between 0.0 and 1.0. |
|---|
| | | * @param cy a floating point number pointing the vertical center of the zoom to be applied. This value should be between 0.0 and 1.0. |
|---|
| | | * @deprecated 16/10/2017 use linphone_call_zoom instead |
|---|
| | | * @donotwrap |
|---|
| | | * cx and cy are updated in return in case their coordinates were too excentrated for the requested zoom factor. The zoom ensures that all the screen is fullfilled with the video. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED void linphone_call_zoom_video (LinphoneCall *call, float zoom_factor, float *cx, float *cy); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Return TRUE if this call is currently part of a conference |
|---|
| | | * @param call The #LinphoneCall object @notnil |
|---|
| | | * @return TRUE if part of a conference. |
|---|
| | | * @deprecated 21/09/2017 Use linphone_call_get_conference() instead. |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED bool_t linphone_call_is_in_conference (const LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @} |
|---|
| | | */ |
|---|
| | | |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback for being notified of received DTMFs. |
|---|
| | | * @param call #LinphoneCall object that received the dtmf |
|---|
| | | * @param call #LinphoneCall object that received the dtmf @notnil |
|---|
| | | * @param dtmf The ascii code of the dtmf |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCallCbsDtmfReceivedCb)(LinphoneCall *call, int dtmf); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Call encryption changed callback. |
|---|
| | | * @param call #LinphoneCall object whose encryption is changed. |
|---|
| | | * @param call #LinphoneCall object whose encryption is changed. @notnil |
|---|
| | | * @param on Whether encryption is activated. |
|---|
| | | * @param authentication_token An authentication_token, currently set for ZRTP kind of encryption only. |
|---|
| | | * @param authentication_token An authentication_token, currently set for ZRTP kind of encryption only. @maybenil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCallCbsEncryptionChangedCb)(LinphoneCall *call, bool_t on, const char *authentication_token); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback for receiving info messages. |
|---|
| | | * @param call #LinphoneCall whose info message belongs to. |
|---|
| | | * @param msg #LinphoneInfoMessage object. |
|---|
| | | * @param call #LinphoneCall whose info message belongs to. @notnil |
|---|
| | | * @param message #LinphoneInfoMessage object. @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCallCbsInfoMessageReceivedCb)(LinphoneCall *call, const LinphoneInfoMessage *msg); |
|---|
| | | typedef void (*LinphoneCallCbsInfoMessageReceivedCb)(LinphoneCall *call, const LinphoneInfoMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Call state notification callback. |
|---|
| | | * @param call #LinphoneCall whose state is changed. |
|---|
| | | * @param cstate The new state of the call |
|---|
| | | * @param message An informational message about the state. |
|---|
| | | * @param call #LinphoneCall whose state is changed. @notnil |
|---|
| | | * @param state The new #LinphoneCallState of the call |
|---|
| | | * @param message An informational message about the state. @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCallCbsStateChangedCb)(LinphoneCall *call, LinphoneCallState cstate, const char *message); |
|---|
| | | typedef void (*LinphoneCallCbsStateChangedCb)(LinphoneCall *call, LinphoneCallState state, const char *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback for receiving quality statistics for calls. |
|---|
| | | * @param call #LinphoneCall object whose statistics are notified |
|---|
| | | * @param stats #LinphoneCallStats object |
|---|
| | | * @param call #LinphoneCall object whose statistics are notified @notnil |
|---|
| | | * @param stats #LinphoneCallStats object @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCallCbsStatsUpdatedCb)(LinphoneCall *call, const LinphoneCallStats *stats); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback for notifying progresses of transfers. |
|---|
| | | * @param call #LinphoneCall that was transfered |
|---|
| | | * @param cstate The state of the call to transfer target at the far end. |
|---|
| | | * @param call #LinphoneCall that was transfered @notnil |
|---|
| | | * @param state The #LinphoneCallState of the call to transfer target at the far end. |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCallCbsTransferStateChangedCb)(LinphoneCall *call, LinphoneCallState cstate); |
|---|
| | | typedef void (*LinphoneCallCbsTransferStateChangedCb)(LinphoneCall *call, LinphoneCallState state); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback for notifying the processing SIP ACK messages. |
|---|
| | | * @param call #LinphoneCall for which an ACK is being received or sent |
|---|
| | | * @param ack the ACK message |
|---|
| | | * @param call #LinphoneCall for which an ACK is being received or sent @notnil |
|---|
| | | * @param ack the ACK #LinphoneHeaders @notnil |
|---|
| | | * @param is_received if TRUE this ACK is an incoming one, otherwise it is an ACK about to be sent. |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCallCbsAckProcessingCb)(LinphoneCall *call, LinphoneHeaders *ack, bool_t is_received); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback for notifying a received TMMBR. |
|---|
| | | * @param call LinphoneCall for which the TMMBR has changed |
|---|
| | | * @param call LinphoneCall for which the TMMBR has changed @notnil |
|---|
| | | * @param stream_index the index of the current stream |
|---|
| | | * @param tmmbr the value of the received TMMBR |
|---|
| | | */ |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback for notifying a snapshot taken. |
|---|
| | | * @param call LinphoneCall for which the snapshot was taken |
|---|
| | | * @param filepath the name of the saved file |
|---|
| | | * @param call LinphoneCall for which the snapshot was taken @notnil |
|---|
| | | * @param file_path the name of the saved file @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCallCbsSnapshotTakenCb)(LinphoneCall *call, const char *filepath); |
|---|
| | | typedef void (*LinphoneCallCbsSnapshotTakenCb)(LinphoneCall *call, const char *file_path); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | /** |
|---|
| | | * Callback to notify a next video frame has been decoded |
|---|
| | | * @param call LinphoneCall for which the next video frame has been decoded |
|---|
| | | * @param call LinphoneCall for which the next video frame has been decoded @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCallCbsNextVideoFrameDecodedCb)(LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback to notify that the camera is not working and has been changed to "No Webcam". |
|---|
| | | * |
|---|
| | | * A camera is detected as mis-functionning as soon as it outputs no frames at all during |
|---|
| | | * a period of 5 seconds. |
|---|
| | | * This check is only performed on desktop platforms, in the purpose of notifying camera |
|---|
| | | * failures, for example if when a usb cable gets disconnected. |
|---|
| | | * |
|---|
| | | * @param call LinphoneCall for which the next video frame has been decoded @notnil |
|---|
| | | * @param camera_name the name of the non-working camera @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCallCbsCameraNotWorkingCb)(LinphoneCall *call, const char *camera_name); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback to notify that the audio device has been changed. |
|---|
| | | * |
|---|
| | | * @param call LinphoneCall for which the audio device has changed @notnil |
|---|
| | | * @param audio_device the new audio device used for this call @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCallCbsAudioDeviceChangedCb)(LinphoneCall *call, LinphoneAudioDevice *audio_device); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @} |
|---|
| | |
|---|
| | | * @{ |
|---|
| | | */ |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Call back used to notify message delivery status |
|---|
| | | * @param msg #LinphoneChatMessage object |
|---|
| | | * @param status #LinphoneChatMessageState |
|---|
| | | * @param ud application user data |
|---|
| | | * @deprecated Use #LinphoneChatMessageCbsMsgStateChangedCb instead. |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneChatMessageStateChangedCb)(LinphoneChatMessage* msg, LinphoneChatMessageState state, void* ud); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Call back used to notify message delivery status |
|---|
| | | * @param msg #LinphoneChatMessage object |
|---|
| | | * @param status #LinphoneChatMessageState |
|---|
| | | * @param message #LinphoneChatMessage object @notnil |
|---|
| | | * @param state #LinphoneChatMessageState |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneChatMessageCbsMsgStateChangedCb)(LinphoneChatMessage* msg, LinphoneChatMessageState state); |
|---|
| | | typedef void (*LinphoneChatMessageCbsMsgStateChangedCb)(LinphoneChatMessage* message, LinphoneChatMessageState state); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Call back used to notify participant IMDN state |
|---|
| | | * @param msg #LinphoneChatMessage object |
|---|
| | | * @param state #LinphoneParticipantImdnState |
|---|
| | | * @param message #LinphoneChatMessage object @notnil |
|---|
| | | * @param state #LinphoneParticipantImdnState @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneChatMessageCbsParticipantImdnStateChangedCb)(LinphoneChatMessage* msg, const LinphoneParticipantImdnState *state); |
|---|
| | | typedef void (*LinphoneChatMessageCbsParticipantImdnStateChangedCb)(LinphoneChatMessage* message, const LinphoneParticipantImdnState *state); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * File transfer receive callback prototype. This function is called by the core upon an incoming File transfer is started. This function may be call several time for the same file in case of large file. |
|---|
| | | * @param msg #LinphoneChatMessage message from which the body is received. |
|---|
| | | * @param content #LinphoneContent incoming content information |
|---|
| | | * @param buffer #LinphoneBuffer holding the received data. Empty buffer means end of file. |
|---|
| | | * @param message #LinphoneChatMessage message from which the body is received. @notnil |
|---|
| | | * @param content #LinphoneContent incoming content information @notnil |
|---|
| | | * @param buffer #LinphoneBuffer holding the received data. Empty buffer means end of file. @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneChatMessageCbsFileTransferRecvCb)(LinphoneChatMessage *msg, const LinphoneContent* content, const LinphoneBuffer *buffer); |
|---|
| | | typedef void (*LinphoneChatMessageCbsFileTransferRecvCb)(LinphoneChatMessage *message, LinphoneContent* content, const LinphoneBuffer *buffer); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * File transfer send callback prototype. This function is called by the core when an outgoing file transfer is started. This function is called until size is set to 0. |
|---|
| | | * @param msg #LinphoneChatMessage message from which the body is received. |
|---|
| | | * @param content #LinphoneContent outgoing content |
|---|
| | | * @param message #LinphoneChatMessage message from which the body is received. @notnil |
|---|
| | | * @param content #LinphoneContent outgoing content @notnil |
|---|
| | | * @param offset the offset in the file from where to get the data to be sent |
|---|
| | | * @param size the number of bytes expected by the framework |
|---|
| | | * @return A #LinphoneBuffer object holding the data written by the application. An empty buffer means end of file. |
|---|
| | | * @return A #LinphoneBuffer object holding the data written by the application. An empty buffer means end of file. @maybenil @warning The returned value isn't used, hence the deprecation! |
|---|
| | | * @deprecated 17/08/2020 Use #LinphoneChatMessageCbsFileTransferSendChunkCb instead. |
|---|
| | | */ |
|---|
| | | typedef LinphoneBuffer * (*LinphoneChatMessageCbsFileTransferSendCb)(LinphoneChatMessage *msg, const LinphoneContent* content, size_t offset, size_t size); |
|---|
| | | typedef LinphoneBuffer * (*LinphoneChatMessageCbsFileTransferSendCb)(LinphoneChatMessage *message, LinphoneContent* content, size_t offset, size_t size); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * File transfer send callback prototype. This function is called by the core when an outgoing file transfer is started. This function is called until size is set to 0. |
|---|
| | | * @param message #LinphoneChatMessage message from which the body is received. @notnil |
|---|
| | | * @param content #LinphoneContent outgoing content @notnil |
|---|
| | | * @param offset the offset in the file from where to get the data to be sent |
|---|
| | | * @param size the number of bytes expected by the framework |
|---|
| | | * @param buffer A #LinphoneBuffer to be filled. Leave it empty when end of file has been reached. @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneChatMessageCbsFileTransferSendChunkCb)(LinphoneChatMessage *message, LinphoneContent* content, size_t offset, size_t size, LinphoneBuffer *buffer); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * File transfer progress indication callback prototype. |
|---|
| | | * @param msg #LinphoneChatMessage message from which the body is received. |
|---|
| | | * @param content #LinphoneContent incoming content information |
|---|
| | | * @param message #LinphoneChatMessage message from which the body is received. @notnil |
|---|
| | | * @param content #LinphoneContent incoming content information @notnil |
|---|
| | | * @param offset The number of bytes sent/received since the beginning of the transfer. |
|---|
| | | * @param total The total number of bytes to be sent/received. |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneChatMessageCbsFileTransferProgressIndicationCb)(LinphoneChatMessage *msg, const LinphoneContent* content, size_t offset, size_t total); |
|---|
| | | typedef void (*LinphoneChatMessageCbsFileTransferProgressIndicationCb)(LinphoneChatMessage *message, LinphoneContent* content, size_t offset, size_t total); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback used to notify an ephemeral message that its lifespan before disappearing has started to decrease. |
|---|
| | | * This callback is called when the ephemeral message is read by the receiver. |
|---|
| | | * @param message #LinphoneChatMessage object @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneChatMessageCbsEphemeralMessageTimerStartedCb)(LinphoneChatMessage* message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Call back used to notify ephemeral message is deleted. |
|---|
| | | * @param message #LinphoneChatMessage object @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneChatMessageCbsEphemeralMessageDeletedCb)(LinphoneChatMessage* message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Is composing notification callback prototype. |
|---|
| | | * @param[in] cr #LinphoneChatRoom involved in the conversation |
|---|
| | | * @param[in] remoteAddr The address that has sent the is-composing notification |
|---|
| | | * @param[in] isComposing A boolean value telling whether the remote is composing or not |
|---|
| | | * @param chat_room #LinphoneChatRoom involved in the conversation @notnil |
|---|
| | | * @param remote_address The #LinphoneAddress that has sent the is-composing notification @notnil |
|---|
| | | * @param is_composing A boolean value telling whether the remote is composing or not |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneChatRoomCbsIsComposingReceivedCb) (LinphoneChatRoom *cr, const LinphoneAddress *remoteAddr, bool_t isComposing); |
|---|
| | | typedef void (*LinphoneChatRoomCbsIsComposingReceivedCb) (LinphoneChatRoom *chat_room, const LinphoneAddress *remote_address, bool_t is_composing); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback used to notify a chat room that a message has been received. |
|---|
| | | * @param[in] cr #LinphoneChatRoom object |
|---|
| | | * @param[in] msg The #LinphoneChatMessage that has been received |
|---|
| | | * @param chat_room #LinphoneChatRoom object @notnil |
|---|
| | | * @param message The #LinphoneChatMessage that has been received @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneChatRoomCbsMessageReceivedCb) (LinphoneChatRoom *cr, LinphoneChatMessage *msg); |
|---|
| | | typedef void (*LinphoneChatRoomCbsMessageReceivedCb) (LinphoneChatRoom *chat_room, LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback used to notify a chat room that an event log has been created. |
|---|
| | | * @param chat_room #LinphoneChatRoom object @notnil |
|---|
| | | * @param event_log #LinphoneEventLog The event to be notified @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneChatRoomCbsNewEventCb) (LinphoneChatRoom *chat_room, const LinphoneEventLog *event_log); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback used to notify a chat room that a chat message has been received. |
|---|
| | | * @param[in] cr #LinphoneChatRoom object |
|---|
| | | * @param[in] event_log #LinphoneEventLog The event to be notified |
|---|
| | | * @param chat_room #LinphoneChatRoom object @notnil |
|---|
| | | * @param event_log #LinphoneEventLog The event to be notified @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneChatRoomCbsChatMessageReceivedCb) (LinphoneChatRoom *cr, const LinphoneEventLog *event_log); |
|---|
| | | typedef void (*LinphoneChatRoomCbsChatMessageReceivedCb) (LinphoneChatRoom *chat_room, const LinphoneEventLog *event_log); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback used to notify a chat room that a chat message is being sent. |
|---|
| | | * @param[in] cr #LinphoneChatRoom object |
|---|
| | | * @param[in] event_log #LinphoneEventLog The event to be notified |
|---|
| | | * @param chat_room #LinphoneChatRoom object @notnil |
|---|
| | | * @param event_log #LinphoneEventLog The event to be notified @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneChatRoomCbsChatMessageSentCb) (LinphoneChatRoom *cr, const LinphoneEventLog *event_log); |
|---|
| | | typedef void (*LinphoneChatRoomCbsChatMessageSendingCb) (LinphoneChatRoom *chat_room, const LinphoneEventLog *event_log); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback used to notify a chat room that a chat message has been sent. |
|---|
| | | * @param chat_room #LinphoneChatRoom object @notnil |
|---|
| | | * @param event_log #LinphoneEventLog The event to be notified @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneChatRoomCbsChatMessageSentCb) (LinphoneChatRoom *chat_room, const LinphoneEventLog *event_log); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback used to notify a chat room that a participant has been added. |
|---|
| | | * @param[in] cr #LinphoneChatRoom object |
|---|
| | | * @param[in] event_log #LinphoneEventLog The event to be notified |
|---|
| | | * @param chat_room #LinphoneChatRoom object @notnil |
|---|
| | | * @param event_log #LinphoneEventLog The event to be notified @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneChatRoomCbsParticipantAddedCb) (LinphoneChatRoom *cr, const LinphoneEventLog *event_log); |
|---|
| | | typedef void (*LinphoneChatRoomCbsParticipantAddedCb) (LinphoneChatRoom *chat_room, const LinphoneEventLog *event_log); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback used to notify a chat room that a participant has been removed. |
|---|
| | | * @param[in] cr #LinphoneChatRoom object |
|---|
| | | * @param[in] event_log #LinphoneEventLog The event to be notified |
|---|
| | | * @param chat_room #LinphoneChatRoom object @notnil |
|---|
| | | * @param event_log #LinphoneEventLog The event to be notified @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneChatRoomCbsParticipantRemovedCb) (LinphoneChatRoom *cr, const LinphoneEventLog *event_log); |
|---|
| | | typedef void (*LinphoneChatRoomCbsParticipantRemovedCb) (LinphoneChatRoom *chat_room, const LinphoneEventLog *event_log); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback used to notify a chat room that the admin status of a participant has been changed. |
|---|
| | | * @param[in] cr #LinphoneChatRoom object |
|---|
| | | * @param[in] event_log #LinphoneEventLog The event to be notified |
|---|
| | | * @param chat_room #LinphoneChatRoom object @notnil |
|---|
| | | * @param event_log #LinphoneEventLog The event to be notified @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneChatRoomCbsParticipantAdminStatusChangedCb) (LinphoneChatRoom *cr, const LinphoneEventLog *event_log); |
|---|
| | | typedef void (*LinphoneChatRoomCbsParticipantAdminStatusChangedCb) (LinphoneChatRoom *chat_room, const LinphoneEventLog *event_log); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback used to notify a chat room state has changed. |
|---|
| | | * @param[in] cr #LinphoneChatRoom object |
|---|
| | | * @param[in] newState The new state of the chat room |
|---|
| | | * @param chat_room #LinphoneChatRoom object @notnil |
|---|
| | | * @param newState The new #LinphoneChatRoomState of the chat room |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneChatRoomCbsStateChangedCb) (LinphoneChatRoom *cr, LinphoneChatRoomState newState); |
|---|
| | | typedef void (*LinphoneChatRoomCbsStateChangedCb) (LinphoneChatRoom *chat_room, LinphoneChatRoomState newState); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback used to notify a security event in the chat room. |
|---|
| | | * @param[in] cr #LinphoneChatRoom object |
|---|
| | | * @param[in] event_log #LinphoneEventLog The event to be notified |
|---|
| | | * @param chat_room #LinphoneChatRoom object @notnil |
|---|
| | | * @param event_log #LinphoneEventLog The event to be notified @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneChatRoomCbsSecurityEventCb) (LinphoneChatRoom *cr, const LinphoneEventLog *event_log); |
|---|
| | | typedef void (*LinphoneChatRoomCbsSecurityEventCb) (LinphoneChatRoom *chat_room, const LinphoneEventLog *event_log); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback used to notify that the subject of a chat room has changed. |
|---|
| | | * @param[in] cr #LinphoneChatRoom object |
|---|
| | | * @param[in] event_log #LinphoneEventLog The event to be notified |
|---|
| | | * @param chat_room #LinphoneChatRoom object @notnil |
|---|
| | | * @param event_log #LinphoneEventLog The event to be notified @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneChatRoomCbsSubjectChangedCb) (LinphoneChatRoom *cr, const LinphoneEventLog *event_log); |
|---|
| | | typedef void (*LinphoneChatRoomCbsSubjectChangedCb) (LinphoneChatRoom *chat_room, const LinphoneEventLog *event_log); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback used to notify a chat room that a message has been received but we were unable to decrypt it |
|---|
| | | * @param cr #LinphoneChatRoom involved in this conversation |
|---|
| | | * @param msg The #LinphoneChatMessage that has been received |
|---|
| | | * @param chat_room #LinphoneChatRoom involved in this conversation @notnil |
|---|
| | | * @param message The #LinphoneChatMessage that has been received @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneChatRoomCbsUndecryptableMessageReceivedCb) (LinphoneChatRoom *cr, LinphoneChatMessage *msg); |
|---|
| | | typedef void (*LinphoneChatRoomCbsUndecryptableMessageReceivedCb) (LinphoneChatRoom *chat_room, LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback used to notify a chat room that a participant has been added. |
|---|
| | | * @param[in] cr #LinphoneChatRoom object |
|---|
| | | * @param[in] event_log #LinphoneEventLog The event to be notified |
|---|
| | | * @param chat_room #LinphoneChatRoom object @notnil |
|---|
| | | * @param event_log #LinphoneEventLog The event to be notified @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneChatRoomCbsParticipantDeviceAddedCb) (LinphoneChatRoom *cr, const LinphoneEventLog *event_log); |
|---|
| | | typedef void (*LinphoneChatRoomCbsParticipantDeviceAddedCb) (LinphoneChatRoom *chat_room, const LinphoneEventLog *event_log); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback used to notify a chat room that a participant has been removed. |
|---|
| | | * @param[in] cr #LinphoneChatRoom object |
|---|
| | | * @param[in] event_log #LinphoneEventLog The event to be notified |
|---|
| | | * @param chat_room #LinphoneChatRoom object @notnil |
|---|
| | | * @param event_log #LinphoneEventLog The event to be notified @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneChatRoomCbsParticipantDeviceRemovedCb) (LinphoneChatRoom *cr, const LinphoneEventLog *event_log); |
|---|
| | | typedef void (*LinphoneChatRoomCbsParticipantDeviceRemovedCb) (LinphoneChatRoom *chat_room, const LinphoneEventLog *event_log); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback used to notify a chat room has been joined. |
|---|
| | | * @param[in] cr #LinphoneChatRoom object |
|---|
| | | * @param[in] event_log #LinphoneEventLog The event to be notified |
|---|
| | | * @param chat_room #LinphoneChatRoom object @notnil |
|---|
| | | * @param event_log #LinphoneEventLog The event to be notified @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneChatRoomCbsConferenceJoinedCb) (LinphoneChatRoom *cr, const LinphoneEventLog *eventLog); |
|---|
| | | typedef void (*LinphoneChatRoomCbsConferenceJoinedCb) (LinphoneChatRoom *chat_room, const LinphoneEventLog *event_log); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback used to notify a chat room has been left. |
|---|
| | | * @param[in] cr #LinphoneChatRoom object |
|---|
| | | * @param[in] event_log #LinphoneEventLog The event to be notified |
|---|
| | | * @param chat_room #LinphoneChatRoom object @notnil |
|---|
| | | * @param event_log #LinphoneEventLog The event to be notified @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneChatRoomCbsConferenceLeftCb) (LinphoneChatRoom *cr, const LinphoneEventLog *eventLog); |
|---|
| | | typedef void (*LinphoneChatRoomCbsConferenceLeftCb) (LinphoneChatRoom *chat_room, const LinphoneEventLog *event_log); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback used to notify a chat room that an ephemeral related event has been generated. |
|---|
| | | * @param chat_room #LinphoneChatRoom object @notnil |
|---|
| | | * @param event_log #LinphoneEventLog The event to be notified @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneChatRoomCbsEphemeralEventCb) (LinphoneChatRoom *chat_room, const LinphoneEventLog *event_log); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback used to notify a chat room that the lifespan of an ephemeral message before disappearing has started to decrease. |
|---|
| | | * This callback is called when the ephemeral message is read by the receiver. |
|---|
| | | * @param chat_room #LinphoneChatRoom object @notnil |
|---|
| | | * @param event_log #LinphoneEventLog The event to be notified @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneChatRoomCbsEphemeralMessageTimerStartedCb) (LinphoneChatRoom *chat_room, const LinphoneEventLog *event_log); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback used to notify a chat room that an ephemeral message has been deleted. |
|---|
| | | * @param chat_room #LinphoneChatRoom object @notnil |
|---|
| | | * @param event_log #LinphoneEventLog The event to be notified @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneChatRoomCbsEphemeralMessageDeletedCb) (LinphoneChatRoom *chat_room, const LinphoneEventLog *event_log); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback used when a group chat room is created server-side to generate the address of the chat room. |
|---|
| | | * The function linphone_chat_room_set_conference_address() needs to be called by this callback. |
|---|
| | | * @param[in] cr #LinphoneChatRoom object |
|---|
| | | * @param chat_room #LinphoneChatRoom object @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneChatRoomCbsConferenceAddressGenerationCb) (LinphoneChatRoom *cr); |
|---|
| | | typedef void (*LinphoneChatRoomCbsConferenceAddressGenerationCb) (LinphoneChatRoom *chat_room); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback used when a group chat room server is subscribing to registration state of a participant. |
|---|
| | | * @param[in] cr #LinphoneChatRoom object |
|---|
| | | * @param[in] participantAddr #LinphoneAddress object |
|---|
| | | * @param chat_room #LinphoneChatRoom object @notnil |
|---|
| | | * @param participant_address #LinphoneAddress object @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneChatRoomCbsParticipantRegistrationSubscriptionRequestedCb) (LinphoneChatRoom *cr, const LinphoneAddress *participantAddr); |
|---|
| | | typedef void (*LinphoneChatRoomCbsParticipantRegistrationSubscriptionRequestedCb) (LinphoneChatRoom *chat_room, const LinphoneAddress *participant_address); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback used when a group chat room server is unsubscribing to registration state of a participant. |
|---|
| | | * @param[in] cr #LinphoneChatRoom object |
|---|
| | | * @param[in] participantAddr #LinphoneAddress object |
|---|
| | | * @param chat_room #LinphoneChatRoom object @notnil |
|---|
| | | * @param participant_address #LinphoneAddress object @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneChatRoomCbsParticipantRegistrationUnsubscriptionRequestedCb) (LinphoneChatRoom *cr, const LinphoneAddress *participantAddr); |
|---|
| | | typedef void (*LinphoneChatRoomCbsParticipantRegistrationUnsubscriptionRequestedCb) (LinphoneChatRoom *chat_room, const LinphoneAddress *participant_address); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback used to tell the core whether or not to store the incoming message in db or not using linphone_chat_message_set_to_be_stored(). |
|---|
| | | * @param[in] cr #LinphoneChatRoom object |
|---|
| | | * @param[in] msg The #LinphoneChatMessage that is being received |
|---|
| | | * @param chat_room #LinphoneChatRoom object @notnil |
|---|
| | | * @param message The #LinphoneChatMessage that is being received @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneChatRoomCbsShouldChatMessageBeStoredCb) (LinphoneChatRoom *cr, LinphoneChatMessage *msg); |
|---|
| | | typedef void (*LinphoneChatRoomCbsShouldChatMessageBeStoredCb) (LinphoneChatRoom *chat_room, LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback used to notify a participant state has changed in a message of this chat room. |
|---|
| | | * @param chat_room #LinphoneChatRoom object @notnil |
|---|
| | | * @param message The #LinphoneChatMessage for which a participant has it's state changed @notnil |
|---|
| | | * @param state The #LinphoneParticipantImdnState @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneChatRoomCbsChatMessageParticipantImdnStateChangedCb) (LinphoneChatRoom *chat_room, LinphoneChatMessage *message, const LinphoneParticipantImdnState *state); |
|---|
| | | |
|---|
| | | /************ */ |
|---|
| | | /* DEPRECATED */ |
|---|
| | | /* ********** */ |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Call back used to notify message delivery status |
|---|
| | | * @param message #LinphoneChatMessage object @notnil |
|---|
| | | * @param state #LinphoneChatMessageState |
|---|
| | | * @param user_data application user data |
|---|
| | | * @deprecated 03/07/2018 Use #LinphoneChatMessageCbsMsgStateChangedCb instead. |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneChatMessageStateChangedCb)(LinphoneChatMessage* message, LinphoneChatMessageState state, void* user_data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @} |
|---|
| | | **/ |
|---|
| | | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @addtogroup conference |
|---|
| | | * @{ |
|---|
| | | */ |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback used to notify a chat room that a participant has been added. |
|---|
| | | * @param[in] conference #LinphoneConference object @notnil |
|---|
| | | * @param[in] participant #LinphoneParticipant that has been added to the conference @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneConferenceCbsParticipantAddedCb) (LinphoneConference *conference, const LinphoneParticipant *participant); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback used to notify a chat room that a participant has been removed. |
|---|
| | | * @param[in] conference #LinphoneConference object @notnil |
|---|
| | | * @param[in] participant #LinphoneParticipant that has been removed to the conference @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneConferenceCbsParticipantRemovedCb) (LinphoneConference *conference, const LinphoneParticipant *participant); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback used to notify a chat room that the admin status of a participant has been changed. |
|---|
| | | * @param[in] conference #LinphoneConference object @notnil |
|---|
| | | * @param[in] participant #LinphoneParticipant whose admin status has changed @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneConferenceCbsParticipantAdminStatusChangedCb) (LinphoneConference *conference, const LinphoneParticipant *participant); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback used to notify a chat room state has changed. |
|---|
| | | * @param[in] conference #LinphoneConference object @notnil |
|---|
| | | * @param[in] newState The new state of the chat room |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneConferenceCbsStateChangedCb) (LinphoneConference *conference, LinphoneConferenceState newState); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback used to notify that the subject of a chat room has changed. |
|---|
| | | * @param[in] conference #LinphoneConference object @notnil |
|---|
| | | * @param[in] subject subject of the conference @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneConferenceCbsSubjectChangedCb) (LinphoneConference *conference, const char *subject); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback used to notify a chat room that a participant has been added. |
|---|
| | | * @param[in] conference #LinphoneConference object @notnil |
|---|
| | | * @param[in] participant_device #LinphoneParticipantDevice that has been added to the conference @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneConferenceCbsParticipantDeviceAddedCb) (LinphoneConference *conference, const LinphoneParticipantDevice *participant_device); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback used to notify a chat room that a participant has been removed. |
|---|
| | | * @param[in] conference #LinphoneConference object @notnil |
|---|
| | | * @param[in] participant_device #LinphoneParticipantDevice that has been removed to the conference @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneConferenceCbsParticipantDeviceRemovedCb) (LinphoneConference *conference, const LinphoneParticipantDevice *participant_device); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @} |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | LinphoneChatMessageCbs *linphone_chat_message_cbs_new (void); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Acquire a reference to the chat room callbacks object. |
|---|
| | | * @param[in] cbs The chat room callbacks object |
|---|
| | | * @return The same chat room callbacks object |
|---|
| | | * Acquire a reference to the chat message callbacks object. |
|---|
| | | * @param cbs The #LinphoneChatMessageCbs object @notnil |
|---|
| | | * @return The same chat message callbacks object |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatMessageCbs * linphone_chat_message_cbs_ref (LinphoneChatMessageCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Release reference to the chat room callbacks object. |
|---|
| | | * @param[in] cr The chat room callbacks object |
|---|
| | | * Release reference to the chat message callbacks object. |
|---|
| | | * @param cbs The #LinphoneChatMessageCbs object @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_message_cbs_unref (LinphoneChatMessageCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Retrieve the user pointer associated with the chat room callbacks object. |
|---|
| | | * @param[in] cr The chat room callbacks object |
|---|
| | | * @return The user pointer associated with the chat room callbacks object |
|---|
| | | * Retrieve the user pointer associated with the chat message callbacks object. |
|---|
| | | * @param cbs The #LinphoneChatMessageCbs object @notnil |
|---|
| | | * @return The user pointer associated with the chat message callbacks object. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void * linphone_chat_message_cbs_get_user_data (const LinphoneChatMessageCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user pointer to the chat room callbacks object. |
|---|
| | | * @param[in] cr The chat room callbacks object |
|---|
| | | * @param[in] ud The user pointer to associate with the chat room callbacks object |
|---|
| | | * Assign a user pointer to the chat message callbacks object. |
|---|
| | | * @param cbs The #LinphoneChatMessageCbs object @notnil |
|---|
| | | * @param user_data The user pointer to associate with the chat message callbacks object. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_message_cbs_set_user_data (LinphoneChatMessageCbs *cbs, void *ud); |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_message_cbs_set_user_data (LinphoneChatMessageCbs *cbs, void *user_data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the message state changed callback. |
|---|
| | | * @param[in] cbs #LinphoneChatMessageCbs object. |
|---|
| | | * @param cbs #LinphoneChatMessageCbs object. @notnil |
|---|
| | | * @return The current message state changed callback. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatMessageCbsMsgStateChangedCb linphone_chat_message_cbs_get_msg_state_changed (const LinphoneChatMessageCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the message state changed callback. |
|---|
| | | * @param[in] cbs LinphoneChatMessageCbs object. |
|---|
| | | * @param[in] cb The message state changed callback to be used. |
|---|
| | | * @param cbs LinphoneChatMessageCbs object. @notnil |
|---|
| | | * @param cb The message state changed callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_message_cbs_set_msg_state_changed (LinphoneChatMessageCbs *cbs, LinphoneChatMessageCbsMsgStateChangedCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the file transfer receive callback. |
|---|
| | | * @param[in] cbs LinphoneChatMessageCbs object. |
|---|
| | | * @param cbs LinphoneChatMessageCbs object. @notnil |
|---|
| | | * @return The current file transfer receive callback. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatMessageCbsFileTransferRecvCb linphone_chat_message_cbs_get_file_transfer_recv (const LinphoneChatMessageCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the file transfer receive callback. |
|---|
| | | * @param[in] cbs LinphoneChatMessageCbs object. |
|---|
| | | * @param[in] cb The file transfer receive callback to be used. |
|---|
| | | * @param cbs LinphoneChatMessageCbs object. @notnil |
|---|
| | | * @param cb The file transfer receive callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_message_cbs_set_file_transfer_recv (LinphoneChatMessageCbs *cbs, LinphoneChatMessageCbsFileTransferRecvCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the file transfer send callback. |
|---|
| | | * @param[in] cbs LinphoneChatMessageCbs object. |
|---|
| | | * @param cbs LinphoneChatMessageCbs object. @notnil |
|---|
| | | * @return The current file transfer send callback. |
|---|
| | | * @deprecated 17/08/2020 Use #linphone_chat_message_cbs_get_file_transfer_send_chunk() instead. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatMessageCbsFileTransferSendCb linphone_chat_message_cbs_get_file_transfer_send (const LinphoneChatMessageCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the file transfer send callback. |
|---|
| | | * @param[in] cbs LinphoneChatMessageCbs object. |
|---|
| | | * @param[in] cb The file transfer send callback to be used. |
|---|
| | | * @param cbs LinphoneChatMessageCbs object. @notnil |
|---|
| | | * @param cb The file transfer send callback to be used. |
|---|
| | | * @deprecated 17/08/2020 Use #linphone_chat_message_cbs_set_file_transfer_send_chunk() instead. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_message_cbs_set_file_transfer_send (LinphoneChatMessageCbs *cbs, LinphoneChatMessageCbsFileTransferSendCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the file transfer send callback. |
|---|
| | | * @param cbs LinphoneChatMessageCbs object. @notnil |
|---|
| | | * @return The current file transfer send callback. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatMessageCbsFileTransferSendChunkCb linphone_chat_message_cbs_get_file_transfer_send_chunk (const LinphoneChatMessageCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the file transfer send callback. |
|---|
| | | * @param cbs LinphoneChatMessageCbs object. @notnil |
|---|
| | | * @param cb The file transfer send callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_message_cbs_set_file_transfer_send_chunk (LinphoneChatMessageCbs *cbs, LinphoneChatMessageCbsFileTransferSendChunkCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the file transfer progress indication callback. |
|---|
| | | * @param[in] cbs LinphoneChatMessageCbs object. |
|---|
| | | * @param cbs LinphoneChatMessageCbs object. @notnil |
|---|
| | | * @return The current file transfer progress indication callback. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatMessageCbsFileTransferProgressIndicationCb linphone_chat_message_cbs_get_file_transfer_progress_indication (const LinphoneChatMessageCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the file transfer progress indication callback. |
|---|
| | | * @param[in] cbs LinphoneChatMessageCbs object. |
|---|
| | | * @param[in] cb The file transfer progress indication callback to be used. |
|---|
| | | * @param cbs LinphoneChatMessageCbs object. @notnil |
|---|
| | | * @param cb The file transfer progress indication callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_message_cbs_set_file_transfer_progress_indication (LinphoneChatMessageCbs *cbs, LinphoneChatMessageCbsFileTransferProgressIndicationCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the participant IMDN state changed callback. |
|---|
| | | * @param[in] cbs #LinphoneChatMessageCbs object. |
|---|
| | | * @param cbs #LinphoneChatMessageCbs object. @notnil |
|---|
| | | * @return The current participant IMDN state changed callback. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatMessageCbsParticipantImdnStateChangedCb linphone_chat_message_cbs_get_participant_imdn_state_changed (const LinphoneChatMessageCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the participant IMDN state changed callback. |
|---|
| | | * @param[in] cbs LinphoneChatMessageCbs object. |
|---|
| | | * @param[in] cb The participant IMDN state changed callback to be used. |
|---|
| | | * @param cbs LinphoneChatMessageCbs object. @notnil |
|---|
| | | * @param cb The participant IMDN state changed callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_message_cbs_set_participant_imdn_state_changed (LinphoneChatMessageCbs *cbs, LinphoneChatMessageCbsParticipantImdnStateChangedCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the current "ephemeral message timer started" callback. This callback is called when the message deletion timer starts (the message has been viewed). |
|---|
| | | * @param cbs #LinphoneChatMessageCbs object. @notnil |
|---|
| | | * @return The current ephemeral message timer started callback. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatMessageCbsEphemeralMessageTimerStartedCb linphone_chat_message_cbs_get_ephemeral_message_timer_started (const LinphoneChatMessageCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the ephemeral message timer started callback. This callback will be used when new message deletion timer starts (the message has been viewed). |
|---|
| | | * @param cbs LinphoneChatMessageCbs object. @notnil |
|---|
| | | * @param cb The ephemeral message timer started callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_message_cbs_set_ephemeral_message_timer_started (LinphoneChatMessageCbs *cbs, LinphoneChatMessageCbsEphemeralMessageTimerStartedCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the ephemeral message deleted callback. This callback is used when a message deletion timer runs out (message is deleted). |
|---|
| | | * @param cbs #LinphoneChatMessageCbs object. @notnil |
|---|
| | | * @return The current ephemeral message deleted callback. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatMessageCbsEphemeralMessageDeletedCb linphone_chat_message_cbs_get_ephemeral_message_deleted (const LinphoneChatMessageCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the ephemeral message deleted callback. This callback is used when new message deletion timer runs out (message is deleted). |
|---|
| | | * @param cbs LinphoneChatMessageCbs object. @notnil |
|---|
| | | * @param cb The ephemeral message deleted callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_message_cbs_set_ephemeral_message_deleted (LinphoneChatMessageCbs *cbs, LinphoneChatMessageCbsEphemeralMessageDeletedCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @} |
|---|
| | | */ |
|---|
| | | |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Acquire a reference to the chat message. |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * @return The same chat message. |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @return The same #LinphoneChatMessage object. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatMessage *linphone_chat_message_ref (LinphoneChatMessage *msg); |
|---|
| | | LINPHONE_PUBLIC LinphoneChatMessage *linphone_chat_message_ref (LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Release reference to the chat message. |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_message_unref (LinphoneChatMessage *msg); |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_message_unref (LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Retrieve the user pointer associated with the chat message. |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * @return The user pointer associated with the chat message. |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @return The user pointer associated with the chat message. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void *linphone_chat_message_get_user_data (const LinphoneChatMessage *msg); |
|---|
| | | LINPHONE_PUBLIC void *linphone_chat_message_get_user_data (const LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user pointer to the chat message. |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * @param[in] ud The user pointer to associate with the chat message. |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @param user_data The user pointer to associate with the chat message. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_message_set_user_data (LinphoneChatMessage *msg, void *ud); |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_message_set_user_data (LinphoneChatMessage *message, void *user_data); |
|---|
| | | |
|---|
| | | // ============================================================================= |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns back pointer to #LinphoneCore object. |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @return the #LinphoneCore object associated with this message. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneCore *linphone_chat_message_get_core (const LinphoneChatMessage *msg); |
|---|
| | | LINPHONE_PUBLIC LinphoneCore *linphone_chat_message_get_core (const LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | LINPHONE_PUBLIC const char *linphone_chat_message_get_external_body_url (const LinphoneChatMessage *msg); |
|---|
| | | /** |
|---|
| | | * Linphone message can carry external body as defined by rfc2017 |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @return external body url or NULL if not present. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_chat_message_get_external_body_url (const LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_message_set_external_body_url (LinphoneChatMessage *msg, const char *external_body_url); |
|---|
| | | /** |
|---|
| | | * Linphone message can carry external body as defined by rfc2017 |
|---|
| | | * |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @param external_body_url ex: access-type=URL; URL="http://www.foo.com/file" @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_message_set_external_body_url (LinphoneChatMessage *message, const char *external_body_url); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the time the message was sent. |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @return the timestamp of when the message was sent. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC time_t linphone_chat_message_get_time (const LinphoneChatMessage *msg); |
|---|
| | | LINPHONE_PUBLIC time_t linphone_chat_message_get_time (const LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns TRUE if the message has been sent, returns FALSE if the message has been received. |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * Returns wehther the message has been sent or received. |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @return TRUE if message has been sent, FALSE if it has been received. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_chat_message_is_outgoing (const LinphoneChatMessage *msg); |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_chat_message_is_outgoing (const LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get origin of the message |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * @return #LinphoneAddress |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @return the #LinphoneAddress of the sender. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress *linphone_chat_message_get_from_address (const LinphoneChatMessage *msg); |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress *linphone_chat_message_get_from_address (const LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get destination of the message |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * @return #LinphoneAddress |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @return the #LinphoneAddress of the recipient. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress *linphone_chat_message_get_to_address (const LinphoneChatMessage *msg); |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress *linphone_chat_message_get_to_address (const LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the content type of a chat message. |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * @return The content type of the chat message |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @return The content type of the chat message @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_chat_message_get_content_type (const LinphoneChatMessage *msg); |
|---|
| | | LINPHONE_PUBLIC const char *linphone_chat_message_get_content_type (const LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the content type of a chat message. |
|---|
| | | * This content type must match a content that is text representable, such as text/plain, text/html or image/svg+xml. |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * @param[in] content_type The new content type of the chat message |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @param content_type The new content type of the chat message @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_message_set_content_type (LinphoneChatMessage *msg, const char *content_type); |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_message_set_content_type (LinphoneChatMessage *message, const char *content_type); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get text part of this message |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * @return text or NULL if no text. |
|---|
| | | * @deprecated use getTextContent() instead |
|---|
| | | * Get text part of this message. Introduced in 01/07/2020 |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @return The text in UTF8 or NULL if no text. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_chat_message_get_text (const LinphoneChatMessage* msg); |
|---|
| | | LINPHONE_PUBLIC const char *linphone_chat_message_get_utf8_text (const LinphoneChatMessage* message); |
|---|
| | | |
|---|
| | | /** Set a chat message text to be sent by linphone_chat_room_send_message(). Introduced in 01/07/2020 |
|---|
| | | * @param message #LinphoneChatMessage @notnil |
|---|
| | | * @param text The text in UTF8 to set. @maybenil |
|---|
| | | * @return 0 if succeed. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC int linphone_chat_message_set_utf8_text(LinphoneChatMessage *message , const char* text); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the message identifier. |
|---|
| | | * It is used to identify a message so that it can be notified as delivered and/or displayed. |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * @return The message identifier. |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @return The message identifier. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_chat_message_get_message_id (const LinphoneChatMessage *msg); |
|---|
| | | LINPHONE_PUBLIC const char *linphone_chat_message_get_message_id (const LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Linphone message has an app-specific field that can store a text. The application might want |
|---|
| | | * to use it for keeping data over restarts, like thumbnail image path. |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * @return the application-specific data or NULL if none has been stored. |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @return the application-specific data or NULL if none has been stored. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_chat_message_get_appdata (const LinphoneChatMessage *msg); |
|---|
| | | LINPHONE_PUBLIC const char *linphone_chat_message_get_appdata (const LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Linphone message has an app-specific field that can store a text. The application might want |
|---|
| | | * to use it for keeping data over restarts, like thumbnail image path. |
|---|
| | | * |
|---|
| | | * Invoking this function will attempt to update the message storage to reflect the changeif it is |
|---|
| | | * Invoking this function will attempt to update the message storage to reflect the change if it is |
|---|
| | | * enabled. |
|---|
| | | * |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * @param data the data to store into the message |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @param data the data to store into the message. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_message_set_appdata (LinphoneChatMessage *msg, const char *data); |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_message_set_appdata (LinphoneChatMessage *message, const char *data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the chatroom this message belongs to. |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @return the #LinphoneChatRoom in which this message has been sent or received. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoom *linphone_chat_message_get_chat_room (const LinphoneChatMessage *msg); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the path to the file to read from or write to during the file transfer. |
|---|
| | | * @param[in] msg #LinphoneChatMessage object |
|---|
| | | * @return The path to the file to use for the file transfer. |
|---|
| | | * @deprecated use linphone_content_get_file_path() instead. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_chat_message_get_file_transfer_filepath (const LinphoneChatMessage *msg); |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoom *linphone_chat_message_get_chat_room (const LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | // ============================================================================= |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get if a chat message is to be stored. |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @return Whether or not the message is to be stored |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_chat_message_get_to_be_stored (const LinphoneChatMessage *msg); |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_chat_message_get_to_be_stored (const LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set if a chat message is to be stored. |
|---|
| | | * This content type must match a content that is text representable, such as text/plain, text/html or image/svg+xml. |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * @param[in] to_be_stored Whether or not the chat message is to be stored |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @param to_be_stored Whether or not the chat message is to be stored |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_message_set_to_be_stored (LinphoneChatMessage *msg, bool_t to_be_stored); |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_message_set_to_be_stored (LinphoneChatMessage *message, bool_t to_be_stored); |
|---|
| | | |
|---|
| | | LINPHONE_PUBLIC unsigned int linphone_chat_message_store (LinphoneChatMessage *msg); |
|---|
| | | LINPHONE_PUBLIC unsigned int linphone_chat_message_store (LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the state of the message |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * @return #LinphoneChatMessageState |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @return the current #LinphoneChatMessageState of the message. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatMessageState linphone_chat_message_get_state (const LinphoneChatMessage *msg); |
|---|
| | | LINPHONE_PUBLIC LinphoneChatMessageState linphone_chat_message_get_state (const LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get if the message was encrypted when transfered |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * @return whether the message was encrypted when transfered or not |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @return TRUE if the message was encrypted when transfered, FALSE otherwise. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_chat_message_is_secured (const LinphoneChatMessage *msg); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Linphone message can carry external body as defined by rfc2017 |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * @return external body url or NULL if not present. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_chat_message_get_external_body_url (const LinphoneChatMessage *msg); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Linphone message can carry external body as defined by rfc2017 |
|---|
| | | * |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * @param url ex: access-type=URL; URL="http://www.foo.com/file" |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_message_set_external_body_url (LinphoneChatMessage *msg,const char *url); |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_chat_message_is_secured (const LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the file_transfer_information (used by call backs to recover informations during a rcs file transfer) |
|---|
| | | * |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * @return a pointer to the #LinphoneContent structure or NULL if not present. |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @return a pointer to the #LinphoneContent structure or NULL if not present. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneContent *linphone_chat_message_get_file_transfer_information (const LinphoneChatMessage *msg); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Return whether or not a chat message is a file transfer. |
|---|
| | | * @param[in] msg #LinphoneChatMessage object |
|---|
| | | * @return Whether or not the message is a file transfer |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_chat_message_is_file_transfer (const LinphoneChatMessage *msg); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Return whether or not a chat message is a text. |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * @return Whether or not the message is a text |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_chat_message_is_text (const LinphoneChatMessage *msg); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Start the download of the file from remote server |
|---|
| | | * |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * @param status_cb #LinphoneChatMessageStateChangeCb status callback invoked when file is downloaded or could not be downloaded |
|---|
| | | * @param ud user data |
|---|
| | | * @deprecated Use linphone_chat_message_download_file() instead. |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED void linphone_chat_message_start_file_download ( |
|---|
| | | LinphoneChatMessage *msg, |
|---|
| | | LinphoneChatMessageStateChangedCb status_cb, |
|---|
| | | void *ud |
|---|
| | | ); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Start the download of the file referenced in a #LinphoneChatMessage from remote server. |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * @deprecated Use linphone_chat_message_download_content() instead |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_chat_message_download_file (LinphoneChatMessage *msg); |
|---|
| | | LINPHONE_PUBLIC LinphoneContent *linphone_chat_message_get_file_transfer_information (const LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Start the download of the #LinphoneContent referenced in the #LinphoneChatMessage from remote server. |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * @param[in] c_content #LinphoneContent object to download. |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @param content the #LinphoneContent object to download (must have the linphone_content_is_file_transfer() method return TRUE). @notnil |
|---|
| | | * @return FALSE if there is an error, TRUE otherwise. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_chat_message_download_content(LinphoneChatMessage *msg, LinphoneContent *c_content); |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_chat_message_download_content(LinphoneChatMessage *message, LinphoneContent *content); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Cancel an ongoing file transfer attached to this message.(upload or download) |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_message_cancel_file_transfer (LinphoneChatMessage *msg); |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_message_cancel_file_transfer (LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Send a chat message. |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_message_send (LinphoneChatMessage *msg); |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_message_send (LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress *linphone_chat_message_get_peer_address (const LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Resend a chat message if it is in the 'not delivered' state for whatever reason. |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * @deprecated Use linphone_chat_message_send instead. |
|---|
| | | * @donotwrap |
|---|
| | | * Returns the local address the message was sent or received with. |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @return the #LinphoneAddress of the local address used to send/receive this message. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED void linphone_chat_message_resend (LinphoneChatMessage *msg); |
|---|
| | | |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress *linphone_chat_message_get_peer_address (const LinphoneChatMessage *msg); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the origin address of a message if it was a outgoing message, or the destination address if it was an incoming message. |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * @return #LinphoneAddress |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress *linphone_chat_message_get_local_address (const LinphoneChatMessage *msg); |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress *linphone_chat_message_get_local_address (const LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Add custom headers to the message. |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * @param header_name name of the header |
|---|
| | | * @param header_value header value |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @param header_name name of the header @notnil |
|---|
| | | * @param header_value header value @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_message_add_custom_header ( |
|---|
| | | LinphoneChatMessage *msg, |
|---|
| | | LinphoneChatMessage *message, |
|---|
| | | const char *header_name, |
|---|
| | | const char *header_value |
|---|
| | | ); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Retrieve a custom header value given its name. |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * @param header_name header name searched |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @param header_name header name searched @notnil |
|---|
| | | * @return the custom header value or NULL if not found. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_chat_message_get_custom_header (const LinphoneChatMessage *msg, const char *header_name); |
|---|
| | | LINPHONE_PUBLIC const char * linphone_chat_message_get_custom_header (const LinphoneChatMessage *message, const char *header_name); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Removes a custom header from the message. |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * @param header_name name of the header to remove |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @param header_name name of the header to remove @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_message_remove_custom_header (LinphoneChatMessage *msg, const char *header_name); |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_message_remove_custom_header (LinphoneChatMessage *message, const char *header_name); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns TRUE if the message has been read, otherwise returns FALSE. |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * Returns wether the message has been read or not. |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @return TRUE if message has been marked as read, FALSE otherwise. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_chat_message_is_read (const LinphoneChatMessage *msg); |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_chat_message_is_read (const LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | LINPHONE_PUBLIC LinphoneReason linphone_chat_message_get_reason (const LinphoneChatMessage *msg); |
|---|
| | | LINPHONE_PUBLIC LinphoneReason linphone_chat_message_get_reason (const LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get full details about delivery error of a chat message. |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * @return a #LinphoneErrorInfo describing the details. |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @return a #LinphoneErrorInfo describing the details. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const LinphoneErrorInfo *linphone_chat_message_get_error_info (const LinphoneChatMessage *msg); |
|---|
| | | LINPHONE_PUBLIC const LinphoneErrorInfo *linphone_chat_message_get_error_info (const LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the path to the file to read from or write to during the file transfer. |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * @param[in] filepath The path to the file to use for the file transfer. |
|---|
| | | * @deprecated use linphone_content_set_file_path() instead. |
|---|
| | | * Returns wether the chat message is a forward message or not. |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @return TRUE if it is a forward message, FALSE otherwise |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_message_set_file_transfer_filepath (LinphoneChatMessage *msg, const char *filepath); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns true if the chat message is a forward message. |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * @return true if it is a forward message, false otherwise |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_chat_message_is_forward (LinphoneChatMessage *msg); |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_chat_message_is_forward (LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the forward info if available as a string |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * @return the #LinphoneContent buffer if available, null otherwise |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @return the original sender of the message if it has been forwarded, NULL otherwise. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_chat_message_get_forward_info (const LinphoneChatMessage *msg); |
|---|
| | | LINPHONE_PUBLIC const char *linphone_chat_message_get_forward_info (const LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Fulfill a chat message char by char. Message linked to a Real Time Text Call send char in realtime following RFC 4103/T.140 |
|---|
| | | * To commit a message, use #linphone_chat_room_send_message |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * @param[in] character T.140 char |
|---|
| | | * @returns 0 if succeed. |
|---|
| | | * Returns wether the chat message is an ephemeral message or not. |
|---|
| | | * An ephemeral message will automatically disappear from the recipient's screen after the message has been viewed. |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @return TRUE if it is an ephemeral message, FALSE otherwise |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_chat_message_put_char (LinphoneChatMessage *msg, uint32_t character); |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_chat_message_is_ephemeral(const LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the #LinphoneChatMessageCbs object associated with the LinphoneChatMessage. |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * @return The #LinphoneChatMessageCbs object associated with the LinphoneChatMessage. |
|---|
| | | * @deprecated |
|---|
| | | * Returns lifetime of an ephemeral message. |
|---|
| | | * The lifetime is the duration after which the ephemeral message will disappear once viewed. |
|---|
| | | * @see linphone_chat_message_is_ephemeral() |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @return the lifetime of an ephemeral message, by default 86400s. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatMessageCbs *linphone_chat_message_get_callbacks (const LinphoneChatMessage *msg); |
|---|
| | | LINPHONE_PUBLIC long linphone_chat_message_get_ephemeral_lifetime (const LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the real time at which an ephemeral message expires and will be deleted. |
|---|
| | | * @see linphone_chat_message_is_ephemeral() |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @return the time at which an ephemeral message expires. 0 means the message has not been read. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC time_t linphone_chat_message_get_ephemeral_expire_time (const LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Fulfill a chat message char by char. |
|---|
| | | * Message linked to a Real Time Text Call send char in realtime following RFC 4103/T.140 |
|---|
| | | * To commit a message, use linphone_chat_room_send_message() |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @param character T.140 char |
|---|
| | | * @return 0 if succeed. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_chat_message_put_char (LinphoneChatMessage *message, uint32_t character); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Add a listener in order to be notified of #LinphoneChatMessage events. |
|---|
| | | * @param[in] msg #LinphoneChatMessage object to monitor. |
|---|
| | | * @param[in] cbs A #LinphoneChatMessageCbs object holding the callbacks you need. |
|---|
| | | * @param message #LinphoneChatMessage object to monitor. @notnil |
|---|
| | | * @param cbs A #LinphoneChatMessageCbs object holding the callbacks you need. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_message_add_callbacks(LinphoneChatMessage *msg, LinphoneChatMessageCbs *cbs); |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_message_add_callbacks(LinphoneChatMessage *message, LinphoneChatMessageCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Remove a listener from a #LinphoneChatMessage |
|---|
| | | * @param[in] msg #LinphoneChatMessage object |
|---|
| | | * @param[in] cbs #LinphoneChatMessageCbs object to remove. |
|---|
| | | * @param message #LinphoneChatMessage object @notnil |
|---|
| | | * @param cbs #LinphoneChatMessageCbs object to remove. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_message_remove_callbacks(LinphoneChatMessage *msg, LinphoneChatMessageCbs *cbs); |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_message_remove_callbacks(LinphoneChatMessage *message, LinphoneChatMessageCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the current LinphoneChatMessageCbs. |
|---|
| | | * This is meant only to be called from a callback to be able to get the user_data associated with the #LinphoneChatMessageCbs that is calling the callback. |
|---|
| | | * @param[in] msg #LinphoneChatMessage object |
|---|
| | | * @return The #LinphoneChatMessageCbs that has called the last callback |
|---|
| | | * @param message #LinphoneChatMessage object @notnil |
|---|
| | | * @return The #LinphoneChatMessageCbs that has called the last callback. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatMessageCbs *linphone_chat_message_get_current_callbacks(const LinphoneChatMessage *msg); |
|---|
| | | LINPHONE_PUBLIC LinphoneChatMessageCbs *linphone_chat_message_get_current_callbacks(const LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Adds a file content to the ChatMessage. |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * @param[in] c_content #LinphoneContent object to add. |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @param content the #LinphoneContent object to add. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_message_add_file_content (LinphoneChatMessage *msg, LinphoneContent *c_content); |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_message_add_file_content (LinphoneChatMessage *message, LinphoneContent *content); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Adds a text content to the ChatMessage. |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * @param[in] text The text to add to the message. |
|---|
| | | * Creates a #LinphoneContent of type PlainText with the given text as body. Introduced in 01/07/2020 |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @param text The text in UTF8 to add to the message. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_message_add_text_content (LinphoneChatMessage *msg, const char *text); |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_message_add_utf8_text_content (LinphoneChatMessage *message, const char *text); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Adds a content to the ChatMessage. |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @param content the #LinphoneContent object to add. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_message_add_content (LinphoneChatMessage *message, LinphoneContent *content); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Removes a content from the ChatMessage. |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * @param[in] content the #LinphoneContent object to remove. |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @param content the #LinphoneContent object to remove. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_message_remove_content (LinphoneChatMessage *msg, LinphoneContent *content); |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_message_remove_content (LinphoneChatMessage *message, LinphoneContent *content); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the list of contents in the message. |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * @return \bctbx_list{LinphoneContent} the list of #LinphoneContent. |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @return The list of #LinphoneContent. @bctbx_list{LinphoneContent} @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const bctbx_list_t *linphone_chat_message_get_contents(const LinphoneChatMessage *msg); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns true if the chat message has a text content |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * @return true if it has one, false otherwise |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_chat_message_has_text_content (const LinphoneChatMessage *msg); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the text content if available as a string |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * @return the #LinphoneContent buffer if available, null otherwise |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_chat_message_get_text_content (const LinphoneChatMessage *msg); |
|---|
| | | LINPHONE_PUBLIC const bctbx_list_t *linphone_chat_message_get_contents(const LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets whether or not a file is currently being downloaded or uploaded |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * @return true if download or upload is in progress, false otherwise |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @return TRUE if download or upload is in progress, FALSE otherwise |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_chat_message_is_file_transfer_in_progress (const LinphoneChatMessage *msg); |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_chat_message_is_file_transfer_in_progress (const LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the list of participants for which the imdn state has reached the specified state and the time at which they did. |
|---|
| | | * @param[in] msg #LinphoneChatMessage object. |
|---|
| | | * @param[in] state The LinphoneChatMessageState the imdn have reached (only use LinphoneChatMessageStateDelivered, |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @param state The LinphoneChatMessageState the imdn have reached (only use LinphoneChatMessageStateDelivered, |
|---|
| | | * LinphoneChatMessageStateDeliveredToUser, LinphoneChatMessageStateDisplayed and LinphoneChatMessageStateNotDelivered) |
|---|
| | | * @return \bctbx_list{LinphoneParticipantImdnState} \onTheFlyList |
|---|
| | | * @return The list of participants. \bctbx_list{LinphoneParticipantImdnState} @tobefreed @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bctbx_list_t *linphone_chat_message_get_participants_by_imdn_state ( |
|---|
| | | const LinphoneChatMessage *msg, |
|---|
| | | const LinphoneChatMessage *message, |
|---|
| | | LinphoneChatMessageState state |
|---|
| | | ); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the callId accociated with the message |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @return the call Id @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_chat_message_get_call_id(const LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /************ */ |
|---|
| | | /* DEPRECATED */ |
|---|
| | | /* ********** */ |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns wether the chat message has a text content or not. |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @return TRUE if it has one, FALSE otherwise. |
|---|
| | | * @deprecated 27/10/2020. Check if linphone_chat_message_get_contents() contains a #LinphoneContent for which it's content type is PlainText. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_chat_message_has_text_content (const LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get text part of this message |
|---|
| | | * @param message #LinphoneChatMessage object. |
|---|
| | | * @return text or NULL if no text. |
|---|
| | | * @deprecated 07/11/2017 use linphone_chat_message_get_utf8_text() instead |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED const char *linphone_chat_message_get_text (const LinphoneChatMessage* message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the path to the file to read from or write to during the file transfer. |
|---|
| | | * @param message #LinphoneChatMessage object |
|---|
| | | * @return The path to the file to use for the file transfer. |
|---|
| | | * @deprecated 12/07/2018 use linphone_content_get_file_path() instead. |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED const char *linphone_chat_message_get_file_transfer_filepath (const LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Start the download of the file from remote server |
|---|
| | | * |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @param status_cb #LinphoneChatMessageStateChangeCb status callback invoked when file is downloaded or could not be downloaded |
|---|
| | | * @param user_data user data |
|---|
| | | * @deprecated 21/09/2017 Use linphone_chat_message_download_file() instead. |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED void linphone_chat_message_start_file_download ( |
|---|
| | | LinphoneChatMessage *message, |
|---|
| | | LinphoneChatMessageStateChangedCb status_cb, |
|---|
| | | void *user_data |
|---|
| | | ); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Start the download of the file referenced in a #LinphoneChatMessage from remote server. |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @deprecated 12/07/2018 Use linphone_chat_message_download_content() instead |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED bool_t linphone_chat_message_download_file (LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Resend a chat message if it is in the 'not delivered' state for whatever reason. |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @deprecated 13/10/2017 Use linphone_chat_message_send instead. |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED void linphone_chat_message_resend (LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the path to the file to read from or write to during the file transfer. |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @param filepath The path to the file to use for the file transfer. @notnil |
|---|
| | | * @deprecated 12/07/2018 use linphone_content_set_file_path() instead. |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED void linphone_chat_message_set_file_transfer_filepath (LinphoneChatMessage *message, const char *filepath); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the #LinphoneChatMessageCbs object associated with the LinphoneChatMessage. |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @return The #LinphoneChatMessageCbs object associated with the LinphoneChatMessage. @notnil |
|---|
| | | * @deprecated 19/02/2019 |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED LinphoneChatMessageCbs *linphone_chat_message_get_callbacks (const LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /** Set a chat message text to be sent by linphone_chat_room_send_message() |
|---|
| | | * @param message #LinphoneChatMessage @notnil |
|---|
| | | * @param text The text is in System Locale. @maybenil |
|---|
| | | * @return 0 if succeed. |
|---|
| | | * @deprecated 01/07/2020. Use linphone_chat_message_set_utf8_text() instead. |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED int linphone_chat_message_set_text(LinphoneChatMessage *message , const char* text); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the text content if available as a string |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @return the #LinphoneContent buffer if available in System Locale, null otherwise. @maybenil |
|---|
| | | * @deprecated 01/07/2020. Use linphone_chat_message_get_utf8_text() instead. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED const char *linphone_chat_message_get_text_content (const LinphoneChatMessage *message ); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates a #LinphoneContent of type PlainText with the given text as body. |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @param text The text in System Locale to add to the message. @notnil |
|---|
| | | * @deprecated 01/07/2020. Use linphone_chat_message_add_utf8_text_content() instead. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED void linphone_chat_message_add_text_content (LinphoneChatMessage *message, const char *text); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Return whether or not a chat message is a file transfer. |
|---|
| | | * @param message #LinphoneChatMessage object @notnil |
|---|
| | | * @return Whether or not the message is a file transfer |
|---|
| | | * @deprecated 06/07/2020 check if linphone_chat_message_get_contents() contains a #LinphoneContent for which linphone_content_is_file_transfer() returns TRUE. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED bool_t linphone_chat_message_is_file_transfer (const LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Return whether or not a chat message is a text. |
|---|
| | | * @param message #LinphoneChatMessage object. @notnil |
|---|
| | | * @return Whether or not the message is a text |
|---|
| | | * @deprecated 06/07/2020 check if linphone_chat_message_get_contents() contains a #LinphoneContent with a PlainText content type. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED bool_t linphone_chat_message_is_text (const LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @} |
|---|
| | | */ |
|---|
| | | |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Acquire a reference to the chat room callbacks object. |
|---|
| | | * @param[in] cbs The chat room callbacks object |
|---|
| | | * @return The same chat room callbacks object |
|---|
| | | * @param cbs The #LinphoneChatRoomCbs object @notnil |
|---|
| | | * @return The same #LinphoneChatRoomCbs object @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoomCbs * linphone_chat_room_cbs_ref (LinphoneChatRoomCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Release reference to the chat room callbacks object. |
|---|
| | | * @param[in] cr The chat room callbacks object |
|---|
| | | * @param cbs The chat room callbacks object @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_cbs_unref (LinphoneChatRoomCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Retrieve the user pointer associated with the chat room callbacks object. |
|---|
| | | * @param[in] cr The chat room callbacks object |
|---|
| | | * @return The user pointer associated with the chat room callbacks object |
|---|
| | | * @param cbs The chat room callbacks object @notnil |
|---|
| | | * @return The user pointer associated with the chat room callbacks object. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void * linphone_chat_room_cbs_get_user_data (const LinphoneChatRoomCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user pointer to the chat room callbacks object. |
|---|
| | | * @param[in] cr The chat room callbacks object |
|---|
| | | * @param[in] ud The user pointer to associate with the chat room callbacks object |
|---|
| | | * @param cbs The chat room callbacks object @notnil |
|---|
| | | * @param user_data The user pointer to associate with the chat room callbacks object. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_cbs_set_user_data (LinphoneChatRoomCbs *cbs, void *ud); |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_cbs_set_user_data (LinphoneChatRoomCbs *cbs, void *user_data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the is-composing received callback. |
|---|
| | | * @param[in] cbs #LinphoneChatRoomCbs object. |
|---|
| | | * @param cbs #LinphoneChatRoomCbs object. @notnil |
|---|
| | | * @return The current is-composing received callback. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoomCbsIsComposingReceivedCb linphone_chat_room_cbs_get_is_composing_received (const LinphoneChatRoomCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the is-composing received callback. |
|---|
| | | * @param[in] cbs #LinphoneChatRoomCbs object. |
|---|
| | | * @param[in] cb The is-composing received callback to be used. |
|---|
| | | * @param cbs #LinphoneChatRoomCbs object. @notnil |
|---|
| | | * @param cb The is-composing received callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_cbs_set_is_composing_received (LinphoneChatRoomCbs *cbs, LinphoneChatRoomCbsIsComposingReceivedCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the message received callback. |
|---|
| | | * @param[in] cbs #LinphoneChatRoomCbs object. |
|---|
| | | * @param cbs #LinphoneChatRoomCbs object. @notnil |
|---|
| | | * @return The current message received callback. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoomCbsMessageReceivedCb linphone_chat_room_cbs_get_message_received (const LinphoneChatRoomCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the message received callback. |
|---|
| | | * @param[in] cbs #LinphoneChatRoomCbs object. |
|---|
| | | * @param[in] cb The message received callback to be used. |
|---|
| | | * @param cbs #LinphoneChatRoomCbs object. @notnil |
|---|
| | | * @param cb The message received callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_cbs_set_message_received (LinphoneChatRoomCbs *cbs, LinphoneChatRoomCbsMessageReceivedCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the new event log callback. |
|---|
| | | * This callback will be called before every other #LinphoneEventLog related callback. |
|---|
| | | * @param cbs #LinphoneChatRoomCbs object. @notnil |
|---|
| | | * @return The current event log created callback. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoomCbsNewEventCb linphone_chat_room_cbs_get_new_event (const LinphoneChatRoomCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the new event log callback. |
|---|
| | | * This callback will be called before every other #LinphoneEventLog related callback. |
|---|
| | | * @param cbs #LinphoneChatRoomCbs object. @notnil |
|---|
| | | * @param cb The event log created callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_cbs_set_new_event (LinphoneChatRoomCbs *cbs, LinphoneChatRoomCbsNewEventCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the chat message received callback. |
|---|
| | | * @param[in] cbs #LinphoneChatRoomCbs object. |
|---|
| | | * @param cbs #LinphoneChatRoomCbs object. @notnil |
|---|
| | | * @return The current chat message received callback. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoomCbsChatMessageReceivedCb linphone_chat_room_cbs_get_chat_message_received (const LinphoneChatRoomCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the chat message received callback. |
|---|
| | | * @param[in] cbs #LinphoneChatRoomCbs object. |
|---|
| | | * @param[in] cb The chat message received callback to be used. |
|---|
| | | * @param cbs #LinphoneChatRoomCbs object. @notnil |
|---|
| | | * @param cb The chat message received callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_cbs_set_chat_message_received (LinphoneChatRoomCbs *cbs, LinphoneChatRoomCbsChatMessageReceivedCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the chat message sending callback. |
|---|
| | | * @param cbs #LinphoneChatRoomCbs object. @notnil |
|---|
| | | * @return The current chat message being sent callback. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoomCbsChatMessageSendingCb linphone_chat_room_cbs_get_chat_message_sending (const LinphoneChatRoomCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the chat message sending callback. |
|---|
| | | * @param cbs #LinphoneChatRoomCbs object. @notnil |
|---|
| | | * @param cb The chat message being sent callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_cbs_set_chat_message_sending (LinphoneChatRoomCbs *cbs, LinphoneChatRoomCbsChatMessageSendingCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the chat message sent callback. |
|---|
| | | * @param[in] cbs #LinphoneChatRoomCbs object. |
|---|
| | | * @param cbs #LinphoneChatRoomCbs object. @notnil |
|---|
| | | * @return The current chat message sent callback. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoomCbsChatMessageSentCb linphone_chat_room_cbs_get_chat_message_sent (const LinphoneChatRoomCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the chat message sent callback. |
|---|
| | | * @param[in] cbs #LinphoneChatRoomCbs object. |
|---|
| | | * @param[in] cb The chat message sent callback to be used. |
|---|
| | | * @param cbs #LinphoneChatRoomCbs object. @notnil |
|---|
| | | * @param cb The chat message sent callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_cbs_set_chat_message_sent (LinphoneChatRoomCbs *cbs, LinphoneChatRoomCbsChatMessageSentCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the participant added callback. |
|---|
| | | * @param[in] cbs #LinphoneChatRoomCbs object. |
|---|
| | | * @param cbs #LinphoneChatRoomCbs object. @notnil |
|---|
| | | * @return The current participant added callback. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoomCbsParticipantAddedCb linphone_chat_room_cbs_get_participant_added (const LinphoneChatRoomCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the participant added callback. |
|---|
| | | * @param[in] cbs #LinphoneChatRoomCbs object. |
|---|
| | | * @param[in] cb The participant added callback to be used. |
|---|
| | | * @param cbs #LinphoneChatRoomCbs object. @notnil |
|---|
| | | * @param cb The participant added callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_cbs_set_participant_added (LinphoneChatRoomCbs *cbs, LinphoneChatRoomCbsParticipantAddedCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the participant removed callback. |
|---|
| | | * @param[in] cbs #LinphoneChatRoomCbs object. |
|---|
| | | * @param cbs #LinphoneChatRoomCbs object. @notnil |
|---|
| | | * @return The current participant removed callback. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoomCbsParticipantRemovedCb linphone_chat_room_cbs_get_participant_removed (const LinphoneChatRoomCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the participant removed callback. |
|---|
| | | * @param[in] cbs #LinphoneChatRoomCbs object. |
|---|
| | | * @param[in] cb The participant removed callback to be used. |
|---|
| | | * @param cbs #LinphoneChatRoomCbs object. @notnil |
|---|
| | | * @param cb The participant removed callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_cbs_set_participant_removed (LinphoneChatRoomCbs *cbs, LinphoneChatRoomCbsParticipantRemovedCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the participant admin status changed callback. |
|---|
| | | * @param[in] cbs #LinphoneChatRoomCbs object. |
|---|
| | | * @param cbs #LinphoneChatRoomCbs object. @notnil |
|---|
| | | * @return The current participant admin status changed callback. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoomCbsParticipantAdminStatusChangedCb linphone_chat_room_cbs_get_participant_admin_status_changed (const LinphoneChatRoomCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the participant admin status changed callback. |
|---|
| | | * @param[in] cbs #LinphoneChatRoomCbs object. |
|---|
| | | * @param[in] cb The participant admin status changed callback to be used. |
|---|
| | | * @param cbs #LinphoneChatRoomCbs object. @notnil |
|---|
| | | * @param cb The participant admin status changed callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_cbs_set_participant_admin_status_changed (LinphoneChatRoomCbs *cbs, LinphoneChatRoomCbsParticipantAdminStatusChangedCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the state changed callback. |
|---|
| | | * @param[in] cbs #LinphoneChatRoomCbs object. |
|---|
| | | * @param cbs #LinphoneChatRoomCbs object. @notnil |
|---|
| | | * @return The current state changed callback. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoomCbsStateChangedCb linphone_chat_room_cbs_get_state_changed (const LinphoneChatRoomCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the state changed callback. |
|---|
| | | * @param[in] cbs #LinphoneChatRoomCbs object. |
|---|
| | | * @param[in] cb The state changed callback to be used. |
|---|
| | | * @param cbs #LinphoneChatRoomCbs object. @notnil |
|---|
| | | * @param cb The state changed callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_cbs_set_state_changed (LinphoneChatRoomCbs *cbs, LinphoneChatRoomCbsStateChangedCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the security event callback. |
|---|
| | | * @param[in] cbs #LinphoneChatRoomCbs object. |
|---|
| | | * @param cbs #LinphoneChatRoomCbs object. @notnil |
|---|
| | | * @return The security event callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoomCbsSecurityEventCb linphone_chat_room_cbs_get_security_event (const LinphoneChatRoomCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the security event callback. |
|---|
| | | * @param[in] cbs #LinphoneChatRoomCbs object. |
|---|
| | | * @param[in] cb The security event callback to be used. |
|---|
| | | * @param cbs #LinphoneChatRoomCbs object. @notnil |
|---|
| | | * @param cb The security event callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_cbs_set_security_event (LinphoneChatRoomCbs *cbs, LinphoneChatRoomCbsSecurityEventCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the subject changed callback. |
|---|
| | | * @param[in] cbs #LinphoneChatRoomCbs object. |
|---|
| | | * @param cbs #LinphoneChatRoomCbs object. @notnil |
|---|
| | | * @return The current subject changed callback. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoomCbsSubjectChangedCb linphone_chat_room_cbs_get_subject_changed (const LinphoneChatRoomCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the subject changed callback. |
|---|
| | | * @param[in] cbs #LinphoneChatRoomCbs object. |
|---|
| | | * @param[in] cb The subject changed callback to be used. |
|---|
| | | * @param cbs #LinphoneChatRoomCbs object. @notnil |
|---|
| | | * @param cb The subject changed callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_cbs_set_subject_changed (LinphoneChatRoomCbs *cbs, LinphoneChatRoomCbsSubjectChangedCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the undecryptable message received callback. |
|---|
| | | * @param[in] cbs #LinphoneChatRoomCbs object. |
|---|
| | | * @param cbs #LinphoneChatRoomCbs object. @notnil |
|---|
| | | * @return The current undecryptable message received callback. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoomCbsUndecryptableMessageReceivedCb linphone_chat_room_cbs_get_undecryptable_message_received (const LinphoneChatRoomCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the undecryptable message received callback. |
|---|
| | | * @param[in] cbs #LinphoneChatRoomCbs object. |
|---|
| | | * @param[in] cb The undecryptable message received callback to be used. |
|---|
| | | * @param cbs #LinphoneChatRoomCbs object. @notnil |
|---|
| | | * @param cb The undecryptable message received callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_cbs_set_undecryptable_message_received (LinphoneChatRoomCbs *cbs, LinphoneChatRoomCbsUndecryptableMessageReceivedCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the participant device added callback. |
|---|
| | | * @param[in] cbs #LinphoneChatRoomCbs object. |
|---|
| | | * @param cbs #LinphoneChatRoomCbs object. @notnil |
|---|
| | | * @return The current participant device added callback. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoomCbsParticipantDeviceAddedCb linphone_chat_room_cbs_get_participant_device_added (const LinphoneChatRoomCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the participant device added callback. |
|---|
| | | * @param[in] cbs #LinphoneChatRoomCbs object. |
|---|
| | | * @param[in] cb The participant device added callback to be used. |
|---|
| | | * @param cbs #LinphoneChatRoomCbs object. @notnil |
|---|
| | | * @param cb The participant device added callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_cbs_set_participant_device_added (LinphoneChatRoomCbs *cbs, LinphoneChatRoomCbsParticipantDeviceAddedCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the participant device removed callback. |
|---|
| | | * @param[in] cbs #LinphoneChatRoomCbs object. |
|---|
| | | * @param cbs #LinphoneChatRoomCbs object. @notnil |
|---|
| | | * @return The current participant device removed callback. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoomCbsParticipantDeviceRemovedCb linphone_chat_room_cbs_get_participant_device_removed (const LinphoneChatRoomCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the participant device removed callback. |
|---|
| | | * @param[in] cbs #LinphoneChatRoomCbs object. |
|---|
| | | * @param[in] cb The participant device removed callback to be used. |
|---|
| | | * @param cbs #LinphoneChatRoomCbs object. @notnil |
|---|
| | | * @param cb The participant device removed callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_cbs_set_participant_device_removed (LinphoneChatRoomCbs *cbs, LinphoneChatRoomCbsParticipantDeviceRemovedCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the conference joined callback. |
|---|
| | | * @param[in] cbs LinphoneChatRoomCbs object. |
|---|
| | | * @param cbs LinphoneChatRoomCbs object. @notnil |
|---|
| | | * @return The current conference joined callback. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoomCbsConferenceJoinedCb linphone_chat_room_cbs_get_conference_joined (const LinphoneChatRoomCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the conference joined callback. |
|---|
| | | * @param[in] cbs LinphoneChatRoomCbs object. |
|---|
| | | * @param[in] cb The conference joined callback to be used. |
|---|
| | | * @param cbs LinphoneChatRoomCbs object. @notnil |
|---|
| | | * @param cb The conference joined callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_cbs_set_conference_joined (LinphoneChatRoomCbs *cbs, LinphoneChatRoomCbsConferenceJoinedCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the conference left callback. |
|---|
| | | * @param[in] cbs LinphoneChatRoomCbs object. |
|---|
| | | * @param cbs LinphoneChatRoomCbs object. @notnil |
|---|
| | | * @return The current conference left callback. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoomCbsConferenceLeftCb linphone_chat_room_cbs_get_conference_left (const LinphoneChatRoomCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the conference left callback. |
|---|
| | | * @param[in] cbs LinphoneChatRoomCbs object. |
|---|
| | | * @param[in] cb The conference left callback to be used. |
|---|
| | | * @param cbs LinphoneChatRoomCbs object. @notnil |
|---|
| | | * @param cb The conference left callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_cbs_set_conference_left (LinphoneChatRoomCbs *cbs, LinphoneChatRoomCbsConferenceLeftCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the ephemeral event callback. |
|---|
| | | * @param cbs #LinphoneChatRoomCbs object. @notnil |
|---|
| | | * @return The ephemeral event callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoomCbsEphemeralEventCb linphone_chat_room_cbs_get_ephemeral_event (const LinphoneChatRoomCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the ephemeral event callback. |
|---|
| | | * @param cbs #LinphoneChatRoomCbs object. @notnil |
|---|
| | | * @param cb The ephemeral event callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_cbs_set_ephemeral_event (LinphoneChatRoomCbs *cbs, LinphoneChatRoomCbsEphemeralEventCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the current "ephemeral message timer started" callback. This callback is called when a message deletion timer starts (the message has been viewed). |
|---|
| | | * @param cbs LinphoneChatRoomCbs object. @notnil |
|---|
| | | * @return The current ephemeral message "timer started" callback. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoomCbsEphemeralMessageTimerStartedCb linphone_chat_room_cbs_get_ephemeral_message_timer_started (const LinphoneChatRoomCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the ephemeral message timer started callback. This callback will be used when new message deletion timer starts (the message has been viewed). |
|---|
| | | * @param cbs LinphoneChatRoomCbs object. @notnil |
|---|
| | | * @param cb The ephemeral message timer started callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_cbs_set_ephemeral_message_timer_started (LinphoneChatRoomCbs *cbs, LinphoneChatRoomCbsEphemeralMessageTimerStartedCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the ephemeral message deleted callback. This callback is used when a message deletion timer runs out (message is deleted). |
|---|
| | | * @param cbs LinphoneChatRoomCbs object. @notnil |
|---|
| | | * @return The current ephemeral message deleted callback. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoomCbsEphemeralMessageDeletedCb linphone_chat_room_cbs_get_ephemeral_message_deleted (const LinphoneChatRoomCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the ephemeral message deleted callback. This callback is used when new message deletion timer runs out (message is deleted). |
|---|
| | | * @param cbs LinphoneChatRoomCbs object. @notnil |
|---|
| | | * @param cb The ephemeral message deleted callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_cbs_set_ephemeral_message_deleted (LinphoneChatRoomCbs *cbs, LinphoneChatRoomCbsEphemeralMessageDeletedCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the conference address generation callback. |
|---|
| | | * @param[in] cbs #LinphoneChatRoomCbs object |
|---|
| | | * @param cbs #LinphoneChatRoomCbs object @notnil |
|---|
| | | * @return The current conference address generation callback |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoomCbsConferenceAddressGenerationCb linphone_chat_room_cbs_get_conference_address_generation (const LinphoneChatRoomCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the conference address generation callback. |
|---|
| | | * @param[in] cbs #LinphoneChatRoomCbs object |
|---|
| | | * @param[in] cb The conference address generation callback to be used |
|---|
| | | * @param cbs #LinphoneChatRoomCbs object @notnil |
|---|
| | | * @param cb The conference address generation callback to be used |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_cbs_set_conference_address_generation (LinphoneChatRoomCbs *cbs, LinphoneChatRoomCbsConferenceAddressGenerationCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the participant registration subscription callback. |
|---|
| | | * @param[in] cbs LinphoneChatRoomCbs object |
|---|
| | | * @param cbs LinphoneChatRoomCbs object @notnil |
|---|
| | | * @return The participant registration subscription callback |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoomCbsParticipantRegistrationSubscriptionRequestedCb linphone_chat_room_cbs_get_participant_registration_subscription_requested (const LinphoneChatRoomCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the participant registration subscription callback. |
|---|
| | | * @param[in] cbs LinphoneChatRoomCbs object |
|---|
| | | * @param[in] cb The participant registration subscription callback to be used |
|---|
| | | * @param cbs LinphoneChatRoomCbs object @notnil |
|---|
| | | * @param cb The participant registration subscription callback to be used |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_cbs_set_participant_registration_subscription_requested (LinphoneChatRoomCbs *cbs, LinphoneChatRoomCbsParticipantRegistrationSubscriptionRequestedCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the participant registration unsubscription callback. |
|---|
| | | * @param[in] cbs LinphoneChatRoomCbs object |
|---|
| | | * @param cbs LinphoneChatRoomCbs object @notnil |
|---|
| | | * @return The participant registration unsubscription callback |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoomCbsParticipantRegistrationUnsubscriptionRequestedCb linphone_chat_room_cbs_get_participant_registration_unsubscription_requested (const LinphoneChatRoomCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the participant registration unsubscription callback. |
|---|
| | | * @param[in] cbs LinphoneChatRoomCbs object |
|---|
| | | * @param[in] cb The participant registration unsubscription callback to be used |
|---|
| | | * @param cbs LinphoneChatRoomCbs object @notnil |
|---|
| | | * @param cb The participant registration unsubscription callback to be used |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_cbs_set_participant_registration_unsubscription_requested (LinphoneChatRoomCbs *cbs, LinphoneChatRoomCbsParticipantRegistrationUnsubscriptionRequestedCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the message should be stored callback. |
|---|
| | | * @param[in] cbs LinphoneChatRoomCbs object |
|---|
| | | * @return The message should be stored getting callback |
|---|
| | | * @param cbs LinphoneChatRoomCbs object @notnil |
|---|
| | | * @return The message should be stored callback |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoomCbsShouldChatMessageBeStoredCb linphone_chat_room_cbs_get_chat_message_should_be_stored( LinphoneChatRoomCbs *cbs); |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoomCbsShouldChatMessageBeStoredCb linphone_chat_room_cbs_get_chat_message_should_be_stored (LinphoneChatRoomCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the message should be stored callback. |
|---|
| | | * @param[in] cbs LinphoneChatRoomCbs object |
|---|
| | | * @param[in] cb The message should be stored callback to be used |
|---|
| | | * @param cbs LinphoneChatRoomCbs object @notnil |
|---|
| | | * @param cb The message should be stored callback to be used |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_cbs_set_chat_message_should_be_stored( LinphoneChatRoomCbs *cbs, LinphoneChatRoomCbsShouldChatMessageBeStoredCb cb); |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_cbs_set_chat_message_should_be_stored (LinphoneChatRoomCbs *cbs, LinphoneChatRoomCbsShouldChatMessageBeStoredCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the message's participant state changed callback. |
|---|
| | | * @param cbs LinphoneChatRoomCbs object @notnil |
|---|
| | | * @return The message's participant state changed callback callback |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoomCbsChatMessageParticipantImdnStateChangedCb linphone_chat_room_cbs_get_chat_message_participant_imdn_state_changed (LinphoneChatRoomCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the message's participant state changed callback callback. |
|---|
| | | * @param cbs LinphoneChatRoomCbs object @notnil |
|---|
| | | * @param cb The message's participant state changed callback to be used |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_cbs_set_chat_message_participant_imdn_state_changed (LinphoneChatRoomCbs *cbs, LinphoneChatRoomCbsChatMessageParticipantImdnStateChangedCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @} |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoomParams *linphone_chat_room_params_new(void); |
|---|
| | | |
|---|
| | | LinphoneChatRoomParams *linphone_chat_room_params_clone(const LinphoneChatRoomParams *params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Acquire a reference to the chat room parameters. |
|---|
| | | * @param[in] params The chat room parameters. |
|---|
| | | * @return The same chat room parameters. |
|---|
| | | * @param params The #LinphoneChatRoomParams object. @notnil |
|---|
| | | * @return The same #LinphoneChatRoomParams object. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoomParams *linphone_chat_room_params_ref(LinphoneChatRoomParams *params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Release reference to the chat room params. |
|---|
| | | * @param[in] params The chat room params. |
|---|
| | | * @param params The #LinphoneChatRoomParams object. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_params_unref(LinphoneChatRoomParams *params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @param[in] params The chat room params. |
|---|
| | | * Returns whether the given parameters are valid or not. |
|---|
| | | * @param params The #LinphoneChatRoomParams object. @notnil |
|---|
| | | * @return TRUE if the given parameters are valid, FALSE otherwise |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_chat_room_params_is_valid(const LinphoneChatRoomParams *params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the backend implementation of the chat room associated with the given parameters. |
|---|
| | | * @param[in] params The chat room params. |
|---|
| | | * @return LinphoneChatRoomBackend |
|---|
| | | * @param params The #LinphoneChatRoomParams object. @notnil |
|---|
| | | * @return the #LinphoneChatRoomBackend |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoomBackend linphone_chat_room_params_get_backend(const LinphoneChatRoomParams *params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the encryption implementation of the chat room associated with the given parameters. |
|---|
| | | * @param[in] params The chat room params. |
|---|
| | | * @return LinphoneChatRoomEncryptionBackend |
|---|
| | | * @param params The #LinphoneChatRoomParams object. @notnil |
|---|
| | | * @return the #LinphoneChatRoomEncryptionBackend |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoomEncryptionBackend linphone_chat_room_params_get_encryption_backend(const LinphoneChatRoomParams *params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the group chat status of the chat room associated with the given parameters. |
|---|
| | | * @param[in] params The chat room params. |
|---|
| | | * @param params The #LinphoneChatRoomParams object. @notnil |
|---|
| | | * @return TRUE if group chat is enabled, FALSE if one-to-one |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_chat_room_params_group_enabled(const LinphoneChatRoomParams *params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the encryption status of the chat room associated with the given parameters. |
|---|
| | | * @param[in] params The chat room params. |
|---|
| | | * @param params The #LinphoneChatRoomParams object. @notnil |
|---|
| | | * @return TRUE if encryption is enabled, FALSE otherwise |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_chat_room_params_encryption_enabled(const LinphoneChatRoomParams *params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the real time text status of the chat room associated with the given parameters. |
|---|
| | | * @param[in] params The chat room params. |
|---|
| | | * @param params The #LinphoneChatRoomParams object. @notnil |
|---|
| | | * @return TRUE if real time text is enabled, FALSE otherwise |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_chat_room_params_rtt_enabled(const LinphoneChatRoomParams *params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the backend implementation of these chat room parameters. |
|---|
| | | * @param[in] params The chat room params. |
|---|
| | | * @param[in] backend The #LinphoneChatRoomBackend enum value |
|---|
| | | * @param params The #LinphoneChatRoomParams object. @notnil |
|---|
| | | * @param backend The #LinphoneChatRoomBackend enum value |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_params_set_backend(LinphoneChatRoomParams *params, LinphoneChatRoomBackend backend); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the encryption backend implementation of these chat room parameters. |
|---|
| | | * @param[in] params The chat room params. |
|---|
| | | * @param[in] backend The #LinphoneChatRoomEncryptionBackend enum value |
|---|
| | | * @param params The #LinphoneChatRoomParams object. @notnil |
|---|
| | | * @param backend The #LinphoneChatRoomEncryptionBackend enum value |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_params_set_encryption_backend(LinphoneChatRoomParams *params, LinphoneChatRoomEncryptionBackend backend); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Enables or disables group chat for the chat room associated with the given parameters. |
|---|
| | | * @param[in] cr The chat room params. |
|---|
| | | * @param[in] group. TRUE to enable group chat, FALSE to disable (resulting in one-to-one chat room) |
|---|
| | | * @param params The #LinphoneChatRoomParams object. @notnil |
|---|
| | | * @param group. TRUE to enable group chat, FALSE to disable (resulting in one-to-one chat room) |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_params_enable_group(LinphoneChatRoomParams *params, bool_t group); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Enables or disables encryption for the chat room associated with the given parameters. |
|---|
| | | * @param[in] params The chat room params. |
|---|
| | | * @param[in] encrypted. TRUE to enable encryption, FALSE to disable. |
|---|
| | | * @param params The #LinphoneChatRoomParams object. @notnil |
|---|
| | | * @param encrypted. TRUE to enable encryption, FALSE to disable. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_params_enable_encryption(LinphoneChatRoomParams *params, bool_t encrypted); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Enables or disables real time text for the chat room associated with the given parameters. |
|---|
| | | * @param[in] params The chat room params. |
|---|
| | | * @param[in] rtt. TRUE to enable real time text, FALSE to disable. |
|---|
| | | * @param params The #LinphoneChatRoomParams object. @notnil |
|---|
| | | * @param rtt. TRUE to enable real time text, FALSE to disable. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_params_enable_rtt(LinphoneChatRoomParams *params, bool_t rtt); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the subject of the chat room. |
|---|
| | | * @param params The #LinphoneChatRoomParams object. @notnil |
|---|
| | | * @return The subject. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_chat_room_params_get_subject(LinphoneChatRoomParams *params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the subject of the chat room. |
|---|
| | | * @param params The #LinphoneChatRoomParams object. @notnil |
|---|
| | | * @param subject The subject to set. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_params_set_subject(LinphoneChatRoomParams *params, const char *subject); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @} |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Acquire a reference to the chat room. |
|---|
| | | * @param[in] cr The chat room. |
|---|
| | | * @return The same chat room. |
|---|
| | | * @param chat_room The #LinphoneChatRoom object. @notnil |
|---|
| | | * @return The same #LinphoneChatRoom object. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoom *linphone_chat_room_ref(LinphoneChatRoom *cr); |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoom *linphone_chat_room_ref(LinphoneChatRoom *chat_room); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Release reference to the chat room. |
|---|
| | | * @param[in] cr The chat room. |
|---|
| | | * @param chat_room The #LinphoneChatRoom object. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_unref(LinphoneChatRoom *cr); |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_unref(LinphoneChatRoom *chat_room); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Retrieve the user pointer associated with the chat room. |
|---|
| | | * @param[in] cr The chat room. |
|---|
| | | * @return The user pointer associated with the chat room. |
|---|
| | | * @param chat_room the #LinphoneChatRoom object. @notnil |
|---|
| | | * @return The user pointer associated with the chat room. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void *linphone_chat_room_get_user_data(const LinphoneChatRoom *cr); |
|---|
| | | LINPHONE_PUBLIC void *linphone_chat_room_get_user_data(const LinphoneChatRoom *chat_room); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user pointer to the chat room. |
|---|
| | | * @param[in] cr The chat room. |
|---|
| | | * @param[in] ud The user pointer to associate with the chat room. |
|---|
| | | * @param chat_room the #LinphoneChatRoom object. @notnil |
|---|
| | | * @param user_data The user pointer to associate with the chat room. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_set_user_data(LinphoneChatRoom *cr, void *ud); |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_set_user_data(LinphoneChatRoom *chat_room, void *user_data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates an empty message attached to a dedicated chat room. |
|---|
| | | * @param cr the chat room. |
|---|
| | | * @return a new #LinphoneChatMessage |
|---|
| | | * Creates an empty message attached to the given chat room. |
|---|
| | | * @param chat_room the #LinphoneChatRoom object. @notnil |
|---|
| | | * @return a new #LinphoneChatMessage @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatMessage *linphone_chat_room_create_empty_message (LinphoneChatRoom *cr); |
|---|
| | | LINPHONE_PUBLIC LinphoneChatMessage *linphone_chat_room_create_empty_message (LinphoneChatRoom *chat_room); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates a message attached to a dedicated chat room. |
|---|
| | | * @param cr the chat room. |
|---|
| | | * @param message text message, NULL if absent. |
|---|
| | | * @return a new #LinphoneChatMessage |
|---|
| | | * Creates a message attached to the given chat room with a plain text content filled with the given message. Introduced in 01/07/2020 |
|---|
| | | * @param chat_room the #LinphoneChatRoom object. @notnil |
|---|
| | | * @param message text message in UTF8, NULL if absent. @maybenil |
|---|
| | | * @return a new #LinphoneChatMessage @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatMessage* linphone_chat_room_create_message(LinphoneChatRoom *cr,const char* message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates a message attached to a dedicated chat room. |
|---|
| | | * @param cr the chat room. |
|---|
| | | * @param message text message, NULL if absent. |
|---|
| | | * @param external_body_url the URL given in external body or NULL. |
|---|
| | | * @param state the LinphoneChatMessage.State of the message. |
|---|
| | | * @param time the time_t at which the message has been received/sent. |
|---|
| | | * @param is_read TRUE if the message should be flagged as read, FALSE otherwise. |
|---|
| | | * @param is_incoming TRUE if the message has been received, FALSE otherwise. |
|---|
| | | * @return a new #LinphoneChatMessage |
|---|
| | | * @deprecated Use #linphone_chat_room_create_message() instead. Deprecated since 2017-11-14. |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatMessage* linphone_chat_room_create_message_2(LinphoneChatRoom *cr, const char* message, const char* external_body_url, LinphoneChatMessageState state, time_t time, bool_t is_read, bool_t is_incoming); |
|---|
| | | LINPHONE_PUBLIC LinphoneChatMessage* linphone_chat_room_create_message_from_utf8(LinphoneChatRoom *chat_room,const char* message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates a message attached to a dedicated chat room with a particular content. |
|---|
| | | * Use #linphone_chat_room_send_message to initiate the transfer |
|---|
| | | * @param cr the chat room. |
|---|
| | | * @param initial_content #LinphoneContent initial content. #LinphoneCoreVTable.file_transfer_send is invoked later to notify file transfer progress and collect next chunk of the message if LinphoneContent.data is NULL. |
|---|
| | | * @return a new #LinphoneChatMessage |
|---|
| | | * Creates a message attached to the given chat room with a particular content. |
|---|
| | | * Use linphone_chat_room_send_message() to initiate the transfer |
|---|
| | | * @param chat_room the #LinphoneChatRoom object. @notnil |
|---|
| | | * @param initial_content #LinphoneContent initial content. @notnil |
|---|
| | | * @return a new #LinphoneChatMessage @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatMessage* linphone_chat_room_create_file_transfer_message(LinphoneChatRoom *cr, LinphoneContent* initial_content); |
|---|
| | | LINPHONE_PUBLIC LinphoneChatMessage* linphone_chat_room_create_file_transfer_message(LinphoneChatRoom *chat_room, LinphoneContent* initial_content); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates a forward message attached to a dedicated chat room with a particular message. |
|---|
| | | * @param cr the chat room. |
|---|
| | | * @param msg #LinphoneChatMessage message to be forwarded. |
|---|
| | | * @return a new #LinphoneChatMessage |
|---|
| | | * Creates a forward message attached to the given chat room with a particular message. |
|---|
| | | * @param chat_room the #LinphoneChatRoom object. @notnil |
|---|
| | | * @param message #LinphoneChatMessage message to be forwarded. @notnil |
|---|
| | | * @return a new #LinphoneChatMessage @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatMessage *linphone_chat_room_create_forward_message (LinphoneChatRoom *cr, LinphoneChatMessage *msg); |
|---|
| | | LINPHONE_PUBLIC LinphoneChatMessage *linphone_chat_room_create_forward_message (LinphoneChatRoom *chat_room, LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * get peer address \link linphone_core_get_chat_room() associated to \endlink this #LinphoneChatRoom |
|---|
| | | * @param cr #LinphoneChatRoom object |
|---|
| | | * @return #LinphoneAddress peer address |
|---|
| | | * Get the peer address associated to this chat room. |
|---|
| | | * @param chat_room #LinphoneChatRoom object. @notnil |
|---|
| | | * @return The peer address. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress* linphone_chat_room_get_peer_address(LinphoneChatRoom *cr); |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress* linphone_chat_room_get_peer_address(LinphoneChatRoom *chat_room); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * get local address \link linphone_core_get_chat_room() associated to \endlink this #LinphoneChatRoom |
|---|
| | | * @param cr #LinphoneChatRoom object |
|---|
| | | * @return #LinphoneAddress local address |
|---|
| | | * Get the local address associated to this chat room. |
|---|
| | | * @param chat_room #LinphoneChatRoom object. @notnil |
|---|
| | | * @return The local address. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress* linphone_chat_room_get_local_address(LinphoneChatRoom *cr); |
|---|
| | | |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress* linphone_chat_room_get_local_address(LinphoneChatRoom *chat_room); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Send a message to peer member of this chat room. |
|---|
| | | * @deprecated Use linphone_chat_message_send() instead. |
|---|
| | | * @param cr #LinphoneChatRoom object |
|---|
| | | * @param msg message to be sent |
|---|
| | | * @donotwrap |
|---|
| | | * Used to receive a chat message when using async mechanism with IM enchat_roomyption engine |
|---|
| | | * @param chat_room #LinphoneChatRoom object @notnil |
|---|
| | | * @param message #LinphoneChatMessage object @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED void linphone_chat_room_send_message(LinphoneChatRoom *cr, const char *msg); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Send a message to peer member of this chat room. |
|---|
| | | * @param[in] cr #LinphoneChatRoom object |
|---|
| | | * @param[in] msg #LinphoneChatMessage object |
|---|
| | | * The state of the message sending will be notified via the callbacks defined in the #LinphoneChatMessageCbs object that can be obtained |
|---|
| | | * by calling linphone_chat_message_get_callbacks(). |
|---|
| | | * The #LinphoneChatMessage reference is transfered to the function and thus doesn't need to be unref'd by the application. |
|---|
| | | * @deprecated Use linphone_chat_message_send() instead. |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED void linphone_chat_room_send_chat_message(LinphoneChatRoom *cr, LinphoneChatMessage *msg); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Used to receive a chat message when using async mechanism with IM encryption engine |
|---|
| | | * @param[in] cr #LinphoneChatRoom object |
|---|
| | | * @param[in] msg #LinphoneChatMessage object |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_receive_chat_message (LinphoneChatRoom *cr, LinphoneChatMessage *msg); |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_receive_chat_message (LinphoneChatRoom *chat_room, LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Mark all messages of the conversation as read |
|---|
| | | * @param[in] cr The #LinphoneChatRoom object corresponding to the conversation. |
|---|
| | | * @param chat_room The #LinphoneChatRoom object corresponding to the conversation. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_mark_as_read(LinphoneChatRoom *cr); |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_mark_as_read(LinphoneChatRoom *chat_room); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Enable or disable the ephemeral message feature in the chat room. Works only for conference based chat room. |
|---|
| | | * An ephemeral message will automatically disappear from the recipient's schat_roomeen after the message has been viewed. |
|---|
| | | * @param chat_room #LinphoneChatRoom object @notnil |
|---|
| | | * @param enable TRUE if the ephemeral message feature is enabled, FALSE otherwise. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_enable_ephemeral (LinphoneChatRoom *chat_room, bool_t enable); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns whether or not the ephemeral message feature is enabled in the chat room. |
|---|
| | | * @param chat_room The #LinphoneChatRoom object corresponding to the conversation @notnil |
|---|
| | | * @return TRUE if ephemeral is enabled, FALSE otherwise. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_chat_room_ephemeral_enabled (const LinphoneChatRoom *chat_room); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set lifetime (in seconds) for all new ephemral messages in the chat room. |
|---|
| | | * After the message is read, it will be deleted after "time" seconds. |
|---|
| | | * @see linphone_chat_room_ephemeral_enabled() |
|---|
| | | * @param chat_room #LinphoneChatRoom object @notnil |
|---|
| | | * @param time The ephemral lifetime, default 24h, 86400s |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_set_ephemeral_lifetime (LinphoneChatRoom *chat_room, long time); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get lifetime (in seconds) for all new ephemeral messages in the chat room. |
|---|
| | | * After the message is read, it will be deleted after "time" seconds. |
|---|
| | | * @see linphone_chat_room_ephemeral_enabled() |
|---|
| | | * @param chat_room #LinphoneChatRoom object @notnil |
|---|
| | | * @return the ephemeral lifetime (in secoonds) |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC long linphone_chat_room_get_ephemeral_lifetime (const LinphoneChatRoom *chat_room); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Uses linphone spec to check if all participants support ephemeral messages. |
|---|
| | | * It doesn't prevent to send ephemeral messages in the room but those who don't support it |
|---|
| | | * won't delete messages after lifetime has expired. |
|---|
| | | * @see linphone_chat_room_ephemeral_enabled() |
|---|
| | | * @param chat_room #LinphoneChatRoom object @notnil |
|---|
| | | * @return TRUE if all participants in the chat room support ephemeral messages, FALSE otherwise |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_chat_room_ephemeral_supported_by_all_participants (const LinphoneChatRoom *chat_room); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Delete a message from the chat room history. |
|---|
| | | * @param[in] cr The #LinphoneChatRoom object corresponding to the conversation. |
|---|
| | | * @param[in] msg The #LinphoneChatMessage object to remove. |
|---|
| | | * @param chat_room The #LinphoneChatRoom object corresponding to the conversation. @notnil |
|---|
| | | * @param message The #LinphoneChatMessage object to remove. @notnil |
|---|
| | | */ |
|---|
| | | |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_delete_message(LinphoneChatRoom *cr, LinphoneChatMessage *msg); |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_delete_message(LinphoneChatRoom *chat_room, LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Delete all messages from the history |
|---|
| | | * @param[in] cr The #LinphoneChatRoom object corresponding to the conversation. |
|---|
| | | * @param chat_room The #LinphoneChatRoom object corresponding to the conversation. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_delete_history(LinphoneChatRoom *cr); |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_delete_history(LinphoneChatRoom *chat_room); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the number of messages in a chat room. |
|---|
| | | * @param[in] cr The #LinphoneChatRoom object corresponding to the conversation for which size has to be computed |
|---|
| | | * @param chat_room The #LinphoneChatRoom object corresponding to the conversation for which size has to be computed @notnil |
|---|
| | | * @return the number of messages. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC int linphone_chat_room_get_history_size(LinphoneChatRoom *cr); |
|---|
| | | LINPHONE_PUBLIC int linphone_chat_room_get_history_size(LinphoneChatRoom *chat_room); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns whether or not a #LinphoneChatRoom has at least one #LinphoneChatMessage or not. |
|---|
| | | * @param[in] cr The #LinphoneChatRoom object corresponding to the conversation |
|---|
| | | * @return true if there are no #LinphoneChatMessage, false otherwise. |
|---|
| | | * @param chat_room The #LinphoneChatRoom object corresponding to the conversation @notnil |
|---|
| | | * @return TRUE if there are no #LinphoneChatMessage, FALSE otherwise. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_chat_room_is_empty (LinphoneChatRoom *cr); |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_chat_room_is_empty (LinphoneChatRoom *chat_room); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets nb_message most recent messages from cr chat room, sorted from oldest to most recent. |
|---|
| | | * @param[in] cr The #LinphoneChatRoom object corresponding to the conversation for which messages should be retrieved |
|---|
| | | * @param[in] nb_message Number of message to retrieve. 0 means everything. |
|---|
| | | * @return \bctbx_list{LinphoneChatMessage} \onTheFlyList |
|---|
| | | * Gets nb_message most recent messages from chat_room chat room, sorted from oldest to most recent. |
|---|
| | | * @param chat_room The #LinphoneChatRoom object corresponding to the conversation for which messages should be retrieved @notnil |
|---|
| | | * @param nb_message Number of message to retrieve. 0 means everything. |
|---|
| | | * @return A list of chat messages. \bctbx_list{LinphoneChatMessage} @tobefreed |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bctbx_list_t *linphone_chat_room_get_history (LinphoneChatRoom *cr, int nb_message); |
|---|
| | | LINPHONE_PUBLIC bctbx_list_t *linphone_chat_room_get_history (LinphoneChatRoom *chat_room, int nb_message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the partial list of messages in the given range, sorted from oldest to most recent. |
|---|
| | | * @param[in] cr The #LinphoneChatRoom object corresponding to the conversation for which messages should be retrieved |
|---|
| | | * @param[in] begin The first message of the range to be retrieved. History most recent message has index 0. |
|---|
| | | * @param[in] end The last message of the range to be retrieved. History oldest message has index of history size - 1 (use #linphone_chat_room_get_history_size to retrieve history size) |
|---|
| | | * @return \bctbx_list{LinphoneChatMessage} \onTheFlyList |
|---|
| | | * @param chat_room The #LinphoneChatRoom object corresponding to the conversation for which messages should be retrieved @notnil |
|---|
| | | * @param begin The first message of the range to be retrieved. History most recent message has index 0. |
|---|
| | | * @param end The last message of the range to be retrieved. History oldest message has index of history size - 1 (use #linphone_chat_room_get_history_size() to retrieve history size) |
|---|
| | | * @return A list of chat messages. \bctbx_list{LinphoneChatMessage} @tobefreed |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bctbx_list_t *linphone_chat_room_get_history_range (LinphoneChatRoom *cr, int begin, int end); |
|---|
| | | LINPHONE_PUBLIC bctbx_list_t *linphone_chat_room_get_history_range (LinphoneChatRoom *chat_room, int begin, int end); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets nb_events most recent chat message events from cr chat room, sorted from oldest to most recent. |
|---|
| | | * @param[in] cr The #LinphoneChatRoom object corresponding to the conversation for which events should be retrieved |
|---|
| | | * @param[in] nb_events Number of events to retrieve. 0 means everything. |
|---|
| | | * @return \bctbx_list{LinphoneEventLog} \onTheFlyList |
|---|
| | | * Gets nb_events most recent chat message events from chat_room chat room, sorted from oldest to most recent. |
|---|
| | | * @param chat_room The #LinphoneChatRoom object corresponding to the conversation for which events should be retrieved @notnil |
|---|
| | | * @param nb_events Number of events to retrieve. 0 means everything. |
|---|
| | | * @return A list \bctbx_list{LinphoneEventLog} @tobefreed |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bctbx_list_t *linphone_chat_room_get_history_message_events (LinphoneChatRoom *cr, int nb_events); |
|---|
| | | LINPHONE_PUBLIC bctbx_list_t *linphone_chat_room_get_history_message_events (LinphoneChatRoom *chat_room, int nb_events); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the partial list of chat message events in the given range, sorted from oldest to most recent. |
|---|
| | | * @param[in] cr The #LinphoneChatRoom object corresponding to the conversation for which events should be retrieved |
|---|
| | | * @param[in] begin The first event of the range to be retrieved. History most recent event has index 0. |
|---|
| | | * @param[in] end The last event of the range to be retrieved. History oldest event has index of history size - 1 |
|---|
| | | * @return \bctbx_list{LinphoneEventLog} \onTheFlyList |
|---|
| | | * @param chat_room The #LinphoneChatRoom object corresponding to the conversation for which events should be retrieved @notnil |
|---|
| | | * @param begin The first event of the range to be retrieved. History most recent event has index 0. |
|---|
| | | * @param end The last event of the range to be retrieved. History oldest event has index of history size - 1 |
|---|
| | | * @return The list of chat message events. \bctbx_list{LinphoneEventLog} @tobefreed |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bctbx_list_t *linphone_chat_room_get_history_range_message_events (LinphoneChatRoom *cr, int begin, int end); |
|---|
| | | LINPHONE_PUBLIC bctbx_list_t *linphone_chat_room_get_history_range_message_events (LinphoneChatRoom *chat_room, int begin, int end); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets nb_events most recent events from cr chat room, sorted from oldest to most recent. |
|---|
| | | * @param[in] cr The #LinphoneChatRoom object corresponding to the conversation for which events should be retrieved |
|---|
| | | * @param[in] nb_events Number of events to retrieve. 0 means everything. |
|---|
| | | * @return \bctbx_list{LinphoneEventLog} \onTheFlyList |
|---|
| | | * Gets nb_events most recent events from chat_room chat room, sorted from oldest to most recent. |
|---|
| | | * @param chat_room The #LinphoneChatRoom object corresponding to the conversation for which events should be retrieved @notnil |
|---|
| | | * @param nb_events Number of events to retrieve. 0 means everything. |
|---|
| | | * @return The list of the most recent events. \bctbx_list{LinphoneEventLog} @tobefreed |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bctbx_list_t *linphone_chat_room_get_history_events (LinphoneChatRoom *cr, int nb_events); |
|---|
| | | LINPHONE_PUBLIC bctbx_list_t *linphone_chat_room_get_history_events (LinphoneChatRoom *chat_room, int nb_events); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the partial list of events in the given range, sorted from oldest to most recent. |
|---|
| | | * @param[in] cr The #LinphoneChatRoom object corresponding to the conversation for which events should be retrieved |
|---|
| | | * @param[in] begin The first event of the range to be retrieved. History most recent event has index 0. |
|---|
| | | * @param[in] end The last event of the range to be retrieved. History oldest event has index of history size - 1 |
|---|
| | | * @return \bctbx_list{LinphoneEventLog} \onTheFlyList |
|---|
| | | * @param chat_room The #LinphoneChatRoom object corresponding to the conversation for which events should be retrieved @notnil |
|---|
| | | * @param begin The first event of the range to be retrieved. History most recent event has index 0. |
|---|
| | | * @param end The last event of the range to be retrieved. History oldest event has index of history size - 1 |
|---|
| | | * @return The list of the found events. \bctbx_list{LinphoneEventLog} @tobefreed |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bctbx_list_t *linphone_chat_room_get_history_range_events (LinphoneChatRoom *cr, int begin, int end); |
|---|
| | | LINPHONE_PUBLIC bctbx_list_t *linphone_chat_room_get_history_range_events (LinphoneChatRoom *chat_room, int begin, int end); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the number of events in a chat room. |
|---|
| | | * @param[in] cr The #LinphoneChatRoom object corresponding to the conversation for which size has to be computed |
|---|
| | | * @param chat_room The #LinphoneChatRoom object corresponding to the conversation for which size has to be computed @notnil |
|---|
| | | * @return the number of events. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC int linphone_chat_room_get_history_events_size(LinphoneChatRoom *cr); |
|---|
| | | LINPHONE_PUBLIC int linphone_chat_room_get_history_events_size(LinphoneChatRoom *chat_room); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the last chat message sent or received in this chat room |
|---|
| | | * @param[in] cr The #LinphoneChatRoom object corresponding to the conversation for which last message should be retrieved |
|---|
| | | * @return the latest #LinphoneChatMessage |
|---|
| | | * @param chat_room The #LinphoneChatRoom object corresponding to the conversation for which last message should be retrieved @notnil |
|---|
| | | * @return the latest #LinphoneChatMessage or NULL if no message. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatMessage *linphone_chat_room_get_last_message_in_history(LinphoneChatRoom *cr); |
|---|
| | | LINPHONE_PUBLIC LinphoneChatMessage *linphone_chat_room_get_last_message_in_history(LinphoneChatRoom *chat_room); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the chat message sent or received in this chat room that matches the message_id |
|---|
| | | * @param[in] cr The #LinphoneChatRoom object corresponding to the conversation for which the message should be retrieved |
|---|
| | | * @param[in] message_id The id of the message to find |
|---|
| | | * @return the #LinphoneChatMessage |
|---|
| | | * @param chat_room The #LinphoneChatRoom object corresponding to the conversation for which the message should be retrieved @notnil |
|---|
| | | * @param message_id The id of the message to find @notnil |
|---|
| | | * @return the #LinphoneChatMessage if found or NULL. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatMessage * linphone_chat_room_find_message(LinphoneChatRoom *cr, const char *message_id); |
|---|
| | | LINPHONE_PUBLIC LinphoneChatMessage * linphone_chat_room_find_message(LinphoneChatRoom *chat_room, const char *message_id); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Notifies the destination of the chat message being composed that the user is typing a new message. |
|---|
| | | * @param[in] cr The #LinphoneChatRoom object corresponding to the conversation for which a new message is being typed. |
|---|
| | | * @param chat_room The #LinphoneChatRoom object corresponding to the conversation for which a new message is being typed. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_compose(LinphoneChatRoom *cr); |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_compose(LinphoneChatRoom *chat_room); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Tells whether the remote is currently composing a message. |
|---|
| | | * @param[in] cr The #LinphoneChatRoom object corresponding to the conversation. |
|---|
| | | * @param chat_room The #LinphoneChatRoom object corresponding to the conversation. @notnil |
|---|
| | | * @return TRUE if the remote is currently composing a message, FALSE otherwise. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_chat_room_is_remote_composing(const LinphoneChatRoom *cr); |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_chat_room_is_remote_composing(const LinphoneChatRoom *chat_room); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the number of unread messages in the chatroom. |
|---|
| | | * @param[in] cr The #LinphoneChatRoom object corresponding to the conversation. |
|---|
| | | * @param chat_room The #LinphoneChatRoom object corresponding to the conversation. @notnil |
|---|
| | | * @return the number of unread messages. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC int linphone_chat_room_get_unread_messages_count(LinphoneChatRoom *cr); |
|---|
| | | LINPHONE_PUBLIC int linphone_chat_room_get_unread_messages_count(LinphoneChatRoom *chat_room); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns back pointer to #LinphoneCore object. |
|---|
| | | * @param chat_room the #LinphoneChatRoom object. @notnil |
|---|
| | | * @return the #LinphoneCore object this chat room is attached to. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneCore* linphone_chat_room_get_core(const LinphoneChatRoom *cr); |
|---|
| | | LINPHONE_PUBLIC LinphoneCore* linphone_chat_room_get_core(const LinphoneChatRoom *chat_room); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * When realtime text is enabled #linphone_call_params_realtime_text_enabled, #LinphoneCoreIsComposingReceivedCb is call everytime a char is received from peer. |
|---|
| | | * When realtime text is enabled linphone_call_params_realtime_text_enabled(), #LinphoneCoreIsComposingReceivedCb is call everytime a char is received from peer. |
|---|
| | | * At the end of remote typing a regular #LinphoneChatMessage is received with committed data from #LinphoneCoreMessageReceivedCb. |
|---|
| | | * @param[in] cr #LinphoneChatRoom object |
|---|
| | | * @returns RFC 4103/T.140 char |
|---|
| | | * @param chat_room #LinphoneChatRoom object @notnil |
|---|
| | | * @return RFC 4103/T.140 char |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC uint32_t linphone_chat_room_get_char(const LinphoneChatRoom *cr); |
|---|
| | | LINPHONE_PUBLIC uint32_t linphone_chat_room_get_char(LinphoneChatRoom *chat_room); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns true if lime is available for given peer |
|---|
| | | * |
|---|
| | | * @return true if zrtp secrets have already been shared and ready to use |
|---|
| | | * Returns wether lime is available for given peer or not. * |
|---|
| | | * @return TRUE if zrtp secrets have already been shared and ready to use, FALSE otherwise. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_chat_room_lime_available(LinphoneChatRoom *cr); |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_chat_room_lime_available(LinphoneChatRoom *chat_room); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * get Curent Call associated to this chatroom if any |
|---|
| | | * To commit a message, use #linphone_chat_room_send_message |
|---|
| | | * @param[in] room #LinphoneChatRomm |
|---|
| | | * @returns #LinphoneCall or NULL. |
|---|
| | | * Gets the current call associated to this chatroom if any |
|---|
| | | * To commit a message, use linphone_chat_room_send_message() |
|---|
| | | * @param chat_room the #LinphoneChatRomm object @notnil |
|---|
| | | * @return #LinphoneCall or NULL. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneCall *linphone_chat_room_get_call(const LinphoneChatRoom *room); |
|---|
| | | LINPHONE_PUBLIC LinphoneCall *linphone_chat_room_get_call(const LinphoneChatRoom *chat_room); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Add a listener in order to be notified of #LinphoneChatRoom events. Once an event is received, registred #LinphoneChatRoomCbs are |
|---|
| | | * invoked sequencially. |
|---|
| | | * @param[in] call #LinphoneChatRoom object to monitor. |
|---|
| | | * @param[in] cbs A #LinphoneChatRoomCbs object holding the callbacks you need. A reference is taken by the #LinphoneChatRoom until you invoke linphone_call_remove_callbacks(). |
|---|
| | | * @param chat_room #LinphoneChatRoom object to monitor. @notnil |
|---|
| | | * @param cbs A #LinphoneChatRoomCbs object holding the callbacks you need. A reference is taken by the #LinphoneChatRoom until you invoke linphone_call_remove_callbacks(). @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_add_callbacks(LinphoneChatRoom *cr, LinphoneChatRoomCbs *cbs); |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_add_callbacks(LinphoneChatRoom *chat_room, LinphoneChatRoomCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Remove a listener from a LinphoneChatRoom |
|---|
| | | * @param[in] call LinphoneChatRoom object |
|---|
| | | * @param[in] cbs LinphoneChatRoomCbs object to remove. |
|---|
| | | * @param chat_room #LinphoneChatRoom object @notnil |
|---|
| | | * @param cbs LinphoneChatRoomCbs object to remove. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_remove_callbacks(LinphoneChatRoom *cr, LinphoneChatRoomCbs *cbs); |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_remove_callbacks(LinphoneChatRoom *chat_room, LinphoneChatRoomCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the current LinphoneChatRoomCbs. |
|---|
| | | * This is meant only to be called from a callback to be able to get the user_data associated with the LinphoneChatRoomCbs that is calling the callback. |
|---|
| | | * @param[in] call LinphoneChatRoom object |
|---|
| | | * @return The LinphoneChatRoomCbs that has called the last callback |
|---|
| | | * @param chat_room #LinphoneChatRoom object @notnil |
|---|
| | | * @return The LinphoneChatRoomCbs that has called the last callback @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoomCbs *linphone_chat_room_get_current_callbacks(const LinphoneChatRoom *cr); |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoomCbs *linphone_chat_room_get_current_callbacks(const LinphoneChatRoom *chat_room); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the state of the chat room. |
|---|
| | | * @param[in] cr #LinphoneChatRoom object |
|---|
| | | * @return The state of the chat room |
|---|
| | | * @param chat_room #LinphoneChatRoom object @notnil |
|---|
| | | * @return The current #LinphoneChatRoomState of the chat room |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoomState linphone_chat_room_get_state (const LinphoneChatRoom *cr); |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoomState linphone_chat_room_get_state (const LinphoneChatRoom *chat_room); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Return whether or not the chat room has been left. |
|---|
| | | * @param[in] cr #LinphoneChatRoom object |
|---|
| | | * @return whether or not the chat room has been left |
|---|
| | | * @param chat_room #LinphoneChatRoom object @notnil |
|---|
| | | * @return TRUE if the chat room has been left, FALSE otherwise. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_chat_room_has_been_left (const LinphoneChatRoom *cr); |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_chat_room_has_been_left (const LinphoneChatRoom *chat_room); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Return the last updated time for the chat room |
|---|
| | | * @param[in] cr LinphoneChatRoom object |
|---|
| | | * @param chat_room #LinphoneChatRoom object @notnil |
|---|
| | | * @return the last updated time |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC time_t linphone_chat_room_get_last_update_time(const LinphoneChatRoom *cr); |
|---|
| | | LINPHONE_PUBLIC time_t linphone_chat_room_get_last_update_time(const LinphoneChatRoom *chat_room); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Add a participant to a chat room. This may fail if this type of chat room does not handle participants. |
|---|
| | | * Use linphone_chat_room_can_handle_participants() to know if this chat room handles participants. |
|---|
| | | * @param[in] cr A #LinphoneChatRoom object |
|---|
| | | * @param[in] addr The address of the participant to add to the chat room |
|---|
| | | * @param chat_room A #LinphoneChatRoom object @notnil |
|---|
| | | * @param addr The address of the participant to add to the chat room @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_add_participant (LinphoneChatRoom *cr, const LinphoneAddress *addr); |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_add_participant (LinphoneChatRoom *chat_room, const LinphoneAddress *addr); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Add several participants to a chat room at once. This may fail if this type of chat room does not handle participants. |
|---|
| | | * Use linphone_chat_room_can_handle_participants() to know if this chat room handles participants. |
|---|
| | | * @param[in] cr A #LinphoneChatRoom object |
|---|
| | | * @param[in] addresses \bctbx_list{LinphoneAddress} |
|---|
| | | * @param chat_room A #LinphoneChatRoom object @notnil |
|---|
| | | * @param addresses The participants to add. \bctbx_list{LinphoneAddress} @notnil |
|---|
| | | * @return TRUE if everything is OK, FALSE otherwise |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_add_participants (LinphoneChatRoom *cr, const bctbx_list_t *addresses); |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_chat_room_add_participants (LinphoneChatRoom *chat_room, const bctbx_list_t *addresses); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Tells whether a chat room is able to handle participants. |
|---|
| | | * @param[in] cr A #LinphoneChatRoom object |
|---|
| | | * @return A boolean value telling whether the chat room can handle participants or not |
|---|
| | | * @param chat_room A #LinphoneChatRoom object @notnil |
|---|
| | | * @return TRUE if the chat room can handle participants, FALSE otherwise |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_chat_room_can_handle_participants (const LinphoneChatRoom *cr); |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_chat_room_can_handle_participants (const LinphoneChatRoom *chat_room); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Find a participant of a chat room from its address. |
|---|
| | | * @param[in] cr A #LinphoneChatRoom object |
|---|
| | | * @param[in] addr The address to search in the list of participants of the chat room |
|---|
| | | * @return The participant if found, NULL otherwise. |
|---|
| | | * @param chat_room A #LinphoneChatRoom object @notnil |
|---|
| | | * @param address The #LinphoneAddress to search in the list of participants of the chat room @notnil |
|---|
| | | * @return The participant if found, NULL otherwise. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneParticipant *linphone_chat_room_find_participant (const LinphoneChatRoom *cr, const LinphoneAddress *addr); |
|---|
| | | LINPHONE_PUBLIC LinphoneParticipant *linphone_chat_room_find_participant (const LinphoneChatRoom *chat_room, const LinphoneAddress *address); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the capabilities of a chat room. |
|---|
| | | * @param[in] cr A #LinphoneChatRoom object |
|---|
| | | * @return The capabilities of the chat room |
|---|
| | | * @param chat_room A #LinphoneChatRoom object @notnil |
|---|
| | | * @return The capabilities of the chat room (as a #LinphoneChatRoomCapabilitiesMask) |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoomCapabilitiesMask linphone_chat_room_get_capabilities (const LinphoneChatRoom *cr); |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoomCapabilitiesMask linphone_chat_room_get_capabilities (const LinphoneChatRoom *chat_room); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Check if a chat room has given capabilities. |
|---|
| | | * @param[in] cr A #LinphoneChatRoom object |
|---|
| | | * @param[in] mask A Capabilities mask |
|---|
| | | * @return True if the mask matches, false otherwise |
|---|
| | | * @param chat_room A #LinphoneChatRoom object @notnil |
|---|
| | | * @param mask a #LinphoneChatRoomCapabilitiesMask mask |
|---|
| | | * @return TRUE if the mask matches, FALSE otherwise |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_chat_room_has_capability(const LinphoneChatRoom *cr, int mask); |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_chat_room_has_capability(const LinphoneChatRoom *chat_room, int mask); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the conference address of the chat room. |
|---|
| | | * @param[in] cr A #LinphoneChatRoom object |
|---|
| | | * @return The conference address of the chat room or NULL if this type of chat room is not conference based |
|---|
| | | * @param chat_room A #LinphoneChatRoom object @notnil |
|---|
| | | * @return The conference address of the chat room or NULL if this type of chat room is not conference based. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress *linphone_chat_room_get_conference_address (const LinphoneChatRoom *cr); |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress *linphone_chat_room_get_conference_address (const LinphoneChatRoom *chat_room); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the participant representing myself in the chat room. |
|---|
| | | * @param[in] cr A #LinphoneChatRoom object |
|---|
| | | * @return The participant representing myself in the conference. |
|---|
| | | * @param chat_room A #LinphoneChatRoom object @notnil |
|---|
| | | * @return The participant representing myself in the conference or NULL if me is not set. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneParticipant *linphone_chat_room_get_me (const LinphoneChatRoom *cr); |
|---|
| | | LINPHONE_PUBLIC LinphoneParticipant *linphone_chat_room_get_me (const LinphoneChatRoom *chat_room); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the number of participants in the chat room (that is without ourselves). |
|---|
| | | * @param[in] cr A #LinphoneChatRoom object |
|---|
| | | * @param chat_room A #LinphoneChatRoom object @notnil |
|---|
| | | * @return The number of participants in the chat room |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC int linphone_chat_room_get_nb_participants (const LinphoneChatRoom *cr); |
|---|
| | | LINPHONE_PUBLIC int linphone_chat_room_get_nb_participants (const LinphoneChatRoom *chat_room); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the list of participants of a chat room. |
|---|
| | | * @param[in] cr A #LinphoneChatRoom object |
|---|
| | | * @return \bctbx_list{LinphoneParticipant} |
|---|
| | | * @param chat_room A #LinphoneChatRoom object @notnil |
|---|
| | | * @return A \bctbx_list{LinphoneParticipant} of the participants |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bctbx_list_t * linphone_chat_room_get_participants (const LinphoneChatRoom *cr); |
|---|
| | | LINPHONE_PUBLIC bctbx_list_t * linphone_chat_room_get_participants (const LinphoneChatRoom *chat_room); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the subject of a chat room. |
|---|
| | | * @param[in] cr A #LinphoneChatRoom object |
|---|
| | | * @return The subject of the chat room |
|---|
| | | * @param chat_room A #LinphoneChatRoom object @notnil |
|---|
| | | * @return The subject of the chat room. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_chat_room_get_subject (const LinphoneChatRoom *cr); |
|---|
| | | LINPHONE_PUBLIC const char * linphone_chat_room_get_subject (const LinphoneChatRoom *chat_room); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the security level of a chat room. |
|---|
| | | * @param[in] cr A #LinphoneChatRoom object |
|---|
| | | * @return The security level of the chat room |
|---|
| | | * @param chat_room A #LinphoneChatRoom object @notnil |
|---|
| | | * @return The current #LinphoneChatRoomSecurityLevel of the chat room |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoomSecurityLevel linphone_chat_room_get_security_level (LinphoneChatRoom *cr); |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoomSecurityLevel linphone_chat_room_get_security_level (LinphoneChatRoom *chat_room); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Leave a chat room. |
|---|
| | | * @param[in] cr A #LinphoneChatRoom object |
|---|
| | | * @param chat_room A #LinphoneChatRoom object @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_leave (LinphoneChatRoom *cr); |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_leave (LinphoneChatRoom *chat_room); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Remove a participant of a chat room. |
|---|
| | | * @param[in] cr A #LinphoneChatRoom object |
|---|
| | | * @param[in] participant The participant to remove from the chat room |
|---|
| | | * @param chat_room A #LinphoneChatRoom object @notnil |
|---|
| | | * @param participant The participant to remove from the chat room @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_remove_participant (LinphoneChatRoom *cr, LinphoneParticipant *participant); |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_remove_participant (LinphoneChatRoom *chat_room, LinphoneParticipant *participant); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Remove several participants of a chat room at once. |
|---|
| | | * @param[in] cr A #LinphoneChatRoom object |
|---|
| | | * @param[in] participants \bctbx_list{LinphoneParticipant} |
|---|
| | | * @param chat_room A #LinphoneChatRoom object @notnil |
|---|
| | | * @param participants The participants to remove. \bctbx_list{LinphoneParticipant} @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_remove_participants (LinphoneChatRoom *cr, const bctbx_list_t *participants); |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_remove_participants (LinphoneChatRoom *chat_room, const bctbx_list_t *participants); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Change the admin status of a participant of a chat room (you need to be an admin yourself to do this). |
|---|
| | | * @param[in] cr A #LinphoneChatRoom object |
|---|
| | | * @param[in] participant The Participant for which to change the admin status |
|---|
| | | * @param[in] isAdmin A boolean value telling whether the participant should now be an admin or not |
|---|
| | | * @param chat_room A #LinphoneChatRoom object @notnil |
|---|
| | | * @param participant The Participant for which to change the admin status @notnil |
|---|
| | | * @param is_admin A boolean value telling whether the participant should now be an admin or not |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_set_participant_admin_status (LinphoneChatRoom *cr, LinphoneParticipant *participant, bool_t isAdmin); |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_set_participant_admin_status (LinphoneChatRoom *chat_room, LinphoneParticipant *participant, bool_t is_admin); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the subject of a chat room. |
|---|
| | | * @param[in] cr A #LinphoneChatRoom object |
|---|
| | | * @param[in] subject The new subject to set for the chat room |
|---|
| | | * @param chat_room A #LinphoneChatRoom object @notnil |
|---|
| | | * @param subject The new subject to set for the chat room @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_set_subject (LinphoneChatRoom *cr, const char *subject); |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_set_subject (LinphoneChatRoom *chat_room, const char *subject); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the list of participants that are currently composing |
|---|
| | | * @param[in] cr A #LinphoneChatRoom object |
|---|
| | | * @return \bctbx_list{LinphoneAddress} list of addresses that are in the is_composing state |
|---|
| | | * @param chat_room A #LinphoneChatRoom object @notnil |
|---|
| | | * @return List of addresses that are in the is_composing state. \bctbx_list{LinphoneAddress} |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const bctbx_list_t * linphone_chat_room_get_composing_addresses(LinphoneChatRoom *cr); |
|---|
| | | LINPHONE_PUBLIC const bctbx_list_t * linphone_chat_room_get_composing_addresses(LinphoneChatRoom *chat_room); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the conference address of a group chat room. This function needs to be called from the |
|---|
| | | * #LinphoneChatRoomCbsConferenceAddressGenerationCb callback and only there. |
|---|
| | | * This function is meaningful only for server implementation of chatroom, and shall not by used by client applications. |
|---|
| | | * @param[in] cr A #LinphoneChatRoom object |
|---|
| | | * @param[in] confAddr The conference address to be used by the group chat room |
|---|
| | | * @param chat_room A #LinphoneChatRoom object @notnil |
|---|
| | | * @param conference_address The conference #LinphoneAddress to be used by the group chat room @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_set_conference_address (LinphoneChatRoom *cr, const LinphoneAddress *confAddr); |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_set_conference_address (LinphoneChatRoom *chat_room, const LinphoneAddress *conference_address); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the list of participant devices in the form of SIP URIs with GRUUs for a given participant. |
|---|
| | | * This function is meaningful only for server implementation of chatroom, and shall not by used by client applications. |
|---|
| | | * @param[in] cr A #LinphoneChatRoom object |
|---|
| | | * @param[in] partAddr The participant address |
|---|
| | | * @param[in] deviceIdentities \bctbx_list{LinphoneParticipantDeviceIdentity} list of the participant devices to be used by the group chat room |
|---|
| | | * @param chat_room A #LinphoneChatRoom object @notnil |
|---|
| | | * @param participant_address The participant address @notnil |
|---|
| | | * @param device_identities List of the participant devices to be used by the group chat room \bctbx_list{LinphoneParticipantDeviceIdentity} @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_set_participant_devices(LinphoneChatRoom *cr, const LinphoneAddress *partAddr, const bctbx_list_t *deviceIdentities); |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_set_participant_devices(LinphoneChatRoom *chat_room, const LinphoneAddress *participant_address, const bctbx_list_t *device_identities); |
|---|
| | | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Notify the chatroom that a participant device has just registered. |
|---|
| | | * This function is meaningful only for server implementation of chatroom, and shall not by used by client applications. |
|---|
| | | * @param[in] cr A #LinphoneChatRoom object |
|---|
| | | * @param[in] partDevice list of the participant devices to be used by the group chat room |
|---|
| | | * @param chat_room A #LinphoneChatRoom object @notnil |
|---|
| | | * @param participant_device list of the participant devices to be used by the group chat room @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_notify_participant_device_registration(LinphoneChatRoom *cr, const LinphoneAddress *participant_device); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns back pointer to #LinphoneCore object. |
|---|
| | | * @deprecated use linphone_chat_room_get_core() |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED LinphoneCore* linphone_chat_room_get_lc(const LinphoneChatRoom *cr); |
|---|
| | | LINPHONE_PUBLIC void linphone_chat_room_notify_participant_device_registration(LinphoneChatRoom *chat_room, const LinphoneAddress *participant_device); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns current parameters associated with the chat room. |
|---|
| | | * This is typically the parameters passed at chat room creation to linphone_core_create_chat_room() or some default |
|---|
| | | * parameters if no #LinphoneChatRoomParams was explicitely passed during chat room creation. |
|---|
| | | * @param cr the #LinphoneChatRoom object |
|---|
| | | * @return the chat room current parameters. |
|---|
| | | * This is typically the parameters passed at chat room chat_roomeation to linphone_core_chat_roomeate_chat_room() or some default |
|---|
| | | * parameters if no #LinphoneChatRoomParams was explicitely passed during chat room chat_roomeation. |
|---|
| | | * @param chat_room the #LinphoneChatRoom object @notnil |
|---|
| | | * @return the current #LinphoneChatRoomParams parameters. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const LinphoneChatRoomParams *linphone_chat_room_get_current_params(const LinphoneChatRoom *cr); |
|---|
| | | LINPHONE_PUBLIC const LinphoneChatRoomParams *linphone_chat_room_get_current_params(const LinphoneChatRoom *chat_room); |
|---|
| | | |
|---|
| | | /************ */ |
|---|
| | | /* DEPRECATED */ |
|---|
| | | /* ********** */ |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates a message attached to the given chat room. |
|---|
| | | * @param chat_room the #LinphoneChatRoom object. |
|---|
| | | * @param message text message, NULL if absent. |
|---|
| | | * @param external_body_url the URL given in external body or NULL. |
|---|
| | | * @param state the LinphoneChatMessage. State of the message. |
|---|
| | | * @param time the time_t at which the message has been received/sent. |
|---|
| | | * @param is_read TRUE if the message should be flagged as read, FALSE otherwise. |
|---|
| | | * @param is_incoming TRUE if the message has been received, FALSE otherwise. |
|---|
| | | * @return a new #LinphoneChatMessage |
|---|
| | | * @deprecated 14/11/2017 Use #linphone_chat_room_create_message_from_utf8() instead. |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED LinphoneChatMessage* linphone_chat_room_create_message_2(LinphoneChatRoom *chat_room, const char* message, const char* external_body_url, LinphoneChatMessageState state, time_t time, bool_t is_read, bool_t is_incoming); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns back pointer to #LinphoneCore object. |
|---|
| | | * @deprecated 15/09/2017 use linphone_chat_room_get_core() |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED LinphoneCore* linphone_chat_room_get_lc(const LinphoneChatRoom *chat_room); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Send a message to peer member of this chat room. |
|---|
| | | * @deprecated 13/10/2017 Use linphone_chat_message_send() instead. |
|---|
| | | * @param chat_room #LinphoneChatRoom object |
|---|
| | | * @param message message to be sent |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED void linphone_chat_room_send_message(LinphoneChatRoom *chat_room, const char *msg); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Send a message to peer member of this chat room. |
|---|
| | | * @param chat_room #LinphoneChatRoom object |
|---|
| | | * @param message #LinphoneChatMessage object |
|---|
| | | * The state of the message sending will be notified via the callbacks defined in the #LinphoneChatMessageCbs object that can be obtained |
|---|
| | | * by calling linphone_chat_message_get_callbacks(). |
|---|
| | | * The #LinphoneChatMessage reference is transfered to the function and thus doesn't need to be unref'd by the application. |
|---|
| | | * @deprecated 13/10/2017 Use linphone_chat_message_send() instead. |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED void linphone_chat_room_send_chat_message(LinphoneChatRoom *chat_room, LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates a message attached to the given chat room with a plain text content filled with the given message. |
|---|
| | | * @param chat_room the #LinphoneChatRoom object. @notnil |
|---|
| | | * @param message text message, NULL if absent. @maybenil |
|---|
| | | * @return a new #LinphoneChatMessage @notnil |
|---|
| | | * @deprecated 01/07/2020. Use linphone_chat_room_create_message_from_utf8() instead. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED LinphoneChatMessage* linphone_chat_room_create_message(LinphoneChatRoom *chat_room,const char* message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @} |
|---|
| New file |
| | |
|---|
| | | /* |
|---|
| | | * Copyright (c) 2010-2019 Belledonne Communications SARL. |
|---|
| | | * |
|---|
| | | * This file is part of Liblinphone. |
|---|
| | | * |
|---|
| | | * 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 3 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, see <http://www.gnu.org/licenses/>. |
|---|
| | | */ |
|---|
| | | |
|---|
| | | #ifndef _L_C_CONFERENCE_CBS_H_ |
|---|
| | | #define _L_C_CONFERENCE_CBS_H_ |
|---|
| | | |
|---|
| | | #include "linphone/api/c-callbacks.h" |
|---|
| | | #include "linphone/api/c-types.h" |
|---|
| | | |
|---|
| | | // ============================================================================= |
|---|
| | | |
|---|
| | | #ifdef __cplusplus |
|---|
| | | extern "C" { |
|---|
| | | #endif // ifdef __cplusplus |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @addtogroup conferencing |
|---|
| | | * @{ |
|---|
| | | */ |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Acquire a reference to the conference callbacks object. |
|---|
| | | * @param[in] cbs The conference callbacks object |
|---|
| | | * @return The same conference callbacks object |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneConferenceCbs * linphone_conference_cbs_ref (LinphoneConferenceCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Release reference to the conference callbacks object. |
|---|
| | | * @param[in] cr The conference callbacks object |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_conference_cbs_unref (LinphoneConferenceCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Retrieve the user pointer associated with the conference callbacks object. |
|---|
| | | * @param[in] cr The conference callbacks object |
|---|
| | | * @return The user pointer associated with the conference callbacks object |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void * linphone_conference_cbs_get_user_data (const LinphoneConferenceCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user pointer to the conference callbacks object. |
|---|
| | | * @param[in] cr The conference callbacks object |
|---|
| | | * @param[in] ud The user pointer to associate with the conference callbacks object |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_conference_cbs_set_user_data (LinphoneConferenceCbs *cbs, void *ud); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the participant added callback. |
|---|
| | | * @param[in] cbs #LinphoneConferenceCbs object. |
|---|
| | | * @return The current participant added callback. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneConferenceCbsParticipantAddedCb linphone_conference_cbs_get_participant_added (const LinphoneConferenceCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the participant added callback. |
|---|
| | | * @param[in] cbs #LinphoneConferenceCbs object. |
|---|
| | | * @param[in] cb The participant added callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_conference_cbs_set_participant_added (LinphoneConferenceCbs *cbs, LinphoneConferenceCbsParticipantAddedCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the participant removed callback. |
|---|
| | | * @param[in] cbs #LinphoneConferenceCbs object. |
|---|
| | | * @return The current participant removed callback. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneConferenceCbsParticipantRemovedCb linphone_conference_cbs_get_participant_removed (const LinphoneConferenceCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the participant removed callback. |
|---|
| | | * @param[in] cbs #LinphoneConferenceCbs object. |
|---|
| | | * @param[in] cb The participant removed callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_conference_cbs_set_participant_removed (LinphoneConferenceCbs *cbs, LinphoneConferenceCbsParticipantRemovedCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the participant device added callback. |
|---|
| | | * @param[in] cbs #LinphoneConferenceCbs object. |
|---|
| | | * @return The current participant device added callback. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneConferenceCbsParticipantDeviceAddedCb linphone_conference_cbs_get_participant_device_added (const LinphoneConferenceCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the participant device added callback. |
|---|
| | | * @param[in] cbs #LinphoneConferenceCbs object. |
|---|
| | | * @param[in] cb The participant device added callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_conference_cbs_set_participant_device_added (LinphoneConferenceCbs *cbs, LinphoneConferenceCbsParticipantDeviceAddedCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the participant device removed callback. |
|---|
| | | * @param[in] cbs #LinphoneConferenceCbs object. |
|---|
| | | * @return The current participant device removed callback. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneConferenceCbsParticipantDeviceRemovedCb linphone_conference_cbs_get_participant_device_removed (const LinphoneConferenceCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the participant device removed callback. |
|---|
| | | * @param[in] cbs #LinphoneConferenceCbs object. |
|---|
| | | * @param[in] cb The participant device removed callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_conference_cbs_set_participant_device_removed (LinphoneConferenceCbs *cbs, LinphoneConferenceCbsParticipantDeviceRemovedCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the participant admin status changed callback. |
|---|
| | | * @param[in] cbs #LinphoneConferenceCbs object. |
|---|
| | | * @return The current participant admin status changed callback. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneConferenceCbsParticipantAdminStatusChangedCb linphone_conference_cbs_get_participant_admin_status_changed (const LinphoneConferenceCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the participant admin status changed callback. |
|---|
| | | * @param[in] cbs #LinphoneConferenceCbs object. |
|---|
| | | * @param[in] cb The participant admin status changed callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_conference_cbs_set_participant_admin_status_changed (LinphoneConferenceCbs *cbs, LinphoneConferenceCbsParticipantAdminStatusChangedCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the state changed callback. |
|---|
| | | * @param[in] cbs #LinphoneConferenceCbs object. |
|---|
| | | * @return The current state changed callback. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneConferenceCbsStateChangedCb linphone_conference_cbs_get_state_changed (const LinphoneConferenceCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the state changed callback. |
|---|
| | | * @param[in] cbs #LinphoneConferenceCbs object. |
|---|
| | | * @param[in] cb The state changed callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_conference_cbs_set_state_changed (LinphoneConferenceCbs *cbs, LinphoneConferenceCbsStateChangedCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the subject changed callback. |
|---|
| | | * @param[in] cbs #LinphoneConferenceCbs object. |
|---|
| | | * @return The current subject changed callback. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneConferenceCbsSubjectChangedCb linphone_conference_cbs_get_subject_changed (const LinphoneConferenceCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the subject changed callback. |
|---|
| | | * @param[in] cbs #LinphoneConferenceCbs object. |
|---|
| | | * @param[in] cb The subject changed callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_conference_cbs_set_subject_changed (LinphoneConferenceCbs *cbs, LinphoneConferenceCbsSubjectChangedCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @} |
|---|
| | | */ |
|---|
| | | |
|---|
| | | #ifdef __cplusplus |
|---|
| | | } |
|---|
| | | #endif // ifdef __cplusplus |
|---|
| | | |
|---|
| | | #endif // ifndef _L_C_CONFERENCE_CBS_H_ |
|---|
| New file |
| | |
|---|
| | | /* |
|---|
| | | * Copyright (c) 2010-2019 Belledonne Communications SARL. |
|---|
| | | * |
|---|
| | | * This file is part of Liblinphone. |
|---|
| | | * |
|---|
| | | * 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 3 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, see <http://www.gnu.org/licenses/>. |
|---|
| | | */ |
|---|
| | | |
|---|
| | | #ifndef _L_C_CONFERENCE_H_ |
|---|
| | | #define _L_C_CONFERENCE_H_ |
|---|
| | | |
|---|
| | | #include "linphone/api/c-types.h" |
|---|
| | | |
|---|
| | | // ============================================================================= |
|---|
| | | |
|---|
| | | #ifdef __cplusplus |
|---|
| | | extern "C" { |
|---|
| | | #endif // ifdef __cplusplus |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @addtogroup conferencing |
|---|
| | | * @{ |
|---|
| | | */ |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Add a listener in order to be notified of #LinphoneConference events. Once an event is received, registred #LinphoneConferenceCbs are |
|---|
| | | * invoked sequencially. |
|---|
| | | * @param conference #LinphoneConference object. @notnil |
|---|
| | | * @param cbs A #LinphoneConferenceCbs object holding the callbacks you need. A reference is taken by the #LinphoneConference until you invoke linphone_conference_remove_callbacks(). @notnil |
|---|
| | | |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_conference_add_callbacks(LinphoneConference *conference, LinphoneConferenceCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Remove a listener from a LinphoneConference |
|---|
| | | * @param conference #LinphoneConference object. @notnil |
|---|
| | | * @param cbs #LinphoneConferenceCbs object to remove. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_conference_remove_callbacks(LinphoneConference *conference, LinphoneConferenceCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the current LinphoneConferenceCbs. |
|---|
| | | * This is meant only to be called from a callback to be able to get the user_data associated with the LinphoneConferenceCbs that is calling the callback. |
|---|
| | | * @param conference #LinphoneConference object. @notnil |
|---|
| | | * @return The LinphoneConferenceCbs that has called the last callback. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneConferenceCbs *linphone_conference_get_current_callbacks(const LinphoneConference *conference); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns core for a #LinphoneConference |
|---|
| | | * @param conference #LinphoneConference object. @notnil |
|---|
| | | * @return back pointer to #LinphoneCore object. @notnil |
|---|
| | | * Returns back pointer to #LinphoneCore object. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneCore* linphone_conference_get_core(const LinphoneConference *conference); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the conference address of the conference. |
|---|
| | | * @param conference A #LinphoneConference object. @notnil |
|---|
| | | * @return The conference address of the conference or NULL if it is unknown. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress *linphone_conference_get_conference_address (const LinphoneConference *conference); |
|---|
| | | LINPHONE_PUBLIC char *linphone_conference_get_conference_address_as_string (const LinphoneConference *conference); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @} |
|---|
| | | */ |
|---|
| | | |
|---|
| | | #ifdef __cplusplus |
|---|
| | | } |
|---|
| | | #endif // ifdef __cplusplus |
|---|
| | | |
|---|
| | | #endif // ifndef _L_C_CONFERENCE_H_ |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Acquire a reference to the content. |
|---|
| | | * @param[in] content #LinphoneContent object. |
|---|
| | | * @return The same #LinphoneContent object. |
|---|
| | | * @param content #LinphoneContent object. @notnil |
|---|
| | | * @return The same #LinphoneContent object. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneContent *linphone_content_ref (LinphoneContent *content); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Release reference to the content. |
|---|
| | | * @param[in] content #LinphoneContent object. |
|---|
| | | * @param content #LinphoneContent object. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_content_unref (LinphoneContent *content); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Retrieve the user pointer associated with the content. |
|---|
| | | * @param[in] content #LinphoneContent object. |
|---|
| | | * @return The user pointer associated with the content. |
|---|
| | | * @param content #LinphoneContent object. @notnil |
|---|
| | | * @return The user pointer associated with the content. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void *linphone_content_get_user_data (const LinphoneContent *content); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user pointer to the content. |
|---|
| | | * @param[in] content #LinphoneContent object. |
|---|
| | | * @param[in] ud The user pointer to associate with the content. |
|---|
| | | * @param content #LinphoneContent object. @notnil |
|---|
| | | * @param user_data The user pointer to associate with the content. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_content_set_user_data (LinphoneContent *content, void *user_data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the mime type of the content data. |
|---|
| | | * @param[in] content #LinphoneContent object. |
|---|
| | | * @return The mime type of the content data, for example "application". |
|---|
| | | * @param content #LinphoneContent object. @notnil |
|---|
| | | * @return The mime type of the content data, for example "application". @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_content_get_type (const LinphoneContent *content); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the mime type of the content data. |
|---|
| | | * @param[in] content #LinphoneContent object. |
|---|
| | | * @param[in] type The mime type of the content data, for example "application". |
|---|
| | | * @param content #LinphoneContent object. @notnil |
|---|
| | | * @param type The mime type of the content data, for example "application". @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_content_set_type (LinphoneContent *content, const char *type); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the mime subtype of the content data. |
|---|
| | | * @param[in] content #LinphoneContent object. |
|---|
| | | * @return The mime subtype of the content data, for example "html". |
|---|
| | | * @param content #LinphoneContent object. @notnil |
|---|
| | | * @return The mime subtype of the content data, for example "html". @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_content_get_subtype (const LinphoneContent *content); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the mime subtype of the content data. |
|---|
| | | * @param[in] content #LinphoneContent object. |
|---|
| | | * @param[in] subtype The mime subtype of the content data, for example "html". |
|---|
| | | * @param content #LinphoneContent object. @notnil |
|---|
| | | * @param subtype The mime subtype of the content data, for example "html". @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_content_set_subtype (LinphoneContent *content, const char *subtype); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Adds a parameter to the ContentType header. |
|---|
| | | * @param[in] content LinphoneContent object. |
|---|
| | | * @param[in] name the name of the parameter to add. |
|---|
| | | * @param[in] value the value of the parameter to add. |
|---|
| | | * @param content #LinphoneContent object. @notnil |
|---|
| | | * @param name the name of the parameter to add. @notnil |
|---|
| | | * @param value the value of the parameter to add. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_content_add_content_type_parameter ( |
|---|
| | | LinphoneContent *content, |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the content data buffer, usually a string. |
|---|
| | | * @param[in] content #LinphoneContent object. |
|---|
| | | * @return The content data buffer. |
|---|
| | | * @param content #LinphoneContent object. @notnil |
|---|
| | | * @return The content data buffer. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const uint8_t *linphone_content_get_buffer (const LinphoneContent *content); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the content data buffer, usually a string. |
|---|
| | | * @param[in] content #LinphoneContent object. |
|---|
| | | * @param[in] buffer The content data buffer. |
|---|
| | | * @param[in] size The size of the content data buffer. |
|---|
| | | * @param content #LinphoneContent object. @notnil |
|---|
| | | * @param buffer The content data buffer. @notnil |
|---|
| | | * @param size The size of the content data buffer. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_content_set_buffer (LinphoneContent *content, const uint8_t *buffer, size_t size); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the string content data buffer. |
|---|
| | | * @param[in] content #LinphoneContent object |
|---|
| | | * @return The string content data buffer. |
|---|
| | | * Get the string content data buffer. Introduced in 01/07/2020 |
|---|
| | | * @param content #LinphoneContent object. @notnil |
|---|
| | | * @return The string content data buffer in UTF8. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_content_get_string_buffer (const LinphoneContent *content); |
|---|
| | | LINPHONE_PUBLIC const char *linphone_content_get_utf8_text(const LinphoneContent *content); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the string content data buffer. |
|---|
| | | * @param[in] content #LinphoneContent object. |
|---|
| | | * @param[in] buffer The string content data buffer. |
|---|
| | | * Get the string content data buffer. Introduced in 01/07/2020 |
|---|
| | | * @param content #LinphoneContent object. @notnil |
|---|
| | | * @param buffer The string content data buffer in UTF8. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_content_set_string_buffer (LinphoneContent *content, const char *buffer); |
|---|
| | | LINPHONE_PUBLIC void linphone_content_set_utf8_text (LinphoneContent *content, const char *buffer); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the content data buffer size, excluding null character despite null character is always set for convenience. |
|---|
| | | * @param[in] content #LinphoneContent object. |
|---|
| | | * @param content #LinphoneContent object. @notnil |
|---|
| | | * @return The content data buffer size. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC size_t linphone_content_get_size (const LinphoneContent *content); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the file size if content is either a FileContent or a FileTransferContent. |
|---|
| | | * @param[in] content #LinphoneContent object. |
|---|
| | | * @param content #LinphoneContent object. @notnil |
|---|
| | | * @return The represented file size. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC size_t linphone_content_get_file_size(const LinphoneContent *content); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the content data size, excluding null character despite null character is always set for convenience. |
|---|
| | | * @param[in] content #LinphoneContent object |
|---|
| | | * @param[in] size The content data buffer size. |
|---|
| | | * @param content #LinphoneContent object @notnil |
|---|
| | | * @param size The content data buffer size. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_content_set_size (LinphoneContent *content, size_t size); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the encoding of the data buffer, for example "gzip". |
|---|
| | | * @param[in] content #LinphoneContent object. |
|---|
| | | * @return The encoding of the data buffer. |
|---|
| | | * @param content #LinphoneContent object. @notnil |
|---|
| | | * @return The encoding of the data buffer. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_content_get_encoding (const LinphoneContent *content); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the encoding of the data buffer, for example "gzip". |
|---|
| | | * @param[in] content #LinphoneContent object. |
|---|
| | | * @param[in] encoding The encoding of the data buffer. |
|---|
| | | * @param content #LinphoneContent object. @notnil |
|---|
| | | * @param encoding The encoding of the data buffer. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_content_set_encoding (LinphoneContent *content, const char *encoding); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the name associated with a RCS file transfer message. It is used to store the original filename of the file to be downloaded from server. |
|---|
| | | * @param[in] content #LinphoneContent object. |
|---|
| | | * @return The name of the content. |
|---|
| | | * @param content #LinphoneContent object. @notnil |
|---|
| | | * @return The name of the content. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_content_get_name (const LinphoneContent *content); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the name associated with a RCS file transfer message. It is used to store the original filename of the file to be downloaded from server. |
|---|
| | | * @param[in] content #LinphoneContent object. |
|---|
| | | * @param[in] name The name of the content. |
|---|
| | | * @param content #LinphoneContent object. @notnil |
|---|
| | | * @param name The name of the content. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_content_set_name (LinphoneContent *content, const char *name); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Tell whether a content is a multipart content. |
|---|
| | | * @param[in] content #LinphoneContent object. |
|---|
| | | * @param content #LinphoneContent object. @notnil |
|---|
| | | * @return A boolean value telling whether the content is multipart or not. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_content_is_multipart (const LinphoneContent *content); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get all the parts from a multipart content. |
|---|
| | | * @param[in] content #LinphoneContent object. |
|---|
| | | * @return A \bctbx_list{LinphoneContent} \onTheFlyList object holding the part if found, NULL otherwise. |
|---|
| | | * @param content #LinphoneContent object. @notnil |
|---|
| | | * @return A \bctbx_list{LinphoneContent} object holding the part if found, NULL otherwise. @tobefreed @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC |
|---|
| | | bctbx_list_t *linphone_content_get_parts (const LinphoneContent *content); |
|---|
| | | LINPHONE_PUBLIC bctbx_list_t *linphone_content_get_parts (const LinphoneContent *content); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get a part from a multipart content according to its index. |
|---|
| | | * @param[in] content #LinphoneContent object. |
|---|
| | | * @param[in] idx The index of the part to get. |
|---|
| | | * @return A #LinphoneContent object holding the part if found, NULL otherwise. |
|---|
| | | * @param content #LinphoneContent object. @notnil |
|---|
| | | * @param index The index of the part to get. |
|---|
| | | * @return A #LinphoneContent object holding the part if found, NULL otherwise. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneContent *linphone_content_get_part (const LinphoneContent *content, int idx); |
|---|
| | | LINPHONE_PUBLIC LinphoneContent *linphone_content_get_part (const LinphoneContent *content, int index); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Find a part from a multipart content looking for a part header with a specified value. |
|---|
| | | * @param[in] content #LinphoneContent object. |
|---|
| | | * @param[in] header_name The name of the header to look for. |
|---|
| | | * @param[in] header_value The value of the header to look for. |
|---|
| | | * @return A #LinphoneContent object object the part if found, NULL otherwise. |
|---|
| | | * @param content #LinphoneContent object. @notnil |
|---|
| | | * @param header_name The name of the header to look for. @notnil |
|---|
| | | * @param header_value The value of the header to look for. @notnil |
|---|
| | | * @return A #LinphoneContent object object the part if found, NULL otherwise. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneContent *linphone_content_find_part_by_header ( |
|---|
| | | const LinphoneContent *content, |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get a custom header value of a content. |
|---|
| | | * @param[in] content #LinphoneContent object. |
|---|
| | | * @param[in] header_name The name of the header to get the value from. |
|---|
| | | * @return The value of the header if found, NULL otherwise. |
|---|
| | | * @param content #LinphoneContent object. @notnil |
|---|
| | | * @param header_name The name of the header to get the value from. @notnil |
|---|
| | | * @return The value of the header if found, NULL otherwise. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_content_get_custom_header (const LinphoneContent *content, const char *header_name); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the key associated with a RCS file transfer message if encrypted |
|---|
| | | * @param[in] content #LinphoneContent object. |
|---|
| | | * @return The key to encrypt/decrypt the file associated to this content. |
|---|
| | | * @param content #LinphoneContent object. @notnil |
|---|
| | | * @return The key to encrypt/decrypt the file associated to this content. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_content_get_key (const LinphoneContent *content); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the size of key associated with a RCS file transfer message if encrypted |
|---|
| | | * @param[in] content #LinphoneContent object. |
|---|
| | | * @param content #LinphoneContent object. @notnil |
|---|
| | | * @return The key size in bytes |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC size_t linphone_content_get_key_size (const LinphoneContent *content); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the key associated with a RCS file transfer message if encrypted |
|---|
| | | * @param[in] content #LinphoneContent object. |
|---|
| | | * @param[in] key The key to be used to encrypt/decrypt file associated to this content. |
|---|
| | | * @param[in] key_length The lengh of the key. |
|---|
| | | * @param content #LinphoneContent object. @notnil |
|---|
| | | * @param key The key to be used to encrypt/decrypt file associated to this content. @notnil |
|---|
| | | * @param key_length The lengh of the key. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_content_set_key (LinphoneContent *content, const char *key, const size_t key_length); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the file transfer filepath set for this content (replace linphone_chat_message_get_file_transfer_filepath). |
|---|
| | | * @param[in] content #LinphoneContent object. |
|---|
| | | * @return The file path set for this content if it has been set, NULL otherwise. |
|---|
| | | * @param content #LinphoneContent object. @notnil |
|---|
| | | * @return The file path set for this content if it has been set, NULL otherwise. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_content_get_file_path (const LinphoneContent *content); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the file transfer filepath for this content (replace linphone_chat_message_set_file_transfer_filepath). |
|---|
| | | * If the content is an encrypted file, generate a temporary plain copy of the file and returns its paths |
|---|
| | | * The caller is responsible to then delete this temporary copy and the returned string |
|---|
| | | * @param[in] content #LinphoneContent object. |
|---|
| | | * @param[in] file_path the file transfer filepath. |
|---|
| | | * @return The file path set for this content if it has been set, NULL otherwise. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC char *linphone_content_get_plain_file_path (const LinphoneContent *content); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the file transfer filepath for this content (replace linphone_chat_message_set_file_transfer_filepath). |
|---|
| | | * @param content #LinphoneContent object. @notnil |
|---|
| | | * @param file_path the file transfer filepath. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_content_set_file_path (LinphoneContent *content, const char *file_path); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Tells whether or not this content contains text. |
|---|
| | | * @param[in] content #LinphoneContent object. |
|---|
| | | * @return True if this content contains plain text, false otherwise. |
|---|
| | | * @param content #LinphoneContent object. @notnil |
|---|
| | | * @return TRUE if this content contains plain text, FALSE otherwise. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_content_is_text (const LinphoneContent *content); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Tells whether or not this content contains a file. |
|---|
| | | * @param[in] content #LinphoneContent object. |
|---|
| | | * @return True if this content contains a file, false otherwise. |
|---|
| | | * @param content #LinphoneContent object. @notnil |
|---|
| | | * @return TRUE if this content contains a file, FALSE otherwise. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_content_is_file (const LinphoneContent *content); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Tells whether or not this content is a file transfer. |
|---|
| | | * @param[in] content #LinphoneContent object. |
|---|
| | | * @return True if this content is a file transfer, false otherwise. |
|---|
| | | * @param content #LinphoneContent object. @notnil |
|---|
| | | * @return TRUE if this content is a file transfer, FALSE otherwise. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_content_is_file_transfer (const LinphoneContent *content); |
|---|
| | | |
|---|
| | | /************ */ |
|---|
| | | /* DEPRECATED */ |
|---|
| | | /* ********** */ |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the string content data buffer. |
|---|
| | | * @param content #LinphoneContent object @notnil |
|---|
| | | * @return The string content data buffer. @notnil |
|---|
| | | * @deprecated 2020-07-01. Use linphone_content_get_utf8_text() instead. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED const char *linphone_content_get_string_buffer (const LinphoneContent *content); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the string content data buffer. |
|---|
| | | * @param content #LinphoneContent object. @notnil |
|---|
| | | * @param buffer The string content data buffer in UTF8. @notnil |
|---|
| | | * @deprecated 2020-07-01. Use linphone_content_set_utf8_text() instead. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED void linphone_content_set_string_buffer (LinphoneContent *content, const char *buffer); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Tells whether or not this content contains an encrypted file |
|---|
| | | * @return True is this content contains a file and this file is encrypted, false otherwise. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_content_is_file_encrypted (const LinphoneContent *content); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @} |
|---|
| | | */ |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Increases the reference counter of #LinphoneDialPlan objects. |
|---|
| | | * @param dial_plan the #LinphoneDialPlan object @notnil |
|---|
| | | * @return the same #LinphoneDialPlan object @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneDialPlan *linphone_dial_plan_ref(LinphoneDialPlan *dp); |
|---|
| | | LINPHONE_PUBLIC LinphoneDialPlan *linphone_dial_plan_ref(LinphoneDialPlan *dial_plan); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Decreases the reference counter of #LinphoneDialPaln objects. |
|---|
| | | * @param dial_plan the #LinphoneDialPlan object @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_dial_plan_unref(LinphoneDialPlan *dp); |
|---|
| | | LINPHONE_PUBLIC void linphone_dial_plan_unref(LinphoneDialPlan *dial_plan); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the country name of the dialplan |
|---|
| | | * @return the country name |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_dial_plan_get_country(const LinphoneDialPlan *dp); |
|---|
| | | /** |
|---|
| | | * Returns the country name of the dialplan |
|---|
| | | * @param dial_plan the #LinphoneDialPlan object @notnil |
|---|
| | | * @return the country name |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_dial_plan_get_country(const LinphoneDialPlan *dial_plan); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the iso country code of the dialplan |
|---|
| | | * @return the iso country code |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_dial_plan_get_iso_country_code(const LinphoneDialPlan *dp); |
|---|
| | | /** |
|---|
| | | * Returns the iso country code of the dialplan |
|---|
| | | * @param dial_plan the #LinphoneDialPlan object @notnil |
|---|
| | | * @return the iso country code @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_dial_plan_get_iso_country_code(const LinphoneDialPlan *dial_plan); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the country calling code of the dialplan |
|---|
| | | * @return the country calling code |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_dial_plan_get_country_calling_code(const LinphoneDialPlan *dp); |
|---|
| | | /** |
|---|
| | | * Returns the country calling code of the dialplan |
|---|
| | | * @param dial_plan the #LinphoneDialPlan object @notnil |
|---|
| | | * @return the country calling code @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_dial_plan_get_country_calling_code(const LinphoneDialPlan *dial_plan); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the national number length of the dialplan |
|---|
| | | * @return the national number length |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC int linphone_dial_plan_get_national_number_length(const LinphoneDialPlan *dp); |
|---|
| | | /** |
|---|
| | | * Returns the national number length of the dialplan |
|---|
| | | * @param dial_plan the #LinphoneDialPlan object @notnil |
|---|
| | | * @return the national number length |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC int linphone_dial_plan_get_national_number_length(const LinphoneDialPlan *dial_plan); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the international call prefix of the dialplan |
|---|
| | | * @return the international call prefix |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_dial_plan_get_international_call_prefix(const LinphoneDialPlan *dp); |
|---|
| | | /** |
|---|
| | | * Returns the international call prefix of the dialplan |
|---|
| | | * @param dial_plan the #LinphoneDialPlan object @notnil |
|---|
| | | * @return the international call prefix @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_dial_plan_get_international_call_prefix(const LinphoneDialPlan *dial_plan); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | *Function to get call country code from ISO 3166-1 alpha-2 code, ex: FR returns 33 |
|---|
| | | *@param iso country code alpha2 |
|---|
| | | *@return call country code or -1 if not found |
|---|
| | | /** |
|---|
| | | * Function to get call country code from ISO 3166-1 alpha-2 code, ex: FR returns 33 |
|---|
| | | * @param iso country code alpha2 @notnil |
|---|
| | | * @return call country code or -1 if not found |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC int linphone_dial_plan_lookup_ccc_from_iso(const char* iso); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | *Function to get call country code from an e164 number, ex: +33952650121 will return 33 |
|---|
| | | *@param e164 phone number |
|---|
| | | *@return call country code or -1 if not found |
|---|
| | | * Function to get call country code from an e164 number, ex: +33952650121 will return 33 |
|---|
| | | * @param e164 phone number @notnil |
|---|
| | | * @return call country code or -1 if not found |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC int linphone_dial_plan_lookup_ccc_from_e164(const char* e164); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Return NULL-terminated array of all known dial plans |
|---|
| | | * @deprecated use linphone_dial_plan_get_all_list instead, this method will always return NULL |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const LinphoneDialPlan* linphone_dial_plan_get_all(void); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @return \bctbx_list{LinphoneDialPlan} of all known dial plans |
|---|
| | | * Returns a list of all known dial plans |
|---|
| | | * @return The list of all known dial plans. \bctbx_list{LinphoneDialPlan} @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC bctbx_list_t * linphone_dial_plan_get_all_list(void); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Find best match for given CCC |
|---|
| | | * @return Return matching dial plan, or a generic one if none found |
|---|
| | | * @param ccc The country calling code @notnil |
|---|
| | | * @return the matching dial plan, or a generic one if none found @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const LinphoneDialPlan* linphone_dial_plan_by_ccc(const char *ccc); |
|---|
| | | /** |
|---|
| | | * Find best match for given CCC |
|---|
| | | * @return Return matching dial plan, or a generic one if none found |
|---|
| | | * @param ccc the country calling code @notnil |
|---|
| | | * @return the matching dial plan, or a generic one if none found @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const LinphoneDialPlan* linphone_dial_plan_by_ccc_as_int(int ccc); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Return if given plan is generic |
|---|
| | | * @param ccc the country calling code @notnil |
|---|
| | | * @return TRUE if generic, FALSE otherwise |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_dial_plan_is_generic(const LinphoneDialPlan *ccc); |
|---|
| | | |
|---|
| | | /************ */ |
|---|
| | | /* DEPRECATED */ |
|---|
| | | /* ********** */ |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Return NULL-terminated array of all known dial plans |
|---|
| | | * @deprecated 16/10/2017 use linphone_dial_plan_get_all_list instead, this method will always return NULL |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED const LinphoneDialPlan* linphone_dial_plan_get_all(void); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @} |
|---|
| | | */ |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Increment reference count of #LinphoneEventLog object. |
|---|
| | | * @param event_log A #LinphoneEventLog object @notnil |
|---|
| | | * @return the same #LinphoneEventLog object @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneEventLog *linphone_event_log_ref (LinphoneEventLog *event_log); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Decrement reference count of #LinphoneEventLog object. When dropped to zero, memory is freed. |
|---|
| | | * @param event_log A #LinphoneEventLog object @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_event_log_unref (LinphoneEventLog *event_log); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the type of a event log. |
|---|
| | | * @param[in] event_log A #LinphoneEventLog object |
|---|
| | | * @return The event type |
|---|
| | | * @param event_log A #LinphoneEventLog object @notnil |
|---|
| | | * @return The #LinphoneEventLogType type |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneEventLogType linphone_event_log_get_type (const LinphoneEventLog *event_log); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the creation time of a event log. |
|---|
| | | * @param[in] event_log A #LinphoneEventLog object |
|---|
| | | * @param event_log A #LinphoneEventLog object @notnil |
|---|
| | | * @return The event creation time |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC time_t linphone_event_log_get_creation_time (const LinphoneEventLog *event_log); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Delete event log from database. |
|---|
| | | * @param[in] event_log A #LinphoneEventLog object |
|---|
| | | * @param event_log A #LinphoneEventLog object @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_event_log_delete_from_database (LinphoneEventLog *event_log); |
|---|
| | | |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the peer address of a conference event. |
|---|
| | | * @param[in] event_log A #LinphoneEventLog object. |
|---|
| | | * @return The peer address. |
|---|
| | | * @param event_log A #LinphoneEventLog object. @notnil |
|---|
| | | * @return The peer #LinphoneAddress. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress *linphone_event_log_get_peer_address (const LinphoneEventLog *event_log); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the local address of a conference event. |
|---|
| | | * @param[in] event_log A #LinphoneEventLog object. |
|---|
| | | * @return The local address. |
|---|
| | | * @param event_log A #LinphoneEventLog object. @notnil |
|---|
| | | * @return The local #LinphoneAddress. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress *linphone_event_log_get_local_address (const LinphoneEventLog *event_log); |
|---|
| | | |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the notify id of a conference notified event. |
|---|
| | | * @param[in] event_log A #LinphoneEventLog object. |
|---|
| | | * @param event_log A #LinphoneEventLog object. @notnil |
|---|
| | | * @return The conference notify id. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC unsigned int linphone_event_log_get_notify_id (const LinphoneEventLog *event_log); |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the call of a conference call event. |
|---|
| | | * @param[in] event_log A #LinphoneEventLog object. |
|---|
| | | * @return The conference call. |
|---|
| | | * @param event_log A #LinphoneEventLog object. @notnil |
|---|
| | | * @return The conference #LinphoneCall. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneCall *linphone_event_log_get_call (const LinphoneEventLog *event_log); |
|---|
| | | |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the chat message of a conference chat message event. |
|---|
| | | * @param[in] event_log A #LinphoneEventLog object. |
|---|
| | | * @return The conference chat message. |
|---|
| | | * @param event_log A #LinphoneEventLog object. @notnil |
|---|
| | | * @return The conference #LinphoneChatMessage. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatMessage *linphone_event_log_get_chat_message (const LinphoneEventLog *event_log); |
|---|
| | | |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the participant address of a conference participant event. |
|---|
| | | * @param[in] event_log A ConferenceParticipantEvent object. |
|---|
| | | * @return The conference participant address. |
|---|
| | | * @param event_log A ConferenceParticipantEvent object. @notnil |
|---|
| | | * @return The conference participant #LinphoneAddress. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress *linphone_event_log_get_participant_address (const LinphoneEventLog *event_log); |
|---|
| | | |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the device address of a conference participant device event. |
|---|
| | | * @param[in] event_log A #LinphoneEventLog object. |
|---|
| | | * @return The conference device address. |
|---|
| | | * @param event_log A #LinphoneEventLog object. @notnil |
|---|
| | | * @return The conference device #LinphoneAddress. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress *linphone_event_log_get_device_address (const LinphoneEventLog *event_log); |
|---|
| | | |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the type of security event. |
|---|
| | | * @param[in] event_log A #LinphoneEventLog object. |
|---|
| | | * @return The security event type. |
|---|
| | | * @param event_log A #LinphoneEventLog object. @notnil |
|---|
| | | * @return The #LinphoneSecurityEventType type. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneSecurityEventType linphone_event_log_get_security_event_type (const LinphoneEventLog *event_log); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the faulty device address of a conference security event. |
|---|
| | | * @param[in] event_log A #LinphoneEventLog object. |
|---|
| | | * @return The address of the faulty device. |
|---|
| | | * @param event_log A #LinphoneEventLog object. @notnil |
|---|
| | | * @return The #LinphoneAddress of the faulty device. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneAddress *linphone_event_log_get_security_event_faulty_device_address (const LinphoneEventLog *event_log); |
|---|
| | | |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the subject of a conference subject event. |
|---|
| | | * @param[in] event_log A #LinphoneEventLog object. |
|---|
| | | * @return The conference subject. |
|---|
| | | * @param event_log A #LinphoneEventLog object. @notnil |
|---|
| | | * @return The conference subject. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_event_log_get_subject (const LinphoneEventLog *event_log); |
|---|
| | | |
|---|
| | | // ----------------------------------------------------------------------------- |
|---|
| | | // ConferenceEphemeralMessageEvent. |
|---|
| | | // ----------------------------------------------------------------------------- |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the ephemeral message lifetime of a conference ephemeral message event. |
|---|
| | | * Ephemeral lifetime means the time before an ephemeral message which has been viewed gets deleted. |
|---|
| | | * @param event_log A #LinphoneEventLog object. @notnil |
|---|
| | | * @return The ephemeral message lifetime. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC long linphone_event_log_get_ephemeral_message_lifetime (const LinphoneEventLog *event_log); |
|---|
| | | /** |
|---|
| | | * @} |
|---|
| | | */ |
|---|
| New file |
| | |
|---|
| | | /* |
|---|
| | | * Copyright (c) 2010-2019 Belledonne Communications SARL. |
|---|
| | | * |
|---|
| | | * This file is part of Liblinphone. |
|---|
| | | * |
|---|
| | | * 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 3 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, see <http://www.gnu.org/licenses/>. |
|---|
| | | */ |
|---|
| | | |
|---|
| | | #ifndef LINPHONE_FACTORY_H |
|---|
| | | #define LINPHONE_FACTORY_H |
|---|
| | | |
|---|
| | | #include "linphone/api/c-types.h" |
|---|
| | | #include "linphone/types.h" |
|---|
| | | #include "linphone/logging.h" |
|---|
| | | |
|---|
| | | #ifdef __cplusplus |
|---|
| | | extern "C" { |
|---|
| | | #endif |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @addtogroup initializing |
|---|
| | | * @{ |
|---|
| | | */ |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Create the #LinphoneFactory if that has not been done and return a pointer on it. |
|---|
| | | * @return A pointer on the #LinphoneFactory @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneFactory *linphone_factory_get(void); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Clean the factory. This function is generally useless as the factory is unique per process, however |
|---|
| | | * calling this function at the end avoid getting reports from belle-sip leak detector about memory leaked in linphone_factory_get(). |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_factory_clean(void); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Instantiate a #LinphoneCore object. |
|---|
| | | * |
|---|
| | | * The #LinphoneCore object is the primary handle for doing all phone actions. It should be unique within your |
|---|
| | | * application. |
|---|
| | | * The #LinphoneCore object is not started automatically, you need to call linphone_core_start() to that effect. |
|---|
| | | * The returned #LinphoneCore will be in #LinphoneGlobalState Ready. |
|---|
| | | * Core ressources can be released using linphone_core_stop() which is strongly encouraged on garbage collected languages. |
|---|
| | | * @param factory The #LinphoneFactory singleton. @notnil |
|---|
| | | * @param config_path A path to a config file. If it does not exists it will be created. The config file is used to |
|---|
| | | * store all settings, proxies... so that all these settings become persistent over the life of the #LinphoneCore object. |
|---|
| | | * It is allowed to set a NULL config file. In that case #LinphoneCore will not store any settings. @maybenil |
|---|
| | | * @param factory_config_path A path to a read-only config file that can be used to store hard-coded preferences |
|---|
| | | * such as proxy settings or internal preferences. The settings in this factory file always override the ones in the |
|---|
| | | * normal config file. It is optional, use NULL if unneeded. @maybenil |
|---|
| | | * @param system_context A pointer to a system object required by the core to operate. Currently it is required to |
|---|
| | | * pass an android Context on android, pass NULL on other platforms. @maybenil |
|---|
| | | * @return a #LinphoneCore object @notnil |
|---|
| | | * @see linphone_core_new_with_config_3() |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneCore *linphone_factory_create_core_3 ( |
|---|
| | | const LinphoneFactory *factory, |
|---|
| | | const char *config_path, |
|---|
| | | const char *factory_config_path, |
|---|
| | | void *system_context |
|---|
| | | ); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Instantiate a shared #LinphoneCore object. |
|---|
| | | * |
|---|
| | | * The shared #LinphoneCore allow you to create several #LinphoneCore with the same config. |
|---|
| | | * Two #LinphoneCore can't run at the same time. |
|---|
| | | * |
|---|
| | | * A shared #LinphoneCore can be a "Main Core" or an "Executor Core". |
|---|
| | | * A "Main Core" automatically stops a running "Executor Core" when calling linphone_core_start() |
|---|
| | | * An "Executor Core" can't start unless no other #LinphoneCore is started. It can be stopped by a "Main Core" and |
|---|
| | | * switch to #LinphoneGlobalState Off at any time. |
|---|
| | | * |
|---|
| | | * Shared Executor Core are used in iOS UNNotificationServiceExtension to receive new messages from push notifications. |
|---|
| | | * When the application is in background, its Shared Main Core is stopped. |
|---|
| | | * |
|---|
| | | * The #LinphoneCore object is not started automatically, you need to call linphone_core_start() to that effect. |
|---|
| | | * The returned #LinphoneCore will be in #LinphoneGlobalState Ready. |
|---|
| | | * Core ressources can be released using linphone_core_stop() which is strongly encouraged on garbage collected languages. |
|---|
| | | * @param factory The #LinphoneFactory singleton. @notnil |
|---|
| | | * @param config_filename The name of the config file. If it does not exists it will be created. |
|---|
| | | * Its path is computed using the app_group_id. The config file is used to |
|---|
| | | * store all settings, proxies... so that all these settings become persistent over the life of the #LinphoneCore object. |
|---|
| | | * It is allowed to set a NULL config file. In that case #LinphoneCore will not store any settings. @maybenil |
|---|
| | | * @param factory_config_path A path to a read-only config file that can be used to store hard-coded preferences |
|---|
| | | * such as proxy settings or internal preferences. The settings in this factory file always override the ones in the |
|---|
| | | * normal config file. It is optional, use NULL if unneeded. @maybenil |
|---|
| | | * @param system_context A pointer to a system object required by the core to operate. Currently it is required to |
|---|
| | | * pass an android Context on android, pass NULL on other platforms. @maybenil |
|---|
| | | * @param app_group_id Name of iOS App Group that lead to the file system that is shared between an app and its app extensions. @notnil |
|---|
| | | * @param main_core Indicate if we want to create a "Main Core" or an "Executor Core". |
|---|
| | | * @return a #LinphoneCore object @notnil |
|---|
| | | * @see linphone_factory_create_shared_core_with_config() |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneCore *linphone_factory_create_shared_core ( |
|---|
| | | const LinphoneFactory *factory, |
|---|
| | | const char *config_filename, |
|---|
| | | const char *factory_config_path, |
|---|
| | | void *system_context, |
|---|
| | | const char *app_group_id, |
|---|
| | | bool_t main_core |
|---|
| | | ); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Instantiate a #LinphoneCore object with a given LinphoneConfig. |
|---|
| | | * |
|---|
| | | * The #LinphoneCore object is the primary handle for doing all phone actions. It should be unique within your |
|---|
| | | * application. |
|---|
| | | * The #LinphoneCore object is not started automatically, you need to call linphone_core_start() to that effect. |
|---|
| | | * The returned #LinphoneCore will be in #LinphoneGlobalState Ready. |
|---|
| | | * Core ressources can be released using linphone_core_stop() which is strongly encouraged on garbage collected languages. |
|---|
| | | * @param factory The #LinphoneFactory singleton. @notnil |
|---|
| | | * @param config A #LinphoneConfig object holding the configuration for the #LinphoneCore to be instantiated. @notnil |
|---|
| | | * @param system_context A pointer to a system object required by the core to operate. Currently it is required to |
|---|
| | | * pass an android Context on android, pass NULL on other platforms. @maybenil |
|---|
| | | * @return a #LinphoneCore object @notnil |
|---|
| | | * @see linphone_factory_create_core_3() |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneCore *linphone_factory_create_core_with_config_3 ( |
|---|
| | | const LinphoneFactory *factory, |
|---|
| | | LinphoneConfig *config, |
|---|
| | | void *system_context |
|---|
| | | ); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Instantiate a shared #LinphoneCore object. |
|---|
| | | * |
|---|
| | | * The shared #LinphoneCore allow you to create several #LinphoneCore with the same config. |
|---|
| | | * Two #LinphoneCore can't run at the same time. |
|---|
| | | * |
|---|
| | | * A shared #LinphoneCore can be a "Main Core" or an "Executor Core". |
|---|
| | | * A "Main Core" automatically stops a running "Executor Core" when calling linphone_core_start() |
|---|
| | | * An "Executor Core" can't start unless no other #LinphoneCore is started. It can be stopped by a "Main Core" and |
|---|
| | | * switch to #LinphoneGlobalState Off at any time. |
|---|
| | | * |
|---|
| | | * Shared Executor Core are used in iOS UNNotificationServiceExtension to receive new messages from push notifications. |
|---|
| | | * When the application is in background, its Shared Main Core is stopped. |
|---|
| | | * |
|---|
| | | * The #LinphoneCore object is not started automatically, you need to call linphone_core_start() to that effect. |
|---|
| | | * The returned #LinphoneCore will be in #LinphoneGlobalState Ready. |
|---|
| | | * Core ressources can be released using linphone_core_stop() which is strongly encouraged on garbage collected languages. |
|---|
| | | * @param factory The #LinphoneFactory singleton. @notnil |
|---|
| | | * @param config A #LinphoneConfig object holding the configuration for the #LinphoneCore to be instantiated. @notnil |
|---|
| | | * @param system_context A pointer to a system object required by the core to operate. Currently it is required to |
|---|
| | | * pass an android Context on android, pass NULL on other platforms. @maybenil |
|---|
| | | * @param app_group_id Name of iOS App Group that lead to the file system that is shared between an app and its app extensions. @notnil |
|---|
| | | * @param main_core Indicate if we want to create a "Main Core" or an "Executor Core". |
|---|
| | | * @return a #LinphoneCore object @notnil |
|---|
| | | * @see linphone_factory_create_shared_core() |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneCore *linphone_factory_create_shared_core_with_config ( |
|---|
| | | const LinphoneFactory *factory, |
|---|
| | | LinphoneConfig *config, |
|---|
| | | void *system_context, |
|---|
| | | const char *app_group_id, |
|---|
| | | bool_t main_core |
|---|
| | | ); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Instanciate a #LinphoneCoreCbs object. |
|---|
| | | * @param factory The #LinphoneFactory singleton. @notnil |
|---|
| | | * @return a new #LinphoneCoreCbs. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneCoreCbs *linphone_factory_create_core_cbs(const LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Parse a string holding a SIP URI and create the according #LinphoneAddress object. |
|---|
| | | * @param factory The #LinphoneFactory singleton. @notnil |
|---|
| | | * @param addr A string holding the SIP URI to parse. @notnil |
|---|
| | | * @return A new #LinphoneAddress. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneAddress *linphone_factory_create_address(const LinphoneFactory *factory, const char *addr); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Create a #LinphoneParticipantDeviceIdentity object. |
|---|
| | | * @param factory The #LinphoneFactory singleton. @notnil |
|---|
| | | * @param address #LinphoneAddress object. @notnil |
|---|
| | | * @param name the name given to the device. @maybenil |
|---|
| | | * @return A new #LinphoneParticipantDeviceIdentity. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneParticipantDeviceIdentity *linphone_factory_create_participant_device_identity( |
|---|
| | | const LinphoneFactory *factory, |
|---|
| | | const LinphoneAddress *address, |
|---|
| | | const char *name |
|---|
| | | ); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates a #LinphoneAuthInfo object. |
|---|
| | | * The object can be created empty, that is with all arguments set to NULL. |
|---|
| | | * Username, userid, password, realm and domain can be set later using specific methods. |
|---|
| | | * At the end, username and passwd (or ha1) are required. |
|---|
| | | * @param factory The #LinphoneFactory singleton. @notnil |
|---|
| | | * @param username The username that needs to be authenticated @notnil |
|---|
| | | * @param userid The userid used for authenticating (use NULL if you don't know what it is) @maybenil |
|---|
| | | * @param passwd The password in clear text @maybenil |
|---|
| | | * @param ha1 The ha1-encrypted password if password is not given in clear text. @maybenil |
|---|
| | | * @param realm The authentication domain (which can be larger than the sip domain. Unfortunately many SIP servers don't use this parameter. @maybenil |
|---|
| | | * @param domain The SIP domain for which this authentication information is valid, if it has to be restricted for a single SIP domain. @maybenil |
|---|
| | | * @return A #LinphoneAuthInfo object. linphone_auth_info_destroy() must be used to destroy it when no longer needed. The #LinphoneCore makes a copy of #LinphoneAuthInfo |
|---|
| | | * passed through linphone_core_add_auth_info(). @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneAuthInfo *linphone_factory_create_auth_info(const LinphoneFactory *factory, const char *username, const char *userid, const char *passwd, const char *ha1, const char *realm, const char *domain); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates a #LinphoneAuthInfo object. |
|---|
| | | * The object can be created empty, that is with all arguments set to NULL. |
|---|
| | | * Username, userid, password, realm and domain can be set later using specific methods. |
|---|
| | | * At the end, username and passwd (or ha1) are required. |
|---|
| | | * @param factory The #LinphoneFactory singleton. @notnil |
|---|
| | | * @param username The username that needs to be authenticated @notnil |
|---|
| | | * @param userid The userid used for authenticating (use NULL if you don't know what it is) @maybenil |
|---|
| | | * @param passwd The password in clear text @maybenil |
|---|
| | | * @param ha1 The ha1-encrypted password if password is not given in clear text. @maybenil |
|---|
| | | * @param realm The authentication domain (which can be larger than the sip domain. Unfortunately many SIP servers don't use this parameter. @maybenil |
|---|
| | | * @param domain The SIP domain for which this authentication information is valid, if it has to be restricted for a single SIP domain. @maybenil |
|---|
| | | * @param algorithm The algorithm for encrypting password. @maybenil |
|---|
| | | * @return A #LinphoneAuthInfo object. linphone_auth_info_destroy() must be used to destroy it when no longer needed. The #LinphoneCore makes a copy of #LinphoneAuthInfo |
|---|
| | | * passed through linphone_core_add_auth_info(). @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneAuthInfo *linphone_factory_create_auth_info_2(const LinphoneFactory *factory, const char *username, const char *userid, const char *passwd, const char *ha1, const char *realm, const char *domain, const char *algorithm); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Create a #LinphoneCallCbs object that holds callbacks for events happening on a call. |
|---|
| | | * @param factory #LinphoneFactory singletion object @notnil |
|---|
| | | * @return A new #LinphoneCallCbs object @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneCallCbs * linphone_factory_create_call_cbs(const LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Create a #LinphoneConferenceCbs object that holds callbacks for events happening on a conference. |
|---|
| | | * @param[in] factory #LinphoneFactory singletion object @notnil |
|---|
| | | * @return A new #LinphoneConferenceCbs object @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneConferenceCbs * linphone_factory_create_conference_cbs(const LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Create a LinphoneChatRoomCbs object that holds callbacks for events happening on a chat room. |
|---|
| | | * @param factory #LinphoneFactory singletion object @notnil |
|---|
| | | * @return A new #LinphoneChatRoomCbs object @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoomCbs * linphone_factory_create_chat_room_cbs(const LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Create a LinphoneChatMessageCbs object that holds callbacks for events happening on a chat message. |
|---|
| | | * @param factory #LinphoneFactory singletion object @notnil |
|---|
| | | * @return A new #LinphoneChatMessageCbs object @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatMessageCbs * linphone_factory_create_chat_message_cbs(const LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Create an empty #LinphoneVcard. |
|---|
| | | * @param factory #LinphoneFactory singletion object @notnil |
|---|
| | | * @return a new #LinphoneVcard. @notnil |
|---|
| | | * @ingroup initializing |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneVcard *linphone_factory_create_vcard(LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Create a #LinphoneVideoDefinition from a given width and height |
|---|
| | | * @param factory #LinphoneFactory singleton object @notnil |
|---|
| | | * @param width The width of the created video definition |
|---|
| | | * @param height The height of the created video definition |
|---|
| | | * @return A new #LinphoneVideoDefinition object @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneVideoDefinition * linphone_factory_create_video_definition(const LinphoneFactory *factory, unsigned int width, unsigned int height); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Create a #LinphoneVideoDefinition from a given standard definition name |
|---|
| | | * @param factory #LinphoneFactory singleton object @notnil |
|---|
| | | * @param name The standard definition name of the video definition to create @notnil |
|---|
| | | * @return A new #LinphoneVideoDefinition object @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneVideoDefinition * linphone_factory_create_video_definition_from_name(const LinphoneFactory *factory, const char *name); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the list of standard video definitions supported by Linphone. |
|---|
| | | * @param factory #LinphoneFactory singleton object @notnil |
|---|
| | | * @return A list of video definitions. \bctbx_list{LinphoneVideoDefinition} @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const bctbx_list_t * linphone_factory_get_supported_video_definitions(const LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the top directory where the resources are located. |
|---|
| | | * @param factory #LinphoneFactory object @notnil |
|---|
| | | * @return The path to the top directory where the resources are located @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_factory_get_top_resources_dir(const LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the top directory where the resources are located. |
|---|
| | | * If you only define this top directory, the other resources directory will automatically be derived form this one. |
|---|
| | | * @param factory #LinphoneFactory object @notnil |
|---|
| | | * @param path The path to the top directory where the resources are located @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_factory_set_top_resources_dir(LinphoneFactory *factory, const char *path); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the directory where the data resources are located. |
|---|
| | | * @param factory #LinphoneFactory object @notnil |
|---|
| | | * @return The path to the directory where the data resources are located @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_factory_get_data_resources_dir(LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the directory where the data resources are located. |
|---|
| | | * @param factory #LinphoneFactory object @notnil |
|---|
| | | * @param path The path where the data resources are located @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_factory_set_data_resources_dir(LinphoneFactory *factory, const char *path); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the directory where the sound resources are located. |
|---|
| | | * @param factory #LinphoneFactory object @notnil |
|---|
| | | * @return The path to the directory where the sound resources are located @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_factory_get_sound_resources_dir(LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the directory where the sound resources are located. |
|---|
| | | * @param factory #LinphoneFactory object @notnil |
|---|
| | | * @param path The path where the sound resources are located @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_factory_set_sound_resources_dir(LinphoneFactory *factory, const char *path); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the directory where the ring resources are located. |
|---|
| | | * @param factory #LinphoneFactory object @notnil |
|---|
| | | * @return The path to the directory where the ring resources are located @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_factory_get_ring_resources_dir(LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the directory where the ring resources are located. |
|---|
| | | * @param factory #LinphoneFactory object @notnil |
|---|
| | | * @param path The path where the ring resources are located @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_factory_set_ring_resources_dir(LinphoneFactory *factory, const char *path); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the directory where the image resources are located. |
|---|
| | | * @param factory #LinphoneFactory object @notnil |
|---|
| | | * @return The path to the directory where the image resources are located @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_factory_get_image_resources_dir(LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the directory where the image resources are located. |
|---|
| | | * @param factory #LinphoneFactory object @notnil |
|---|
| | | * @param path The path where the image resources are located @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_factory_set_image_resources_dir(LinphoneFactory *factory, const char *path); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the directory where the mediastreamer2 plugins are located. |
|---|
| | | * @param factory #LinphoneFactory object @notnil |
|---|
| | | * @return The path to the directory where the mediastreamer2 plugins are located, or NULL if it has not been set. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_factory_get_msplugins_dir(LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the directory where the mediastreamer2 plugins are located. |
|---|
| | | * @param factory #LinphoneFactory object @notnil |
|---|
| | | * @param path The path to the directory where the mediastreamer2 plugins are located @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_factory_set_msplugins_dir(LinphoneFactory *factory, const char *path); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates an object LinphoneErrorInfo. |
|---|
| | | * @param factory #LinphoneFactory object @notnil |
|---|
| | | * @return a #LinphoneErrorInfo object. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneErrorInfo *linphone_factory_create_error_info(LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates an object LinphoneRange. |
|---|
| | | * @param factory #LinphoneFactory object @notnil |
|---|
| | | * @return a #LinphoneRange object. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneRange *linphone_factory_create_range(LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates an object LinphoneTransports. |
|---|
| | | * @param factory #LinphoneFactory object @notnil |
|---|
| | | * @return a #LinphoneTransports object. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneTransports *linphone_factory_create_transports(LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates an object LinphoneVideoActivationPolicy. |
|---|
| | | * @param factory #LinphoneFactory object @notnil |
|---|
| | | * @return #LinphoneVideoActivationPolicy object. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneVideoActivationPolicy *linphone_factory_create_video_activation_policy(LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns a bctbx_list_t of all DialPlans |
|---|
| | | * @param factory the #LinphoneFactory object @notnil |
|---|
| | | * @return A list of #LinphoneDialPlan \bctbx_list{LinphoneDialPlan} @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const bctbx_list_t * linphone_factory_get_dial_plans(const LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates an object #LinphoneContent |
|---|
| | | * @param factory the #LinphoneFactory @notnil |
|---|
| | | * @return a #LinphoneContent @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneContent *linphone_factory_create_content(LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates an object #LinphoneBuffer |
|---|
| | | * @param factory the #LinphoneFactory @notnil |
|---|
| | | * @return a #LinphoneBuffer @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneBuffer *linphone_factory_create_buffer(LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates an object #LinphoneBuffer |
|---|
| | | * @param factory the #LinphoneFactory @notnil |
|---|
| | | * @param data the data to set in the buffer @notnil |
|---|
| | | * @param size the size of the data |
|---|
| | | * @return a #LinphoneBuffer @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneBuffer *linphone_factory_create_buffer_from_data(LinphoneFactory *factory, const uint8_t *data, size_t size); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates an object #LinphoneBuffer |
|---|
| | | * @param factory the #LinphoneFactory @notnil |
|---|
| | | * @param data the data to set in the buffer @notnil |
|---|
| | | * @return a #LinphoneBuffer @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneBuffer *linphone_factory_create_buffer_from_string(LinphoneFactory *factory, const char *data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates an object #LinphoneConfig |
|---|
| | | * @param factory the #LinphoneFactory @notnil |
|---|
| | | * @param path the path of the config @maybenil |
|---|
| | | * @return a #LinphoneConfig @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneConfig *linphone_factory_create_config(LinphoneFactory *factory, const char *path); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates an object #LinphoneConfig |
|---|
| | | * @param factory the #LinphoneFactory @notnil |
|---|
| | | * @param path the path of the config @maybenil |
|---|
| | | * @param factory_path the path of the factory @maybenil |
|---|
| | | * @return a #LinphoneConfig @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneConfig *linphone_factory_create_config_with_factory(LinphoneFactory *factory, const char *path, const char *factory_path); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates an object #LinphoneConfig |
|---|
| | | * @param factory the #LinphoneFactory @notnil |
|---|
| | | * @param data the config data @notnil |
|---|
| | | * @return a #LinphoneConfig @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneConfig *linphone_factory_create_config_from_string(LinphoneFactory *factory, const char *data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the user data in the #LinphoneFactory object |
|---|
| | | * @param factory the #LinphoneFactory @notnil |
|---|
| | | * @return the user data. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void *linphone_factory_get_user_data(const LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the user data in the #LinphoneFactory object |
|---|
| | | * @param factory the #LinphoneFactory object @notnil |
|---|
| | | * @param data the user data. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_factory_set_user_data(LinphoneFactory *factory, void *data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the log collection path |
|---|
| | | * @param factory the #LinphoneFactory @notnil |
|---|
| | | * @param path the path of the logs @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_factory_set_log_collection_path(LinphoneFactory *factory, const char *path); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Enables or disables log collection |
|---|
| | | * @param factory the #LinphoneFactory @notnil |
|---|
| | | * @param state the #LinphoneLogCollectionState for log collection |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_factory_enable_log_collection(LinphoneFactory *factory, LinphoneLogCollectionState state); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates an object #LinphoneTunnelConfig |
|---|
| | | * @param factory the #LinphoneFactory @notnil |
|---|
| | | * @return a #LinphoneTunnelConfig @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneTunnelConfig *linphone_factory_create_tunnel_config(LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates an object #LinphoneLoggingServiceCbs |
|---|
| | | * @param factory the #LinphoneFactory @notnil |
|---|
| | | * @return a #LinphoneLoggingServiceCbs @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneLoggingServiceCbs *linphone_factory_create_logging_service_cbs(LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates an object #LinphonePlayerCbs |
|---|
| | | * @param factory the #LinphoneFactory @notnil |
|---|
| | | * @return a #LinphonePlayerCbs @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphonePlayerCbs *linphone_factory_create_player_cbs(LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates an object #LinphoneEventCbs |
|---|
| | | * @param factory the #LinphoneFactory @notnil |
|---|
| | | * @return a #LinphoneEventCbs @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneEventCbs *linphone_factory_create_event_cbs(LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates an object #LinphoneFriendListCbs |
|---|
| | | * @param factory the #LinphoneFactory @notnil |
|---|
| | | * @return a #LinphoneFriendListCbs @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneFriendListCbs *linphone_factory_create_friend_list_cbs(LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates an object #LinphoneAccountCreatorCbs |
|---|
| | | * @param factory the #LinphoneFactory @notnil |
|---|
| | | * @return a #LinphoneAccountCreatorCbs @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneAccountCreatorCbs *linphone_factory_create_account_creator_cbs(LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates an object #LinphoneXmlRpcRequestCbs |
|---|
| | | * @param factory the #LinphoneFactory @notnil |
|---|
| | | * @return a #LinphoneXmlRpcRequestCbs @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneXmlRpcRequestCbs *linphone_factory_create_xml_rpc_request_cbs(LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Indicates if the given LinphoneChatRoomBackend is available |
|---|
| | | * @param factory the #LinphoneFactory @notnil |
|---|
| | | * @param chatroom_backend the #LinphoneChatRoomBackend |
|---|
| | | * @return TRUE if the chatroom backend is available, FALSE otherwise |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_factory_is_chatroom_backend_available(LinphoneFactory *factory, LinphoneChatRoomBackend chatroom_backend); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Indicates if the storage in database is available |
|---|
| | | * @param factory the #LinphoneFactory @notnil |
|---|
| | | * @return TRUE if the database storage is available, FALSE otherwise |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_factory_is_database_storage_available(LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Indicates if IMDN are available |
|---|
| | | * @param factory the #LinphoneFactory @notnil |
|---|
| | | * @return TRUE if IDMN are available |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_factory_is_imdn_available(LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the config path |
|---|
| | | * @param factory the #LinphoneFactory @notnil |
|---|
| | | * @param context used to compute path. Can be NULL. JavaPlatformHelper on Android and char *appGroupId on iOS with shared core. @maybenil |
|---|
| | | * @return The config path @notnil |
|---|
| | | * @ingroup misc |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_factory_get_config_dir(LinphoneFactory *factory, void *context); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the data path |
|---|
| | | * @param factory the #LinphoneFactory @notnil |
|---|
| | | * @param context used to compute path. Can be NULL. JavaPlatformHelper on Android and char *appGroupId on iOS with shared core. @maybenil |
|---|
| | | * @return The data path @notnil |
|---|
| | | * @ingroup misc |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_factory_get_data_dir(LinphoneFactory *factory, void *context); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the download path |
|---|
| | | * @param factory the #LinphoneFactory @notnil |
|---|
| | | * @param context used to compute path. Can be NULL. JavaPlatformHelper on Android and char *appGroupId on iOS with shared core. @maybenil |
|---|
| | | * @return The download path @notnil |
|---|
| | | * @ingroup misc |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_factory_get_download_dir(LinphoneFactory *factory, void *context); |
|---|
| | | |
|---|
| | | /************ */ |
|---|
| | | /* DEPRECATED */ |
|---|
| | | /* ********** */ |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Instanciate a #LinphoneCore object. |
|---|
| | | * |
|---|
| | | * The #LinphoneCore object is the primary handle for doing all phone actions. |
|---|
| | | * It should be unique within your application. |
|---|
| | | * @param factory The #LinphoneFactory singleton. |
|---|
| | | * @param cbs a #LinphoneCoreCbs object holding your application callbacks. A reference |
|---|
| | | * will be taken on it until the destruciton of the core or the unregistration |
|---|
| | | * with linphone_core_remove_cbs(). |
|---|
| | | * @param config_path a path to a config file. If it does not exists it will be created. |
|---|
| | | * The config file is used to store all settings, call logs, friends, proxies... so that all these settings |
|---|
| | | * become persistent over the life of the LinphoneCore object. |
|---|
| | | * It is allowed to set a NULL config file. In that case LinphoneCore will not store any settings. |
|---|
| | | * @param factory_config_path a path to a read-only config file that can be used to |
|---|
| | | * to store hard-coded preference such as proxy settings or internal preferences. |
|---|
| | | * The settings in this factory file always override the one in the normal config file. |
|---|
| | | * It is OPTIONAL, use NULL if unneeded. |
|---|
| | | * @see linphone_core_new_with_config() |
|---|
| | | * @deprecated 2018-01-10: Use linphone_factory_create_core_3() instead |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | LINPHONE_DEPRECATED LINPHONE_PUBLIC LinphoneCore *linphone_factory_create_core( |
|---|
| | | const LinphoneFactory *factory, |
|---|
| | | LinphoneCoreCbs *cbs, |
|---|
| | | const char *config_path, |
|---|
| | | const char *factory_config_path |
|---|
| | | ); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Instanciate a #LinphoneCore object. |
|---|
| | | * |
|---|
| | | * The #LinphoneCore object is the primary handle for doing all phone actions. |
|---|
| | | * It should be unique within your application. |
|---|
| | | * @param factory The #LinphoneFactory singleton. |
|---|
| | | * @param cbs a #LinphoneCoreCbs object holding your application callbacks. A reference |
|---|
| | | * will be taken on it until the destruciton of the core or the unregistration |
|---|
| | | * with linphone_core_remove_cbs(). |
|---|
| | | * @param config_path a path to a config file. If it does not exists it will be created. |
|---|
| | | * The config file is used to store all settings, call logs, friends, proxies... so that all these settings |
|---|
| | | * become persistent over the life of the LinphoneCore object. |
|---|
| | | * It is allowed to set a NULL config file. In that case LinphoneCore will not store any settings. |
|---|
| | | * @param factory_config_path a path to a read-only config file that can be used to |
|---|
| | | * to store hard-coded preference such as proxy settings or internal preferences. |
|---|
| | | * The settings in this factory file always override the one in the normal config file. |
|---|
| | | * It is OPTIONAL, use NULL if unneeded. |
|---|
| | | * @param user_data an application pointer associated with the returned core. |
|---|
| | | * @param system_context a pointer to a system object required by the core to operate. Currently it is required to pass an android Context on android, pass NULL on other platforms. |
|---|
| | | * @see linphone_core_new_with_config() |
|---|
| | | * @deprecated 2018-01-10: Use linphone_factory_create_core_3() instead |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | LINPHONE_DEPRECATED LINPHONE_PUBLIC LinphoneCore *linphone_factory_create_core_2 ( |
|---|
| | | const LinphoneFactory *factory, |
|---|
| | | LinphoneCoreCbs *cbs, |
|---|
| | | const char *config_path, |
|---|
| | | const char *factory_config_path, |
|---|
| | | void *user_data, |
|---|
| | | void *system_context |
|---|
| | | ); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Instantiates a #LinphoneCore object with a given LpConfig. |
|---|
| | | * |
|---|
| | | * @param factory The #LinphoneFactory singleton. |
|---|
| | | * The #LinphoneCore object is the primary handle for doing all phone actions. |
|---|
| | | * It should be unique within your application. |
|---|
| | | * @param cbs a #LinphoneCoreCbs object holding your application callbacks. A reference |
|---|
| | | * will be taken on it until the destruciton of the core or the unregistration |
|---|
| | | * with linphone_core_remove_cbs(). |
|---|
| | | * @param config a pointer to an LpConfig object holding the configuration of the #LinphoneCore to be instantiated. |
|---|
| | | * @see linphone_core_new() |
|---|
| | | * @deprecated 2018-01-10: Use linphone_factory_create_core_with_config_3() instead |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | LINPHONE_DEPRECATED LINPHONE_PUBLIC LinphoneCore *linphone_factory_create_core_with_config ( |
|---|
| | | const LinphoneFactory *factory, |
|---|
| | | LinphoneCoreCbs *cbs, |
|---|
| | | LinphoneConfig *config |
|---|
| | | ); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Instantiates a #LinphoneCore object with a given LpConfig. |
|---|
| | | * |
|---|
| | | * @param factory The #LinphoneFactory singleton. |
|---|
| | | * The #LinphoneCore object is the primary handle for doing all phone actions. |
|---|
| | | * It should be unique within your application. |
|---|
| | | * @param cbs a #LinphoneCoreCbs object holding your application callbacks. A reference |
|---|
| | | * will be taken on it until the destruciton of the core or the unregistration |
|---|
| | | * with linphone_core_remove_cbs(). |
|---|
| | | * @param config a pointer to an LpConfig object holding the configuration of the #LinphoneCore to be instantiated. |
|---|
| | | * @param user_data an application pointer associated with the returned core. |
|---|
| | | * @param system_context a pointer to a system object required by the core to operate. Currently it is required to pass an android Context on android, pass NULL on other platforms. |
|---|
| | | * @see linphone_core_new() |
|---|
| | | * @deprecated 2018-01-10: Use linphone_factory_create_core_with_config_3() instead |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | LINPHONE_DEPRECATED LINPHONE_PUBLIC LinphoneCore *linphone_factory_create_core_with_config_2 ( |
|---|
| | | const LinphoneFactory *factory, |
|---|
| | | LinphoneCoreCbs *cbs, |
|---|
| | | LinphoneConfig *config, |
|---|
| | | void *user_data, |
|---|
| | | void *system_context |
|---|
| | | ); |
|---|
| | | |
|---|
| | | #define LINPHONE_VFS_ENCRYPTION_PLAIN 0xFFFF |
|---|
| | | #define LINPHONE_VFS_ENCRYPTION_UNSET 0x0000 |
|---|
| | | #define LINPHONE_VFS_ENCRYPTION_DUMMY 0x0001 |
|---|
| | | #define LINPHONE_VFS_ENCRYPTION_AES256GCM128_SHA256 0x0002 |
|---|
| | | /** |
|---|
| | | * Select encryption module and set secret material to encrypt the files |
|---|
| | | * @param[in] factory the #LinphoneFactory @notnil |
|---|
| | | * @param[in] encryptionModule One of the available encryption module for VFS, pick in the LINPHONE_VFS_ENCRYPTION_* list |
|---|
| | | * if set to _UNSET, default bctoolbox VFS is switch to Standard one |
|---|
| | | * @param[in] secret the secret material used to encrypt the files, can be NULL for the _PLAIN module @maybenil |
|---|
| | | * @param[in] secretSize size of the secret |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_factory_set_vfs_encryption(LinphoneFactory *factory, const uint16_t encryptionModule, const uint8_t *secret, const size_t secretSize); |
|---|
| | | /** |
|---|
| | | * @} |
|---|
| | | */ |
|---|
| | | |
|---|
| | | #ifdef __cplusplus |
|---|
| | | } |
|---|
| | | #endif |
|---|
| | | |
|---|
| | | |
|---|
| | | #endif // LINPHONE_FACTORY_H |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Constructs a LinphoneMagicSearch object |
|---|
| | | * @param core a #LinphoneCore object @notnil |
|---|
| | | * @return a #LinphoneMagicSearch object @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneMagicSearch *linphone_magic_search_new (LinphoneCore *lc); |
|---|
| | | LINPHONE_PUBLIC LinphoneMagicSearch *linphone_magic_search_new (LinphoneCore *core); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Increment reference count of LinphoneMagicSearch object. |
|---|
| | | * @param magic_search a #LinphoneMagicSearch object @notnil |
|---|
| | | * @return the same #LinphoneMagicSearch object @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneMagicSearch *linphone_magic_search_ref (LinphoneMagicSearch *magic_search); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Decrement reference count of LinphoneMagicSearch object. When dropped to zero, memory is freed. |
|---|
| | | * @param magic_search a #LinphoneMagicSearch object @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_magic_search_unref (LinphoneMagicSearch *magic_search); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the minimum value used to calculate the weight in search |
|---|
| | | * @param[in] weight minimum weight |
|---|
| | | * @param magic_search a #LinphoneMagicSearch object @notnil |
|---|
| | | * @param weight minimum weight |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_magic_search_set_min_weight (LinphoneMagicSearch *magic_search, unsigned int weight); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the minimum value used to calculate the weight in search |
|---|
| | | * @param magic_search a #LinphoneMagicSearch object @notnil |
|---|
| | | * @return the minimum value used to calculate the weight in search |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC unsigned int linphone_magic_search_get_min_weight (const LinphoneMagicSearch *magic_search); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the maximum value used to calculate the weight in search |
|---|
| | | * @param[in] weight maximum weight |
|---|
| | | * @param magic_search a #LinphoneMagicSearch object @notnil |
|---|
| | | * @param weight maximum weight |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_magic_search_set_max_weight (LinphoneMagicSearch *magic_search, unsigned int weight); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the maximum value used to calculate the weight in search |
|---|
| | | * @param magic_search a #LinphoneMagicSearch object @notnil |
|---|
| | | * @return the maximum value used to calculate the weight in search |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC unsigned int linphone_magic_search_get_max_weight (const LinphoneMagicSearch *magic_search); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @return the delimiter used to find matched filter word |
|---|
| | | * Get the delimiter used for the search. |
|---|
| | | * @param magic_search a #LinphoneMagicSearch object @notnil |
|---|
| | | * @return the delimiter used to find matched filter word @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_magic_search_get_delimiter (const LinphoneMagicSearch *magic_search); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the delimiter used to find matched filter word |
|---|
| | | * @param[in] delimiter delimiter (example "-_.,") |
|---|
| | | * @param magic_search a #LinphoneMagicSearch object @notnil |
|---|
| | | * @param delimiter delimiter (example "-_.,") @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_magic_search_set_delimiter (LinphoneMagicSearch *magic_search, const char *delimiter); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns whether the delimiter is being used for the search |
|---|
| | | * @param magic_search a #LinphoneMagicSearch object @notnil |
|---|
| | | * @return if the delimiter search is used |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_magic_search_get_use_delimiter (LinphoneMagicSearch *magic_search); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Enable or disable the delimiter in search |
|---|
| | | * @param[in] enable |
|---|
| | | * @param magic_search a #LinphoneMagicSearch object @notnil |
|---|
| | | * @param enable TRUE to use the delimiter, FALSE otherwise |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_magic_search_set_use_delimiter (LinphoneMagicSearch *magic_search, bool_t enable); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @return the number of the maximum SearchResult which will be return |
|---|
| | | * Get the number of maximum search result the search will return |
|---|
| | | * @param magic_search a #LinphoneMagicSearch object @notnil |
|---|
| | | * @return the number of the maximum #LinphoneSearchResult which will be returned |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC unsigned int linphone_magic_search_get_search_limit (const LinphoneMagicSearch *magic_search); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the number of the maximum SearchResult which will be return |
|---|
| | | * @param[in] limit |
|---|
| | | * Set the number of the maximum SearchResult which will be returned |
|---|
| | | * @param magic_search a #LinphoneMagicSearch object @notnil |
|---|
| | | * @param limit the maximum number of #LinphoneSearchResult the search will return |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_magic_search_set_search_limit (LinphoneMagicSearch *magic_search, unsigned int limit); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @return if the search is limited |
|---|
| | | * Return whether or not the search is limited |
|---|
| | | * @param magic_search a #LinphoneMagicSearch object @notnil |
|---|
| | | * @return TRUE if the search is limited, FALSE otherwise |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_magic_search_get_limited_search (const LinphoneMagicSearch *magic_search); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Enable or disable the limited search |
|---|
| | | * @param[in] limited |
|---|
| | | * @param magic_search a #LinphoneMagicSearch object @notnil |
|---|
| | | * @param limited TRUE to limit the search, FALSE otherwise |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_magic_search_set_limited_search (LinphoneMagicSearch *magic_search, bool_t limited); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Reset the cache to begin a new search |
|---|
| | | * @param magic_search a #LinphoneMagicSearch object @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_magic_search_reset_search_cache (LinphoneMagicSearch *magic_search); |
|---|
| | | |
|---|
| | |
|---|
| | | * The last item list will be an address formed with "filter" if a proxy config exist |
|---|
| | | * During the first search, a cache is created and used for the next search |
|---|
| | | * Use linphone_magic_search_reset_search_cache() to begin a new search |
|---|
| | | * @param[in] filter word we search |
|---|
| | | * @param[in] domain domain which we want to search only |
|---|
| | | * - "" for searching in all contact |
|---|
| | | * @param magic_search a #LinphoneMagicSearch object @notnil |
|---|
| | | * @param filter word we search @maybenil |
|---|
| | | * @param domain domain which we want to search only @maybenil |
|---|
| | | * - NULL or "" for searching in all contact |
|---|
| | | * - "*" for searching in contact with sip SipUri |
|---|
| | | * - "yourdomain" for searching in contact from "yourdomain" domain |
|---|
| | | * @return sorted list of \bctbx_list{LinphoneSearchResult} \onTheFlyList |
|---|
| | | * @return sorted list of \bctbx_list{LinphoneSearchResult} @tobefreed @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC bctbx_list_t *linphone_magic_search_get_contact_list_from_filter ( |
|---|
| | | const LinphoneMagicSearch *magic_search, |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Constructs a #LinphoneParticipantDeviceIdentity object. |
|---|
| | | * @param address a #LinphoneAddress of the participant device @notnil |
|---|
| | | * @param name the name of the participant device @maybenil |
|---|
| | | * @return a new #LinphoneParticipantDeviceIdentity @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneParticipantDeviceIdentity *linphone_participant_device_identity_new (const LinphoneAddress *address, const char *name); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Clones a #LinphoneParticipantDeviceIdentity object. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneParticipantDeviceIdentity *linphone_participant_device_identity_clone (const LinphoneParticipantDeviceIdentity *deviceIdentity); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Increment reference count of #LinphoneParticipantDeviceIdentity object. |
|---|
| | | * @param device_identity the #LinphoneParticipantDeviceIdentity object @notnil |
|---|
| | | * @return the same #LinphoneParticipantDeviceIdentity object @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneParticipantDeviceIdentity *linphone_participant_device_identity_ref (LinphoneParticipantDeviceIdentity *deviceIdentity); |
|---|
| | | LINPHONE_PUBLIC LinphoneParticipantDeviceIdentity *linphone_participant_device_identity_ref (LinphoneParticipantDeviceIdentity *device_identity); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Decrement reference count of #LinphoneParticipantDeviceIdentity object. When dropped to zero, memory is freed. |
|---|
| | | * @param device_identity the #LinphoneParticipantDeviceIdentity object @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_participant_device_identity_unref (LinphoneParticipantDeviceIdentity *deviceIdentity); |
|---|
| | | LINPHONE_PUBLIC void linphone_participant_device_identity_unref (LinphoneParticipantDeviceIdentity *device_identity); |
|---|
| | | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the capability descriptor (currently +org.linphone.specs value) for this participant device identity. |
|---|
| | | * @param device_identity the #LinphoneParticipantDeviceIdentity object @notnil |
|---|
| | | * @param capability_descriptor the capability descriptor string. |
|---|
| | | * |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_participant_device_identity_set_capability_descriptor(LinphoneParticipantDeviceIdentity *device_identity, const char *capability_descriptor); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the capability descriptor (currently +org.linphone.specs value) for this participant device identity. |
|---|
| | | * @param device_identity the #LinphoneParticipantDeviceIdentity object @notnil |
|---|
| | | * @return the capability descriptor string. |
|---|
| | | * |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char* linphone_participant_device_identity_get_capability_descriptor(const LinphoneParticipantDeviceIdentity *device_identity); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the address of the participant device. |
|---|
| | | * @param device_identity the #LinphoneParticipantDeviceIdentity @notnil |
|---|
| | | * @return the address. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress* linphone_participant_device_identity_get_address(const LinphoneParticipantDeviceIdentity *deviceIdentity); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @} |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | #ifndef _L_C_PARTICIPANT_DEVICE_H_ |
|---|
| | | #define _L_C_PARTICIPANT_DEVICE_H_ |
|---|
| | | |
|---|
| | | #include "time.h" |
|---|
| | | |
|---|
| | | #include "linphone/api/c-types.h" |
|---|
| | | |
|---|
| | | // ============================================================================= |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Increment reference count of #LinphoneParticipantDevice object. |
|---|
| | | * @param participant_device the #LinphoneParticipantDevice object @notnil |
|---|
| | | * @return the same #LinphoneParticipantDevice object @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneParticipantDevice *linphone_participant_device_ref (LinphoneParticipantDevice *participant_device); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Decrement reference count of #LinphoneParticipantDevice object. |
|---|
| | | * @param participant_device the #LinphoneParticipantDevice object @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_participant_device_unref (LinphoneParticipantDevice *participant_device); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Retrieve the user pointer associated with the participant's device. |
|---|
| | | * @param[in] participant_device A #LinphoneParticipantDevice object |
|---|
| | | * @return The user pointer associated with the participant's device. |
|---|
| | | * @param participant_device A #LinphoneParticipantDevice object @notnil |
|---|
| | | * @return The user pointer associated with the participant's device. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void * linphone_participant_device_get_user_data(const LinphoneParticipantDevice *participant_device); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user pointer to the participant's device. |
|---|
| | | * @param[in] participant_device A #LinphoneParticipantDevice object |
|---|
| | | * @param[in] ud The user pointer to associate with the participant's device |
|---|
| | | * @param participant_device A #LinphoneParticipantDevice object @notnil |
|---|
| | | * @param user_data The user pointer to associate with the participant's device. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_participant_device_set_user_data(LinphoneParticipantDevice *participant_device, void *ud); |
|---|
| | | LINPHONE_PUBLIC void linphone_participant_device_set_user_data(LinphoneParticipantDevice *participant_device, void *user_data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the address of a participant's device. |
|---|
| | | * @param[in] participant_device A #LinphoneParticipantDevice object |
|---|
| | | * @return The address of the participant's device |
|---|
| | | * @param participant_device A #LinphoneParticipantDevice object @notnil |
|---|
| | | * @return The #LinphoneAddress of the participant's device @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress * linphone_participant_device_get_address (const LinphoneParticipantDevice *participant_device); |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress* linphone_participant_device_get_address (const LinphoneParticipantDevice *participant_device); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the security level of a participant's device. |
|---|
| | | * @param[in] participant_device A #LinphoneParticipantDevice object |
|---|
| | | * @return The security level of the device |
|---|
| | | * @param participant_device A #LinphoneParticipantDevice object @notnil |
|---|
| | | * @return The #LinphoneChatRoomSecurityLevel of the device |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoomSecurityLevel linphone_participant_device_get_security_level (const LinphoneParticipantDevice *participant_device); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Return the name of the device or NULL. |
|---|
| | | * @param[in] participant_device A #LinphoneParticipantDevice object |
|---|
| | | * @return the name of the device or NULL |
|---|
| | | * @param participant_device A #LinphoneParticipantDevice object @notnil |
|---|
| | | * @return the name of the device or NULL. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_participant_device_get_name (const LinphoneParticipantDevice *LinphoneParticipantDevice); |
|---|
| | | LINPHONE_PUBLIC const char *linphone_participant_device_get_name (const LinphoneParticipantDevice *participant_device); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Return whether the participant device is in a conference or not. |
|---|
| | | * @param participant_device A #LinphoneParticipantDevice object @notnil |
|---|
| | | * @return a boolean to state whether the device is in a conference |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_participant_device_is_in_conference (const LinphoneParticipantDevice *participant_device); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the timestamp the device joined a conference. |
|---|
| | | * @param participant A #LinphoneParticipantDevice object @notnil |
|---|
| | | * @return time of joining a conference as returned by time(nullptr). For UNIX based systems it is the number of seconds since 00:00hours of the 1st of January 1970 |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC time_t linphone_participant_device_get_time_of_joining(const LinphoneParticipantDevice *participant_device); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @} |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Increment reference count of LinphoneParticipantImdnState object. |
|---|
| | | * @param state the #LinphoneParticipantImdnState object @notnil |
|---|
| | | * @return the same #LinphoneParticipantImdnState object @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneParticipantImdnState *linphone_participant_imdn_state_ref (LinphoneParticipantImdnState *state); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Decrement reference count of LinphoneParticipantImdnState object. |
|---|
| | | * @param state the #LinphoneParticipantImdnState object @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_participant_imdn_state_unref (LinphoneParticipantImdnState *state); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Retrieve the user pointer associated with a LinphoneParticipantImdnState. |
|---|
| | | * @param[in] state A LinphoneParticipantImdnState object |
|---|
| | | * @return The user pointer associated with the LinphoneParticipantImdnState. |
|---|
| | | * @param state A LinphoneParticipantImdnState object @notnil |
|---|
| | | * @return The user pointer associated with the LinphoneParticipantImdnState. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void *linphone_participant_imdn_state_get_user_data(const LinphoneParticipantImdnState *state); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user pointer to a LinphoneParticipantImdnState. |
|---|
| | | * @param[in] state A LinphoneParticipantImdnState object |
|---|
| | | * @param[in] ud The user pointer to associate with the LinphoneParticipantImdnState |
|---|
| | | * @param state A LinphoneParticipantImdnState object @notnil |
|---|
| | | * @param user_data The user pointer to associate with the LinphoneParticipantImdnState. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_participant_imdn_state_set_user_data(LinphoneParticipantImdnState *state, void *ud); |
|---|
| | | LINPHONE_PUBLIC void linphone_participant_imdn_state_set_user_data(LinphoneParticipantImdnState *state, void *user_data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the participant concerned by a LinphoneParticipantImdnState. |
|---|
| | | * @param[in] state A LinphoneParticipantImdnState object |
|---|
| | | * @return The participant concerned by the LinphoneParticipantImdnState |
|---|
| | | * @param state A LinphoneParticipantImdnState object @notnil |
|---|
| | | * @return The #LinphoneParticipant concerned by the LinphoneParticipantImdnState @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const LinphoneParticipant *linphone_participant_imdn_state_get_participant ( |
|---|
| | | const LinphoneParticipantImdnState *state |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the chat message state the participant is in. |
|---|
| | | * @param state A LinphoneParticipantImdnState object |
|---|
| | | * @return The chat message state the participant is in |
|---|
| | | * @param state A LinphoneParticipantImdnState object @notnil |
|---|
| | | * @return The #LinphoneChatMessageState the participant is in |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatMessageState linphone_participant_imdn_state_get_state (const LinphoneParticipantImdnState *state); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the timestamp at which a participant has reached the state described by a LinphoneParticipantImdnState. |
|---|
| | | * @param[in] state A LinphoneParticipantImdnState object |
|---|
| | | * @param state A LinphoneParticipantImdnState object @notnil |
|---|
| | | * @return The timestamp at which the participant has reached the state described in the LinphoneParticipantImdnState |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC time_t linphone_participant_imdn_state_get_state_change_time (const LinphoneParticipantImdnState *state); |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | #ifndef _L_C_PARTICIPANT_H_ |
|---|
| | | #define _L_C_PARTICIPANT_H_ |
|---|
| | | |
|---|
| | | #include "time.h" |
|---|
| | | #include "linphone/api/c-types.h" |
|---|
| | | |
|---|
| | | // ============================================================================= |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Increment reference count of #LinphoneParticipant object. |
|---|
| | | * @param participant a #LinphoneParticipant object @notnil |
|---|
| | | * @return the same #LinphoneParticipant object @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneParticipant *linphone_participant_ref (LinphoneParticipant *participant); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Decrement reference count of #LinphoneParticipant object. |
|---|
| | | * @param participant a #LinphoneParticipant object @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_participant_unref (LinphoneParticipant *participant); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Retrieve the user pointer associated with the conference participant. |
|---|
| | | * @param[in] participant A #LinphoneParticipant object |
|---|
| | | * @return The user pointer associated with the participant. |
|---|
| | | * @param participant A #LinphoneParticipant object @notnil |
|---|
| | | * @return The user pointer associated with the participant. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void * linphone_participant_get_user_data(const LinphoneParticipant *participant); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user pointer to the conference participant. |
|---|
| | | * @param[in] participant A #LinphoneParticipant object |
|---|
| | | * @param[in] ud The user pointer to associate with the participant |
|---|
| | | * @param participant A #LinphoneParticipant object @notnil |
|---|
| | | * @param user_data The user pointer to associate with the participant. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_participant_set_user_data(LinphoneParticipant *participant, void *ud); |
|---|
| | | LINPHONE_PUBLIC void linphone_participant_set_user_data(LinphoneParticipant *participant, void *user_data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the address of a conference participant. |
|---|
| | | * @param[in] participant A #LinphoneParticipant object |
|---|
| | | * @return The address of the participant |
|---|
| | | * @param participant A #LinphoneParticipant object @notnil |
|---|
| | | * @return The #LinphoneAddress of the participant @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress * linphone_participant_get_address (const LinphoneParticipant *participant); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Tells whether a conference participant is an administrator of the conference. |
|---|
| | | * @param[in] participant A #LinphoneParticipant object |
|---|
| | | * @param participant A #LinphoneParticipant object |
|---|
| | | * @return A boolean value telling whether the participant is an administrator |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_participant_is_admin (const LinphoneParticipant *participant); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the security level of a chat room. |
|---|
| | | * @param[in] cr A #LinphoneChatRoom object |
|---|
| | | * @return The security level of the chat room |
|---|
| | | * Tells whether a conference participant is the focus of the conference. |
|---|
| | | * @param participant A #LinphoneParticipant object |
|---|
| | | * @return A boolean value telling whether the participant is a focus of a conference |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_participant_is_focus (const LinphoneParticipant *participant); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the security level of a participant. |
|---|
| | | * @param participant A #LinphoneParticipant object @notnil |
|---|
| | | * @return The #LinphoneChatRoomSecurityLevel of the participant |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoomSecurityLevel linphone_participant_get_security_level (const LinphoneParticipant *participant); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the list of devices from a chat room's participant. |
|---|
| | | * @param[in] participant A #LinphoneParticipant object |
|---|
| | | * @return \bctbx_list{LinphoneParticipantDevice} |
|---|
| | | * @param participant A #LinphoneParticipant object @notnil |
|---|
| | | * @return List of devices. \bctbx_list{LinphoneParticipantDevice} @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bctbx_list_t *linphone_participant_get_devices (const LinphoneParticipant *participant); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Find a device in the list of devices from a chat room's participant. |
|---|
| | | * @param[in] participant A #LinphoneParticipant object |
|---|
| | | * @param[in] address A #LinphoneAddress object |
|---|
| | | * @return a #LinphoneParticipantDevice or NULL if not found |
|---|
| | | * @param participant A #LinphoneParticipant object @notnil |
|---|
| | | * @param address A #LinphoneAddress object @notnil |
|---|
| | | * @return a #LinphoneParticipantDevice or NULL if not found. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneParticipantDevice *linphone_participant_find_device (const LinphoneParticipant *participant, const LinphoneAddress *address); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the timestamp of the creation of the participant. |
|---|
| | | * @param participant A #LinphoneParticipant object @notnil |
|---|
| | | * @return time of creation of the participant as returned by time(nullptr). For UNIX based systems it is the number of seconds since 00:00hours of the 1st of January 1970 |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC time_t linphone_participant_get_creation_time(const LinphoneParticipant *participant); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @} |
|---|
| | | */ |
|---|
| | | |
|---|
| New file |
| | |
|---|
| | | /* |
|---|
| | | * Copyright (c) 2010-2019 Belledonne Communications SARL. |
|---|
| | | * |
|---|
| | | * This file is part of Liblinphone. |
|---|
| | | * |
|---|
| | | * 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 3 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, see <http://www.gnu.org/licenses/>. |
|---|
| | | */ |
|---|
| | | |
|---|
| | | #ifndef LINPHONE_PUSH_NOTIFICATION_MESSAGE_H |
|---|
| | | #define LINPHONE_PUSH_NOTIFICATION_MESSAGE_H |
|---|
| | | |
|---|
| | | #include "linphone/api/c-types.h" |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @addtogroup misc |
|---|
| | | * @{ |
|---|
| | | */ |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Safely cast a belle_sip_object_t into #LinphonePushNotificationMessage |
|---|
| | | */ |
|---|
| | | |
|---|
| | | #ifdef __cplusplus |
|---|
| | | extern "C" { |
|---|
| | | #endif |
|---|
| | | |
|---|
| | | LINPHONE_PUBLIC LinphonePushNotificationMessage *linphone_push_notification_message_new(const char *call_id, bool_t is_text, |
|---|
| | | const char *text_content, const char *subject, const char *from_addr, |
|---|
| | | const char *local_addr, const char *peer_addr); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Take a reference on a #LinphonePushNotificationMessage. |
|---|
| | | * @param message the #LinphonePushNotificationMessage object @notnil |
|---|
| | | * @return the same #LinphonePushNotificationMessage object @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphonePushNotificationMessage *linphone_push_notification_message_ref(LinphonePushNotificationMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Release a #LinphonePushNotificationMessage. |
|---|
| | | * @param message the #LinphonePushNotificationMessage object @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_push_notification_message_unref(LinphonePushNotificationMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the call id. |
|---|
| | | * @param message The #LinphonePushNotificationMessage object @notnil |
|---|
| | | * @return The call id. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_push_notification_message_get_call_id(const LinphonePushNotificationMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns wether it is a text message or not. |
|---|
| | | * @param message The #LinphonePushNotificationMessage object @notnil |
|---|
| | | * @return TRUE if it is a text message, FALSE otherwise. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_push_notification_message_is_text(const LinphonePushNotificationMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the text content. |
|---|
| | | * @param message The #LinphonePushNotificationMessage object @notnil |
|---|
| | | * @return The text content or NULL. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_push_notification_message_get_text_content(const LinphonePushNotificationMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the subject. |
|---|
| | | * @param message The #LinphonePushNotificationMessage object @notnil |
|---|
| | | * @return The subject or NULL. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_push_notification_message_get_subject(const LinphonePushNotificationMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the from address. |
|---|
| | | * @param message The #LinphonePushNotificationMessage object @notnil |
|---|
| | | * @return The from #LinphoneAddress. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress *linphone_push_notification_message_get_from_addr(const LinphonePushNotificationMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the local address. |
|---|
| | | * @param message The #LinphonePushNotificationMessage object @notnil |
|---|
| | | * @return The local #LinphoneAddress. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress *linphone_push_notification_message_get_local_addr(const LinphonePushNotificationMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the peer address. |
|---|
| | | * @param message The #LinphonePushNotificationMessage object @notnil |
|---|
| | | * @return The peer #LinphoneAddress. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress *linphone_push_notification_message_get_peer_addr(const LinphonePushNotificationMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @} |
|---|
| | | */ |
|---|
| | | |
|---|
| | | #ifdef __cplusplus |
|---|
| | | } |
|---|
| | | #endif |
|---|
| | | |
|---|
| | | #endif /* LINPHONE_PUSH_NOTIFICATION_MESSAGE_H */ |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Increment reference count of LinphoneSearchResult object. |
|---|
| | | * @param search_result the #LinphoneSearchResult object @notnil |
|---|
| | | * @return the same #LinphoneSearchResult object @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneSearchResult *linphone_search_result_ref(LinphoneSearchResult *searchResult); |
|---|
| | | LINPHONE_PUBLIC LinphoneSearchResult *linphone_search_result_ref(LinphoneSearchResult *search_result); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Decrement reference count of LinphoneSearchResult object. When dropped to zero, memory is freed. |
|---|
| | | * @param search_result the #LinphoneSearchResult object @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_search_result_unref(LinphoneSearchResult *searchResult); |
|---|
| | | LINPHONE_PUBLIC void linphone_search_result_unref(LinphoneSearchResult *search_result); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @return LinphoneFriend associed |
|---|
| | | * Gets the friend of the search result if any. |
|---|
| | | * @param search_result the #LinphoneSearchResult object @notnil |
|---|
| | | * @return The associated #LinphoneFriend or NULL. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const LinphoneFriend* linphone_search_result_get_friend(const LinphoneSearchResult *searchResult); |
|---|
| | | LINPHONE_PUBLIC const LinphoneFriend* linphone_search_result_get_friend(const LinphoneSearchResult *search_result); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @return LinphoneAddress associed |
|---|
| | | * Gets the address of the search result if any. |
|---|
| | | * @param search_result the #LinphoneSearchResult object @notnil |
|---|
| | | * @return The associed #LinphoneAddress or NULL. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress* linphone_search_result_get_address(const LinphoneSearchResult *searchResult); |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress* linphone_search_result_get_address(const LinphoneSearchResult *search_result); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @return Phone Number associed |
|---|
| | | * Gets the phone number of the search result if any. |
|---|
| | | * @param search_result the #LinphoneSearchResult object @notnil |
|---|
| | | * @return The associed phone number or NULL. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char* linphone_search_result_get_phone_number(const LinphoneSearchResult *searchResult); |
|---|
| | | LINPHONE_PUBLIC const char* linphone_search_result_get_phone_number(const LinphoneSearchResult *search_result); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @return the capabilities associated to the search result |
|---|
| | | * Returns the capabilities mask of the search result. |
|---|
| | | * @param search_result the #LinphoneSearchResult object @notnil |
|---|
| | | * @return the capabilities mask associated to the search result |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC int linphone_search_result_get_capabilities(const LinphoneSearchResult *searchResult); |
|---|
| | | LINPHONE_PUBLIC int linphone_search_result_get_capabilities(const LinphoneSearchResult *search_result); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @return whether a search result has a given capability |
|---|
| | | * Returns whether or not the search result has the given capability |
|---|
| | | * @param search_result the #LinphoneSearchResult object @notnil |
|---|
| | | * @param capability the #LinphoneFriendCapability to check |
|---|
| | | * @return TRUE if it has the capability, FALSE otherwise. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_search_result_has_capability(const LinphoneSearchResult *searchResult, const LinphoneFriendCapability capability); |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_search_result_has_capability(const LinphoneSearchResult *search_result, const LinphoneFriendCapability capability); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the weight of the search result. |
|---|
| | | * @param search_result the #LinphoneSearchResult object @notnil |
|---|
| | | * @return the result weight |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC unsigned int linphone_search_result_get_weight(const LinphoneSearchResult *searchResult); |
|---|
| | | LINPHONE_PUBLIC unsigned int linphone_search_result_get_weight(const LinphoneSearchResult *search_result); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @} |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | #include "linphone/enums/call-enums.h" |
|---|
| | | #include "linphone/enums/chat-message-enums.h" |
|---|
| | | #include "linphone/enums/chat-room-enums.h" |
|---|
| | | #include "linphone/enums/conference-enums.h" |
|---|
| | | #include "linphone/enums/encryption-engine-enums.h" |
|---|
| | | #include "linphone/enums/event-log-enums.h" |
|---|
| | | #include "linphone/enums/security-event-enums.h" |
|---|
| | |
|---|
| | | #define TRUE 1 |
|---|
| | | #define FALSE 0 |
|---|
| | | |
|---|
| | | // ============================================================================= |
|---|
| | | // C Structures. |
|---|
| | | // ============================================================================= |
|---|
| | | // ----------------------------------------------------------------------------- |
|---|
| | | // Authentication. |
|---|
| | | // ----------------------------------------------------------------------------- |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Object holding authentication information. |
|---|
| | | * |
|---|
| | | * In most case, authentication information consists of a username and password. |
|---|
| | | * If realm isn't set, it will be deduced automatically from the first authentication challenge as for the hash algorithm. |
|---|
| | | * Sometimes, a userid is required by the proxy and then domain can be useful to discriminate different credentials. |
|---|
| | | * You can also use this object if you need to use a client certificate. |
|---|
| | | * |
|---|
| | | * Once created and filled, a #LinphoneAuthInfo must be added to the #LinphoneCore in |
|---|
| | | * order to become known and used automatically when needed. |
|---|
| | | * Use linphone_core_add_auth_info() for that purpose. |
|---|
| | | * |
|---|
| | | * The #LinphoneCore object can take the initiative to request authentication information |
|---|
| | | * when needed to the application through the authentication_requested() callback of it's #LinphoneCoreCbs. |
|---|
| | | * |
|---|
| | | * The application can respond to this information request later using |
|---|
| | | * linphone_core_add_auth_info(). This will unblock all pending authentication |
|---|
| | | * transactions and retry them with authentication headers. |
|---|
| | | * |
|---|
| | | * @ingroup authentication |
|---|
| | | **/ |
|---|
| | | typedef struct _LinphoneAuthInfo LinphoneAuthInfo; |
|---|
| | | |
|---|
| | | // ----------------------------------------------------------------------------- |
|---|
| | | // Address. |
|---|
| | | // ----------------------------------------------------------------------------- |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Object that represents a SIP address. |
|---|
| | | * @brief Object that represents a parsed SIP address. |
|---|
| | | * |
|---|
| | | * The #LinphoneAddress is an opaque object to represents SIP addresses, ie |
|---|
| | | * the content of SIP's 'from' and 'to' headers. |
|---|
| | | * A SIP address is made of display name, username, domain name, port, and various |
|---|
| | | * uri headers (such as tags). It looks like 'Alice <sip:alice@example.net>'. |
|---|
| | | * |
|---|
| | | * You can create an address using linphone_factory_create_address() or linphone_core_interpret_url() |
|---|
| | | * and both will return a NULL object if it doesn't match the grammar defined by the standard. |
|---|
| | | * |
|---|
| | | * This object is used in almost every other major objects to identity people (including yourself) & servers. |
|---|
| | | * |
|---|
| | | * The #LinphoneAddress has methods to extract and manipulate all parts of the address. |
|---|
| | | * When some part of the address (for example the username) is empty, the accessor methods |
|---|
| | | * return NULL. |
|---|
| | | * @ingroup linphone_address |
|---|
| | | */ |
|---|
| | | typedef struct _LinphoneAddress LinphoneAddress; |
|---|
| | | |
|---|
| | | // ----------------------------------------------------------------------------- |
|---|
| | | // Conference. |
|---|
| | | // ----------------------------------------------------------------------------- |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief TODO |
|---|
| | | * @ingroup conferencing |
|---|
| | | */ |
|---|
| | | typedef struct _LinphoneConference LinphoneConference; |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief TODO |
|---|
| | | * @ingroup conferencing |
|---|
| | | */ |
|---|
| | | typedef struct _LinphoneConferenceParams LinphoneConferenceParams; |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief An object to handle the callbacks for the handling a #LinphoneConference objects. |
|---|
| | | * |
|---|
| | | * Use linphone_factory_create_conference_cbs() to create an instance. |
|---|
| | | * Then pass the object to a #LinphoneConference instance through linphone_conference_add_callbacks(). |
|---|
| | | * @ingroup conferencing |
|---|
| | | */ |
|---|
| | | typedef struct _LinphoneConferenceCbs LinphoneConferenceCbs; |
|---|
| | | |
|---|
| | | // ----------------------------------------------------------------------------- |
|---|
| | | // Participants. |
|---|
| | | // ----------------------------------------------------------------------------- |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Identifies a member of a #LinphoneConference or #LinphoneChatRoom. |
|---|
| | | * |
|---|
| | | * A participant is identified by it's SIP address. |
|---|
| | | * It can have many #LinphoneParticipantDevice. |
|---|
| | | * @ingroup conference |
|---|
| | | */ |
|---|
| | | typedef struct _LinphoneParticipant LinphoneParticipant; |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief This object represents a unique device for a member of a #LinphoneConference or #LinphoneChatRoom. |
|---|
| | | * |
|---|
| | | * Devices are identified by the gruu parameter inside the #LinphoneAddress which can be obtained by linphone_participant_device_get_address(). |
|---|
| | | * It is specially usefull to know the security level of each device inside an end-to-end encrypted #LinphoneChatRoom. |
|---|
| | | * |
|---|
| | | * You can get a list of all #LinphoneParticipantDevice using linphone_participant_get_devices(). |
|---|
| | | * @ingroup conference |
|---|
| | | */ |
|---|
| | | typedef struct _LinphoneParticipantDevice LinphoneParticipantDevice; |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief This object represents the delivery/display state of a given chat message for a given participant. |
|---|
| | | * |
|---|
| | | * It also contains a timestamp at which this participant state has changed. |
|---|
| | | * |
|---|
| | | * Use linphone_chat_message_get_participants_by_imdn_state() to get all #LinphoneParticipantImdnState for a given state. |
|---|
| | | * From there use linphone_participant_imdn_state_get_participant() to get the #LinphoneParticipant object if you need it. |
|---|
| | | * @ingroup conference |
|---|
| | | */ |
|---|
| | | typedef struct _LinphoneParticipantImdnState LinphoneParticipantImdnState; |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief This object is only used on server side for #LinphoneChatRoom with #LinphoneChatRoomBackendFlexisipChat backend. |
|---|
| | | * @ingroup conference |
|---|
| | | */ |
|---|
| | | typedef struct _LinphoneParticipantDeviceIdentity LinphoneParticipantDeviceIdentity; |
|---|
| | | |
|---|
| | | // ----------------------------------------------------------------------------- |
|---|
| | | // Call. |
|---|
| | | // ----------------------------------------------------------------------------- |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * The #LinphoneCall object represents a call issued or received by the #LinphoneCore |
|---|
| | | * @brief This object represents a call issued or received by the #LinphoneCore. |
|---|
| | | * |
|---|
| | | * You may have multiple calls at the same time, but only one will be |
|---|
| | | * in #LinphoneCallStateStreamsRunning at any time unless they are merged into a #LinphoneConference, |
|---|
| | | * others will be paused. |
|---|
| | | * |
|---|
| | | * You can get the #LinphoneCallState of the call using linphone_call_get_state(), |
|---|
| | | * it's current #LinphoneCallParams with linphone_call_get_current_params() and |
|---|
| | | * the latest statistics by calling linphone_call_get_audio_stats() or linphone_call_get_video_stats(). |
|---|
| | | * |
|---|
| | | * @ingroup call_control |
|---|
| | | */ |
|---|
| | | typedef struct _LinphoneCall LinphoneCall; |
|---|
| | |
|---|
| | | typedef void (*LinphoneCallCbFunc) (LinphoneCall *call, void *ud); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * That class holds all the callbacks which are called by #LinphoneCall objects. |
|---|
| | | * @brief That class holds all the callbacks which are called by #LinphoneCall objects. |
|---|
| | | * |
|---|
| | | * Use linphone_factory_create_call_cbs() to create an instance. Then, call the |
|---|
| | | * callback setters on the events you need to monitor and pass the object to |
|---|
| | |
|---|
| | | */ |
|---|
| | | typedef struct _LinphoneCallCbs LinphoneCallCbs; |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief An object containing various parameters of a #LinphoneCall. |
|---|
| | | * |
|---|
| | | * You can specify your params while answering an incoming call using linphone_call_accept_with_params() |
|---|
| | | * or while initiating an outgoing call with linphone_core_invite_address_with_params(). |
|---|
| | | * |
|---|
| | | * This object can be created using linphone_core_create_call_params(), using NULL for the call pointer if you plan to use it for an outgoing call. |
|---|
| | | * |
|---|
| | | * For each call, three #LinphoneCallParams are available: yours, your correspondent's |
|---|
| | | * and the one that describe the current state of the call that is the result of the negociation between the previous two. |
|---|
| | | * For example, you might enable a certain feature in your call param but this feature can be denied in the remote's configuration, hence the difference. |
|---|
| | | * |
|---|
| | | * @see linphone_call_get_current_params(), linphone_call_get_remote_params() and linphone_call_get_params(). |
|---|
| | | * @ingroup call_control |
|---|
| | | **/ |
|---|
| | | typedef struct _LinphoneCallParams LinphoneCallParams; |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Object used to keep track of all calls initiated, received or missed. |
|---|
| | | * |
|---|
| | | * It contains the call ID, date & time at which the call took place and it's duration (0 if it wasn't answered). |
|---|
| | | * You can also know if video was enabled or not or if it was a conference, as well as it's average quality. |
|---|
| | | * |
|---|
| | | * If needed, you can also create a fake #LinphoneCallLog using linphone_core_create_call_log(), |
|---|
| | | * otherwise use linphone_core_get_call_logs() or even linphone_call_get_call_log() to get the log of an ongoing call. |
|---|
| | | * |
|---|
| | | * @ingroup call_logs |
|---|
| | | **/ |
|---|
| | | typedef struct _LinphoneCallLog LinphoneCallLog; |
|---|
| | | |
|---|
| | | // ----------------------------------------------------------------------------- |
|---|
| | | // Audio. |
|---|
| | | // ----------------------------------------------------------------------------- |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Object holding audio device information. |
|---|
| | | * |
|---|
| | | * It contains the name of the device, it's type if available (Earpiece, Speaker, Bluetooth, etc..) |
|---|
| | | * and capabilities (input, output or both) the name of the driver that created it (filter in mediastreamer). |
|---|
| | | * |
|---|
| | | * You can use the #LinphoneAudioDevice objects to configure default input/output devices or do it dynamically during a call. |
|---|
| | | * |
|---|
| | | * To get the list of available devices, use linphone_core_get_audio_devices(). This list will be limited to one device of each type. |
|---|
| | | * Use linphone_core_get_extended_audio_devices() for a complete list. |
|---|
| | | * |
|---|
| | | * @ingroup audio |
|---|
| | | **/ |
|---|
| | | typedef struct _LinphoneAudioDevice LinphoneAudioDevice; |
|---|
| | | |
|---|
| | | // ----------------------------------------------------------------------------- |
|---|
| | | // ChatRoom. |
|---|
| | | // ----------------------------------------------------------------------------- |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * An chat message is the object that is sent and received through LinphoneChatRooms. |
|---|
| | | * @brief An chat message is the object that is sent or received through a #LinphoneChatRoom. |
|---|
| | | * |
|---|
| | | * To create a #LinphoneChatMessage, use linphone_chat_room_create_empty_message(), |
|---|
| | | * then either add text using linphone_chat_message_add_utf8_text_content() or a |
|---|
| | | * #LinphoneContent with file informations using linphone_chat_message_add_file_content(). |
|---|
| | | * A valid #LinphoneContent for file transfer must contain a type and subtype, the name of the file and it's size. |
|---|
| | | * Finally call linphone_chat_message_send() to send it. |
|---|
| | | * |
|---|
| | | * To send files through a #LinphoneChatMessage, you need to have configured a file transfer server URL with linphone_core_set_file_transfer_server(). |
|---|
| | | * On the receiving side, either use linphone_chat_message_download_content() to download received files or enable auto-download in the #LinphoneCore using |
|---|
| | | * linphone_core_set_max_size_for_auto_download_incoming_files(), -1 disabling the feature and 0 always downloading files no matter it's size. |
|---|
| | | * |
|---|
| | | * Keep in mind a #LinphoneChatMessage created by a #LinphoneChatRoomBackendBasic #LinphoneChatRoom can only contain one #LinphoneContent, either text or file. |
|---|
| | | * @ingroup chatroom |
|---|
| | | */ |
|---|
| | | typedef struct _LinphoneChatMessage LinphoneChatMessage; |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * An object to handle the callbacks for the handling a #LinphoneChatMessage objects. |
|---|
| | | * @brief An object to handle the callbacks for the handling a #LinphoneChatMessage objects. |
|---|
| | | * @ingroup chatroom |
|---|
| | | */ |
|---|
| | | typedef struct _LinphoneChatMessageCbs LinphoneChatMessageCbs; |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * A chat room is the place where text messages are exchanged. |
|---|
| | | * Can be created by linphone_core_create_chat_room(). |
|---|
| | | * @brief A chat room is the place where #LinphoneChatMessage are exchanged. |
|---|
| | | * |
|---|
| | | * To create (or find) a #LinphoneChatRoom, you first need a #LinphoneChatRoomParams object. |
|---|
| | | * A chat room is uniquely identified by it's local and remote SIP addresses, meaning you can |
|---|
| | | * only have one chat room between two accounts (unless the backend is #LinphoneChatRoomBackendFlexisipChat). |
|---|
| | | * Then you can call linphone_core_search_chat_room() or linphone_core_create_chat_room_6(). |
|---|
| | | * |
|---|
| | | * Be careful as a #LinphoneChatRoomBackendFlexisipChat backend #LinphoneChatRoom will be created asynchronously, so |
|---|
| | | * make sure you add a #LinphoneChatRoomCbs to the returned object to be notified |
|---|
| | | * when it will be in state #LinphoneChatRoomStateCreated. |
|---|
| | | * |
|---|
| | | * All chat rooms are loaded from database when the #LinphoneCore starts, and you can get them using |
|---|
| | | * linphone_core_get_chat_rooms(). This method doesn't return empty chat rooms nor ones for which the local address |
|---|
| | | * doesn't match an existing #LinphoneProxyConfig identity, unless you specify otherwise in the [misc] section |
|---|
| | | * of your configuration file by setting hide_empty_chat_rooms=0 and/or hide_chat_rooms_from_removed_proxies=0. |
|---|
| | | * @ingroup chatroom |
|---|
| | | */ |
|---|
| | | typedef struct _LinphoneChatRoom LinphoneChatRoom; |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * An object to handle a chat room parameters. |
|---|
| | | * Can be created with linphone_core_get_default_chat_room_params() or linphone_chat_room_params_new(). |
|---|
| | | * @brief Object defining parameters for a #LinphoneChatRoom. |
|---|
| | | * |
|---|
| | | * Can be created with linphone_core_create_default_chat_room_params(). |
|---|
| | | * You can use linphone_chat_room_params_is_valid() to check if your configuration is valid or not. |
|---|
| | | * |
|---|
| | | * If the #LinphoneChatRoom backend is #LinphoneChatRoomBackendBasic, then no other parameter is required, |
|---|
| | | * but #LinphoneChatMessage sent and received won't benefit from all features a #LinphoneChatRoomBackendFlexisipChat can offer |
|---|
| | | * like conversation with multiple participants and a subject, end-to-end encryption, ephemeral messages, etc... |
|---|
| | | * but this type is the only one that can interoperate with other SIP clients or with non-flexisip SIP proxies. |
|---|
| | | * @ingroup chatroom |
|---|
| | | */ |
|---|
| | | typedef struct _LinphoneChatRoomParams LinphoneChatRoomParams; |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * A mask of #LinphoneChatRoomCapabilities |
|---|
| | | * @brief A mask of #LinphoneChatRoomCapabilities |
|---|
| | | * @ingroup chatroom |
|---|
| | | */ |
|---|
| | | typedef int LinphoneChatRoomCapabilitiesMask; |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * An object to handle the callbacks for the handling a #LinphoneChatRoom objects. |
|---|
| | | * @brief An object to handle the callbacks for the handling a #LinphoneChatRoom objects. |
|---|
| | | * @ingroup chatroom |
|---|
| | | */ |
|---|
| | | typedef struct _LinphoneChatRoomCbs LinphoneChatRoomCbs; |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Object holding chat message data received by a push notification on iOS platform only. |
|---|
| | | * |
|---|
| | | * This object is a subset of #LinphoneChatMessage, so only a few methods of it's parent are available, |
|---|
| | | * like linphone_push_notification_message_get_text_content() and linphone_push_notification_message_get_subject(), |
|---|
| | | * just enough to be able to build a notification to show the user. |
|---|
| | | * @ingroup chatroom |
|---|
| | | **/ |
|---|
| | | typedef struct _LinphonePushNotificationMessage LinphonePushNotificationMessage; |
|---|
| | | |
|---|
| | | // ----------------------------------------------------------------------------- |
|---|
| | | // EventLog. |
|---|
| | | // ----------------------------------------------------------------------------- |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Base object of events. |
|---|
| | | * @brief Object that represents an event that must be stored in database. |
|---|
| | | * |
|---|
| | | * For example, all chat related events are wrapped in an #LinphoneEventLog, |
|---|
| | | * and many callbacks use this kind of type as parameter. |
|---|
| | | * |
|---|
| | | * Use linphone_event_log_get_type() to get the #LinphoneEventLogType it refers to, |
|---|
| | | * and then you can use one of the accessor methods to get the underlying object, |
|---|
| | | * for example linphone_event_log_get_chat_message() for a #LinphoneChatMessage. |
|---|
| | | * @ingroup events |
|---|
| | | */ |
|---|
| | | typedef struct _LinphoneEventLog LinphoneEventLog; |
|---|
| | |
|---|
| | | // ----------------------------------------------------------------------------- |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * The LinphoneContent object holds data that can be embedded in a signaling message. |
|---|
| | | * @brief This object holds data that can be embedded in a signaling message. |
|---|
| | | * |
|---|
| | | * Use linphone_core_create_content() to create it, and then you should set at least it's |
|---|
| | | * type and subtype and fill the buffer with your data. |
|---|
| | | * |
|---|
| | | * A #LinphoneContent can be multipart (contain other contents), have file information (name, path, size), |
|---|
| | | * be encrypted, have custom headers, etc... |
|---|
| | | * |
|---|
| | | * It is mainly used to send information through a #LinphoneChatMessage. |
|---|
| | | * @ingroup misc |
|---|
| | | */ |
|---|
| | | typedef struct _LinphoneContent LinphoneContent; |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Represents a dial plan |
|---|
| | | * @brief Represents a dial plan |
|---|
| | | * @ingroup misc |
|---|
| | | */ |
|---|
| | | typedef struct _LinphoneDialPlan LinphoneDialPlan; |
|---|
| | | |
|---|
| | | // ----------------------------------------------------------------------------- |
|---|
| | | // Search. |
|---|
| | | // ----------------------------------------------------------------------------- |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * A #LinphoneMagicSearch is used to do specifics searchs |
|---|
| | | * @brief A #LinphoneMagicSearch is used to do specifics searchs |
|---|
| | | * @ingroup misc |
|---|
| | | */ |
|---|
| | | typedef struct _LinphoneMagicSearch LinphoneMagicSearch; |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @ingroup misc |
|---|
| | | */ |
|---|
| | | typedef struct _LinphoneParticipant LinphoneParticipant; |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * The LinphoneParticipantImdnState object represents the state of chat message for a participant of a conference chat room. |
|---|
| | | * @ingroup misc |
|---|
| | | */ |
|---|
| | | typedef struct _LinphoneParticipantImdnState LinphoneParticipantImdnState; |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @ingroup misc |
|---|
| | | */ |
|---|
| | | typedef struct _LinphoneParticipantDevice LinphoneParticipantDevice; |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @ingroup misc |
|---|
| | | */ |
|---|
| | | typedef struct _LinphoneParticipantDeviceIdentity LinphoneParticipantDeviceIdentity; |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * The LinphoneSearchResult object represents a result of a search |
|---|
| | | * @brief The LinphoneSearchResult object represents a result of a search |
|---|
| | | * @ingroup misc |
|---|
| | | */ |
|---|
| | | typedef struct _LinphoneSearchResult LinphoneSearchResult; |
|---|
| | | |
|---|
| | | // ============================================================================= |
|---|
| | | // C Enums. |
|---|
| | | // ============================================================================= |
|---|
| | | |
|---|
| | | // ----------------------------------------------------------------------------- |
|---|
| | | // How-to: Declare one enum |
|---|
| | | // |
|---|
| | | // 1. Declare a macro like this example in include/linphone/enums/chat-message-enums.h: |
|---|
| | | // |
|---|
| | | // #define L_ENUM_VALUES_CHAT_MESSAGE_DIRECTION(F) \ // |
|---|
| | | // F(Incoming /**< Incoming message */) \ // |
|---|
| | | // F(Outgoing /**< Outgoing message */) |
|---|
| | | // |
|---|
| | | // 2. And in this file, call L_DECLARE_C_ENUM with the enum name and values as params: |
|---|
| | | // |
|---|
| | | // L_DECLARE_C_ENUM(ChatMessageDirection, L_ENUM_VALUES_CHAT_MESSAGE_DIRECTION); |
|---|
| | | // |
|---|
| | | // 3. Do not forget to replace each single quote (with ') or other special char like |
|---|
| | | // to an escaped sequence. Otherwise you get this error at compilation: |
|---|
| | | // |
|---|
| | | // [ 99%] Building CXX object wrappers/cpp/CMakeFiles/linphone++.dir/src/linphone++.cc.o |
|---|
| | | // c++: error: WORK/desktop/Build/linphone/wrappers/cpp/src/linphone++.cc: No such file or directory |
|---|
| | | // c++: fatal error: no input files |
|---|
| | | // compilation terminated. |
|---|
| | | // ----------------------------------------------------------------------------- |
|---|
| | | |
|---|
| | | // ----------------------------------------------------------------------------- |
|---|
| | | // Call. |
|---|
| | | // ----------------------------------------------------------------------------- |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * #LinphoneCallState enum represents the different states a call can reach into. |
|---|
| | | * The application is notified of a state change through the LinphoneCoreVTable::call_state_changed callback. |
|---|
| | | * @ingroup call_control |
|---|
| | | */ |
|---|
| | | L_DECLARE_C_ENUM(CallState, L_ENUM_VALUES_CALL_SESSION_STATE); |
|---|
| | | |
|---|
| | | // ----------------------------------------------------------------------------- |
|---|
| | | // ChatRoom. |
|---|
| | | // ----------------------------------------------------------------------------- |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * #LinphoneChatMessageDirection is used to indicate if a message is outgoing or incoming. |
|---|
| | | * @ingroup chatroom |
|---|
| | | */ |
|---|
| | | L_DECLARE_C_ENUM(ChatMessageDirection, L_ENUM_VALUES_CHAT_MESSAGE_DIRECTION); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * #LinphoneChatMessageState is used to notify if messages have been successfully delivered or not. |
|---|
| | | * @ingroup chatroom |
|---|
| | | */ |
|---|
| | | L_DECLARE_C_ENUM(ChatMessageState, L_ENUM_VALUES_CHAT_MESSAGE_STATE); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * #LinphoneChatRoomCapabilities is used to indicate the capabilities of a chat room. |
|---|
| | | * @ingroup chatroom |
|---|
| | | */ |
|---|
| | | L_DECLARE_C_ENUM_FIXED_VALUES(ChatRoomCapabilities, L_ENUM_VALUES_CHAT_ROOM_CAPABILITIES); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * #LinphoneChatRoomBackend is used to indicate the backend implementation of a chat room. |
|---|
| | | * @ingroup chatroom |
|---|
| | | */ |
|---|
| | | L_DECLARE_C_ENUM_FIXED_VALUES(ChatRoomBackend, L_ENUM_VALUES_CHAT_ROOM_BACKEND); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * #LinphoneChatRoomEncryptionBackend is used to indicate the encryption engine used by a chat room. |
|---|
| | | * @ingroup chatroom |
|---|
| | | */ |
|---|
| | | L_DECLARE_C_ENUM_FIXED_VALUES(ChatRoomEncryptionBackend, L_ENUM_VALUES_CHAT_ROOM_ENCRYPTION_BACKEND); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * TODO move to encryption engine object when available |
|---|
| | | * #LinphoneChatRoomSecurityLevel is used to indicate the encryption security level of a chat room. |
|---|
| | | * @ingroup chatroom |
|---|
| | | */ |
|---|
| | | L_DECLARE_C_ENUM(ChatRoomSecurityLevel, L_ENUM_VALUES_ENCRYPTION_ENGINE_SECURITY_LEVEL); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * #LinphoneChatRoomState is used to indicate the current state of a chat room. |
|---|
| | | * @ingroup chatroom |
|---|
| | | */ |
|---|
| | | L_DECLARE_C_ENUM(ChatRoomState, L_ENUM_VALUES_CHAT_ROOM_STATE); |
|---|
| | | |
|---|
| | | // ----------------------------------------------------------------------------- |
|---|
| | | // EventLog. |
|---|
| | | // ----------------------------------------------------------------------------- |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * #LinphoneEventLogType is used to indicate the type of an event. Useful for cast. |
|---|
| | | * @ingroup events |
|---|
| | | */ |
|---|
| | | L_DECLARE_C_ENUM(EventLogType, L_ENUM_VALUES_EVENT_LOG_TYPE); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * #LinphoneSecurityEventType is used to indicate the type of security event. |
|---|
| | | * @ingroup events |
|---|
| | | */ |
|---|
| | | L_DECLARE_C_ENUM(SecurityEventType, L_ENUM_VALUES_SECURITY_EVENT_TYPE); |
|---|
| | | |
|---|
| | | #ifdef __cplusplus |
|---|
| | | } |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Create a new empty #LinphoneBuffer object. |
|---|
| | | * @return A new #LinphoneBuffer object. |
|---|
| | | * @return A new #LinphoneBuffer object. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneBuffer * linphone_buffer_new(void); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Create a new #LinphoneBuffer object from existing data. |
|---|
| | | * @param[in] data The initial data to store in the LinphoneBuffer. |
|---|
| | | * @param[in] size The size of the initial data to stroe in the LinphoneBuffer. |
|---|
| | | * @return A new #LinphoneBuffer object. |
|---|
| | | * @param data The initial data to store in the LinphoneBuffer. @notnil |
|---|
| | | * @param size The size of the initial data to stroe in the LinphoneBuffer. |
|---|
| | | * @return A new #LinphoneBuffer object. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneBuffer * linphone_buffer_new_from_data(const uint8_t *data, size_t size); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Create a new #LinphoneBuffer object from a string. |
|---|
| | | * @param[in] data The initial string content of the LinphoneBuffer. |
|---|
| | | * @return A new #LinphoneBuffer object. |
|---|
| | | * @param data The initial string content of the LinphoneBuffer. @notnil |
|---|
| | | * @return A new #LinphoneBuffer object. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneBuffer * linphone_buffer_new_from_string(const char *data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Acquire a reference to the buffer. |
|---|
| | | * @param[in] buffer #LinphoneBuffer object. |
|---|
| | | * @return The same #LinphoneBuffer object. |
|---|
| | | * @param buffer #LinphoneBuffer object. @notnil |
|---|
| | | * @return The same #LinphoneBuffer object. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneBuffer * linphone_buffer_ref(LinphoneBuffer *buffer); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Release reference to the buffer. |
|---|
| | | * @param[in] buffer #LinphoneBuffer object. |
|---|
| | | * @param buffer #LinphoneBuffer object. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_buffer_unref(LinphoneBuffer *buffer); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Retrieve the user pointer associated with the buffer. |
|---|
| | | * @param[in] buffer #LinphoneBuffer object. |
|---|
| | | * @return The user pointer associated with the buffer. |
|---|
| | | * @param buffer #LinphoneBuffer object. @notnil |
|---|
| | | * @return The user pointer associated with the buffer. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void *linphone_buffer_get_user_data(const LinphoneBuffer *buffer); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user pointer to the buffer. |
|---|
| | | * @param[in] buffer #LinphoneBuffer object. |
|---|
| | | * @param[in] ud The user pointer to associate with the buffer. |
|---|
| | | * @param buffer #LinphoneBuffer object. @notnil |
|---|
| | | * @param user_data The user pointer to associate with the buffer. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_buffer_set_user_data(LinphoneBuffer *buffer, void *ud); |
|---|
| | | LINPHONE_PUBLIC void linphone_buffer_set_user_data(LinphoneBuffer *buffer, void *user_data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the content of the data buffer. |
|---|
| | | * @param[in] buffer #LinphoneBuffer object. |
|---|
| | | * @return The content of the data buffer. |
|---|
| | | * @param buffer #LinphoneBuffer object. @notnil |
|---|
| | | * @return The content of the data buffer. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const uint8_t * linphone_buffer_get_content(const LinphoneBuffer *buffer); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the content of the data buffer. |
|---|
| | | * @param[in] buffer #LinphoneBuffer object. |
|---|
| | | * @param[in] content The content of the data buffer. |
|---|
| | | * @param[in] size The size of the content of the data buffer. |
|---|
| | | * @param buffer #LinphoneBuffer object. @notnil |
|---|
| | | * @param content The content of the data buffer. @notnil |
|---|
| | | * @param size The size of the content of the data buffer. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_buffer_set_content(LinphoneBuffer *buffer, const uint8_t *content, size_t size); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the string content of the data buffer. |
|---|
| | | * @param[in] buffer #LinphoneBuffer object |
|---|
| | | * @return The string content of the data buffer. |
|---|
| | | * @param buffer #LinphoneBuffer object |
|---|
| | | * @return The string content of the data buffer. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_buffer_get_string_content(const LinphoneBuffer *buffer); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the string content of the data buffer. |
|---|
| | | * @param[in] buffer #LinphoneBuffer object. |
|---|
| | | * @param[in] content The string content of the data buffer. |
|---|
| | | * @param buffer #LinphoneBuffer object. @notnil |
|---|
| | | * @param content The string content of the data buffer. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_buffer_set_string_content(LinphoneBuffer *buffer, const char *content); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the size of the content of the data buffer. |
|---|
| | | * @param[in] buffer #LinphoneBuffer object. |
|---|
| | | * @param buffer #LinphoneBuffer object. @notnil |
|---|
| | | * @return The size of the content of the data buffer. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC size_t linphone_buffer_get_size(const LinphoneBuffer *buffer); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the size of the content of the data buffer. |
|---|
| | | * @param[in] buffer #LinphoneBuffer object |
|---|
| | | * @param[in] size The size of the content of the data buffer. |
|---|
| | | * @param buffer #LinphoneBuffer object @notnil |
|---|
| | | * @param size The size of the content of the data buffer. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_buffer_set_size(LinphoneBuffer *buffer, size_t size); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Tell whether the #LinphoneBuffer is empty. |
|---|
| | | * @param[in] buffer #LinphoneBuffer object |
|---|
| | | * @param buffer #LinphoneBuffer object @notnil |
|---|
| | | * @return A boolean value telling whether the #LinphoneBuffer is empty or not. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_buffer_is_empty(const LinphoneBuffer *buffer); |
|---|
old mode 100644
new mode 100755
old mode 100644
new mode 100755
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the call ID used by the call. |
|---|
| | | * @param[in] cl #LinphoneCallLog object |
|---|
| | | * @return The call ID used by the call as a string. |
|---|
| | | * @param call_log #LinphoneCallLog object @notnil |
|---|
| | | * @return The call ID used by the call as a string. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_call_log_get_call_id(const LinphoneCallLog *cl); |
|---|
| | | LINPHONE_PUBLIC const char * linphone_call_log_get_call_id(const LinphoneCallLog *call_log); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the direction of the call. |
|---|
| | | * @param[in] cl #LinphoneCallLog object |
|---|
| | | * @return The direction of the call. |
|---|
| | | * @param call_log #LinphoneCallLog object @notnil |
|---|
| | | * @return The #LinphoneCallDir of the call. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneCallDir linphone_call_log_get_dir(const LinphoneCallLog *cl); |
|---|
| | | LINPHONE_PUBLIC LinphoneCallDir linphone_call_log_get_dir(const LinphoneCallLog *call_log); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the duration of the call since connected. |
|---|
| | | * @param[in] cl #LinphoneCallLog object |
|---|
| | | * @param call_log #LinphoneCallLog object @notnil |
|---|
| | | * @return The duration of the call in seconds. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC int linphone_call_log_get_duration(const LinphoneCallLog *cl); |
|---|
| | | LINPHONE_PUBLIC int linphone_call_log_get_duration(const LinphoneCallLog *call_log); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the origin address (ie from) of the call. |
|---|
| | | * @param[in] cl #LinphoneCallLog object |
|---|
| | | * @return The origin address (ie from) of the call. |
|---|
| | | * @param call_log #LinphoneCallLog object @notnil |
|---|
| | | * @return The origin #LinphoneAddress (ie from) of the call. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress * linphone_call_log_get_from_address(const LinphoneCallLog *cl); |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress * linphone_call_log_get_from_address(const LinphoneCallLog *call_log); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the RTP statistics computed locally regarding the call. |
|---|
| | | * @param[in] cl #LinphoneCallLog object |
|---|
| | | * @param call_log #LinphoneCallLog object @notnil |
|---|
| | | * @return The RTP statistics that have been computed locally for the call. |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const rtp_stats_t * linphone_call_log_get_local_stats(const LinphoneCallLog *cl); |
|---|
| | | LINPHONE_PUBLIC const rtp_stats_t * linphone_call_log_get_local_stats(const LinphoneCallLog *call_log); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the overall quality indication of the call. |
|---|
| | | * @param[in] cl #LinphoneCallLog object |
|---|
| | | * @param call_log #LinphoneCallLog object @notnil |
|---|
| | | * @return The overall quality indication of the call. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC float linphone_call_log_get_quality(const LinphoneCallLog *cl); |
|---|
| | | LINPHONE_PUBLIC float linphone_call_log_get_quality(const LinphoneCallLog *call_log); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the persistent reference key associated to the call log. |
|---|
| | |
|---|
| | | * The reference key can be for example an id to an external database. |
|---|
| | | * It is stored in the config file, thus can survive to process exits/restarts. |
|---|
| | | * |
|---|
| | | * @param[in] cl #LinphoneCallLog object |
|---|
| | | * @return The reference key string that has been associated to the call log, or NULL if none has been associated. |
|---|
| | | * @param call_log #LinphoneCallLog object @notnil |
|---|
| | | * @return The reference key string that has been associated to the call log, or NULL if none has been associated. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_call_log_get_ref_key(const LinphoneCallLog *cl); |
|---|
| | | LINPHONE_PUBLIC const char * linphone_call_log_get_ref_key(const LinphoneCallLog *call_log); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the local address (that is from or to depending on call direction) |
|---|
| | | * @param[in] cl LinphoneCallLog object |
|---|
| | | * @return The local address of the call |
|---|
| | | * @param call_log LinphoneCallLog object @notnil |
|---|
| | | * @return The local #LinphoneAddress of the call @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress *linphone_call_log_get_local_address(const LinphoneCallLog *cl); |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress *linphone_call_log_get_local_address(const LinphoneCallLog *call_log); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the remote address (that is from or to depending on call direction). |
|---|
| | | * @param[in] cl #LinphoneCallLog object |
|---|
| | | * @return The remote address of the call. |
|---|
| | | * @param call_log #LinphoneCallLog object @notnil |
|---|
| | | * @return The remote #LinphoneAddress of the call. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress * linphone_call_log_get_remote_address(const LinphoneCallLog *cl); |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress * linphone_call_log_get_remote_address(const LinphoneCallLog *call_log); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the RTP statistics computed by the remote end and sent back via RTCP. |
|---|
| | | * @note Not implemented yet. |
|---|
| | | * @param[in] cl #LinphoneCallLog object |
|---|
| | | * @param call_log #LinphoneCallLog object @notnil |
|---|
| | | * @return The RTP statistics that have been computed by the remote end for the call. |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const rtp_stats_t * linphone_call_log_get_remote_stats(const LinphoneCallLog *cl); |
|---|
| | | LINPHONE_PUBLIC const rtp_stats_t * linphone_call_log_get_remote_stats(const LinphoneCallLog *call_log); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the start date of the call. |
|---|
| | | * @param[in] cl #LinphoneCallLog object |
|---|
| | | * @param call_log #LinphoneCallLog object @notnil |
|---|
| | | * @return The date of the beginning of the call. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC time_t linphone_call_log_get_start_date(const LinphoneCallLog *cl); |
|---|
| | | LINPHONE_PUBLIC time_t linphone_call_log_get_start_date(const LinphoneCallLog *call_log); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the status of the call. |
|---|
| | | * @param[in] cl #LinphoneCallLog object |
|---|
| | | * @return The status of the call. |
|---|
| | | * @param call_log #LinphoneCallLog object @notnil |
|---|
| | | * @return The #LinphoneCallStatus of the call. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneCallStatus linphone_call_log_get_status(const LinphoneCallLog *cl); |
|---|
| | | LINPHONE_PUBLIC LinphoneCallStatus linphone_call_log_get_status(const LinphoneCallLog *call_log); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the destination address (ie to) of the call. |
|---|
| | | * @param[in] cl #LinphoneCallLog object |
|---|
| | | * @return The destination address (ie to) of the call. |
|---|
| | | * @param call_log #LinphoneCallLog object @notnil |
|---|
| | | * @return The destination #LinphoneAddress (ie to) of the call. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress * linphone_call_log_get_to_address(const LinphoneCallLog *cl); |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress * linphone_call_log_get_to_address(const LinphoneCallLog *call_log); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Associate a persistent reference key to the call log. |
|---|
| | |
|---|
| | | * The reference key can be for example an id to an external database. |
|---|
| | | * It is stored in the config file, thus can survive to process exits/restarts. |
|---|
| | | * |
|---|
| | | * @param[in] cl #LinphoneCallLog object |
|---|
| | | * @param[in] refkey The reference key string to associate to the call log. |
|---|
| | | * @param call_log #LinphoneCallLog object @notnil |
|---|
| | | * @param refkey The reference key string to associate to the call log. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_log_set_ref_key(LinphoneCallLog *cl, const char *refkey); |
|---|
| | | LINPHONE_PUBLIC void linphone_call_log_set_ref_key(LinphoneCallLog *call_log, const char *refkey); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Tell whether video was enabled at the end of the call or not. |
|---|
| | | * @param[in] cl #LinphoneCallLog object |
|---|
| | | * @param call_log #LinphoneCallLog object @notnil |
|---|
| | | * @return A boolean value telling whether video was enabled at the end of the call. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_call_log_video_enabled(const LinphoneCallLog *cl); |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_call_log_video_enabled(const LinphoneCallLog *call_log); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get a human readable string describing the call. |
|---|
| | | * @note: the returned string must be freed by the application (use ms_free()). |
|---|
| | | * @param[in] cl #LinphoneCallLog object |
|---|
| | | * @return A human readable string describing the call. |
|---|
| | | * @param call_log #LinphoneCallLog object @notnil |
|---|
| | | * @return A human readable string describing the call. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC char * linphone_call_log_to_str(const LinphoneCallLog *cl); |
|---|
| | | LINPHONE_PUBLIC char * linphone_call_log_to_str(const LinphoneCallLog *call_log); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Tells whether that call was a call to a conference server |
|---|
| | | * @param[in] cl #LinphoneCallLog object |
|---|
| | | * @return TRUE if the call was a call to a conference server |
|---|
| | | * @param call_log #LinphoneCallLog object @notnil |
|---|
| | | * @return TRUE if the call was a call to a conference server, FALSE otherwise. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_call_log_was_conference(const LinphoneCallLog *cl); |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_call_log_was_conference(const LinphoneCallLog *call_log); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * When the call was failed, return an object describing the failure. |
|---|
| | | * @param[in] cl #LinphoneCallLog object |
|---|
| | | * @return information about the error encountered by the call associated with this call log. |
|---|
| | | * @param call_log #LinphoneCallLog object @notnil |
|---|
| | | * @return #LinphoneErrorInfo about the error encountered by the call associated with this call log or NULL. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const LinphoneErrorInfo *linphone_call_log_get_error_info(const LinphoneCallLog *cl); |
|---|
| | | LINPHONE_PUBLIC const LinphoneErrorInfo *linphone_call_log_get_error_info(const LinphoneCallLog *call_log); |
|---|
| | | |
|---|
| | | |
|---|
| | | /******************************************************************************* |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the user data associated with the call log. |
|---|
| | | * @param[in] cl #LinphoneCallLog object |
|---|
| | | * @return The user data associated with the call log. |
|---|
| | | * @param call_log #LinphoneCallLog object @notnil |
|---|
| | | * @return The user data associated with the call log. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void *linphone_call_log_get_user_data(const LinphoneCallLog *cl); |
|---|
| | | LINPHONE_PUBLIC void *linphone_call_log_get_user_data(const LinphoneCallLog *call_log); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user data to the call log. |
|---|
| | | * @param[in] cl #LinphoneCallLog object |
|---|
| | | * @param[in] ud The user data to associate with the call log. |
|---|
| | | * @param call_log #LinphoneCallLog object @notnil |
|---|
| | | * @param user_data The user data to associate with the call log. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_log_set_user_data(LinphoneCallLog *cl, void *ud); |
|---|
| | | LINPHONE_PUBLIC void linphone_call_log_set_user_data(LinphoneCallLog *call_log, void *user_data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Acquire a reference to the call log. |
|---|
| | | * @param[in] cl #LinphoneCallLog object |
|---|
| | | * @return The same #LinphoneCallLog object |
|---|
| | | * @param call_log #LinphoneCallLog object @notnil |
|---|
| | | * @return The same #LinphoneCallLog object @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneCallLog * linphone_call_log_ref(LinphoneCallLog *cl); |
|---|
| | | LINPHONE_PUBLIC LinphoneCallLog * linphone_call_log_ref(LinphoneCallLog *call_log); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Release a reference to the call log. |
|---|
| | | * @param[in] cl #LinphoneCallLog object |
|---|
| | | * @param call_log #LinphoneCallLog object @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_log_unref(LinphoneCallLog *cl); |
|---|
| | | LINPHONE_PUBLIC void linphone_call_log_unref(LinphoneCallLog *call_log); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates a fake LinphoneCallLog. |
|---|
| | | * @param[in] lc LinphoneCore object |
|---|
| | | * @param[in] from LinphoneAddress of caller |
|---|
| | | * @param[in] to LinphoneAddress of callee |
|---|
| | | * @param[in] dir LinphoneCallDir of call |
|---|
| | | * @param[in] duration call length in seconds |
|---|
| | | * @param[in] start_time timestamp of call start time |
|---|
| | | * @param[in] connected_time timestamp of call connection |
|---|
| | | * @param[in] status LinphoneCallStatus of call |
|---|
| | | * @param[in] video_enabled whether video was enabled or not for this call |
|---|
| | | * @param[in] quality call quality |
|---|
| | | * @return LinphoneCallLog object |
|---|
| | | * Creates a fake #LinphoneCallLog. |
|---|
| | | * @param core #LinphoneCore object @notnil |
|---|
| | | * @param from #LinphoneAddress of caller @notnil |
|---|
| | | * @param to #LinphoneAddress of callee @notnil |
|---|
| | | * @param dir #LinphoneCallDir of call |
|---|
| | | * @param duration call length in seconds |
|---|
| | | * @param start_time timestamp of call start time |
|---|
| | | * @param connected_time timestamp of call connection |
|---|
| | | * @param status #LinphoneCallStatus of call |
|---|
| | | * @param video_enabled whether video was enabled or not for this call |
|---|
| | | * @param quality call quality |
|---|
| | | * @return a #LinphoneCallLog object @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneCallLog *linphone_core_create_call_log(LinphoneCore *lc, LinphoneAddress *from, LinphoneAddress *to, LinphoneCallDir dir, |
|---|
| | | LINPHONE_PUBLIC LinphoneCallLog *linphone_core_create_call_log(LinphoneCore *core, LinphoneAddress *from, LinphoneAddress *to, LinphoneCallDir dir, |
|---|
| | | int duration, time_t start_time, time_t connected_time, LinphoneCallStatus status, bool_t video_enabled, float quality); |
|---|
| | | |
|---|
| | | |
|---|
| | | /******************************************************************************* |
|---|
| | | * DEPRECATED * |
|---|
| | | ******************************************************************************/ |
|---|
| | | |
|---|
| | | /** @deprecated Use linphone_call_log_get_from_address() instead. */ |
|---|
| | | #define linphone_call_log_get_from(cl) linphone_call_log_get_from_address(cl) |
|---|
| | | |
|---|
| | | /** @deprecated Use linphone_call_log_get_to_address() instead. */ |
|---|
| | | #define linphone_call_log_get_to(cl) linphone_call_log_get_to_address(cl) |
|---|
| | | |
|---|
| | | /** @deprecated Use linphone_call_log_set_user_data() instead. */ |
|---|
| | | #define linphone_call_log_set_user_pointer(cl, ud) linphone_call_log_set_user_data(cl, ud) |
|---|
| | | |
|---|
| | | /** @deprecated Use linphone_call_log_get_user_data() instead. */ |
|---|
| | | #define linphone_call_log_get_user_pointer(cl) linphone_call_log_get_user_data(cl) |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Destroy a LinphoneCallLog. |
|---|
| | | * @param cl #LinphoneCallLog object |
|---|
| | | * @deprecated Use linphone_call_log_unref() instead. |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED void linphone_call_log_destroy(LinphoneCallLog *cl); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @} |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Add a custom SIP header in the INVITE for a call. |
|---|
| | | * @param[in] cp The #LinphoneCallParams to add a custom SIP header to. |
|---|
| | | * @param[in] header_name The name of the header to add. |
|---|
| | | * @param[in] header_value The content of the header to add. |
|---|
| | | * @param call_params The #LinphoneCallParams to add a custom SIP header to. @notnil |
|---|
| | | * @param header_name The name of the header to add. @notnil |
|---|
| | | * @param header_value The content of the header to add. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_params_add_custom_header(LinphoneCallParams *cp, const char *header_name, const char *header_value); |
|---|
| | | LINPHONE_PUBLIC void linphone_call_params_add_custom_header(LinphoneCallParams *call_params, const char *header_name, const char *header_value); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Copy an existing #LinphoneCallParams object to a new #LinphoneCallParams object. |
|---|
| | | * @param[in] cp The #LinphoneCallParams object to copy. |
|---|
| | | * @return A copy of the #LinphoneCallParams object. |
|---|
| | | * @param call_params The #LinphoneCallParams object to copy. @notnil |
|---|
| | | * @return A copy of the #LinphoneCallParams object. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneCallParams * linphone_call_params_copy(const LinphoneCallParams *cp); |
|---|
| | | LINPHONE_PUBLIC LinphoneCallParams * linphone_call_params_copy(const LinphoneCallParams *call_params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Indicate whether sending of early media was enabled. |
|---|
| | | * @param[in] cp #LinphoneCallParams object |
|---|
| | | * @param call_params #LinphoneCallParams object @notnil |
|---|
| | | * @return A boolean value telling whether sending of early media was enabled. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_call_params_early_media_sending_enabled(const LinphoneCallParams *cp); |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_call_params_early_media_sending_enabled(const LinphoneCallParams *call_params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Enable sending of real early media (during outgoing calls). |
|---|
| | | * @param[in] cp #LinphoneCallParams object |
|---|
| | | * @param[in] enabled A boolean value telling whether to enable early media sending or not. |
|---|
| | | * @param call_params #LinphoneCallParams object @notnil |
|---|
| | | * @param enabled A boolean value telling whether to enable early media sending or not. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_params_enable_early_media_sending(LinphoneCallParams *cp, bool_t enabled); |
|---|
| | | LINPHONE_PUBLIC void linphone_call_params_enable_early_media_sending(LinphoneCallParams *call_params, bool_t enabled); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Indicate low bandwith mode. |
|---|
| | | * Configuring a call to low bandwidth mode will result in the core to activate several settings for the call in order to ensure that bitrate usage |
|---|
| | | * is lowered to the minimum possible. Typically, ptime (packetization time) will be increased, audio codec's output bitrate will be targetted to 20kbit/s provided |
|---|
| | | * that it is achievable by the codec selected after SDP handshake. Video is automatically disabled. |
|---|
| | | * @param[in] cp #LinphoneCallParams object |
|---|
| | | * @param[in] enabled A boolean value telling whether to activate the low bandwidth mode or not. |
|---|
| | | * @param call_params #LinphoneCallParams object @notnil |
|---|
| | | * @param enabled A boolean value telling whether to activate the low bandwidth mode or not. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_params_enable_low_bandwidth(LinphoneCallParams *cp, bool_t enabled); |
|---|
| | | LINPHONE_PUBLIC void linphone_call_params_enable_low_bandwidth(LinphoneCallParams *call_params, bool_t enabled); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Enable audio stream. |
|---|
| | | * @param[in] cp #LinphoneCallParams object |
|---|
| | | * @param[in] enabled A boolean value telling whether to enable audio or not. |
|---|
| | | * @param call_params #LinphoneCallParams object @notnil |
|---|
| | | * @param enabled A boolean value telling whether to enable audio or not. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_params_enable_audio(LinphoneCallParams *cp, bool_t enabled); |
|---|
| | | LINPHONE_PUBLIC void linphone_call_params_enable_audio(LinphoneCallParams *call_params, bool_t enabled); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Enable video stream. |
|---|
| | | * @param[in] cp #LinphoneCallParams object |
|---|
| | | * @param[in] enabled A boolean value telling whether to enable video or not. |
|---|
| | | * @param call_params #LinphoneCallParams object @notnil |
|---|
| | | * @param enabled A boolean value telling whether to enable video or not. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_params_enable_video(LinphoneCallParams *cp, bool_t enabled); |
|---|
| | | LINPHONE_PUBLIC void linphone_call_params_enable_video(LinphoneCallParams *call_params, bool_t enabled); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get a custom SIP header. |
|---|
| | | * @param[in] cp The #LinphoneCallParams to get the custom SIP header from. |
|---|
| | | * @param[in] header_name The name of the header to get. |
|---|
| | | * @return The content of the header or NULL if not found. |
|---|
| | | * @param call_params The #LinphoneCallParams to get the custom SIP header from. @notnil |
|---|
| | | * @param header_name The name of the header to get. @notnil |
|---|
| | | * @return The content of the header or NULL if not found. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_call_params_get_custom_header(const LinphoneCallParams *cp, const char *header_name); |
|---|
| | | LINPHONE_PUBLIC const char *linphone_call_params_get_custom_header(const LinphoneCallParams *call_params, const char *header_name); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Tell whether the call is part of the locally managed conference. |
|---|
| | |
|---|
| | | * that function does not return TRUE even if the conference is running.<br/> |
|---|
| | | * If you want to test whether the conference is running, you should test |
|---|
| | | * whether linphone_core_get_conference() return a non-null pointer. |
|---|
| | | * @param[in] cp #LinphoneCallParams object |
|---|
| | | * @param call_params #LinphoneCallParams object @notnil |
|---|
| | | * @return A boolean value telling whether the call is part of the locally managed conference. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_call_params_get_local_conference_mode(const LinphoneCallParams *cp); |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_call_params_get_local_conference_mode(const LinphoneCallParams *call_params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the kind of media encryption selected for the call. |
|---|
| | | * @param[in] cp #LinphoneCallParams object |
|---|
| | | * @return The kind of media encryption selected for the call. |
|---|
| | | * @param call_params #LinphoneCallParams object @notnil |
|---|
| | | * @return The kind of #LinphoneMediaEncryption selected for the call. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneMediaEncryption linphone_call_params_get_media_encryption(const LinphoneCallParams *cp); |
|---|
| | | LINPHONE_PUBLIC LinphoneMediaEncryption linphone_call_params_get_media_encryption(const LinphoneCallParams *call_params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get requested level of privacy for the call. |
|---|
| | | * @param[in] cp #LinphoneCallParams object |
|---|
| | | * @return The privacy mode used for the call. |
|---|
| | | * @param call_params #LinphoneCallParams object @notnil |
|---|
| | | * @return The #LinphonePrivacyMask used for the call. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphonePrivacyMask linphone_call_params_get_privacy(const LinphoneCallParams *cp); |
|---|
| | | LINPHONE_PUBLIC LinphonePrivacyMask linphone_call_params_get_privacy(const LinphoneCallParams *call_params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the framerate of the video that is received. |
|---|
| | | * @param[in] cp #LinphoneCallParams object |
|---|
| | | * @param call_params #LinphoneCallParams object @notnil |
|---|
| | | * @return The actual received framerate in frames per seconds, 0 if not available. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC float linphone_call_params_get_received_framerate(const LinphoneCallParams *cp); |
|---|
| | | LINPHONE_PUBLIC float linphone_call_params_get_received_framerate(const LinphoneCallParams *call_params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the definition of the received video. |
|---|
| | | * @param[in] cp #LinphoneCallParams object |
|---|
| | | * @return The received #LinphoneVideoDefinition |
|---|
| | | * @param call_params #LinphoneCallParams object @notnil |
|---|
| | | * @return The received #LinphoneVideoDefinition or NULL. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const LinphoneVideoDefinition * linphone_call_params_get_received_video_definition(const LinphoneCallParams *cp); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Get the size of the video that is received. |
|---|
| | | * @param[in] cp #LinphoneCallParams object |
|---|
| | | * @return The received video size or MS_VIDEO_SIZE_UNKNOWN if not available. |
|---|
| | | * @deprecated Use #linphone_call_params_get_received_video_definition() instead. Deprecated since 2017-03-28. |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED MSVideoSize linphone_call_params_get_received_video_size(const LinphoneCallParams *cp); |
|---|
| | | LINPHONE_PUBLIC const LinphoneVideoDefinition * linphone_call_params_get_received_video_definition(const LinphoneCallParams *call_params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the path for the audio recording of the call. |
|---|
| | | * @param[in] cp #LinphoneCallParams object |
|---|
| | | * @return The path to the audio recording of the call. |
|---|
| | | * @param call_params #LinphoneCallParams object @notnil |
|---|
| | | * @return The path to the audio recording of the call or NULL. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_call_params_get_record_file(const LinphoneCallParams *cp); |
|---|
| | | LINPHONE_PUBLIC const char *linphone_call_params_get_record_file(const LinphoneCallParams *call_params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the RTP profile being used. |
|---|
| | | * @param[in] cp #LinphoneCallParams object |
|---|
| | | * @return The RTP profile. |
|---|
| | | * @param call_params #LinphoneCallParams object @notnil |
|---|
| | | * @return The RTP profile. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_call_params_get_rtp_profile(const LinphoneCallParams *cp); |
|---|
| | | LINPHONE_PUBLIC const char * linphone_call_params_get_rtp_profile(const LinphoneCallParams *call_params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the framerate of the video that is sent. |
|---|
| | | * @param[in] cp #LinphoneCallParams object |
|---|
| | | * @param call_params #LinphoneCallParams object @notnil |
|---|
| | | * @return The actual sent framerate in frames per seconds, 0 if not available. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC float linphone_call_params_get_sent_framerate(const LinphoneCallParams *cp); |
|---|
| | | LINPHONE_PUBLIC float linphone_call_params_get_sent_framerate(const LinphoneCallParams *call_params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the definition of the sent video. |
|---|
| | | * @param[in] cp #LinphoneCallParams object |
|---|
| | | * @return The sent #LinphoneVideoDefinition |
|---|
| | | * @param call_params #LinphoneCallParams object @notnil |
|---|
| | | * @return The sent #LinphoneVideoDefinition or NULL. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const LinphoneVideoDefinition * linphone_call_params_get_sent_video_definition(const LinphoneCallParams *cp); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Gets the size of the video that is sent. |
|---|
| | | * @param[in] cp #LinphoneCalParams object |
|---|
| | | * @return The sent video size or MS_VIDEO_SIZE_UNKNOWN if not available. |
|---|
| | | * @deprecated Use #linphone_call_params_get_sent_video_definition() instead. Deprecated since 2017-03-28. |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED MSVideoSize linphone_call_params_get_sent_video_size(const LinphoneCallParams *cp); |
|---|
| | | LINPHONE_PUBLIC const LinphoneVideoDefinition * linphone_call_params_get_sent_video_definition(const LinphoneCallParams *call_params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the session name of the media session (ie in SDP). |
|---|
| | | * Subject from the SIP message can be retrieved using linphone_call_params_get_custom_header() and is different. |
|---|
| | | * @param[in] cp #LinphoneCallParams object |
|---|
| | | * @return The session name of the media session. |
|---|
| | | * @param call_params #LinphoneCallParams object @notnil |
|---|
| | | * @return The session name of the media session or NULL. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_call_params_get_session_name(const LinphoneCallParams *cp); |
|---|
| | | LINPHONE_PUBLIC const char *linphone_call_params_get_session_name(const LinphoneCallParams *call_params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the audio payload type that has been selected by a call. |
|---|
| | | * @param[in] cp The call. |
|---|
| | | * @return The selected payload type. NULL is returned if no audio payload type has been seleced |
|---|
| | | * by the call. |
|---|
| | | * @param call_params The #LinphoneCallParams object. @notnil |
|---|
| | | * @return The selected #LinphonePayloadType. NULL is returned if no audio payload type has been selected by the call. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphonePayloadType *linphone_call_params_get_used_audio_payload_type(const LinphoneCallParams *cp); |
|---|
| | | LINPHONE_PUBLIC LinphonePayloadType *linphone_call_params_get_used_audio_payload_type(const LinphoneCallParams *call_params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the video payload type that has been selected by a call. |
|---|
| | | * @param[in] cp The call. |
|---|
| | | * @return The selected payload type. NULL is returned if no video payload type has been seleced |
|---|
| | | * by the call. |
|---|
| | | * @param call_params The #LinphoneCallParams object. @notnil |
|---|
| | | * @return The selected #LinphonePayloadType. NULL is returned if no video payload type has been selected by the call. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphonePayloadType *linphone_call_params_get_used_video_payload_type(const LinphoneCallParams *cp); |
|---|
| | | LINPHONE_PUBLIC LinphonePayloadType *linphone_call_params_get_used_video_payload_type(const LinphoneCallParams *call_params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the text payload type that has been selected by a call. |
|---|
| | | * @param[in] cp The call. |
|---|
| | | * @return The selected payload type. NULL is returned if no text payload type has been seleced |
|---|
| | | * by the call. |
|---|
| | | * @param call_params The #LinphoneCallParams object. @notnil |
|---|
| | | * @return The selected #LinphonePayloadType. NULL is returned if no text payload type has been selected by the call. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphonePayloadType *linphone_call_params_get_used_text_payload_type(const LinphoneCallParams *cp); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the audio payload type that has been selected by a call. |
|---|
| | | * @param[in] cp The call. |
|---|
| | | * @return The selected payload type. NULL is returned if no audio payload type has been seleced by the call. |
|---|
| | | * @deprecated Use linphone_call_params_get_used_audio_payload_type() instead. |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED const OrtpPayloadType *linphone_call_params_get_used_audio_codec(const LinphoneCallParams *cp); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the video payload type that has been selected by a call. |
|---|
| | | * @param[in] cp The call. |
|---|
| | | * @return The selected payload type. NULL is returned if no video payload type has been seleced by the call. |
|---|
| | | * @deprecated Use linphone_call_params_get_used_video_payload_type() instead. |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED const OrtpPayloadType *linphone_call_params_get_used_video_codec(const LinphoneCallParams *cp); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the text payload type that has been selected by a call. |
|---|
| | | * @param[in] cp The call. |
|---|
| | | * @return The selected payload type. NULL is returned if no text payload type has been seleced by the call. |
|---|
| | | * @deprecated Use linphone_call_params_get_used_text_payload_type() instead. |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED const OrtpPayloadType *linphone_call_params_get_used_text_codec(const LinphoneCallParams *cp); |
|---|
| | | LINPHONE_PUBLIC LinphonePayloadType *linphone_call_params_get_used_text_payload_type(const LinphoneCallParams *call_params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Tell whether the call has been configured in low bandwidth mode or not. |
|---|
| | |
|---|
| | | * An application that would have reliable way to know network capacity may not use activate_edge_workarounds=1 but instead manually configure |
|---|
| | | * low bandwidth mode with linphone_call_params_enable_low_bandwidth(). |
|---|
| | | * When enabled, this param may transform a call request with video in audio only mode. |
|---|
| | | * @param[in] cp #LinphoneCallParams object |
|---|
| | | * @param call_params #LinphoneCallParams object @notnil |
|---|
| | | * @return A boolean value telling whether the low bandwidth mode has been configured/detected. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_call_params_low_bandwidth_enabled(const LinphoneCallParams *cp); |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_call_params_low_bandwidth_enabled(const LinphoneCallParams *call_params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Refine bandwidth settings for this call by setting a bandwidth limit for audio streams. |
|---|
| | | * As a consequence, codecs whose bitrates are not compatible with this limit won't be used. |
|---|
| | | * @param[in] cp #LinphoneCallParams object |
|---|
| | | * @param[in] bw The audio bandwidth limit to set in kbit/s. |
|---|
| | | * @param call_params #LinphoneCallParams object @notnil |
|---|
| | | * @param bandwidth The audio bandwidth limit to set in kbit/s. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_params_set_audio_bandwidth_limit(LinphoneCallParams *cp, int bw); |
|---|
| | | LINPHONE_PUBLIC void linphone_call_params_set_audio_bandwidth_limit(LinphoneCallParams *call_params, int bandwidth); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set requested media encryption for a call. |
|---|
| | | * @param[in] cp #LinphoneCallParams object |
|---|
| | | * @param[in] enc The media encryption to use for the call. |
|---|
| | | * @param call_params #LinphoneCallParams object @notnil |
|---|
| | | * @param encryption The #LinphoneMediaEncryption to use for the call. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_params_set_media_encryption(LinphoneCallParams *cp, LinphoneMediaEncryption enc); |
|---|
| | | LINPHONE_PUBLIC void linphone_call_params_set_media_encryption(LinphoneCallParams *call_params, LinphoneMediaEncryption encryption); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set requested level of privacy for the call. |
|---|
| | | * \xmlonly <language-tags>javascript</language-tags> \endxmlonly |
|---|
| | | * @param[in] cp #LinphoneCallParams object |
|---|
| | | * @param[in] privacy The privacy mode to used for the call. |
|---|
| | | * @param call_params #LinphoneCallParams object @notnil |
|---|
| | | * @param privacy The #LinphonePrivacyMask to used for the call. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_params_set_privacy(LinphoneCallParams *cp, LinphonePrivacyMask privacy); |
|---|
| | | LINPHONE_PUBLIC void linphone_call_params_set_privacy(LinphoneCallParams *call_params, LinphonePrivacyMask privacy); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Enable recording of the call. |
|---|
| | | * This function must be used before the call parameters are assigned to the call. |
|---|
| | | * The call recording can be started and paused after the call is established with |
|---|
| | | * linphone_call_start_recording() and linphone_call_pause_recording(). |
|---|
| | | * @param[in] cp #LinphoneCallParams object |
|---|
| | | * @param[in] path A string containing the path and filename of the file where audio/video streams are to be written. |
|---|
| | | * The filename must have either .mkv or .wav extention. The video stream will be written only if a MKV file is given. |
|---|
| | | * @param call_params #LinphoneCallParams object @notnil |
|---|
| | | * @param path A string containing the path and filename of the file where audio/video streams are to be written. |
|---|
| | | * The filename must have either .mkv or .wav extention. The video stream will be written only if a MKV file is given. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_params_set_record_file(LinphoneCallParams *cp, const char *path); |
|---|
| | | LINPHONE_PUBLIC void linphone_call_params_set_record_file(LinphoneCallParams *call_params, const char *path); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the session name of the media session (ie in SDP). |
|---|
| | | * Subject from the SIP message (which is different) can be set using linphone_call_params_set_custom_header(). |
|---|
| | | * @param[in] cp #LinphoneCallParams object |
|---|
| | | * @param[in] name The session name to be used. |
|---|
| | | * @param call_params #LinphoneCallParams object @notnil |
|---|
| | | * @param name The session name to be used. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_params_set_session_name(LinphoneCallParams *cp, const char *name); |
|---|
| | | LINPHONE_PUBLIC void linphone_call_params_set_session_name(LinphoneCallParams *call_params, const char *name); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Tell whether audio is enabled or not. |
|---|
| | | * @param[in] cp #LinphoneCallParams object |
|---|
| | | * @param call_params #LinphoneCallParams object @notnil |
|---|
| | | * @return A boolean value telling whether audio is enabled or not. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_call_params_audio_enabled(const LinphoneCallParams *cp); |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_call_params_audio_enabled(const LinphoneCallParams *call_params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Tell whether video is enabled or not. |
|---|
| | | * @param[in] cp #LinphoneCallParams object |
|---|
| | | * @param call_params #LinphoneCallParams object @notnil |
|---|
| | | * @return A boolean value telling whether video is enabled or not. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_call_params_video_enabled(const LinphoneCallParams *cp); |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_call_params_video_enabled(const LinphoneCallParams *call_params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the audio stream direction. |
|---|
| | | * @param[in] cp #LinphoneCallParams object |
|---|
| | | * @return The audio stream direction associated with the call params. |
|---|
| | | * @param call_params #LinphoneCallParams object @notnil |
|---|
| | | * @return The audio stream #LinphoneMediaDirection associated with the call params. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneMediaDirection linphone_call_params_get_audio_direction(const LinphoneCallParams *cp); |
|---|
| | | LINPHONE_PUBLIC LinphoneMediaDirection linphone_call_params_get_audio_direction(const LinphoneCallParams *call_params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the video stream direction. |
|---|
| | | * @param[in] cp #LinphoneCallParams object |
|---|
| | | * @return The video stream direction associated with the call params. |
|---|
| | | * @param call_params #LinphoneCallParams object @notnil |
|---|
| | | * @return The video stream #LinphoneMediaDirection associated with the call params. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneMediaDirection linphone_call_params_get_video_direction(const LinphoneCallParams *cp); |
|---|
| | | LINPHONE_PUBLIC LinphoneMediaDirection linphone_call_params_get_video_direction(const LinphoneCallParams *call_params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the audio stream direction. |
|---|
| | | * @param[in] cp #LinphoneCallParams object |
|---|
| | | * @param[in] dir The audio stream direction associated with this call params. |
|---|
| | | * @param call_params #LinphoneCallParams object @notnil |
|---|
| | | * @param direction The audio stream #LinphoneMediaDirection associated with this call params. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_params_set_audio_direction(LinphoneCallParams *cp, LinphoneMediaDirection dir); |
|---|
| | | LINPHONE_PUBLIC void linphone_call_params_set_audio_direction(LinphoneCallParams *call_params, LinphoneMediaDirection direction); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the video stream direction. |
|---|
| | | * @param[in] cp #LinphoneCallParams object |
|---|
| | | * @param[in] dir The video stream direction associated with this call params. |
|---|
| | | * @param call_params #LinphoneCallParams object @notnil |
|---|
| | | * @param direction The video stream #LinphoneMediaDirection associated with this call params. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_params_set_video_direction(LinphoneCallParams *cp, LinphoneMediaDirection dir); |
|---|
| | | LINPHONE_PUBLIC void linphone_call_params_set_video_direction(LinphoneCallParams *call_params, LinphoneMediaDirection direction); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the #LinphoneProxyConfig to use for the call |
|---|
| | | * |
|---|
| | | * @param params the #LinphoneCallParams @notnil |
|---|
| | | * @param proxy_config The #LinphoneProxyConfig to use, or NULL if none has been selected. The #LinphoneCallParams keep a reference on it and remove the older if it exists. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_params_set_proxy_config(LinphoneCallParams *params, LinphoneProxyConfig *proxy_config); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the #LinphoneProxyConfig that is used for the call |
|---|
| | | * |
|---|
| | | * @param params the #LinphoneCallParams @notnil |
|---|
| | | * @return The selected #LinphoneProxyConfig for the call, or NULL if none has been selected. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneProxyConfig *linphone_call_params_get_proxy_config(const LinphoneCallParams *params); |
|---|
| | | |
|---|
| | | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the video stream direction. |
|---|
| | | * @param[in] params #LinphoneCallParams object |
|---|
| | | * @param[in] enable wether or not AVPF should be enabled for this call |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_params_enable_avpf(LinphoneCallParams *params, bool_t enable); |
|---|
| | | |
|---|
| | | int linphone_call_params_get_audio_bandwidth_limit(const LinphoneCallParams *params); |
|---|
| | | bool_t linphone_call_params_real_early_media_enabled(const LinphoneCallParams *params); |
|---|
| | | bool_t linphone_call_params_avpf_enabled(const LinphoneCallParams *params); |
|---|
| | | void linphone_call_params_enable_avpf(LinphoneCallParams *params, bool_t enable); |
|---|
| | | bool_t linphone_call_params_has_avpf_enabled_been_set(const LinphoneCallParams *params); |
|---|
| | | bool_t linphone_call_params_mandatory_media_encryption_enabled(const LinphoneCallParams *params); |
|---|
| | | void linphone_call_params_enable_mandatory_media_encryption(LinphoneCallParams *params, bool_t value); |
|---|
| | | uint16_t linphone_call_params_get_avpf_rr_interval(const LinphoneCallParams *params); |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the user data associated with the call params. |
|---|
| | | * @param[in] cp #LinphoneCallParams object |
|---|
| | | * @return The user data associated with the call params. |
|---|
| | | * @param call_params #LinphoneCallParams object @notnil |
|---|
| | | * @return The user data associated with the call params. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void *linphone_call_params_get_user_data(const LinphoneCallParams *cp); |
|---|
| | | LINPHONE_PUBLIC void *linphone_call_params_get_user_data(const LinphoneCallParams *call_params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user data to the call params. |
|---|
| | | * @param[in] cp #LinphoneCallParams object |
|---|
| | | * @param[in] ud The user data to associate with the call params. |
|---|
| | | * @param call_params #LinphoneCallParams object @notnil |
|---|
| | | * @param user_data The user data to associate with the call params. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_params_set_user_data(LinphoneCallParams *cp, void *ud); |
|---|
| | | LINPHONE_PUBLIC void linphone_call_params_set_user_data(LinphoneCallParams *call_params, void *user_data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Acquire a reference to the call params. |
|---|
| | | * @param[in] cp #LinphoneCallParams object |
|---|
| | | * @return The same #LinphoneCallParams object |
|---|
| | | * @param call_params #LinphoneCallParams object @notnil |
|---|
| | | * @return The same #LinphoneCallParams object @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneCallParams * linphone_call_params_ref(LinphoneCallParams *cp); |
|---|
| | | LINPHONE_PUBLIC LinphoneCallParams * linphone_call_params_ref(LinphoneCallParams *call_params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Release a reference to the call params. |
|---|
| | | * @param[in] cp #LinphoneCallParams object |
|---|
| | | * @param call_params #LinphoneCallParams object @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_params_unref(LinphoneCallParams *cp); |
|---|
| | | LINPHONE_PUBLIC void linphone_call_params_unref(LinphoneCallParams *call_params); |
|---|
| | | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Use to enable multicast rtp for audio stream. |
|---|
| | | * * If enabled, outgoing calls put a multicast address from #linphone_core_get_video_multicast_addr into audio cline. In case of outgoing call audio stream is sent to this multicast address. |
|---|
| | | * * If enabled, outgoing calls put a multicast address from #linphone_core_get_video_multicast_addr() into audio cline. In case of outgoing call audio stream is sent to this multicast address. |
|---|
| | | * <br> For incoming calls behavior is unchanged. |
|---|
| | | * @param params #LinphoneCallParams |
|---|
| | | * @param yesno if yes, subsequent calls will propose multicast ip set by #linphone_core_set_audio_multicast_addr |
|---|
| | | * @param params #LinphoneCallParams @notnil |
|---|
| | | * @param yesno if yes, subsequent calls will propose multicast ip set by #linphone_core_set_audio_multicast_addr() |
|---|
| | | * @ingroup media_parameters |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_params_enable_audio_multicast(LinphoneCallParams *params, bool_t yesno); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Use to get multicast state of audio stream. |
|---|
| | | * @param params #LinphoneCallParams |
|---|
| | | * @return true if subsequent calls will propose multicast ip set by #linphone_core_set_audio_multicast_addr |
|---|
| | | * @param params #LinphoneCallParams @notnil |
|---|
| | | * @return true if subsequent calls will propose multicast ip set by #linphone_core_set_audio_multicast_addr() |
|---|
| | | * @ingroup media_parameters |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_call_params_audio_multicast_enabled(const LinphoneCallParams *params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Use to enable multicast rtp for video stream. |
|---|
| | | * If enabled, outgoing calls put a multicast address from #linphone_core_get_video_multicast_addr into video cline. In case of outgoing call video stream is sent to this multicast address. |
|---|
| | | * If enabled, outgoing calls put a multicast address from #linphone_core_get_video_multicast_addr() into video cline. In case of outgoing call video stream is sent to this multicast address. |
|---|
| | | * <br> For incoming calls behavior is unchanged. |
|---|
| | | * @param params #LinphoneCallParams |
|---|
| | | * @param yesno if yes, subsequent outgoing calls will propose multicast ip set by #linphone_core_set_video_multicast_addr |
|---|
| | | * @param params #LinphoneCallParams @notnil |
|---|
| | | * @param yesno if yes, subsequent outgoing calls will propose multicast ip set by #linphone_core_set_video_multicast_addr() |
|---|
| | | * @ingroup media_parameters |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_params_enable_video_multicast(LinphoneCallParams *params, bool_t yesno); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Use to get multicast state of video stream. |
|---|
| | | * @param params #LinphoneCallParams |
|---|
| | | * @return true if subsequent calls will propose multicast ip set by #linphone_core_set_video_multicast_addr |
|---|
| | | * @param params #LinphoneCallParams @notnil |
|---|
| | | * @return true if subsequent calls will propose multicast ip set by #linphone_core_set_video_multicast_addr() |
|---|
| | | * @ingroup media_parameters |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_call_params_video_multicast_enabled(const LinphoneCallParams *params); |
|---|
| | |
|---|
| | | /** |
|---|
| | | * Use to enable real time text following rfc4103. |
|---|
| | | * If enabled, outgoing calls put a m=text line in SDP offer . |
|---|
| | | * @param params #LinphoneCallParams |
|---|
| | | * @param params #LinphoneCallParams @notnil |
|---|
| | | * @param yesno if yes, subsequent outgoing calls will propose rtt |
|---|
| | | * @return 0 |
|---|
| | | * @ingroup media_parameters |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_call_params_enable_realtime_text(LinphoneCallParams *params, bool_t yesno); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Use to get real time text following rfc4103. |
|---|
| | | * @param params #LinphoneCallParams |
|---|
| | | * @returns returns true if call rtt is activated. |
|---|
| | | * @param params #LinphoneCallParams @notnil |
|---|
| | | * @return returns true if call rtt is activated. |
|---|
| | | * @ingroup media_parameters |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_call_params_realtime_text_enabled(const LinphoneCallParams *params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Use to set keep alive interval for real time text following rfc4103. |
|---|
| | | * @param params #LinphoneCallParams @notnil |
|---|
| | | * @param interval The keep alive interval for real time text, 25000 by default. |
|---|
| | | * @ingroup media_parameters |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_params_set_realtime_text_keepalive_interval(LinphoneCallParams *params, unsigned int interval); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Use to get keep alive interval of real time text following rfc4103. |
|---|
| | | * @param params #LinphoneCallParams @notnil |
|---|
| | | * @return returns keep alive interval of real time text. |
|---|
| | | * @ingroup media_parameters |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC unsigned int linphone_call_params_get_realtime_text_keepalive_interval(const LinphoneCallParams *params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Add a custom attribute related to all the streams in the SDP exchanged within SIP messages during a call. |
|---|
| | | * @param[in] params The #LinphoneCallParams to add a custom SDP attribute to. |
|---|
| | | * @param[in] attribute_name The name of the attribute to add. |
|---|
| | | * @param[in] attribute_value The content value of the attribute to add. |
|---|
| | | * @param params The #LinphoneCallParams to add a custom SDP attribute to. @notnil |
|---|
| | | * @param attribute_name The name of the attribute to add. @notnil |
|---|
| | | * @param attribute_value The content value of the attribute to add. @maybenil |
|---|
| | | * @ingroup media_parameters |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_params_add_custom_sdp_attribute(LinphoneCallParams *params, const char *attribute_name, const char *attribute_value); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Add a custom attribute related to a specific stream in the SDP exchanged within SIP messages during a call. |
|---|
| | | * @param[in] params The #LinphoneCallParams to add a custom SDP attribute to. |
|---|
| | | * @param[in] type The type of the stream to add a custom SDP attribute to. |
|---|
| | | * @param[in] attribute_name The name of the attribute to add. |
|---|
| | | * @param[in] attribute_value The content value of the attribute to add. |
|---|
| | | * @param params The #LinphoneCallParams to add a custom SDP attribute to. @notnil |
|---|
| | | * @param type The type of the stream to add a custom SDP attribute to. |
|---|
| | | * @param attribute_name The name of the attribute to add. @notnil |
|---|
| | | * @param attribute_value The content value of the attribute to add. @maybenil |
|---|
| | | * @ingroup media_parameters |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_params_add_custom_sdp_media_attribute(LinphoneCallParams *params, LinphoneStreamType type, const char *attribute_name, const char *attribute_value); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get a custom SDP attribute that is related to all the streams. |
|---|
| | | * @param[in] params The #LinphoneCallParams to get the custom SDP attribute from. |
|---|
| | | * @param[in] attribute_name The name of the attribute to get. |
|---|
| | | * @return The content value of the attribute or NULL if not found. |
|---|
| | | * @param params The #LinphoneCallParams to get the custom SDP attribute from. @notnil |
|---|
| | | * @param attribute_name The name of the attribute to get. @notnil |
|---|
| | | * @return The content value of the attribute or NULL if not found. @maybenil |
|---|
| | | * @ingroup media_parameters |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_call_params_get_custom_sdp_attribute(const LinphoneCallParams *params, const char *attribute_name); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get a custom SDP attribute that is related to a specific stream. |
|---|
| | | * @param[in] params The #LinphoneCallParams to get the custom SDP attribute from. |
|---|
| | | * @param[in] type The type of the stream to add a custom SDP attribute to. |
|---|
| | | * @param[in] attribute_name The name of the attribute to get. |
|---|
| | | * @return The content value of the attribute or NULL if not found. |
|---|
| | | * @param params The #LinphoneCallParams to get the custom SDP attribute from. @notnil |
|---|
| | | * @param type The type of the stream to add a custom SDP attribute to. |
|---|
| | | * @param attribute_name The name of the attribute to get. @notnil |
|---|
| | | * @return The content value of the attribute or NULL if not found. @maybenil |
|---|
| | | * @ingroup media_parameters |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_call_params_get_custom_sdp_media_attribute(const LinphoneCallParams *params, LinphoneStreamType type, const char *attribute_name); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Clear the custom SDP attributes related to all the streams in the SDP exchanged within SIP messages during a call. |
|---|
| | | * @param[in] params The #LinphoneCallParams to clear the custom SDP attributes from. |
|---|
| | | * @param params The #LinphoneCallParams to clear the custom SDP attributes from. @notnil |
|---|
| | | * @ingroup media_parameters |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_params_clear_custom_sdp_attributes(LinphoneCallParams *params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Clear the custom SDP attributes related to a specific stream in the SDP exchanged within SIP messages during a call. |
|---|
| | | * @param[in] params The #LinphoneCallParams to clear the custom SDP attributes from. |
|---|
| | | * @param[in] type The type of the stream to clear the custom SDP attributes from. |
|---|
| | | * @param params The #LinphoneCallParams to clear the custom SDP attributes from. @notnil |
|---|
| | | * @param type The type of the stream to clear the custom SDP attributes from. |
|---|
| | | * @ingroup media_parameters |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_params_clear_custom_sdp_media_attributes(LinphoneCallParams *params, LinphoneStreamType type); |
|---|
| | | |
|---|
| | | |
|---|
| | | /******************************************************************************* |
|---|
| | | * DEPRECATED * |
|---|
| | | ******************************************************************************/ |
|---|
| | | |
|---|
| | | /** @deprecated Use linphone_call_params_get_local_conference_mode() instead. */ |
|---|
| | | #define linphone_call_params_local_conference_mode linphone_call_params_get_local_conference_mode |
|---|
| | | /** |
|---|
| | | * Gets a list of #LinphoneContent set if exists |
|---|
| | | * @param params The #LinphoneCallParams to get the custom Content from. @notnil |
|---|
| | | * @return A list of #LinphoneContent set if exists, NULL otherwise. \bctbx_list{LinphoneContent} @maybenil |
|---|
| | | * @ingroup media_parameters |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC bctbx_list_t* linphone_call_params_get_custom_contents (const LinphoneCallParams *params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Destroy a #LinphoneCallParams object. |
|---|
| | | * @param[in] cp #LinphoneCallParams object |
|---|
| | | * @deprecated Use linphone_call_params_unref() instead. |
|---|
| | | * Adds a #LinphoneContent to be added to the INVITE SDP. |
|---|
| | | * @param params The #LinphoneCallParams in which to set the custom #LinphoneContent. @notnil |
|---|
| | | * @param content The #LinphoneContent to be added. @notnil |
|---|
| | | * @ingroup media_parameters |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_params_add_custom_content (LinphoneCallParams *params, LinphoneContent *content); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Indicates whether RTP bundle mode (also known as Media Multiplexing) is enabled. |
|---|
| | | * See https://tools.ietf.org/html/draft-ietf-mmusic-sdp-bundle-negotiation-54 for more information. |
|---|
| | | * @param params the #LinphoneCallParams @notnil |
|---|
| | | * @return a boolean indicating the enablement of rtp bundle mode. |
|---|
| | | * @ingroup media_parameters |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_call_params_rtp_bundle_enabled(const LinphoneCallParams *params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Enables or disables RTP bundle mode (Media Multiplexing). |
|---|
| | | * See https://tools.ietf.org/html/draft-ietf-mmusic-sdp-bundle-negotiation-54 for more information about the feature. |
|---|
| | | * When enabled, liblinphone will try to negociate the use of a single port for all streams. |
|---|
| | | * It automatically enables rtcp-mux. |
|---|
| | | * @param params the #LinphoneCallParams @notnil |
|---|
| | | * @param value a boolean to indicate whether the feature is to be enabled. |
|---|
| | | * @ingroup media_parameters |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_call_params_enable_rtp_bundle(LinphoneCallParams *params, bool_t value); |
|---|
| | | |
|---|
| | | /************ */ |
|---|
| | | /* DEPRECATED */ |
|---|
| | | /* ********** */ |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Get the size of the video that is received. |
|---|
| | | * @param call_params #LinphoneCallParams object @notnil |
|---|
| | | * @return The received video size or MS_VIDEO_SIZE_UNKNOWN if not available. |
|---|
| | | * @deprecated 22/11/2017 Use #linphone_call_params_get_received_video_definition() instead. |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED MSVideoSize linphone_call_params_get_received_video_size(const LinphoneCallParams *call_params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Gets the size of the video that is sent. |
|---|
| | | * @param call_params #LinphoneCalParams object @notnil |
|---|
| | | * @return The sent video size or MS_VIDEO_SIZE_UNKNOWN if not available. |
|---|
| | | * @deprecated 22/11/2017 Use #linphone_call_params_get_sent_video_definition() instead. |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED MSVideoSize linphone_call_params_get_sent_video_size(const LinphoneCallParams *call_params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the audio payload type that has been selected by a call. |
|---|
| | | * @param call_params The #LinphoneCallParams object. @notnil |
|---|
| | | * @return The selected payload type. NULL is returned if no audio payload type has been seleced by the call. |
|---|
| | | * @deprecated 31/03/2017 Use linphone_call_params_get_used_audio_payload_type() instead. |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | | LINPHONE_DEPRECATED LINPHONE_PUBLIC void linphone_call_params_destroy(LinphoneCallParams *cp); |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED const OrtpPayloadType *linphone_call_params_get_used_audio_codec(const LinphoneCallParams *call_params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the video payload type that has been selected by a call. |
|---|
| | | * @param call_params The #LinphoneCallParams object. @notnil |
|---|
| | | * @return The selected payload type. NULL is returned if no video payload type has been seleced by the call. |
|---|
| | | * @deprecated 31/03/2017 Use linphone_call_params_get_used_video_payload_type() instead. |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED const OrtpPayloadType *linphone_call_params_get_used_video_codec(const LinphoneCallParams *call_params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the text payload type that has been selected by a call. |
|---|
| | | * @param call_params The #LinphoneCallParams object. @notnil |
|---|
| | | * @return The selected payload type. NULL is returned if no text payload type has been seleced by the call. |
|---|
| | | * @deprecated 31/03/2017 Use linphone_call_params_get_used_text_payload_type() instead. |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED const OrtpPayloadType *linphone_call_params_get_used_text_codec(const LinphoneCallParams *call_params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @} |
|---|
old mode 100644
new mode 100755
old mode 100644
new mode 100755
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback notifying that a new #LinphoneCall (either incoming or outgoing) has been created. |
|---|
| | | * @param[in] lc #LinphoneCore object that has created the call |
|---|
| | | * @param[in] call The newly created #LinphoneCall object |
|---|
| | | * @param core #LinphoneCore object that has created the call @notnil |
|---|
| | | * @param call The newly created #LinphoneCall object @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreCbsCallCreatedCb)(LinphoneCore *lc, LinphoneCall *call); |
|---|
| | | typedef void (*LinphoneCoreCbsCallCreatedCb)(LinphoneCore *core, LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Global state notification callback. |
|---|
| | | * @param lc the #LinphoneCore. |
|---|
| | | * @param gstate the global state |
|---|
| | | * @param message informational message. |
|---|
| | | * @param core the #LinphoneCore. @notnil |
|---|
| | | * @param state the #LinphoneGlobalState |
|---|
| | | * @param message informational message. @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreCbsGlobalStateChangedCb)(LinphoneCore *lc, LinphoneGlobalState gstate, const char *message); |
|---|
| | | typedef void (*LinphoneCoreCbsGlobalStateChangedCb)(LinphoneCore *core, LinphoneGlobalState state, const char *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Old name of #LinphoneCoreCbsGlobalStateChangedCb. |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Call state notification callback. |
|---|
| | | * @param lc the #LinphoneCore |
|---|
| | | * @param call the call object whose state is changed. |
|---|
| | | * @param cstate the new state of the call |
|---|
| | | * @param message a non NULL informational message about the state. |
|---|
| | | * @param core the #LinphoneCore @notnil |
|---|
| | | * @param call the #LinphoneCall object whose state is changed. @notnil |
|---|
| | | * @param state the new #LinphoneCallState of the call |
|---|
| | | * @param message a non NULL informational message about the state. @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreCbsCallStateChangedCb)(LinphoneCore *lc, LinphoneCall *call, LinphoneCallState cstate, const char *message); |
|---|
| | | typedef void (*LinphoneCoreCbsCallStateChangedCb)(LinphoneCore *core, LinphoneCall *call, LinphoneCallState state, const char *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Old name of #LinphoneCoreCbsCallStateChangedCb. |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Call encryption changed callback. |
|---|
| | | * @param lc the #LinphoneCore |
|---|
| | | * @param call the call on which encryption is changed. |
|---|
| | | * @param on whether encryption is activated. |
|---|
| | | * @param authentication_token an authentication_token, currently set for ZRTP kind of encryption only. |
|---|
| | | * @param core the #LinphoneCore @notnil |
|---|
| | | * @param call the #LinphoneCall on which encryption is changed. @notnil |
|---|
| | | * @param media_encryption_enabled whether encryption is activated. |
|---|
| | | * @param authentication_token an authentication_token, currently set for ZRTP kind of encryption only. @maybenil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreCbsCallEncryptionChangedCb)(LinphoneCore *lc, LinphoneCall *call, bool_t on, const char *authentication_token); |
|---|
| | | typedef void (*LinphoneCoreCbsCallEncryptionChangedCb)(LinphoneCore *core, LinphoneCall *call, bool_t media_encryption_enabled, const char *authentication_token); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Old name of #LinphoneCoreCbsCallEncryptionChangedCb. |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Registration state notification callback prototype |
|---|
| | | * @param core the #LinphoneCore @notnil |
|---|
| | | * @param proxy_config the #LinphoneProxyConfig which state has changed @notnil |
|---|
| | | * @param state the current #LinphoneRegistrationState |
|---|
| | | * @param message a non NULL informational message about the state @notnil |
|---|
| | | * @ingroup Proxies |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreCbsRegistrationStateChangedCb)(LinphoneCore *lc, LinphoneProxyConfig *cfg, LinphoneRegistrationState cstate, const char *message); |
|---|
| | | typedef void (*LinphoneCoreCbsRegistrationStateChangedCb)(LinphoneCore *core, LinphoneProxyConfig *proxy_config, LinphoneRegistrationState state, const char *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Old name of #LinphoneCoreCbsRegistrationStateChangedCb. |
|---|
| | |
|---|
| | | typedef LinphoneCoreCbsRegistrationStateChangedCb LinphoneCoreRegistrationStateChangedCb; |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Report status change for a friend previously \link linphone_core_add_friend() added \endlink to #LinphoneCore. |
|---|
| | | * @param lc #LinphoneCore object . |
|---|
| | | * @param lf Updated #LinphoneFriend . |
|---|
| | | * Report status change for a friend previously added to the #LinphoneCore with linphone_core_add_friend(). |
|---|
| | | * @param core #LinphoneCore object @notnil |
|---|
| | | * @param linphone_friend Updated #LinphoneFriend @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreCbsNotifyPresenceReceivedCb)(LinphoneCore *lc, LinphoneFriend * lf); |
|---|
| | | typedef void (*LinphoneCoreCbsNotifyPresenceReceivedCb)(LinphoneCore *core, LinphoneFriend * linphone_friend); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Old name of #LinphoneCoreCbsNotifyPresenceReceivedCb. |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Reports presence model change for a specific URI or phone number of a friend |
|---|
| | | * @param lc #LinphoneCore object |
|---|
| | | * @param lf #LinphoneFriend object |
|---|
| | | * @param uri_or_tel The URI or phone number for which teh presence model has changed |
|---|
| | | * @param presence_model The new presence model |
|---|
| | | * @param core #LinphoneCore object @notnil |
|---|
| | | * @param linphone_friend #LinphoneFriend object @notnil |
|---|
| | | * @param uri_or_tel The URI or phone number for which the presence model has changed @notnil |
|---|
| | | * @param presence_model The new #LinphonePresenceModel @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreCbsNotifyPresenceReceivedForUriOrTelCb)(LinphoneCore *lc, LinphoneFriend *lf, const char *uri_or_tel, const LinphonePresenceModel *presence_model); |
|---|
| | | typedef void (*LinphoneCoreCbsNotifyPresenceReceivedForUriOrTelCb)(LinphoneCore *core, LinphoneFriend *linphone_friend, const char *uri_or_tel, const LinphonePresenceModel *presence_model); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Old name of #LinphoneCoreCbsNotifyPresenceReceivedForUriOrTelCb. |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Reports that a new subscription request has been received and wait for a decision. |
|---|
| | | * Status on this subscription request is notified by \link linphone_friend_set_inc_subscribe_policy() changing policy \endlink for this friend |
|---|
| | | * @param lc #LinphoneCore object |
|---|
| | | * @param lf #LinphoneFriend corresponding to the subscriber |
|---|
| | | * @param url of the subscriber |
|---|
| | | * @note A subscription request is notified by this function only if the #LinphoneSubscribePolicy for the |
|---|
| | | * given #LinphoneFriend has been set to #LinphoneSPWait. See linphone_friend_set_inc_subscribe_policy(). |
|---|
| | | * @param core #LinphoneCore object @notnil |
|---|
| | | * @param linphone_friend The #LinphoneFriend aimed by the subscription. @notnil |
|---|
| | | * @param url URI of the subscriber @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreCbsNewSubscriptionRequestedCb)(LinphoneCore *lc, LinphoneFriend *lf, const char *url); |
|---|
| | | typedef void (*LinphoneCoreCbsNewSubscriptionRequestedCb)(LinphoneCore *core, LinphoneFriend *linphone_friend, const char *url); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Old name of #LinphoneCoreCbsNewSubscriptionRequestedCb. |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback for requesting authentication information to application or user. |
|---|
| | | * @param lc the #LinphoneCore |
|---|
| | | * @param realm the realm (domain) on which authentication is required. |
|---|
| | | * @param username the username that needs to be authenticated. |
|---|
| | | * @param domain the domain on which authentication is required. |
|---|
| | | * @param core the #LinphoneCore @notnil |
|---|
| | | * @param auth_info a #LinphoneAuthInfo pre-filled with username, realm and domain values as much as possible @notnil |
|---|
| | | * @param method the type of authentication requested as #LinphoneAuthMethod enum @notnil |
|---|
| | | * Application shall reply to this callback using linphone_core_add_auth_info(). |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreAuthInfoRequestedCb)(LinphoneCore *lc, const char *realm, const char *username, const char *domain); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback for requesting authentication information to application or user. |
|---|
| | | * @param lc the #LinphoneCore |
|---|
| | | * @param auth_info a #LinphoneAuthInfo pre-filled with username, realm and domain values as much as possible |
|---|
| | | * @param method the type of authentication requested |
|---|
| | | * Application shall reply to this callback using linphone_core_add_auth_info(). |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreCbsAuthenticationRequestedCb)(LinphoneCore *lc, LinphoneAuthInfo *auth_info, LinphoneAuthMethod method); |
|---|
| | | typedef void (*LinphoneCoreCbsAuthenticationRequestedCb)(LinphoneCore *core, LinphoneAuthInfo *auth_info, LinphoneAuthMethod method); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Old name of #LinphoneCoreCbsAuthenticationRequestedCb. |
|---|
| | |
|---|
| | | /** |
|---|
| | | * Callback to notify a new call-log entry has been added. |
|---|
| | | * This is done typically when a call terminates. |
|---|
| | | * @param lc the #LinphoneCore |
|---|
| | | * @param newcl the new call log entry added. |
|---|
| | | * @param core the #LinphoneCore @notnil |
|---|
| | | * @param call_log the new #LinphoneCallLog entry added. @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreCbsCallLogUpdatedCb)(LinphoneCore *lc, LinphoneCallLog *newcl); |
|---|
| | | typedef void (*LinphoneCoreCbsCallLogUpdatedCb)(LinphoneCore *core, LinphoneCallLog *call_log); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Old name of #LinphoneCoreCbsCallLogUpdatedCb. |
|---|
| | |
|---|
| | | typedef LinphoneCoreCbsCallLogUpdatedCb LinphoneCoreCallLogUpdatedCb; |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback prototype |
|---|
| | | * @param lc #LinphoneCore object |
|---|
| | | * @param room #LinphoneChatRoom involved in this conversation. Can be be created by the framework in case \link #LinphoneAddress the from \endlink is not present in any chat room. |
|---|
| | | * @param from #LinphoneAddress from |
|---|
| | | * @param message incoming message |
|---|
| | | * @deprecated use #LinphoneCoreMessageReceivedCb instead. |
|---|
| | | * @donotwrap |
|---|
| | | * Callback to notify the callid of a call has been updated. |
|---|
| | | * This is done typically when a call retry. |
|---|
| | | * @param core the #LinphoneCore @notnil |
|---|
| | | * @param previous_call_id the previous callid. @notnil |
|---|
| | | * @param current_call_id the new callid. @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreTextMessageReceivedCb)(LinphoneCore *lc, LinphoneChatRoom *room, const LinphoneAddress *from, const char *message); |
|---|
| | | typedef void (*LinphoneCoreCbsCallIdUpdatedCb)(LinphoneCore *core, const char *previous_call_id, const char *current_call_id); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Chat message callback prototype |
|---|
| | | * @param lc #LinphoneCore object |
|---|
| | | * @param room #LinphoneChatRoom involved in this conversation. Can be be created by the framework in case \link #LinphoneAddress the from \endlink is not present in any chat room. |
|---|
| | | * @param #LinphoneChatMessage incoming message |
|---|
| | | * Old name of #LinphoneCoreCbsCallIdUpdatedCb. |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreCbsMessageReceivedCb)(LinphoneCore *lc, LinphoneChatRoom *room, LinphoneChatMessage *message); |
|---|
| | | typedef LinphoneCoreCbsCallIdUpdatedCb LinphoneCoreCallIdUpdatedCb; |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Chat message callback prototype |
|---|
| | | * @param lc #LinphoneCore object |
|---|
| | | * @param room #LinphoneChatRoom involved in this conversation. Can be be created by the framework in case \link #LinphoneAddress the from \endlink is not present in any chat room. |
|---|
| | | * @param #LinphoneChatMessage outgoing message |
|---|
| | | * Chat message callback prototype. |
|---|
| | | * @param core #LinphoneCore object @notnil |
|---|
| | | * @param chat_room #LinphoneChatRoom involved in this conversation. Can be created by the framework in case the From-URI is not present in any chat room. @notnil |
|---|
| | | * @param message #LinphoneChatMessage incoming message @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreCbsMessageSentCb)(LinphoneCore *lc, LinphoneChatRoom *room, LinphoneChatMessage *message); |
|---|
| | | typedef void (*LinphoneCoreCbsMessageReceivedCb)(LinphoneCore *core, LinphoneChatRoom *chat_room, LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Called after the #send method of the #LinphoneChatMessage was called. |
|---|
| | | * The message will be in state InProgress. |
|---|
| | | * In case of resend this callback won't be called. |
|---|
| | | * @param core #LinphoneCore object @notnil |
|---|
| | | * @param chat_room #LinphoneChatRoom involved in this conversation. Can be be created by the framework in case the From-URI is not present in any chat room. @notnil |
|---|
| | | * @param message #LinphoneChatMessage outgoing message @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreCbsMessageSentCb)(LinphoneCore *core, LinphoneChatRoom *chat_room, LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Old name of #LinphoneCoreCbsMessageReceivedCb. |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Chat room marked as read callback |
|---|
| | | * @param lc #LinphoneCore object |
|---|
| | | * @param room #LinphoneChatRoom that has been marked as read. |
|---|
| | | * @param core #LinphoneCore object @notnil |
|---|
| | | * @param chat_room #LinphoneChatRoom that has been marked as read. @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreCbsChatRoomReadCb)(LinphoneCore *lc, LinphoneChatRoom *room); |
|---|
| | | typedef void (*LinphoneCoreCbsChatRoomReadCb)(LinphoneCore *core, LinphoneChatRoom *chat_room); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Chat message not decrypted callback prototype |
|---|
| | | * @param lc #LinphoneCore object |
|---|
| | | * @param room #LinphoneChatRoom involved in this conversation. Can be be created by the framework in case \link #LinphoneAddress the from \endlink is not present in any chat room. |
|---|
| | | * @param #LinphoneChatMessage incoming message |
|---|
| | | * @param core #LinphoneCore object @notnil |
|---|
| | | * @param chat_room #LinphoneChatRoom involved in this conversation. Can be be created by the framework in case the from-URI is not present in any chat room. @notnil |
|---|
| | | * @param message #LinphoneChatMessage incoming message @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreCbsMessageReceivedUnableDecryptCb)(LinphoneCore *lc, LinphoneChatRoom *room, LinphoneChatMessage *message); |
|---|
| | | typedef void (*LinphoneCoreCbsMessageReceivedUnableDecryptCb)(LinphoneCore *core, LinphoneChatRoom *chat_room, LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * File transfer receive callback prototype. This function is called by the core upon an incoming File transfer is started. This function may be call several time for the same file in case of large file. |
|---|
| | | * @param lc #LinphoneCore object |
|---|
| | | * @param message #LinphoneChatMessage message from which the body is received. |
|---|
| | | * @param content #LinphoneContent incoming content information |
|---|
| | | * @param buff pointer to the received data |
|---|
| | | * @param core #LinphoneCore object @notnil |
|---|
| | | * @param message #LinphoneChatMessage message from which the body is received. @notnil |
|---|
| | | * @param content #LinphoneContent incoming content information @notnil |
|---|
| | | * @param buffer pointer to the received data @maybenil |
|---|
| | | * @param size number of bytes to be read from buff. 0 means end of file. |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreFileTransferRecvCb)(LinphoneCore *lc, LinphoneChatMessage *message, const LinphoneContent* content, const char* buff, size_t size); |
|---|
| | | typedef void (*LinphoneCoreFileTransferRecvCb)(LinphoneCore *core, LinphoneChatMessage *message, LinphoneContent* content, const char* buffer, size_t size); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * File transfer send callback prototype. This function is called by the core upon an outgoing file transfer is started. This function is called until size is set to 0. |
|---|
| | | * @param lc #LinphoneCore object |
|---|
| | | * @param message #LinphoneChatMessage message from which the body is received. |
|---|
| | | * @param content #LinphoneContent outgoing content |
|---|
| | | * @param buff pointer to the buffer where data chunk shall be written by the app |
|---|
| | | * @param core #LinphoneCore object @notnil |
|---|
| | | * @param message #LinphoneChatMessage message from which the body is received. @notnil |
|---|
| | | * @param content #LinphoneContent outgoing content @notnil |
|---|
| | | * @param buffer pointer to the buffer where data chunk shall be written by the app @notnil |
|---|
| | | * @param size as input value, it represents the number of bytes expected by the framework. As output value, it means the number of bytes wrote by the application in the buffer. 0 means end of file. |
|---|
| | | * |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreFileTransferSendCb)(LinphoneCore *lc, LinphoneChatMessage *message, const LinphoneContent* content, char* buff, size_t* size); |
|---|
| | | typedef void (*LinphoneCoreFileTransferSendCb)(LinphoneCore *core, LinphoneChatMessage *message, LinphoneContent* content, char* buffer, size_t* size); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * File transfer progress indication callback prototype. |
|---|
| | | * @param lc #LinphoneCore object |
|---|
| | | * @param message #LinphoneChatMessage message from which the body is received. |
|---|
| | | * @param content #LinphoneContent incoming content information |
|---|
| | | * @param core #LinphoneCore object @notnil |
|---|
| | | * @param message #LinphoneChatMessage message from which the body is received. @notnil |
|---|
| | | * @param content #LinphoneContent incoming content information @notnil |
|---|
| | | * @param offset The number of bytes sent/received since the beginning of the transfer. |
|---|
| | | * @param total The total number of bytes to be sent/received. |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreFileTransferProgressIndicationCb)(LinphoneCore *lc, LinphoneChatMessage *message, const LinphoneContent* content, size_t offset, size_t total); |
|---|
| | | typedef void (*LinphoneCoreFileTransferProgressIndicationCb)(LinphoneCore *core, LinphoneChatMessage *message, LinphoneContent* content, size_t offset, size_t total); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Is composing notification callback prototype. |
|---|
| | | * @param[in] lc #LinphoneCore object |
|---|
| | | * @param[in] room #LinphoneChatRoom involved in the conversation. |
|---|
| | | * @param core #LinphoneCore object @notnil |
|---|
| | | * @param chat_room #LinphoneChatRoom involved in the conversation. @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreCbsIsComposingReceivedCb)(LinphoneCore *lc, LinphoneChatRoom *room); |
|---|
| | | typedef void (*LinphoneCoreCbsIsComposingReceivedCb)(LinphoneCore *core, LinphoneChatRoom *chat_room); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Old name of #LinphoneCoreCbsIsComposingReceivedCb. |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback for being notified of DTMFs received. |
|---|
| | | * @param lc the linphone core |
|---|
| | | * @param call the call that received the dtmf |
|---|
| | | * @param core the #LinphoneCore @notnil |
|---|
| | | * @param call the #LinphoneCall that received the dtmf @notnil |
|---|
| | | * @param dtmf the ascii code of the dtmf |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreCbsDtmfReceivedCb)(LinphoneCore* lc, LinphoneCall *call, int dtmf); |
|---|
| | | typedef void (*LinphoneCoreCbsDtmfReceivedCb)(LinphoneCore* core, LinphoneCall *call, int dtmf); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Old name of #LinphoneCoreCbsDtmfReceivedCb. |
|---|
| | | */ |
|---|
| | | typedef LinphoneCoreCbsDtmfReceivedCb LinphoneCoreDtmfReceivedCb; |
|---|
| | | |
|---|
| | | /** Callback prototype */ |
|---|
| | | typedef void (*LinphoneCoreCbsReferReceivedCb)(LinphoneCore *lc, const char *refer_to); |
|---|
| | | /** |
|---|
| | | * Callback prototype for when a refer is received |
|---|
| | | * @param core the #LinphoneCore @notnil |
|---|
| | | * @param refer_to the address of the refer @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreCbsReferReceivedCb)(LinphoneCore *core, const char *refer_to); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Old name of #LinphoneCoreCbsReferReceivedCb. |
|---|
| | | */ |
|---|
| | | typedef LinphoneCoreCbsReferReceivedCb LinphoneCoreReferReceivedCb; |
|---|
| | | |
|---|
| | | /** Callback prototype */ |
|---|
| | | typedef void (*LinphoneCoreCbsBuddyInfoUpdatedCb)(LinphoneCore *lc, LinphoneFriend *lf); |
|---|
| | | /** |
|---|
| | | * Callback prototype when using the buddy plugin |
|---|
| | | * @param core the #LinphoneCore @notnil |
|---|
| | | * @param linphone_friend the #LinphoneFriend that has been updated @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreCbsBuddyInfoUpdatedCb)(LinphoneCore *core, LinphoneFriend *linphone_friend); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Old name of #LinphoneCoreCbsBuddyInfoUpdatedCb. |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback for notifying progresses of transfers. |
|---|
| | | * @param lc the #LinphoneCore |
|---|
| | | * @param transfered the call that was transfered |
|---|
| | | * @param new_call_state the state of the call to transfer target at the far end. |
|---|
| | | * @param core the #LinphoneCore @notnil |
|---|
| | | * @param transfered the #LinphoneCall that was transfered @notnil |
|---|
| | | * @param call_state the #LinphoneCallState of the call to transfer target at the far end. |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreCbsTransferStateChangedCb)(LinphoneCore *lc, LinphoneCall *transfered, LinphoneCallState new_call_state); |
|---|
| | | typedef void (*LinphoneCoreCbsTransferStateChangedCb)(LinphoneCore *core, LinphoneCall *transfered, LinphoneCallState call_state); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Old name of LinphoneCoreCbsTransferStateChangedCb. |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback for receiving quality statistics for calls. |
|---|
| | | * @param lc the #LinphoneCore |
|---|
| | | * @param call the call |
|---|
| | | * @param stats the call statistics. |
|---|
| | | * @param core the #LinphoneCore @notnil |
|---|
| | | * @param call the call @notnil |
|---|
| | | * @param call_stats the call statistics. @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreCbsCallStatsUpdatedCb)(LinphoneCore *lc, LinphoneCall *call, const LinphoneCallStats *stats); |
|---|
| | | typedef void (*LinphoneCoreCbsCallStatsUpdatedCb)(LinphoneCore *core, LinphoneCall *call, const LinphoneCallStats *call_stats); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Old name of #LinphoneCoreCbsCallStatsUpdatedCb. |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback prototype for receiving info messages. |
|---|
| | | * @param lc the #LinphoneCore |
|---|
| | | * @param call the call whose info message belongs to. |
|---|
| | | * @param msg the info message. |
|---|
| | | * @param core the #LinphoneCore @notnil |
|---|
| | | * @param call the call whose info message belongs to. @notnil |
|---|
| | | * @param message the info message. @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreCbsInfoReceivedCb)(LinphoneCore *lc, LinphoneCall *call, const LinphoneInfoMessage *msg); |
|---|
| | | typedef void (*LinphoneCoreCbsInfoReceivedCb)(LinphoneCore *core, LinphoneCall *call, const LinphoneInfoMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Old name of #LinphoneCoreCbsInfoReceivedCb. |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback prototype for configuring status changes notification |
|---|
| | | * @param lc the #LinphoneCore |
|---|
| | | * @param message informational message. |
|---|
| | | * @param core the #LinphoneCore @notnil |
|---|
| | | * @param status the current #LinphoneConfiguringState |
|---|
| | | * @param message informational message. @maybenil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreCbsConfiguringStatusCb)(LinphoneCore *lc, LinphoneConfiguringState status, const char *message); |
|---|
| | | typedef void (*LinphoneCoreCbsConfiguringStatusCb)(LinphoneCore *core, LinphoneConfiguringState status, const char *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Old name of #LinphoneCoreCbsConfiguringStatusCb. |
|---|
| | |
|---|
| | | typedef LinphoneCoreCbsConfiguringStatusCb LinphoneCoreConfiguringStatusCb; |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback prototype for reporting network change either automatically detected or notified by #linphone_core_set_network_reachable. |
|---|
| | | * @param lc the #LinphoneCore |
|---|
| | | * Callback prototype for reporting network change either automatically detected or notified by #linphone_core_set_network_reachable(). |
|---|
| | | * @param core the #LinphoneCore @notnil |
|---|
| | | * @param reachable true if network is reachable. |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreCbsNetworkReachableCb)(LinphoneCore *lc, bool_t reachable); |
|---|
| | | typedef void (*LinphoneCoreCbsNetworkReachableCb)(LinphoneCore *core, bool_t reachable); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Old name of #LinphoneCoreCbsNetworkReachableCb. |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback prototype for reporting log collection upload state change. |
|---|
| | | * @param[in] lc #LinphoneCore object |
|---|
| | | * @param[in] state The state of the log collection upload |
|---|
| | | * @param[in] info Additional information: error message in case of error state, URL of uploaded file in case of success. |
|---|
| | | * @param core #LinphoneCore object @notnil |
|---|
| | | * @param state The state of the log collection upload |
|---|
| | | * @param info Additional information: error message in case of error state, URL of uploaded file in case of success. @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreCbsLogCollectionUploadStateChangedCb)(LinphoneCore *lc, LinphoneCoreLogCollectionUploadState state, const char *info); |
|---|
| | | typedef void (*LinphoneCoreCbsLogCollectionUploadStateChangedCb)(LinphoneCore *core, LinphoneCoreLogCollectionUploadState state, const char *info); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Old name of #LinphoneCoreCbsLogCollectionUploadStateChangedCb. |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback prototype for reporting log collection upload progress indication. |
|---|
| | | * @param[in] lc #LinphoneCore object |
|---|
| | | * @param core #LinphoneCore object @notnil |
|---|
| | | * @param offset the number of bytes sent since the start of the upload |
|---|
| | | * @param total the total number of bytes to upload |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreCbsLogCollectionUploadProgressIndicationCb)(LinphoneCore *lc, size_t offset, size_t total); |
|---|
| | | typedef void (*LinphoneCoreCbsLogCollectionUploadProgressIndicationCb)(LinphoneCore *core, size_t offset, size_t total); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Old name of #LinphoneCoreCbsLogCollectionUploadProgressIndicationCb. |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback prototype for reporting when a friend list has been added to the core friends list. |
|---|
| | | * @param[in] lc #LinphoneCore object |
|---|
| | | * @param[in] list #LinphoneFriendList object |
|---|
| | | * @param core #LinphoneCore object @notnil |
|---|
| | | * @param friend_list #LinphoneFriendList object @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreCbsFriendListCreatedCb) (LinphoneCore *lc, LinphoneFriendList *list); |
|---|
| | | typedef void (*LinphoneCoreCbsFriendListCreatedCb) (LinphoneCore *core, LinphoneFriendList *friend_list); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Old name of #LinphoneCoreCbsFriendListCreatedCb. |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback prototype for reporting when a friend list has been removed from the core friends list. |
|---|
| | | * @param[in] lc #LinphoneCore object |
|---|
| | | * @param[in] list #LinphoneFriendList object |
|---|
| | | * @param core #LinphoneCore object @notnil |
|---|
| | | * @param friend_list #LinphoneFriendList object @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreCbsFriendListRemovedCb) (LinphoneCore *lc, LinphoneFriendList *list); |
|---|
| | | typedef void (*LinphoneCoreCbsFriendListRemovedCb) (LinphoneCore *core, LinphoneFriendList *friend_list); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Old name of #LinphoneCoreCbsFriendListRemovedCb. |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback prototype for reporting the result of a version update check. |
|---|
| | | * @param[in] lc #LinphoneCore object |
|---|
| | | * @param[in] result The result of the version update check |
|---|
| | | * @param[in] url The url where to download the new version if the result is #LinphoneVersionUpdateCheckNewVersionAvailable |
|---|
| | | * @param core #LinphoneCore object @notnil |
|---|
| | | * @param result The result of the version update check @notnil |
|---|
| | | * @param url The url where to download the new version if the result is #LinphoneVersionUpdateCheckNewVersionAvailable @maybenil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreCbsVersionUpdateCheckResultReceivedCb) (LinphoneCore *lc, LinphoneVersionUpdateCheckResult result, const char *version, const char *url); |
|---|
| | | typedef void (*LinphoneCoreCbsVersionUpdateCheckResultReceivedCb) (LinphoneCore *core, LinphoneVersionUpdateCheckResult result, const char *version, const char *url); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback prototype telling that a #LinphoneConference state has changed. |
|---|
| | | * @param[in] core #LinphoneCore object @notnil |
|---|
| | | * @param[in] conference The #LinphoneConference object for which the state has changed @notnil |
|---|
| | | * @param[in] state the current #LinphoneChatRoomState |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreCbsConferenceStateChangedCb) (LinphoneCore * core, LinphoneConference *conference, LinphoneConferenceState state); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback prototype telling that a #LinphoneChatRoom state has changed. |
|---|
| | | * @param[in] lc #LinphoneCore object |
|---|
| | | * @param[in] cr The #LinphoneChatRoom object for which the state has changed |
|---|
| | | * @param core #LinphoneCore object @notnil |
|---|
| | | * @param chat_room The #LinphoneChatRoom object for which the state has changed @notnil |
|---|
| | | * @param state the current #LinphoneChatRoomState |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreCbsChatRoomStateChangedCb) (LinphoneCore *lc, LinphoneChatRoom *cr, LinphoneChatRoomState state); |
|---|
| | | typedef void (*LinphoneCoreCbsChatRoomStateChangedCb) (LinphoneCore *core, LinphoneChatRoom *chat_room, LinphoneChatRoomState state); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback prototype telling that a #LinphoneChatRoom subject has changed. |
|---|
| | | * @param core #LinphoneCore object @notnil |
|---|
| | | * @param chat_room The #LinphoneChatRoom object for which the subject has changed @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreCbsChatRoomSubjectChangedCb) (LinphoneCore *core, LinphoneChatRoom *chat_room); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback prototype telling that a #LinphoneChatRoom ephemeral message has expired. |
|---|
| | | * @param core #LinphoneCore object @notnil |
|---|
| | | * @param chat_room The #LinphoneChatRoom object for which a message has expired. @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreCbsChatRoomEphemeralMessageDeleteCb) (LinphoneCore *core, LinphoneChatRoom *chat_room); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback prototype telling that an Instant Message Encryption Engine user registered on the server with or without success. |
|---|
| | | * @param core #LinphoneCore object @notnil |
|---|
| | | * @param status the return status of the registration action. |
|---|
| | | * @param user_id the userId published on the encryption engine server @notnil |
|---|
| | | * @param info information about failure @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreCbsImeeUserRegistrationCb) (LinphoneCore *core, const bool_t status, const char *user_id, const char *info); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback prototype telling the result of decoded qrcode |
|---|
| | | * @param[in] lc LinphoneCore object |
|---|
| | | * @param[in] result The result of the decoded qrcode |
|---|
| | | * @param core #LinphoneCore object @notnil |
|---|
| | | * @param result The result of the decoded qrcode @maybenil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreCbsQrcodeFoundCb)(LinphoneCore *lc, const char *result); |
|---|
| | | typedef void (*LinphoneCoreCbsQrcodeFoundCb)(LinphoneCore *core, const char *result); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback prototype telling a call has started (incoming or outgoing) while there was no other call. |
|---|
| | | * @param core #LinphoneCore object @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreCbsFirstCallStartedCb)(LinphoneCore *core); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback prototype telling the last call has ended (#LinphoneCore.get_calls_nb() returns 0) |
|---|
| | | * @param core #LinphoneCore object @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreCbsLastCallEndedCb)(LinphoneCore *core); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback prototype telling that the audio device for at least one call has changed |
|---|
| | | * @param core #LinphoneCore object @notnil |
|---|
| | | * @param audio_device the newly used #LinphoneAudioDevice object @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreCbsAudioDeviceChangedCb)(LinphoneCore *core, LinphoneAudioDevice *audio_device); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback prototype telling the audio devices list has been updated. |
|---|
| | | * Either a new device is available or a previously available device isn't anymore. |
|---|
| | | * You can call linphone_core_get_audio_devices() to get the new list. |
|---|
| | | * @param core #LinphoneCore object @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreCbsAudioDevicesListUpdatedCb)(LinphoneCore *core); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @} |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback prototype for notifying the application about notification received from the network. |
|---|
| | | **/ |
|---|
| | | typedef void (*LinphoneCoreCbsNotifyReceivedCb)(LinphoneCore *lc, LinphoneEvent *lev, const char *notified_event, const LinphoneContent *body); |
|---|
| | | * @param core #LinphoneCore object @notnil |
|---|
| | | * @param linphone_event the #LinphoneEvent received @notnil |
|---|
| | | * @param notified_event The event as string @notnil |
|---|
| | | * @param body the #LinphoneContent of the event @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreCbsNotifyReceivedCb)(LinphoneCore *core, LinphoneEvent *linphone_event, const char *notified_event, const LinphoneContent *body); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Old name of #LinphoneCoreCbsNotifyReceivedCb. |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback prototype for notifying the application about subscription received from the network. |
|---|
| | | **/ |
|---|
| | | typedef void (*LinphoneCoreCbsSubscribeReceivedCb)(LinphoneCore *lc, LinphoneEvent *lev, const char *subscribe_event, const LinphoneContent *body); |
|---|
| | | * @param core #LinphoneCore object @notnil |
|---|
| | | * @param linphone_event the #LinphoneEvent received @notnil |
|---|
| | | * @param subscribe_event The event as string @notnil |
|---|
| | | * @param body the #LinphoneContent of the event @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreCbsSubscribeReceivedCb)(LinphoneCore *core, LinphoneEvent *linphone_event, const char *subscribe_event, const LinphoneContent *body); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Old name of #LinphoneCoreCbsSubscribeReceivedCb. |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback prototype for notifying the application about changes of subscription states, including arrival of new subscriptions. |
|---|
| | | **/ |
|---|
| | | typedef void (*LinphoneCoreCbsSubscriptionStateChangedCb)(LinphoneCore *lc, LinphoneEvent *lev, LinphoneSubscriptionState state); |
|---|
| | | * @param core #LinphoneCore object @notnil |
|---|
| | | * @param linphone_event the #LinphoneEvent @notnil |
|---|
| | | * @param state the new #LinphoneSubscriptionState |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreCbsSubscriptionStateChangedCb)(LinphoneCore *core, LinphoneEvent *linphone_event, LinphoneSubscriptionState state); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Old name of #LinphoneCoreCbsSubscriptionStateChangedCb. |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback prototype for notifying the application about changes of publish states. |
|---|
| | | **/ |
|---|
| | | typedef void (*LinphoneCoreCbsPublishStateChangedCb)(LinphoneCore *lc, LinphoneEvent *lev, LinphonePublishState state); |
|---|
| | | * @param core #LinphoneCore object @notnil |
|---|
| | | * @param linphone_event the #LinphoneEvent @notnil |
|---|
| | | * @param state the new #LinphonePublishState |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreCbsPublishStateChangedCb)(LinphoneCore *core, LinphoneEvent *linphone_event, LinphonePublishState state); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Old name of LinphoneCoreCbsPublishStateChangedCb. |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback used to notify the response to a sent NOTIFY |
|---|
| | | * @param ev The LinphoneEvent object that has sent the NOTIFY and for which we received a response |
|---|
| | | * @param linphone_event The #LinphoneEvent object that has sent the NOTIFY and for which we received a response @notnil |
|---|
| | | **/ |
|---|
| | | typedef void (*LinphoneEventCbsNotifyResponseCb)(const LinphoneEvent *ev); |
|---|
| | | typedef void (*LinphoneEventCbsNotifyResponseCb)(const LinphoneEvent *linphone_event); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @} |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback used to notify a new contact has been created on the CardDAV server and downloaded locally |
|---|
| | | * @param list The #LinphoneFriendList object the new contact is added to |
|---|
| | | * @param lf The #LinphoneFriend object that has been created |
|---|
| | | * @param friend_list The #LinphoneFriendList object the new contact is added to @notnil |
|---|
| | | * @param linphone_friend The #LinphoneFriend object that has been created @notnil |
|---|
| | | **/ |
|---|
| | | typedef void (*LinphoneFriendListCbsContactCreatedCb)(LinphoneFriendList *list, LinphoneFriend *lf); |
|---|
| | | typedef void (*LinphoneFriendListCbsContactCreatedCb)(LinphoneFriendList *friend_list, LinphoneFriend *linphone_friend); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback used to notify a contact has been deleted on the CardDAV server |
|---|
| | | * @param list The #LinphoneFriendList object a contact has been removed from |
|---|
| | | * @param lf The #LinphoneFriend object that has been deleted |
|---|
| | | * @param friend_list The #LinphoneFriendList object a contact has been removed from @notnil |
|---|
| | | * @param linphone_friend The #LinphoneFriend object that has been deleted @notnil |
|---|
| | | **/ |
|---|
| | | typedef void (*LinphoneFriendListCbsContactDeletedCb)(LinphoneFriendList *list, LinphoneFriend *lf); |
|---|
| | | typedef void (*LinphoneFriendListCbsContactDeletedCb)(LinphoneFriendList *friend_list, LinphoneFriend *linphone_friend); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback used to notify a contact has been updated on the CardDAV server |
|---|
| | | * @param list The #LinphoneFriendList object in which a contact has been updated |
|---|
| | | * @param new_friend The new #LinphoneFriend object corresponding to the updated contact |
|---|
| | | * @param old_friend The old #LinphoneFriend object before update |
|---|
| | | * @param friend_list The #LinphoneFriendList object in which a contact has been updated @notnil |
|---|
| | | * @param new_friend The new #LinphoneFriend object corresponding to the updated contact @notnil |
|---|
| | | * @param old_friend The old #LinphoneFriend object before update @notnil |
|---|
| | | **/ |
|---|
| | | typedef void (*LinphoneFriendListCbsContactUpdatedCb)(LinphoneFriendList *list, LinphoneFriend *new_friend, LinphoneFriend *old_friend); |
|---|
| | | typedef void (*LinphoneFriendListCbsContactUpdatedCb)(LinphoneFriendList *friend_list, LinphoneFriend *new_friend, LinphoneFriend *old_friend); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback used to notify the status of the synchronization has changed |
|---|
| | | * @param list The #LinphoneFriendList object for which the status has changed |
|---|
| | | * @param status The new synchronisation status |
|---|
| | | * @param msg An additional information on the status update |
|---|
| | | * @param friend_list The #LinphoneFriendList object for which the status has changed @notnil |
|---|
| | | * @param status The new #LinphoneFriendListSyncStatus |
|---|
| | | * @param message An additional information on the status update @notnil |
|---|
| | | **/ |
|---|
| | | typedef void (*LinphoneFriendListCbsSyncStateChangedCb)(LinphoneFriendList *list, LinphoneFriendListSyncStatus status, const char *msg); |
|---|
| | | typedef void (*LinphoneFriendListCbsSyncStateChangedCb)(LinphoneFriendList *friend_list, LinphoneFriendListSyncStatus status, const char *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback used to notify a list with all friends that have received presence information. |
|---|
| | | * @param list The #LinphoneFriendList object for which the status has changed |
|---|
| | | * @param friends A \bctbx_list{LinphoneFriend} of the relevant friends |
|---|
| | | * @param friend_list The #LinphoneFriendList object for which the status has changed @notnil |
|---|
| | | * @param friends A \bctbx_list{LinphoneFriend} of the relevant friends @notnil |
|---|
| | | **/ |
|---|
| | | typedef void (*LinphoneFriendListCbsPresenceReceivedCb)(LinphoneFriendList *list, const bctbx_list_t *friends); |
|---|
| | | typedef void (*LinphoneFriendListCbsPresenceReceivedCb)(LinphoneFriendList *friend_list, const bctbx_list_t *friends); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @} |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Function prototype used by #linphone_core_cbs_set_ec_calibrator_result(). |
|---|
| | | * @param lc The core. |
|---|
| | | * @param status The state of the calibrator. |
|---|
| | | * @param core The #LinphoneCore. @notnil |
|---|
| | | * @param status The #LinphoneEcCalibratorStatus of the calibrator. |
|---|
| | | * @param delay_ms The measured delay if available. |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreCbsEcCalibrationResultCb)(LinphoneCore *lc, LinphoneEcCalibratorStatus status, int delay_ms); |
|---|
| | | typedef void (*LinphoneCoreCbsEcCalibrationResultCb)(LinphoneCore *core, LinphoneEcCalibratorStatus status, int delay_ms); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Function prototype used by #linphone_core_cbs_set_ec_calibrator_audio_init(). |
|---|
| | | * @param lc The core. |
|---|
| | | * @param core The #LinphoneCore. @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreCbsEcCalibrationAudioInitCb)(LinphoneCore *lc); |
|---|
| | | typedef void (*LinphoneCoreCbsEcCalibrationAudioInitCb)(LinphoneCore *core); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Function prototype used by #linphone_core_cbs_set_ec_calibrator_audio_uninit(). |
|---|
| | | * @param lc The core. |
|---|
| | | * @param core The #LinphoneCore. @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreCbsEcCalibrationAudioUninitCb)(LinphoneCore *lc); |
|---|
| | | typedef void (*LinphoneCoreCbsEcCalibrationAudioUninitCb)(LinphoneCore *core); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback to decrypt incoming #LinphoneChatMessage |
|---|
| | | * @param engine ImEncryptionEngine object |
|---|
| | | * @param room #LinphoneChatRoom object |
|---|
| | | * @param msg #LinphoneChatMessage object |
|---|
| | | * @param engine The #LinphoneImEncryptionEngine object @notnil |
|---|
| | | * @param chat_room #LinphoneChatRoom object @notnil |
|---|
| | | * @param message #LinphoneChatMessage object @notnil |
|---|
| | | * @return -1 if nothing to be done, 0 on success or an integer > 0 for error |
|---|
| | | */ |
|---|
| | | typedef int (*LinphoneImEncryptionEngineCbsIncomingMessageCb)(LinphoneImEncryptionEngine *engine, LinphoneChatRoom *room, LinphoneChatMessage *msg); |
|---|
| | | typedef int (*LinphoneImEncryptionEngineCbsIncomingMessageCb)(LinphoneImEncryptionEngine *engine, LinphoneChatRoom *chat_room, LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback to encrypt outgoing #LinphoneChatMessage |
|---|
| | | * @param engine #LinphoneImEncryptionEngine object |
|---|
| | | * @param room #LinphoneChatRoom object |
|---|
| | | * @param msg #LinphoneChatMessage object |
|---|
| | | * @param engine #LinphoneImEncryptionEngine object @notnil |
|---|
| | | * @param chat_room #LinphoneChatRoom object @notnil |
|---|
| | | * @param message #LinphoneChatMessage object @notnil |
|---|
| | | * @return -1 if nothing to be done, 0 on success or an integer > 0 for error |
|---|
| | | */ |
|---|
| | | typedef int (*LinphoneImEncryptionEngineCbsOutgoingMessageCb)(LinphoneImEncryptionEngine *engine, LinphoneChatRoom *room, LinphoneChatMessage *msg); |
|---|
| | | typedef int (*LinphoneImEncryptionEngineCbsOutgoingMessageCb)(LinphoneImEncryptionEngine *engine, LinphoneChatRoom *chat_room, LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback to know whether or not the engine will encrypt files before uploading them |
|---|
| | | * @param engine #LinphoneImEncryptionEngine object |
|---|
| | | * @param room #LinphoneChatRoom object |
|---|
| | | * @param engine #LinphoneImEncryptionEngine object @notnil |
|---|
| | | * @param chat_room #LinphoneChatRoom object @notnil |
|---|
| | | * @return TRUE if files will be encrypted, FALSE otherwise |
|---|
| | | */ |
|---|
| | | typedef bool_t (*LinphoneImEncryptionEngineCbsIsEncryptionEnabledForFileTransferCb)(LinphoneImEncryptionEngine *engine, LinphoneChatRoom *room); |
|---|
| | | typedef bool_t (*LinphoneImEncryptionEngineCbsIsEncryptionEnabledForFileTransferCb)(LinphoneImEncryptionEngine *engine, LinphoneChatRoom *chat_room); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback to generate the key used to encrypt the files before uploading them |
|---|
| | | * Key can be stored in the #LinphoneContent object inside the #LinphoneChatMessage using linphone_content_set_key |
|---|
| | | * @param engine #LinphoneImEncryptionEngine object |
|---|
| | | * @param room #LinphoneChatRoom object |
|---|
| | | * @param msg #LinphoneChatMessage object |
|---|
| | | * @param engine #LinphoneImEncryptionEngine object @notnil |
|---|
| | | * @param chat_room #LinphoneChatRoom object @notnil |
|---|
| | | * @param message #LinphoneChatMessage object @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneImEncryptionEngineCbsGenerateFileTransferKeyCb)(LinphoneImEncryptionEngine *engine, LinphoneChatRoom *room, LinphoneChatMessage *msg); |
|---|
| | | typedef void (*LinphoneImEncryptionEngineCbsGenerateFileTransferKeyCb)(LinphoneImEncryptionEngine *engine, LinphoneChatRoom *chat_room, LinphoneChatMessage *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback to decrypt downloading file |
|---|
| | | * @param engine #LinphoneImEncryptionEngine object |
|---|
| | | * @param msg #LinphoneChatMessage object |
|---|
| | | * @param engine #LinphoneImEncryptionEngine object @notnil |
|---|
| | | * @param message #LinphoneChatMessage object @notnil |
|---|
| | | * @param offset The current offset of the upload |
|---|
| | | * @param[in] buffer Encrypted data buffer |
|---|
| | | * @param[in] size Size of the encrypted data buffer and maximum size of the decrypted data buffer |
|---|
| | | * @param[out] decrypted_buffer Buffer in which to write the decrypted data which maximum size is size |
|---|
| | | * @param buffer Encrypted data buffer @maybenil |
|---|
| | | * @param size Size of the encrypted data buffer and maximum size of the decrypted data buffer |
|---|
| | | * @param[out] decrypted_buffer Buffer in which to write the decrypted data which maximum size is size @notnil |
|---|
| | | * @return -1 if nothing to be done, 0 on success or an integer > 0 for error |
|---|
| | | */ |
|---|
| | | typedef int (*LinphoneImEncryptionEngineCbsDownloadingFileCb)(LinphoneImEncryptionEngine *engine, LinphoneChatMessage *msg, size_t offset, const uint8_t *buffer, size_t size, uint8_t *decrypted_buffer); |
|---|
| | | typedef int (*LinphoneImEncryptionEngineCbsDownloadingFileCb)(LinphoneImEncryptionEngine *engine, LinphoneChatMessage *message, size_t offset, const uint8_t *buffer, size_t size, uint8_t *decrypted_buffer); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback to encrypt uploading file |
|---|
| | | * @param engine #LinphoneImEncryptionEngine object |
|---|
| | | * @param msg #LinphoneChatMessage object |
|---|
| | | * @param engine #LinphoneImEncryptionEngine object @notnil |
|---|
| | | * @param message #LinphoneChatMessage object @notnil |
|---|
| | | * @param offset The current offset of the upload |
|---|
| | | * @param[in] buffer Encrypted data buffer |
|---|
| | | * @param buffer Encrypted data buffer @maybenil |
|---|
| | | * @param[in,out] size Size of the plain data buffer and the size of the encrypted data buffer once encryption is done |
|---|
| | | * @param[out] encrypted_buffer Buffer in which to write the encrypted data which maxmimum size is size |
|---|
| | | * @param[out] encrypted_buffer Buffer in which to write the encrypted data which maxmimum size is size @notnil |
|---|
| | | * @return -1 if nothing to be done, 0 on success or an integer > 0 for error |
|---|
| | | */ |
|---|
| | | typedef int (*LinphoneImEncryptionEngineCbsUploadingFileCb)(LinphoneImEncryptionEngine *engine, LinphoneChatMessage *msg, size_t offset, const uint8_t *buffer, size_t *size, uint8_t *encrypted_buffer); |
|---|
| | | typedef int (*LinphoneImEncryptionEngineCbsUploadingFileCb)(LinphoneImEncryptionEngine *engine, LinphoneChatMessage *message, size_t offset, const uint8_t *buffer, size_t *size, uint8_t *encrypted_buffer); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback used to notify the response to an XML-RPC request. |
|---|
| | | * @param[in] request #LinphoneXmlRpcRequest object |
|---|
| | | * @param request #LinphoneXmlRpcRequest object @notnil |
|---|
| | | **/ |
|---|
| | | typedef void (*LinphoneXmlRpcRequestCbsResponseCb)(LinphoneXmlRpcRequest *request); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback used to notify a chat room has been exhumed. Internal use only! |
|---|
| | | * @param core #LinphoneCore object @notnil |
|---|
| | | * @param chat_room #LinphoneChatRoom object @notnil |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | | typedef void (*LinphoneCoreCbsChatRoomExhumedCb)(LinphoneCore *core, LinphoneChatRoom *chat_room); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @} |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback for notifying end of play (file). |
|---|
| | | * @param[in] player The #LinphonePlayer object |
|---|
| | | * @param player The #LinphonePlayer object @notnil |
|---|
| | | **/ |
|---|
| | | typedef void (*LinphonePlayerCbsEofReachedCb)(LinphonePlayer *obj); |
|---|
| | | typedef void (*LinphonePlayerCbsEofReachedCb)(LinphonePlayer *player); |
|---|
| | | |
|---|
| | | /************ */ |
|---|
| | | /* DEPRECATED */ |
|---|
| | | /* ********** */ |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback prototype |
|---|
| | | * @param core #LinphoneCore object @notnil |
|---|
| | | * @param chat_room #LinphoneChatRoom involved in this conversation. Can be be created by the framework in case the From-URI is not present in any chat room. @notnil |
|---|
| | | * @param from #LinphoneAddress from @notnil |
|---|
| | | * @param message incoming message @notnil |
|---|
| | | * @deprecated 30/03/2017 use #LinphoneCoreMessageReceivedCb instead. |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreTextMessageReceivedCb)(LinphoneCore *core, LinphoneChatRoom *chat_room, const LinphoneAddress *from, const char *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Callback for requesting authentication information to application or user. |
|---|
| | | * @param core the #LinphoneCore @notnil |
|---|
| | | * @param realm the realm (domain) on which authentication is required. @notnil |
|---|
| | | * @param username the username that needs to be authenticated. @notnil |
|---|
| | | * @param domain the domain on which authentication is required. @notnil |
|---|
| | | * Application shall reply to this callback using linphone_core_add_auth_info(). |
|---|
| | | * @deprecated 08/07/2020 use #LinphoneCoreCbsAuthenticationRequestedCb instead |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneCoreAuthInfoRequestedCb)(LinphoneCore *core, const char *realm, const char *username, const char *domain); |
|---|
| | | |
|---|
| | | |
|---|
| | | /** |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | */ |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns an list of chat rooms |
|---|
| | | * @param[in] lc #LinphoneCore object |
|---|
| | | * @return \bctbx_list{LinphoneChatRoom} |
|---|
| | | * Returns a list of chat rooms |
|---|
| | | * @param core #LinphoneCore object @notnil |
|---|
| | | * @return List of chat rooms. \bctbx_list{LinphoneChatRoom} @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const bctbx_list_t* linphone_core_get_chat_rooms(LinphoneCore *lc); |
|---|
| | | LINPHONE_PUBLIC const bctbx_list_t* linphone_core_get_chat_rooms(LinphoneCore *core); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates and returns the default chat room parameters. |
|---|
| | | * @param[in] lc #LinphoneCore object |
|---|
| | | * @return LinphoneChatRoomParams |
|---|
| | | * @param core #LinphoneCore object @notnil |
|---|
| | | * @return A #LinphoneChatRoomParams object @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoomParams *linphone_core_create_default_chat_room_params(LinphoneCore *lc); |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoomParams *linphone_core_create_default_chat_room_params(LinphoneCore *core); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @} |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | extern "C" { |
|---|
| | | #endif |
|---|
| | | |
|---|
| | | typedef enum { |
|---|
| | | LinphoneConferenceClassLocal, |
|---|
| | | LinphoneConferenceClassRemote |
|---|
| | | } LinphoneConferenceClass; |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @addtogroup call_control |
|---|
| | | * @{ |
|---|
| | | */ |
|---|
| | | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Create a #LinphoneConferenceParams with default parameters set. |
|---|
| | | * @param core #LinphoneCore to use to find out the default parameters. Can be NULL. |
|---|
| | | * @return A freshly allocated #LinphoneConferenceParams |
|---|
| | | * Create an object of type a #LinphoneConferenceParams. |
|---|
| | | * @param core The #LinphoneCore to pass to the constructor. @notnil |
|---|
| | | * @return The created #LinphoneConferenceParams. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneConferenceParams *linphone_conference_params_new(const LinphoneCore *core); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Take a reference on a #LinphoneConferencParams. |
|---|
| | | * @param[in] params The #LinphoneConferenceParams to ref. |
|---|
| | | * @return The freshly refed #LinphoneConferenceParams. |
|---|
| | | * Take a reference on a #LinphoneConferenceParams. |
|---|
| | | * @param params The #LinphoneConferenceParams to ref. @notnil |
|---|
| | | * @return The freshly refed #LinphoneConferenceParams. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneConferenceParams *linphone_conference_params_ref(LinphoneConferenceParams *params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Release a #LinphoneConferenceParams. |
|---|
| | | * @param[in] params The #LinphoneConferenceParams to release. |
|---|
| | | * @param params The #LinphoneConferenceParams to release. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_conference_params_unref(LinphoneConferenceParams *params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Free a #LinphoneConferenceParams |
|---|
| | | * @param params #LinphoneConferenceParams to free |
|---|
| | | * @deprecated Use linphone_conference_params_unref() instead. |
|---|
| | | * @param params #LinphoneConferenceParams to free @notnil |
|---|
| | | * @deprecated 17/03/2017 Use linphone_conference_params_unref() instead. |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED void linphone_conference_params_free(LinphoneConferenceParams *params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Clone a #LinphoneConferenceParams |
|---|
| | | * @param params The #LinphoneConferenceParams to clone |
|---|
| | | * @return An allocated #LinphoneConferenceParams with the same parameters than params |
|---|
| | | * @param params The #LinphoneConferenceParams to clone @notnil |
|---|
| | | * @return An allocated #LinphoneConferenceParams with the same parameters than params @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneConferenceParams *linphone_conference_params_clone(const LinphoneConferenceParams *params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Enable video when starting a conference |
|---|
| | | * @param params A #LinphoneConferenceParams |
|---|
| | | * @param params A #LinphoneConferenceParams @notnil |
|---|
| | | * @param enable If true, video will be enabled during conference |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_conference_params_enable_video(LinphoneConferenceParams *params, bool_t enable); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Check whether video will be enable at conference starting |
|---|
| | | * @return if true, the video will be enable at conference starting |
|---|
| | | * @param params A #LinphoneConferenceParams @notnil |
|---|
| | | * @return TRUE if the video will be enable at conference starting, FALSE otherwise |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_conference_params_video_requested(const LinphoneConferenceParams *params); |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_conference_params_video_enabled(const LinphoneConferenceParams *params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Enable local participant to enter the conference. |
|---|
| | | * The local participant is the one driving the local #LinphoneCore. It uses the local sound devices. |
|---|
| | | * The default value is TRUE. Setting to FALSE is mostly helpful when using liblinphone on a server application. |
|---|
| | | * @param params A #LinphoneConferenceParams @notnil |
|---|
| | | * @param enable TRUE if local participant is automatically added to the conference, FALSE otherwise |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_conference_params_enable_local_participant(LinphoneConferenceParams *params, bool_t enable); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns whether local participant has to enter the conference. |
|---|
| | | * @param params A #LinphoneConferenceParams @notnil |
|---|
| | | * @return TRUE if local participant is by default part of the conference, FALSE otherwise |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_conference_params_local_participant_enabled(const LinphoneConferenceParams *params); |
|---|
| | | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Take a reference on a #LinphoneConference. |
|---|
| | | * @param[in] conf The #LinphoneConference to ref. |
|---|
| | | * @return The freshly refed #LinphoneConference. |
|---|
| | | * @param conf The #LinphoneConference to ref. @notnil |
|---|
| | | * @return The same #LinphoneConference object. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneConference *linphone_conference_ref(LinphoneConference *conf); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Release a #LinphoneConference. |
|---|
| | | * @param[in] conf The #LinphoneConference to release. |
|---|
| | | * @param conf The #LinphoneConference to release. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_conference_unref(LinphoneConference *conf); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Remove a participant from a conference |
|---|
| | | * @param obj A #LinphoneConference |
|---|
| | | * @param uri SIP URI of the participant to remove |
|---|
| | | * @warning The passed SIP URI must be one of the URIs returned by linphone_conference_get_participants() |
|---|
| | | * @return 0 if succeeded, -1 if failed |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_conference_remove_participant(LinphoneConference *obj, const LinphoneAddress *uri); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get URIs of all participants of one conference |
|---|
| | | * The returned bctbx_list_t contains URIs of all participant. That list must be |
|---|
| | | * freed after use and each URI must be unref with linphone_address_unref() |
|---|
| | | * @param obj A #LinphoneConference |
|---|
| | | * @return \bctbx_list{LinphoneAddress} |
|---|
| | | * @param conf A #LinphoneConference @notnil |
|---|
| | | * @return The list of the participants' address. \bctbx_list{LinphoneAddress} @maybenil |
|---|
| | | * @deprecated 10/07/2020 Use linphone_conference_get_participant_list() instead. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bctbx_list_t *linphone_conference_get_participants(const LinphoneConference *obj); |
|---|
| | | LINPHONE_PUBLIC bctbx_list_t *linphone_conference_get_participants(const LinphoneConference *conf); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get list of all participants of one conference |
|---|
| | | * @param conf A #LinphoneConference @notnil |
|---|
| | | * @return A list of participants. \bctbx_list{LinphoneParticipant} @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bctbx_list_t *linphone_conference_get_participant_list(const LinphoneConference *conf); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @param conference A #LinphoneConference @notnil |
|---|
| | | * @param uri URI of the participant to remove @notnil |
|---|
| | | * @warning The passed participant uri must be one of those returned by linphone_conference_get_participants() |
|---|
| | | * @return 0 if succeeded, -1 if failed |
|---|
| | | * @deprecated 10/07/2020 Use linphone_conference_remove_participant_2() instead. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_conference_remove_participant(LinphoneConference *conference, const LinphoneAddress *uri); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @param conference A #LinphoneConference @notnil |
|---|
| | | * @param participant participant to remove @notnil |
|---|
| | | * @warning The passed participant must be one of those returned by linphone_conference_get_participant_list() |
|---|
| | | * @warning This method may destroy the conference if the only remaining participant had an existing call to the local participant before the conference was created |
|---|
| | | * @return 0 if succeeded, -1 if failed |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_conference_remove_participant_2(LinphoneConference *conference, LinphoneParticipant *participant); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @param conference A #LinphoneConference @notnil |
|---|
| | | * @param call call to remove @notnil |
|---|
| | | * @return 0 if succeeded, -1 if failed |
|---|
| | | * @deprecated 10/07/2020 Use linphone_conference_remove_participant_2() instead. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_conference_remove_participant_3(LinphoneConference *conference, LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Find a participant from a conference |
|---|
| | | * @param conference A #LinphoneConference. @notnil |
|---|
| | | * @param uri SIP URI of the participant to search. @notnil |
|---|
| | | * @return a pointer to the participant found or nullptr. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneParticipant * linphone_conference_find_participant(LinphoneConference *conference, const LinphoneAddress *uri); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Invite participants to the conference, by supplying a list of #LinphoneAddress |
|---|
| | | * @param obj The conference. |
|---|
| | | * @param addresses \bctbx_list{LinphoneAddress} |
|---|
| | | * @param params #LinphoneCallParams to use for inviting the participants. |
|---|
| | | * @param conf The #LinphoneConference object. @notnil |
|---|
| | | * @param addresses A list of SIP addresses to invite. @bctbx_list{LinphoneAddress} @notnil |
|---|
| | | * @param params #LinphoneCallParams to use for inviting the participants. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_conference_invite_participants(LinphoneConference *conf, const bctbx_list_t *addresses, const LinphoneCallParams *params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the conference id as string |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_conference_get_ID(const LinphoneConference *obj); |
|---|
| | | * Join an existing call to the conference. |
|---|
| | | * @param conf The #LinphoneConference object. @notnil |
|---|
| | | * @param call a #LinphoneCall that has to be added to the conference. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_conference_add_participant(LinphoneConference *conference, LinphoneCall *call); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the conference id as string |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_conference_set_ID(const LinphoneConference *obj, const char *conferenceID); |
|---|
| | | * Join a participant to the conference. |
|---|
| | | * @param conference The #LinphoneConference object. @notnil |
|---|
| | | * @param uri a #LinphoneAddress that has to be added to the conference. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_conference_add_participant_2 (LinphoneConference *conference, const LinphoneAddress *uri); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Update parameters of the conference. |
|---|
| | | * This is typically used enable or disable the video stream in the conference. |
|---|
| | | * @param conf The #LinphoneConference object. @notnil |
|---|
| | | * @param params the new parameters to apply. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC int linphone_conference_update_params(LinphoneConference *conf, const LinphoneConferenceParams *params); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get current parameters of the conference. |
|---|
| | | * @param conf The #LinphoneConference object. @notnil |
|---|
| | | * @return a #LinphoneConferenceParams . @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const LinphoneConferenceParams * linphone_conference_get_current_params(const LinphoneConference *conf); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the conference subject |
|---|
| | | * @param conference The #LinphoneConference object. @notnil |
|---|
| | | * @return conference subject. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_conference_get_subject(const LinphoneConference *conference); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the conference subject |
|---|
| | | * @param conference The #LinphoneConference object. @notnil |
|---|
| | | * @param subject conference subject @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_conference_set_subject(LinphoneConference *conference, const char *subject); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get number of participants |
|---|
| | | * @param conference The #LinphoneConference object. @notnil |
|---|
| | | * @return the number of participants in a #LinphoneConference |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC int linphone_conference_get_participant_count(const LinphoneConference *conference); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * For a local audio video conference, this function returns the participant hosting the conference |
|---|
| | | * For a remote audio video conference, this function returns the focus of the conference |
|---|
| | | * @param conference The #LinphoneConference object. @notnil |
|---|
| | | * @return a #LinphoneParticipant . @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneParticipant *linphone_conference_get_me(const LinphoneConference *conference); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Terminates conference |
|---|
| | | * @param conference The #LinphoneConference object. @notnil |
|---|
| | | * @return 0 if the termination is successful, -1 otherwise. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC int linphone_conference_terminate(LinphoneConference *conference); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Retrieves the user pointer that was given to linphone_conference_new() |
|---|
| | | * @param conference #LinphoneConference object @notnil |
|---|
| | | * @return The user data associated with the #LinphoneConference object. @maybenil |
|---|
| | | * @ingroup initializing |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void *linphone_conference_get_user_data(const LinphoneConference *conference); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Associate a user pointer to the linphone conference. |
|---|
| | | * @param core #LinphoneConference object @notnil |
|---|
| | | * @param user_data The user data to associate with the #LinphoneConference object. @maybenil |
|---|
| | | * @ingroup initializing |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_conference_set_user_data(LinphoneConference *conference, void *user_data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Call generic OpenGL render preview for a given conference |
|---|
| | | * @param conf The #LinphoneConference object. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_conference_preview_ogl_render(LinphoneConference *conf); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Call generic OpenGL render for a given conference |
|---|
| | | * @param conf The #LinphoneConference object. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_conference_ogl_render(LinphoneConference *conf); |
|---|
| | | /** |
|---|
| | | * Get the conference id as string |
|---|
| | | * @param conf The #LinphoneConference object. @notnil |
|---|
| | | * @return the conference id @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_conference_get_ID(const LinphoneConference *conf); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the conference id as string |
|---|
| | | * @param conf The #LinphoneConference object. @notnil |
|---|
| | | * @param conference_id the conference id to set. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_conference_set_ID(LinphoneConference *conf, const char *conference_id); |
|---|
| | | |
|---|
| | | /************ */ |
|---|
| | | /* DEPRECATED */ |
|---|
| | | /* ********** */ |
|---|
| | | |
|---|
| | | LINPHONE_PUBLIC int linphone_conference_enter(LinphoneConference *conference); |
|---|
| | | int linphone_conference_leave(LinphoneConference *conference); |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_conference_is_in(const LinphoneConference *conference); |
|---|
| | | |
|---|
| | | LinphoneConference *linphone_local_conference_new(LinphoneCore *core, LinphoneAddress * addr); |
|---|
| | | LinphoneConference *linphone_local_conference_new_with_params(LinphoneCore *core, LinphoneAddress * addr, const LinphoneConferenceParams *params); |
|---|
| | | LinphoneConference *linphone_remote_conference_new(LinphoneCore *core, LinphoneAddress * addr); |
|---|
| | | LinphoneConference *linphone_remote_conference_new_with_params(LinphoneCore *core, LinphoneAddress * focus, LinphoneAddress * addr, const LinphoneConferenceParams *params); |
|---|
| | | |
|---|
| | | int linphone_conference_get_size(const LinphoneConference *conference); |
|---|
| | | |
|---|
| | | /* This is actually only used by the ToneManager. TODO: encapsulate this better. */ |
|---|
| | | AudioStream *linphone_conference_get_audio_stream(LinphoneConference *conference); |
|---|
| | | |
|---|
| | | int linphone_conference_mute_microphone(LinphoneConference *conference, bool_t val); |
|---|
| | | bool_t linphone_conference_microphone_is_muted(const LinphoneConference *conference); |
|---|
| | | float linphone_conference_get_input_volume(const LinphoneConference *conference); |
|---|
| | | |
|---|
| | | int linphone_conference_start_recording(LinphoneConference *conference, const char *path); |
|---|
| | | int linphone_conference_stop_recording(LinphoneConference *conference); |
|---|
| | | |
|---|
| | | void linphone_conference_on_call_terminating(LinphoneConference *conference, LinphoneCall *call); |
|---|
| | | |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_conference_check_class(LinphoneConference *conference, LinphoneConferenceClass _class); |
|---|
| | | |
|---|
| | | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @} |
|---|
old mode 100644
new mode 100755
old mode 100644
new mode 100755
old mode 100644
new mode 100755
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Starts an echo calibration of the sound devices, in order to find adequate settings for the echo canceler automatically. |
|---|
| | | * @deprecated Use #linphone_core_start_echo_canceller_calibration() instead. To set the callbacks create or get an already instantiated |
|---|
| | | * @deprecated 16/10/2017 Use #linphone_core_start_echo_canceller_calibration() instead. To set the callbacks create or get an already instantiated |
|---|
| | | * #LinphoneCoreCbs and call #linphone_core_cbs_set_ec_calibration_result(), #linphone_core_cbs_set_ec_calibration_audio_init() and |
|---|
| | | * #linphone_core_cbs_set_ec_callibration_audio_uninit(). Deprecated since 2017-10-16. |
|---|
| | | * @ingroup misc |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Starts an echo calibration of the sound devices, in order to find adequate settings for the echo canceler automatically. |
|---|
| | | * @param[in] lc #LinphoneCore object. |
|---|
| | | * @param core #LinphoneCore object. @notnil |
|---|
| | | * @return #LinphoneStatus whether calibration has started or not. |
|---|
| | | * @ingroup misc |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_core_start_echo_canceller_calibration(LinphoneCore *lc); |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_core_start_echo_canceller_calibration(LinphoneCore *core); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Start the simulation of call to test the latency with an external device |
|---|
| | | * @param lc The core. |
|---|
| | | * @param core The #LinphoneCore object. @notnil |
|---|
| | | * @param rate Sound sample rate. |
|---|
| | | * @return -1 in case of failure, 1 otherwise. |
|---|
| | | * @ingroup misc |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_core_start_echo_tester(LinphoneCore *lc, unsigned int rate); |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_core_start_echo_tester(LinphoneCore *core, unsigned int rate); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Stop the simulation of call |
|---|
| | | * @param core The #LinphoneCore object. @notnil |
|---|
| | | * @ingroup misc |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_core_stop_echo_tester(LinphoneCore *lc); |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_core_stop_echo_tester(LinphoneCore *core); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Check whether the device is flagged has crappy opengl |
|---|
| | | * @returns TRUE if crappy opengl flag is set, FALSE otherwise |
|---|
| | | * @param core The #LinphoneCore object. @notnil |
|---|
| | | * @return TRUE if crappy opengl flag is set, FALSE otherwise |
|---|
| | | * @ingroup misc |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_core_has_crappy_opengl(LinphoneCore *lc); |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_core_has_crappy_opengl(LinphoneCore *core); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Check whether the device has a hardware echo canceller |
|---|
| | | * @returns TRUE if it does, FALSE otherwise |
|---|
| | | * @param core The #LinphoneCore object. @notnil |
|---|
| | | * @return TRUE if it does, FALSE otherwise |
|---|
| | | * @ingroup misc |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_core_has_builtin_echo_canceller(LinphoneCore *lc); |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_core_has_builtin_echo_canceller(LinphoneCore *core); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Check whether the device is echo canceller calibration is required |
|---|
| | | * @returns TRUE if it is required, FALSE otherwise |
|---|
| | | * @param core The #LinphoneCore object. @notnil |
|---|
| | | * @return TRUE if it is required, FALSE otherwise |
|---|
| | | * @ingroup misc |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_core_is_echo_canceller_calibration_required(LinphoneCore *lc); |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_core_is_echo_canceller_calibration_required(LinphoneCore *core); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @ingroup IOS |
|---|
| | | * Special function to warm up dtmf feeback stream. #linphone_core_stop_dtmf_stream must() be called before entering FG mode |
|---|
| | | * @param core The #LinphoneCore object. @notnil |
|---|
| | | * Special function to warm up dtmf feeback stream. #linphone_core_stop_dtmf_stream() must be called before entering FG mode |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_core_start_dtmf_stream(LinphoneCore* lc); |
|---|
| | | LINPHONE_PUBLIC void linphone_core_start_dtmf_stream(LinphoneCore* core); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @ingroup IOS |
|---|
| | | * @param core The #LinphoneCore object. @notnil |
|---|
| | | * Special function to stop dtmf feed back function. Must be called before entering BG mode |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_core_stop_dtmf_stream(LinphoneCore* lc); |
|---|
| | | LINPHONE_PUBLIC void linphone_core_stop_dtmf_stream(LinphoneCore* core); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Special function to indicate if the audio session is activated. Must be called when ProviderDelegate of the callkit notifies that the audio session is activated or deactivated. |
|---|
| | | * @param core The #LinphoneCore object. @notnil |
|---|
| | | * @param activated TRUE to activate the audio session, FALSE to disable it. |
|---|
| | | * @ingroup IOS |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_core_activate_audio_session(LinphoneCore* core, bool_t actived); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Special function to configure audio session with default settings. Must be called in ProviderDelegate's callbacks when answer an incoming call and start an outgoing call. |
|---|
| | | * @param core The #LinphoneCore object. @notnil |
|---|
| | | * @ingroup IOS |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_core_configure_audio_session(LinphoneCore* core); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Special function to enable the callkit. |
|---|
| | | * @param core The #LinphoneCore object. @notnil |
|---|
| | | * @param enabled TRUE to enable callkit, FALSE to disable it. |
|---|
| | | * @ingroup IOS |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_core_enable_callkit (LinphoneCore* core, bool_t enabled); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Special function to indicate if the audio route is changed. Must be called in the callback of AVAudioSessionRouteChangeNotification. |
|---|
| | | * @param core The #LinphoneCore object. @notnil |
|---|
| | | * @ingroup IOS |
|---|
| | | * @deprecated 07/01/2020 now handled in the linphone SDK directly |
|---|
| | | */ |
|---|
| | | LINPHONE_DEPRECATED LINPHONE_PUBLIC void linphone_core_audio_route_changed (LinphoneCore *core); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Special function to check if the callkit is enabled, False by default. |
|---|
| | | * @param core The #LinphoneCore object. @notnil |
|---|
| | | * @return TRUE if callkit is enabled, FALSE otherwise. |
|---|
| | | * @ingroup IOS |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_core_callkit_enabled (const LinphoneCore *core); |
|---|
| | | |
|---|
| | | typedef bool_t (*LinphoneCoreIterateHook)(void *data); |
|---|
| | | |
|---|
old mode 100644
new mode 100755
old mode 100644
new mode 100755
old mode 100644
new mode 100755
| | |
|---|
| | | #define _L_CALL_ENUMS_H_ |
|---|
| | | |
|---|
| | | // ============================================================================= |
|---|
| | | /** |
|---|
| | | * #LinphoneCallState enum represents the different states a call can reach into. |
|---|
| | | * The application is notified of a state change through the LinphoneCoreVTable::call_state_changed callback. |
|---|
| | | * @ingroup call_control |
|---|
| | | */ |
|---|
| | | typedef enum _LinphoneCallState{ |
|---|
| | | LinphoneCallStateIdle, /**< Initial state */ |
|---|
| | | LinphoneCallStateIncomingReceived, /**< Incoming call received */ |
|---|
| | | LinphoneCallStatePushIncomingReceived, /**< PushIncoming call received */ |
|---|
| | | LinphoneCallStateOutgoingInit, /**< Outgoing call initialized */ |
|---|
| | | LinphoneCallStateOutgoingProgress, /**< Outgoing call in progress */ |
|---|
| | | LinphoneCallStateOutgoingRinging, /**< Outgoing call ringing */ |
|---|
| | | LinphoneCallStateOutgoingEarlyMedia, /**< Outgoing call early media */ |
|---|
| | | LinphoneCallStateConnected, /**< Connected */ |
|---|
| | | LinphoneCallStateStreamsRunning, /**< Streams running */ |
|---|
| | | LinphoneCallStatePausing, /**< Pausing */ |
|---|
| | | LinphoneCallStatePaused, /**< Paused */ |
|---|
| | | LinphoneCallStateResuming, /**< Resuming */ |
|---|
| | | LinphoneCallStateReferred, /**< Referred */ |
|---|
| | | LinphoneCallStateError, /**< Error */ |
|---|
| | | LinphoneCallStateEnd, /**< Call end */ |
|---|
| | | LinphoneCallStatePausedByRemote, /**< Paused by remote */ |
|---|
| | | LinphoneCallStateUpdatedByRemote, /**< The call's parameters are updated for example when video is asked by remote */ |
|---|
| | | LinphoneCallStateIncomingEarlyMedia, /**< We are proposing early media to an incoming call */ |
|---|
| | | LinphoneCallStateUpdating, /**< We have initiated a call update */ |
|---|
| | | LinphoneCallStateReleased, /**< The call object is now released */ |
|---|
| | | LinphoneCallStateEarlyUpdatedByRemote, /**< The call is updated by remote while not yet answered (SIP UPDATE in early dialog received) */ |
|---|
| | | LinphoneCallStateEarlyUpdating, /**< We are updating the call while not yet answered (SIP UPDATE in early dialog sent) */ |
|---|
| | | } LinphoneCallState; |
|---|
| | | |
|---|
| | | #define L_ENUM_VALUES_CALL_SESSION_STATE(F) \ |
|---|
| | | F(Idle /**< Initial state */) \ |
|---|
| | | F(IncomingReceived /**< Incoming call received */) \ |
|---|
| | | F(OutgoingInit /**< Outgoing call initialized */) \ |
|---|
| | | F(OutgoingProgress /**< Outgoing call in progress */) \ |
|---|
| | | F(OutgoingRinging /**< Outgoing call ringing */) \ |
|---|
| | | F(OutgoingEarlyMedia /**< Outgoing call early media */) \ |
|---|
| | | F(Connected /**< Connected */) \ |
|---|
| | | F(StreamsRunning /**< Streams running */) \ |
|---|
| | | F(Pausing /**< Pausing */) \ |
|---|
| | | F(Paused /**< Paused */) \ |
|---|
| | | F(Resuming /**< Resuming */) \ |
|---|
| | | F(Referred /**< Referred */) \ |
|---|
| | | F(Error /**< Error */) \ |
|---|
| | | F(End /**< Call end */) \ |
|---|
| | | F(PausedByRemote /**< Paused by remote */) \ |
|---|
| | | F(UpdatedByRemote /**< The call's parameters are updated for example when video is asked by remote */) \ |
|---|
| | | F(IncomingEarlyMedia /**< We are proposing early media to an incoming call */) \ |
|---|
| | | F(Updating /**< We have initiated a call update */) \ |
|---|
| | | F(Released /**< The call object is now released */) \ |
|---|
| | | F(EarlyUpdatedByRemote /**< The call is updated by remote while not yet answered (SIP UPDATE in early dialog received) */) \ |
|---|
| | | F(EarlyUpdating /**< We are updating the call while not yet answered (SIP UPDATE in early dialog sent) */) |
|---|
| | | /** |
|---|
| | | * #LinphoneAudioDeviceType enum represents the different types of an audio device. |
|---|
| | | * @ingroup audio |
|---|
| | | */ |
|---|
| | | typedef enum _LinphoneAudioDeviceType { |
|---|
| | | LinphoneAudioDeviceTypeUnknown, /** Unknown */ |
|---|
| | | LinphoneAudioDeviceTypeMicrophone, /** Microphone */ |
|---|
| | | LinphoneAudioDeviceTypeEarpiece, /** Earpiece */ |
|---|
| | | LinphoneAudioDeviceTypeSpeaker, /** Speaker */ |
|---|
| | | LinphoneAudioDeviceTypeBluetooth, /** Bluetooth */ |
|---|
| | | LinphoneAudioDeviceTypeBluetoothA2DP, /** Bluetooth A2DP */ |
|---|
| | | LinphoneAudioDeviceTypeTelephony, /** Telephony */ |
|---|
| | | LinphoneAudioDeviceTypeAuxLine, /** AuxLine */ |
|---|
| | | LinphoneAudioDeviceTypeGenericUsb, /** GenericUsb */ |
|---|
| | | LinphoneAudioDeviceTypeHeadset, /** Headset */ |
|---|
| | | LinphoneAudioDeviceTypeHeadphones, /** Headphones */ |
|---|
| | | } LinphoneAudioDeviceType; |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * #LinphoneAudioDeviceCapabilities enum represents whether a device can record audio, play audio or both |
|---|
| | | * @ingroup audio |
|---|
| | | */ |
|---|
| | | typedef enum _LinphoneAudioDeviceCapabilities { |
|---|
| | | LinphoneAudioDeviceCapabilityRecord = 1 << 0, /** Can record audio */ |
|---|
| | | LinphoneAudioDeviceCapabilityPlay = 1 << 1, /** Can play audio */ |
|---|
| | | } LinphoneAudioDeviceCapabilities; |
|---|
| | | |
|---|
| | | // ============================================================================= |
|---|
| | | // DEPRECATED |
|---|
| | |
|---|
| | | |
|---|
| | | #define LinphoneCallIdle LinphoneCallStateIdle |
|---|
| | | #define LinphoneCallIncomingReceived LinphoneCallStateIncomingReceived |
|---|
| | | #define LinphoneCallPushIncomingReceived LinphoneCallStatePushIncomingReceived |
|---|
| | | #define LinphoneCallOutgoingInit LinphoneCallStateOutgoingInit |
|---|
| | | #define LinphoneCallOutgoingProgress LinphoneCallStateOutgoingProgress |
|---|
| | | #define LinphoneCallOutgoingRinging LinphoneCallStateOutgoingRinging |
|---|
| | |
|---|
| | | #define LinphoneCallUpdatedByRemote LinphoneCallStateUpdatedByRemote |
|---|
| | | #define LinphoneCallIncomingEarlyMedia LinphoneCallStateIncomingEarlyMedia |
|---|
| | | #define LinphoneCallUpdating LinphoneCallStateUpdating |
|---|
| | | #define LinphoneCallEarlyUpdating LinphoneCallStateEarlyUpdating |
|---|
| | | #define LinphoneCallReleased LinphoneCallStateReleased |
|---|
| | | #define LinphoneCallEarlyUpdatedByRemote LinphoneCallStateEarlyUpdatedByRemote |
|---|
| | | #define LinphoneCallEarlyUpdating LinphoneCallStateEarlyUpdating |
|---|
| | | |
|---|
| | | #endif // ifndef _L_CALL_ENUMS_H_ |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | |
|---|
| | | // ============================================================================= |
|---|
| | | |
|---|
| | | #define L_ENUM_VALUES_CHAT_MESSAGE_STATE(F) \ |
|---|
| | | F(Idle /**< Initial state */) \ |
|---|
| | | F(InProgress /**< Delivery in progress */) \ |
|---|
| | | F(Delivered /**< Message successfully delivered and acknowledged by the server */) \ |
|---|
| | | F(NotDelivered /**< Message was not delivered */) \ |
|---|
| | | F(FileTransferError /**< Message was received and acknowledged but cannot get file from server */) \ |
|---|
| | | F(FileTransferDone /**< File transfer has been completed successfully */) \ |
|---|
| | | F(DeliveredToUser /**< Message successfully delivered an acknowledged by the remote user */) \ |
|---|
| | | F(Displayed /**< Message successfully displayed to the remote user */) \ |
|---|
| | | F(FileTransferInProgress /** <File transfer is in progress. If message is incoming it's a download, otherwise it's an upload. */) |
|---|
| | | /** |
|---|
| | | * #LinphoneChatMessageState is used to notify if messages have been successfully delivered or not. |
|---|
| | | * @ingroup chatroom |
|---|
| | | */ |
|---|
| | | typedef enum _LinphoneChatMessageState{ |
|---|
| | | LinphoneChatMessageStateIdle, /**< Initial state */ |
|---|
| | | LinphoneChatMessageStateInProgress, /**< Delivery in progress */ |
|---|
| | | LinphoneChatMessageStateDelivered, /**< Message successfully delivered and acknowledged by the server */ |
|---|
| | | LinphoneChatMessageStateNotDelivered, /**< Message was not delivered */ |
|---|
| | | LinphoneChatMessageStateFileTransferError, /**< Message was received and acknowledged but cannot get file from server */ |
|---|
| | | LinphoneChatMessageStateFileTransferDone, /**< File transfer has been completed successfully */ |
|---|
| | | LinphoneChatMessageStateDeliveredToUser, /**< Message successfully delivered an acknowledged by the remote user */ |
|---|
| | | LinphoneChatMessageStateDisplayed, /**< Message successfully displayed to the remote user */ |
|---|
| | | LinphoneChatMessageStateFileTransferInProgress, /** <File transfer is in progress. If message is incoming it's a download, otherwise it's an upload. */ |
|---|
| | | } LinphoneChatMessageState; |
|---|
| | | |
|---|
| | | #define L_ENUM_VALUES_CHAT_MESSAGE_DIRECTION(F) \ |
|---|
| | | F(Incoming /**< Incoming message */) \ |
|---|
| | | F(Outgoing /**< Outgoing message */) |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * #LinphoneChatMessageDirection is used to indicate if a message is outgoing or incoming. |
|---|
| | | * @ingroup chatroom |
|---|
| | | */ |
|---|
| | | typedef enum _LinphoneChatMessageDirection{ |
|---|
| | | LinphoneChatMessageDirectionIncoming, /**< Incoming message */ |
|---|
| | | LinphoneChatMessageDirectionOutgoing, /**< Outgoing message */ |
|---|
| | | } LinphoneChatMessageDirection; |
|---|
| | | |
|---|
| | | |
|---|
| | | #endif // ifndef _L_CHAT_MESSAGE_ENUMS_H_ |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | #define _L_CHAT_ROOM_ENUMS_H_ |
|---|
| | | |
|---|
| | | // ============================================================================= |
|---|
| | | /** |
|---|
| | | * #LinphoneChatRoomState is used to indicate the current state of a chat room. |
|---|
| | | * @ingroup chatroom |
|---|
| | | */ |
|---|
| | | typedef enum _LinphoneChatRoomState{ |
|---|
| | | LinphoneChatRoomStateNone, /**< Initial state */ |
|---|
| | | LinphoneChatRoomStateInstantiated, /**< Chat room is now instantiated on local */ |
|---|
| | | LinphoneChatRoomStateCreationPending, /**< One creation request was sent to the server */ |
|---|
| | | LinphoneChatRoomStateCreated, /**< Chat room was created on the server */ |
|---|
| | | LinphoneChatRoomStateCreationFailed, /**< Chat room creation failed */ |
|---|
| | | LinphoneChatRoomStateTerminationPending, /**< Wait for chat room termination */ |
|---|
| | | LinphoneChatRoomStateTerminated, /**< Chat room exists on server but not in local */ |
|---|
| | | LinphoneChatRoomStateTerminationFailed, /**< The chat room termination failed */ |
|---|
| | | LinphoneChatRoomStateDeleted, /**< Chat room was deleted on the server */ |
|---|
| | | } LinphoneChatRoomState; |
|---|
| | | |
|---|
| | | #define L_ENUM_VALUES_CHAT_ROOM_STATE(F) \ |
|---|
| | | F(None /**< Initial state */) \ |
|---|
| | | F(Instantiated /**< Chat room is now instantiated on local */) \ |
|---|
| | | F(CreationPending /**< One creation request was sent to the server */) \ |
|---|
| | | F(Created /**< Chat room was created on the server */) \ |
|---|
| | | F(CreationFailed /**< Chat room creation failed */) \ |
|---|
| | | F(TerminationPending /**< Wait for chat room termination */) \ |
|---|
| | | F(Terminated /**< Chat room exists on server but not in local */) \ |
|---|
| | | F(TerminationFailed /**< The chat room termination failed */) \ |
|---|
| | | F(Deleted /**< Chat room was deleted on the server */) |
|---|
| | | /** |
|---|
| | | * #LinphoneChatRoomCapabilities is used to indicate the capabilities of a chat room. |
|---|
| | | * @ingroup chatroom |
|---|
| | | */ |
|---|
| | | typedef enum _LinphoneChatRoomCapabilities{ |
|---|
| | | LinphoneChatRoomCapabilitiesNone = 0, /**< No capabilities. */ |
|---|
| | | LinphoneChatRoomCapabilitiesBasic = 1 << 0 , /**< No server. It's a direct communication */ |
|---|
| | | LinphoneChatRoomCapabilitiesRealTimeText = 1 << 1, /**< Supports RTT */ |
|---|
| | | LinphoneChatRoomCapabilitiesConference = 1 << 2, /**< Use server (supports group chat) */ |
|---|
| | | LinphoneChatRoomCapabilitiesProxy = 1 << 3, /**< Special proxy chat room flag */ |
|---|
| | | LinphoneChatRoomCapabilitiesMigratable = 1 << 4, /**< Chat room migratable from Basic to Conference */ |
|---|
| | | LinphoneChatRoomCapabilitiesOneToOne = 1 << 5, /**< A communication between two participants (can be Basic or Conference) */ |
|---|
| | | LinphoneChatRoomCapabilitiesEncrypted = 1 << 6 /**< Chat room is encrypted */ |
|---|
| | | } LinphoneChatRoomCapabilities; |
|---|
| | | |
|---|
| | | //To be deprecated |
|---|
| | | #define L_ENUM_VALUES_CHAT_ROOM_CAPABILITIES(F) \ |
|---|
| | | F(None /**< No capabilities. */, 0) \ |
|---|
| | | F(Basic /**< No server. It's a direct communication */, 1 << 0) \ |
|---|
| | | F(RealTimeText /**< Supports RTT */, 1 << 1) \ |
|---|
| | | F(Conference /**< Use server (supports group chat) */, 1 << 2) \ |
|---|
| | | F(Proxy /**< Special proxy chat room flag */, 1 << 3) \ |
|---|
| | | F(Migratable /**< Chat room migratable from Basic to Conference */, 1 << 4) \ |
|---|
| | | F(OneToOne /**< A communication between two participants (can be Basic or Conference) */, 1 << 5) \ |
|---|
| | | F(Encrypted /**< Chat room is encrypted */, 1 << 6) |
|---|
| | | |
|---|
| | | #define L_ENUM_VALUES_CHAT_ROOM_BACKEND(F) \ |
|---|
| | | F(Basic /**< Basic (client-to-client) chat room. */, 1 << 0) \ |
|---|
| | | F(FlexisipChat /**< Server-based chat room. */, 1 << 1) |
|---|
| | | /** |
|---|
| | | * #LinphoneChatRoomBackend is used to indicate the backend implementation of a chat room. |
|---|
| | | * @ingroup chatroom |
|---|
| | | */ |
|---|
| | | typedef enum _LinphoneChatRoomBackend{ |
|---|
| | | LinphoneChatRoomBackendBasic = 1 << 0, /**< Basic (client-to-client) chat room. */ |
|---|
| | | LinphoneChatRoomBackendFlexisipChat = 1 << 1 /**< Server-based chat room. */ |
|---|
| | | } LinphoneChatRoomBackend; |
|---|
| | | |
|---|
| | | #define L_ENUM_VALUES_CHAT_ROOM_ENCRYPTION_BACKEND(F) \ |
|---|
| | | F(None /**< No encryption. */, 0) \ |
|---|
| | | F(Lime /**< Lime x3dh encryption. */, 1 << 0) |
|---|
| | | /** |
|---|
| | | * #LinphoneChatRoomEncryptionBackend is used to indicate the encryption engine used by a chat room. |
|---|
| | | * @ingroup chatroom |
|---|
| | | */ |
|---|
| | | typedef enum _LinphoneChatRoomEncryptionBackend{ |
|---|
| | | LinphoneChatRoomEncryptionBackendNone = 0, /**< No encryption. */ |
|---|
| | | LinphoneChatRoomEncryptionBackendLime = 1 << 0 /**< Lime x3dh encryption. */ |
|---|
| | | } LinphoneChatRoomEncryptionBackend; |
|---|
| | | |
|---|
| | | |
|---|
| | | #endif // ifndef _L_CHAT_ROOM_ENUMS_H_ |
|---|
| New file |
| | |
|---|
| | | /* |
|---|
| | | * Copyright (c) 2010-2019 Belledonne Communications SARL. |
|---|
| | | * |
|---|
| | | * This file is part of Liblinphone. |
|---|
| | | * |
|---|
| | | * 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 3 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, see <http://www.gnu.org/licenses/>. |
|---|
| | | */ |
|---|
| | | |
|---|
| | | #ifndef _L_CONFERENCE_ENUMS_H_ |
|---|
| | | #define _L_CONFERENCE_ENUMS_H_ |
|---|
| | | |
|---|
| | | // ============================================================================= |
|---|
| | | /** |
|---|
| | | * #LinphoneConferenceState is used to indicate the current state of a conference. |
|---|
| | | * @ingroup conferencing |
|---|
| | | */ |
|---|
| | | |
|---|
| | | typedef enum _LinphoneConferenceState{ |
|---|
| | | LinphoneConferenceStateNone, /**< Initial state */ |
|---|
| | | LinphoneConferenceStateInstantiated, /**< Conference is now instantiated on local */ |
|---|
| | | LinphoneConferenceStateCreationPending, /**< One creation request was sent to the server */ |
|---|
| | | LinphoneConferenceStateCreated, /**< Conference was created on the server */ |
|---|
| | | LinphoneConferenceStateCreationFailed, /**< Conference creation failed */ |
|---|
| | | LinphoneConferenceStateTerminationPending, /**< Wait for conference termination */ |
|---|
| | | LinphoneConferenceStateTerminated, /**< Conference exists on server but not in local */ |
|---|
| | | LinphoneConferenceStateTerminationFailed, /**< Conference termination failed */ |
|---|
| | | LinphoneConferenceStateDeleted, /**< Conference was deleted on the server */ |
|---|
| | | } LinphoneConferenceState; |
|---|
| | | |
|---|
| | | #endif // ifndef _L_CONFERENCE_ENUMS_H_ |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | #define _L_ENCRYPTION_ENGINE_ENUMS_H_ |
|---|
| | | |
|---|
| | | // ============================================================================= |
|---|
| | | |
|---|
| | | #define L_ENUM_VALUES_ENCRYPTION_ENGINE_SECURITY_LEVEL(F) \ |
|---|
| | | F(Unsafe /**< Security failure */) \ |
|---|
| | | F(ClearText /**< No encryption */) \ |
|---|
| | | F(Encrypted /**< Encrypted */) \ |
|---|
| | | F(Safe /**< Encrypted and verified */) |
|---|
| | | /** |
|---|
| | | * TODO move to encryption engine object when available |
|---|
| | | * #LinphoneChatRoomSecurityLevel is used to indicate the encryption security level of a chat room. |
|---|
| | | * @ingroup chatroom |
|---|
| | | */ |
|---|
| | | typedef enum _LinphoneChatRoomSecurityLevel{ |
|---|
| | | LinphoneChatRoomSecurityLevelUnsafe, /**< Security failure */ |
|---|
| | | LinphoneChatRoomSecurityLevelClearText, /**< No encryption */ |
|---|
| | | LinphoneChatRoomSecurityLevelEncrypted, /**< Encrypted */ |
|---|
| | | LinphoneChatRoomSecurityLevelSafe /**< Encrypted and verified */ |
|---|
| | | } LinphoneChatRoomSecurityLevel; |
|---|
| | | |
|---|
| | | #endif // ifndef _L_ENCRYPTION_ENGINE_ENUMS_H_ |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | |
|---|
| | | // ============================================================================= |
|---|
| | | |
|---|
| | | #define L_ENUM_VALUES_EVENT_LOG_TYPE(F) \ |
|---|
| | | F(None /**< No defined event */) \ |
|---|
| | | F(ConferenceCreated /**< Conference (created) event */) \ |
|---|
| | | F(ConferenceTerminated /**< Conference (terminated) event */) \ |
|---|
| | | F(ConferenceCallStart /**< Conference call (start) event */) \ |
|---|
| | | F(ConferenceCallEnd /**< Conference call (end) event */) \ |
|---|
| | | F(ConferenceChatMessage /**< Conference chat message event */) \ |
|---|
| | | F(ConferenceParticipantAdded /**< Conference participant (added) event */) \ |
|---|
| | | F(ConferenceParticipantRemoved /**< Conference participant (removed) event */) \ |
|---|
| | | F(ConferenceParticipantSetAdmin /**< Conference participant (set admin) event */) \ |
|---|
| | | F(ConferenceParticipantUnsetAdmin /**< Conference participant (unset admin) event */) \ |
|---|
| | | F(ConferenceParticipantDeviceAdded /**< Conference participant device (added) event */) \ |
|---|
| | | F(ConferenceParticipantDeviceRemoved /**< Conference participant device (removed) event */) \ |
|---|
| | | F(ConferenceSubjectChanged /**< Conference subject event */) \ |
|---|
| | | F(ConferenceSecurityEvent /**< Conference encryption security event*/) \ |
|---|
| | | // ----------------------------------------------------------------------------- |
|---|
| | | // EventLog. |
|---|
| | | // ----------------------------------------------------------------------------- |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * #LinphoneEventLogType is used to indicate the type of an event. Useful for cast. |
|---|
| | | * @ingroup events |
|---|
| | | */ |
|---|
| | | typedef enum _EventLogType{ |
|---|
| | | LinphoneEventLogTypeNone, /**< No defined event */ |
|---|
| | | LinphoneEventLogTypeConferenceCreated, /**< Conference (created) event */ |
|---|
| | | LinphoneEventLogTypeConferenceTerminated, /**< Conference (terminated) event */ |
|---|
| | | LinphoneEventLogTypeConferenceCallStart, /**< Conference call (start) event */ |
|---|
| | | LinphoneEventLogTypeConferenceCallEnd, /**< Conference call (end) event */ |
|---|
| | | LinphoneEventLogTypeConferenceChatMessage, /**< Conference chat message event */ |
|---|
| | | LinphoneEventLogTypeConferenceParticipantAdded, /**< Conference participant (added) event */ |
|---|
| | | LinphoneEventLogTypeConferenceParticipantRemoved, /**< Conference participant (removed) event */ |
|---|
| | | LinphoneEventLogTypeConferenceParticipantSetAdmin, /**< Conference participant (set admin) event */ |
|---|
| | | LinphoneEventLogTypeConferenceParticipantUnsetAdmin, /**< Conference participant (unset admin) event */ |
|---|
| | | LinphoneEventLogTypeConferenceParticipantDeviceAdded, /**< Conference participant device (added) event */ |
|---|
| | | LinphoneEventLogTypeConferenceParticipantDeviceRemoved, /**< Conference participant device (removed) event */ |
|---|
| | | LinphoneEventLogTypeConferenceSubjectChanged, /**< Conference subject event */ |
|---|
| | | |
|---|
| | | LinphoneEventLogTypeConferenceSecurityEvent, /**< Conference encryption security event*/ |
|---|
| | | LinphoneEventLogTypeConferenceEphemeralMessageLifetimeChanged, /**< Conference ephemeral message (ephemeral message lifetime changed) event */ |
|---|
| | | LinphoneEventLogTypeConferenceEphemeralMessageEnabled, /**< Conference ephemeral message (ephemeral message enabled) event */ |
|---|
| | | LinphoneEventLogTypeConferenceEphemeralMessageDisabled, /**< Conference ephemeral message (ephemeral message disabled) event */ |
|---|
| | | } LinphoneEventLogType; |
|---|
| | | |
|---|
| | | #endif // ifndef _L_EVENT_LOG_ENUMS_H_ |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | |
|---|
| | | // ============================================================================= |
|---|
| | | |
|---|
| | | #define L_ENUM_VALUES_SECURITY_EVENT_TYPE(F) \ |
|---|
| | | F(None /**< Event is not a security event */) \ |
|---|
| | | F(SecurityLevelDowngraded /**< Chatroom security level downgraded event */) \ |
|---|
| | | F(ParticipantMaxDeviceCountExceeded /**< Participant has exceeded the maximum number of device event */) \ |
|---|
| | | F(EncryptionIdentityKeyChanged /**< Peer device instant messaging encryption identity key has changed event */) \ |
|---|
| | | F(ManInTheMiddleDetected /**< Man in the middle detected event */) \ |
|---|
| | | /** |
|---|
| | | * #LinphoneSecurityEventType is used to indicate the type of security event. |
|---|
| | | * @ingroup events |
|---|
| | | */ |
|---|
| | | |
|---|
| | | typedef enum _SecurityEventType{ |
|---|
| | | LinphoneSecurityEventTypeNone, /**< Event is not a security event */ |
|---|
| | | LinphoneSecurityEventTypeSecurityLevelDowngraded, /**< Chatroom security level downgraded event */ |
|---|
| | | LinphoneSecurityEventTypeParticipantMaxDeviceCountExceeded, /**< Participant has exceeded the maximum number of device event */ |
|---|
| | | LinphoneSecurityEventTypeEncryptionIdentityKeyChanged, /**< Peer device instant messaging encryption identity key has changed event */ |
|---|
| | | LinphoneSecurityEventTypeManInTheMiddleDetected, /**< Man in the middle detected event */ |
|---|
| | | } LinphoneSecurityEventType; |
|---|
| | | |
|---|
| | | |
|---|
| | | #endif // ifndef _L_SECURITY_EVENT_ENUMS_H_ |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | * - the "phrase", a text phrase describing the error |
|---|
| | | * - the "warning", the content of warning headers if any |
|---|
| | | * - a sub "LinphoneErrorInfo" may be provided if a SIP response includes a Reason header (RFC3326). |
|---|
| | | * @return a new #LinphoneErrorInfo object @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneErrorInfo *linphone_error_info_new(void); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Increment refcount. |
|---|
| | | * @param[in] ei ErrorInfo object |
|---|
| | | * @param error_info #LinphoneErrorInfo object @notnil |
|---|
| | | * @return the same #LinphoneErrorInfo object @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneErrorInfo *linphone_error_info_ref(LinphoneErrorInfo *ei); |
|---|
| | | LINPHONE_PUBLIC LinphoneErrorInfo *linphone_error_info_ref(LinphoneErrorInfo *error_info); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Decrement refcount and possibly free the object. |
|---|
| | | * @param[in] ei ErrorInfo object |
|---|
| | | * @param error_info #LinphoneErrorInfo object @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_error_info_unref(LinphoneErrorInfo *ei); |
|---|
| | | LINPHONE_PUBLIC void linphone_error_info_unref(LinphoneErrorInfo *error_info); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get Retry-After delay second from the error info. |
|---|
| | | * @param[in] ei ErrorInfo object |
|---|
| | | * @param error_info #LinphoneErrorInfo object @notnil |
|---|
| | | * @return The Retry-After delay second |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC int linphone_error_info_get_retry_after(const LinphoneErrorInfo *ei); |
|---|
| | | LINPHONE_PUBLIC int linphone_error_info_get_retry_after(const LinphoneErrorInfo *error_info); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get reason code from the error info. |
|---|
| | | * @param[in] ei ErrorInfo object |
|---|
| | | * @return A #LinphoneReason |
|---|
| | | * @param error_info #LinphoneErrorInfo object @notnil |
|---|
| | | * @return A #LinphoneReason object |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneReason linphone_error_info_get_reason(const LinphoneErrorInfo *ei); |
|---|
| | | LINPHONE_PUBLIC LinphoneReason linphone_error_info_get_reason(const LinphoneErrorInfo *error_info); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get pointer to chained #LinphoneErrorInfo set in sub_ei. |
|---|
| | | * It corresponds to a Reason header in a received SIP response. |
|---|
| | | * @param ei ErrorInfo object |
|---|
| | | * @return #LinphoneErrorInfo pointer defined in the ei object. |
|---|
| | | * @param error_info #LinphoneErrorInfo object @notnil |
|---|
| | | * @return #LinphoneErrorInfo pointer defined in the ei object. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneErrorInfo* linphone_error_info_get_sub_error_info(const LinphoneErrorInfo *ei); |
|---|
| | | LINPHONE_PUBLIC LinphoneErrorInfo* linphone_error_info_get_sub_error_info(const LinphoneErrorInfo *error_info); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get textual phrase from the error info. |
|---|
| | | * This is the text that is provided by the peer in the protocol (SIP). |
|---|
| | | * @param[in] ei ErrorInfo object |
|---|
| | | * @return The error phrase |
|---|
| | | * @param error_info #LinphoneErrorInfo object @notnil |
|---|
| | | * @return The error phrase @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_error_info_get_phrase(const LinphoneErrorInfo *ei); |
|---|
| | | LINPHONE_PUBLIC const char * linphone_error_info_get_phrase(const LinphoneErrorInfo *error_info); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get protocol from the error info. |
|---|
| | | * @param[in] ei ErrorInfo object |
|---|
| | | * @return The protocol |
|---|
| | | * @param error_info #LinphoneErrorInfo object @notnil |
|---|
| | | * @return The protocol. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_error_info_get_protocol(const LinphoneErrorInfo *ei); |
|---|
| | | LINPHONE_PUBLIC const char *linphone_error_info_get_protocol(const LinphoneErrorInfo *error_info); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Provides additional information regarding the failure. |
|---|
| | | * With SIP protocol, the content of "Warning" headers are returned. |
|---|
| | | * @param[in] ei ErrorInfo object |
|---|
| | | * @return More details about the failure |
|---|
| | | * @param error_info #LinphoneErrorInfo object @notnil |
|---|
| | | * @return More details about the failure. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_error_info_get_warnings(const LinphoneErrorInfo *ei); |
|---|
| | | LINPHONE_PUBLIC const char * linphone_error_info_get_warnings(const LinphoneErrorInfo *error_info); |
|---|
| | | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the status code from the low level protocol (ex a SIP status code). |
|---|
| | | * @param[in] ei ErrorInfo object |
|---|
| | | * @param error_info #LinphoneErrorInfo object @notnil |
|---|
| | | * @return The status code |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC int linphone_error_info_get_protocol_code(const LinphoneErrorInfo *ei); |
|---|
| | | LINPHONE_PUBLIC int linphone_error_info_get_protocol_code(const LinphoneErrorInfo *error_info); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign information to a #LinphoneErrorInfo object. |
|---|
| | | * @param[in] ei ErrorInfo object |
|---|
| | | * @param[in] protocol protocol name |
|---|
| | | * @param[in] reason reason from #LinphoneReason enum |
|---|
| | | * @param[in] code protocol code |
|---|
| | | * @param[in] status_string description of the reason |
|---|
| | | * @param[in] warning warning message |
|---|
| | | * @param error_info #LinphoneErrorInfo object @notnil |
|---|
| | | * @param protocol protocol name @maybenil |
|---|
| | | * @param reason reason from #LinphoneReason enum |
|---|
| | | * @param code protocol code |
|---|
| | | * @param status description of the reason @maybenil |
|---|
| | | * @param warning warning message @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_error_info_set(LinphoneErrorInfo *ei, const char *protocol, LinphoneReason reason, int code, const char *status_string, const char *warning); |
|---|
| | | LINPHONE_PUBLIC void linphone_error_info_set(LinphoneErrorInfo *error_info, const char *protocol, LinphoneReason reason, int code, const char *status, const char *warning); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the sub_ei in #LinphoneErrorInfo to another LinphoneErrorInfo. |
|---|
| | | * Set the sub_ei in #LinphoneErrorInfo to another #LinphoneErrorInfo. |
|---|
| | | * Used when a reason header is to be added in a SIP response. The first level #LinphoneErrorInfo defines the SIP response code and phrase, |
|---|
| | | * the second (sub) #LinphoneErroInfo defining the content of the Reason header. |
|---|
| | | * @param[in] ei #LinphoneErrorInfo object to which the other #LinphoneErrorInfo will be appended as ei->sub_ei. |
|---|
| | | * @param[in] appended_ei #LinphoneErrorInfo to append |
|---|
| | | * @param error_info #LinphoneErrorInfo object to which the other #LinphoneErrorInfo will be appended as ei->sub_ei. @notnil |
|---|
| | | * @param appended_error_info #LinphoneErrorInfo to append @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_error_info_set_sub_error_info(LinphoneErrorInfo *ei, LinphoneErrorInfo *appended_ei); |
|---|
| | | LINPHONE_PUBLIC void linphone_error_info_set_sub_error_info(LinphoneErrorInfo *error_info, LinphoneErrorInfo *appended_error_info); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign retry-after value to a #LinphoneErrorInfo object. |
|---|
| | | * @param[in] ei ErrorInfo object |
|---|
| | | * @param[in] retry_after the retry-after value |
|---|
| | | * @param error_info #LinphoneErrorInfo object @notnil |
|---|
| | | * @param retry_after the retry-after value |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_error_info_set_retry_after(LinphoneErrorInfo *ei, int retry_after); |
|---|
| | | LINPHONE_PUBLIC void linphone_error_info_set_retry_after(LinphoneErrorInfo *error_info, int retry_after); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign reason #LinphoneReason to a #LinphoneErrorInfo object. |
|---|
| | | * @param[in] ei ErrorInfo object |
|---|
| | | * @param[in] reason reason from #LinphoneReason enum |
|---|
| | | * @param error_info #LinphoneErrorInfo object @notnil |
|---|
| | | * @param reason reason from #LinphoneReason enum |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_error_info_set_reason(LinphoneErrorInfo *ei, LinphoneReason reason); |
|---|
| | | LINPHONE_PUBLIC void linphone_error_info_set_reason(LinphoneErrorInfo *error_info, LinphoneReason reason); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign protocol name to a #LinphoneErrorInfo object. |
|---|
| | | * @param[in] ei ErrorInfo object |
|---|
| | | * @param[in] proto the protocol name |
|---|
| | | * @param error_info #LinphoneErrorInfo object @notnil |
|---|
| | | * @param protocol the protocol name @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_error_info_set_protocol(LinphoneErrorInfo *ei, const char *proto); |
|---|
| | | LINPHONE_PUBLIC void linphone_error_info_set_protocol(LinphoneErrorInfo *error_info, const char *protocol); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign protocol code to a #LinphoneErrorInfo object. |
|---|
| | | * @param[in] ei ErrorInfo object |
|---|
| | | * @param[in] code the protocol code |
|---|
| | | * @param error_info #LinphoneErrorInfo object @notnil |
|---|
| | | * @param code the protocol code |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_error_info_set_protocol_code(LinphoneErrorInfo *ei, int code); |
|---|
| | | LINPHONE_PUBLIC void linphone_error_info_set_protocol_code(LinphoneErrorInfo *error_info, int code); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign phrase to a #LinphoneErrorInfo object. |
|---|
| | | * @param[in] ei ErrorInfo object |
|---|
| | | * @param[in] phrase the phrase explaining the error |
|---|
| | | * @param error_info #LinphoneErrorInfo object @notnil |
|---|
| | | * @param phrase the phrase explaining the error @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_error_info_set_phrase(LinphoneErrorInfo *ei, const char *phrase); |
|---|
| | | LINPHONE_PUBLIC void linphone_error_info_set_phrase(LinphoneErrorInfo *error_info, const char *phrase); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign warnings to a #LinphoneErrorInfo object. |
|---|
| | | * @param[in] ei ErrorInfo object |
|---|
| | | * @param[in] phrase the warnings |
|---|
| | | * @param error_info #LinphoneErrorInfo object @notnil |
|---|
| | | * @param warnings the warnings @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_error_info_set_warnings(LinphoneErrorInfo *ei, const char *warnings); |
|---|
| | | LINPHONE_PUBLIC void linphone_error_info_set_warnings(LinphoneErrorInfo *error_info, const char *warnings); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @} |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Send a subscription previously created by linphone_core_create_subscribe(). |
|---|
| | | * @param ev the #LinphoneEvent |
|---|
| | | * @param body optional content to attach with the subscription. |
|---|
| | | * @param linphone_event the #LinphoneEvent @notnil |
|---|
| | | * @param body optional content to attach with the subscription. @maybenil |
|---|
| | | * @return 0 if successful, -1 otherwise. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_event_send_subscribe(LinphoneEvent *ev, const LinphoneContent *body); |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_event_send_subscribe(LinphoneEvent *linphone_event, const LinphoneContent *body); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Update (refresh) an outgoing subscription, changing the body. |
|---|
| | | * @param lev a #LinphoneEvent |
|---|
| | | * @param body an optional body to include in the subscription update, may be NULL. |
|---|
| | | * @param linphone_event a #LinphoneEvent @notnil |
|---|
| | | * @param body an optional body to include in the subscription update, may be NULL. @maybenil |
|---|
| | | * @return 0 if successful, error code otherwise |
|---|
| | | * @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_event_update_subscribe(LinphoneEvent *lev, const LinphoneContent *body); |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_event_update_subscribe(LinphoneEvent *linphone_event, const LinphoneContent *body); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Refresh an outgoing subscription keeping the same body. |
|---|
| | | * @param lev #LinphoneEvent object. |
|---|
| | | * @param linphone_event #LinphoneEvent object. @notnil |
|---|
| | | * @return 0 if successful, -1 otherwise. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_event_refresh_subscribe(LinphoneEvent *lev); |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_event_refresh_subscribe(LinphoneEvent *linphone_event); |
|---|
| | | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Accept an incoming subcription. |
|---|
| | | * @param linphone_event #LinphoneEvent object. @notnil |
|---|
| | | * @return 0 if successful, error code otherwise |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_event_accept_subscription(LinphoneEvent *lev); |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_event_accept_subscription(LinphoneEvent *linphone_event); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Deny an incoming subscription with given reason. |
|---|
| | | * @param linphone_event #LinphoneEvent object. @notnil |
|---|
| | | * @return 0 if successful, error code otherwise |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_event_deny_subscription(LinphoneEvent *lev, LinphoneReason reason); |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_event_deny_subscription(LinphoneEvent *linphone_event, LinphoneReason reason); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Send a notification. |
|---|
| | | * @param lev a #LinphoneEvent corresponding to an incoming subscription previously received and accepted. |
|---|
| | | * @param body an optional body containing the actual notification data. |
|---|
| | | * @param linphone_event a #LinphoneEvent corresponding to an incoming subscription previously received and accepted. @notnil |
|---|
| | | * @param body an optional body containing the actual notification data.@maybenil |
|---|
| | | * @return 0 if successful, -1 otherwise. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_event_notify(LinphoneEvent *lev, const LinphoneContent *body); |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_event_notify(LinphoneEvent *linphone_event, const LinphoneContent *body); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Send a publish created by linphone_core_create_publish(). |
|---|
| | | * @param lev the #LinphoneEvent |
|---|
| | | * @param body the new data to be published |
|---|
| | | * @param linphone_event the #LinphoneEvent @notnil |
|---|
| | | * @param body the new data to be published @notnil |
|---|
| | | * @return 0 if successful, -1 otherwise. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_event_send_publish(LinphoneEvent *lev, const LinphoneContent *body); |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_event_send_publish(LinphoneEvent *linphone_event, const LinphoneContent *body); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Update (refresh) a publish. |
|---|
| | | * @param lev the #LinphoneEvent |
|---|
| | | * @param body the new data to be published |
|---|
| | | * @param linphone_event the #LinphoneEvent @notnil |
|---|
| | | * @param body the new data to be published @notnil |
|---|
| | | * @return 0 if successful, error code otherwise |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_event_update_publish(LinphoneEvent *lev, const LinphoneContent *body); |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_event_update_publish(LinphoneEvent *linphone_event, const LinphoneContent *body); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Refresh an outgoing publish keeping the same body. |
|---|
| | | * @param lev #LinphoneEvent object. |
|---|
| | | * @param linphone_event #LinphoneEvent object. @notnil |
|---|
| | | * @return 0 if successful, -1 otherwise. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_event_refresh_publish(LinphoneEvent *lev); |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_event_refresh_publish(LinphoneEvent *linphone_event); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Prevent an event from refreshing its publish. |
|---|
| | | * This is useful to let registrations to expire naturally (or) when the application wants to keep control on when |
|---|
| | | * refreshes are sent. |
|---|
| | | * The refreshing operations can be resumed with linphone_proxy_config_refresh_register(). |
|---|
| | | * @param[in] lev #LinphoneEvent object. |
|---|
| | | * @param linphone_event #LinphoneEvent object. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_event_pause_publish(LinphoneEvent *lev); |
|---|
| | | LINPHONE_PUBLIC void linphone_event_pause_publish(LinphoneEvent *linphone_event); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Return reason code (in case of error state reached). |
|---|
| | | * @param linphone_event #LinphoneEvent object. @notnil |
|---|
| | | * @return a #LinphoneReason enum |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneReason linphone_event_get_reason(const LinphoneEvent *lev); |
|---|
| | | LINPHONE_PUBLIC LinphoneReason linphone_event_get_reason(const LinphoneEvent *linphone_event); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get full details about an error occured. |
|---|
| | | * @param linphone_event #LinphoneEvent object. @notnil |
|---|
| | | * @return a #LinphoneErrorInfo object. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const LinphoneErrorInfo *linphone_event_get_error_info(const LinphoneEvent *lev); |
|---|
| | | LINPHONE_PUBLIC const LinphoneErrorInfo *linphone_event_get_error_info(const LinphoneEvent *linphone_event); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get subscription state. If the event object was not created by a subscription mechanism, #LinphoneSubscriptionNone is returned. |
|---|
| | | * @param linphone_event #LinphoneEvent object. @notnil |
|---|
| | | * @return the current #LinphoneSubscriptionState |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneSubscriptionState linphone_event_get_subscription_state(const LinphoneEvent *lev); |
|---|
| | | LINPHONE_PUBLIC LinphoneSubscriptionState linphone_event_get_subscription_state(const LinphoneEvent *linphone_event); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get publish state. If the event object was not created by a publish mechanism, #LinphonePublishNone is returned. |
|---|
| | | * @param linphone_event #LinphoneEvent object. @notnil |
|---|
| | | * @return the current #LinphonePublishState |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphonePublishState linphone_event_get_publish_state(const LinphoneEvent *lev); |
|---|
| | | LINPHONE_PUBLIC LinphonePublishState linphone_event_get_publish_state(const LinphoneEvent *linphone_event); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get subscription direction. |
|---|
| | | * If the object wasn't created by a subscription mechanism, #LinphoneSubscriptionInvalidDir is returned. |
|---|
| | | * @param linphone_event #LinphoneEvent object. @notnil |
|---|
| | | * @return the #LinphoneSubscriptionDir |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneSubscriptionDir linphone_event_get_subscription_dir(LinphoneEvent *lev); |
|---|
| | | LINPHONE_PUBLIC LinphoneSubscriptionDir linphone_event_get_subscription_dir(LinphoneEvent *linphone_event); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set a user (application) pointer. |
|---|
| | | * @param linphone_event #LinphoneEvent object. @notnil |
|---|
| | | * @param user_data The user data to set. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_event_set_user_data(LinphoneEvent *ev, void *up); |
|---|
| | | LINPHONE_PUBLIC void linphone_event_set_user_data(LinphoneEvent *linphone_event, void *user_data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Retrieve user pointer. |
|---|
| | | * @param linphone_event #LinphoneEvent object. @notnil |
|---|
| | | * @return the user_data pointer or NULL. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void *linphone_event_get_user_data(const LinphoneEvent *ev); |
|---|
| | | LINPHONE_PUBLIC void *linphone_event_get_user_data(const LinphoneEvent *linphone_event); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Add a custom header to an outgoing susbscription or publish. |
|---|
| | | * @param ev the #LinphoneEvent |
|---|
| | | * @param name header's name |
|---|
| | | * @param value the header's value. |
|---|
| | | * @param linphone_event the #LinphoneEvent @notnil |
|---|
| | | * @param name header's name @notnil |
|---|
| | | * @param value the header's value. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_event_add_custom_header(LinphoneEvent *ev, const char *name, const char *value); |
|---|
| | | LINPHONE_PUBLIC void linphone_event_add_custom_header(LinphoneEvent *linphone_event, const char *name, const char *value); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Remove custom header to an outgoing susbscription or publish. |
|---|
| | | * @param ev the #LinphoneEvent @notnil |
|---|
| | | * @param name header's name @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_event_remove_custom_header(LinphoneEvent *ev, const char *name); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Obtain the value of a given header for an incoming subscription. |
|---|
| | | * @param ev the #LinphoneEvent |
|---|
| | | * @param name header's name |
|---|
| | | * @return the header's value or NULL if such header doesn't exist. |
|---|
| | | * @param linphone_event the #LinphoneEvent @notnil |
|---|
| | | * @param name header's name @notnil |
|---|
| | | * @return the header's value or NULL if such header doesn't exist. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_event_get_custom_header(LinphoneEvent *ev, const char *name); |
|---|
| | | LINPHONE_PUBLIC const char *linphone_event_get_custom_header(LinphoneEvent *linphone_event, const char *name); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Terminate an incoming or outgoing subscription that was previously acccepted, or a previous publication. |
|---|
| | | * The #LinphoneEvent shall not be used anymore after this operation, unless the application explicitely took a reference on the object with |
|---|
| | | * linphone_event_ref(). |
|---|
| | | * The #LinphoneEvent shall not be used anymore after this operation. |
|---|
| | | * @param linphone_event #LinphoneEvent object @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_event_terminate(LinphoneEvent *lev); |
|---|
| | | LINPHONE_PUBLIC void linphone_event_terminate(LinphoneEvent *linphone_event); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Increase reference count of LinphoneEvent. |
|---|
| | | * By default #LinphoneEvents created by the core are owned by the core only. |
|---|
| | | * A #LinphoneEvent created by the core when receiving an incoming SUBSCRIBE or PUBLISH are owned by the core only. |
|---|
| | | * An application that wishes to retain a reference to it must call linphone_event_ref(). |
|---|
| | | * When this reference is no longer needed, linphone_event_unref() must be called. |
|---|
| | | * @param linphone_event #LinphoneEvent object @notnil |
|---|
| | | * @return the same #LinphoneEvent object. @notnil |
|---|
| | | * |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneEvent *linphone_event_ref(LinphoneEvent *lev); |
|---|
| | | LINPHONE_PUBLIC LinphoneEvent *linphone_event_ref(LinphoneEvent *linphone_event); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Decrease reference count. |
|---|
| | | * @param linphone_event #LinphoneEvent object @notnil |
|---|
| | | * @see linphone_event_ref() |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_event_unref(LinphoneEvent *lev); |
|---|
| | | LINPHONE_PUBLIC void linphone_event_unref(LinphoneEvent *linphone_event); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the name of the event as specified in the event package RFC. |
|---|
| | | * @param linphone_event #LinphoneEvent object @notnil |
|---|
| | | * @return the event name. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_event_get_name(const LinphoneEvent *lev); |
|---|
| | | LINPHONE_PUBLIC const char *linphone_event_get_name(const LinphoneEvent *linphone_event); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the "from" address of the subscription. |
|---|
| | | * @param linphone_event #LinphoneEvent object @notnil |
|---|
| | | * @return the from #LinphoneAddress. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress *linphone_event_get_from(const LinphoneEvent *lev); |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress *linphone_event_get_from(const LinphoneEvent *linphone_event); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the "to" address of the subscription. |
|---|
| | | * @param linphone_event #LinphoneEvent object @notnil |
|---|
| | | * @return the "to" #LinphoneAddress. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress *linphone_event_get_to(const LinphoneEvent *lev); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the resource address of the subscription or publish. |
|---|
| | | * @param linphone_event #LinphoneEvent object @notnil |
|---|
| | | * @return the resource #LinphoneAddress. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress *linphone_event_get_resource(const LinphoneEvent *lev); |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress *linphone_event_get_resource(const LinphoneEvent *linphone_event); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the "contact" address of the subscription. |
|---|
| | | * @param[in] lev #LinphoneEvent object |
|---|
| | | * @return The "contact" address of the subscription |
|---|
| | | * @param linphone_event #LinphoneEvent object @notnil |
|---|
| | | * @return The "contact" address of the subscription @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress *linphone_event_get_remote_contact (const LinphoneEvent *lev); |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress *linphone_event_get_remote_contact (const LinphoneEvent *linphone_event); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns back pointer to the #LinphoneCore that created this #LinphoneEvent |
|---|
| | | * @param linphone_event #LinphoneEvent object @notnil |
|---|
| | | * @return the #LinphoneCore object associated. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneCore *linphone_event_get_core(const LinphoneEvent *lev); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the LinphoneEventCbs object associated with a LinphoneEvent. |
|---|
| | | * @param[in] ev LinphoneEvent object |
|---|
| | | * @return The LinphoneEventCbs object associated with the LinphoneEvent. |
|---|
| | | * @deprecated use add_callbacks / remove_callbacks instead |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneEventCbs *linphone_event_get_callbacks(const LinphoneEvent *ev); |
|---|
| | | LINPHONE_PUBLIC LinphoneCore *linphone_event_get_core(const LinphoneEvent *linphone_event); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Adds a LinphoneEventCbs object to be associated with a LinphoneEvent. |
|---|
| | | * @param[in] ev LinphoneEvent object |
|---|
| | | * @param[in] cbs The LinphoneEventCbs object to add |
|---|
| | | * @param linphone_event #LinphoneEvent object @notnil |
|---|
| | | * @param cbs The LinphoneEventCbs object to add @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_event_add_callbacks(LinphoneEvent *ev, LinphoneEventCbs *cbs); |
|---|
| | | LINPHONE_PUBLIC void linphone_event_add_callbacks(LinphoneEvent *linphone_event, LinphoneEventCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Removes a LinphoneEventCbs object associated with a LinphoneEvent. |
|---|
| | | * @param[in] ev LinphoneEvent object |
|---|
| | | * @param[in] cbs The LinphoneEventCbs object to remove |
|---|
| | | * @param linphone_event #LinphoneEvent object @notnil |
|---|
| | | * @param cbs The LinphoneEventCbs object to remove @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_event_remove_callbacks(LinphoneEvent *ev, LinphoneEventCbs *cbs); |
|---|
| | | LINPHONE_PUBLIC void linphone_event_remove_callbacks(LinphoneEvent *linphone_event, LinphoneEventCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the current LinphoneEventCbs object associated with a LinphoneEvent. |
|---|
| | | * @param[in] ev LinphoneEvent object |
|---|
| | | * @return The current LinphoneEventCbs object associated with the LinphoneEvent. |
|---|
| | | * @param linphone_event #LinphoneEvent object @notnil |
|---|
| | | * @return The current LinphoneEventCbs object associated with the LinphoneEvent. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneEventCbs *linphone_event_get_current_callbacks(const LinphoneEvent *ev); |
|---|
| | | LINPHONE_PUBLIC LinphoneEventCbs *linphone_event_get_current_callbacks(const LinphoneEvent *linphone_event); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Acquire a reference to a LinphoneEventCbs object. |
|---|
| | | * @param[in] cbs LinphoneEventCbs object. |
|---|
| | | * @return The same LinphoneEventCbs object. |
|---|
| | | * @return The same LinphoneEventCbs object. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneEventCbs *linphone_event_cbs_ref(LinphoneEventCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Release a reference to a LinphoneEventCbs object. |
|---|
| | | * @param[in] cbs LinphoneEventCbs object. |
|---|
| | | * @param cbs LinphoneEventCbs object. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_event_cbs_unref(LinphoneEventCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Retrieve the user pointer associated with a LinphoneEventCbs object. |
|---|
| | | * @param[in] cbs LinphoneEventCbs object. |
|---|
| | | * @return The user pointer associated with the LinphoneEventCbs object. |
|---|
| | | * @param cbs LinphoneEventCbs object. @notnil |
|---|
| | | * @return The user pointer associated with the LinphoneEventCbs object. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void *linphone_event_cbs_get_user_data(const LinphoneEventCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user pointer to a LinphoneEventCbs object. |
|---|
| | | * @param[in] cbs LinphoneEventCbs object. |
|---|
| | | * @param[in] ud The user pointer to associate with the LinphoneEventCbs object. |
|---|
| | | * @param cbs LinphoneEventCbs object. @notnil |
|---|
| | | * @param user_data The user pointer to associate with the LinphoneEventCbs object. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_event_cbs_set_user_data(LinphoneEventCbs *cbs, void *ud); |
|---|
| | | LINPHONE_PUBLIC void linphone_event_cbs_set_user_data(LinphoneEventCbs *cbs, void *user_data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the notify response callback. |
|---|
| | | * @param[in] cbs LinphoneEventCbs object. |
|---|
| | | * @param cbs LinphoneEventCbs object. @notnil |
|---|
| | | * @return The current notify response callback. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneEventCbsNotifyResponseCb linphone_event_cbs_get_notify_response(const LinphoneEventCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the notify response callback. |
|---|
| | | * @param[in] cbs LinphoneEventCbs object. |
|---|
| | | * @param[in] cb The notify response callback to be used. |
|---|
| | | * @param cbs LinphoneEventCbs object. @notnil |
|---|
| | | * @param cb The notify response callback to be used. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_event_cbs_set_notify_response(LinphoneEventCbs *cbs, LinphoneEventCbsNotifyResponseCb cb); |
|---|
| | | |
|---|
| | | /************ */ |
|---|
| | | /* DEPRECATED */ |
|---|
| | | /* ********** */ |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the LinphoneEventCbs object associated with a LinphoneEvent. |
|---|
| | | * @param linphone_event #LinphoneEvent object @notnil |
|---|
| | | * @return The LinphoneEventCbs object associated with the LinphoneEvent. @notnil |
|---|
| | | * @deprecated 19/02/2019 use add_callbacks / remove_callbacks instead |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED LinphoneEventCbs *linphone_event_get_callbacks(const LinphoneEvent *linphone_event); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @} |
|---|
| | | **/ |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | * along with this program. If not, see <http://www.gnu.org/licenses/>. |
|---|
| | | */ |
|---|
| | | |
|---|
| | | #ifndef LINPHONE_FACTORY_H |
|---|
| | | #define LINPHONE_FACTORY_H |
|---|
| | | //In nested files |
|---|
| | | //#ifndef LINPHONE_FACTORY_H |
|---|
| | | //#define LINPHONE_FACTORY_H |
|---|
| | | |
|---|
| | | #include "linphone/types.h" |
|---|
| | | #include "logging.h" |
|---|
| | | #include "linphone/api/c-factory.h" |
|---|
| | | |
|---|
| | | #ifdef __cplusplus |
|---|
| | | extern "C" { |
|---|
| | | #endif |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @addtogroup initializing |
|---|
| | | * @{ |
|---|
| | | */ |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Create the #LinphoneFactory if that has not been done and return |
|---|
| | | * a pointer on it. |
|---|
| | | * @return A pointer on the #LinphoneFactory |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneFactory *linphone_factory_get(void); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Clean the factory. This function is generally useless as the factory is unique per process, however |
|---|
| | | * calling this function at the end avoid getting reports from belle-sip leak detector about memory leaked in linphone_factory_get(). |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_factory_clean(void); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Instanciate a #LinphoneCore object. |
|---|
| | | * |
|---|
| | | * The #LinphoneCore object is the primary handle for doing all phone actions. |
|---|
| | | * It should be unique within your application. |
|---|
| | | * @param factory The #LinphoneFactory singleton. |
|---|
| | | * @param cbs a #LinphoneCoreCbs object holding your application callbacks. A reference |
|---|
| | | * will be taken on it until the destruciton of the core or the unregistration |
|---|
| | | * with linphone_core_remove_cbs(). |
|---|
| | | * @param config_path a path to a config file. If it does not exists it will be created. |
|---|
| | | * The config file is used to store all settings, call logs, friends, proxies... so that all these settings |
|---|
| | | * become persistent over the life of the LinphoneCore object. |
|---|
| | | * It is allowed to set a NULL config file. In that case LinphoneCore will not store any settings. |
|---|
| | | * @param factory_config_path a path to a read-only config file that can be used to |
|---|
| | | * to store hard-coded preference such as proxy settings or internal preferences. |
|---|
| | | * The settings in this factory file always override the one in the normal config file. |
|---|
| | | * It is OPTIONAL, use NULL if unneeded. |
|---|
| | | * @see linphone_core_new_with_config |
|---|
| | | * @deprecated 2018-01-10: Use linphone_factory_create_core_3() instead |
|---|
| | | */ |
|---|
| | | LINPHONE_DEPRECATED LINPHONE_PUBLIC LinphoneCore *linphone_factory_create_core( |
|---|
| | | const LinphoneFactory *factory, |
|---|
| | | LinphoneCoreCbs *cbs, |
|---|
| | | const char *config_path, |
|---|
| | | const char *factory_config_path |
|---|
| | | ); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Instanciate a #LinphoneCore object. |
|---|
| | | * |
|---|
| | | * The #LinphoneCore object is the primary handle for doing all phone actions. |
|---|
| | | * It should be unique within your application. |
|---|
| | | * @param factory The #LinphoneFactory singleton. |
|---|
| | | * @param cbs a #LinphoneCoreCbs object holding your application callbacks. A reference |
|---|
| | | * will be taken on it until the destruciton of the core or the unregistration |
|---|
| | | * with linphone_core_remove_cbs(). |
|---|
| | | * @param config_path a path to a config file. If it does not exists it will be created. |
|---|
| | | * The config file is used to store all settings, call logs, friends, proxies... so that all these settings |
|---|
| | | * become persistent over the life of the LinphoneCore object. |
|---|
| | | * It is allowed to set a NULL config file. In that case LinphoneCore will not store any settings. |
|---|
| | | * @param factory_config_path a path to a read-only config file that can be used to |
|---|
| | | * to store hard-coded preference such as proxy settings or internal preferences. |
|---|
| | | * The settings in this factory file always override the one in the normal config file. |
|---|
| | | * It is OPTIONAL, use NULL if unneeded. |
|---|
| | | * @param user_data an application pointer associated with the returned core. |
|---|
| | | * @param system_context a pointer to a system object required by the core to operate. Currently it is required to pass an android Context on android, pass NULL on other platforms. |
|---|
| | | * @see linphone_core_new_with_config |
|---|
| | | * @deprecated 2018-01-10: Use linphone_factory_create_core_3() instead |
|---|
| | | */ |
|---|
| | | LINPHONE_DEPRECATED LINPHONE_PUBLIC LinphoneCore *linphone_factory_create_core_2 ( |
|---|
| | | const LinphoneFactory *factory, |
|---|
| | | LinphoneCoreCbs *cbs, |
|---|
| | | const char *config_path, |
|---|
| | | const char *factory_config_path, |
|---|
| | | void *user_data, |
|---|
| | | void *system_context |
|---|
| | | ); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Instantiate a #LinphoneCore object. |
|---|
| | | * |
|---|
| | | * The #LinphoneCore object is the primary handle for doing all phone actions. It should be unique within your |
|---|
| | | * application. |
|---|
| | | * The #LinphoneCore object is not started automatically, you need to call linphone_core_start() to that effect. |
|---|
| | | * The returned #LinphoneCore will be in #LinphoneGlobalState Ready. |
|---|
| | | * Core ressources can be released using linphone_core_stop() which is strongly encouraged on garbage collected languages. |
|---|
| | | * @param[in] factory The #LinphoneFactory singleton. |
|---|
| | | * @param[in] config_path A path to a config file. If it does not exists it will be created. The config file is used to |
|---|
| | | * store all settings, proxies... so that all these settings become persistent over the life of the #LinphoneCore object. |
|---|
| | | * It is allowed to set a NULL config file. In that case #LinphoneCore will not store any settings. |
|---|
| | | * @param[in] factory_config_path A path to a read-only config file that can be used to store hard-coded preferences |
|---|
| | | * such as proxy settings or internal preferences. The settings in this factory file always override the ones in the |
|---|
| | | * normal config file. It is optional, use NULL if unneeded. |
|---|
| | | * @param[in] system_context A pointer to a system object required by the core to operate. Currently it is required to |
|---|
| | | * pass an android Context on android, pass NULL on other platforms. |
|---|
| | | * @see linphone_core_new_with_config_3 |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneCore *linphone_factory_create_core_3 ( |
|---|
| | | const LinphoneFactory *factory, |
|---|
| | | const char *config_path, |
|---|
| | | const char *factory_config_path, |
|---|
| | | void *system_context |
|---|
| | | ); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Instantiates a #LinphoneCore object with a given LpConfig. |
|---|
| | | * |
|---|
| | | * @param factory The #LinphoneFactory singleton. |
|---|
| | | * The #LinphoneCore object is the primary handle for doing all phone actions. |
|---|
| | | * It should be unique within your application. |
|---|
| | | * @param cbs a #LinphoneCoreCbs object holding your application callbacks. A reference |
|---|
| | | * will be taken on it until the destruciton of the core or the unregistration |
|---|
| | | * with linphone_core_remove_cbs(). |
|---|
| | | * @param config a pointer to an LpConfig object holding the configuration of the #LinphoneCore to be instantiated. |
|---|
| | | * @see linphone_core_new |
|---|
| | | * @deprecated 2018-01-10: Use linphone_factory_create_core_with_config_3() instead |
|---|
| | | */ |
|---|
| | | LINPHONE_DEPRECATED LINPHONE_PUBLIC LinphoneCore *linphone_factory_create_core_with_config ( |
|---|
| | | const LinphoneFactory *factory, |
|---|
| | | LinphoneCoreCbs *cbs, |
|---|
| | | LinphoneConfig *config |
|---|
| | | ); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Instantiates a #LinphoneCore object with a given LpConfig. |
|---|
| | | * |
|---|
| | | * @param factory The #LinphoneFactory singleton. |
|---|
| | | * The #LinphoneCore object is the primary handle for doing all phone actions. |
|---|
| | | * It should be unique within your application. |
|---|
| | | * @param cbs a #LinphoneCoreCbs object holding your application callbacks. A reference |
|---|
| | | * will be taken on it until the destruciton of the core or the unregistration |
|---|
| | | * with linphone_core_remove_cbs(). |
|---|
| | | * @param config a pointer to an LpConfig object holding the configuration of the #LinphoneCore to be instantiated. |
|---|
| | | * @param user_data an application pointer associated with the returned core. |
|---|
| | | * @param system_context a pointer to a system object required by the core to operate. Currently it is required to pass an android Context on android, pass NULL on other platforms. |
|---|
| | | * @see linphone_core_new |
|---|
| | | * @deprecated 2018-01-10: Use linphone_factory_create_core_with_config_3() instead |
|---|
| | | */ |
|---|
| | | LINPHONE_DEPRECATED LINPHONE_PUBLIC LinphoneCore *linphone_factory_create_core_with_config_2 ( |
|---|
| | | const LinphoneFactory *factory, |
|---|
| | | LinphoneCoreCbs *cbs, |
|---|
| | | LinphoneConfig *config, |
|---|
| | | void *user_data, |
|---|
| | | void *system_context |
|---|
| | | ); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Instantiate a #LinphoneCore object with a given LinphoneConfig. |
|---|
| | | * |
|---|
| | | * The #LinphoneCore object is the primary handle for doing all phone actions. It should be unique within your |
|---|
| | | * application. |
|---|
| | | * The #LinphoneCore object is not started automatically, you need to call linphone_core_start() to that effect. |
|---|
| | | * The returned #LinphoneCore will be in #LinphoneGlobalState Ready. |
|---|
| | | * Core ressources can be released using linphone_core_stop() which is strongly encouraged on garbage collected languages. |
|---|
| | | * @param[in] factory The #LinphoneFactory singleton. |
|---|
| | | * @param[in] config A #LinphoneConfig object holding the configuration for the #LinphoneCore to be instantiated. |
|---|
| | | * @param[in] system_context A pointer to a system object required by the core to operate. Currently it is required to |
|---|
| | | * pass an android Context on android, pass NULL on other platforms. |
|---|
| | | * @see linphone_factory_create_core_3 |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneCore *linphone_factory_create_core_with_config_3 ( |
|---|
| | | const LinphoneFactory *factory, |
|---|
| | | LinphoneConfig *config, |
|---|
| | | void *system_context |
|---|
| | | ); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Instanciate a #LinphoneCoreCbs object. |
|---|
| | | * @return a new #LinphoneCoreCbs. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneCoreCbs *linphone_factory_create_core_cbs(const LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Parse a string holding a SIP URI and create the according #LinphoneAddress object. |
|---|
| | | * @param factory The #LinphoneFactory singleton. |
|---|
| | | * @param addr A string holding the SIP URI to parse. |
|---|
| | | * @return A new #LinphoneAddress. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneAddress *linphone_factory_create_address(const LinphoneFactory *factory, const char *addr); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Create a #LinphoneParticipantDeviceIdentity object. |
|---|
| | | * @param factory The #LinphoneFactory singleton. |
|---|
| | | * @param address #LinphoneAddress object. |
|---|
| | | * @param name the name given to the device. |
|---|
| | | * @return A new #LinphoneParticipantDeviceIdentity. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneParticipantDeviceIdentity *linphone_factory_create_participant_device_identity( |
|---|
| | | const LinphoneFactory *factory, |
|---|
| | | const LinphoneAddress *address, |
|---|
| | | const char *name |
|---|
| | | ); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates a #LinphoneAuthInfo object. |
|---|
| | | * The object can be created empty, that is with all arguments set to NULL. |
|---|
| | | * Username, userid, password, realm and domain can be set later using specific methods. |
|---|
| | | * At the end, username and passwd (or ha1) are required. |
|---|
| | | * @param factory The #LinphoneFactory singleton. |
|---|
| | | * @param username The username that needs to be authenticated |
|---|
| | | * @param userid The userid used for authenticating (use NULL if you don't know what it is) |
|---|
| | | * @param passwd The password in clear text |
|---|
| | | * @param ha1 The ha1-encrypted password if password is not given in clear text. |
|---|
| | | * @param realm The authentication domain (which can be larger than the sip domain. Unfortunately many SIP servers don't use this parameter. |
|---|
| | | * @param domain The SIP domain for which this authentication information is valid, if it has to be restricted for a single SIP domain. |
|---|
| | | * @return A #LinphoneAuthInfo object. linphone_auth_info_destroy() must be used to destroy it when no longer needed. The #LinphoneCore makes a copy of #LinphoneAuthInfo |
|---|
| | | * passed through linphone_core_add_auth_info(). |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneAuthInfo *linphone_factory_create_auth_info(const LinphoneFactory *factory, const char *username, const char *userid, const char *passwd, const char *ha1, const char *realm, const char *domain); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates a #LinphoneAuthInfo object. |
|---|
| | | * The object can be created empty, that is with all arguments set to NULL. |
|---|
| | | * Username, userid, password, realm and domain can be set later using specific methods. |
|---|
| | | * At the end, username and passwd (or ha1) are required. |
|---|
| | | * @param factory The #LinphoneFactory singleton. |
|---|
| | | * @param username The username that needs to be authenticated |
|---|
| | | * @param userid The userid used for authenticating (use NULL if you don't know what it is) |
|---|
| | | * @param passwd The password in clear text |
|---|
| | | * @param ha1 The ha1-encrypted password if password is not given in clear text. |
|---|
| | | * @param realm The authentication domain (which can be larger than the sip domain. Unfortunately many SIP servers don't use this parameter. |
|---|
| | | * @param domain The SIP domain for which this authentication information is valid, if it has to be restricted for a single SIP domain. |
|---|
| | | * @param algorithm The algorithm for encrypting password. |
|---|
| | | * @return A #LinphoneAuthInfo object. linphone_auth_info_destroy() must be used to destroy it when no longer needed. The #LinphoneCore makes a copy of #LinphoneAuthInfo |
|---|
| | | * passed through linphone_core_add_auth_info(). |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneAuthInfo *linphone_factory_create_auth_info_2(const LinphoneFactory *factory, const char *username, const char *userid, const char *passwd, const char *ha1, const char *realm, const char *domain, const char *algorithm); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Create a #LinphoneCallCbs object that holds callbacks for events happening on a call. |
|---|
| | | * @param[in] factory #LinphoneFactory singletion object |
|---|
| | | * @return A new #LinphoneCallCbs object |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneCallCbs * linphone_factory_create_call_cbs(const LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Create a LinphoneChatRoomCbs object that holds callbacks for events happening on a chat room. |
|---|
| | | * @param[in] factory LinphoneFactory singletion object |
|---|
| | | * @return A new LinphoneChatRoomCbs object |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatRoomCbs * linphone_factory_create_chat_room_cbs(const LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Create a LinphoneChatMessageCbs object that holds callbacks for events happening on a chat message. |
|---|
| | | * @param[in] factory LinphoneFactory singletion object |
|---|
| | | * @return A new LinphoneChatMessageCbs object |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneChatMessageCbs * linphone_factory_create_chat_message_cbs(const LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Create an empty #LinphoneVcard. |
|---|
| | | * @return a new #LinphoneVcard. |
|---|
| | | * @ingroup initializing |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneVcard *linphone_factory_create_vcard(LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Create a #LinphoneVideoDefinition from a given width and height |
|---|
| | | * @param[in] factory #LinphoneFactory singleton object |
|---|
| | | * @param[in] width The width of the created video definition |
|---|
| | | * @param[in] height The height of the created video definition |
|---|
| | | * @return A new #LinphoneVideoDefinition object |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneVideoDefinition * linphone_factory_create_video_definition(const LinphoneFactory *factory, unsigned int width, unsigned int height); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Create a #LinphoneVideoDefinition from a given standard definition name |
|---|
| | | * @param[in] factory #LinphoneFactory singleton object |
|---|
| | | * @param[in] name The standard definition name of the video definition to create |
|---|
| | | * @return A new #LinphoneVideoDefinition object |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneVideoDefinition * linphone_factory_create_video_definition_from_name(const LinphoneFactory *factory, const char *name); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the list of standard video definitions supported by Linphone. |
|---|
| | | * @param[in] factory #LinphoneFactory singleton object |
|---|
| | | * @return \bctbx_list{LinphoneVideoDefinition} |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const bctbx_list_t * linphone_factory_get_supported_video_definitions(const LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the top directory where the resources are located. |
|---|
| | | * @param[in] factory #LinphoneFactory object |
|---|
| | | * @return The path to the top directory where the resources are located |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_factory_get_top_resources_dir(const LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the top directory where the resources are located. |
|---|
| | | * If you only define this top directory, the other resources directory will automatically be derived form this one. |
|---|
| | | * @param[in] factory #LinphoneFactory object |
|---|
| | | * @param[in] path The path to the top directory where the resources are located |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_factory_set_top_resources_dir(LinphoneFactory *factory, const char *path); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the directory where the data resources are located. |
|---|
| | | * @param[in] factory #LinphoneFactory object |
|---|
| | | * @return The path to the directory where the data resources are located |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_factory_get_data_resources_dir(LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the directory where the data resources are located. |
|---|
| | | * @param[in] factory #LinphoneFactory object |
|---|
| | | * @param[in] path The path where the data resources are located |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_factory_set_data_resources_dir(LinphoneFactory *factory, const char *path); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the directory where the sound resources are located. |
|---|
| | | * @param[in] factory #LinphoneFactory object |
|---|
| | | * @return The path to the directory where the sound resources are located |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_factory_get_sound_resources_dir(LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the directory where the sound resources are located. |
|---|
| | | * @param[in] factory #LinphoneFactory object |
|---|
| | | * @param[in] path The path where the sound resources are located |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_factory_set_sound_resources_dir(LinphoneFactory *factory, const char *path); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the directory where the ring resources are located. |
|---|
| | | * @param[in] factory #LinphoneFactory object |
|---|
| | | * @return The path to the directory where the ring resources are located |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_factory_get_ring_resources_dir(LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the directory where the ring resources are located. |
|---|
| | | * @param[in] factory #LinphoneFactory object |
|---|
| | | * @param[in] path The path where the ring resources are located |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_factory_set_ring_resources_dir(LinphoneFactory *factory, const char *path); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the directory where the image resources are located. |
|---|
| | | * @param[in] factory #LinphoneFactory object |
|---|
| | | * @return The path to the directory where the image resources are located |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_factory_get_image_resources_dir(LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the directory where the image resources are located. |
|---|
| | | * @param[in] factory #LinphoneFactory object |
|---|
| | | * @param[in] path The path where the image resources are located |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_factory_set_image_resources_dir(LinphoneFactory *factory, const char *path); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the directory where the mediastreamer2 plugins are located. |
|---|
| | | * @param[in] factory #LinphoneFactory object |
|---|
| | | * @return The path to the directory where the mediastreamer2 plugins are located, or NULL if it has not been set |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_factory_get_msplugins_dir(LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the directory where the mediastreamer2 plugins are located. |
|---|
| | | * @param[in] factory #LinphoneFactory object |
|---|
| | | * @param[in] path The path to the directory where the mediastreamer2 plugins are located |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_factory_set_msplugins_dir(LinphoneFactory *factory, const char *path); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates an object LinphoneErrorInfo. |
|---|
| | | * @param[in] factory #LinphoneFactory object |
|---|
| | | * @return #LinphoneErrorInfo object. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneErrorInfo *linphone_factory_create_error_info(LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates an object LinphoneRange. |
|---|
| | | * @param[in] factory #LinphoneFactory object |
|---|
| | | * @return #LinphoneRange object. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneRange *linphone_factory_create_range(LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates an object LinphoneTransports. |
|---|
| | | * @param[in] factory #LinphoneFactory object |
|---|
| | | * @return #LinphoneTransports object. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneTransports *linphone_factory_create_transports(LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates an object LinphoneVideoActivationPolicy. |
|---|
| | | * @param[in] factory #LinphoneFactory object |
|---|
| | | * @return #LinphoneVideoActivationPolicy object. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneVideoActivationPolicy *linphone_factory_create_video_activation_policy(LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns a bctbx_list_t of all DialPlans |
|---|
| | | * @param[in] factory the #LinphoneFactory object |
|---|
| | | * @return \bctbx_list{LinphoneDialPlan} a list of DialPlan |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const bctbx_list_t * linphone_factory_get_dial_plans(const LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates an object #LinphoneContent |
|---|
| | | * @param[in] factory the #LinphoneFactory |
|---|
| | | * @return a #LinphoneContent |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneContent *linphone_factory_create_content(LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates an object #LinphoneBuffer |
|---|
| | | * @param[in] factory the #LinphoneFactory |
|---|
| | | * @return a #LinphoneBuffer |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneBuffer *linphone_factory_create_buffer(LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates an object #LinphoneBuffer |
|---|
| | | * @param[in] factory the #LinphoneFactory |
|---|
| | | * @param[in] data the data to set in the buffer |
|---|
| | | * @param[in] size the size of the data |
|---|
| | | * @return a #LinphoneBuffer |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneBuffer *linphone_factory_create_buffer_from_data(LinphoneFactory *factory, const uint8_t *data, size_t size); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates an object #LinphoneBuffer |
|---|
| | | * @param[in] factory the #LinphoneFactory |
|---|
| | | * @param[in] data the data to set in the buffer |
|---|
| | | * @return a #LinphoneBuffer |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneBuffer *linphone_factory_create_buffer_from_string(LinphoneFactory *factory, const char *data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates an object #LinphoneConfig |
|---|
| | | * @param[in] factory the #LinphoneFactory |
|---|
| | | * @param[in] path the path of the config |
|---|
| | | * @return a #LinphoneConfig |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneConfig *linphone_factory_create_config(LinphoneFactory *factory, const char *path); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates an object #LinphoneConfig |
|---|
| | | * @param[in] factory the #LinphoneFactory |
|---|
| | | * @param[in] path the path of the config |
|---|
| | | * @param[in] path the path of the factory |
|---|
| | | * @return a #LinphoneConfig |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneConfig *linphone_factory_create_config_with_factory(LinphoneFactory *factory, const char *path, const char *factory_path); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates an object #LinphoneConfig |
|---|
| | | * @param[in] factory the #LinphoneFactory |
|---|
| | | * @param[in] data the config data |
|---|
| | | * @return a #LinphoneConfig |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneConfig *linphone_factory_create_config_from_string(LinphoneFactory *factory, const char *data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the user data in the #LinphoneFactory object |
|---|
| | | * @param[in] factory the #LinphoneFactory |
|---|
| | | * @return the user data |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void *linphone_factory_get_user_data(const LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the user data in the #LinphoneFactory object |
|---|
| | | * @param[in] factory the #LinphoneFactory object |
|---|
| | | * @param[in] data the user data |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_factory_set_user_data(LinphoneFactory *factory, void *data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the log collection path |
|---|
| | | * @param[in] factory the #LinphoneFactory |
|---|
| | | * @param[in] path the path of the logs |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_factory_set_log_collection_path(LinphoneFactory *factory, const char *path); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Enables or disables log collection |
|---|
| | | * @param[in] factory the #LinphoneFactory |
|---|
| | | * @param[in] state the policy for log collection |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_factory_enable_log_collection(LinphoneFactory *factory, LinphoneLogCollectionState state); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates an object #LinphoneTunnelConfig |
|---|
| | | * @param[in] factory the #LinphoneFactory |
|---|
| | | * @return a #LinphoneTunnelConfig |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneTunnelConfig *linphone_factory_create_tunnel_config(LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates an object #LinphoneLoggingServiceCbs |
|---|
| | | * @param[in] factory the #LinphoneFactory |
|---|
| | | * @return a #LinphoneLoggingServiceCbs |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneLoggingServiceCbs *linphone_factory_create_logging_service_cbs(LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates an object #LinphonePlayerCbs |
|---|
| | | * @param[in] factory the #LinphoneFactory |
|---|
| | | * @return a #LinphonePlayerCbs |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphonePlayerCbs *linphone_factory_create_player_cbs(LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates an object #LinphoneEventCbs |
|---|
| | | * @param[in] factory the #LinphoneFactory |
|---|
| | | * @return a #LinphoneEventCbs |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneEventCbs *linphone_factory_create_event_cbs(LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates an object #LinphoneFriendListCbs |
|---|
| | | * @param[in] factory the #LinphoneFactory |
|---|
| | | * @return a #LinphoneFriendListCbs |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneFriendListCbs *linphone_factory_create_friend_list_cbs(LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates an object #LinphoneAccountCreatorCbs |
|---|
| | | * @param[in] factory the #LinphoneFactory |
|---|
| | | * @return a #LinphoneAccountCreatorCbs |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneAccountCreatorCbs *linphone_factory_create_account_creator_cbs(LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates an object #LinphoneXmlRpcRequestCbs |
|---|
| | | * @param[in] factory the #LinphoneFactory |
|---|
| | | * @return a #LinphoneXmlRpcRequestCbs |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneXmlRpcRequestCbs *linphone_factory_create_xml_rpc_request_cbs(LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Indicates if the given LinphoneChatRoomBackend is available |
|---|
| | | * @param[in] factory the #LinphoneFactory |
|---|
| | | * @param[in] chatroom_backend the #LinphoneChatRoomBackend |
|---|
| | | * @return TRUE if the chatroom backend is available, FALSE otherwise |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_factory_is_chatroom_backend_available(LinphoneFactory *factory, LinphoneChatRoomBackend chatroom_backend); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Indicates if the storage in database is available |
|---|
| | | * @param[in] factory the #LinphoneFactory |
|---|
| | | * @return TRUE if the database storage is available, FALSE otherwise |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_factory_is_database_storage_available(LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Indicates if IMDN are available |
|---|
| | | * @param[in] factory the #LinphoneFactory |
|---|
| | | * @return TRUE if IDMN are available |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_factory_is_imdn_available(LinphoneFactory *factory); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @} |
|---|
| | | */ |
|---|
| | | |
|---|
| | | #ifdef __cplusplus |
|---|
| | | } |
|---|
| | | #endif |
|---|
| | | |
|---|
| | | |
|---|
| | | #endif // LINPHONE_FACTORY_H |
|---|
| | | //#endif // LINPHONE_FACTORY_H |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | */ |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set #LinphoneAddress for this friend |
|---|
| | | * @param linphone_friend #LinphoneFriend object @notnil |
|---|
| | | * @param address the #LinphoneAddress to set @maybenil |
|---|
| | | * return 0 if successfull, -1 otherwise |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_friend_set_address(LinphoneFriend *fr, const LinphoneAddress* address); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get address of this friend. |
|---|
| | | * @note the #LinphoneAddress object returned is hold by the LinphoneFriend, however calling several time this function may return different objects. |
|---|
| | | * @param linphone_friend #LinphoneFriend object @notnil |
|---|
| | | * @return the #LinphoneAddress. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress * linphone_friend_get_address(const LinphoneFriend *linphone_friend); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Adds an address in this friend |
|---|
| | | * @param linphone_friend #LinphoneFriend object @notnil |
|---|
| | | * @param address #LinphoneAddress object @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_add_address(LinphoneFriend *linphone_friend, const LinphoneAddress *address); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns a list of #LinphoneAddress for this friend |
|---|
| | | * @param linphone_friend #LinphoneFriend object @notnil |
|---|
| | | * @return A list of #LinphoneAddress. \bctbx_list{LinphoneAddress} @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const bctbx_list_t* linphone_friend_get_addresses(const LinphoneFriend *linphone_friend); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Removes an address in this friend |
|---|
| | | * @param linphone_friend #LinphoneFriend object @notnil |
|---|
| | | * @param address #LinphoneAddress object @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_remove_address(LinphoneFriend *linphone_friend, const LinphoneAddress *address); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Adds a phone number in this friend |
|---|
| | | * @param linphone_friend #LinphoneFriend object @notnil |
|---|
| | | * @param phone_number number to add @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_add_phone_number(LinphoneFriend *linphone_friend, const char *phone_number); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns a list of phone numbers for this friend |
|---|
| | | * @param linphone_friend #LinphoneFriend object @notnil |
|---|
| | | * @return A list of phone numbers as string. \bctbx_list{const char *} @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bctbx_list_t* linphone_friend_get_phone_numbers(const LinphoneFriend *linphone_friend); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns whether a friend contains the given phone number |
|---|
| | | * @param linphone_friend #LinphoneFriend object @notnil |
|---|
| | | * @param phone_number the phone number to search for @notnil |
|---|
| | | * @return TRUE if found, FALSE otherwise |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_friend_has_phone_number(const LinphoneFriend *linphone_friend, const char *phone_number); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Removes a phone number in this friend |
|---|
| | | * @param linphone_friend #LinphoneFriend object @notnil |
|---|
| | | * @param phone_number number to remove @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_remove_phone_number(LinphoneFriend *linphone_friend, const char *phone_number); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the display name for this friend |
|---|
| | | * @param linphone_friend #LinphoneFriend object @notnil |
|---|
| | | * @param name the display name to set @maybenil |
|---|
| | | * @return 0 if successful, -1 otherwise |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_friend_set_name(LinphoneFriend *linphone_friend, const char *name); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the display name for this friend |
|---|
| | | * @param linphone_friend #LinphoneFriend object @notnil |
|---|
| | | * @return The display name of this friend. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_friend_get_name(const LinphoneFriend *linphone_friend); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * get subscription flag value |
|---|
| | | * @param linphone_friend #LinphoneFriend object @notnil |
|---|
| | | * @return returns TRUE is subscription is activated for this friend |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_friend_subscribes_enabled(const LinphoneFriend *linphone_friend); |
|---|
| | | #define linphone_friend_get_send_subscribe linphone_friend_subscribes_enabled |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Configure #LinphoneFriend to subscribe to presence information |
|---|
| | | * @param linphone_friend #LinphoneFriend object @notnil |
|---|
| | | * @param enable if TRUE this friend will receive subscription message |
|---|
| | | * @return 0 |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_friend_enable_subscribes(LinphoneFriend *fr, bool_t enable); |
|---|
| | | #define linphone_friend_send_subscribe linphone_friend_enable_subscribes |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Configure incoming subscription policy for this friend. |
|---|
| | | * @param linphone_friend #LinphoneFriend object @notnil |
|---|
| | | * @param policy #LinphoneSubscribePolicy policy to apply. |
|---|
| | | * @return 0 |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_friend_set_inc_subscribe_policy(LinphoneFriend *fr, LinphoneSubscribePolicy policy); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * get current subscription policy for this #LinphoneFriend |
|---|
| | | * @param linphone_friend #LinphoneFriend object @notnil |
|---|
| | | * @return the #LinphoneSubscribePolicy enum |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneSubscribePolicy linphone_friend_get_inc_subscribe_policy(const LinphoneFriend *linphone_friend); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Starts editing a friend configuration. |
|---|
| | | * |
|---|
| | | * Because friend configuration must be consistent, applications MUST |
|---|
| | | * call linphone_friend_edit() before doing any attempts to modify |
|---|
| | | * friend configuration (such as linphone_friend_set_address() or linphone_friend_set_inc_subscribe_policy()). |
|---|
| | | * Once the modifications are done, then the application must call |
|---|
| | | * linphone_friend_done() to commit the changes. |
|---|
| | | * @param linphone_friend #LinphoneFriend object @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_edit(LinphoneFriend *linphone_friend); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Commits modification made to the friend configuration. |
|---|
| | | * @param linphone_friend #LinphoneFriend object @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_done(LinphoneFriend *linphone_friend); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get subscription state of a friend |
|---|
| | | * @param linphone_friend A #LinphoneFriend object @notnil |
|---|
| | | * @return the #LinphoneSubscriptionState enum |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneSubscriptionState linphone_friend_get_subscription_state(const LinphoneFriend *linphone_friend); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the presence model of a friend |
|---|
| | | * @param linphone_friend A #LinphoneFriend object @notnil |
|---|
| | | * @return A #LinphonePresenceModel object, or NULL if the friend do not have presence information (in which case he is considered offline). @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const LinphonePresenceModel * linphone_friend_get_presence_model(const LinphoneFriend *linphone_friend); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the consolidated presence of a friend. |
|---|
| | | * @param linphone_friend #LinphoneFriend object @notnil |
|---|
| | | * @return The #LinphoneConsolidatedPresence of the friend |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneConsolidatedPresence linphone_friend_get_consolidated_presence(const LinphoneFriend *linphone_friend); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the presence model for a specific SIP URI or phone number of a friend |
|---|
| | | * @param linphone_friend A #LinphoneFriend object @notnil |
|---|
| | | * @param uri_or_tel The SIP URI or phone number for which to get the presence model @notnil |
|---|
| | | * @return A #LinphonePresenceModel object, or NULL if the friend do not have presence information for this SIP URI or phone number. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const LinphonePresenceModel * linphone_friend_get_presence_model_for_uri_or_tel(const LinphoneFriend *linphone_friend, const char *uri_or_tel); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the presence model of a friend |
|---|
| | | * @param linphone_friend A #LinphoneFriend object @notnil |
|---|
| | | * @param presence The #LinphonePresenceModel object to set for the friend @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_set_presence_model(LinphoneFriend *linphone_friend, LinphonePresenceModel *presence); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the presence model for a specific SIP URI or phone number of a friend |
|---|
| | | * @param linphone_friend A #LinphoneFriend object @notnil |
|---|
| | | * @param uri_or_tel The SIP URI or phone number for which to set the presence model @notnil |
|---|
| | | * @param presence The #LinphonePresenceModel object to set @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_set_presence_model_for_uri_or_tel(LinphoneFriend *linphone_friend, const char *uri_or_tel, LinphonePresenceModel *presence); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Tells whether we already received presence information for a friend. |
|---|
| | | * @param linphone_friend A #LinphoneFriend object @notnil |
|---|
| | | * @return TRUE if presence information has been received for the friend, FALSE otherwise. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_friend_is_presence_received(const LinphoneFriend *linphone_friend); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Store user pointer to friend object. |
|---|
| | | * @param linphone_friend A #LinphoneFriend object @notnil |
|---|
| | | * @param user_data the user data to store. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_set_user_data(LinphoneFriend *linphone_friend, void *user_data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Retrieve user data associated with friend. |
|---|
| | | * @param linphone_friend A #LinphoneFriend object @notnil |
|---|
| | | * @return the user data pointer. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void* linphone_friend_get_user_data(const LinphoneFriend *linphone_friend); |
|---|
| | | |
|---|
| | | LINPHONE_PUBLIC BuddyInfo * linphone_friend_get_info(const LinphoneFriend *linphone_friend); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the reference key of a friend. |
|---|
| | | * @param linphone_friend #LinphoneFriend object. @notnil |
|---|
| | | * @param key The reference key to use for the friend. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_set_ref_key(LinphoneFriend *linphone_friend, const char *key); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the reference key of a friend. |
|---|
| | | * @param linphone_friend #LinphoneFriend object. @notnil |
|---|
| | | * @return The reference key of the friend. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_friend_get_ref_key(const LinphoneFriend *linphone_friend); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Check that the given friend is in a friend list. |
|---|
| | | * @param linphone_friend #LinphoneFriend object. @notnil |
|---|
| | | * @return TRUE if the friend is in a friend list, FALSE otherwise. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_friend_in_list(const LinphoneFriend *linphone_friend); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Acquire a reference to the linphone friend. |
|---|
| | | * @param linphone_friend #LinphoneFriend object @notnil |
|---|
| | | * @return The same #LinphoneFriend object @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneFriend * linphone_friend_ref(LinphoneFriend *linphone_friend); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Release a reference to the linphone friend. |
|---|
| | | * @param linphone_friend #LinphoneFriend object @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_unref(LinphoneFriend *linphone_friend); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the #LinphoneCore object managing this friend, if any. |
|---|
| | | * @param linphone_friend #LinphoneFriend object @notnil |
|---|
| | | * @return the #LinphoneCore object associated. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneCore *linphone_friend_get_core(const LinphoneFriend *linphone_friend); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the vCard object associated to this friend, if any |
|---|
| | | * @param linphone_friend #LinphoneFriend object @notnil |
|---|
| | | * @return the #LinphoneVcard or NULL. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneVcard* linphone_friend_get_vcard(const LinphoneFriend *linphone_friend); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Binds a vCard object to a friend |
|---|
| | | * @param linphone_friend #LinphoneFriend object @notnil |
|---|
| | | * @param vcard The #LinphoneVcard object to bind @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_set_vcard(LinphoneFriend *linphone_friend, LinphoneVcard *vcard); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates a vCard object associated to this friend if there isn't one yet and if the full name is available, either by the parameter or the one in the friend's SIP URI |
|---|
| | | * @param linphone_friend #LinphoneFriend object @notnil |
|---|
| | | * @param name The full name of the friend or NULL to use the one from the friend's SIP URI @maybenil |
|---|
| | | * @return TRUE if the vCard has been created, FALSE if it wasn't possible (for exemple if name and the friend's SIP URI are null or if the friend's SIP URI doesn't have a display name), or if there is already one vcard |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_friend_create_vcard(LinphoneFriend *linphone_friend, const char *name); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Contructor same as linphone_friend_new() + linphone_friend_set_address() |
|---|
| | | * @param vcard a #LinphoneVcard object @notnil |
|---|
| | | * @return a new #LinphoneFriend which has its vCard attribute initialized from the given vCard. |
|---|
| | | * This can be get by linphone_friend_get_vcard(). @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneFriend *linphone_friend_new_from_vcard(LinphoneVcard *vcard); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Saves a friend either in database if configured, otherwise in linphonerc |
|---|
| | | * @param linphone_friend the linphone friend to save @notnil |
|---|
| | | * @param core the linphone core @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_save(LinphoneFriend *linphone_friend, LinphoneCore *core); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the capabilities associated to this friend |
|---|
| | | * @param linphone_friend #LinphoneFriend object @notnil |
|---|
| | | * @return an int representing the capabilities of the friend |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC int linphone_friend_get_capabilities(const LinphoneFriend *linphone_friend); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns whether or not a friend has a capbility |
|---|
| | | * @param linphone_friend #LinphoneFriend object @notnil |
|---|
| | | * @param capability #LinphoneFriendCapability object |
|---|
| | | * @return whether or not a friend has a capbility |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_friend_has_capability(const LinphoneFriend *linphone_friend, const LinphoneFriendCapability capability); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns whether or not a friend has a capbility with a given version. |
|---|
| | | * @param linphone_friend #LinphoneFriend object @notnil |
|---|
| | | * @param capability #LinphoneFriendCapability object |
|---|
| | | * @param version the version to test |
|---|
| | | * @return whether or not a friend has a capbility with a given version or -1.0 if friend has not capability. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_friend_has_capability_with_version(const LinphoneFriend *linphone_friend, const LinphoneFriendCapability capability, float version); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns whether or not a friend has a capbility with a given version or more. |
|---|
| | | * @param linphone_friend #LinphoneFriend object @notnil |
|---|
| | | * @param capability #LinphoneFriendCapability object |
|---|
| | | * @param version the version to test |
|---|
| | | * @return whether or not a friend has a capbility with a given version or more. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_friend_has_capability_with_version_or_more(const LinphoneFriend *linphone_friend, const LinphoneFriendCapability capability, float version); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the version of a friend's capbility. |
|---|
| | | * @param linphone_friend #LinphoneFriend object @notnil |
|---|
| | | * @param capability #LinphoneFriendCapability object |
|---|
| | | * @return the version of a friend's capbility. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC float linphone_friend_get_capability_version(const LinphoneFriend *linphone_friend, const LinphoneFriendCapability capability); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Removes a friend from it's friend list and from the rc if exists |
|---|
| | | * @param linphone_friend #LinphoneFriend object to delete @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_remove(LinphoneFriend *linphone_friend); |
|---|
| | | |
|---|
| | | /************ */ |
|---|
| | | /* DEPRECATED */ |
|---|
| | | /* ********** */ |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Contructor |
|---|
| | | * @return a new empty #LinphoneFriend |
|---|
| | | * @deprecated use #linphone_core_create_friend instead |
|---|
| | | * @deprecated 03/02/2016 use #linphone_core_create_friend() instead |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED LinphoneFriend * linphone_friend_new(void); |
|---|
| | |
|---|
| | | /** |
|---|
| | | * Contructor same as linphone_friend_new() + linphone_friend_set_address() |
|---|
| | | * @param addr a buddy address, must be a sip uri like sip:joe@sip.linphone.org |
|---|
| | | * @return a new #LinphoneFriend with \link linphone_friend_get_address() address initialized \endlink |
|---|
| | | * @deprecated use #linphone_core_create_friend_with_address instead |
|---|
| | | * @return a new #LinphoneFriend with an initialized address. |
|---|
| | | * @deprecated 03/02/2016 use #linphone_core_create_friend_with_address() instead |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED LinphoneFriend *linphone_friend_new_with_address(const char *addr); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Contructor same as linphone_friend_new() + linphone_friend_set_address() |
|---|
| | | * @deprecated Use #linphone_friend_new_with_address instead |
|---|
| | | */ |
|---|
| | | #define linphone_friend_new_with_addr linphone_friend_new_with_address |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Destroy a LinphoneFriend. |
|---|
| | | * @param lf #LinphoneFriend object |
|---|
| | | * @deprecated Use linphone_friend_unref() instead. |
|---|
| | | * @param linphone_friend #LinphoneFriend object |
|---|
| | | * @deprecated 31/03/2015 Use linphone_friend_unref() instead. |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED void linphone_friend_destroy(LinphoneFriend *lf); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set #LinphoneAddress for this friend |
|---|
| | | * @param fr #LinphoneFriend object |
|---|
| | | * @param address #LinphoneAddress |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_friend_set_address(LinphoneFriend *fr, const LinphoneAddress* address); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set #LinphoneAddress for this friend |
|---|
| | | * @deprecated Use #linphone_friend_set_address instead |
|---|
| | | */ |
|---|
| | | #define linphone_friend_set_addr linphone_friend_set_address |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get address of this friend. |
|---|
| | | * @note the #LinphoneAddress object returned is hold by the LinphoneFriend, however calling several time this function may return different objects. |
|---|
| | | * @param lf #LinphoneFriend object |
|---|
| | | * @return #LinphoneAddress |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress * linphone_friend_get_address(const LinphoneFriend *lf); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Adds an address in this friend |
|---|
| | | * @param lf #LinphoneFriend object |
|---|
| | | * @param addr #LinphoneAddress object |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_add_address(LinphoneFriend *lf, const LinphoneAddress *addr); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns a list of #LinphoneAddress for this friend |
|---|
| | | * @param lf #LinphoneFriend object |
|---|
| | | * @return \bctbx_list{LinphoneAddress} |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const bctbx_list_t* linphone_friend_get_addresses(const LinphoneFriend *lf); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Removes an address in this friend |
|---|
| | | * @param lf #LinphoneFriend object |
|---|
| | | * @param addr #LinphoneAddress object |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_remove_address(LinphoneFriend *lf, const LinphoneAddress *addr); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Adds a phone number in this friend |
|---|
| | | * @param lf #LinphoneFriend object |
|---|
| | | * @param phone number to add |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_add_phone_number(LinphoneFriend *lf, const char *phone); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns a list of phone numbers for this friend |
|---|
| | | * @param lf #LinphoneFriend object |
|---|
| | | * @return \bctbx_list{const char *} |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bctbx_list_t* linphone_friend_get_phone_numbers(const LinphoneFriend *lf); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Removes a phone number in this friend |
|---|
| | | * @param lf #LinphoneFriend object |
|---|
| | | * @param phone number to remove |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_remove_phone_number(LinphoneFriend *lf, const char *phone); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the display name for this friend |
|---|
| | | * @param lf #LinphoneFriend object |
|---|
| | | * @param name |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_friend_set_name(LinphoneFriend *lf, const char *name); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the display name for this friend |
|---|
| | | * @param lf #LinphoneFriend object |
|---|
| | | * @return The display name of this friend |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_friend_get_name(const LinphoneFriend *lf); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * get subscription flag value |
|---|
| | | * @param lf #LinphoneFriend object |
|---|
| | | * @return returns true is subscription is activated for this friend |
|---|
| | | * |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_friend_subscribes_enabled(const LinphoneFriend *lf); |
|---|
| | | #define linphone_friend_get_send_subscribe linphone_friend_subscribes_enabled |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Configure #LinphoneFriend to subscribe to presence information |
|---|
| | | * @param fr #LinphoneFriend object |
|---|
| | | * @param val if TRUE this friend will receive subscription message |
|---|
| | | */ |
|---|
| | | |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_friend_enable_subscribes(LinphoneFriend *fr, bool_t val); |
|---|
| | | #define linphone_friend_send_subscribe linphone_friend_enable_subscribes |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Configure incoming subscription policy for this friend. |
|---|
| | | * @param fr #LinphoneFriend object |
|---|
| | | * @param pol #LinphoneSubscribePolicy policy to apply. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_friend_set_inc_subscribe_policy(LinphoneFriend *fr, LinphoneSubscribePolicy pol); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * get current subscription policy for this #LinphoneFriend |
|---|
| | | * @param lf #LinphoneFriend object |
|---|
| | | * @return #LinphoneSubscribePolicy |
|---|
| | | * |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneSubscribePolicy linphone_friend_get_inc_subscribe_policy(const LinphoneFriend *lf); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Starts editing a friend configuration. |
|---|
| | | * |
|---|
| | | * Because friend configuration must be consistent, applications MUST |
|---|
| | | * call linphone_friend_edit() before doing any attempts to modify |
|---|
| | | * friend configuration (such as \link linphone_friend_set_address() address \endlink or \link linphone_friend_set_inc_subscribe_policy() subscription policy\endlink and so on). |
|---|
| | | * Once the modifications are done, then the application must call |
|---|
| | | * linphone_friend_done() to commit the changes. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_edit(LinphoneFriend *fr); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Commits modification made to the friend configuration. |
|---|
| | | * @param fr #LinphoneFriend object |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_done(LinphoneFriend *fr); |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED void linphone_friend_destroy(LinphoneFriend *linphone_friend); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the status of a friend |
|---|
| | | * @param[in] lf A #LinphoneFriend object |
|---|
| | | * @param lf A #LinphoneFriend object |
|---|
| | | * @return #LinphoneOnlineStatus |
|---|
| | | * @deprecated Use linphone_friend_get_presence_model() instead |
|---|
| | | * @deprecated 19/06/2013 Use linphone_friend_get_presence_model() instead |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED LinphoneOnlineStatus linphone_friend_get_status(const LinphoneFriend *lf); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get subscription state of a friend |
|---|
| | | * @param[in] lf A #LinphoneFriend object |
|---|
| | | * @return #LinphoneSubscriptionState |
|---|
| | | */ |
|---|
| | | |
|---|
| | | LINPHONE_PUBLIC LinphoneSubscriptionState linphone_friend_get_subscription_state(const LinphoneFriend *lf); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the presence model of a friend |
|---|
| | | * @param[in] lf A #LinphoneFriend object |
|---|
| | | * @return A #LinphonePresenceModel object, or NULL if the friend do not have presence information (in which case he is considered offline) |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const LinphonePresenceModel * linphone_friend_get_presence_model(const LinphoneFriend *lf); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the consolidated presence of a friend. |
|---|
| | | * @param[in] lf #LinphoneFriend object |
|---|
| | | * @return The consolidated presence of the friend |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneConsolidatedPresence linphone_friend_get_consolidated_presence(const LinphoneFriend *lf); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the presence model for a specific SIP URI or phone number of a friend |
|---|
| | | * @param[in] lf A #LinphoneFriend object |
|---|
| | | * @param[in] uri_or_tel The SIP URI or phone number for which to get the presence model |
|---|
| | | * @return A #LinphonePresenceModel object, or NULL if the friend do not have presence information for this SIP URI or phone number |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const LinphonePresenceModel * linphone_friend_get_presence_model_for_uri_or_tel(const LinphoneFriend *lf, const char *uri_or_tel); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the presence model of a friend |
|---|
| | | * @param[in] lf A #LinphoneFriend object |
|---|
| | | * @param[in] presence The #LinphonePresenceModel object to set for the friend |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_set_presence_model(LinphoneFriend *lf, LinphonePresenceModel *presence); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the presence model for a specific SIP URI or phone number of a friend |
|---|
| | | * @param[in] lf A #LinphoneFriend object |
|---|
| | | * @param[in] uri_or_tel The SIP URI or phone number for which to set the presence model |
|---|
| | | * @param[in] presence The #LinphonePresenceModel object to set |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_set_presence_model_for_uri_or_tel(LinphoneFriend *lf, const char *uri_or_tel, LinphonePresenceModel *presence); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Tells whether we already received presence information for a friend. |
|---|
| | | * @param[in] lf A #LinphoneFriend object |
|---|
| | | * @return TRUE if presence information has been received for the friend, FALSE otherwise. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_friend_is_presence_received(const LinphoneFriend *lf); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Store user pointer to friend object. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_set_user_data(LinphoneFriend *lf, void *data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Retrieve user data associated with friend. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void* linphone_friend_get_user_data(const LinphoneFriend *lf); |
|---|
| | | |
|---|
| | | LINPHONE_PUBLIC BuddyInfo * linphone_friend_get_info(const LinphoneFriend *lf); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the reference key of a friend. |
|---|
| | | * @param[in] lf #LinphoneFriend object. |
|---|
| | | * @param[in] key The reference key to use for the friend. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_set_ref_key(LinphoneFriend *lf, const char *key); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the reference key of a friend. |
|---|
| | | * @param[in] lf #LinphoneFriend object. |
|---|
| | | * @return The reference key of the friend. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_friend_get_ref_key(const LinphoneFriend *lf); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Check that the given friend is in a friend list. |
|---|
| | | * @param[in] lf #LinphoneFriend object. |
|---|
| | | * @return TRUE if the friend is in a friend list, FALSE otherwise. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_friend_in_list(const LinphoneFriend *lf); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Acquire a reference to the linphone friend. |
|---|
| | | * @param[in] lf #LinphoneFriend object |
|---|
| | | * @return The same #LinphoneFriend object |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneFriend * linphone_friend_ref(LinphoneFriend *lf); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Release a reference to the linphone friend. |
|---|
| | | * @param[in] lf #LinphoneFriend object |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_unref(LinphoneFriend *lf); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the #LinphoneCore object managing this friend, if any. |
|---|
| | | * @param[in] fr #LinphoneFriend object |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneCore *linphone_friend_get_core(const LinphoneFriend *fr); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the vCard object associated to this friend, if any |
|---|
| | | * @param[in] fr #LinphoneFriend object |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneVcard* linphone_friend_get_vcard(const LinphoneFriend *fr); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Binds a vCard object to a friend |
|---|
| | | * @param[in] fr #LinphoneFriend object |
|---|
| | | * @param[in] vcard The vCard object to bind |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_set_vcard(LinphoneFriend *fr, LinphoneVcard *vcard); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates a vCard object associated to this friend if there isn't one yet and if the full name is available, either by the parameter or the one in the friend's SIP URI |
|---|
| | | * @param[in] fr #LinphoneFriend object |
|---|
| | | * @param[in] name The full name of the friend or NULL to use the one from the friend's SIP URI |
|---|
| | | * @return true if the vCard has been created, false if it wasn't possible (for exemple if name and the friend's SIP URI are null or if the friend's SIP URI doesn't have a display name), or if there is already one vcard |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_friend_create_vcard(LinphoneFriend *fr, const char *name); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Contructor same as linphone_friend_new() + linphone_friend_set_address() |
|---|
| | | * @param vcard a vCard object |
|---|
| | | * @return a new #LinphoneFriend with \link linphone_friend_get_vcard() vCard initialized \endlink |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneFriend *linphone_friend_new_from_vcard(LinphoneVcard *vcard); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Saves a friend either in database if configured, otherwise in linphonerc |
|---|
| | | * @param fr the linphone friend to save |
|---|
| | | * @param lc the linphone core |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_save(LinphoneFriend *fr, LinphoneCore *lc); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the capabilities associated to this friend |
|---|
| | | * @param[in] lf #LinphoneFriend object |
|---|
| | | * @return an int representing the capabilities of the friend |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC int linphone_friend_get_capabilities(const LinphoneFriend *lf); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns whether or not a friend has a capbility |
|---|
| | | * @param[in] lf #LinphoneFriend object |
|---|
| | | * @param[in] capability #LinphoneFriendCapability object |
|---|
| | | * @return whether or not a friend has a capbility |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_friend_has_capability(const LinphoneFriend *lf, const LinphoneFriendCapability capability); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns whether or not a friend has a capbility with a given version. |
|---|
| | | * @param[in] lf #LinphoneFriend object |
|---|
| | | * @param[in] capability #LinphoneFriendCapability object |
|---|
| | | * @param[in] version the version to test |
|---|
| | | * @return whether or not a friend has a capbility with a given version or -1.0 if friend has not capability. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_friend_has_capability_with_version(const LinphoneFriend *lf, const LinphoneFriendCapability capability, float version); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns whether or not a friend has a capbility with a given version or more. |
|---|
| | | * @param[in] lf #LinphoneFriend object |
|---|
| | | * @param[in] capability #LinphoneFriendCapability object |
|---|
| | | * @param[in] version the version to test |
|---|
| | | * @return whether or not a friend has a capbility with a given version or more. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_friend_has_capability_with_version_or_more(const LinphoneFriend *lf, const LinphoneFriendCapability capability, float version); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the version of a friend's capbility. |
|---|
| | | * @param[in] lf #LinphoneFriend object |
|---|
| | | * @param[in] capability #LinphoneFriendCapability object |
|---|
| | | * @return the version of a friend's capbility. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC float linphone_friend_get_capability_version(const LinphoneFriend *lf, const LinphoneFriendCapability capability); |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED LinphoneOnlineStatus linphone_friend_get_status(const LinphoneFriend *linphone_friend); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @} |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Acquire a reference to the friend list. |
|---|
| | | * @param[in] list #LinphoneFriendList object. |
|---|
| | | * @return The same #LinphoneFriendList object. |
|---|
| | | * @param friend_list #LinphoneFriendList object. @notnil |
|---|
| | | * @return The same #LinphoneFriendList object. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneFriendList * linphone_friend_list_ref(LinphoneFriendList *list); |
|---|
| | | LINPHONE_PUBLIC LinphoneFriendList * linphone_friend_list_ref(LinphoneFriendList *friend_list); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Release reference to the friend list. |
|---|
| | | * @param[in] list #LinphoneFriendList object. |
|---|
| | | * @param friend_list #LinphoneFriendList object. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_list_unref(LinphoneFriendList *list); |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_list_unref(LinphoneFriendList *friend_list); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Retrieve the user pointer associated with the friend list. |
|---|
| | | * @param[in] list #LinphoneFriendList object. |
|---|
| | | * @return The user pointer associated with the friend list. |
|---|
| | | * @param friend_list #LinphoneFriendList object. @notnil |
|---|
| | | * @return The user pointer associated with the friend list. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void * linphone_friend_list_get_user_data(const LinphoneFriendList *list); |
|---|
| | | LINPHONE_PUBLIC void * linphone_friend_list_get_user_data(const LinphoneFriendList *friend_list); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user pointer to the friend list. |
|---|
| | | * @param[in] list #LinphoneFriendList object. |
|---|
| | | * @param[in] ud The user pointer to associate with the friend list. |
|---|
| | | * @param friend_list #LinphoneFriendList object. @notnil |
|---|
| | | * @param user_data The user pointer to associate with the friend list. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_list_set_user_data(LinphoneFriendList *list, void *ud); |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_list_set_user_data(LinphoneFriendList *friend_list, void *user_data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the display name of the friend list. |
|---|
| | | * @param[in] list #LinphoneFriendList object. |
|---|
| | | * @return The display name of the friend list. |
|---|
| | | * @param friend_list #LinphoneFriendList object. @notnil |
|---|
| | | * @return The display name of the friend list. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_friend_list_get_display_name(const LinphoneFriendList *list); |
|---|
| | | LINPHONE_PUBLIC const char * linphone_friend_list_get_display_name(const LinphoneFriendList *friend_list); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the display name of the friend list. |
|---|
| | | * @param[in] list #LinphoneFriendList object. |
|---|
| | | * @param[in] display_name The new display name of the friend list. |
|---|
| | | * @param friend_list #LinphoneFriendList object. @notnil |
|---|
| | | * @param display_name The new display name of the friend list. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_list_set_display_name(LinphoneFriendList *list, const char *display_name); |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_list_set_display_name(LinphoneFriendList *friend_list, const char *display_name); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the RLS (Resource List Server) URI associated with the friend list to subscribe to these friends presence. |
|---|
| | | * @param[in] list #LinphoneFriendList object. |
|---|
| | | * @return The RLS URI associated with the friend list. |
|---|
| | | * @param friend_list #LinphoneFriendList object. @notnil |
|---|
| | | * @return The RLS URI associated with the friend list. @maybenil |
|---|
| | | * @deprecated 27/10/2020. Use linphone_friend_list_get_rls_address() instead. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_friend_list_get_rls_uri(const LinphoneFriendList *list); |
|---|
| | | LINPHONE_PUBLIC const char * linphone_friend_list_get_rls_uri(const LinphoneFriendList *friend_list); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the RLS (Resource List Server) URI associated with the friend list to subscribe to these friends presence. |
|---|
| | | * @param[in] list #LinphoneFriendList object. |
|---|
| | | * @param[in] rls_uri The RLS URI to associate with the friend list. |
|---|
| | | * @param friend_list #LinphoneFriendList object. @notnil |
|---|
| | | * @param rls_uri The RLS URI to associate with the friend list. @maybenil |
|---|
| | | * @deprecated 27/10/2020. Use linphone_friend_list_set_rls_address() instead. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_list_set_rls_uri(LinphoneFriendList *list, const char *rls_uri); |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_list_set_rls_uri(LinphoneFriendList *friend_list, const char *rls_uri); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the RLS (Resource List Server) URI associated with the friend list to subscribe to these friends presence. |
|---|
| | | * @param[in] list #LinphoneFriendList object. |
|---|
| | | * @return The RLS URI associated with the friend list. |
|---|
| | | * @param friend_list #LinphoneFriendList object. @notnil |
|---|
| | | * @return The RLS URI as #LinphoneAddress associated with the friend list. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress * linphone_friend_list_get_rls_address(const LinphoneFriendList *list); |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress * linphone_friend_list_get_rls_address(const LinphoneFriendList *friend_list); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the RLS (Resource List Server) URI associated with the friend list to subscribe to these friends presence. |
|---|
| | | * @param[in] list #LinphoneFriendList object. |
|---|
| | | * @param[in] rls_addr The RLS URI to associate with the friend list. |
|---|
| | | * @param friend_list #LinphoneFriendList object. @notnil |
|---|
| | | * @param rls_addr The RLS URI to associate with the friend list. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_list_set_rls_address(LinphoneFriendList *list, const LinphoneAddress *rls_addr); |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_list_set_rls_address(LinphoneFriendList *friend_list, const LinphoneAddress *rls_addr); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Add a friend to a friend list. If or when a remote CardDAV server will be attached to the list, the friend will be sent to the server. |
|---|
| | | * @param[in] list #LinphoneFriendList object. |
|---|
| | | * @param[in] lf #LinphoneFriend object to add to the friend list. |
|---|
| | | * @param friend_list #LinphoneFriendList object. @notnil |
|---|
| | | * @param linphone_friend #LinphoneFriend object to add to the friend list. @notnil |
|---|
| | | * @return #LinphoneFriendListOK if successfully added, #LinphoneFriendListInvalidFriend if the friend is not valid. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneFriendListStatus linphone_friend_list_add_friend(LinphoneFriendList *list, LinphoneFriend *lf); |
|---|
| | | LINPHONE_PUBLIC LinphoneFriendListStatus linphone_friend_list_add_friend(LinphoneFriendList *friend_list, LinphoneFriend *linphone_friend); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Add a friend to a friend list. The friend will never be sent to a remote CardDAV server. |
|---|
| | | * Warning! #LinphoneFriends added this way will be removed on the next synchronization, and the callback contact_deleted will be called. |
|---|
| | | * @param[in] list #LinphoneFriendList object. |
|---|
| | | * @param[in] lf #LinphoneFriend object to add to the friend list. |
|---|
| | | * @param friend_list #LinphoneFriendList object. @notnil |
|---|
| | | * @param linphone_friend #LinphoneFriend object to add to the friend list. @notnil |
|---|
| | | * @return #LinphoneFriendListOK if successfully added, #LinphoneFriendListInvalidFriend if the friend is not valid. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneFriendListStatus linphone_friend_list_add_local_friend(LinphoneFriendList *list, LinphoneFriend *lf); |
|---|
| | | LINPHONE_PUBLIC LinphoneFriendListStatus linphone_friend_list_add_local_friend(LinphoneFriendList *friend_list, LinphoneFriend *linphone_friend); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Remove a friend from a friend list. |
|---|
| | | * @param[in] list #LinphoneFriendList object. |
|---|
| | | * @param[in] lf #LinphoneFriend object to remove from the friend list. |
|---|
| | | * @param friend_list #LinphoneFriendList object. @notnil |
|---|
| | | * @param linphone_friend #LinphoneFriend object to remove from the friend list. @notnil |
|---|
| | | * @return #LinphoneFriendListOK if removed successfully, #LinphoneFriendListNonExistentFriend if the friend is not in the list. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneFriendListStatus linphone_friend_list_remove_friend(LinphoneFriendList *list, LinphoneFriend *lf); |
|---|
| | | LINPHONE_PUBLIC LinphoneFriendListStatus linphone_friend_list_remove_friend(LinphoneFriendList *friend_list, LinphoneFriend *linphone_friend); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Retrieves the list of #LinphoneFriend from this LinphoneFriendList. |
|---|
| | | * @param[in] list #LinphoneFriendList object |
|---|
| | | * @return \bctbx_list{LinphoneFriend} a list of #LinphoneFriend |
|---|
| | | * @param friend_list #LinphoneFriendList object @notnil |
|---|
| | | * @return A list of #LinphoneFriend \bctbx_list{LinphoneFriend} @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const bctbx_list_t * linphone_friend_list_get_friends(const LinphoneFriendList *list); |
|---|
| | | LINPHONE_PUBLIC const bctbx_list_t * linphone_friend_list_get_friends(const LinphoneFriendList *friend_list); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Find a friend in the friend list using a LinphoneAddress. |
|---|
| | | * @param[in] list #LinphoneFriendList object. |
|---|
| | | * @param[in] address #LinphoneAddress object of the friend we want to search for. |
|---|
| | | * @return A #LinphoneFriend if found, NULL otherwise. |
|---|
| | | * @param friend_list #LinphoneFriendList object. @notnil |
|---|
| | | * @param address #LinphoneAddress object of the friend we want to search for. @notnil |
|---|
| | | * @return A #LinphoneFriend if found, NULL otherwise. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneFriend * linphone_friend_list_find_friend_by_address(const LinphoneFriendList *list, const LinphoneAddress *address); |
|---|
| | | LINPHONE_PUBLIC LinphoneFriend * linphone_friend_list_find_friend_by_address(const LinphoneFriendList *friend_list, const LinphoneAddress *address); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Find a friend in the friend list using a phone number. |
|---|
| | | * @param friend_list #LinphoneFriendList object. @notnil |
|---|
| | | * @param phone_number a string of the phone number for which we want to find a friend. @notnil |
|---|
| | | * @return A #LinphoneFriend if found, NULL otherwise. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneFriend * linphone_friend_list_find_friend_by_phone_number(const LinphoneFriendList *friend_list, const char *phone_number); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Find all friends in the friend list using a LinphoneAddress. |
|---|
| | | * @param[in] list #LinphoneFriendList object. |
|---|
| | | * @param[in] address #LinphoneAddress object of the friends we want to search for. |
|---|
| | | * @return \bctbx_list{LinphoneFriend} as a list of #LinphoneFriend if found, NULL otherwise. |
|---|
| | | * @param friend_list #LinphoneFriendList object. @notnil |
|---|
| | | * @param address #LinphoneAddress object of the friends we want to search for. @notnil |
|---|
| | | * @return A list of #LinphoneFriend if found, NULL otherwise. \bctbx_list{LinphoneFriend} @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC bctbx_list_t * linphone_friend_list_find_friends_by_address(const LinphoneFriendList *list, const LinphoneAddress *address); |
|---|
| | | LINPHONE_PUBLIC bctbx_list_t * linphone_friend_list_find_friends_by_address(const LinphoneFriendList *friend_list, const LinphoneAddress *address); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Find a friend in the friend list using an URI string. |
|---|
| | | * @param[in] list #LinphoneFriendList object. |
|---|
| | | * @param[in] uri A string containing the URI of the friend we want to search for. |
|---|
| | | * @return A #LinphoneFriend if found, NULL otherwise. |
|---|
| | | * @param friend_list #LinphoneFriendList object. @notnil |
|---|
| | | * @param uri A string containing the URI of the friend we want to search for. @notnil |
|---|
| | | * @return A #LinphoneFriend if found, NULL otherwise. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneFriend * linphone_friend_list_find_friend_by_uri(const LinphoneFriendList *list, const char *uri); |
|---|
| | | LINPHONE_PUBLIC LinphoneFriend * linphone_friend_list_find_friend_by_uri(const LinphoneFriendList *friend_list, const char *uri); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Find all friends in the friend list using an URI string. |
|---|
| | | * @param[in] list #LinphoneFriendList object. |
|---|
| | | * @param[in] uri A string containing the URI of the friends we want to search for. |
|---|
| | | * @return \bctbx_list{LinphoneFriend} as a list of #LinphoneFriend if found, NULL otherwise. |
|---|
| | | * @param friend_list #LinphoneFriendList object. @notnil |
|---|
| | | * @param uri A string containing the URI of the friends we want to search for. @notnil |
|---|
| | | * @return A list of #LinphoneFriend if found, NULL otherwise. \bctbx_list{LinphoneFriend} @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC bctbx_list_t * linphone_friend_list_find_friends_by_uri(const LinphoneFriendList *list, const char *uri); |
|---|
| | | LINPHONE_PUBLIC bctbx_list_t * linphone_friend_list_find_friends_by_uri(const LinphoneFriendList *friend_list, const char *uri); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Find a friend in the friend list using a ref key. |
|---|
| | | * @param[in] list #LinphoneFriendList object. |
|---|
| | | * @param[in] ref_key The ref key string of the friend we want to search for. |
|---|
| | | * @return A #LinphoneFriend if found, NULL otherwise. |
|---|
| | | * @param friend_list #LinphoneFriendList object. @notnil |
|---|
| | | * @param ref_key The ref key string of the friend we want to search for. @notnil |
|---|
| | | * @return A #LinphoneFriend if found, NULL otherwise. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneFriend * linphone_friend_list_find_friend_by_ref_key(const LinphoneFriendList *list, const char *ref_key); |
|---|
| | | LINPHONE_PUBLIC LinphoneFriend * linphone_friend_list_find_friend_by_ref_key(const LinphoneFriendList *friend_list, const char *ref_key); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Update presence subscriptions for the entire list. Calling this function is necessary when list subscriptions are enabled, |
|---|
| | | * ie when a RLS presence server is used. |
|---|
| | | * @param[in] list the friend list |
|---|
| | | * @param friend_list the #LinphoneFriendList @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_list_update_subscriptions(LinphoneFriendList *list); |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_list_update_subscriptions(LinphoneFriendList *friend_list); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Notify our presence to all the friends in the friend list that have subscribed to our presence directly (not using a RLS). |
|---|
| | | * @param[in] list #LinphoneFriendList object. |
|---|
| | | * @param[in] presence #LinphonePresenceModel object. |
|---|
| | | * @param friend_list #LinphoneFriendList object. @notnil |
|---|
| | | * @param presence #LinphonePresenceModel object. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_list_notify_presence(LinphoneFriendList *list, LinphonePresenceModel *presence); |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_list_notify_presence(LinphoneFriendList *friend_list, LinphonePresenceModel *presence); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the URI associated with the friend list. |
|---|
| | | * @param[in] list #LinphoneFriendList object. |
|---|
| | | * @return The URI associated with the friend list. |
|---|
| | | * @param friend_list #LinphoneFriendList object. @notnil |
|---|
| | | * @return The URI associated with the friend list. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_friend_list_get_uri(const LinphoneFriendList *list); |
|---|
| | | LINPHONE_PUBLIC const char * linphone_friend_list_get_uri(const LinphoneFriendList *friend_list); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the URI associated with the friend list. |
|---|
| | | * @param[in] list #LinphoneFriendList object. |
|---|
| | | * @param[in] uri The URI to associate with the friend list. |
|---|
| | | * @param friend_list #LinphoneFriendList object. @notnil |
|---|
| | | * @param uri The URI to associate with the friend list. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_list_set_uri(LinphoneFriendList *list, const char *uri); |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_list_set_uri(LinphoneFriendList *friend_list, const char *uri); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get wheter the subscription of the friend list is bodyless or not. |
|---|
| | | * @param[in] list #LinphoneFriendList object. |
|---|
| | | * @param friend_list #LinphoneFriendList object. @notnil |
|---|
| | | * @return Wheter the subscription of the friend list is bodyless or not. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_friend_list_is_subscription_bodyless(LinphoneFriendList *list); |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_friend_list_is_subscription_bodyless(LinphoneFriendList *friend_list); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set wheter the subscription of the friend list is bodyless or not. |
|---|
| | | * @param[in] list #LinphoneFriendList object. |
|---|
| | | * @param[in] a boolean telling if the subscription of the friend list is bodyless or not. |
|---|
| | | * @param friend_list #LinphoneFriendList object. @notnil |
|---|
| | | * @param bodyless boolean telling if the subscription of the friend list is bodyless or not. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_list_set_subscription_bodyless(LinphoneFriendList *list, bool_t bodyless); |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_list_set_subscription_bodyless(LinphoneFriendList *friend_list, bool_t bodyless); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the revision from the last synchronization. |
|---|
| | | * @param[in] list #LinphoneFriendList object. |
|---|
| | | * @param[in] rev The revision |
|---|
| | | * @param friend_list #LinphoneFriendList object. @notnil |
|---|
| | | * @param revision The revision |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_list_update_revision(LinphoneFriendList *list, int rev); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the #LinphoneFriendListCbs object associated with a LinphoneFriendList. |
|---|
| | | * @param[in] friend_list #LinphoneFriendList object |
|---|
| | | * @return The #LinphoneFriendListCbs object associated with the LinphoneFriendList. |
|---|
| | | * @deprecated use add_callbacks / remove_callbacks instead |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneFriendListCbs * linphone_friend_list_get_callbacks(const LinphoneFriendList *friend_list); |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_list_update_revision(LinphoneFriendList *friend_list, int revision); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Adds the #LinphoneFriendListCbs object associated with a LinphoneFriendList. |
|---|
| | | * @param[in] friend_list #LinphoneFriendList object |
|---|
| | | * @param[in] cbs The current #LinphoneFriendListCbs object to be added to the LinphoneFriendList. |
|---|
| | | * @param friend_list #LinphoneFriendList object @notnil |
|---|
| | | * @param cbs The current #LinphoneFriendListCbs object to be added to the LinphoneFriendList. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_list_add_callbacks(LinphoneFriendList *friend_list, LinphoneFriendListCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Removes the #LinphoneFriendListCbs object associated with a LinphoneFriendList. |
|---|
| | | * @param[in] friend_list #LinphoneFriendList object |
|---|
| | | * @param[in] cbs The current #LinphoneFriendListCbs object to be remove from the LinphoneFriendList. |
|---|
| | | * @param friend_list #LinphoneFriendList object @notnil |
|---|
| | | * @param cbs The current #LinphoneFriendListCbs object to be remove from the LinphoneFriendList. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_list_remove_callbacks(LinphoneFriendList *friend_list, LinphoneFriendListCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the current #LinphoneFriendListCbs object associated with a LinphoneFriendList. |
|---|
| | | * @param[in] friend_list #LinphoneFriendList object |
|---|
| | | * @return The current #LinphoneFriendListCbs object associated with the LinphoneFriendList. |
|---|
| | | * @param friend_list #LinphoneFriendList object @notnil |
|---|
| | | * @return The current #LinphoneFriendListCbs object associated with the LinphoneFriendList. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneFriendListCbs *linphone_friend_list_get_current_callbacks(const LinphoneFriendList *friend_list); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Acquire a reference to a #LinphoneFriendListCbs object. |
|---|
| | | * @param[in] cbs #LinphoneFriendListCbs object. |
|---|
| | | * @param cbs #LinphoneFriendListCbs object. @notnil |
|---|
| | | * @return The same #LinphoneFriendListCbs object. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneFriendListCbs * linphone_friend_list_cbs_ref(LinphoneFriendListCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Release a reference to a #LinphoneFriendListCbs object. |
|---|
| | | * @param[in] cbs #LinphoneFriendListCbs object. |
|---|
| | | * @param cbs #LinphoneFriendListCbs object. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_list_cbs_unref(LinphoneFriendListCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Retrieve the user pointer associated with a #LinphoneFriendListCbs object. |
|---|
| | | * @param[in] cbs #LinphoneFriendListCbs object. |
|---|
| | | * @return The user pointer associated with the #LinphoneFriendListCbs object. |
|---|
| | | * @param cbs #LinphoneFriendListCbs object. @notnil |
|---|
| | | * @return The user pointer associated with the #LinphoneFriendListCbs object. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void *linphone_friend_list_cbs_get_user_data(const LinphoneFriendListCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user pointer to a #LinphoneFriendListCbs object. |
|---|
| | | * @param[in] cbs #LinphoneFriendListCbs object. |
|---|
| | | * @param[in] ud The user pointer to associate with the #LinphoneFriendListCbs object. |
|---|
| | | * @param cbs #LinphoneFriendListCbs object. @notnil |
|---|
| | | * @param user_data The user pointer to associate with the #LinphoneFriendListCbs object. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_list_cbs_set_user_data(LinphoneFriendListCbs *cbs, void *ud); |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_list_cbs_set_user_data(LinphoneFriendListCbs *cbs, void *user_data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the contact created callback. |
|---|
| | | * @param[in] cbs #LinphoneFriendListCbs object. |
|---|
| | | * @param cbs #LinphoneFriendListCbs object. @notnil |
|---|
| | | * @return The current contact created callback. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneFriendListCbsContactCreatedCb linphone_friend_list_cbs_get_contact_created(const LinphoneFriendListCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the contact created callback. |
|---|
| | | * @param[in] cbs #LinphoneFriendListCbs object. |
|---|
| | | * @param[in] cb The contact created to be used. |
|---|
| | | * @param cbs #LinphoneFriendListCbs object. @notnil |
|---|
| | | * @param cb The contact created to be used. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_list_cbs_set_contact_created(LinphoneFriendListCbs *cbs, LinphoneFriendListCbsContactCreatedCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the contact deleted callback. |
|---|
| | | * @param[in] cbs #LinphoneFriendListCbs object. |
|---|
| | | * @param cbs #LinphoneFriendListCbs object. @notnil |
|---|
| | | * @return The current contact deleted callback. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneFriendListCbsContactDeletedCb linphone_friend_list_cbs_get_contact_deleted(const LinphoneFriendListCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the contact deleted callback. |
|---|
| | | * @param[in] cbs #LinphoneFriendListCbs object. |
|---|
| | | * @param[in] cb The contact deleted to be used. |
|---|
| | | * @param cbs #LinphoneFriendListCbs object. @notnil |
|---|
| | | * @param cb The contact deleted to be used. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_list_cbs_set_contact_deleted(LinphoneFriendListCbs *cbs, LinphoneFriendListCbsContactDeletedCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the contact updated callback. |
|---|
| | | * @param[in] cbs #LinphoneFriendListCbs object. |
|---|
| | | * @param cbs #LinphoneFriendListCbs object. @notnil |
|---|
| | | * @return The current contact updated callback. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneFriendListCbsContactUpdatedCb linphone_friend_list_cbs_get_contact_updated(const LinphoneFriendListCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the contact updated callback. |
|---|
| | | * @param[in] cbs #LinphoneFriendListCbs object. |
|---|
| | | * @param[in] cb The contact updated to be used. |
|---|
| | | * @param cbs #LinphoneFriendListCbs object. @notnil |
|---|
| | | * @param cb The contact updated to be used. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_list_cbs_set_contact_updated(LinphoneFriendListCbs *cbs, LinphoneFriendListCbsContactUpdatedCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the sync status changed callback. |
|---|
| | | * @param[in] cbs #LinphoneFriendListCbs object. |
|---|
| | | * @param cbs #LinphoneFriendListCbs object. @notnil |
|---|
| | | * @return The current sync status changedcallback. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneFriendListCbsSyncStateChangedCb linphone_friend_list_cbs_get_sync_status_changed(const LinphoneFriendListCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the contact updated callback. |
|---|
| | | * @param[in] cbs #LinphoneFriendListCbs object. |
|---|
| | | * @param[in] cb The sync status changed to be used. |
|---|
| | | * @param cbs #LinphoneFriendListCbs object. @notnil |
|---|
| | | * @param cb The sync status changed to be used. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_list_cbs_set_sync_status_changed(LinphoneFriendListCbs *cbs, LinphoneFriendListCbsSyncStateChangedCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the presence received callback. |
|---|
| | | * @param[in] cbs #LinphoneFriendListCbs object. |
|---|
| | | * @param cbs #LinphoneFriendListCbs object. @notnil |
|---|
| | | * @return The current presence received callback. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneFriendListCbsPresenceReceivedCb linphone_friend_list_cbs_get_presence_received(const LinphoneFriendListCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the presence received callback. |
|---|
| | | * @param[in] cbs #LinphoneFriendListCbs object. |
|---|
| | | * @param[in] cb The presence received callback to be used. |
|---|
| | | * @param cbs #LinphoneFriendListCbs object. @notnil |
|---|
| | | * @param cb The presence received callback to be used. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_list_cbs_set_presence_received(LinphoneFriendListCbs *cbs, LinphoneFriendListCbsPresenceReceivedCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Starts a CardDAV synchronization using value set using linphone_friend_list_set_uri. |
|---|
| | | * @param[in] list #LinphoneFriendList object. |
|---|
| | | * @param friend_list #LinphoneFriendList object. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_list_synchronize_friends_from_server(LinphoneFriendList *list); |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_list_synchronize_friends_from_server(LinphoneFriendList *friend_list); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Goes through all the #LinphoneFriend that are dirty and does a CardDAV PUT to update the server. |
|---|
| | | * @param[in] list #LinphoneFriendList object. |
|---|
| | | * @param friend_list #LinphoneFriendList object. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_list_update_dirty_friends(LinphoneFriendList *list); |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_list_update_dirty_friends(LinphoneFriendList *friend_list); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the #LinphoneCore object attached to this LinphoneFriendList. |
|---|
| | | * @param[in] list #LinphoneFriendList object. |
|---|
| | | * @return a #LinphoneCore object |
|---|
| | | * @param friend_list #LinphoneFriendList object. @notnil |
|---|
| | | * @return a #LinphoneCore object @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneCore* linphone_friend_list_get_core(const LinphoneFriendList *list); |
|---|
| | | LINPHONE_PUBLIC LinphoneCore* linphone_friend_list_get_core(const LinphoneFriendList *friend_list); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates and adds #LinphoneFriend objects to #LinphoneFriendList from a file that contains the vCard(s) to parse |
|---|
| | | * @param[in] list the #LinphoneFriendList object |
|---|
| | | * @param[in] vcard_file the path to a file that contains the vCard(s) to parse |
|---|
| | | * @param friend_list the #LinphoneFriendList object @notnil |
|---|
| | | * @param vcard_file the path to a file that contains the vCard(s) to parse @notnil |
|---|
| | | * @return the amount of linphone friends created |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_friend_list_import_friends_from_vcard4_file(LinphoneFriendList *list, const char *vcard_file); |
|---|
| | | LINPHONE_PUBLIC int linphone_friend_list_import_friends_from_vcard4_file(LinphoneFriendList *friend_list, const char *vcard_file); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates and adds #LinphoneFriend objects to #LinphoneFriendList from a buffer that contains the vCard(s) to parse |
|---|
| | | * @param[in] list the #LinphoneFriendList object |
|---|
| | | * @param[in] vcard_buffer the buffer that contains the vCard(s) to parse |
|---|
| | | * @param friend_list the #LinphoneFriendList object @notnil |
|---|
| | | * @param vcard_buffer the buffer that contains the vCard(s) to parse @notnil |
|---|
| | | * @return the amount of linphone friends created |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_friend_list_import_friends_from_vcard4_buffer(LinphoneFriendList *list, const char *vcard_buffer); |
|---|
| | | LINPHONE_PUBLIC int linphone_friend_list_import_friends_from_vcard4_buffer(LinphoneFriendList *friend_list, const char *vcard_buffer); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates and export #LinphoneFriend objects from #LinphoneFriendList to a file using vCard 4 format |
|---|
| | | * @param[in] list the #LinphoneFriendList object |
|---|
| | | * @param[in] vcard_file the path to a file that will contain the vCards |
|---|
| | | * @param friend_list the #LinphoneFriendList object @notnil |
|---|
| | | * @param vcard_file the path to a file that will contain the vCards @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_list_export_friends_as_vcard4_file(LinphoneFriendList *list, const char *vcard_file); |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_list_export_friends_as_vcard4_file(LinphoneFriendList *friend_list, const char *vcard_file); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Enable subscription to NOTIFYes of all friends list |
|---|
| | | * @param[in] list the #LinphoneFriendList object |
|---|
| | | * @param[in] enabled should subscription be enabled or not |
|---|
| | | * @param friend_list the #LinphoneFriendList object @notnil |
|---|
| | | * @param enabled should subscription be enabled or not |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_list_enable_subscriptions(LinphoneFriendList *list, bool_t enabled); |
|---|
| | | LINPHONE_PUBLIC void linphone_friend_list_enable_subscriptions(LinphoneFriendList *friend_list, bool_t enabled); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets whether subscription to NOTIFYes of all friends list are enabled or not |
|---|
| | | * @param[in] list the #LinphoneFriendList object |
|---|
| | | * @param friend_list the #LinphoneFriendList object @notnil |
|---|
| | | * @return Whether subscriptions are enabled or not |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_friend_list_subscriptions_enabled(LinphoneFriendList *list); |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_friend_list_subscriptions_enabled(LinphoneFriendList *friend_list); |
|---|
| | | |
|---|
| | | /************ */ |
|---|
| | | /* DEPRECATED */ |
|---|
| | | /* ********** */ |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the #LinphoneFriendListCbs object associated with a LinphoneFriendList. |
|---|
| | | * @param friend_list #LinphoneFriendList object @notnil |
|---|
| | | * @return The #LinphoneFriendListCbs object associated with the LinphoneFriendList. |
|---|
| | | * @deprecated 19/02/2019 use add_callbacks / remove_callbacks instead |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED LinphoneFriendListCbs * linphone_friend_list_get_callbacks(const LinphoneFriendList *friend_list); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @} |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Search for a given header name and return its value. |
|---|
| | | * @param obj the #LinphoneHeaders object |
|---|
| | | * @param name the header's name |
|---|
| | | * @return the header's value or NULL if not found. |
|---|
| | | * @param headers the #LinphoneHeaders object @notnil |
|---|
| | | * @param name the header's name @notnil |
|---|
| | | * @return the header's value or NULL if not found. @maybenil |
|---|
| | | **/ |
|---|
| | | |
|---|
| | | LINPHONE_PUBLIC const char* linphone_headers_get_value(LinphoneHeaders *obj, const char *header_name); |
|---|
| | | LINPHONE_PUBLIC const char* linphone_headers_get_value(LinphoneHeaders *headers, const char *header_name); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Add given header name and corresponding value. |
|---|
| | | * @param obj the #LinphoneHeaders object |
|---|
| | | * @param name the header's name |
|---|
| | | * @param the header's value |
|---|
| | | * @param headers the #LinphoneHeaders object @notnil |
|---|
| | | * @param name the header's name @notnil |
|---|
| | | * @param value the header's value @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_headers_add(LinphoneHeaders *obj, const char *name, const char *value); |
|---|
| | | LINPHONE_PUBLIC void linphone_headers_add(LinphoneHeaders *headers, const char *name, const char *value); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Add given header name and corresponding value. |
|---|
| | | * @param obj the #LinphoneHeaders object |
|---|
| | | * @param name the header's name |
|---|
| | | * @param the header's value |
|---|
| | | * @param headers the #LinphoneHeaders object @notnil |
|---|
| | | * @param name the header's name @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_headers_remove(LinphoneHeaders *obj, const char *name); |
|---|
| | | LINPHONE_PUBLIC void linphone_headers_remove(LinphoneHeaders *headers, const char *name); |
|---|
| | | |
|---|
| | | |
|---|
| | | /** |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Acquire a reference to the LinphoneImEncryptionEngineCbs. |
|---|
| | | * @param[in] cbs #LinphoneImEncryptionEngineCbs object. |
|---|
| | | * @param cbs #LinphoneImEncryptionEngineCbs object. |
|---|
| | | * @return The same #LinphoneImEncryptionEngineCbs object. |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Release reference to the LinphoneImEncryptionEngineCbs. |
|---|
| | | * @param[in] cbs #LinphoneImEncryptionEngineCbs object. |
|---|
| | | * @param cbs #LinphoneImEncryptionEngineCbs object. |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | | void linphone_im_encryption_engine_cbs_unref(LinphoneImEncryptionEngineCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the user data in the #LinphoneImEncryptionEngineCbs object |
|---|
| | | * @param[in] cbs the #LinphoneImEncryptionEngineCbs |
|---|
| | | * @param cbs the #LinphoneImEncryptionEngineCbs |
|---|
| | | * @return the user data |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the user data in the #LinphoneImEncryptionEngineCbs object |
|---|
| | | * @param[in] cbs the #LinphoneImEncryptionEngineCbs object |
|---|
| | | * @param[in] data the user data |
|---|
| | | * @param cbs the #LinphoneImEncryptionEngineCbs object |
|---|
| | | * @param data the user data |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_im_encryption_engine_cbs_set_user_data(LinphoneImEncryptionEngineCbs *cbs, void *data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Acquire a reference to the LinphoneImEncryptionEngine. |
|---|
| | | * @param[in] imee #LinphoneImEncryptionEngine object. |
|---|
| | | * @param imee #LinphoneImEncryptionEngine object. |
|---|
| | | * @return The same #LinphoneImEncryptionEngine object. |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Release reference to the LinphoneImEncryptionEngine. |
|---|
| | | * @param[in] imee #LinphoneImEncryptionEngine object. |
|---|
| | | * @param imee #LinphoneImEncryptionEngine object. |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_im_encryption_engine_unref(LinphoneImEncryptionEngine *imee); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the user data in the #LinphoneImEncryptionEngine object |
|---|
| | | * @param[in] imee the #LinphoneImEncryptionEngine |
|---|
| | | * @param imee the #LinphoneImEncryptionEngine |
|---|
| | | * @return the user data |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the user data in the #LinphoneImEncryptionEngine object |
|---|
| | | * @param[in] imee the #LinphoneImEncryptionEngine object |
|---|
| | | * @param[in] data the user data |
|---|
| | | * @param imee the #LinphoneImEncryptionEngine object |
|---|
| | | * @param data the user data |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_im_encryption_engine_set_user_data(LinphoneImEncryptionEngine *imee, void *data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the #LinphoneCore object that created the IM encryption engine |
|---|
| | | * @param[in] imee #LinphoneImEncryptionEngine object |
|---|
| | | * @param imee #LinphoneImEncryptionEngine object |
|---|
| | | * @return The #LinphoneCore object that created the IM encryption engine |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the #LinphoneImEncryptionEngineCbs object that holds the callbacks |
|---|
| | | * @param[in] imee the #LinphoneImEncryptionEngine object |
|---|
| | | * @param imee the #LinphoneImEncryptionEngine object |
|---|
| | | * @return the #LinphoneImEncryptionEngineCbs object |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the callback that will decrypt the chat messages upon reception |
|---|
| | | * @param[in] cbs the #LinphoneImEncryptionEngineCbs object |
|---|
| | | * @param cbs the #LinphoneImEncryptionEngineCbs object |
|---|
| | | * @return the callback |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the callback that will decrypt the chat messages upon reception |
|---|
| | | * @param[in] cbs the #LinphoneImEncryptionEngineCbs object |
|---|
| | | * @param[in] cb the callback to call |
|---|
| | | * @param cbs the #LinphoneImEncryptionEngineCbs object |
|---|
| | | * @param cb the callback to call |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_im_encryption_engine_cbs_set_process_incoming_message(LinphoneImEncryptionEngineCbs *cbs, LinphoneImEncryptionEngineCbsIncomingMessageCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the callback that will encrypt the chat messages before sending them |
|---|
| | | * @param[in] cbs the #LinphoneImEncryptionEngineCbs object |
|---|
| | | * @param cbs the #LinphoneImEncryptionEngineCbs object |
|---|
| | | * @return the callback |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the callback that will encrypt the chat messages before sending them |
|---|
| | | * @param[in] cbs the #LinphoneImEncryptionEngineCbs object |
|---|
| | | * @param[in] cb the callback to call |
|---|
| | | * @param cbs the #LinphoneImEncryptionEngineCbs object |
|---|
| | | * @param cb the callback to call |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_im_encryption_engine_cbs_set_process_outgoing_message(LinphoneImEncryptionEngineCbs *cbs, LinphoneImEncryptionEngineCbsOutgoingMessageCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the callback that will decrypt the files while downloading them |
|---|
| | | * @param[in] cbs the #LinphoneImEncryptionEngineCbs object |
|---|
| | | * @param cbs the #LinphoneImEncryptionEngineCbs object |
|---|
| | | * @return the callback |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the callback that will decrypt the files while downloading them |
|---|
| | | * @param[in] cbs the #LinphoneImEncryptionEngineCbs object |
|---|
| | | * @param[in] cb the callback to call |
|---|
| | | * @param cbs the #LinphoneImEncryptionEngineCbs object |
|---|
| | | * @param cb the callback to call |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_im_encryption_engine_cbs_set_process_downloading_file(LinphoneImEncryptionEngineCbs *cbs, LinphoneImEncryptionEngineCbsDownloadingFileCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the callback that will will encrypt the files while uploading them |
|---|
| | | * @param[in] cbs the #LinphoneImEncryptionEngineCbs object |
|---|
| | | * @param cbs the #LinphoneImEncryptionEngineCbs object |
|---|
| | | * @return the callback |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the callback that will encrypt the files while uploading them |
|---|
| | | * @param[in] cbs the #LinphoneImEncryptionEngineCbs object |
|---|
| | | * @param[in] cb the callback to call |
|---|
| | | * @param cbs the #LinphoneImEncryptionEngineCbs object |
|---|
| | | * @param cb the callback to call |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_im_encryption_engine_cbs_set_process_uploading_file(LinphoneImEncryptionEngineCbs *cbs, LinphoneImEncryptionEngineCbsUploadingFileCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the callback telling whether or not to encrypt the files |
|---|
| | | * @param[in] cbs the LinphoneImEncryptionEngineCbs object |
|---|
| | | * @param cbs the LinphoneImEncryptionEngineCbs object |
|---|
| | | * @return the callback |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the callback telling whether or not to encrypt the files |
|---|
| | | * @param[in] cbs the LinphoneImEncryptionEngineCbs object |
|---|
| | | * @param[in] cb the callback to call |
|---|
| | | * @param cbs the LinphoneImEncryptionEngineCbs object |
|---|
| | | * @param cb the callback to call |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_im_encryption_engine_cbs_set_is_encryption_enabled_for_file_transfer(LinphoneImEncryptionEngineCbs *cbs, LinphoneImEncryptionEngineCbsIsEncryptionEnabledForFileTransferCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the callback that will generate the key to encrypt the file before uploading it |
|---|
| | | * @param[in] cbs the #LinphoneImEncryptionEngineCbs object |
|---|
| | | * @param cbs the #LinphoneImEncryptionEngineCbs object |
|---|
| | | * @return the callback |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the callback that will generate the key to encrypt the file before uploading it |
|---|
| | | * @param[in] cbs the #LinphoneImEncryptionEngineCbs object |
|---|
| | | * @param[in] cb the callback to call |
|---|
| | | * @param cbs the #LinphoneImEncryptionEngineCbs object |
|---|
| | | * @param cb the callback to call |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_im_encryption_engine_cbs_set_generate_file_transfer_key(LinphoneImEncryptionEngineCbs *cbs, LinphoneImEncryptionEngineCbsGenerateFileTransferKeyCb cb); |
|---|
| | | |
|---|
| | | /** Set a chat message text to be sent by #linphone_chat_room_send_message |
|---|
| | | * @param[in] msg #LinphoneChatMessage |
|---|
| | | * @param[in] text Const char * |
|---|
| | | * @returns 0 if succeed. |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC int linphone_chat_message_set_text(LinphoneChatMessage *msg, const char* text); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Create the IM encryption engine |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Acquire a reference to the #LinphoneImNotifPolicy object. |
|---|
| | | * @param[in] policy #LinphoneImNotifPolicy object. |
|---|
| | | * @return The same #LinphoneImNotifPolicy object. |
|---|
| | | * @param policy #LinphoneImNotifPolicy object. @notnil |
|---|
| | | * @return The same #LinphoneImNotifPolicy object. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneImNotifPolicy * linphone_im_notif_policy_ref(LinphoneImNotifPolicy *policy); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Release reference to the #LinphoneImNotifPolicy object. |
|---|
| | | * @param[in] policy #LinphoneImNotifPolicy object. |
|---|
| | | * @param policy #LinphoneImNotifPolicy object. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_im_notif_policy_unref(LinphoneImNotifPolicy *policy); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Retrieve the user pointer associated with the #LinphoneImNotifPolicy object. |
|---|
| | | * @param[in] policy #LinphoneImNotifPolicy object. |
|---|
| | | * @return The user pointer associated with the #LinphoneImNotifPolicy object. |
|---|
| | | * @param policy #LinphoneImNotifPolicy object. @notnil |
|---|
| | | * @return The user pointer associated with the #LinphoneImNotifPolicy object. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void *linphone_im_notif_policy_get_user_data(const LinphoneImNotifPolicy *policy); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user pointer to the #LinphoneImNotifPolicy object. |
|---|
| | | * @param[in] policy #LinphoneImNotifPolicy object. |
|---|
| | | * @param[in] ud The user pointer to associate with the #LinphoneImNotifPolicy object. |
|---|
| | | * @param policy #LinphoneImNotifPolicy object. @notnil |
|---|
| | | * @param user_data The user pointer to associate with the #LinphoneImNotifPolicy object. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_im_notif_policy_set_user_data(LinphoneImNotifPolicy *policy, void *ud); |
|---|
| | | LINPHONE_PUBLIC void linphone_im_notif_policy_set_user_data(LinphoneImNotifPolicy *policy, void *user_data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Clear an IM notif policy (deactivate all receiving and sending of notifications). |
|---|
| | | * @param[in] policy #LinphoneImNotifPolicy object. |
|---|
| | | * @param policy #LinphoneImNotifPolicy object. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_im_notif_policy_clear(LinphoneImNotifPolicy *policy); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Enable all receiving and sending of notifications. |
|---|
| | | * @param[in] policy #LinphoneImNotifPolicy object. |
|---|
| | | * @param policy #LinphoneImNotifPolicy object. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_im_notif_policy_enable_all(LinphoneImNotifPolicy *policy); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Tell whether is_composing notifications are being sent. |
|---|
| | | * @param[in] policy #LinphoneImNotifPolicy object |
|---|
| | | * @param policy #LinphoneImNotifPolicy object @notnil |
|---|
| | | * @return Boolean value telling whether is_composing notifications are being sent. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_im_notif_policy_get_send_is_composing(const LinphoneImNotifPolicy *policy); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Enable is_composing notifications sending. |
|---|
| | | * @param[in] policy #LinphoneImNotifPolicy object |
|---|
| | | * @param[in] enable Boolean value telling whether to send is_composing notifications. |
|---|
| | | * @param policy #LinphoneImNotifPolicy object @notnil |
|---|
| | | * @param enable Boolean value telling whether to send is_composing notifications. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_im_notif_policy_set_send_is_composing(LinphoneImNotifPolicy *policy, bool_t enable); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Tell whether is_composing notifications are being notified when received. |
|---|
| | | * @param[in] policy #LinphoneImNotifPolicy object |
|---|
| | | * @param policy #LinphoneImNotifPolicy object @notnil |
|---|
| | | * @return Boolean value telling whether is_composing notifications are being notified when received. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_im_notif_policy_get_recv_is_composing(const LinphoneImNotifPolicy *policy); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Enable is_composing notifications receiving. |
|---|
| | | * @param[in] policy #LinphoneImNotifPolicy object |
|---|
| | | * @param[in] enable Boolean value telling whether to notify received is_composing notifications. |
|---|
| | | * @param policy #LinphoneImNotifPolicy object @notnil |
|---|
| | | * @param enable Boolean value telling whether to notify received is_composing notifications. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_im_notif_policy_set_recv_is_composing(LinphoneImNotifPolicy *policy, bool_t enable); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Tell whether imdn delivered notifications are being sent. |
|---|
| | | * @param[in] policy #LinphoneImNotifPolicy object |
|---|
| | | * @param policy #LinphoneImNotifPolicy object @notnil |
|---|
| | | * @return Boolean value telling whether imdn delivered notifications are being sent. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_im_notif_policy_get_send_imdn_delivered(const LinphoneImNotifPolicy *policy); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Enable imdn delivered notifications sending. |
|---|
| | | * @param[in] policy #LinphoneImNotifPolicy object |
|---|
| | | * @param[in] enable Boolean value telling whether to send imdn delivered notifications. |
|---|
| | | * @param policy #LinphoneImNotifPolicy object @notnil |
|---|
| | | * @param enable Boolean value telling whether to send imdn delivered notifications. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_im_notif_policy_set_send_imdn_delivered(LinphoneImNotifPolicy *policy, bool_t enable); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Tell whether imdn delivered notifications are being notified when received. |
|---|
| | | * @param[in] policy #LinphoneImNotifPolicy object |
|---|
| | | * @param policy #LinphoneImNotifPolicy object @notnil |
|---|
| | | * @return Boolean value telling whether imdn delivered notifications are being notified when received. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_im_notif_policy_get_recv_imdn_delivered(const LinphoneImNotifPolicy *policy); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Enable imdn delivered notifications receiving. |
|---|
| | | * @param[in] policy #LinphoneImNotifPolicy object |
|---|
| | | * @param[in] enable Boolean value telling whether to notify received imdn delivered notifications. |
|---|
| | | * @param policy #LinphoneImNotifPolicy object @notnil |
|---|
| | | * @param enable Boolean value telling whether to notify received imdn delivered notifications. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_im_notif_policy_set_recv_imdn_delivered(LinphoneImNotifPolicy *policy, bool_t enable); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Tell whether imdn displayed notifications are being sent. |
|---|
| | | * @param[in] policy #LinphoneImNotifPolicy object |
|---|
| | | * @param policy #LinphoneImNotifPolicy object @notnil |
|---|
| | | * @return Boolean value telling whether imdn displayed notifications are being sent. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_im_notif_policy_get_send_imdn_displayed(const LinphoneImNotifPolicy *policy); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Enable imdn displayed notifications sending. |
|---|
| | | * @param[in] policy #LinphoneImNotifPolicy object |
|---|
| | | * @param[in] enable Boolean value telling whether to send imdn displayed notifications. |
|---|
| | | * @param policy #LinphoneImNotifPolicy object @notnil |
|---|
| | | * @param enable Boolean value telling whether to send imdn displayed notifications. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_im_notif_policy_set_send_imdn_displayed(LinphoneImNotifPolicy *policy, bool_t enable); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Tell whether imdn displayed notifications are being notified when received. |
|---|
| | | * @param[in] policy #LinphoneImNotifPolicy object |
|---|
| | | * @param policy #LinphoneImNotifPolicy object @notnil |
|---|
| | | * @return Boolean value telling whether imdn displayed notifications are being notified when received. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_im_notif_policy_get_recv_imdn_displayed(const LinphoneImNotifPolicy *policy); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Enable imdn displayed notifications receiving. |
|---|
| | | * @param[in] policy #LinphoneImNotifPolicy object |
|---|
| | | * @param[in] enable Boolean value telling whether to notify received imdn displayed notifications. |
|---|
| | | * @param policy #LinphoneImNotifPolicy object @notnil |
|---|
| | | * @param enable Boolean value telling whether to notify received imdn displayed notifications. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_im_notif_policy_set_recv_imdn_displayed(LinphoneImNotifPolicy *policy, bool_t enable); |
|---|
| | | |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Add a header to an info message to be sent. |
|---|
| | | * @param im the info message |
|---|
| | | * @param name the header'name |
|---|
| | | * @param value the header's value |
|---|
| | | * @param info_message the #LinphoneInfoMessage object @notnil |
|---|
| | | * @param name the header'name @notnil |
|---|
| | | * @param value the header's value @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_info_message_add_header(LinphoneInfoMessage *im, const char *name, const char *value); |
|---|
| | | LINPHONE_PUBLIC void linphone_info_message_add_header(LinphoneInfoMessage *info_message, const char *name, const char *value); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Obtain a header value from a received info message. |
|---|
| | | * @param im the info message |
|---|
| | | * @param name the header'name |
|---|
| | | * @return the corresponding header's value, or NULL if not exists. |
|---|
| | | * @param info_message the #LinphoneInfoMessage object @notnil |
|---|
| | | * @param name the header'name @notnil |
|---|
| | | * @return the corresponding header's value, or NULL if not exists. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_info_message_get_header(const LinphoneInfoMessage *im, const char *name); |
|---|
| | | LINPHONE_PUBLIC const char *linphone_info_message_get_header(const LinphoneInfoMessage *info_message, const char *name); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a content to the info message. |
|---|
| | | * @param im the linphone info message |
|---|
| | | * @param content the content described as a #LinphoneContent structure. |
|---|
| | | * |
|---|
| | | * All fields of the #LinphoneContent are copied, thus the application can destroy/modify/recycloe the content object freely ater the function returns. |
|---|
| | | * @param info_message the #LinphoneInfoMessage object @notnil |
|---|
| | | * @param content the content described as a #LinphoneContent structure. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_info_message_set_content(LinphoneInfoMessage *im, const LinphoneContent *content); |
|---|
| | | LINPHONE_PUBLIC void linphone_info_message_set_content(LinphoneInfoMessage *info_message, const LinphoneContent *content); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the info message's content as a #LinphoneContent structure. |
|---|
| | | * @param info_message the #LinphoneInfoMessage object @notnil |
|---|
| | | * @return the #LinphoneContent object. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const LinphoneContent * linphone_info_message_get_content(const LinphoneInfoMessage *im); |
|---|
| | | LINPHONE_PUBLIC const LinphoneContent * linphone_info_message_get_content(const LinphoneInfoMessage *info_message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Take a reference on a #LinphoneInfoMessage. |
|---|
| | | * @param info_message the #LinphoneInfoMessage object @notnil |
|---|
| | | * @return the same #LinphoneInfoMessage object @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneInfoMessage *linphone_info_message_ref(LinphoneInfoMessage *im); |
|---|
| | | LINPHONE_PUBLIC LinphoneInfoMessage *linphone_info_message_ref(LinphoneInfoMessage *info_message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Release a reference on a #LinphoneInfoMessage. |
|---|
| | | * @param info_message the linphone info message @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_info_message_unref(LinphoneInfoMessage *im); |
|---|
| | | LINPHONE_PUBLIC void linphone_info_message_unref(LinphoneInfoMessage *info_message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Destroy a LinphoneInfoMessage. |
|---|
| | | * @deprecated Use linphone_info_message_unref() instead. |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED void linphone_info_message_destroy(LinphoneInfoMessage *im); |
|---|
| | | |
|---|
| | | LINPHONE_PUBLIC LinphoneInfoMessage *linphone_info_message_copy(const LinphoneInfoMessage *orig); |
|---|
| | | LINPHONE_PUBLIC LinphoneInfoMessage *linphone_info_message_copy(const LinphoneInfoMessage *info_message); |
|---|
| | | |
|---|
| | | |
|---|
| | | /** |
|---|
old mode 100644
new mode 100755
old mode 100644
new mode 100755
old mode 100644
new mode 100755
old mode 100644
new mode 100755
old mode 100644
new mode 100755
old mode 100644
new mode 100755
old mode 100644
new mode 100755
old mode 100644
new mode 100755
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Singleton class giving access to logging features. |
|---|
| | | * |
|---|
| | | * It supports custom domain, writing into a file as well as several verbosity levels. |
|---|
| | | * The #LinphoneLoggingServiceCbs listener allows you to be notified each time a log is printed. |
|---|
| | | * |
|---|
| | | * As the #LinphoneLoggingService is a singleton, use linphone_logging_service_get() to get it. |
|---|
| | | */ |
|---|
| | | typedef struct _LinphoneLoggingService LinphoneLoggingService; |
|---|
| | | |
|---|
| | |
|---|
| | | * @brief Verbosity levels of log messages. |
|---|
| | | */ |
|---|
| | | typedef enum _LinphoneLogLevel { |
|---|
| | | LinphoneLogLevelDebug = 1, /**< @brief Level for debug messages. */ |
|---|
| | | LinphoneLogLevelDebug = 1<<0, /**< @brief Level for debug messages. */ |
|---|
| | | LinphoneLogLevelTrace = 1<<1, /**< @brief Level for traces. */ |
|---|
| | | LinphoneLogLevelMessage = 1<<2, /**< @brief Level for information messages. */ |
|---|
| | | LinphoneLogLevelWarning = 1<<3, /**< @brief Level for warning messages. */ |
|---|
| | |
|---|
| | | /** |
|---|
| | | * @brief Type of callbacks called each time liblinphone write a log message. |
|---|
| | | * |
|---|
| | | * @param log_service A pointer on the logging service singleton. |
|---|
| | | * @param domain A string describing which sub-library of liblinphone the message is coming from. |
|---|
| | | * @param lev Verbosity level of the message. |
|---|
| | | * @param message Content of the message. |
|---|
| | | * @param log_service A pointer on the logging service singleton. @notnil |
|---|
| | | * @param domain A string describing which sub-library of liblinphone the message is coming from. @notnil |
|---|
| | | * @param level Verbosity #LinphoneLogLevel of the message. |
|---|
| | | * @param message Content of the message. @notnil |
|---|
| | | */ |
|---|
| | | typedef void (*LinphoneLoggingServiceCbsLogMessageWrittenCb)(LinphoneLoggingService *log_service, const char *domain, LinphoneLogLevel lev, const char *message); |
|---|
| | | |
|---|
| | | |
|---|
| | | |
|---|
| | | |
|---|
| | | typedef void (*LinphoneLoggingServiceCbsLogMessageWrittenCb)(LinphoneLoggingService *log_service, const char *domain, LinphoneLogLevel level, const char *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Gets the singleton logging service object. |
|---|
| | |
|---|
| | | * The singleton is automatically instantiated if it hasn't |
|---|
| | | * been done yet. |
|---|
| | | * |
|---|
| | | * @return A pointer on the singleton. |
|---|
| | | * @return A pointer on the #LinphoneLoggingService singleton. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneLoggingService *linphone_logging_service_get(void); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Increases the reference counter. |
|---|
| | | * @param log_service the #LinphoneLoggingService object @notnil |
|---|
| | | * @return the same #LinphoneLoggingService object @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneLoggingService *linphone_logging_service_ref(LinphoneLoggingService *service); |
|---|
| | | LINPHONE_PUBLIC LinphoneLoggingService *linphone_logging_service_ref(LinphoneLoggingService *log_service); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Decreases the reference counter and destroy the object |
|---|
| | | * if the counter reaches 0. |
|---|
| | | * @brief Decreases the reference counter and destroy the object if the counter reaches 0. |
|---|
| | | * @param log_service the #LinphoneLoggingService object @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_logging_service_unref(LinphoneLoggingService *service); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Gets the logging service listener. |
|---|
| | | * @deprecated Use add_callbacks / remove_callbacks instead |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneLoggingServiceCbs *linphone_logging_service_get_callbacks(const LinphoneLoggingService *log_service); |
|---|
| | | LINPHONE_PUBLIC void linphone_logging_service_unref(LinphoneLoggingService *log_service); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Adds a callback object to the list of listeners |
|---|
| | | * @param log_service the LinphoneLoggingService object |
|---|
| | | * @param cbs the LinphoneLoggingServiceCbs to add |
|---|
| | | * @param log_service the #LinphoneLoggingService object @notnil |
|---|
| | | * @param cbs the #LinphoneLoggingServiceCbs to add @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_logging_service_add_callbacks(LinphoneLoggingService *log_service, LinphoneLoggingServiceCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Removes a callback object from the list of listeners |
|---|
| | | * @param log_service the LinphoneLoggingService object |
|---|
| | | * @param cbs the LinphoneLoggingServiceCbs to remove |
|---|
| | | * @param log_service the #LinphoneLoggingService object @notnil |
|---|
| | | * @param cbs the #LinphoneLoggingServiceCbs to remove @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_logging_service_remove_callbacks(LinphoneLoggingService *log_service, LinphoneLoggingServiceCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the current callbacks being called while iterating on callbacks |
|---|
| | | * @param log_service the LinphoneLoggingService object |
|---|
| | | * @return A pointer to the current LinphoneLoggingServiceCbs object |
|---|
| | | * @param log_service the #LinphoneLoggingService object @notnil |
|---|
| | | * @return A pointer to the current #LinphoneLoggingServiceCbs object @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneLoggingServiceCbs *linphone_logging_service_get_current_callbacks(const LinphoneLoggingService *log_service); |
|---|
| | | |
|---|
| | |
|---|
| | | * |
|---|
| | | * For instance, a level of #LinphoneLogLevelMessage will let pass fatal, error, warning and message-typed messages |
|---|
| | | * whereas trace and debug messages will be dumped out. |
|---|
| | | * @param log_service the #LinphoneLoggingService object @notnil |
|---|
| | | * @param level the #LinphoneLogLevel to set |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_logging_service_set_log_level(LinphoneLoggingService *log_service, LinphoneLogLevel level); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Sets the types of messages that will be authorized to be written in the log. |
|---|
| | | * @param log_service The logging service singleton. |
|---|
| | | * @param log_service the #LinphoneLoggingService object @notnil |
|---|
| | | * @param mask Example: #LinphoneLogLevelMessage|#LinphoneLogLevelError will ONLY let pass message-typed and error messages. |
|---|
| | | * @note Calling that function reset the log level that has been specified by #linphone_logging_service_set_log_level(). |
|---|
| | | */ |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Gets the log level mask. |
|---|
| | | * @param log_service the #LinphoneLoggingService object @notnil |
|---|
| | | * @return the log level mask |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC unsigned int linphone_logging_service_get_log_level_mask(const LinphoneLoggingService *log_service); |
|---|
| | | |
|---|
| | |
|---|
| | | * That function enables an internal log handler that writes log messages in |
|---|
| | | * log-rotated files. |
|---|
| | | * |
|---|
| | | * @param dir Directory where to create the distinct parts of the log. |
|---|
| | | * @param filename Name of the log file. |
|---|
| | | * @param log_service the #LinphoneLoggingService object @notnil |
|---|
| | | * @param dir Directory where to create the distinct parts of the log. @notnil |
|---|
| | | * @param filename Name of the log file. @notnil |
|---|
| | | * @param max_size The maximal size of each part of the log. The log rotating is triggered |
|---|
| | | * each time the currently opened log part reach that limit. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_logging_service_set_log_file(const LinphoneLoggingService *service, const char *dir, const char *filename, size_t max_size); |
|---|
| | | LINPHONE_PUBLIC void linphone_logging_service_set_log_file(const LinphoneLoggingService *log_service, const char *dir, const char *filename, size_t max_size); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Set the domain where application logs are written (for example with #linphone_logging_service_message()). |
|---|
| | | * @param log_service the #LinphoneLoggingService object @notnil |
|---|
| | | * @param domain The domain. @maybenil |
|---|
| | | * @note The domain is mandatory to write logs. This needs to be set before setting the log level. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_logging_service_set_domain(LinphoneLoggingService *log_service, const char *domain); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Get the domain where application logs are written (for example with #linphone_logging_service_message()). |
|---|
| | | * @param log_service the #LinphoneLoggingService object @maybenil |
|---|
| | | * @return The domain where application logs are written. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_logging_service_get_domain(LinphoneLoggingService *log_service); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Write a LinphoneLogLevelDebug message to the logs. |
|---|
| | | * @param log_service the #LinphoneLoggingService object @notnil |
|---|
| | | * @param message The log message. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_logging_service_debug(LinphoneLoggingService *log_service, const char *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Write a LinphoneLogLevelTrace message to the logs. |
|---|
| | | * @param log_service the #LinphoneLoggingService object @notnil |
|---|
| | | * @param message The log message. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_logging_service_trace(LinphoneLoggingService *log_service, const char *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Write a LinphoneLogLevelMessage message to the logs. |
|---|
| | | * @param log_service the #LinphoneLoggingService object @notnil |
|---|
| | | * @param message The log message. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_logging_service_message(LinphoneLoggingService *log_service, const char *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Write a LinphoneLogLevelWarning message to the logs. |
|---|
| | | * @param log_service the #LinphoneLoggingService object @notnil |
|---|
| | | * @param message The log message. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_logging_service_warning(LinphoneLoggingService *log_service, const char *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Write a LinphoneLogLevelError message to the logs. |
|---|
| | | * @param log_service the #LinphoneLoggingService object @notnil |
|---|
| | | * @param message The log message. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_logging_service_error(LinphoneLoggingService *log_service, const char *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Write a LinphoneLogLevelFatal message to the logs. |
|---|
| | | * @param log_service the #LinphoneLoggingService object @notnil |
|---|
| | | * @param message The log message. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_logging_service_fatal(LinphoneLoggingService *log_service, const char *message); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Increases the reference counter. |
|---|
| | | * @param cbs the #LinphoneLoggingServiceCbs object. @notnil |
|---|
| | | * @return the same #LinphoneLoggingServiceCbs object @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneLoggingServiceCbs *linphone_logging_service_cbs_ref(LinphoneLoggingServiceCbs *cbs); |
|---|
| | | |
|---|
| | |
|---|
| | | * @brief Decreases the reference counter. |
|---|
| | | * |
|---|
| | | * The object is automatically destroyed once the counter reach 0. |
|---|
| | | * @param cbs the #LinphoneLoggingServiceCbs object. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_logging_service_cbs_unref(LinphoneLoggingServiceCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Sets the callback to call each time liblinphone writes a log message. |
|---|
| | | * @param cbs the #LinphoneLoggingServiceCbs object. @notnil |
|---|
| | | * @param cb the #LinphoneLoggingServiceCbsLogMessageWrittenCb to set |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_logging_service_cbs_set_log_message_written(LinphoneLoggingServiceCbs *cbs, LinphoneLoggingServiceCbsLogMessageWrittenCb cb); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Gets the value of the message event callback. |
|---|
| | | * @param cbs the #LinphoneLoggingServiceCbs object. @notnil |
|---|
| | | * @return the current #LinphoneLoggingServiceCbsLogMessageWrittenCb |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneLoggingServiceCbsLogMessageWrittenCb linphone_logging_service_cbs_get_log_message_written(const LinphoneLoggingServiceCbs *cbs); |
|---|
| | | |
|---|
| | |
|---|
| | | * @brief Pass a pointer on a custom object. |
|---|
| | | * |
|---|
| | | * That pointer can be get back by callbacks by using #linphone_logging_service_get_cbs() and #linphone_logging_service_cbs_get_user_data(). |
|---|
| | | * @param cbs the #LinphoneLoggingServiceCbs object. @notnil |
|---|
| | | * @param user_data the user data pointer. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_logging_service_cbs_set_user_data(LinphoneLoggingServiceCbs *cbs, void *user_data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Gets the user_data pointer back. |
|---|
| | | * @param cbs the #LinphoneLoggingServiceCbs object. @notnil |
|---|
| | | * @return the user data pointer. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void *linphone_logging_service_cbs_get_user_data(const LinphoneLoggingServiceCbs *cbs); |
|---|
| | | |
|---|
| | | /************ */ |
|---|
| | | /* DEPRECATED */ |
|---|
| | | /* ********** */ |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Gets the logging service listener. |
|---|
| | | * @param log_service the #LinphoneLoggingService object |
|---|
| | | * @deprecated 19/02/2019 Use add_callbacks / remove_callbacks instead |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED LinphoneLoggingServiceCbs *linphone_logging_service_get_callbacks(const LinphoneLoggingService *log_service); |
|---|
| | | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @} |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | * Instantiates a #LinphoneConfig object from a user config file. |
|---|
| | | * The caller of this constructor owns a reference. linphone_config_unref() must be called when this object is no longer needed. |
|---|
| | | * @ingroup misc |
|---|
| | | * @param filename the filename of the config file to read to fill the instantiated #LinphoneConfig |
|---|
| | | * @see linphone_config_new_with_factory |
|---|
| | | * @param filename the filename of the config file to read to fill the instantiated #LinphoneConfig @maybenil |
|---|
| | | * @see linphone_config_new_with_factory() |
|---|
| | | * @return a #LinphoneConfig object @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneConfig * linphone_config_new(const char *filename); |
|---|
| | | |
|---|
| | |
|---|
| | | * Instantiates a #LinphoneConfig object from a user provided buffer. |
|---|
| | | * The caller of this constructor owns a reference. linphone_config_unref() must be called when this object is no longer needed. |
|---|
| | | * @ingroup misc |
|---|
| | | * @param buffer the buffer from which the #LinphoneConfig will be retrieved. We expect the buffer to be null-terminated. |
|---|
| | | * @see linphone_config_new_with_factory |
|---|
| | | * @see linphone_config_new |
|---|
| | | * @param buffer the buffer from which the #LinphoneConfig will be retrieved. We expect the buffer to be null-terminated. @notnil |
|---|
| | | * @see linphone_config_new_with_factory() |
|---|
| | | * @see linphone_config_new() |
|---|
| | | * @return a #LinphoneConfig object @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneConfig * linphone_config_new_from_buffer(const char *buffer); |
|---|
| | | |
|---|
| | |
|---|
| | | * Instantiates a #LinphoneConfig object from a user config file and a factory config file. |
|---|
| | | * The caller of this constructor owns a reference. linphone_config_unref() must be called when this object is no longer needed. |
|---|
| | | * @ingroup misc |
|---|
| | | * @param config_filename the filename of the user config file to read to fill the instantiated #LinphoneConfig |
|---|
| | | * @param factory_config_filename the filename of the factory config file to read to fill the instantiated #LinphoneConfig |
|---|
| | | * @see linphone_config_new |
|---|
| | | * @param config_filename the filename of the user config file to read to fill the instantiated #LinphoneConfig @maybenil |
|---|
| | | * @param factory_config_filename the filename of the factory config file to read to fill the instantiated #LinphoneConfig @maybenil |
|---|
| | | * @see linphone_config_new() |
|---|
| | | * @return a #LinphoneConfig object @maybenil |
|---|
| | | * |
|---|
| | | * The user config file is read first to fill the #LinphoneConfig and then the factory config file is read. |
|---|
| | | * Therefore the configuration parameters defined in the user config file will be overwritten by the parameters |
|---|
| | |
|---|
| | | LINPHONE_PUBLIC LinphoneConfig * linphone_config_new_with_factory(const char *config_filename, const char *factory_config_filename); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Instantiates a #LinphoneConfig object from a user config file name, group id and a factory config file. |
|---|
| | | * The "group id" is the string that identify the "App group" capability of the iOS application. |
|---|
| | | * App group gives access to a shared file system where all the configuration files for shared core are stored. |
|---|
| | | * Both iOS application and iOS app extension that need shared core must activate the "App group" capability with the SAME |
|---|
| | | * "group id" in the project settings. |
|---|
| | | * The caller of this constructor owns a reference. linphone_config_unref() must be called when this object is no longer needed. |
|---|
| | | * @ingroup misc |
|---|
| | | * @param app_group_id used to compute the path of the config file in the file system shared by the shared Cores @notnil |
|---|
| | | * @param config_filename the filename of the user config file to read to fill the instantiated #LinphoneConfig @maybenil |
|---|
| | | * @param factory_config_filename the filename of the factory config file to read to fill the instantiated #LinphoneConfig @maybenil |
|---|
| | | * @see linphone_config_new() |
|---|
| | | * @return a #LinphoneConfig object @maybenil |
|---|
| | | * |
|---|
| | | * The user config file is read first to fill the #LinphoneConfig and then the factory config file is read. |
|---|
| | | * Therefore the configuration parameters defined in the user config file will be overwritten by the parameters |
|---|
| | | * defined in the factory config file. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneConfig * linphone_config_new_for_shared_core(const char *app_group_id, const char* config_filename, const char *factory_config_filename); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Reads a user config file and fill the #LinphoneConfig with the read config values. |
|---|
| | | * @ingroup misc |
|---|
| | | * @param lpconfig The #LinphoneConfig object to fill with the content of the file |
|---|
| | | * @param filename The filename of the config file to read to fill the #LinphoneConfig |
|---|
| | | * @param config The #LinphoneConfig object to fill with the content of the file @notnil |
|---|
| | | * @param filename The filename of the config file to read to fill the #LinphoneConfig @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_config_read_file(LinphoneConfig *lpconfig, const char *filename); |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_config_read_file(LinphoneConfig *config, const char *filename); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Reads a xml config file and fill the #LinphoneConfig with the read config dynamic values. |
|---|
| | | * @ingroup misc |
|---|
| | | * @param lpconfig The #LinphoneConfig object to fill with the content of the file |
|---|
| | | * @param filename The filename of the config file to read to fill the #LinphoneConfig |
|---|
| | | * @param config The #LinphoneConfig object to fill with the content of the file @notnil |
|---|
| | | * @param filename The filename of the config file to read to fill the #LinphoneConfig @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char* linphone_config_load_from_xml_file(LinphoneConfig *lpc, const char *filename); |
|---|
| | | LINPHONE_PUBLIC const char* linphone_config_load_from_xml_file(LinphoneConfig *config, const char *filename); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Reads a xml config string and fill the #LinphoneConfig with the read config dynamic values. |
|---|
| | | * @ingroup misc |
|---|
| | | * @param lpconfig The #LinphoneConfig object to fill with the content of the file |
|---|
| | | * @param buffer The string of the config file to fill the #LinphoneConfig |
|---|
| | | * @param config The #LinphoneConfig object to fill with the content of the file @notnil |
|---|
| | | * @param buffer The string of the config file to fill the #LinphoneConfig @notnil |
|---|
| | | * @return 0 in case of success |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_config_load_from_xml_string(LpConfig *lpc, const char *buffer); |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_config_load_from_xml_string(LinphoneConfig *config, const char *buffer); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Retrieves a configuration item as a string, given its section, key, and default value. |
|---|
| | | * |
|---|
| | | * The default value string is returned if the config item isn't found. |
|---|
| | | * @param config The #LinphoneConfig object @notnil |
|---|
| | | * @param section The section from which to retrieve a configuration item @notnil |
|---|
| | | * @param key The name of the configuration item to retrieve @notnil |
|---|
| | | * @param default_string The default value to return if not found. @maybenil |
|---|
| | | * @return the found value or the default one if not found. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_config_get_string(const LinphoneConfig *lpconfig, const char *section, const char *key, const char *default_string); |
|---|
| | | LINPHONE_PUBLIC const char *linphone_config_get_string(const LinphoneConfig *config, const char *section, const char *key, const char *default_string); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Retrieves a configuration item as a list of strings, given its section, key, and default value. |
|---|
| | | * The default value is returned if the config item is not found. |
|---|
| | | * @param[in] lpconfig A #LinphoneConfig object |
|---|
| | | * @param[in] section The section from which to retrieve a configuration item |
|---|
| | | * @param[in] key The name of the configuration item to retrieve |
|---|
| | | * @param[in] default_list \bctbx_list{const char *} |
|---|
| | | * @return \bctbx_list{const char *} |
|---|
| | | * @param config A #LinphoneConfig object @notnil |
|---|
| | | * @param section The section from which to retrieve a configuration item @notnil |
|---|
| | | * @param key The name of the configuration item to retrieve @notnil |
|---|
| | | * @param default_list The list to return when the key doesn't exist. \bctbx_list{const char *} @maybenil |
|---|
| | | * @return A list of strings. \bctbx_list{const char *} @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bctbx_list_t * linphone_config_get_string_list(const LinphoneConfig *lpconfig, const char *section, const char *key, bctbx_list_t *default_list); |
|---|
| | | LINPHONE_PUBLIC bctbx_list_t * linphone_config_get_string_list(const LinphoneConfig *config, const char *section, const char *key, bctbx_list_t *default_list); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Retrieves a configuration item as a range, given its section, key, and default min and max values. |
|---|
| | | * |
|---|
| | | * @param config The #LinphoneConfig object @notnil |
|---|
| | | * @param section The section from which to retrieve a configuration item @notnil |
|---|
| | | * @param key The name of the configuration item to retrieve @notnil |
|---|
| | | * @param[out] min The min value found or default_min @notnil |
|---|
| | | * @param[out] max The max value found or default_max @notnil |
|---|
| | | * @param default_min the default min value to return if not found |
|---|
| | | * @param default_max the default max value to return if not found. |
|---|
| | | * @return TRUE if the value is successfully parsed as a range, FALSE otherwise. |
|---|
| | | * If FALSE is returned, min and max are filled respectively with default_min and default_max values. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_config_get_range(const LinphoneConfig *lpconfig, const char *section, const char *key, int *min, int *max, int default_min, int default_max); |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_config_get_range(const LinphoneConfig *config, const char *section, const char *key, int *min, int *max, int default_min, int default_max); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Retrieves a configuration item as an integer, given its section, key, and default value. |
|---|
| | | * |
|---|
| | | * The default integer value is returned if the config item isn't found. |
|---|
| | | * @param config The #LinphoneConfig object @notnil |
|---|
| | | * @param section The section from which to retrieve a configuration item @notnil |
|---|
| | | * @param key The name of the configuration item to retrieve @notnil |
|---|
| | | * @param default_value The default value to return if not found |
|---|
| | | * @return the found value or default_value if not found. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC int linphone_config_get_int(const LinphoneConfig *lpconfig,const char *section, const char *key, int default_value); |
|---|
| | | LINPHONE_PUBLIC int linphone_config_get_int(const LinphoneConfig *config, const char *section, const char *key, int default_value); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Retrieves a configuration item as a boolean, given its section, key, and default value. |
|---|
| | | * |
|---|
| | | * The default boolean value is returned if the config item isn't found. |
|---|
| | | * @param config The #LinphoneConfig object @notnil |
|---|
| | | * @param section The section from which to retrieve a configuration item @notnil |
|---|
| | | * @param key The name of the configuration item to retrieve @notnil |
|---|
| | | * @param default_value The default value to return if not found |
|---|
| | | * @return the found value or default_value if not found. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_config_get_bool(const LpConfig *lpconfig, const char *section, const char *key, bool_t default_value); |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_config_get_bool(const LinphoneConfig *config, const char *section, const char *key, bool_t default_value); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Retrieves a configuration item as a 64 bit integer, given its section, key, and default value. |
|---|
| | | * |
|---|
| | | * The default integer value is returned if the config item isn't found. |
|---|
| | | * @param config The #LinphoneConfig object @notnil |
|---|
| | | * @param section The section from which to retrieve a configuration item @notnil |
|---|
| | | * @param key The name of the configuration item to retrieve @notnil |
|---|
| | | * @param default_value The default value to return if not found |
|---|
| | | * @return the found value or default_value if not found. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC int64_t linphone_config_get_int64(const LinphoneConfig *lpconfig,const char *section, const char *key, int64_t default_value); |
|---|
| | | LINPHONE_PUBLIC int64_t linphone_config_get_int64(const LinphoneConfig *config, const char *section, const char *key, int64_t default_value); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Retrieves a configuration item as a float, given its section, key, and default value. |
|---|
| | | * |
|---|
| | | * The default float value is returned if the config item isn't found. |
|---|
| | | * @param config The #LinphoneConfig object @notnil |
|---|
| | | * @param section The section from which to retrieve a configuration item @notnil |
|---|
| | | * @param key The name of the configuration item to retrieve @notnil |
|---|
| | | * @param default_value The default value to return if not found |
|---|
| | | * @return the found value or default_value if not found. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC float linphone_config_get_float(const LinphoneConfig *lpconfig,const char *section, const char *key, float default_value); |
|---|
| | | LINPHONE_PUBLIC float linphone_config_get_float(const LinphoneConfig *config, const char *section, const char *key, float default_value); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets a string config item |
|---|
| | | * @param config The #LinphoneConfig object @notnil |
|---|
| | | * @param section The section from which to retrieve a configuration item @notnil |
|---|
| | | * @param key The name of the configuration item to retrieve @notnil |
|---|
| | | * @param value The value to set @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_config_set_string(LinphoneConfig *lpconfig,const char *section, const char *key, const char *value); |
|---|
| | | LINPHONE_PUBLIC void linphone_config_set_string(LinphoneConfig *config,const char *section, const char *key, const char *value); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets a string list config item |
|---|
| | | * @param[in] lpconfig A #LinphoneConfig object |
|---|
| | | * @param[in] section The name of the section to put the configuration item into |
|---|
| | | * @param[in] key The name of the configuration item to set |
|---|
| | | * @param[in] value \bctbx_list{const char *} The value to set |
|---|
| | | * @param config A #LinphoneConfig object @notnil |
|---|
| | | * @param section The name of the section to put the configuration item into @notnil |
|---|
| | | * @param key The name of the configuration item to set @notnil |
|---|
| | | * @param value The value to set. \bctbx_list{const char *} @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_config_set_string_list(LinphoneConfig *lpconfig, const char *section, const char *key, const bctbx_list_t *value); |
|---|
| | | LINPHONE_PUBLIC void linphone_config_set_string_list(LinphoneConfig *config, const char *section, const char *key, const bctbx_list_t *value); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets a range config item |
|---|
| | | * @param config The #LinphoneConfig object @notnil |
|---|
| | | * @param section The section from which to retrieve a configuration item @notnil |
|---|
| | | * @param key The name of the configuration item to retrieve @notnil |
|---|
| | | * @param min_value the min value to set |
|---|
| | | * @param max_value the max value to set |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_config_set_range(LinphoneConfig *lpconfig, const char *section, const char *key, int min_value, int max_value); |
|---|
| | | LINPHONE_PUBLIC void linphone_config_set_range(LinphoneConfig *config, const char *section, const char *key, int min_value, int max_value); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets an integer config item |
|---|
| | | * @param config The #LinphoneConfig object @notnil |
|---|
| | | * @param section The section from which to retrieve a configuration item @notnil |
|---|
| | | * @param key The name of the configuration item to retrieve @notnil |
|---|
| | | * @param value the value to set |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_config_set_int(LinphoneConfig *lpconfig,const char *section, const char *key, int value); |
|---|
| | | LINPHONE_PUBLIC void linphone_config_set_int(LinphoneConfig *config,const char *section, const char *key, int value); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets a boolean config item |
|---|
| | | * @param config The #LinphoneConfig object @notnil |
|---|
| | | * @param section The section from which to retrieve a configuration item @notnil |
|---|
| | | * @param key The name of the configuration item to retrieve @notnil |
|---|
| | | * @param value the value to set |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_config_set_bool(LinphoneConfig *lpconfig,const char *section, const char *key, bool_t value); |
|---|
| | | LINPHONE_PUBLIC void linphone_config_set_bool(LinphoneConfig *config,const char *section, const char *key, bool_t value); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets an integer config item, but store it as hexadecimal |
|---|
| | | * @param config The #LinphoneConfig object @notnil |
|---|
| | | * @param section The section from which to retrieve a configuration item @notnil |
|---|
| | | * @param key The name of the configuration item to retrieve @notnil |
|---|
| | | * @param value the value to set |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_config_set_int_hex(LinphoneConfig *lpconfig,const char *section, const char *key, int value); |
|---|
| | | LINPHONE_PUBLIC void linphone_config_set_int_hex(LinphoneConfig *config,const char *section, const char *key, int value); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets a 64 bits integer config item |
|---|
| | | * @param config The #LinphoneConfig object @notnil |
|---|
| | | * @param section The section from which to retrieve a configuration item @notnil |
|---|
| | | * @param key The name of the configuration item to retrieve @notnil |
|---|
| | | * @param value the value to set |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_config_set_int64(LinphoneConfig *lpconfig,const char *section, const char *key, int64_t value); |
|---|
| | | LINPHONE_PUBLIC void linphone_config_set_int64(LinphoneConfig *config,const char *section, const char *key, int64_t value); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets a float config item |
|---|
| | | * @param config The #LinphoneConfig object @notnil |
|---|
| | | * @param section The section from which to retrieve a configuration item @notnil |
|---|
| | | * @param key The name of the configuration item to retrieve @notnil |
|---|
| | | * @param value the value to set |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_config_set_float(LinphoneConfig *lpconfig,const char *section, const char *key, float value); |
|---|
| | | LINPHONE_PUBLIC void linphone_config_set_float(LinphoneConfig *config,const char *section, const char *key, float value); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Writes the config file to disk. |
|---|
| | | * @param config The #LinphoneConfig object @notnil |
|---|
| | | * @return 0 if successful, -1 otherwise |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_config_sync(LinphoneConfig *lpconfig); |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_config_sync(LinphoneConfig *config); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns 1 if a given section is present in the configuration. |
|---|
| | | * Reload the config from the file. |
|---|
| | | * @param config The #LinphoneConfig object @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC int linphone_config_has_section(const LinphoneConfig *lpconfig, const char *section); |
|---|
| | | LINPHONE_PUBLIC void linphone_config_reload(LinphoneConfig *config); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns if a given section is present in the configuration. |
|---|
| | | * @param config The #LinphoneConfig object @notnil |
|---|
| | | * @param section the section to check if exists @notnil |
|---|
| | | * @return 1 if it exists, 0 otherwise |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC int linphone_config_has_section(const LinphoneConfig *config, const char *section); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Removes every pair of key,value in a section and remove the section. |
|---|
| | | * @param config The #LinphoneConfig object @notnil |
|---|
| | | * @param section the section to clean @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_config_clean_section(LinphoneConfig *lpconfig, const char *section); |
|---|
| | | LINPHONE_PUBLIC void linphone_config_clean_section(LinphoneConfig *config, const char *section); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns 1 if a given section with a given key is present in the configuration. |
|---|
| | | * @param[in] lpconfig The #LinphoneConfig object |
|---|
| | | * @param[in] section |
|---|
| | | * @param[in] key |
|---|
| | | * Returns if a given section with a given key is present in the configuration. |
|---|
| | | * @param config The #LinphoneConfig object @notnil |
|---|
| | | * @param section to check if the given entry exists @notnil |
|---|
| | | * @param key to check if it exists @notnil |
|---|
| | | * @return 1 if it exists, 0 otherwise |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC int linphone_config_has_entry(const LinphoneConfig *lpconfig, const char *section, const char *key); |
|---|
| | | LINPHONE_PUBLIC int linphone_config_has_entry(const LinphoneConfig *config, const char *section, const char *key); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Removes entries for key,value in a section. |
|---|
| | | * @param[in] lpconfig The #LinphoneConfig object |
|---|
| | | * @param[in] section |
|---|
| | | * @param[in] key |
|---|
| | | * @param config The #LinphoneConfig object @notnil |
|---|
| | | * @param section the section for which to clean the key entry @notnil |
|---|
| | | * @param key the key to clean @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_config_clean_entry(LinphoneConfig *lpconfig, const char *section, const char *key); |
|---|
| | | LINPHONE_PUBLIC void linphone_config_clean_entry(LinphoneConfig *config, const char *section, const char *key); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the list of sections' names in the LinphoneConfig. |
|---|
| | | * @param[in] lpconfig The #LinphoneConfig object |
|---|
| | | * @return a null terminated static array of strings |
|---|
| | | * @deprecated use linphone_config_get_sections_names_list instead |
|---|
| | | * @donotwrap |
|---|
| | | * @param config The #LinphoneConfig object @notnil |
|---|
| | | * @return A list of strings. \bctbx_list{char *} @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char** linphone_config_get_sections_names(LinphoneConfig *lpconfig); |
|---|
| | | LINPHONE_PUBLIC const bctbx_list_t * linphone_config_get_sections_names_list(LinphoneConfig *config); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the list of sections' names in the LinphoneConfig. |
|---|
| | | * @param[in] lpconfig The #LinphoneConfig object |
|---|
| | | * @return \bctbx_list{char *} a null terminated static array of strings |
|---|
| | | * Returns the list of keys' names for a section in the LinphoneConfig. |
|---|
| | | * @param config The #LinphoneConfig object @notnil |
|---|
| | | * @param section The section name @notnil |
|---|
| | | * @return A list of strings. \bctbx_list{char *} @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const bctbx_list_t * linphone_config_get_sections_names_list(LpConfig *lpconfig); |
|---|
| | | LINPHONE_PUBLIC const bctbx_list_t * linphone_config_get_keys_names_list(LinphoneConfig *config, const char *section ); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Call a function for each section present in the configuration. |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | | void linphone_config_for_each_section(const LinphoneConfig *lpconfig, void (*callback)(const char *section, void *ctx), void *ctx); |
|---|
| | | void linphone_config_for_each_section(const LinphoneConfig *config, void (*callback)(const char *section, void *ctx), void *ctx); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @brief Call a function for each entry present in a section configuration. |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | | void linphone_config_for_each_entry(const LinphoneConfig *lpconfig, const char *section, void (*callback)(const char *entry, void *ctx), void *ctx); |
|---|
| | | void linphone_config_for_each_entry(const LinphoneConfig *config, const char *section, void (*callback)(const char *entry, void *ctx), void *ctx); |
|---|
| | | |
|---|
| | | /*tells whether uncommited (with linphone_config_sync()) modifications exist*/ |
|---|
| | | bool_t linphone_config_needs_commit(const LinphoneConfig *lpconfig); |
|---|
| | | bool_t linphone_config_needs_commit(const LinphoneConfig *config); |
|---|
| | | |
|---|
| | | LINPHONE_PUBLIC void linphone_config_destroy(LinphoneConfig *cfg); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Retrieves a default configuration item as an integer, given its section, key, and default value. |
|---|
| | | * The default integer value is returned if the config item isn't found. |
|---|
| | | * @param config The #LinphoneConfig object @notnil |
|---|
| | | * @param section The section from which to retrieve the default value @notnil |
|---|
| | | * @param key The name of the configuration item to retrieve @notnil |
|---|
| | | * @param default_value The default value to return if not found |
|---|
| | | * @return the found default value or default_value if not found. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC int linphone_config_get_default_int(const LinphoneConfig *lpconfig, const char *section, const char *key, int default_value); |
|---|
| | | LINPHONE_PUBLIC int linphone_config_get_default_int(const LinphoneConfig *config, const char *section, const char *key, int default_value); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Retrieves a default configuration item as a 64 bit integer, given its section, key, and default value. |
|---|
| | | * The default integer value is returned if the config item isn't found. |
|---|
| | | * @param config The #LinphoneConfig object @notnil |
|---|
| | | * @param section The section from which to retrieve the default value @notnil |
|---|
| | | * @param key The name of the configuration item to retrieve @notnil |
|---|
| | | * @param default_value The default value to return if not found |
|---|
| | | * @return the found default value or default_value if not found. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC int64_t linphone_config_get_default_int64(const LinphoneConfig *lpconfig, const char *section, const char *key, int64_t default_value); |
|---|
| | | LINPHONE_PUBLIC int64_t linphone_config_get_default_int64(const LinphoneConfig *config, const char *section, const char *key, int64_t default_value); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Retrieves a default configuration item as a float, given its section, key, and default value. |
|---|
| | | * The default float value is returned if the config item isn't found. |
|---|
| | | * @param config The #LinphoneConfig object @notnil |
|---|
| | | * @param section The section from which to retrieve the default value @notnil |
|---|
| | | * @param key The name of the configuration item to retrieve @notnil |
|---|
| | | * @param default_value The default value to return if not found |
|---|
| | | * @return the found default value or default_value if not found. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC float linphone_config_get_default_float(const LinphoneConfig *lpconfig, const char *section, const char *key, float default_value); |
|---|
| | | LINPHONE_PUBLIC float linphone_config_get_default_float(const LinphoneConfig *config, const char *section, const char *key, float default_value); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Retrieves a default configuration item as a string, given its section, key, and default value. |
|---|
| | | * The default value string is returned if the config item isn't found. |
|---|
| | | * @param config The #LinphoneConfig object @notnil |
|---|
| | | * @param section The section from which to retrieve the default value @notnil |
|---|
| | | * @param key The name of the configuration item to retrieve @notnil |
|---|
| | | * @param default_value The default value to return if not found |
|---|
| | | * @return the found default value or default_value if not found. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char* linphone_config_get_default_string(const LinphoneConfig *lpconfig, const char *section, const char *key, const char *default_value); |
|---|
| | | LINPHONE_PUBLIC const char* linphone_config_get_default_string(const LinphoneConfig *config, const char *section, const char *key, const char *default_value); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Retrieves a section parameter item as a string, given its section and key. |
|---|
| | | * The default value string is returned if the config item isn't found. |
|---|
| | | * @param config The #LinphoneConfig object @notnil |
|---|
| | | * @param section The section from which to retrieve the default value @notnil |
|---|
| | | * @param key The name of the configuration item to retrieve @notnil |
|---|
| | | * @param default_value The default value to return if not found. @maybenil |
|---|
| | | * @return the found default value or default_value if not found. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char* linphone_config_get_section_param_string(const LinphoneConfig *lpconfig, const char *section, const char *key, const char *default_value); |
|---|
| | | LINPHONE_PUBLIC const char* linphone_config_get_section_param_string(const LinphoneConfig *config, const char *section, const char *key, const char *default_value); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * increment reference count |
|---|
| | | * @param config The #LinphoneConfig object @notnil |
|---|
| | | * @return the same #LinphoneConfig object @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneConfig *linphone_config_ref(LinphoneConfig *lpconfig); |
|---|
| | | LINPHONE_PUBLIC LinphoneConfig *linphone_config_ref(LinphoneConfig *config); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Decrement reference count, which will eventually free the object. |
|---|
| | | * @param config The #LinphoneConfig object @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_config_unref(LinphoneConfig *lpconfig); |
|---|
| | | LINPHONE_PUBLIC void linphone_config_unref(LinphoneConfig *config); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Write a string in a file placed relatively with the Linphone configuration file. |
|---|
| | | * @param lpconfig #LinphoneConfig instance used as a reference |
|---|
| | | * @param filename Name of the file where to write data. The name is relative to the place of the config file |
|---|
| | | * @param data String to write |
|---|
| | | * @param config #LinphoneConfig instance used as a reference @notnil |
|---|
| | | * @param filename Name of the file where to write data. The name is relative to the place of the config file @notnil |
|---|
| | | * @param data String to write @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_config_write_relative_file(const LinphoneConfig *lpconfig, const char *filename, const char *data); |
|---|
| | | LINPHONE_PUBLIC void linphone_config_write_relative_file(const LinphoneConfig *config, const char *filename, const char *data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Read a string from a file placed beside the Linphone configuration file |
|---|
| | | * @param lpconfig #LinphoneConfig instance used as a reference |
|---|
| | | * @param config #LinphoneConfig instance used as a reference |
|---|
| | | * @param filename Name of the file where data will be read from. The name is relative to the place of the config file |
|---|
| | | * @param data Buffer where read string will be stored |
|---|
| | | * @param max_length Length of the buffer |
|---|
| | | * @return 0 on success, -1 on failure |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_config_read_relative_file(const LinphoneConfig *lpconfig, const char *filename, char *data, size_t max_length); |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_config_read_relative_file(const LinphoneConfig *config, const char *filename, char *data, size_t max_length); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Check if given file name exists relatively to the current location |
|---|
| | | * @param config The #LinphoneConfig object @notnil |
|---|
| | | * @param filename The file name to check if exists @notnil |
|---|
| | | * @return TRUE if file exists relative to the to the current location |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_config_relative_file_exists(const LinphoneConfig *lpconfig, const char *filename); |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_config_relative_file_exists(const LinphoneConfig *config, const char *filename); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Dumps the #LinphoneConfig as XML into a buffer |
|---|
| | | * @param[in] lpconfig The #LinphoneConfig object |
|---|
| | | * @return The buffer that contains the XML dump |
|---|
| | | * @param config The #LinphoneConfig object @notnil |
|---|
| | | * @return The buffer that contains the XML dump @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC char* linphone_config_dump_as_xml(const LinphoneConfig *lpconfig); |
|---|
| | | LINPHONE_PUBLIC char* linphone_config_dump_as_xml(const LinphoneConfig *config); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Dumps the #LinphoneConfig as INI into a buffer |
|---|
| | | * @param[in] lpconfig The #LinphoneConfig object |
|---|
| | | * @return The buffer that contains the config dump |
|---|
| | | * @param config The #LinphoneConfig object @notnil |
|---|
| | | * @return The buffer that contains the config dump @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC char* linphone_config_dump(const LinphoneConfig *lpconfig); |
|---|
| | | LINPHONE_PUBLIC char* linphone_config_dump(const LinphoneConfig *config); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Retrieves the overwrite flag for a config item |
|---|
| | | * @param config The #LinphoneConfig object @notnil |
|---|
| | | * @param section The section from which to retrieve the overwrite flag @notnil |
|---|
| | | * @param key The name of the configuration item to retrieve the overwrite flag from. @notnil |
|---|
| | | * @return TRUE if overwrite flag is set, FALSE otherwise. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_config_get_overwrite_flag_for_entry(const LinphoneConfig *lpconfig, const char *section, const char *key); |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_config_get_overwrite_flag_for_entry(const LinphoneConfig *config, const char *section, const char *key); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the overwrite flag for a config item (used when dumping config as xml) |
|---|
| | | * @param config The #LinphoneConfig object @notnil |
|---|
| | | * @param section The section from which to set the overwrite flag @notnil |
|---|
| | | * @param key The name of the configuration item to set the overwrite flag from @notnil |
|---|
| | | * @param value The overwrite flag value to set |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_config_set_overwrite_flag_for_entry(LinphoneConfig *lpconfig, const char *section, const char *key, bool_t value); |
|---|
| | | LINPHONE_PUBLIC void linphone_config_set_overwrite_flag_for_entry(LinphoneConfig *config, const char *section, const char *key, bool_t value); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Retrieves the overwrite flag for a config section |
|---|
| | | * @param config The #LinphoneConfig object @notnil |
|---|
| | | * @param section The section from which to retrieve the overwrite flag @notnil |
|---|
| | | * @return TRUE if overwrite flag is set, FALSE otherwise. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_config_get_overwrite_flag_for_section(const LinphoneConfig *lpconfig, const char *section); |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_config_get_overwrite_flag_for_section(const LinphoneConfig *config, const char *section); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the overwrite flag for a config section (used when dumping config as xml) |
|---|
| | | * @param config The #LinphoneConfig object @notnil |
|---|
| | | * @param section The section from which to set the overwrite flag @notnil |
|---|
| | | * @param value The overwrite flag value to set |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_config_set_overwrite_flag_for_section(LinphoneConfig *lpconfig, const char *section, bool_t value); |
|---|
| | | LINPHONE_PUBLIC void linphone_config_set_overwrite_flag_for_section(LinphoneConfig *config, const char *section, bool_t value); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Retrieves the skip flag for a config item |
|---|
| | | * @param config The #LinphoneConfig object @notnil |
|---|
| | | * @param section The section from which to retrieve the skip flag @notnil |
|---|
| | | * @param key The name of the configuration item to retrieve the skip flag from |
|---|
| | | * @return TRUE if skip flag is set, FALSE otherwise. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_config_get_skip_flag_for_entry(const LinphoneConfig *lpconfig, const char *section, const char *key); |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_config_get_skip_flag_for_entry(const LinphoneConfig *config, const char *section, const char *key); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the skip flag for a config item (used when dumping config as xml) |
|---|
| | | * @param config The #LinphoneConfig object @notnil |
|---|
| | | * @param section The section from which to set the skip flag @notnil |
|---|
| | | * @param key The name of the configuration item to set the skip flag from @notnil |
|---|
| | | * @param value The skip flag value to set |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_config_set_skip_flag_for_entry(LinphoneConfig *lpconfig, const char *section, const char *key, bool_t value); |
|---|
| | | LINPHONE_PUBLIC void linphone_config_set_skip_flag_for_entry(LinphoneConfig *config, const char *section, const char *key, bool_t value); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Retrieves the skip flag for a config section |
|---|
| | | * @param config The #LinphoneConfig object @notnil |
|---|
| | | * @param section The section from which to retrieve the skip flag @notnil |
|---|
| | | * @return TRUE if skip flag is set, FALSE otherwise. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_config_get_skip_flag_for_section(const LinphoneConfig *lpconfig, const char *section); |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_config_get_skip_flag_for_section(const LinphoneConfig *config, const char *section); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the skip flag for a config section (used when dumping config as xml) |
|---|
| | | * @param config The #LinphoneConfig object @notnil |
|---|
| | | * @param section The section from which to set the skip flag @notnil |
|---|
| | | * @param value The skip flag value to set |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_config_set_skip_flag_for_section(LinphoneConfig *lpconfig, const char *section, bool_t value); |
|---|
| | | LINPHONE_PUBLIC void linphone_config_set_skip_flag_for_section(LinphoneConfig *config, const char *section, bool_t value); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Converts a config section into a dictionary. |
|---|
| | | * @return a dictionary with all the keys from a section, or NULL if the section doesn't exist |
|---|
| | | * @param config The #LinphoneConfig object @notnil |
|---|
| | | * @param section The section to dump as dictionary @notnil |
|---|
| | | * @return a dictionary with all the keys from a section, or NULL if the section doesn't exist. @maybenil |
|---|
| | | * @donotwrap LinphoneDictionary can't be wrapped |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneDictionary * lp_config_section_to_dict( const LpConfig* lpconfig, const char* section ); |
|---|
| | | LINPHONE_PUBLIC LinphoneDictionary * linphone_config_section_to_dict(const LinphoneConfig* config, const char* section); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Loads a dictionary into a section of the lpconfig. If the section doesn't exist it is created. |
|---|
| | | * Loads a dictionary into a section of the #LinphoneConfig. If the section doesn't exist it is created. |
|---|
| | | * Overwrites existing keys, creates non-existing keys. |
|---|
| | | * @param config The #LinphoneConfig object @notnil |
|---|
| | | * @param section The section to dump as dictionary @notnil |
|---|
| | | * @param dict the dictionnary to load into the section @notnil |
|---|
| | | * @donotwrap LinphoneDictionary can't be wrapped |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void lp_config_load_dict_to_section( LpConfig* lpconfig, const char* section, const LinphoneDictionary* dict); |
|---|
| | | LINPHONE_PUBLIC void linphone_config_load_dict_to_section(LinphoneConfig* config, const char* section, const LinphoneDictionary* dict); |
|---|
| | | |
|---|
| | | /************ */ |
|---|
| | | /* DEPRECATED */ |
|---|
| | | /* ********** */ |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the list of sections' names in the LinphoneConfig. |
|---|
| | | * @param config The #LinphoneConfig object |
|---|
| | | * @return a null terminated static array of strings |
|---|
| | | * @deprecated 12/10/2017 use linphone_config_get_sections_names_list instead |
|---|
| | | * @donotwrap |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char** linphone_config_get_sections_names(LinphoneConfig *config); |
|---|
| | | |
|---|
| | | #ifdef __cplusplus |
|---|
| | | } |
|---|
| | | #endif |
|---|
| | | |
|---|
| | | // Define old function names for backward compatibility |
|---|
| | | #define lp_config_new linphone_config_new |
|---|
| | | #define lp_config_new_from_buffer linphone_config_new_from_buffer |
|---|
| | | #define lp_config_new_with_factory linphone_config_new_with_factory |
|---|
| | | #define lp_config_read_file linphone_config_read_file |
|---|
| | | #define lp_config_get_string linphone_config_get_string |
|---|
| | | #define lp_config_get_string_list linphone_config_get_string_list |
|---|
| | | #define lp_config_get_range linphone_config_get_range |
|---|
| | | #define lp_config_get_int linphone_config_get_int |
|---|
| | | #define lp_config_get_int64 linphone_config_get_int64 |
|---|
| | | #define lp_config_get_float linphone_config_get_float |
|---|
| | | #define lp_config_set_string linphone_config_set_string |
|---|
| | | #define lp_config_set_string_list linphone_config_set_string_list |
|---|
| | | #define lp_config_set_range linphone_config_set_range |
|---|
| | | #define lp_config_set_int linphone_config_set_int |
|---|
| | | #define lp_config_set_int_hex linphone_config_set_int_hex |
|---|
| | | #define lp_config_set_int64 linphone_config_set_int64 |
|---|
| | | #define lp_config_set_float linphone_config_set_float |
|---|
| | | #define lp_config_sync linphone_config_sync |
|---|
| | | #define lp_config_has_section linphone_config_has_section |
|---|
| | | #define lp_config_clean_section linphone_config_clean_section |
|---|
| | | #define lp_config_has_entry linphone_config_has_entry |
|---|
| | | #define lp_config_clean_entry linphone_config_clean_entry |
|---|
| | | #define lp_config_get_sections_names linphone_config_get_sections_names |
|---|
| | | #define lp_config_for_each_section linphone_config_for_each_section |
|---|
| | | #define lp_config_for_each_entry linphone_config_for_each_entry |
|---|
| | | #define lp_config_needs_commit linphone_config_needs_commit |
|---|
| | | #define lp_config_destroy linphone_config_destroy |
|---|
| | | #define lp_config_get_default_int linphone_config_get_default_int |
|---|
| | | #define lp_config_get_default_int64 linphone_config_get_default_int64 |
|---|
| | | #define lp_config_get_default_float linphone_config_get_default_float |
|---|
| | | #define lp_config_get_default_string linphone_config_get_default_string |
|---|
| | | #define lp_config_get_section_param_string linphone_config_get_section_param_string |
|---|
| | | #define lp_config_ref linphone_config_ref |
|---|
| | | #define lp_config_unref linphone_config_unref |
|---|
| | | #define lp_config_write_relative_file linphone_config_write_relative_file |
|---|
| | | #define lp_config_read_relative_file linphone_config_read_relative_file |
|---|
| | | #define lp_config_relative_file_exists linphone_config_relative_file_exists |
|---|
| | | #define lp_config_dump_as_xml linphone_config_dump_as_xml |
|---|
| | | #define lp_config_dump linphone_config_dump |
|---|
| | | #define lp_config_get_overwrite_flag_for_entry linphone_config_get_overwrite_flag_for_entry |
|---|
| | | #define lp_config_set_overwrite_flag_for_entry linphone_config_set_overwrite_flag_for_entry |
|---|
| | | #define lp_config_get_overwrite_flag_for_section linphone_config_get_overwrite_flag_for_section |
|---|
| | | #define lp_config_set_overwrite_flag_for_section linphone_config_set_overwrite_flag_for_section |
|---|
| | | #define lp_config_get_skip_flag_for_entry linphone_config_get_skip_flag_for_entry |
|---|
| | | #define lp_config_set_skip_flag_for_entry linphone_config_set_skip_flag_for_entry |
|---|
| | | #define lp_config_get_skip_flag_for_section linphone_config_get_skip_flag_for_section |
|---|
| | | #define lp_config_set_skip_flag_for_section linphone_config_set_skip_flag_for_section |
|---|
| | | // 08/07/2020 Define old function names for backward compatibility |
|---|
| | | #define lp_config_section_to_dict linphone_config_section_to_dict |
|---|
| | | #define lp_config_load_dict_to_section linphone_config_load_dict_to_section |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @} |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | /** |
|---|
| | | * Function returning a human readable value for LinphoneStreamType. |
|---|
| | | * @ingroup initializing |
|---|
| | | * @param type the #LinphoneStreamType |
|---|
| | | * @return a string representation of the #LinphoneStreamType @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_stream_type_to_string(const LinphoneStreamType); |
|---|
| | | LINPHONE_PUBLIC const char *linphone_stream_type_to_string(const LinphoneStreamType type); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Human readable version of the #LinphoneRegistrationState |
|---|
| | | * @param cs sate |
|---|
| | | * @param state #LinphoneRegistrationState the value for which we want a string representation |
|---|
| | | * @return a string representation of the #LinphoneRegistrationState @notnil |
|---|
| | | * @ingroup proxies |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_registration_state_to_string(LinphoneRegistrationState cs); |
|---|
| | | LINPHONE_PUBLIC const char *linphone_registration_state_to_string(LinphoneRegistrationState state); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Convert enum member to string. |
|---|
| | | * @param media_encryption the #LinphoneMediaEncryption to convert |
|---|
| | | * @return a string representation of the #LinphoneMediaEncryption @notnil |
|---|
| | | * @ingroup media_parameters |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_media_encryption_to_string(LinphoneMediaEncryption menc); |
|---|
| | | LINPHONE_PUBLIC const char *linphone_media_encryption_to_string(LinphoneMediaEncryption media_encryption); |
|---|
| | | |
|---|
| | | LINPHONE_PUBLIC const char* linphone_privacy_to_string(LinphonePrivacy privacy); |
|---|
| | | |
|---|
| | |
|---|
| | | LINPHONE_PUBLIC const char *linphone_call_state_to_string(LinphoneCallState cs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Converts a _LinphoneConfiguringState enum to a string. |
|---|
| | | * Converts a #LinphoneConfiguringState enum to a string. |
|---|
| | | * @param state #LinphoneConfiguringState the value for which we want a string representation |
|---|
| | | * @return a string representation of the #LinphoneConfiguringState @notnil |
|---|
| | | * @ingroup misc |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_configuring_state_to_string(LinphoneConfiguringState cs); |
|---|
| | | LINPHONE_PUBLIC const char *linphone_configuring_state_to_string(LinphoneConfiguringState state); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns a #LinphoneChatMessageState as a string. |
|---|
| | | * @param state #LinphoneChatMessageState the value for which we want a string representation |
|---|
| | | * @return a string representation of the #LinphoneChatMessageState @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char* linphone_chat_message_state_to_string(const LinphoneChatMessageState state); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Converts a #LinphoneReason enum to a string. |
|---|
| | | * @param[in] err A #LinphoneReason |
|---|
| | | * @return The string representation of the specified #LinphoneReason |
|---|
| | | * @param error A #LinphoneReason |
|---|
| | | * @return The string representation of the specified #LinphoneReason @notnil |
|---|
| | | * @ingroup misc |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_reason_to_string(LinphoneReason err); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Return humain readable presence status |
|---|
| | | * @param ss |
|---|
| | | * @deprecated Use #LinphonePresenceModel, #LinphonePresenceActivity and linphone_presence_activity_to_string() instead. |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED const char *linphone_online_status_to_string(LinphoneOnlineStatus ss); |
|---|
| | | LINPHONE_PUBLIC const char *linphone_reason_to_string(LinphoneReason error); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Convert a string into #LinphoneTunnelMode enum |
|---|
| | | * @param string String to convert |
|---|
| | | * @param string String to convert @maybenil |
|---|
| | | * @return An #LinphoneTunnelMode enum. If the passed string is NULL or |
|---|
| | | * does not match with any mode, the #LinphoneTunnelModeDisable is returned. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneTunnelMode linphone_tunnel_mode_from_string(const char *string); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Convert a tunnel mode enum into string |
|---|
| | | * @param mode Enum to convert |
|---|
| | | * @return "disable", "enable" or "auto" |
|---|
| | | * Convert a #LinphoneTunnelMode enum into string |
|---|
| | | * @param mode #LinphoneTunnelMode to convert |
|---|
| | | * @return "disable", "enable" or "auto" @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_tunnel_mode_to_string(LinphoneTunnelMode mode); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Check whether Matroksa format is supported by the player |
|---|
| | | * @return TRUE if it is supported |
|---|
| | | * @return TRUE if it is supported, FALSE otherwise |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_local_player_matroska_supported(void); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Converts a #LinphoneTransportType enum to a lowercase string. |
|---|
| | | * @param transport a #LinphoneTransportType to convert to string |
|---|
| | | * @return the string representation of the #LinphoneTransportType @notnil |
|---|
| | | * @ingroup misc |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC const char* linphone_transport_to_string(LinphoneTransportType transport); |
|---|
| | |
|---|
| | | /** |
|---|
| | | * Converts a lowercase string to a #LinphoneTransportType enum. |
|---|
| | | * @ingroup misc |
|---|
| | | * @return Transport matching input, or #LinphoneTransportUdp if nothing is found |
|---|
| | | * @param transport the transport to parse. @notnil |
|---|
| | | * @return #LinphoneTransportType matching input, or #LinphoneTransportUdp if nothing is found |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneTransportType linphone_transport_parse(const char* transport); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Check whether an error code is in Retry-After field. |
|---|
| | | * @param[in] err An error code |
|---|
| | | * @param error An error code |
|---|
| | | * @return TRUE if it is in Retry-After field |
|---|
| | | * @ingroup misc |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_error_code_is_retry_after(int err); |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_error_code_is_retry_after(int error); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Converts an error code to a LinphoneReason. |
|---|
| | | * @param[in] err An error code |
|---|
| | | * @param error An error code |
|---|
| | | * @return The #LinphoneReason corresponding to the specified error code |
|---|
| | | * @ingroup misc |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneReason linphone_error_code_to_reason(int err); |
|---|
| | | LINPHONE_PUBLIC LinphoneReason linphone_error_code_to_reason(int error); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Converts a #LinphoneReason to an error code. |
|---|
| | | * @param[in] reason A #LinphoneReason |
|---|
| | | * @param reason A #LinphoneReason |
|---|
| | | * @return The error code corresponding to the specified #LinphoneReason |
|---|
| | | * @ingroup misc |
|---|
| | | */ |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Increment refcount. |
|---|
| | | * @param[in] range #LinphoneRange object |
|---|
| | | * @param range #LinphoneRange object @notnil |
|---|
| | | * @return the same #LinphoneRange object @notnil |
|---|
| | | * @ingroup misc |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneRange *linphone_range_ref(LinphoneRange *range); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Decrement refcount and possibly free the object. |
|---|
| | | * @param[in] range #LinphoneRange object |
|---|
| | | * @param range #LinphoneRange object @notnil |
|---|
| | | * @ingroup misc |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_range_unref(LinphoneRange *range); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the user data in the #LinphoneRange object |
|---|
| | | * @param[in] range the #LinphoneRange |
|---|
| | | * @return the user data |
|---|
| | | * @param range the #LinphoneRange @notnil |
|---|
| | | * @return the user data. @maybenil |
|---|
| | | * @ingroup misc |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void *linphone_range_get_user_data(const LinphoneRange *range); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the user data in the #LinphoneRange object |
|---|
| | | * @param[in] range the #LinphoneRange object |
|---|
| | | * @param[in] data the user data |
|---|
| | | * @param range the #LinphoneRange object @notnil |
|---|
| | | * @param user_data the user data @maybenil |
|---|
| | | * @ingroup misc |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_range_set_user_data(LinphoneRange *range, void *data); |
|---|
| | | LINPHONE_PUBLIC void linphone_range_set_user_data(LinphoneRange *range, void *user_data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the lower value of the range |
|---|
| | | * @param[in] range a #LinphoneRange |
|---|
| | | * @param range a #LinphoneRange @notnil |
|---|
| | | * @return The lower value |
|---|
| | | * @ingroup misc |
|---|
| | | */ |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the higher value of the range |
|---|
| | | * @param[in] range a #LinphoneRange |
|---|
| | | * @param range a #LinphoneRange @notnil |
|---|
| | | * @return The higher value |
|---|
| | | * @ingroup misc |
|---|
| | | */ |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the lower value of the range |
|---|
| | | * @param[in] range a #LinphoneRange |
|---|
| | | * @param[in] min the value to set |
|---|
| | | * @param range a #LinphoneRange @notnil |
|---|
| | | * @param min the value to set |
|---|
| | | * @ingroup misc |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_range_set_min(LinphoneRange *range, int min); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the higher value of the range |
|---|
| | | * @param[in] range a #LinphoneRange |
|---|
| | | * @param[in] max the value to set |
|---|
| | | * @param range a #LinphoneRange @notnil |
|---|
| | | * @param max the value to set |
|---|
| | | * @ingroup misc |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_range_set_max(LinphoneRange *range, int max); |
|---|
| | | |
|---|
| | | /************ */ |
|---|
| | | /* DEPRECATED */ |
|---|
| | | /* ********** */ |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Return humain readable presence status |
|---|
| | | * @param status |
|---|
| | | * @deprecated 03/02/2017 Use #LinphonePresenceModel, #LinphonePresenceActivity and linphone_presence_activity_to_string() instead. |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED const char *linphone_online_status_to_string(LinphoneOnlineStatus status); |
|---|
| | | |
|---|
| | | |
|---|
| | | #ifdef __cplusplus |
|---|
| | | } |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Acquire a reference to the #LinphoneNatPolicy object. |
|---|
| | | * @param[in] policy #LinphoneNatPolicy object. |
|---|
| | | * @return The same #LinphoneNatPolicy object. |
|---|
| | | * @param policy #LinphoneNatPolicy object. @notnil |
|---|
| | | * @return The same #LinphoneNatPolicy object. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphoneNatPolicy * linphone_nat_policy_ref(LinphoneNatPolicy *policy); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Release reference to the #LinphoneNatPolicy object. |
|---|
| | | * @param[in] policy #LinphoneNatPolicy object. |
|---|
| | | * @param policy #LinphoneNatPolicy object. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_nat_policy_unref(LinphoneNatPolicy *policy); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Retrieve the user pointer associated with the #LinphoneNatPolicy object. |
|---|
| | | * @param[in] policy #LinphoneNatPolicy object. |
|---|
| | | * @return The user pointer associated with the #LinphoneNatPolicy object. |
|---|
| | | * @param policy #LinphoneNatPolicy object. @notnil |
|---|
| | | * @return The user pointer associated with the #LinphoneNatPolicy object. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void *linphone_nat_policy_get_user_data(const LinphoneNatPolicy *policy); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user pointer to the #LinphoneNatPolicy object. |
|---|
| | | * @param[in] policy #LinphoneNatPolicy object. |
|---|
| | | * @param[in] ud The user pointer to associate with the #LinphoneNatPolicy object. |
|---|
| | | * @param policy #LinphoneNatPolicy object. @notnil |
|---|
| | | * @param user_data The user pointer to associate with the #LinphoneNatPolicy object. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_nat_policy_set_user_data(LinphoneNatPolicy *policy, void *ud); |
|---|
| | | LINPHONE_PUBLIC void linphone_nat_policy_set_user_data(LinphoneNatPolicy *policy, void *user_data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Clear a NAT policy (deactivate all protocols and unset the STUN server). |
|---|
| | | * @param[in] policy #LinphoneNatPolicy object. |
|---|
| | | * @param policy #LinphoneNatPolicy object. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_nat_policy_clear(LinphoneNatPolicy *policy); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Tell whether STUN is enabled. |
|---|
| | | * @param[in] policy #LinphoneNatPolicy object |
|---|
| | | * @param policy #LinphoneNatPolicy object @notnil |
|---|
| | | * @return Boolean value telling whether STUN is enabled. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_nat_policy_stun_enabled(const LinphoneNatPolicy *policy); |
|---|
| | |
|---|
| | | /** |
|---|
| | | * Enable STUN. |
|---|
| | | * If TURN is also enabled, TURN will be used instead of STUN. |
|---|
| | | * @param[in] policy #LinphoneNatPolicy object |
|---|
| | | * @param[in] enable Boolean value telling whether to enable STUN. |
|---|
| | | * @param policy #LinphoneNatPolicy object @notnil |
|---|
| | | * @param enable Boolean value telling whether to enable STUN. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_nat_policy_enable_stun(LinphoneNatPolicy *policy, bool_t enable); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Tell whether TURN is enabled. |
|---|
| | | * @param[in] policy #LinphoneNatPolicy object |
|---|
| | | * @param policy #LinphoneNatPolicy object @notnil |
|---|
| | | * @return Boolean value telling whether TURN is enabled. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_nat_policy_turn_enabled(const LinphoneNatPolicy *policy); |
|---|
| | |
|---|
| | | /** |
|---|
| | | * Enable TURN. |
|---|
| | | * If STUN is also enabled, it is ignored and TURN is used. |
|---|
| | | * @param[in] policy #LinphoneNatPolicy object |
|---|
| | | * @param[in] enable Boolean value telling whether to enable TURN. |
|---|
| | | * @param policy #LinphoneNatPolicy object @notnil |
|---|
| | | * @param enable Boolean value telling whether to enable TURN. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_nat_policy_enable_turn(LinphoneNatPolicy *policy, bool_t enable); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Tell whether ICE is enabled. |
|---|
| | | * @param[in] policy #LinphoneNatPolicy object |
|---|
| | | * @param policy #LinphoneNatPolicy object @notnil |
|---|
| | | * @return Boolean value telling whether ICE is enabled. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_nat_policy_ice_enabled(const LinphoneNatPolicy *policy); |
|---|
| | |
|---|
| | | /** |
|---|
| | | * Enable ICE. |
|---|
| | | * ICE can be enabled without STUN/TURN, in which case only the local candidates will be used. |
|---|
| | | * @param[in] policy #LinphoneNatPolicy object |
|---|
| | | * @param[in] enable Boolean value telling whether to enable ICE. |
|---|
| | | * @param policy #LinphoneNatPolicy object @notnil |
|---|
| | | * @param enable Boolean value telling whether to enable ICE. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_nat_policy_enable_ice(LinphoneNatPolicy *policy, bool_t enable); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Tell whether uPnP is enabled. |
|---|
| | | * @param[in] policy #LinphoneNatPolicy object |
|---|
| | | * @param policy #LinphoneNatPolicy object @notnil |
|---|
| | | * @return Boolean value telling whether uPnP is enabled. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_nat_policy_upnp_enabled(const LinphoneNatPolicy *policy); |
|---|
| | |
|---|
| | | /** |
|---|
| | | * Enable uPnP. |
|---|
| | | * This has the effect to disable every other policies (ICE, STUN and TURN). |
|---|
| | | * @param[in] policy #LinphoneNatPolicy object |
|---|
| | | * @param[in] enable Boolean value telling whether to enable uPnP. |
|---|
| | | * @param policy #LinphoneNatPolicy object @notnil |
|---|
| | | * @param enable Boolean value telling whether to enable uPnP. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_nat_policy_enable_upnp(LinphoneNatPolicy *policy, bool_t enable); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the STUN/TURN server to use with this NAT policy. |
|---|
| | | * Used when STUN or TURN are enabled. |
|---|
| | | * @param[in] policy #LinphoneNatPolicy object |
|---|
| | | * @return The STUN server used by this NAT policy. |
|---|
| | | * @param policy #LinphoneNatPolicy object @notnil |
|---|
| | | * @return The STUN server used by this NAT policy. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_nat_policy_get_stun_server(const LinphoneNatPolicy *policy); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the STUN/TURN server to use with this NAT policy. |
|---|
| | | * Used when STUN or TURN are enabled. |
|---|
| | | * @param[in] policy #LinphoneNatPolicy object |
|---|
| | | * @param[in] stun_server The STUN server to use with this NAT policy. |
|---|
| | | * @param policy #LinphoneNatPolicy object @notnil |
|---|
| | | * @param stun_server The STUN server to use with this NAT policy. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_nat_policy_set_stun_server(LinphoneNatPolicy *policy, const char *stun_server); |
|---|
| | | |
|---|
| | |
|---|
| | | * Get the username used to authenticate with the STUN/TURN server. |
|---|
| | | * The authentication will search for a #LinphoneAuthInfo with this username. |
|---|
| | | * If it is not set the username of the currently used #LinphoneProxyConfig is used to search for a LinphoneAuthInfo. |
|---|
| | | * @param[in] policy #LinphoneNatPolicy object |
|---|
| | | * @return The username used to authenticate with the STUN/TURN server. |
|---|
| | | * @param policy #LinphoneNatPolicy object @notnil |
|---|
| | | * @return The username used to authenticate with the STUN/TURN server. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_nat_policy_get_stun_server_username(const LinphoneNatPolicy *policy); |
|---|
| | | |
|---|
| | |
|---|
| | | * Set the username used to authenticate with the STUN/TURN server. |
|---|
| | | * The authentication will search for a #LinphoneAuthInfo with this username. |
|---|
| | | * If it is not set the username of the currently used #LinphoneProxyConfig is used to search for a LinphoneAuthInfo. |
|---|
| | | * @param[in] policy #LinphoneNatPolicy object |
|---|
| | | * @param[in] username The username used to authenticate with the STUN/TURN server. |
|---|
| | | * @param policy #LinphoneNatPolicy object @notnil |
|---|
| | | * @param username The username used to authenticate with the STUN/TURN server. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_nat_policy_set_stun_server_username(LinphoneNatPolicy *policy, const char *username); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Start a STUN server DNS resolution. |
|---|
| | | * @param[in] policy #LinphoneNatPolicy object |
|---|
| | | * @param policy #LinphoneNatPolicy object @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_nat_policy_resolve_stun_server(LinphoneNatPolicy *policy); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the addrinfo representation of the STUN server address. |
|---|
| | | * WARNING: This function may block for up to 1 second. |
|---|
| | | * @param[in] policy #LinphoneNatPolicy object |
|---|
| | | * @param policy #LinphoneNatPolicy object @notnil |
|---|
| | | * @return addrinfo representation of the STUN server address. |
|---|
| | | * @donotwrap |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const struct addrinfo * linphone_nat_policy_get_stun_server_addrinfo(LinphoneNatPolicy *policy); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Enable UDP TURN transport. |
|---|
| | | * Used when TURN is enabled. |
|---|
| | | * @param policy #LinphoneNatPolicy object @notnil |
|---|
| | | * @param enable Boolean value telling whether to enable UDP TURN transport. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_nat_policy_enable_udp_turn_transport(LinphoneNatPolicy *policy, bool_t enable); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Tells whether UDP TURN transport is enabled. |
|---|
| | | * Used when TURN is enabled. |
|---|
| | | * @param policy #LinphoneNatPolicy object @notnil |
|---|
| | | * @return Boolean value telling whether UDP TURN transport is enabled. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_nat_policy_udp_turn_transport_enabled(LinphoneNatPolicy *policy); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Enable TCP TURN transport. |
|---|
| | | * Used when TURN is enabled. |
|---|
| | | * @param policy #LinphoneNatPolicy object @notnil |
|---|
| | | * @param enable Boolean value telling whether to enable TCP TURN transport. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_nat_policy_enable_tcp_turn_transport(LinphoneNatPolicy *policy, bool_t enable); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Tells whether TCP TURN transport is enabled. |
|---|
| | | * Used when TURN is enabled. |
|---|
| | | * @param policy #LinphoneNatPolicy object @notnil |
|---|
| | | * @return Boolean value telling whether TCP TURN transport is enabled. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_nat_policy_tcp_turn_transport_enabled(LinphoneNatPolicy *policy); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Enable TLS TURN transport. |
|---|
| | | * Used when TURN is enabled. |
|---|
| | | * @param policy #LinphoneNatPolicy object @notnil |
|---|
| | | * @param enable Boolean value telling whether to enable TLS TURN transport. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_nat_policy_enable_tls_turn_transport(LinphoneNatPolicy *policy, bool_t enable); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Tells whether TLS TURN transport is enabled. |
|---|
| | | * Used when TURN is enabled. |
|---|
| | | * @param policy #LinphoneNatPolicy object @notnil |
|---|
| | | * @return Boolean value telling whether TLS TURN transport is enabled. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_nat_policy_tls_turn_transport_enabled(LinphoneNatPolicy *policy); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the #LinphoneCore object managing this nat policy, if any. |
|---|
| | | * @param[in] fr #LinphoneNatPolicy object |
|---|
| | | * @param policy #LinphoneNatPolicy object @notnil |
|---|
| | | * @return the #LinphoneCore object associated. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneCore *linphone_nat_policy_get_core(const LinphoneNatPolicy *policy); |
|---|
| | | |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | #endif |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Take a reference on a #LinphonePayloadType. |
|---|
| | | * Instantiates a new payload type with values from source. |
|---|
| | | * @param[in] source The #LinphonePayloadType object to be cloned. @notnil |
|---|
| | | * @return The newly created #LinphonePayloadType object. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphonePayloadType *linphone_payload_type_ref(LinphonePayloadType *pt); |
|---|
| | | LINPHONE_PUBLIC LinphonePayloadType *linphone_payload_type_clone(const LinphonePayloadType *orig); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Take a reference on a #LinphonePayloadType. |
|---|
| | | * @param payload_type the #LinphonePayloadType object @notnil |
|---|
| | | * @return the same #LinphonePayloadType object @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphonePayloadType *linphone_payload_type_ref(LinphonePayloadType *payload_type); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Release a reference on a #LinphonePayloadType. |
|---|
| | | * @param payload_type the #LinphonePayloadType object @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_payload_type_unref(LinphonePayloadType *pt); |
|---|
| | | LINPHONE_PUBLIC void linphone_payload_type_unref(LinphonePayloadType *payload_type); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the type of a payload type. |
|---|
| | | * @param[in] pt The payload type. |
|---|
| | | * @param payload_type The payload type. @notnil |
|---|
| | | * @return The type of the payload e.g. PAYLOAD_AUDIO_CONTINUOUS or PAYLOAD_VIDEO. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC int linphone_payload_type_get_type(const LinphonePayloadType *pt); |
|---|
| | | LINPHONE_PUBLIC int linphone_payload_type_get_type(const LinphonePayloadType *payload_type); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Enable/disable a payload type. |
|---|
| | | * @param[in] pt The payload type to enable/disable. |
|---|
| | | * @param[in] enabled Set TRUE for enabling and FALSE for disabling. |
|---|
| | | * @param payload_type The payload type to enable/disable. @notnil |
|---|
| | | * @param enabled Set TRUE for enabling and FALSE for disabling. |
|---|
| | | * @return 0 for success, -1 for failure. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC int linphone_payload_type_enable(LinphonePayloadType *pt, bool_t enabled); |
|---|
| | | LINPHONE_PUBLIC int linphone_payload_type_enable(LinphonePayloadType *payload_type, bool_t enabled); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Check whether a palyoad type is enabled. |
|---|
| | | * @param payload_type the #LinphonePayloadType object @notnil |
|---|
| | | * @return TRUE if enabled, FALSE if disabled. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_payload_type_enabled(const LinphonePayloadType *pt); |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_payload_type_enabled(const LinphonePayloadType *payload_type); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Return a string describing a payload type. The format of the string is |
|---|
| | | * <mime_type>/<clock_rate>/<channels>. |
|---|
| | | * @param[in] pt The payload type. |
|---|
| | | * @return The description of the payload type. Must be release after use. |
|---|
| | | * @param payload_type the #LinphonePayloadType object @notnil |
|---|
| | | * @return The description of the payload type. Must be release after use. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC char *linphone_payload_type_get_description(const LinphonePayloadType *pt); |
|---|
| | | LINPHONE_PUBLIC char *linphone_payload_type_get_description(const LinphonePayloadType *payload_type); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get a description of the encoder used to provide a payload type. |
|---|
| | | * @param[in] pt The payload type. |
|---|
| | | * @return The description of the encoder. Can be NULL if the payload type is not supported by Mediastreamer2. |
|---|
| | | * @param payload_type the #LinphonePayloadType object @notnil |
|---|
| | | * @return The description of the encoder. Can be NULL if the payload type is not supported by Mediastreamer2. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_payload_type_get_encoder_description(const LinphonePayloadType *pt); |
|---|
| | | LINPHONE_PUBLIC const char *linphone_payload_type_get_encoder_description(const LinphonePayloadType *payload_type); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the normal bitrate in bits/s. |
|---|
| | | * @param[in] pt The payload type. |
|---|
| | | * @param payload_type the #LinphonePayloadType object @notnil |
|---|
| | | * @return The normal bitrate in bits/s or -1 if an error has occured. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC int linphone_payload_type_get_normal_bitrate(const LinphonePayloadType *pt); |
|---|
| | | LINPHONE_PUBLIC int linphone_payload_type_get_normal_bitrate(const LinphonePayloadType *payload_type); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Change the normal bitrate of a payload type.. |
|---|
| | | * @param[in] pt The payload type to change. |
|---|
| | | * @param[in] bitrate The new bitrate in bits/s. |
|---|
| | | * @param payload_type the #LinphonePayloadType object @notnil |
|---|
| | | * @param bitrate The new bitrate in kbits/s. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_payload_type_set_normal_bitrate(LinphonePayloadType *pt, int bitrate); |
|---|
| | | LINPHONE_PUBLIC void linphone_payload_type_set_normal_bitrate(LinphonePayloadType *payload_type, int bitrate); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the mime type. |
|---|
| | | * @param[in] pt The payload type. |
|---|
| | | * @return The mime type. |
|---|
| | | * @param payload_type the #LinphonePayloadType object @notnil |
|---|
| | | * @return The mime type. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_payload_type_get_mime_type(const LinphonePayloadType *pt); |
|---|
| | | LINPHONE_PUBLIC const char * linphone_payload_type_get_mime_type(const LinphonePayloadType *payload_type); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the number of channels. |
|---|
| | | * @param[in] pt The payload type. |
|---|
| | | * @param payload_type the #LinphonePayloadType object @notnil |
|---|
| | | * @return The number of channels. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC int linphone_payload_type_get_channels(const LinphonePayloadType *pt); |
|---|
| | | LINPHONE_PUBLIC int linphone_payload_type_get_channels(const LinphonePayloadType *payload_type); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the payload type number assigned for this codec. |
|---|
| | | * @param[in] pt The payload type. |
|---|
| | | * @param payload_type the #LinphonePayloadType object @notnil |
|---|
| | | * @return The number of the payload type. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC int linphone_payload_type_get_number(const LinphonePayloadType *pt); |
|---|
| | | LINPHONE_PUBLIC int linphone_payload_type_get_number(const LinphonePayloadType *payload_type); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Force a number for a payload type. The #LinphoneCore does payload type number assignment automatically. |
|---|
| | | * This function is mainly to be used for tests, in order to override the automatic assignment mechanism. |
|---|
| | | * @param[in] pt The payload type. |
|---|
| | | * @param[in] number The number to assign to the payload type. |
|---|
| | | * @param payload_type the #LinphonePayloadType object @notnil |
|---|
| | | * @param number The number to assign to the payload type. |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_payload_type_set_number(LinphonePayloadType *pt, int number); |
|---|
| | | LINPHONE_PUBLIC void linphone_payload_type_set_number(LinphonePayloadType *payload_type, int number); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the format parameters for incoming streams. |
|---|
| | | * @param[in] pt The payload type. |
|---|
| | | * @return The format parameters as string. |
|---|
| | | * @param payload_type the #LinphonePayloadType object @notnil |
|---|
| | | * @return The format parameters as string. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_payload_type_get_recv_fmtp(const LinphonePayloadType *pt); |
|---|
| | | LINPHONE_PUBLIC const char *linphone_payload_type_get_recv_fmtp(const LinphonePayloadType *payload_type); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the format parameters for incoming streams. |
|---|
| | | * @param[in] pt The payload type. |
|---|
| | | * @param[in] recv_fmtp The new format parameters as string. The string will be copied. |
|---|
| | | * @param payload_type the #LinphonePayloadType object @notnil |
|---|
| | | * @param recv_fmtp The new format parameters as string. The string will be copied. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_payload_type_set_recv_fmtp(LinphonePayloadType *pt, const char *recv_fmtp); |
|---|
| | | LINPHONE_PUBLIC void linphone_payload_type_set_recv_fmtp(LinphonePayloadType *payload_type, const char *recv_fmtp); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the format parameters for outgoing streams. |
|---|
| | | * @param[in] pt The payload type. |
|---|
| | | * @return The format parameters as string. |
|---|
| | | * @param payload_type the #LinphonePayloadType object @notnil |
|---|
| | | * @return The format parameters as string. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char *linphone_payload_type_get_send_fmtp(const LinphonePayloadType *pt); |
|---|
| | | LINPHONE_PUBLIC const char *linphone_payload_type_get_send_fmtp(const LinphonePayloadType *payload_type); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the format parameters for outgoing streams. |
|---|
| | | * @param[in] pt The payload type. |
|---|
| | | * @param[in] send_fmtp The new format parameters as string. The string will be copied. |
|---|
| | | * @param payload_type the #LinphonePayloadType object @notnil |
|---|
| | | * @param send_fmtp The new format parameters as string. The string will be copied. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_payload_type_set_send_fmtp(LinphonePayloadType *pt, const char *send_fmtp); |
|---|
| | | LINPHONE_PUBLIC void linphone_payload_type_set_send_fmtp(LinphonePayloadType *payload_type, const char *send_fmtp); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the clock rate of a payload type. |
|---|
| | | * @param[in] pt The payload type. |
|---|
| | | * @return[in] The clock rate in Hz. |
|---|
| | | * @param payload_type the #LinphonePayloadType object @notnil |
|---|
| | | * @return The clock rate in Hz. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC int linphone_payload_type_get_clock_rate(const LinphonePayloadType *pt); |
|---|
| | | LINPHONE_PUBLIC int linphone_payload_type_get_clock_rate(const LinphonePayloadType *payload_type); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Tells whether the specified payload type represents a variable bitrate codec. |
|---|
| | | * @param[in] pt The payload type. |
|---|
| | | * @param payload_type the #LinphonePayloadType object @notnil |
|---|
| | | * @return TRUE if the payload type represents a VBR codec, FALSE instead. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_payload_type_is_vbr(const LinphonePayloadType *pt); |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_payload_type_is_vbr(const LinphonePayloadType *payload_type); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Check whether the payload is usable according the bandwidth targets set in the core. |
|---|
| | | * @param[in] pt The payload type to test. |
|---|
| | | * @param payload_type the #LinphonePayloadType object @notnil |
|---|
| | | * @return TRUE if the payload type is usable. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_payload_type_is_usable(const LinphonePayloadType *pt); |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_payload_type_is_usable(const LinphonePayloadType *payload_type); |
|---|
| | | |
|---|
| | | |
|---|
| | | #ifdef __cplusplus |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Acquire a reference to the player. |
|---|
| | | * @param[in] player #LinphonePlayer object. |
|---|
| | | * @return The same #LinphonePlayer object. |
|---|
| | | * @param player #LinphonePlayer object. @notnil |
|---|
| | | * @return The same #LinphonePlayer object. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC LinphonePlayer * linphone_player_ref(LinphonePlayer *player); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Release reference to the player. |
|---|
| | | * @param[in] player #LinphonePlayer object. |
|---|
| | | * @param player #LinphonePlayer object. @notnil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_player_unref(LinphonePlayer *player); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Retrieve the user pointer associated with the player. |
|---|
| | | * @param[in] player #LinphonePlayer object. |
|---|
| | | * @return The user pointer associated with the player. |
|---|
| | | * @param player #LinphonePlayer object. @notnil |
|---|
| | | * @return The user pointer associated with the player. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void *linphone_player_get_user_data(const LinphonePlayer *player); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user pointer to the player. |
|---|
| | | * @param[in] player #LinphonePlayer object. |
|---|
| | | * @param[in] ud The user pointer to associate with the player. |
|---|
| | | * @param player #LinphonePlayer object. @notnil |
|---|
| | | * @param user_data The user pointer to associate with the player. @maybenil |
|---|
| | | **/ |
|---|
| | | LINPHONE_PUBLIC void linphone_player_set_user_data(LinphonePlayer *player, void *ud); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the #LinphonePlayerCbs object associated with the LinphonePlayer. |
|---|
| | | * @param[in] player #LinphonePlayer object |
|---|
| | | * @return The #LinphonePlayerCbs object associated with the LinphonePlayer. |
|---|
| | | * @deprecated use add_callbacks / remove_callbacks instead |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphonePlayerCbs * linphone_player_get_callbacks(const LinphonePlayer *player); |
|---|
| | | LINPHONE_PUBLIC void linphone_player_set_user_data(LinphonePlayer *player, void *user_data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Adds a #LinphonePlayerCbs object associated to the LinphonePlayer. |
|---|
| | | * @param[in] player #LinphonePlayer object |
|---|
| | | * @param[in] cbs The #LinphonePlayerCbs object to be added to the LinphonePlayer. |
|---|
| | | * @param player #LinphonePlayer object @notnil |
|---|
| | | * @param cbs The #LinphonePlayerCbs object to be added to the LinphonePlayer. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_player_add_callbacks(LinphonePlayer *player, LinphonePlayerCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Removes a #LinphonePlayerCbs object associated to the LinphonePlayer. |
|---|
| | | * @param[in] player #LinphonePlayer object |
|---|
| | | * @param[in] cbs The #LinphonePlayerCbs object to be removed from the LinphonePlayer. |
|---|
| | | * @param player #LinphonePlayer object @notnil |
|---|
| | | * @param cbs The #LinphonePlayerCbs object to be removed from the LinphonePlayer. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_player_remove_callbacks(LinphonePlayer *player, LinphonePlayerCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the current LinphonePlayerCbsCbs object |
|---|
| | | * @param[in] player #LinphonePlayer object |
|---|
| | | * @return The current #LinphonePlayerCbs object |
|---|
| | | * @param player #LinphonePlayer object @notnil |
|---|
| | | * @return The current #LinphonePlayerCbs object @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphonePlayerCbs *linphone_player_get_current_callbacks(const LinphonePlayer *player); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Open a file for playing. |
|---|
| | | * @param[in] obj #LinphonePlayer object |
|---|
| | | * @param[in] filename The path to the file to open |
|---|
| | | * @param player #LinphonePlayer object @notnil |
|---|
| | | * @param filename The path to the file to open @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_player_open(LinphonePlayer *obj, const char *filename); |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_player_open(LinphonePlayer *player, const char *filename); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Start playing a file that has been opened with linphone_player_open(). |
|---|
| | | * @param[in] obj #LinphonePlayer object |
|---|
| | | * @param player #LinphonePlayer object @notnil |
|---|
| | | * @return 0 on success, a negative value otherwise |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_player_start(LinphonePlayer *obj); |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_player_start(LinphonePlayer *player); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Pause the playing of a file. |
|---|
| | | * @param[in] obj #LinphonePlayer object |
|---|
| | | * @param player #LinphonePlayer object @notnil |
|---|
| | | * @return 0 on success, a negative value otherwise |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_player_pause(LinphonePlayer *obj); |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_player_pause(LinphonePlayer *player); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Seek in an opened file. |
|---|
| | | * @param[in] obj #LinphonePlayer object |
|---|
| | | * @param[in] time_ms The time we want to go to in the file (in milliseconds). |
|---|
| | | * @param player #LinphonePlayer object @notnil |
|---|
| | | * @param time_ms The time we want to go to in the file (in milliseconds). |
|---|
| | | * @return 0 on success, a negative value otherwise. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_player_seek(LinphonePlayer *obj, int time_ms); |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_player_seek(LinphonePlayer *player, int time_ms); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the current state of a player. |
|---|
| | | * @param[in] obj #LinphonePlayer object |
|---|
| | | * @return The current state of the player. |
|---|
| | | * @param player #LinphonePlayer object @notnil |
|---|
| | | * @return The current #LinphonePlayerState of the player. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphonePlayerState linphone_player_get_state(LinphonePlayer *obj); |
|---|
| | | LINPHONE_PUBLIC LinphonePlayerState linphone_player_get_state(LinphonePlayer *player); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the duration of the opened file. |
|---|
| | | * @param[in] obj #LinphonePlayer object |
|---|
| | | * @param player #LinphonePlayer object @notnil |
|---|
| | | * @return The duration of the opened file |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC int linphone_player_get_duration(LinphonePlayer *obj); |
|---|
| | | LINPHONE_PUBLIC int linphone_player_get_duration(LinphonePlayer *player); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the current position in the opened file. |
|---|
| | | * @param[in] obj #LinphonePlayer object |
|---|
| | | * @param player #LinphonePlayer object @notnil |
|---|
| | | * @return The current position in the opened file |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC int linphone_player_get_current_position(LinphonePlayer *obj); |
|---|
| | | LINPHONE_PUBLIC int linphone_player_get_current_position(LinphonePlayer *player); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Close the opened file. |
|---|
| | | * @param[in] obj #LinphonePlayer object |
|---|
| | | * @param player #LinphonePlayer object @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_player_close(LinphonePlayer *obj); |
|---|
| | | LINPHONE_PUBLIC void linphone_player_close(LinphonePlayer *player); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets a window id to be used to display video if any. |
|---|
| | | * @param player #LinphonePlayer object @notnil |
|---|
| | | * @param window_id The window id pointer to use. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_player_set_window_id(LinphonePlayer *player, void *window_id); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns whether the file has video and if it can be displayed |
|---|
| | | * @param player #LinphonePlayer object @notnil |
|---|
| | | * @return TRUE if file has video and it can be displayed, FALSE otherwise |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_player_get_is_video_available(LinphonePlayer *player); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the #LinphoneCore object managing this player's call, if any. |
|---|
| | | * @param[in] fr #LinphonePlayer object |
|---|
| | | * @param player #LinphonePlayer object @notnil |
|---|
| | | * @return the #LinphoneCore object associated @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneCore *linphone_player_get_core(const LinphonePlayer *player); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Acquire a reference to the #LinphonePlayerCbs object. |
|---|
| | | * @param[in] cbs #LinphonePlayerCbs object. |
|---|
| | | * @return The same #LinphonePlayerCbs object. |
|---|
| | | * @param cbs #LinphonePlayerCbs object. @notnil |
|---|
| | | * @return The same #LinphonePlayerCbs object. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphonePlayerCbs * linphone_player_cbs_ref(LinphonePlayerCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Release reference to the #LinphonePlayerCbs object. |
|---|
| | | * @param[in] cbs #LinphonePlayerCbs object. |
|---|
| | | * @param cbs #LinphonePlayerCbs object. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_player_cbs_unref(LinphonePlayerCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Retrieve the user pointer associated with the #LinphonePlayerCbs object. |
|---|
| | | * @param[in] cbs #LinphonePlayerCbs object. |
|---|
| | | * @return The user pointer associated with the #LinphonePlayerCbs object. |
|---|
| | | * @param cbs #LinphonePlayerCbs object. @notnil |
|---|
| | | * @return The user pointer associated with the #LinphonePlayerCbs object. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void *linphone_player_cbs_get_user_data(const LinphonePlayerCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Assign a user pointer to the #LinphonePlayerCbs object. |
|---|
| | | * @param[in] cbs #LinphonePlayerCbs object. |
|---|
| | | * @param[in] ud The user pointer to associate with the #LinphonePlayerCbs object. |
|---|
| | | * @param cbs #LinphonePlayerCbs object. @notnil |
|---|
| | | * @param user_data The user pointer to associate with the #LinphonePlayerCbs object. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_player_cbs_set_user_data(LinphonePlayerCbs *cbs, void *ud); |
|---|
| | | LINPHONE_PUBLIC void linphone_player_cbs_set_user_data(LinphonePlayerCbs *cbs, void *user_data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the end-of-file reached callback. |
|---|
| | | * @param[in] cbs #LinphonePlayerCbs object. |
|---|
| | | * @param cbs #LinphonePlayerCbs object. @notnil |
|---|
| | | * @return The current end-of-file reached callback. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphonePlayerCbsEofReachedCb linphone_player_cbs_get_eof_reached(const LinphonePlayerCbs *cbs); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Set the end-of-file reached callback. |
|---|
| | | * @param[in] cbs #LinphonePlayerCbs object. |
|---|
| | | * @param[in] cb The end-of-file reached callback to be used. |
|---|
| | | * @param cbs #LinphonePlayerCbs object. @notnil |
|---|
| | | * @param cb The end-of-file reached callback to be used. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_player_cbs_set_eof_reached(LinphonePlayerCbs *cbs, LinphonePlayerCbsEofReachedCb cb); |
|---|
| | | |
|---|
| | | /************ */ |
|---|
| | | /* DEPRECATED */ |
|---|
| | | /* ********** */ |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the #LinphonePlayerCbs object associated with the LinphonePlayer. |
|---|
| | | * @param player #LinphonePlayer object @notnil |
|---|
| | | * @return The #LinphonePlayerCbs object associated with the LinphonePlayer. |
|---|
| | | * @deprecated 19/02/2019 use add_callbacks / remove_callbacks instead @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LINPHONE_DEPRECATED LinphonePlayerCbs * linphone_player_get_callbacks(const LinphonePlayer *player); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * @} |
|---|
| | | **/ |
|---|
old mode 100644
new mode 100755
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates a presence model specifying an activity. |
|---|
| | | * @param[in] activity The activity to set for the created presence model. |
|---|
| | | * @param[in] description An additional description of the activity (mainly useful for the 'other' activity). Set it to NULL to not add a description. |
|---|
| | | * @return The created presence model, or NULL if an error occured. |
|---|
| | | * @see linphone_presence_model_new |
|---|
| | | * @see linphone_presence_model_new_with_activity_and_note |
|---|
| | | * @param activity The #LinphonePresenceActivityType to set for the created presence model. |
|---|
| | | * @param description An additional description of the activity (mainly useful for the 'other' activity). Set it to NULL to not add a description. @maybenil |
|---|
| | | * @return The created #LinphonePresenceModel, or NULL if an error occured. @maybenil |
|---|
| | | * @see linphone_presence_model_new(), linphone_presence_model_new_with_activity_and_note() |
|---|
| | | * |
|---|
| | | * The created presence model has the activity specified in the parameters. |
|---|
| | | */ |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates a presence model specifying an activity and adding a note. |
|---|
| | | * @param[in] activity The activity to set for the created presence model. |
|---|
| | | * @param[in] description An additional description of the activity (mainly useful for the 'other' activity). Set it to NULL to not add a description. |
|---|
| | | * @param[in] note An additional note giving additional information about the contact presence. |
|---|
| | | * @param[in] lang The language the note is written in. It can be set to NULL in order to not specify the language of the note. |
|---|
| | | * @return The created presence model, or NULL if an error occured. |
|---|
| | | * @see linphone_presence_model_new_with_activity |
|---|
| | | * @see linphone_presence_model_new_with_activity_and_note |
|---|
| | | * @param activity The #LinphonePresenceActivityType to set for the created presence model. |
|---|
| | | * @param description An additional description of the activity (mainly useful for the 'other' activity). Set it to NULL to not add a description. @maybenil |
|---|
| | | * @param note An additional note giving additional information about the contact presence. @notnil |
|---|
| | | * @param lang The language the note is written in. It can be set to NULL in order to not specify the language of the note. @maybenil |
|---|
| | | * @return The created #LinphonePresenceModel, or NULL if an error occured. @maybenil |
|---|
| | | * @see linphone_presence_model_new_with_activity(), linphone_presence_model_new_with_activity_and_note() |
|---|
| | | * |
|---|
| | | * The created presence model has the activity and the note specified in the parameters. |
|---|
| | | */ |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the basic status of a presence model. |
|---|
| | | * @param[in] model The #LinphonePresenceModel object to get the basic status from. |
|---|
| | | * @param model The #LinphonePresenceModel object to get the basic status from. @notnil |
|---|
| | | * @return The #LinphonePresenceBasicStatus of the #LinphonePresenceModel object given as parameter. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphonePresenceBasicStatus linphone_presence_model_get_basic_status(const LinphonePresenceModel *model); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the basic status of a presence model. |
|---|
| | | * @param[in] model The #LinphonePresenceModel object for which to set the basic status. |
|---|
| | | * @param[in] basic_status The #LinphonePresenceBasicStatus to set for the #LinphonePresenceModel object. |
|---|
| | | * @param model The #LinphonePresenceModel object for which to set the basic status. @notnil |
|---|
| | | * @param basic_status The #LinphonePresenceBasicStatus to set for the #LinphonePresenceModel object. |
|---|
| | | * @return 0 if successful, a value < 0 in case of error. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_presence_model_set_basic_status(LinphonePresenceModel *model, LinphonePresenceBasicStatus basic_status); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the timestamp of a presence model. |
|---|
| | | * @param[in] model The #LinphonePresenceModel object to get the timestamp from. |
|---|
| | | * @param model The #LinphonePresenceModel object to get the timestamp from. @notnil |
|---|
| | | * @return The timestamp of the #LinphonePresenceModel object or -1 on error. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC time_t linphone_presence_model_get_timestamp(const LinphonePresenceModel *model); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the contact of a presence model. |
|---|
| | | * @param[in] model The #LinphonePresenceModel object to get the contact from. |
|---|
| | | * @return A pointer to a dynamically allocated string containing the contact, or NULL if no contact is found. |
|---|
| | | * @param model The #LinphonePresenceModel object to get the contact from. @notnil |
|---|
| | | * @return A pointer to a dynamically allocated string containing the contact, or NULL if no contact is found. @maybenil |
|---|
| | | * |
|---|
| | | * The returned string is to be freed by calling ms_free(). |
|---|
| | | */ |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the contact of a presence model. |
|---|
| | | * @param[in] model The #LinphonePresenceModel object for which to set the contact. |
|---|
| | | * @param[in] contact The contact string to set. |
|---|
| | | * @param model The #LinphonePresenceModel object for which to set the contact. @notnil |
|---|
| | | * @param contact The contact string to set. @maybenil |
|---|
| | | * @return 0 if successful, a value < 0 in case of error. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_presence_model_set_contact(LinphonePresenceModel *model, const char *contact); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the presentity of a presence model. |
|---|
| | | * @param[in] model The #LinphonePresenceModel object for which to set the contact. |
|---|
| | | * @param[in] presentity The presentity address to set (presentity is copied). |
|---|
| | | * @param model The #LinphonePresenceModel object for which to set the contact. @notnil |
|---|
| | | * @param presentity The presentity address to set (presentity is copied). @maybenil |
|---|
| | | * @return 0 if successful, a value < 0 in case of error. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_presence_model_set_presentity(LinphonePresenceModel *model, const LinphoneAddress *presentity); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the presentity of a presence model. |
|---|
| | | * @param[in] model The #LinphonePresenceModel object to get the contact from. |
|---|
| | | * @return A pointer to a const LinphoneAddress, or NULL if no contact is found. |
|---|
| | | * |
|---|
| | | * @param model The #LinphonePresenceModel object to get the contact from. @notnil |
|---|
| | | * @return A pointer to a const #LinphoneAddress, or NULL if no contact is found. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const LinphoneAddress * linphone_presence_model_get_presentity(const LinphonePresenceModel *model); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the first activity of a presence model (there is usually only one). |
|---|
| | | * @param[in] model The #LinphonePresenceModel object to get the activity from. |
|---|
| | | * @return A #LinphonePresenceActivity object if successful, NULL otherwise. |
|---|
| | | * @param model The #LinphonePresenceModel object to get the activity from. @notnil |
|---|
| | | * @return A #LinphonePresenceActivity object if successful, NULL otherwise. @maybenil @tobefreed |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphonePresenceActivity * linphone_presence_model_get_activity(const LinphonePresenceModel *model); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the activity of a presence model (limits to only one activity). |
|---|
| | | * @param[in] model The #LinphonePresenceModel object for which to set the activity. |
|---|
| | | * @param[in] activity The #LinphonePresenceActivityType to set for the model. |
|---|
| | | * @param[in] description An additional description of the activity to set for the model. Can be NULL if no additional description is to be added. |
|---|
| | | * @param model The #LinphonePresenceModel object for which to set the activity. @notnil |
|---|
| | | * @param activity The #LinphonePresenceActivityType to set for the model. |
|---|
| | | * @param description An additional description of the activity to set for the model. Can be NULL if no additional description is to be added. @maybenil |
|---|
| | | * @return 0 if successful, a value < 0 in case of error. |
|---|
| | | * |
|---|
| | | * WARNING: This function will modify the basic status of the model according to the activity being set. |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the number of activities included in the presence model. |
|---|
| | | * @param[in] model The #LinphonePresenceModel object to get the number of activities from. |
|---|
| | | * @param model The #LinphonePresenceModel object to get the number of activities from. @notnil |
|---|
| | | * @return The number of activities included in the #LinphonePresenceModel object. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC unsigned int linphone_presence_model_get_nb_activities(const LinphonePresenceModel *model); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the nth activity of a presence model. |
|---|
| | | * @param[in] model The #LinphonePresenceModel object to get the activity from. |
|---|
| | | * @param[in] idx The index of the activity to get (the first activity having the index 0). |
|---|
| | | * @return A pointer to a #LinphonePresenceActivity object if successful, NULL otherwise. |
|---|
| | | * @param model The #LinphonePresenceModel object to get the activity from. @notnil |
|---|
| | | * @param index The index of the activity to get (the first activity having the index 0). |
|---|
| | | * @return A pointer to a #LinphonePresenceActivity object if successful, NULL otherwise. @maybenil @tobefreed |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphonePresenceActivity * linphone_presence_model_get_nth_activity(const LinphonePresenceModel *model, unsigned int idx); |
|---|
| | | LINPHONE_PUBLIC LinphonePresenceActivity * linphone_presence_model_get_nth_activity(const LinphonePresenceModel *model, unsigned int index); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Adds an activity to a presence model. |
|---|
| | | * @param[in] model The #LinphonePresenceModel object for which to add an activity. |
|---|
| | | * @param[in] activity The #LinphonePresenceActivity object to add to the model. |
|---|
| | | * @param model The #LinphonePresenceModel object for which to add an activity. @notnil |
|---|
| | | * @param activity The #LinphonePresenceActivity object to add to the model. @notnil |
|---|
| | | * @return 0 if successful, a value < 0 in case of error. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_presence_model_add_activity(LinphonePresenceModel *model, LinphonePresenceActivity *activity); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Clears the activities of a presence model. |
|---|
| | | * @param[in] model The #LinphonePresenceModel object for which to clear the activities. |
|---|
| | | * @param model The #LinphonePresenceModel object for which to clear the activities. @notnil |
|---|
| | | * @return 0 if successful, a value < 0 in case of error. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_presence_model_clear_activities(LinphonePresenceModel *model); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the first note of a presence model (there is usually only one). |
|---|
| | | * @param[in] model The #LinphonePresenceModel object to get the note from. |
|---|
| | | * @param[in] lang The language of the note to get. Can be NULL to get a note that has no language specified or to get the first note whatever language it is written into. |
|---|
| | | * @return A pointer to a #LinphonePresenceNote object if successful, NULL otherwise. |
|---|
| | | * @param model The #LinphonePresenceModel object to get the note from. @notnil |
|---|
| | | * @param lang The language of the note to get. Can be NULL to get a note that has no language specified or to get the first note whatever language it is written into. @maybenil |
|---|
| | | * @return A pointer to a #LinphonePresenceNote object if successful, NULL otherwise. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphonePresenceNote * linphone_presence_model_get_note(const LinphonePresenceModel *model, const char *lang); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Adds a note to a presence model. |
|---|
| | | * @param[in] model The #LinphonePresenceModel object to add a note to. |
|---|
| | | * @param[in] note_content The note to be added to the presence model. |
|---|
| | | * @param[in] lang The language of the note to be added. Can be NULL if no language is to be specified for the note. |
|---|
| | | * @param model The #LinphonePresenceModel object to add a note to. @notnil |
|---|
| | | * @param note_content The note to be added to the presence model. @notnil |
|---|
| | | * @param lang The language of the note to be added. Can be NULL if no language is to be specified for the note. @maybenil |
|---|
| | | * @return 0 if successful, a value < 0 in case of error. |
|---|
| | | * |
|---|
| | | * Only one note for each language can be set, so e.g. setting a note for the 'fr' language if there is only one will replace the existing one. |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Clears all the notes of a presence model. |
|---|
| | | * @param[in] model The #LinphonePresenceModel for which to clear notes. |
|---|
| | | * @param model The #LinphonePresenceModel for which to clear notes. @notnil |
|---|
| | | * @return 0 if successful, a value < 0 in case of error. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_presence_model_clear_notes(LinphonePresenceModel *model); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Get the consolidated presence from a presence model. |
|---|
| | | * @param[in] model #LinphonePresenceModel object |
|---|
| | | * @param model #LinphonePresenceModel object @notnil |
|---|
| | | * @return The #LinphoneConsolidatedPresence corresponding to the presence model |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneConsolidatedPresence linphone_presence_model_get_consolidated_presence(const LinphonePresenceModel *model); |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates a default presence model. |
|---|
| | | * @return The created presence model, NULL on error. |
|---|
| | | * @see linphone_presence_model_new_with_activity |
|---|
| | | * @see linphone_presence_model_new_with_activity_and_note |
|---|
| | | * @return The created presence model, NULL on error. @maybenil |
|---|
| | | * @see linphone_presence_model_new_with_activity(), linphone_presence_model_new_with_activity_and_note() |
|---|
| | | * |
|---|
| | | * The created presence model is considered 'offline'. |
|---|
| | | */ |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the number of services included in the presence model. |
|---|
| | | * @param[in] model The #LinphonePresenceModel object to get the number of services from. |
|---|
| | | * @param model The #LinphonePresenceModel object to get the number of services from. @notnil |
|---|
| | | * @return The number of services included in the #LinphonePresenceModel object. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC unsigned int linphone_presence_model_get_nb_services(const LinphonePresenceModel *model); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the nth service of a presence model. |
|---|
| | | * @param[in] model The #LinphonePresenceModel object to get the service from. |
|---|
| | | * @param[in] idx The index of the service to get (the first service having the index 0). |
|---|
| | | * @return A pointer to a #LinphonePresenceService object if successful, NULL otherwise. |
|---|
| | | * @param model The #LinphonePresenceModel object to get the service from. @notnil |
|---|
| | | * @param index The index of the service to get (the first service having the index 0). |
|---|
| | | * @return A pointer to a #LinphonePresenceService object if successful, NULL otherwise. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphonePresenceService * linphone_presence_model_get_nth_service(const LinphonePresenceModel *model, unsigned int idx); |
|---|
| | | LINPHONE_PUBLIC LinphonePresenceService * linphone_presence_model_get_nth_service(const LinphonePresenceModel *model, unsigned int index); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Adds a service to a presence model. |
|---|
| | | * @param[in] model The #LinphonePresenceModel object for which to add a service. |
|---|
| | | * @param[in] service The #LinphonePresenceService object to add to the model. |
|---|
| | | * @param model The #LinphonePresenceModel object for which to add a service. @notnil |
|---|
| | | * @param service The #LinphonePresenceService object to add to the model. @notnil |
|---|
| | | * @return 0 if successful, a value < 0 in case of error. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_presence_model_add_service(LinphonePresenceModel *model, LinphonePresenceService *service); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Clears the services of a presence model. |
|---|
| | | * @param[in] model The #LinphonePresenceModel object for which to clear the services. |
|---|
| | | * @param model The #LinphonePresenceModel object for which to clear the services. @notnil |
|---|
| | | * @return 0 if successful, a value < 0 in case of error. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_presence_model_clear_services(LinphonePresenceModel *model); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the number of persons included in the presence model. |
|---|
| | | * @param[in] model The #LinphonePresenceModel object to get the number of persons from. |
|---|
| | | * @param model The #LinphonePresenceModel object to get the number of persons from. @notnil |
|---|
| | | * @return The number of persons included in the #LinphonePresenceModel object. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC unsigned int linphone_presence_model_get_nb_persons(const LinphonePresenceModel *model); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the nth person of a presence model. |
|---|
| | | * @param[in] model The #LinphonePresenceModel object to get the person from. |
|---|
| | | * @param[in] idx The index of the person to get (the first person having the index 0). |
|---|
| | | * @return A pointer to a #LinphonePresencePerson object if successful, NULL otherwise. |
|---|
| | | * @param model The #LinphonePresenceModel object to get the person from. @notnil |
|---|
| | | * @param index The index of the person to get (the first person having the index 0). |
|---|
| | | * @return A pointer to a #LinphonePresencePerson object if successful, NULL otherwise. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphonePresencePerson * linphone_presence_model_get_nth_person(const LinphonePresenceModel *model, unsigned int idx); |
|---|
| | | LINPHONE_PUBLIC LinphonePresencePerson * linphone_presence_model_get_nth_person(const LinphonePresenceModel *model, unsigned int index); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Adds a person to a presence model. |
|---|
| | | * @param[in] model The #LinphonePresenceModel object for which to add a person. |
|---|
| | | * @param[in] person The #LinphonePresencePerson object to add to the model. |
|---|
| | | * @param model The #LinphonePresenceModel object for which to add a person. @notnil |
|---|
| | | * @param person The #LinphonePresencePerson object to add to the model. @notnil |
|---|
| | | * @return 0 if successful, a value < 0 in case of error. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_presence_model_add_person(LinphonePresenceModel *model, LinphonePresencePerson *person); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Clears the persons of a presence model. |
|---|
| | | * @param[in] model The #LinphonePresenceModel object for which to clear the persons. |
|---|
| | | * @param model The #LinphonePresenceModel object for which to clear the persons. @notnil |
|---|
| | | * @return 0 if successful, a value < 0 in case of error. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_presence_model_clear_persons(LinphonePresenceModel *model); |
|---|
| | |
|---|
| | | * It is any of theses cases: |
|---|
| | | * - basic status is'open' and no activities |
|---|
| | | * - explicit 'online' tag in the status |
|---|
| | | * @param[in] model #LinphonePresenceModel object |
|---|
| | | * @param model #LinphonePresenceModel object @notnil |
|---|
| | | * @return A boolean value telling whether the presence model is considered online or not. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_presence_model_is_online(const LinphonePresenceModel *model); |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the string representation of a presence basic status. |
|---|
| | | * @param[in] basic_status A #LinphonePresenceBasicStatus for which to get a string representation. |
|---|
| | | * @return A pointer a dynamically allocated string representing the given basic status. |
|---|
| | | * @param basic_status A #LinphonePresenceBasicStatus for which to get a string representation. |
|---|
| | | * @return A pointer a dynamically allocated string representing the given basic status. @notnil |
|---|
| | | * |
|---|
| | | * The returned string is to be freed by calling ms_free(). |
|---|
| | | */ |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates a presence service. |
|---|
| | | * @param[in] id The id of the presence service to be created. Can be NULL to generate it automatically. |
|---|
| | | * @param[in] basic_status The #LinphonePresenceBasicStatus to set for the #LinphonePresenceService object. |
|---|
| | | * @param[in] contact The contact string to set. |
|---|
| | | * @return The created presence service, NULL on error. |
|---|
| | | * @param id The id of the presence service to be created. Can be NULL to generate it automatically. @maybenil |
|---|
| | | * @param basic_status The #LinphonePresenceBasicStatus to set for the #LinphonePresenceService object. |
|---|
| | | * @param contact The contact string to set. @maybenil |
|---|
| | | * @return The created presence service, NULL on error. @maybenil |
|---|
| | | * |
|---|
| | | * The created presence service has the basic status 'closed'. |
|---|
| | | */ |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the id of a presence service. |
|---|
| | | * @param[in] service The #LinphonePresenceService object to get the id from. |
|---|
| | | * @return A pointer to a dynamically allocated string containing the id, or NULL in case of error. |
|---|
| | | * @param service The #LinphonePresenceService object to get the id from. @notnil |
|---|
| | | * @return A pointer to a dynamically allocated string containing the id, or NULL in case of error. @maybenil |
|---|
| | | * |
|---|
| | | * The returned string is to be freed by calling ms_free(). |
|---|
| | | */ |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the id of a presence service. |
|---|
| | | * @param[in] service The #LinphonePresenceService object for which to set the id. |
|---|
| | | * @param[in] id The id string to set. Can be NULL to generate it automatically. |
|---|
| | | * @param service The #LinphonePresenceService object for which to set the id. @notnil |
|---|
| | | * @param id The id string to set. Can be NULL to generate it automatically. @maybenil |
|---|
| | | * @return 0 if successful, a value < 0 in case of error. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_presence_service_set_id(LinphonePresenceService *service, const char *id); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the basic status of a presence service. |
|---|
| | | * @param[in] service The #LinphonePresenceService object to get the basic status from. |
|---|
| | | * @param service The #LinphonePresenceService object to get the basic status from. @notnil |
|---|
| | | * @return The #LinphonePresenceBasicStatus of the #LinphonePresenceService object given as parameter. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphonePresenceBasicStatus linphone_presence_service_get_basic_status(const LinphonePresenceService *service); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the basic status of a presence service. |
|---|
| | | * @param[in] service The #LinphonePresenceService object for which to set the basic status. |
|---|
| | | * @param[in] basic_status The #LinphonePresenceBasicStatus to set for the #LinphonePresenceService object. |
|---|
| | | * @param service The #LinphonePresenceService object for which to set the basic status. @notnil |
|---|
| | | * @param basic_status The #LinphonePresenceBasicStatus to set for the #LinphonePresenceService object. |
|---|
| | | * @return 0 if successful, a value < 0 in case of error. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_presence_service_set_basic_status(LinphonePresenceService *service, LinphonePresenceBasicStatus basic_status); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the contact of a presence service. |
|---|
| | | * @param[in] service The #LinphonePresenceService object to get the contact from. |
|---|
| | | * @return A pointer to a dynamically allocated string containing the contact, or NULL if no contact is found. |
|---|
| | | * @param service The #LinphonePresenceService object to get the contact from. @notnil |
|---|
| | | * @return A pointer to a dynamically allocated string containing the contact, or NULL if no contact is found. @maybenil |
|---|
| | | * |
|---|
| | | * The returned string is to be freed by calling ms_free(). |
|---|
| | | */ |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the contact of a presence service. |
|---|
| | | * @param[in] service The #LinphonePresenceService object for which to set the contact. |
|---|
| | | * @param[in] contact The contact string to set. |
|---|
| | | * @param service The #LinphonePresenceService object for which to set the contact. @notnil |
|---|
| | | * @param contact The contact string to set.@maybenil |
|---|
| | | * @return 0 if successful, a value < 0 in case of error. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_presence_service_set_contact(LinphonePresenceService *service, const char *contact); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the service descriptions of a presence service. |
|---|
| | | * @param[in] service The #LinphonePresenceService object to get the contact from. |
|---|
| | | * @return A \bctbx_list{char *} containing the services descriptions. |
|---|
| | | * @param service The #LinphonePresenceService object to get the contact from. @notnil |
|---|
| | | * @return A \bctbx_list{char *} containing the services descriptions. @maybenil |
|---|
| | | * |
|---|
| | | * The returned string is to be freed. |
|---|
| | | */ |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the service descriptions of a presence service. |
|---|
| | | * @param[in] service The #LinphonePresenceService object for which to set the contact. |
|---|
| | | * @param[in] descriptions \bctbx_list{char *} The service descriptions. |
|---|
| | | * @param service The #LinphonePresenceService object for which to set the contact. @notnil |
|---|
| | | * @param descriptions The service descriptions. @bctbx_list{char *} @maybenil |
|---|
| | | * @return 0 if successful, a value < 0 in case of error. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_presence_service_set_service_descriptions(LinphonePresenceService *service, bctbx_list_t *descriptions); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the number of notes included in the presence service. |
|---|
| | | * @param[in] service The #LinphonePresenceService object to get the number of notes from. |
|---|
| | | * @param service The #LinphonePresenceService object to get the number of notes from. @notnil |
|---|
| | | * @return The number of notes included in the #LinphonePresenceService object. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC unsigned int linphone_presence_service_get_nb_notes(const LinphonePresenceService *service); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the nth note of a presence service. |
|---|
| | | * @param[in] service The #LinphonePresenceService object to get the note from. |
|---|
| | | * @param[in] idx The index of the note to get (the first note having the index 0). |
|---|
| | | * @return A pointer to a #LinphonePresenceNote object if successful, NULL otherwise. |
|---|
| | | * @param service The #LinphonePresenceService object to get the note from. @notnil |
|---|
| | | * @param index The index of the note to get (the first note having the index 0). |
|---|
| | | * @return A pointer to a #LinphonePresenceNote object if successful, NULL otherwise. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphonePresenceNote * linphone_presence_service_get_nth_note(const LinphonePresenceService *service, unsigned int idx); |
|---|
| | | LINPHONE_PUBLIC LinphonePresenceNote * linphone_presence_service_get_nth_note(const LinphonePresenceService *service, unsigned int index); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Adds a note to a presence service. |
|---|
| | | * @param[in] service The #LinphonePresenceService object for which to add a note. |
|---|
| | | * @param[in] note The #LinphonePresenceNote object to add to the service. |
|---|
| | | * @param service The #LinphonePresenceService object for which to add a note. @notnil |
|---|
| | | * @param note The #LinphonePresenceNote object to add to the service. @notnil |
|---|
| | | * @return 0 if successful, a value < 0 in case of error. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_presence_service_add_note(LinphonePresenceService *service, LinphonePresenceNote *note); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Clears the notes of a presence service. |
|---|
| | | * @param[in] service The #LinphonePresenceService object for which to clear the notes. |
|---|
| | | * @param service The #LinphonePresenceService object for which to clear the notes. @notnil |
|---|
| | | * @return 0 if successful, a value < 0 in case of error. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_presence_service_clear_notes(LinphonePresenceService *service); |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates a presence person. |
|---|
| | | * @param[in] id The id of the presence person to be created. Can be NULL to generate it automatically. |
|---|
| | | * @return The created presence person, NULL on error. |
|---|
| | | * @param id The id of the presence person to be created. Can be NULL to generate it automatically. @maybenil |
|---|
| | | * @return The created presence person, NULL on error. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphonePresencePerson * linphone_presence_person_new(const char *id); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the id of a presence person. |
|---|
| | | * @param[in] person The #LinphonePresencePerson object to get the id from. |
|---|
| | | * @return A pointer to a dynamically allocated string containing the id, or NULL in case of error. |
|---|
| | | * @param person The #LinphonePresencePerson object to get the id from. |
|---|
| | | * @return A pointer to a dynamically allocated string containing the id, or NULL in case of error. @maybenil |
|---|
| | | * |
|---|
| | | * The returned string is to be freed by calling ms_free(). |
|---|
| | | */ |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the id of a presence person. |
|---|
| | | * @param[in] person The #LinphonePresencePerson object for which to set the id. |
|---|
| | | * @param[in] id The id string to set. Can be NULL to generate it automatically. |
|---|
| | | * @param person The #LinphonePresencePerson object for which to set the id. @notnil |
|---|
| | | * @param id The id string to set. Can be NULL to generate it automatically. @maybenil |
|---|
| | | * @return 0 if successful, a value < 0 in case of error. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_presence_person_set_id(LinphonePresencePerson *person, const char *id); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the number of activities included in the presence person. |
|---|
| | | * @param[in] person The #LinphonePresencePerson object to get the number of activities from. |
|---|
| | | * @param person The #LinphonePresencePerson object to get the number of activities from. @notnil |
|---|
| | | * @return The number of activities included in the #LinphonePresencePerson object. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC unsigned int linphone_presence_person_get_nb_activities(const LinphonePresencePerson *person); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the nth activity of a presence person. |
|---|
| | | * @param[in] person The #LinphonePresencePerson object to get the activity from. |
|---|
| | | * @param[in] idx The index of the activity to get (the first activity having the index 0). |
|---|
| | | * @return A pointer to a #LinphonePresenceActivity object if successful, NULL otherwise. |
|---|
| | | * @param person The #LinphonePresencePerson object to get the activity from. @notnil |
|---|
| | | * @param index The index of the activity to get (the first activity having the index 0). |
|---|
| | | * @return A pointer to a #LinphonePresenceActivity object if successful, NULL otherwise. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphonePresenceActivity * linphone_presence_person_get_nth_activity(const LinphonePresencePerson *person, unsigned int idx); |
|---|
| | | LINPHONE_PUBLIC LinphonePresenceActivity * linphone_presence_person_get_nth_activity(const LinphonePresencePerson *person, unsigned int index); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Adds an activity to a presence person. |
|---|
| | | * @param[in] person The #LinphonePresencePerson object for which to add an activity. |
|---|
| | | * @param[in] activity The #LinphonePresenceActivity object to add to the person. |
|---|
| | | * @param person The #LinphonePresencePerson object for which to add an activity. @notnil |
|---|
| | | * @param activity The #LinphonePresenceActivity object to add to the person. @notnil |
|---|
| | | * @return 0 if successful, a value < 0 in case of error. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_presence_person_add_activity(LinphonePresencePerson *person, LinphonePresenceActivity *activity); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Clears the activities of a presence person. |
|---|
| | | * @param[in] person The #LinphonePresencePerson object for which to clear the activities. |
|---|
| | | * @param person The #LinphonePresencePerson object for which to clear the activities. @notnil |
|---|
| | | * @return 0 if successful, a value < 0 in case of error. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_presence_person_clear_activities(LinphonePresencePerson *person); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the number of notes included in the presence person. |
|---|
| | | * @param[in] person The #LinphonePresencePerson object to get the number of notes from. |
|---|
| | | * @param person The #LinphonePresencePerson object to get the number of notes from. @notnil |
|---|
| | | * @return The number of notes included in the #LinphonePresencePerson object. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC unsigned int linphone_presence_person_get_nb_notes(const LinphonePresencePerson *person); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the nth note of a presence person. |
|---|
| | | * @param[in] person The #LinphonePresencePerson object to get the note from. |
|---|
| | | * @param[in] idx The index of the note to get (the first note having the index 0). |
|---|
| | | * @return A pointer to a #LinphonePresenceNote object if successful, NULL otherwise. |
|---|
| | | * @param person The #LinphonePresencePerson object to get the note from. @notnil |
|---|
| | | * @param index The index of the note to get (the first note having the index 0). |
|---|
| | | * @return A pointer to a #LinphonePresenceNote object if successful, NULL otherwise. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphonePresenceNote * linphone_presence_person_get_nth_note(const LinphonePresencePerson *person, unsigned int idx); |
|---|
| | | LINPHONE_PUBLIC LinphonePresenceNote * linphone_presence_person_get_nth_note(const LinphonePresencePerson *person, unsigned int index); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Adds a note to a presence person. |
|---|
| | | * @param[in] person The #LinphonePresencePerson object for which to add a note. |
|---|
| | | * @param[in] note The #LinphonePresenceNote object to add to the person. |
|---|
| | | * @param person The #LinphonePresencePerson object for which to add a note. @notnil |
|---|
| | | * @param note The #LinphonePresenceNote object to add to the person. @notnil |
|---|
| | | * @return 0 if successful, a value < 0 in case of error. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_presence_person_add_note(LinphonePresencePerson *person, LinphonePresenceNote *note); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Clears the notes of a presence person. |
|---|
| | | * @param[in] person The #LinphonePresencePerson object for which to clear the notes. |
|---|
| | | * @param person The #LinphonePresencePerson object for which to clear the notes. @notnil |
|---|
| | | * @return 0 if successful, a value < 0 in case of error. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_presence_person_clear_notes(LinphonePresencePerson *person); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the number of activities notes included in the presence person. |
|---|
| | | * @param[in] person The #LinphonePresencePerson object to get the number of activities notes from. |
|---|
| | | * @param person The #LinphonePresencePerson object to get the number of activities notes from. @notnil |
|---|
| | | * @return The number of activities notes included in the #LinphonePresencePerson object. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC unsigned int linphone_presence_person_get_nb_activities_notes(const LinphonePresencePerson *person); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the nth activities note of a presence person. |
|---|
| | | * @param[in] person The #LinphonePresencePerson object to get the activities note from. |
|---|
| | | * @param[in] idx The index of the activities note to get (the first note having the index 0). |
|---|
| | | * @return A pointer to a #LinphonePresenceNote object if successful, NULL otherwise. |
|---|
| | | * @param person The #LinphonePresencePerson object to get the activities note from. @notnil |
|---|
| | | * @param index The index of the activities note to get (the first note having the index 0). |
|---|
| | | * @return A pointer to a #LinphonePresenceNote object if successful, NULL otherwise. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphonePresenceNote * linphone_presence_person_get_nth_activities_note(const LinphonePresencePerson *person, unsigned int idx); |
|---|
| | | LINPHONE_PUBLIC LinphonePresenceNote * linphone_presence_person_get_nth_activities_note(const LinphonePresencePerson *person, unsigned int index); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Adds an activities note to a presence person. |
|---|
| | | * @param[in] person The #LinphonePresencePerson object for which to add an activities note. |
|---|
| | | * @param[in] note The #LinphonePresenceNote object to add to the person. |
|---|
| | | * @param person The #LinphonePresencePerson object for which to add an activities note. @notnil |
|---|
| | | * @param note The #LinphonePresenceNote object to add to the person. @notnil |
|---|
| | | * @return 0 if successful, a value < 0 in case of error. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_presence_person_add_activities_note(LinphonePresencePerson *person, LinphonePresenceNote *note); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Clears the activities notes of a presence person. |
|---|
| | | * @param[in] person The #LinphonePresencePerson object for which to clear the activities notes. |
|---|
| | | * @param person The #LinphonePresencePerson object for which to clear the activities notes. @notnil |
|---|
| | | * @return 0 if successful, a value < 0 in case of error. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_presence_person_clear_activities_notes(LinphonePresencePerson *person); |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates a presence activity. |
|---|
| | | * @param[in] acttype The #LinphonePresenceActivityType to set for the activity. |
|---|
| | | * @param[in] description An additional description of the activity to set for the activity. Can be NULL if no additional description is to be added. |
|---|
| | | * @return The created presence activity, NULL on error. |
|---|
| | | * @param acttype The #LinphonePresenceActivityType to set for the activity. @notnil |
|---|
| | | * @param description An additional description of the activity to set for the activity. Can be NULL if no additional description is to be added. @maybenil |
|---|
| | | * @return The created presence activity, NULL on error. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphonePresenceActivity * linphone_presence_activity_new(LinphonePresenceActivityType acttype, const char *description); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the string representation of a presence activity. |
|---|
| | | * @param[in] activity A pointer to the #LinphonePresenceActivity object for which to get a string representation. |
|---|
| | | * @return A pointer a dynamically allocated string representing the given activity. |
|---|
| | | * @param activity A pointer to the #LinphonePresenceActivity object for which to get a string representation. @notnil |
|---|
| | | * @return A pointer a dynamically allocated string representing the given activity. @notnil |
|---|
| | | * |
|---|
| | | * The returned string is to be freed by calling ms_free(). |
|---|
| | | */ |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the activity type of a presence activity. |
|---|
| | | * @param[in] activity A pointer to the #LinphonePresenceActivity for which to get the type. |
|---|
| | | * @param activity A pointer to the #LinphonePresenceActivity for which to get the type. @notnil |
|---|
| | | * @return The #LinphonePresenceActivityType of the activity. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphonePresenceActivityType linphone_presence_activity_get_type(const LinphonePresenceActivity *activity); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the type of activity of a presence activity. |
|---|
| | | * @param[in] activity The #LinphonePresenceActivity for which to set for the activity type. |
|---|
| | | * @param[in] acttype The activity type to set for the activity. |
|---|
| | | * @param activity The #LinphonePresenceActivity for which to set for the activity type. @notnil |
|---|
| | | * @param acttype The #LinphonePresenceActivityType to set for the activity. |
|---|
| | | * @return 0 if successful, a value < 0 in case of error. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_presence_activity_set_type(LinphonePresenceActivity *activity, LinphonePresenceActivityType acttype); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the description of a presence activity. |
|---|
| | | * @param[in] activity A pointer to the #LinphonePresenceActivity for which to get the description. |
|---|
| | | * @return A pointer to the description string of the presence activity, or NULL if no description is specified. |
|---|
| | | * @param activity A pointer to the #LinphonePresenceActivity for which to get the description. @notnil |
|---|
| | | * @return A pointer to the description string of the presence activity, or NULL if no description is specified. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_presence_activity_get_description(const LinphonePresenceActivity *activity); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the description of a presence activity. |
|---|
| | | * @param[in] activity The #LinphonePresenceActivity object for which to set the description. |
|---|
| | | * @param[in] description An additional description of the activity. Can be NULL if no additional description is to be added. |
|---|
| | | * @param activity The #LinphonePresenceActivity object for which to set the description. @notnil |
|---|
| | | * @param description An additional description of the activity. Can be NULL if no additional description is to be added. @maybenil |
|---|
| | | * @return 0 if successful, a value < 0 in case of error. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_presence_activity_set_description(LinphonePresenceActivity *activity, const char *description); |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Creates a presence note. |
|---|
| | | * @param[in] content The content of the note to be created. |
|---|
| | | * @param[in] lang The language of the note to be created. Can be NULL if no language is to be specified for the note. |
|---|
| | | * @return The created presence note, NULL on error. |
|---|
| | | * @param content The content of the note to be created. @notnil |
|---|
| | | * @param lang The language of the note to be created. Can be NULL if no language is to be specified for the note. @maybenil |
|---|
| | | * @return The created presence note, NULL on error. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphonePresenceNote * linphone_presence_note_new(const char *content, const char *lang); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the content of a presence note. |
|---|
| | | * @param[in] note A pointer to the #LinphonePresenceNote for which to get the content. |
|---|
| | | * @return A pointer to the content of the presence note. |
|---|
| | | * @param note A pointer to the #LinphonePresenceNote for which to get the content. @notnil |
|---|
| | | * @return A pointer to the content of the presence note. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_presence_note_get_content(const LinphonePresenceNote *note); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the content of a presence note. |
|---|
| | | * @param[in] note The #LinphonePresenceNote object for which to set the content. |
|---|
| | | * @param[in] content The content of the note. |
|---|
| | | * @param note The #LinphonePresenceNote object for which to set the content. @notnil |
|---|
| | | * @param content The content of the note. @notnil |
|---|
| | | * @return 0 if successful, a value < 0 in case of error. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_presence_note_set_content(LinphonePresenceNote *note, const char *content); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the language of a presence note. |
|---|
| | | * @param[in] note A pointer to the #LinphonePresenceNote for which to get the language. |
|---|
| | | * @return A pointer to the language string of the presence note, or NULL if no language is specified. |
|---|
| | | * @param note A pointer to the #LinphonePresenceNote for which to get the language. @notnil |
|---|
| | | * @return A pointer to the language string of the presence note, or NULL if no language is specified. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC const char * linphone_presence_note_get_lang(const LinphonePresenceNote *note); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the language of a presence note. |
|---|
| | | * @param[in] note The #LinphonePresenceNote object for which to set the language. |
|---|
| | | * @param[in] lang The language of the note. |
|---|
| | | * @param note The #LinphonePresenceNote object for which to set the language. @notnil |
|---|
| | | * @param lang The language of the note. @maybenil |
|---|
| | | * @return 0 if successful, a value < 0 in case of error. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphoneStatus linphone_presence_note_set_lang(LinphonePresenceNote *note, const char *lang); |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Increase the reference count of the #LinphonePresenceModel object. |
|---|
| | | * @param[in] model The #LinphonePresenceModel object for which the reference count is to be increased. |
|---|
| | | * @return The #LinphonePresenceModel object with the increased reference count. |
|---|
| | | * @param model The #LinphonePresenceModel object for which the reference count is to be increased. @notnil |
|---|
| | | * @return The #LinphonePresenceModel object with the increased reference count. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphonePresenceModel * linphone_presence_model_ref(LinphonePresenceModel *model); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Decrease the reference count of the #LinphonePresenceModel object and destroy it if it reaches 0. |
|---|
| | | * @param[in] model The #LinphonePresenceModel object for which the reference count is to be decreased. |
|---|
| | | * @return The #LinphonePresenceModel object if the reference count is still positive, NULL if the object has been destroyed. |
|---|
| | | * @param model The #LinphonePresenceModel object for which the reference count is to be decreased. @notnil |
|---|
| | | * @return The #LinphonePresenceModel object if the reference count is still positive, NULL if the object has been destroyed. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphonePresenceModel * linphone_presence_model_unref(LinphonePresenceModel *model); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the user data of a #LinphonePresenceModel object. |
|---|
| | | * @param[in] model The #LinphonePresenceModel object for which to set the user data. |
|---|
| | | * @param[in] user_data A pointer to the user data to set. |
|---|
| | | * @param model The #LinphonePresenceModel object for which to set the user data. @notnil |
|---|
| | | * @param user_data A pointer to the user data to set. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_presence_model_set_user_data(LinphonePresenceModel *model, void *user_data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the user data of a #LinphonePresenceModel object. |
|---|
| | | * @param[in] model The #LinphonePresenceModel object for which to get the user data. |
|---|
| | | * @return A pointer to the user data. |
|---|
| | | * @param model The #LinphonePresenceModel object for which to get the user data. @notnil |
|---|
| | | * @return A pointer to the user data. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void * linphone_presence_model_get_user_data(const LinphonePresenceModel *model); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the capabilities of a #LinphonePresenceModel object. |
|---|
| | | * @param[in] model The #LinphonePresenceModel object for which to set the contact. |
|---|
| | | * @param model The #LinphonePresenceModel object for which to set the contact. @notnil |
|---|
| | | * @return the capabilities. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC int linphone_presence_model_get_capabilities(const LinphonePresenceModel *model); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns whether or not the #LinphonePresenceModel object has a given capability. |
|---|
| | | * @param[in] model The #LinphonePresenceModel object for which to set the contact. |
|---|
| | | * @param[in] capability The capability to test. |
|---|
| | | * @param model The #LinphonePresenceModel object for which to set the contact. @notnil |
|---|
| | | * @param capability The capability to test. |
|---|
| | | * @return whether or not the #LinphonePresenceModel object has a given capability. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_presence_model_has_capability(const LinphonePresenceModel *model, const LinphoneFriendCapability capability); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns whether or not the #LinphonePresenceModel object has a given capability with a certain version. |
|---|
| | | * @param[in] model The #LinphonePresenceModel object for which to set the contact. |
|---|
| | | * @param[in] capability The capability to test. |
|---|
| | | * @param[in] version The wanted version to test. |
|---|
| | | * @param model The #LinphonePresenceModel object for which to set the contact. @notnil |
|---|
| | | * @param capability The #LinphoneFriendCapability to test. |
|---|
| | | * @param version The wanted version to test. |
|---|
| | | * @return whether or not the #LinphonePresenceModel object has a given capability with a certain version. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_presence_model_has_capability_with_version( |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns whether or not the #LinphonePresenceModel object has a given capability with a certain version or more. |
|---|
| | | * @param[in] model The #LinphonePresenceModel object for which to set the contact. |
|---|
| | | * @param[in] capability The capability to test. |
|---|
| | | * @param[in] version The wanted version to test. |
|---|
| | | * @param model The #LinphonePresenceModel object for which to set the contact. @notnil |
|---|
| | | * @param capability The #LinphoneFriendCapability to test. |
|---|
| | | * @param version The wanted version to test. |
|---|
| | | * @return whether or not the #LinphonePresenceModel object has a given capability with a certain version or more. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC bool_t linphone_presence_model_has_capability_with_version_or_more( |
|---|
| | |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Returns the version of the capability of a #LinphonePresenceModel. |
|---|
| | | * @param[in] model The #LinphonePresenceModel object for which to set the contact. |
|---|
| | | * @param[in] capability The capability to test. |
|---|
| | | * @param model The #LinphonePresenceModel object for which to set the contact. @notnil |
|---|
| | | * @param capability The #LinphoneFriendCapability to test. |
|---|
| | | * @return the version of the capability of a #LinphonePresenceModel or -1.0 if the model has not the capability. |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC float linphone_presence_model_get_capability_version(const LinphonePresenceModel *model, const LinphoneFriendCapability capability); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Increase the reference count of the #LinphonePresenceService object. |
|---|
| | | * @param[in] service The #LinphonePresenceService object for which the reference count is to be increased. |
|---|
| | | * @return The #LinphonePresenceService object with the increased reference count. |
|---|
| | | * @param service The #LinphonePresenceService object for which the reference count is to be increased. @notnil |
|---|
| | | * @return The #LinphonePresenceService object with the increased reference count. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphonePresenceService * linphone_presence_service_ref(LinphonePresenceService *service); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Decrease the reference count of the #LinphonePresenceService object and destroy it if it reaches 0. |
|---|
| | | * @param[in] service The #LinphonePresenceService object for which the reference count is to be decreased. |
|---|
| | | * @return The #LinphonePresenceService object if the reference count is still positive, NULL if the object has been destroyed. |
|---|
| | | * @param service The #LinphonePresenceService object for which the reference count is to be decreased. @notnil |
|---|
| | | * @return The #LinphonePresenceService object if the reference count is still positive, NULL if the object has been destroyed. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphonePresenceService * linphone_presence_service_unref(LinphonePresenceService *service); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the user data of a #LinphonePresenceService object. |
|---|
| | | * @param[in] service The #LinphonePresenceService object for which to set the user data. |
|---|
| | | * @param[in] user_data A pointer to the user data to set. |
|---|
| | | * @param service The #LinphonePresenceService object for which to set the user data. @notnil |
|---|
| | | * @param user_data A pointer to the user data to set. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_presence_service_set_user_data(LinphonePresenceService *service, void *user_data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the user data of a #LinphonePresenceService object. |
|---|
| | | * @param[in] service The #LinphonePresenceService object for which to get the user data. |
|---|
| | | * @return A pointer to the user data. |
|---|
| | | * @param service The #LinphonePresenceService object for which to get the user data. @notnil |
|---|
| | | * @return A pointer to the user data. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void * linphone_presence_service_get_user_data(const LinphonePresenceService *service); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Increase the reference count of the #LinphonePresencePerson object. |
|---|
| | | * @param[in] person The #LinphonePresencePerson object for which the reference count is to be increased. |
|---|
| | | * @return The #LinphonePresencePerson object with the increased reference count. |
|---|
| | | * @param person The #LinphonePresencePerson object for which the reference count is to be increased. @notnil |
|---|
| | | * @return The #LinphonePresencePerson object with the increased reference count. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphonePresencePerson * linphone_presence_person_ref(LinphonePresencePerson *person); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Decrease the reference count of the #LinphonePresencePerson object and destroy it if it reaches 0. |
|---|
| | | * @param[in] person The #LinphonePresencePerson object for which the reference count is to be decreased. |
|---|
| | | * @return The #LinphonePresencePerson object if the reference count is still positive, NULL if the object has been destroyed. |
|---|
| | | * @param person The #LinphonePresencePerson object for which the reference count is to be decreased. @notnil |
|---|
| | | * @return The #LinphonePresencePerson object if the reference count is still positive, NULL if the object has been destroyed. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphonePresencePerson * linphone_presence_person_unref(LinphonePresencePerson *person); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the user data of a #LinphonePresencePerson object. |
|---|
| | | * @param[in] person The #LinphonePresencePerson object for which to set the user data. |
|---|
| | | * @param[in] user_data A pointer to the user data to set. |
|---|
| | | * @param person The #LinphonePresencePerson object for which to set the user data. @notnil |
|---|
| | | * @param user_data A pointer to the user data to set. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_presence_person_set_user_data(LinphonePresencePerson *person, void *user_data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the user data of a #LinphonePresencePerson object. |
|---|
| | | * @param[in] person The #LinphonePresencePerson object for which to get the user data. |
|---|
| | | * @return A pointer to the user data. |
|---|
| | | * @param person The #LinphonePresencePerson object for which to get the user data. @notnil |
|---|
| | | * @return A pointer to the user data. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void * linphone_presence_person_get_user_data(const LinphonePresencePerson *person); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Increase the reference count of the #LinphonePresenceActivity object. |
|---|
| | | * @param[in] activity The #LinphonePresenceActivity object for which the reference count is to be increased. |
|---|
| | | * @return The #LinphonePresenceActivity object with the increased reference count. |
|---|
| | | * @param activity The #LinphonePresenceActivity object for which the reference count is to be increased. @notnil |
|---|
| | | * @return The #LinphonePresenceActivity object with the increased reference count. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphonePresenceActivity * linphone_presence_activity_ref(LinphonePresenceActivity *activity); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Decrease the reference count of the #LinphonePresenceActivity object and destroy it if it reaches 0. |
|---|
| | | * @param[in] activity The #LinphonePresenceActivity object for which the reference count is to be decreased. |
|---|
| | | * @return The #LinphonePresenceActivity object if the reference count is still positive, NULL if the object has been destroyed. |
|---|
| | | * @param activity The #LinphonePresenceActivity object for which the reference count is to be decreased. @notnil |
|---|
| | | * @return The #LinphonePresenceActivity object if the reference count is still positive, NULL if the object has been destroyed. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphonePresenceActivity * linphone_presence_activity_unref(LinphonePresenceActivity *activity); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the user data of a #LinphonePresenceActivity object. |
|---|
| | | * @param[in] activity The #LinphonePresenceActivity object for which to set the user data. |
|---|
| | | * @param[in] user_data A pointer to the user data to set. |
|---|
| | | * @param activity The #LinphonePresenceActivity object for which to set the user data. @notnil |
|---|
| | | * @param user_data A pointer to the user data to set. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_presence_activity_set_user_data(LinphonePresenceActivity *activity, void *user_data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the user data of a #LinphonePresenceActivity object. |
|---|
| | | * @param[in] activity The #LinphonePresenceActivity object for which to get the user data. |
|---|
| | | * @return A pointer to the user data. |
|---|
| | | * @param activity The #LinphonePresenceActivity object for which to get the user data. @notnil |
|---|
| | | * @return A pointer to the user data. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void * linphone_presence_activity_get_user_data(const LinphonePresenceActivity *activity); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Increase the reference count of the #LinphonePresenceNote object. |
|---|
| | | * @param[in] note The #LinphonePresenceNote object for which the reference count is to be increased. |
|---|
| | | * @return The #LinphonePresenceNote object with the increased reference count. |
|---|
| | | * @param note The #LinphonePresenceNote object for which the reference count is to be increased. @notnil |
|---|
| | | * @return The #LinphonePresenceNote object with the increased reference count. @notnil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphonePresenceNote * linphone_presence_note_ref(LinphonePresenceNote *note); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Decrease the reference count of the #LinphonePresenceNote object and destroy it if it reaches 0. |
|---|
| | | * @param[in] note The #LinphonePresenceNote object for which the reference count is to be decreased. |
|---|
| | | * @return The #LinphonePresenceNote object if the reference count is still positive, NULL if the object has been destroyed. |
|---|
| | | * @param note The #LinphonePresenceNote object for which the reference count is to be decreased. @notnil |
|---|
| | | * @return The #LinphonePresenceNote object if the reference count is still positive, NULL if the object has been destroyed. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC LinphonePresenceNote * linphone_presence_note_unref(LinphonePresenceNote *note); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Sets the user data of a #LinphonePresenceNote object. |
|---|
| | | * @param[in] note The #LinphonePresenceNote object for which to set the user data. |
|---|
| | | * @param[in] user_data A pointer to the user data to set. |
|---|
| | | * @param note The #LinphonePresenceNote object for which to set the user data. @notnil |
|---|
| | | * @param user_data A pointer to the user data to set. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void linphone_presence_note_set_user_data(LinphonePresenceNote *note, void *user_data); |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Gets the user data of a #LinphonePresenceNote object. |
|---|
| | | * @param[in] note The #LinphonePresenceNote object for which to get the user data. |
|---|
| | | * @return A pointer to the user data. |
|---|
| | | * @param note The #LinphonePresenceNote object for which to get the user data. @notnil |
|---|
| | | * @return A pointer to the user data. @maybenil |
|---|
| | | */ |
|---|
| | | LINPHONE_PUBLIC void * linphone_presence_note_get_user_data(const LinphonePresenceNote *note); |
|---|
| | | |
|---|
| HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/linphone.framework/Headers/proxy_config.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/linphone.framework/Headers/ringtoneplayer.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/linphone.framework/Headers/sipsetup.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/linphone.framework/Headers/tunnel.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/linphone.framework/Headers/types.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/linphone.framework/Headers/utils/algorithm.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/linphone.framework/Headers/utils/enum-generator.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/linphone.framework/Headers/utils/enum-mask.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/linphone.framework/Headers/utils/fs.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/linphone.framework/Headers/utils/general.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/linphone.framework/Headers/utils/magic-macros.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/linphone.framework/Headers/utils/traits.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/linphone.framework/Headers/utils/utils.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/linphone.framework/Headers/vcard.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/linphone.framework/Headers/video_definition.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/linphone.framework/Headers/wrapper_utils.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/linphone.framework/Headers/xmlrpc.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/linphone.framework/Info.plist
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/linphone.framework/linphone
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/linphone.framework/rootca.pem
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/linphonetester.framework/Headers/audio_quality_tester.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/linphonetester.framework/Headers/liblinphone_tester.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/linphonetester.framework/Headers/private-access.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/linphonetester.framework/Headers/tester.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/linphonetester.framework/Info.plist
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/linphonetester.framework/linphonetester
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/mediastreamer2.framework/Headers/allfilters.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/mediastreamer2.framework/Headers/android_utils.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/mediastreamer2.framework/Headers/bitratecontrol.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/mediastreamer2.framework/Headers/devices.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/mediastreamer2.framework/Headers/flowcontrol.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/mediastreamer2.framework/Headers/ice.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/mediastreamer2.framework/Headers/mediastream.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/mediastreamer2.framework/Headers/mscommon.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/mediastreamer2.framework/Headers/msconference.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/mediastreamer2.framework/Headers/msfilter.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/mediastreamer2.framework/Headers/msinterfaces.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/mediastreamer2.framework/Headers/msjpegwriter.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/mediastreamer2.framework/Headers/msmediaplayer.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/mediastreamer2.framework/Headers/msqrcodereader.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/mediastreamer2.framework/Headers/msqueue.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/mediastreamer2.framework/Headers/msrtt4103.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/mediastreamer2.framework/Headers/mssndcard.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/mediastreamer2.framework/Headers/msticker.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/mediastreamer2.framework/Headers/msvideo.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/mediastreamer2.framework/Headers/msvideoswitcher.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/mediastreamer2.framework/Headers/rfc3984.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/mediastreamer2.framework/Headers/stun.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/mediastreamer2.framework/Info.plist
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/mediastreamer2.framework/mediastreamer2
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/msamr.framework/Info.plist
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/msamr.framework/msamr
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/mscodec2.framework/Info.plist
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/mscodec2.framework/mscodec2
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/msopenh264.framework/Info.plist
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/msopenh264.framework/msopenh264
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/mssilk.framework/Info.plist
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/mssilk.framework/mssilk
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/mswebrtc.framework/Info.plist
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/mswebrtc.framework/mswebrtc
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/msx264.framework/Info.plist
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/msx264.framework/msx264
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/ortp.framework/Headers/b64.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/ortp.framework/Headers/nack.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/ortp.framework/Headers/port.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/ortp.framework/Headers/rtcp.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/ortp.framework/Headers/rtp.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/ortp.framework/Headers/rtpsession.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/ortp.framework/Headers/str_utils.h
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/ortp.framework/Info.plist
HDLLinPhoneSDK（OC）/HDLLinPhoneSDK/linphone-sdk/apple-darwin/Frameworks/ortp.framework/ortp
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/ApiDefinition.cs
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/bctoolbox-ios.framework/Info.plist
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/bctoolbox-ios.framework/bctoolbox-ios
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/bctoolbox-tester.framework/Info.plist
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/bctoolbox-tester.framework/bctoolbox-tester
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/bctoolbox.framework/Headers/charconv.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/bctoolbox.framework/Headers/compiler.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/bctoolbox.framework/Headers/crypto.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/bctoolbox.framework/Headers/crypto.hh
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/bctoolbox.framework/Headers/defs.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/bctoolbox.framework/Headers/ios_utils.hh
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/bctoolbox.framework/Headers/list.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/bctoolbox.framework/Headers/logging.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/bctoolbox.framework/Headers/map.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/bctoolbox.framework/Headers/param_string.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/bctoolbox.framework/Headers/parser.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/bctoolbox.framework/Headers/port.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/bctoolbox.framework/Headers/regex.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/bctoolbox.framework/Headers/tester.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/bctoolbox.framework/Headers/vconnect.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/bctoolbox.framework/Headers/vfs.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/bctoolbox.framework/Headers/vfs_encrypted.hh
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/bctoolbox.framework/Headers/vfs_standard.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/bctoolbox.framework/Info.plist
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/bctoolbox.framework/bctoolbox
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/belcard.framework/Info.plist
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/belcard.framework/belcard
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/belcard.framework/vcard_grammar
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/belle-sip.framework/Headers/bodyhandler.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/belle-sip.framework/Headers/dialog.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/belle-sip.framework/Headers/headers.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/belle-sip.framework/Headers/listeningpoint.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/belle-sip.framework/Headers/mainloop.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/belle-sip.framework/Headers/message.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/belle-sip.framework/Headers/object++.hh
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/belle-sip.framework/Headers/provider.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/belle-sip.framework/Headers/sipstack.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/belle-sip.framework/Headers/types.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/belle-sip.framework/Headers/utils.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/belle-sip.framework/Info.plist
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/belle-sip.framework/belle-sip
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/belr.framework/Info.plist
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/belr.framework/belr
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/libHDLLinPhoneSDK.a
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/lime.framework/Headers/lime.hpp
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/lime.framework/Headers/lime_ffi.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/lime.framework/Info.plist
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/lime.framework/lime
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/limetester.framework/Headers/lime-tester-utils.hpp
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/limetester.framework/Headers/lime-tester.hpp
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/limetester.framework/Info.plist
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/limetester.framework/limetester
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/account_creator.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/account_creator_service.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/api/c-address.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/api/c-api.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/api/c-audio-device.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/api/c-auth-info.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/api/c-call-cbs.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/api/c-call-stats.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/api/c-call.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/api/c-callbacks.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/api/c-chat-message-cbs.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/api/c-chat-message.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/api/c-chat-room-cbs.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/api/c-chat-room-params.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/api/c-chat-room.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/api/c-conference-cbs.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/api/c-conference.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/api/c-content.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/api/c-dial-plan.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/api/c-event-log.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/api/c-factory.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/api/c-magic-search.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/api/c-participant-device-identity.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/api/c-participant-device.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/api/c-participant-imdn-state.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/api/c-participant.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/api/c-push-notification-message.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/api/c-search-result.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/api/c-types.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/buffer.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/call.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/call_log.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/call_params.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/call_stats.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/callbacks.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/chat.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/conference.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/contactprovider.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/core.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/core_utils.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/defs.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/dictionary.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/enums/call-enums.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/enums/chat-message-enums.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/enums/chat-room-enums.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/enums/conference-enums.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/enums/encryption-engine-enums.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/enums/event-log-enums.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/enums/security-event-enums.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/error_info.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/event.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/factory.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/friend.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/friendlist.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/headers.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/im_encryption_engine.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/im_notif_policy.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/info_message.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/ldapprovider.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/linphone_proxy_config.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/linphone_tunnel.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/linphonecore.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/linphonecore_utils.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/linphonefriend.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/linphonepresence.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/logging.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/lpconfig.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/misc.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/nat_policy.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/payload_type.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/player.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/presence.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/proxy_config.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/ringtoneplayer.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/sipsetup.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/tunnel.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/types.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/utils/algorithm.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/utils/enum-generator.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/utils/enum-mask.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/utils/fs.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/utils/general.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/utils/magic-macros.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/utils/traits.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/utils/utils.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/vcard.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/video_definition.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/wrapper_utils.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Headers/xmlrpc.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/Info.plist
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/linphone
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphone.framework/rootca.pem
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphonetester.framework/Headers/audio_quality_tester.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphonetester.framework/Headers/liblinphone_tester.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphonetester.framework/Headers/private-access.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphonetester.framework/Headers/tester.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphonetester.framework/Info.plist
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/linphonetester.framework/linphonetester
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/mediastreamer2.framework/Headers/allfilters.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/mediastreamer2.framework/Headers/android_utils.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/mediastreamer2.framework/Headers/bitratecontrol.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/mediastreamer2.framework/Headers/devices.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/mediastreamer2.framework/Headers/flowcontrol.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/mediastreamer2.framework/Headers/ice.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/mediastreamer2.framework/Headers/mediastream.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/mediastreamer2.framework/Headers/mscommon.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/mediastreamer2.framework/Headers/msconference.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/mediastreamer2.framework/Headers/msfilter.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/mediastreamer2.framework/Headers/msinterfaces.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/mediastreamer2.framework/Headers/msjpegwriter.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/mediastreamer2.framework/Headers/msmediaplayer.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/mediastreamer2.framework/Headers/msqrcodereader.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/mediastreamer2.framework/Headers/msqueue.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/mediastreamer2.framework/Headers/msrtt4103.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/mediastreamer2.framework/Headers/mssndcard.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/mediastreamer2.framework/Headers/msticker.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/mediastreamer2.framework/Headers/msvideo.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/mediastreamer2.framework/Headers/msvideoswitcher.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/mediastreamer2.framework/Headers/rfc3984.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/mediastreamer2.framework/Headers/stun.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/mediastreamer2.framework/Info.plist
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/mediastreamer2.framework/mediastreamer2
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/msamr.framework/Info.plist
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/msamr.framework/msamr
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/mscodec2.framework/Info.plist
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/mscodec2.framework/mscodec2
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/msopenh264.framework/Info.plist
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/msopenh264.framework/msopenh264
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/mssilk.framework/Info.plist
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/mssilk.framework/mssilk
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/mswebrtc.framework/Info.plist
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/mswebrtc.framework/mswebrtc
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/msx264.framework/Info.plist
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/msx264.framework/msx264
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/ortp.framework/Headers/b64.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/ortp.framework/Headers/nack.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/ortp.framework/Headers/port.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/ortp.framework/Headers/rtcp.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/ortp.framework/Headers/rtp.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/ortp.framework/Headers/rtpsession.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/ortp.framework/Headers/str_utils.h
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/ortp.framework/Info.plist
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Library/ortp.framework/ortp
Shared.IOS.HDLLinphoneSDK/Shared.IOS.HDLLinphoneSDK/Properties/AssemblyInfo.cs |
