git.maemo.org Git - gc-dialer/blob - src/dc_glade.py

   1 #!/usr/bin/python2.5
   2
   3 """
   4 DialCentral - Front end for Google's GoogleVoice service.
   5 Copyright (C) 2008  Mark Bergman bergman AT merctech DOT com
   6
   7 This library is free software; you can redistribute it and/or
   8 modify it under the terms of the GNU Lesser General Public
   9 License as published by the Free Software Foundation; either
  10 version 2.1 of the License, or (at your option) any later version.
  11
  12 This library is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 Lesser General Public License for more details.
  16
  17 You should have received a copy of the GNU Lesser General Public
  18 License along with this library; if not, write to the Free Software
  19 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  20
  21 @bug When switching to tab while logging in, it doesn't refresh once logged int
  22 """
  23
  24
  25 from __future__ import with_statement
  26
  27 import sys
  28 import gc
  29 import os
  30 import threading
  31 import base64
  32 import ConfigParser
  33 import itertools
  34 import logging
  35
  36 import gtk
  37 import gtk.glade
  38
  39 import constants
  40 import hildonize
  41 import gtk_toolbox
  42
  43
  44 def getmtime_nothrow(path):
  45         try:
  46                 return os.path.getmtime(path)
  47         except Exception:
  48                 return 0
  49
  50
  51 def display_error_message(msg):
  52         error_dialog = gtk.MessageDialog(None, 0, gtk.MESSAGE_ERROR, gtk.BUTTONS_CLOSE, msg)
  53
  54         def close(dialog, response):
  55                 dialog.destroy()
  56         error_dialog.connect("response", close)
  57         error_dialog.run()
  58
  59
  60 class Dialcentral(object):
  61
  62         _glade_files = [
  63                 os.path.join(os.path.dirname(__file__), "dialcentral.glade"),
  64                 os.path.join(os.path.dirname(__file__), "../lib/dialcentral.glade"),
  65                 '/usr/lib/dialcentral/dialcentral.glade',
  66         ]
  67
  68         KEYPAD_TAB = 0
  69         RECENT_TAB = 1
  70         MESSAGES_TAB = 2
  71         CONTACTS_TAB = 3
  72         ACCOUNT_TAB = 4
  73
  74         NULL_BACKEND = 0
  75         GV_BACKEND = 2
  76         BACKENDS = (NULL_BACKEND, GV_BACKEND)
  77
  78         def __init__(self):
  79                 self._initDone = False
  80                 self._connection = None
  81                 self._osso = None
  82                 self._clipboard = gtk.clipboard_get()
  83
  84                 self._credentials = ("", "")
  85                 self._selectedBackendId = self.NULL_BACKEND
  86                 self._defaultBackendId = self.GV_BACKEND
  87                 self._phoneBackends = None
  88                 self._dialpads = None
  89                 self._accountViews = None
  90                 self._messagesViews = None
  91                 self._recentViews = None
  92                 self._contactsViews = None
  93                 self._alarmHandler = None
  94                 self._ledHandler = None
  95                 self._originalCurrentLabels = []
  96
  97                 for path in self._glade_files:
  98                         if os.path.isfile(path):
  99                                 self._widgetTree = gtk.glade.XML(path)
 100                                 break
 101                 else:
 102                         display_error_message("Cannot find dialcentral.glade")
 103                         gtk.main_quit()
 104                         return
 105
 106                 self._window = self._widgetTree.get_widget("mainWindow")
 107                 self._notebook = self._widgetTree.get_widget("notebook")
 108                 self._errorDisplay = gtk_toolbox.ErrorDisplay(self._widgetTree)
 109                 self._credentialsDialog = gtk_toolbox.LoginWindow(self._widgetTree)
 110
 111                 self._isFullScreen = False
 112                 self._app = hildonize.get_app_class()()
 113                 self._window = hildonize.hildonize_window(self._app, self._window)
 114                 hildonize.hildonize_text_entry(self._widgetTree.get_widget("usernameentry"))
 115                 hildonize.hildonize_password_entry(self._widgetTree.get_widget("passwordentry"))
 116                 hildonize.hildonize_combo_entry(self._widgetTree.get_widget("callbackcombo").get_child())
 117
 118                 for scrollingWidget in (
 119                         'recent_scrolledwindow',
 120                         'message_scrolledwindow',
 121                         'contacts_scrolledwindow',
 122                         "phoneSelectionMessages_scrolledwindow",
 123                         "smsMessages_scrolledwindow",
 124                 ):
 125                         hildonize.hildonize_scrollwindow(self._widgetTree.get_widget(scrollingWidget))
 126                 for scrollingWidget in (
 127                         "phonetypes_scrolledwindow",
 128                         "smsMessage_scrolledEntry",
 129                 ):
 130                         hildonize.hildonize_scrollwindow_with_viewport(self._widgetTree.get_widget(scrollingWidget))
 131
 132                 replacementButtons = [gtk.Button("Test")]
 133                 menu = hildonize.hildonize_menu(
 134                         self._window,
 135                         self._widgetTree.get_widget("dialpad_menubar"),
 136                         replacementButtons
 137                 )
 138
 139                 if hildonize.IS_HILDON_SUPPORTED:
 140                         self._window.connect("key-press-event", self._on_key_press)
 141                         self._window.connect("window-state-event", self._on_window_state_change)
 142                 else:
 143                         logging.warning("No hildonization support")
 144
 145                 hildonize.set_application_title(self._window, "%s" % constants.__pretty_app_name__)
 146
 147                 self._window.connect("destroy", self._on_close)
 148                 self._window.set_default_size(800, 300)
 149                 self._window.show_all()
 150
 151                 self._loginSink = gtk_toolbox.threaded_stage(
 152                         gtk_toolbox.comap(
 153                                 self._attempt_login,
 154                                 gtk_toolbox.null_sink(),
 155                         )
 156                 )
 157
 158                 backgroundSetup = threading.Thread(target=self._idle_setup)
 159                 backgroundSetup.setDaemon(True)
 160                 backgroundSetup.start()
 161
 162         def _idle_setup(self):
 163                 """
 164                 If something can be done after the UI loads, push it here so it's not blocking the UI
 165                 """
 166                 # Barebones UI handlers
 167                 try:
 168                         import null_backend
 169                         import null_views
 170
 171                         self._phoneBackends = {self.NULL_BACKEND: null_backend.NullDialer()}
 172                         with gtk_toolbox.gtk_lock():
 173                                 self._dialpads = {self.NULL_BACKEND: null_views.Dialpad(self._widgetTree)}
 174                                 self._accountViews = {self.NULL_BACKEND: null_views.AccountInfo(self._widgetTree)}
 175                                 self._recentViews = {self.NULL_BACKEND: null_views.RecentCallsView(self._widgetTree)}
 176                                 self._messagesViews = {self.NULL_BACKEND: null_views.MessagesView(self._widgetTree)}
 177                                 self._contactsViews = {self.NULL_BACKEND: null_views.ContactsView(self._widgetTree)}
 178
 179                                 self._dialpads[self._selectedBackendId].enable()
 180                                 self._accountViews[self._selectedBackendId].enable()
 181                                 self._recentViews[self._selectedBackendId].enable()
 182                                 self._messagesViews[self._selectedBackendId].enable()
 183                                 self._contactsViews[self._selectedBackendId].enable()
 184                 except Exception, e:
 185                         with gtk_toolbox.gtk_lock():
 186                                 self._errorDisplay.push_exception()
 187
 188                 # Setup maemo specifics
 189                 try:
 190                         try:
 191                                 import osso
 192                         except (ImportError, OSError):
 193                                 osso = None
 194                         self._osso = None
 195                         if osso is not None:
 196                                 self._osso = osso.Context(constants.__app_name__, constants.__version__, False)
 197                                 device = osso.DeviceState(self._osso)
 198                                 device.set_device_state_callback(self._on_device_state_change, 0)
 199                         else:
 200                                 logging.warning("No device state support")
 201
 202                         try:
 203                                 import alarm_handler
 204                                 self._alarmHandler = alarm_handler.AlarmHandler()
 205                         except (ImportError, OSError):
 206                                 alarm_handler = None
 207                         except Exception:
 208                                 with gtk_toolbox.gtk_lock():
 209                                         self._errorDisplay.push_exception()
 210                                 alarm_handler = None
 211                                 logging.warning("No notification support")
 212                         if hildonize.IS_HILDON_SUPPORTED:
 213                                 try:
 214                                         import led_handler
 215                                         self._ledHandler = led_handler.LedHandler()
 216                                 except Exception, e:
 217                                         logging.exception('LED Handling failed: "%s"' % str(e))
 218                                         self._ledHandler = None
 219                         else:
 220                                 self._ledHandler = None
 221
 222                         try:
 223                                 import conic
 224                         except (ImportError, OSError):
 225                                 conic = None
 226                         self._connection = None
 227                         if conic is not None:
 228                                 self._connection = conic.Connection()
 229                                 self._connection.connect("connection-event", self._on_connection_change, constants.__app_magic__)
 230                                 self._connection.request_connection(conic.CONNECT_FLAG_NONE)
 231                         else:
 232                                 logging.warning("No connection support")
 233                 except Exception, e:
 234                         with gtk_toolbox.gtk_lock():
 235                                 self._errorDisplay.push_exception()
 236
 237                 # Setup costly backends
 238                 try:
 239                         import gv_backend
 240                         import file_backend
 241                         import gv_views
 242
 243                         try:
 244                                 os.makedirs(constants._data_path_)
 245                         except OSError, e:
 246                                 if e.errno != 17:
 247                                         raise
 248                         gvCookiePath = os.path.join(constants._data_path_, "gv_cookies.txt")
 249
 250                         self._phoneBackends.update({
 251                                 self.GV_BACKEND: gv_backend.GVDialer(gvCookiePath),
 252                         })
 253                         with gtk_toolbox.gtk_lock():
 254                                 unifiedDialpad = gv_views.Dialpad(self._widgetTree, self._errorDisplay)
 255                                 self._dialpads.update({
 256                                         self.GV_BACKEND: unifiedDialpad,
 257                                 })
 258                                 self._accountViews.update({
 259                                         self.GV_BACKEND: gv_views.AccountInfo(
 260                                                 self._widgetTree, self._phoneBackends[self.GV_BACKEND], self._alarmHandler, self._errorDisplay
 261                                         ),
 262                                 })
 263                                 self._accountViews[self.GV_BACKEND].save_everything = self._save_settings
 264                                 self._recentViews.update({
 265                                         self.GV_BACKEND: gv_views.RecentCallsView(
 266                                                 self._widgetTree, self._phoneBackends[self.GV_BACKEND], self._errorDisplay
 267                                         ),
 268                                 })
 269                                 self._messagesViews.update({
 270                                         self.GV_BACKEND: gv_views.MessagesView(
 271                                                 self._widgetTree, self._phoneBackends[self.GV_BACKEND], self._errorDisplay
 272                                         ),
 273                                 })
 274                                 self._contactsViews.update({
 275                                         self.GV_BACKEND: gv_views.ContactsView(
 276                                                 self._widgetTree, self._phoneBackends[self.GV_BACKEND], self._errorDisplay
 277                                         ),
 278                                 })
 279
 280                         fsContactsPath = os.path.join(constants._data_path_, "contacts")
 281                         fileBackend = file_backend.FilesystemAddressBookFactory(fsContactsPath)
 282
 283                         self._dialpads[self.GV_BACKEND].number_selected = self._select_action
 284                         self._recentViews[self.GV_BACKEND].number_selected = self._select_action
 285                         self._messagesViews[self.GV_BACKEND].number_selected = self._select_action
 286                         self._contactsViews[self.GV_BACKEND].number_selected = self._select_action
 287
 288                         addressBooks = [
 289                                 self._phoneBackends[self.GV_BACKEND],
 290                                 fileBackend,
 291                         ]
 292                         mergedBook = gv_views.MergedAddressBook(addressBooks, gv_views.MergedAddressBook.advanced_lastname_sorter)
 293                         self._contactsViews[self.GV_BACKEND].append(mergedBook)
 294                         self._contactsViews[self.GV_BACKEND].extend(addressBooks)
 295                         self._contactsViews[self.GV_BACKEND].open_addressbook(*self._contactsViews[self.GV_BACKEND].get_addressbooks().next()[0][0:2])
 296
 297                         callbackMapping = {
 298                                 "on_paste": self._on_paste,
 299                                 "on_refresh": self._on_menu_refresh,
 300                                 "on_clearcookies_clicked": self._on_clearcookies_clicked,
 301                                 "on_about_activate": self._on_about_activate,
 302                         }
 303                         if hildonize.GTK_MENU_USED:
 304                                 self._widgetTree.signal_autoconnect(callbackMapping)
 305                         self._notebook.connect("switch-page", self._on_notebook_switch_page)
 306                         self._widgetTree.get_widget("clearcookies").connect("clicked", self._on_clearcookies_clicked)
 307
 308                         with gtk_toolbox.gtk_lock():
 309                                 self._originalCurrentLabels = [
 310                                         self._notebook.get_tab_label(self._notebook.get_nth_page(pageIndex)).get_text()
 311                                         for pageIndex in xrange(self._notebook.get_n_pages())
 312                                 ]
 313                                 self._notebookTapHandler = gtk_toolbox.TapOrHold(self._notebook)
 314                                 self._notebookTapHandler.enable()
 315                         self._notebookTapHandler.on_tap = self._reset_tab_refresh
 316                         self._notebookTapHandler.on_hold = self._on_tab_refresh
 317                         self._notebookTapHandler.on_holding = self._set_tab_refresh
 318                         self._notebookTapHandler.on_cancel = self._reset_tab_refresh
 319
 320                         self._initDone = True
 321
 322                         config = ConfigParser.SafeConfigParser()
 323                         config.read(constants._user_settings_)
 324                         with gtk_toolbox.gtk_lock():
 325                                 self.load_settings(config)
 326                 except Exception, e:
 327                         with gtk_toolbox.gtk_lock():
 328                                 self._errorDisplay.push_exception()
 329                 finally:
 330                         self._spawn_attempt_login(2)
 331
 332         def _spawn_attempt_login(self, *args):
 333                 self._loginSink.send(args)
 334
 335         def _attempt_login(self, numOfAttempts = 10, force = False):
 336                 """
 337                 @note This must be run outside of the UI lock
 338                 """
 339                 try:
 340                         assert 0 <= numOfAttempts, "That was pointless having 0 or less login attempts"
 341                         assert self._initDone, "Attempting login before app is fully loaded"
 342
 343                         serviceId = self.NULL_BACKEND
 344                         loggedIn = False
 345                         if not force:
 346                                 try:
 347                                         self.refresh_session()
 348                                         serviceId = self._defaultBackendId
 349                                         loggedIn = True
 350                                 except Exception, e:
 351                                         logging.exception('Session refresh failed with the following message "%s"' % str(e))
 352
 353                         if not loggedIn:
 354                                 loggedIn, serviceId = self._login_by_user(numOfAttempts)
 355
 356                         with gtk_toolbox.gtk_lock():
 357                                 self._change_loggedin_status(serviceId)
 358                                 if loggedIn:
 359                                         hildonize.show_information_banner(self._window, "Logged In")
 360                 except Exception, e:
 361                         with gtk_toolbox.gtk_lock():
 362                                 self._errorDisplay.push_exception()
 363
 364         def refresh_session(self):
 365                 """
 366                 @note Thread agnostic
 367                 """
 368                 assert self._initDone, "Attempting login before app is fully loaded"
 369
 370                 loggedIn = False
 371                 if not loggedIn:
 372                         loggedIn = self._login_by_cookie()
 373                 if not loggedIn:
 374                         loggedIn = self._login_by_settings()
 375
 376                 if not loggedIn:
 377                         raise RuntimeError("Login Failed")
 378
 379         def _login_by_cookie(self):
 380                 """
 381                 @note Thread agnostic
 382                 """
 383                 loggedIn = self._phoneBackends[self._defaultBackendId].is_authed()
 384                 if loggedIn:
 385                         logging.info("Logged into %r through cookies" % self._phoneBackends[self._defaultBackendId])
 386                 return loggedIn
 387
 388         def _login_by_settings(self):
 389                 """
 390                 @note Thread agnostic
 391                 """
 392                 username, password = self._credentials
 393                 loggedIn = self._phoneBackends[self._defaultBackendId].login(username, password)
 394                 if loggedIn:
 395                         self._credentials = username, password
 396                         logging.info("Logged into %r through settings" % self._phoneBackends[self._defaultBackendId])
 397                 return loggedIn
 398
 399         def _login_by_user(self, numOfAttempts):
 400                 """
 401                 @note This must be run outside of the UI lock
 402                 """
 403                 loggedIn, (username, password) = False, self._credentials
 404                 tmpServiceId = self.GV_BACKEND
 405                 for attemptCount in xrange(numOfAttempts):
 406                         if loggedIn:
 407                                 break
 408                         with gtk_toolbox.gtk_lock():
 409                                 credentials = self._credentialsDialog.request_credentials(
 410                                         defaultCredentials = self._credentials
 411                                 )
 412                                 if not self._phoneBackends[tmpServiceId].get_callback_number():
 413                                         # subtle reminder to the users to configure things
 414                                         self._notebook.set_current_page(self.ACCOUNT_TAB)
 415                         username, password = credentials
 416                         loggedIn = self._phoneBackends[tmpServiceId].login(username, password)
 417
 418                 if loggedIn:
 419                         serviceId = tmpServiceId
 420                         self._credentials = username, password
 421                         logging.info("Logged into %r through user request" % self._phoneBackends[serviceId])
 422                 else:
 423                         serviceId = self.NULL_BACKEND
 424                         self._notebook.set_current_page(self.ACCOUNT_TAB)
 425
 426                 return loggedIn, serviceId
 427
 428         def _select_action(self, action, number, message):
 429                 self.refresh_session()
 430                 if action == "select":
 431                         self._dialpads[self._selectedBackendId].set_number(number)
 432                         self._notebook.set_current_page(self.KEYPAD_TAB)
 433                 elif action == "dial":
 434                         self._on_dial_clicked(number)
 435                 elif action == "sms":
 436                         self._on_sms_clicked(number, message)
 437                 else:
 438                         assert False, "Unknown action: %s" % action
 439
 440         def _change_loggedin_status(self, newStatus):
 441                 oldStatus = self._selectedBackendId
 442                 if oldStatus == newStatus:
 443                         return
 444
 445                 self._dialpads[oldStatus].disable()
 446                 self._accountViews[oldStatus].disable()
 447                 self._recentViews[oldStatus].disable()
 448                 self._messagesViews[oldStatus].disable()
 449                 self._contactsViews[oldStatus].disable()
 450
 451                 self._dialpads[newStatus].enable()
 452                 self._accountViews[newStatus].enable()
 453                 self._recentViews[newStatus].enable()
 454                 self._messagesViews[newStatus].enable()
 455                 self._contactsViews[newStatus].enable()
 456
 457                 if self._phoneBackends[self._selectedBackendId].get_callback_number() is None:
 458                         self._phoneBackends[self._selectedBackendId].set_sane_callback()
 459                 self._accountViews[self._selectedBackendId].update()
 460                 self._refresh_active_tab()
 461
 462                 self._selectedBackendId = newStatus
 463
 464         def load_settings(self, config):
 465                 """
 466                 @note UI Thread
 467                 """
 468                 try:
 469                         self._defaultBackendId = config.getint(constants.__pretty_app_name__, "active")
 470                         blobs = (
 471                                 config.get(constants.__pretty_app_name__, "bin_blob_%i" % i)
 472                                 for i in xrange(len(self._credentials))
 473                         )
 474                         creds = (
 475                                 base64.b64decode(blob)
 476                                 for blob in blobs
 477                         )
 478                         self._credentials = tuple(creds)
 479
 480                         if self._alarmHandler is not None:
 481                                 self._alarmHandler.load_settings(config, "alarm")
 482                 except ConfigParser.NoOptionError, e:
 483                         logging.exception(
 484                                 "Settings file %s is missing section %s" % (
 485                                         constants._user_settings_,
 486                                         e.section,
 487                                 ),
 488                         )
 489                 except ConfigParser.NoSectionError, e:
 490                         logging.exception(
 491                                 "Settings file %s is missing section %s" % (
 492                                         constants._user_settings_,
 493                                         e.section,
 494                                 ),
 495                         )
 496
 497                 for backendId, view in itertools.chain(
 498                         self._dialpads.iteritems(),
 499                         self._accountViews.iteritems(),
 500                         self._messagesViews.iteritems(),
 501                         self._recentViews.iteritems(),
 502                         self._contactsViews.iteritems(),
 503                 ):
 504                         sectionName = "%s - %s" % (backendId, view.name())
 505                         try:
 506                                 view.load_settings(config, sectionName)
 507                         except ConfigParser.NoOptionError, e:
 508                                 logging.exception(
 509                                         "Settings file %s is missing section %s" % (
 510                                                 constants._user_settings_,
 511                                                 e.section,
 512                                         ),
 513                                 )
 514                         except ConfigParser.NoSectionError, e:
 515                                 logging.exception(
 516                                         "Settings file %s is missing section %s" % (
 517                                                 constants._user_settings_,
 518                                                 e.section,
 519                                         ),
 520                                 )
 521
 522                 try:
 523                         previousOrientation = config.getint(constants.__pretty_app_name__, "orientation")
 524                         if previousOrientation == gtk.ORIENTATION_HORIZONTAL:
 525                                 hildonize.window_to_landscape(self._window)
 526                         elif previousOrientation == gtk.ORIENTATION_VERTICAL:
 527                                 hildonize.window_to_portrait(self._window)
 528                 except ConfigParser.NoOptionError, e:
 529                         logging.exception(
 530                                 "Settings file %s is missing section %s" % (
 531                                         constants._user_settings_,
 532                                         e.section,
 533                                 ),
 534                         )
 535                 except ConfigParser.NoSectionError, e:
 536                         logging.exception(
 537                                 "Settings file %s is missing section %s" % (
 538                                         constants._user_settings_,
 539                                         e.section,
 540                                 ),
 541                         )
 542
 543         def save_settings(self, config):
 544                 """
 545                 @note Thread Agnostic
 546                 """
 547                 config.add_section(constants.__pretty_app_name__)
 548                 config.set(constants.__pretty_app_name__, "active", str(self._selectedBackendId))
 549                 config.set(constants.__pretty_app_name__, "orientation", str(int(gtk_toolbox.get_screen_orientation())))
 550                 for i, value in enumerate(self._credentials):
 551                         blob = base64.b64encode(value)
 552                         config.set(constants.__pretty_app_name__, "bin_blob_%i" % i, blob)
 553                 config.add_section("alarm")
 554                 if self._alarmHandler is not None:
 555                         self._alarmHandler.save_settings(config, "alarm")
 556
 557                 for backendId, view in itertools.chain(
 558                         self._dialpads.iteritems(),
 559                         self._accountViews.iteritems(),
 560                         self._messagesViews.iteritems(),
 561                         self._recentViews.iteritems(),
 562                         self._contactsViews.iteritems(),
 563                 ):
 564                         sectionName = "%s - %s" % (backendId, view.name())
 565                         config.add_section(sectionName)
 566                         view.save_settings(config, sectionName)
 567
 568         def _save_settings(self):
 569                 """
 570                 @note Thread Agnostic
 571                 """
 572                 config = ConfigParser.SafeConfigParser()
 573                 self.save_settings(config)
 574                 with open(constants._user_settings_, "wb") as configFile:
 575                         config.write(configFile)
 576
 577         def _refresh_active_tab(self):
 578                 pageIndex = self._notebook.get_current_page()
 579                 if pageIndex == self.CONTACTS_TAB:
 580                         self._contactsViews[self._selectedBackendId].update(force=True)
 581                 elif pageIndex == self.RECENT_TAB:
 582                         self._recentViews[self._selectedBackendId].update(force=True)
 583                 elif pageIndex == self.MESSAGES_TAB:
 584                         self._messagesViews[self._selectedBackendId].update(force=True)
 585
 586                 if pageIndex in (self.RECENT_TAB, self.MESSAGES_TAB):
 587                         if self._ledHandler is not None:
 588                                 self._ledHandler.off()
 589
 590         def _on_close(self, *args, **kwds):
 591                 try:
 592                         if self._osso is not None:
 593                                 self._osso.close()
 594
 595                         if self._initDone:
 596                                 self._save_settings()
 597                 finally:
 598                         gtk.main_quit()
 599
 600         def _on_device_state_change(self, shutdown, save_unsaved_data, memory_low, system_inactivity, message, userData):
 601                 """
 602                 For shutdown or save_unsaved_data, our only state is cookies and I think the cookie manager handles that for us.
 603                 For system_inactivity, we have no background tasks to pause
 604
 605                 @note Hildon specific
 606                 """
 607                 try:
 608                         if memory_low:
 609                                 for backendId in self.BACKENDS:
 610                                         self._phoneBackends[backendId].clear_caches()
 611                                 self._contactsViews[self._selectedBackendId].clear_caches()
 612                                 gc.collect()
 613
 614                         if save_unsaved_data or shutdown:
 615                                 self._save_settings()
 616                 except Exception, e:
 617                         self._errorDisplay.push_exception()
 618
 619         def _on_connection_change(self, connection, event, magicIdentifier):
 620                 """
 621                 @note Hildon specific
 622                 """
 623                 try:
 624                         import conic
 625
 626                         status = event.get_status()
 627                         error = event.get_error()
 628                         iap_id = event.get_iap_id()
 629                         bearer = event.get_bearer_type()
 630
 631                         if status == conic.STATUS_CONNECTED:
 632                                 if self._initDone:
 633                                         self._spawn_attempt_login(2)
 634                         elif status == conic.STATUS_DISCONNECTED:
 635                                 if self._initDone:
 636                                         self._defaultBackendId = self._selectedBackendId
 637                                         self._change_loggedin_status(self.NULL_BACKEND)
 638                 except Exception, e:
 639                         self._errorDisplay.push_exception()
 640
 641         def _on_window_state_change(self, widget, event, *args):
 642                 """
 643                 @note Hildon specific
 644                 """
 645                 try:
 646                         if event.new_window_state & gtk.gdk.WINDOW_STATE_FULLSCREEN:
 647                                 self._isFullScreen = True
 648                         else:
 649                                 self._isFullScreen = False
 650                 except Exception, e:
 651                         self._errorDisplay.push_exception()
 652
 653         def _on_key_press(self, widget, event, *args):
 654                 """
 655                 @note Hildon specific
 656                 """
 657                 try:
 658                         if event.keyval == gtk.keysyms.F6:
 659                                 if self._isFullScreen:
 660                                         self._window.unfullscreen()
 661                                 else:
 662                                         self._window.fullscreen()
 663                 except Exception, e:
 664                         self._errorDisplay.push_exception()
 665
 666         def _on_clearcookies_clicked(self, *args):
 667                 try:
 668                         self._phoneBackends[self._selectedBackendId].logout()
 669                         self._accountViews[self._selectedBackendId].clear()
 670                         self._recentViews[self._selectedBackendId].clear()
 671                         self._messagesViews[self._selectedBackendId].clear()
 672                         self._contactsViews[self._selectedBackendId].clear()
 673                         self._change_loggedin_status(self.NULL_BACKEND)
 674
 675                         self._spawn_attempt_login(2, True)
 676                 except Exception, e:
 677                         self._errorDisplay.push_exception()
 678
 679         def _on_notebook_switch_page(self, notebook, page, pageIndex):
 680                 try:
 681                         self._reset_tab_refresh()
 682
 683                         didRecentUpdate = False
 684                         didMessagesUpdate = False
 685
 686                         if pageIndex == self.RECENT_TAB:
 687                                 didRecentUpdate = self._recentViews[self._selectedBackendId].update()
 688                         elif pageIndex == self.MESSAGES_TAB:
 689                                 didMessagesUpdate = self._messagesViews[self._selectedBackendId].update()
 690                         elif pageIndex == self.CONTACTS_TAB:
 691                                 self._contactsViews[self._selectedBackendId].update()
 692                         elif pageIndex == self.ACCOUNT_TAB:
 693                                 self._accountViews[self._selectedBackendId].update()
 694
 695                         if didRecentUpdate or didMessagesUpdate:
 696                                 if self._ledHandler is not None:
 697                                         self._ledHandler.off()
 698                 except Exception, e:
 699                         self._errorDisplay.push_exception()
 700
 701         def _set_tab_refresh(self, *args):
 702                 try:
 703                         pageIndex = self._notebook.get_current_page()
 704                         child = self._notebook.get_nth_page(pageIndex)
 705                         self._notebook.get_tab_label(child).set_text("Refresh?")
 706                 except Exception, e:
 707                         self._errorDisplay.push_exception()
 708                 return False
 709
 710         def _reset_tab_refresh(self, *args):
 711                 try:
 712                         pageIndex = self._notebook.get_current_page()
 713                         child = self._notebook.get_nth_page(pageIndex)
 714                         self._notebook.get_tab_label(child).set_text(self._originalCurrentLabels[pageIndex])
 715                 except Exception, e:
 716                         self._errorDisplay.push_exception()
 717                 return False
 718
 719         def _on_tab_refresh(self, *args):
 720                 try:
 721                         self._refresh_active_tab()
 722                         self._reset_tab_refresh()
 723                 except Exception, e:
 724                         self._errorDisplay.push_exception()
 725                 return False
 726
 727         def _on_sms_clicked(self, number, message):
 728                 try:
 729                         assert number, "No number specified"
 730                         assert message, "Empty message"
 731                         try:
 732                                 loggedIn = self._phoneBackends[self._selectedBackendId].is_authed()
 733                         except Exception, e:
 734                                 loggedIn = False
 735                                 self._errorDisplay.push_exception()
 736                                 return
 737
 738                         if not loggedIn:
 739                                 self._errorDisplay.push_message(
 740                                         "Backend link with GoogleVoice is not working, please try again"
 741                                 )
 742                                 return
 743
 744                         dialed = False
 745                         try:
 746                                 self._phoneBackends[self._selectedBackendId].send_sms(number, message)
 747                                 hildonize.show_information_banner(self._window, "Sending to %s" % number)
 748                                 dialed = True
 749                         except Exception, e:
 750                                 self._errorDisplay.push_exception()
 751
 752                         if dialed:
 753                                 self._dialpads[self._selectedBackendId].clear()
 754                 except Exception, e:
 755                         self._errorDisplay.push_exception()
 756
 757         def _on_dial_clicked(self, number):
 758                 try:
 759                         assert number, "No number to call"
 760                         try:
 761                                 loggedIn = self._phoneBackends[self._selectedBackendId].is_authed()
 762                         except Exception, e:
 763                                 loggedIn = False
 764                                 self._errorDisplay.push_exception()
 765                                 return
 766
 767                         if not loggedIn:
 768                                 self._errorDisplay.push_message(
 769                                         "Backend link with GoogleVoice is not working, please try again"
 770                                 )
 771                                 return
 772
 773                         dialed = False
 774                         try:
 775                                 assert self._phoneBackends[self._selectedBackendId].get_callback_number() != "", "No callback number specified"
 776                                 self._phoneBackends[self._selectedBackendId].dial(number)
 777                                 hildonize.show_information_banner(self._window, "Calling %s" % number)
 778                                 dialed = True
 779                         except Exception, e:
 780                                 self._errorDisplay.push_exception()
 781
 782                         if dialed:
 783                                 self._dialpads[self._selectedBackendId].clear()
 784                 except Exception, e:
 785                         self._errorDisplay.push_exception()
 786
 787         def _on_menu_refresh(self, *args):
 788                 try:
 789                         self._refresh_active_tab()
 790                 except Exception, e:
 791                         self._errorDisplay.push_exception()
 792
 793         def _on_paste(self, *args):
 794                 try:
 795                         contents = self._clipboard.wait_for_text()
 796                         if contents is not None:
 797                                 self._dialpads[self._selectedBackendId].set_number(contents)
 798                 except Exception, e:
 799                         self._errorDisplay.push_exception()
 800
 801         def _on_about_activate(self, *args):
 802                 try:
 803                         dlg = gtk.AboutDialog()
 804                         dlg.set_name(constants.__pretty_app_name__)
 805                         dlg.set_version("%s-%d" % (constants.__version__, constants.__build__))
 806                         dlg.set_copyright("Copyright 2008 - LGPL")
 807                         dlg.set_comments("Dialcentral is a touch screen enhanced interface to your GoogleVoice account.  This application is not affiliated with Google in any way")
 808                         dlg.set_website("http://gc-dialer.garage.maemo.org/")
 809                         dlg.set_authors(["<z2n@merctech.com>", "Eric Warnke <ericew@gmail.com>", "Ed Page <edpage@byu.net>"])
 810                         dlg.run()
 811                         dlg.destroy()
 812                 except Exception, e:
 813                         self._errorDisplay.push_exception()
 814
 815
 816 def run_doctest():
 817         import doctest
 818
 819         failureCount, testCount = doctest.testmod()
 820         if not failureCount:
 821                 print "Tests Successful"
 822                 sys.exit(0)
 823         else:
 824                 sys.exit(1)
 825
 826
 827 def run_dialpad():
 828         _lock_file = os.path.join(constants._data_path_, ".lock")
 829         #with gtk_toolbox.flock(_lock_file, 0):
 830         gtk.gdk.threads_init()
 831
 832         if hildonize.IS_HILDON_SUPPORTED:
 833                 gtk.set_application_name(constants.__pretty_app_name__)
 834         handle = Dialcentral()
 835         gtk.main()
 836
 837
 838 class DummyOptions(object):
 839
 840         def __init__(self):
 841                 self.test = False
 842
 843
 844 if __name__ == "__main__":
 845         logging.basicConfig(level=logging.DEBUG)
 846         try:
 847                 if len(sys.argv) > 1:
 848                         try:
 849                                 import optparse
 850                         except ImportError:
 851                                 optparse = None
 852
 853                         if optparse is not None:
 854                                 parser = optparse.OptionParser()
 855                                 parser.add_option("-t", "--test", action="store_true", dest="test", help="Run tests")
 856                                 (commandOptions, commandArgs) = parser.parse_args()
 857                 else:
 858                         commandOptions = DummyOptions()
 859                         commandArgs = []
 860
 861                 if commandOptions.test:
 862                         run_doctest()
 863                 else:
 864                         run_dialpad()
 865         finally:
 866                 logging.shutdown()