[directx]

Hi!
Could someone please take a look at the following code and explain to me why this script crashes after the socket.bt_discover() call?

I suspect canvas callbacks but cannot pinpoint the problem. It's probably something very obvious but since I am new to Python on Symbian I cannot see the problem.
Thank you in advance for any helpful information.


[code]
import sys
import e32
import socket
import appuifw

e32.ao_yield()

class KeyboardHandler(object):
def __init__(self, onevent_callback = lambda event:None):
self._keyboard_state = {}
self._downs = {}
self._onevent_callback = onevent_callback

def set__onevent_callback(self, callback):
self._onevent_callback = callback

def handle_event(self, event):
if event['type'] == appuifw.EEventKeyDown:
code = event['scancode']
if not self.is_down(code):
self._downs[code] = self._downs.get(code,0)+1
self._keyboard_state

 = 1
        elif event['type'] == appuifw.EEventKeyUp:
            self._keyboard_state[event['scancode']] = 0
        self._onevent_callback(event)
        
    def is_down(self, scancode):
        return self._keyboard_state.get(scancode, 0)
        
    def pressed(self,scancode):
        if self._downs.get(scancode, 0):
            self._downs[scancode] -= 1
            return True
        return False


class CanvasHandler(object):
    def __init__(self, refresh_callback = lambda rect:None):
        self._refresh_callback = refresh_callback

    def set__refresh_callback(self, callback):
        self._refresh_callback = callback

    def refresh(self, rect):
        self._refresh_callback(rect)


class Application:
    def __init__(self, keyboard_handler, canvas_handler):
        self.lock = e32.Ao_lock()
        
        self.old_title = appuifw.app.title
        appuifw.app.title = u"Application"
        
        self.exit_flag = False
        appuifw.app.exit_key_handler = self.abort
        
        self._canvas = appuifw.Canvas(event_callback = keyboard_handler.handle_event,
                                      redraw_callback = canvas_handler.refresh)  

        appuifw.app.screen = 'normal'
        appuifw.app.body = self._canvas
        
        address,services = socket.bt_discover()

    def event_callback(self, event):
        self.refresh_callback(None)
 
    def refresh_callback(self, rect):
        self._canvas.clear()
        
    def loop(self):
        try:
            while not self.exit_flag:
                self.refresh_callback(None)
                self.lock.wait()
        finally:
            pass
        
    def update(self):
        self.lock.signal()    
        
    def close(self):
        appuifw.app.menu = []
        appuifw.app.body = None
        appuifw.app.exit_key_handler = None
        appuifw.app.title = self.old_title

    def abort(self):
        # Exit-key handler.
        self.exit_flag = True
        self.lock.signal()

       
def main():   
    keyboard_handler = KeyboardHandler()
    canvas_handler = CanvasHandler();
             
    app = Application(keyboard_handler, canvas_handler)
    
    keyboard_handler.set__onevent_callback(app.event_callback)
    canvas_handler.set__refresh_callback(app.refresh_callback)
    
    try:
        app.loop()
    finally:
        app.close()

if __name__ == "__main__":
    main()

[jethro.fn]

This snippet can be found on ORG PyBluez v0.7 (http://org.csail.mit.edu/pybluez/) documentation:

A note on working with Symbian smartphones:
bt_discover in Python for Series 60 will only detect service records
with service class SERIAL_PORT_CLASS and profile SERIAL_PORT_PROFILE

When selecting a device which does not possess these records, socket.bt_discover() raises a confusing and nondescript exception:

... line 64, in __init__
    address,services = socket.bt_discover()
error: (2, 'No such file or directory')

The script works fine when the target device correctly advertises having a serial port profile (tested with Nokia 6600 and a Linux PC).