def updateBonjourServersPopupButton(self):
settings = SIPSimpleSettings()
account = AccountManager().default_account
if isinstance(account, BonjourAccount):
self.bonjour_server_combolist.removeAllItems()
if SIPManager().bonjour_conference_services.servers:
servers = set()
servers_dict = {}
for server in (server for server in SIPManager().bonjour_conference_services.servers if server.uri.transport in settings.sip.transport_list):
servers_dict.setdefault("%s@%s" % (server.uri.user, server.uri.host), []).append(server)
for transport in (transport for transport in ('tls', 'tcp', 'udp') if transport in settings.sip.transport_list):
for k, v in servers_dict.items():
try:
server = next((server for server in v if server.uri.transport == transport))
except StopIteration:
pass
else:
servers.add(server)
break
for server in servers:
self.bonjour_server_combolist.addItemWithTitle_('%s (%s)' % (server.host, server.uri.host))
item = self.bonjour_server_combolist.lastItem()
item.setRepresentedObject_(server)
self.ok_button.setEnabled_(True)
else:
self.bonjour_server_combolist.addItemWithTitle_(NSLocalizedString("No conference server in this neighbourhood", "Menu item"))
self.bonjour_server_combolist.lastItem().setEnabled_(False)
self.ok_button.setEnabled_(False)
else:
self.ok_button.setEnabled_(False)
def init(self):
if self:
NSBundle.loadNibNamed_owner_("EnrollmentWindow", self)
icloud_sync_enabled = NSUserDefaults.standardUserDefaults().stringForKey_("iCloudSyncEnabled")
self.syncWithiCloudCheckbox.setHidden_(not icloud_sync_enabled)
self.selectRadio_(self.radioMatrix)
if not SIPManager().validateAddAccountAction():
self.nextButton.setEnabled_(False)
self.purchaseProLabel.setHidden_(False)
if NSApp.delegate().contactsWindowController.first_run:
NotificationCenter().add_observer(self, name='SIPAccountManagerDidAddAccount')
if NSApp.delegate().allowed_domains:
self.allowed_domains = NSApp.delegate().allowed_domains
self.syncWithiCloudCheckbox.setHidden_(True)
self.syncWithiCloudCheckbox.setState_(NSOffState)
self.domainButton.setHidden_(True)
self.addressText.cell().setPlaceholderString_('user@' + self.allowed_domains[0])
if not NSApp.delegate().icloud_enabled:
self.syncWithiCloudCheckbox.setHidden_(True)
return self
def muteBeforeSpeechWillStart(self):
hasAudio = any(sess.hasStreamOfType("audio") for sess in self.sessionControllersManager.sessionControllers)
if hasAudio:
if not SIPManager().is_muted():
NSApp.delegate().contactsWindowController.muteClicked_(None)
self.muted_by_synthesizer = True
if self.speech_recognizer:
self.speech_recognizer.stopListening()
def init(self):
if self:
NSBundle.loadNibNamed_owner_("EnrollmentWindow", self)
self.selectRadio_(self.radioMatrix)
if not SIPManager().validateAddAccountAction():
self.nextButton.setEnabled_(False)
self.purchaseProLabel.setHidden_(False)
if NSApp.delegate().contactsWindowController.first_run:
NotificationCenter().add_observer(
self, name='SIPAccountManagerDidAddAccount')
return self
def applicationDidFinishLaunching_(self, sender):
BlinkLogger().log_debug("Application launched")
branding_file = NSBundle.mainBundle().infoDictionary().objectForKey_("BrandingFile")
try:
branding = __import__(branding_file)
except ImportError:
try:
import branding
except ImportError:
branding = Null
branding.setup(self)
if self.updater and self.sp_update_url is not None:
self.updater.sp.setFeedURL_(NSURL.URLWithString_(self.sp_update_url))
self.blinkMenu.setTitle_(self.applicationNamePrint)
config_file = ApplicationData.get('config')
self.icloud_manager = iCloudManager()
self.backend = SIPManager()
self.contactsWindowController.setup(self.backend)
while True:
try:
first_run = not os.path.exists(config_file)
self.contactsWindowController.first_run = first_run
self.backend.init()
self.backend.fetch_account()
accounts = AccountManager().get_accounts()
if not accounts or (first_run and accounts == [BonjourAccount()]):
self.wait_for_enrollment = True
self.enroll()
break
except FileParserError as exc:
BlinkLogger().log_warning("Error parsing configuration file: %s" % exc)
if NSRunAlertPanel(NSLocalizedString("Error", "Window title"),
NSLocalizedString("The configuration file is corrupted. You will need to replace it and re-enter your account information. \n\nYour current configuration file will be backed up to %s.corrupted. ", "Label") % config_file,
NSLocalizedString("Replace", "Button title"), NSLocalizedString("Quit", "Button title"), None) != NSAlertDefaultReturn:
NSApp.terminate_(None)
return
os.rename(config_file, config_file+".corrupted")
BlinkLogger().log_info("Renamed configuration file to %s" % config_file+".corrupted")
except BaseException as exc:
import traceback
print(traceback.print_exc())
NSRunAlertPanel(NSLocalizedString("Error", "Window title"), NSLocalizedString("There was an error during startup of core functionality:\n%s", "Label") % exc,
NSLocalizedString("Quit", "Button title"), None, None)
NSApp.terminate_(None)
return
# window should be shown only after enrollment check
if self.wait_for_enrollment:
BlinkLogger().log_info('Starting User Interface')
self.contactsWindowController.model.moveBonjourGroupFirst()
self.contactsWindowController.showWindow_(None)
self.wait_for_enrollment = False
self.contactsWindowController.setupFinished()
SMSWindowManager.SMSWindowManager().setOwner_(self.contactsWindowController)
self.debugWindow = DebugWindow.alloc().init()
self.chatWindowController = ChatWindowController.ChatWindowController.alloc().init()
def validateAddAccountButton(self):
if self.addButton:
self.addButton.setEnabled_(SIPManager().validateAddAccountAction())
def createNewAccount(self):
sip_address = None
display_name = str(self.newDisplayNameText.stringValue().strip())
username = str(self.newUsernameText.stringValue().strip())
password = str(self.newPasswordText.stringValue().strip())
email = str(self.newEmailText.stringValue())
self.progressIndicator.setHidden_(False)
self.domainButton.setHidden_(True)
self.progressText.setHidden_(False)
self.progressIndicator.setUsesThreadedAnimation_(True)
self.progressIndicator.startAnimation_(None)
self.window.display()
url = SIPSimpleSettings().server.enrollment_url
sip_address = None
tzname = datetime.datetime.now(tzlocal()).tzname() or ""
if not tzname:
BlinkLogger().log_warning("Unable to determine timezone")
values = {'password' : password.encode("utf8"),
'username' : username.encode("utf8"),
'email' : email.encode("utf8"),
'display_name' : display_name.encode("utf8"),
'tzinfo' : tzname }
BlinkLogger().log_info("Requesting creation of a new SIP account at %s" % url)
data = urllib.parse.urlencode(values)
req = urllib.request.Request(url, data.encode("utf-8"))
try:
raw_response = urllib.request.urlopen(req)
except urllib.error.URLError as e:
error_message = NSLocalizedString("Cannot connect to enrollment server: %s", "Enrollment panel label") % e
except urllib.error.HTTPError as e:
error_message = NSLocalizedString("Error from enrollment server: %s", "Enrollment panel label") % e
else:
raw_data = raw_response.read().decode().replace('\\/', '/')
try:
json_data = json.loads(raw_data)
except (TypeError, json.decoder.JSONDecodeError):
error_message = NSLocalizedString("Cannot decode data from enrollment server", "Enrollment panel label")
else:
try:
success = json_data["success"]
except (TypeError, KeyError):
success = False
if not success:
BlinkLogger().log_info("Enrollment Server failed to create SIP account")
try:
error_message = json_data["error_message"]
except (TypeError, KeyError):
error_message == 'Cannot read server response'
else:
BlinkLogger().log_info("Enrollment Server successfully created SIP account")
data = defaultdict(lambda: None, json_data)
tls_path = None if data['passport'] is None else SIPManager().save_certificates(data)
sip_address = data['sip_address']
try:
outbound_proxy = data['outbound_proxy']
except KeyError:
outbound_proxy = None
try:
xcap_root = data['xcap_root']
except KeyError:
xcap_root = None
try:
msrp_relay = data['msrp_relay']
except KeyError:
msrp_relay = None
try:
settings_url = data['settings_url']
except KeyError:
settings_url = None
try:
web_alert_url = data['web_alert_url']
except KeyError:
web_alert_url = None
try:
web_password = data['web_password']
except KeyError:
web_password = None
try:
conference_server = data['conference_server']
except KeyError:
conference_server = None
try:
ldap_hostname = data['ldap_hostname']
except KeyError:
ldap_hostname = None
try:
ldap_transport = data['ldap_transport']
except KeyError:
ldap_transport = None
try:
ldap_port = data['ldap_port']
except KeyError:
ldap_port = None
try:
ldap_username = data['ldap_username']
except KeyError:
ldap_username = None
try:
ldap_password = data['ldap_password']
except KeyError:
ldap_password = None
try:
ldap_dn = data['ldap_dn']
except KeyError:
ldap_dn = None
self.progressIndicator.stopAnimation_(None)
self.progressIndicator.setHidden_(True)
self.progressText.setHidden_(True)
self.domainButton.setHidden_(False)
if sip_address is None:
BlinkLogger().log_info(error_message)
NSRunAlertPanel(NSLocalizedString("Sign Up to SIP Account", "Window title"),
NSLocalizedString("Error creating SIP account: %s", "Label") % error_message, NSLocalizedString("OK", "Button title"), None, None)
return False
try:
account = Account(str(sip_address))
except ValueError as e:
NSRunAlertPanel(NSLocalizedString("Sign Up to SIP Account", "Window title"), NSLocalizedString("Cannot add SIP Account: %s", "Label") % e, NSLocalizedString("OK", "Button title"), None, None)
return False
else:
NSApp.delegate().contactsWindowController.created_accounts.add(account.id)
account.display_name = display_name
account.auth.password = password
account.nat_traversal.use_ice = True
account.rtp.srtp_encryption = 'optional'
if tls_path:
account.tls.certificate = tls_path
account.sip.outbound_proxy = outbound_proxy
account.xcap.xcap_root = xcap_root
account.nat_traversal.msrp_relay = msrp_relay
if settings_url:
account.server.settings_url = settings_url
if web_alert_url:
account.web_alert.alert_url = web_alert_url
if web_password:
account.server.web_password = web_password
if conference_server:
account.conference.server_address = conference_server
if ldap_hostname:
account.ldap.enabled = True
account.ldap.hostname = ldap_hostname
account.ldap.dn = ldap_dn
account.ldap.username = ldap_username
if ldap_password:
account.ldap.password = ldap_password
if ldap_transport:
account.ldap.transport = ldap_transport
if ldap_port:
account.ldap.port = ldap_port
sync_with_icloud = bool(self.syncWithiCloudCheckbox.state())
account.gui.sync_with_icloud = sync_with_icloud
account.save()
NSRunAlertPanel(NSLocalizedString("SIP Account Created", "Window title"), NSLocalizedString("Your new SIP Address is:\n\n%s", "Label") % sip_address, NSLocalizedString("Continue", "Button title"), None, None)
# enable account only after Continue pressed to give server time to update
account.enabled = True
account.save()
AccountManager().default_account = account
return True
def createNewAccount(self):
display_name = unicode(self.newDisplayNameText.stringValue())
username = unicode(self.newUsernameText.stringValue())
password = unicode(self.newPasswordText.stringValue())
email = unicode(self.newEmailText.stringValue())
self.progressIndicator.setHidden_(False)
self.progressText.setHidden_(False)
self.progressIndicator.setUsesThreadedAnimation_(True)
self.progressIndicator.startAnimation_(None)
self.window.display()
url = SIPSimpleSettings().server.enrollment_url
tzname = datetime.datetime.now(tzlocal()).tzname() or ""
if not tzname:
BlinkLogger().log_warning(u"Unable to determine timezone")
values = {
'password': password.encode("utf8"),
'username': username.encode("utf8"),
'email': email.encode("utf8"),
'display_name': display_name.encode("utf8"),
'tzinfo': tzname
}
BlinkLogger().log_info(
u"Requesting creation of a new SIP account at %s" % url)
data = urllib.urlencode(values)
req = urllib2.Request(url, data)
raw_response = urllib2.urlopen(req)
json_data = raw_response.read()
try:
response = cjson.decode(json_data.replace('\\/', '/'))
except TypeError:
error_message = 'Cannot decode json data from enrollment server'
if response:
if not response["success"]:
BlinkLogger().log_info(
u"Enrollment Server failed to create SIP account: %(error_message)s"
% response)
error_message = response["error_message"]
else:
BlinkLogger().log_info(
u"Enrollment Server successfully created SIP account %(sip_address)s"
% response)
data = defaultdict(lambda: None, response)
tls_path = None if data['passport'] is None else SIPManager(
).save_certificates(data)
try:
sip_address = data['sip_address']
try:
outbound_proxy = data['outbound_proxy']
except KeyError:
outbound_proxy = None
try:
xcap_root = data['xcap_root']
except KeyError:
xcap_root = None
try:
msrp_relay = data['msrp_relay']
except KeyError:
msrp_relay = None
try:
settings_url = data['settings_url']
except KeyError:
settings_url = None
try:
web_alert_url = data['web_alert_url']
except KeyError:
web_alert_url = None
try:
web_password = data['web_password']
except KeyError:
web_password = None
try:
conference_server = data['conference_server']
except KeyError:
conference_server = None
try:
ldap_hostname = data['ldap_hostname']
except KeyError:
ldap_hostname = None
try:
ldap_transport = data['ldap_transport']
except KeyError:
ldap_transport = None
try:
ldap_port = data['ldap_port']
except KeyError:
ldap_port = None
try:
ldap_username = data['ldap_username']
except KeyError:
ldap_username = None
try:
ldap_password = data['ldap_password']
except KeyError:
ldap_password = None
try:
ldap_dn = data['ldap_dn']
except KeyError:
ldap_dn = None
except KeyError:
sip_address = None
else:
sip_address = None
error_message = "No response received from %s" % url
self.progressIndicator.stopAnimation_(None)
self.progressIndicator.setHidden_(True)
self.progressText.setHidden_(True)
if not sip_address:
NSRunAlertPanel("Sign Up to SIP Account",
"Error creating account: %s" % error_message, "OK",
None, None)
return False
try:
account = Account(str(sip_address))
except ValueError, e:
NSRunAlertPanel("Sign Up to SIP Account",
"Cannot add SIP Account: %s" % str(e), "OK", None,
None)
return False
def unMuteAfterSpeechDidEnd(self):
if self.muted_by_synthesizer and SIPManager().is_muted():
NSApp.delegate().contactsWindowController.muteClicked_(None)
self.muted_by_synthesizer = False
if self.speech_recognizer:
self.speech_recognizer.startListening()
