def connect(self, headers={}):
if self.__client is None:
if not BBLocalDevice.isPoweredOn():
raise OBEXError(_kOBEXSessionNoTransportError,
"Bluetooth device not available")
self.__delegate = _BBOBEXClientDelegate.alloc().initWithCallback_(
self._finishedrequest)
self.__client = BBBluetoothOBEXClient.alloc(
).initWithRemoteDeviceAddress_channelID_delegate_(
_macutil.createbtdevaddr(self.__serveraddr[0]),
self.__serveraddr[1], self.__delegate)
if self.__obexsession is not None:
self.__client.performSelector_withObject_(
"setOBEXSession:", self.__obexsession)
self.__reset()
headerset = _headersdicttoset(headers)
r = self.__client.sendConnectRequestWithHeaders_(headerset)
if r != _kOBEXSuccess:
self.__closetransport()
raise OBEXError(r,
"error starting Connect request (%s)" % errdesc(r))
_macutil.waituntil(self._done)
if self.__error != _kOBEXSuccess:
self.__closetransport()
raise OBEXError(
self.__error,
"error during Connect request (%s)" % errdesc(self.__error))
resp = self.__getresponse()
if resp.code != _obexcommon.OK:
self.__closetransport()
return resp
def __setUp(self):
if self.__client is None:
import bluetooth
self.__sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM)
try:
self.__sock.connect(
(self.__serveraddr[0], self.__serveraddr[1]))
except bluetooth.BluetoothError, e:
raise OBEXError(str(e))
try:
self.__client = _lightblueobex.OBEXClient(self.__sock.fileno())
except IOError, e:
raise OBEXError(str(e))
def setpath(self, headers, cdtoparent=False, createdirs=False):
self.__checkconnected()
self.__reset()
headerset = _headersdicttoset(headers)
r = self.__client.sendSetPathRequestWithHeaders_changeToParentDirectoryFirst_createDirectoriesIfNeeded_(headerset, cdtoparent, createdirs)
if r != _kOBEXSuccess:
raise OBEXError(r, "error starting SetPath request (%s)" %
errdesc(r))
_macutil.waituntil(self._done)
if self.__error != _kOBEXSuccess:
raise OBEXError(self.__error, "error during SetPath request (%s)" %
errdesc(self.__error))
return self.__getresponse()
def delete(self, headers):
self.__checkconnected()
self.__reset()
headerset = _headersdicttoset(headers)
r = self.__client.sendPutRequestWithHeaders_readFromStream_(headerset,
None)
if r != _kOBEXSuccess:
raise OBEXError(r, "error starting Delete request (%s)" %
errdesc(r))
_macutil.waituntil(self._done)
if self.__error != _kOBEXSuccess:
raise OBEXError(self.__error, "error during Delete request (%s)" %
errdesc(self.__error))
return self.__getresponse()
def _recvfile(sock, localpath):
# PyS60's bt_obex_receive() won't receive the file if given a file path
# that already exists (it tells the client there's a conflict error). So
# we need to handle this somehow, and preferably backup the original file
# so that we can put it back if the recv fails.
if os.path.isfile(localpath):
# if given an existing path, rename existing file
temppath = _tempfilename(localpath)
os.rename(localpath, temppath)
else:
temppath = None
try:
# receive a file (get internal _sock cos sock is our own SocketWrapper
# object)
_socket.bt_obex_receive(sock._sock, unicode(localpath))
except _socket.error, e:
try:
if temppath is not None:
# recv failed, put original file back
os.rename(temppath, localpath)
finally:
# if the renaming of the original file fails, this will still
# get raised
raise OBEXError(str(e))
def sendfile(address, channel, source):
if not _lightbluecommon._isbtaddr(address):
raise TypeError("address '%s' is not a valid bluetooth address" %
address)
if not isinstance(channel, int):
raise TypeError("channel must be int, was %s" % type(channel))
if not isinstance(source, types.StringTypes) and \
not hasattr(source, "read"):
raise TypeError("source must be string or file-like object with read() method")
if isinstance(source, types.StringTypes):
headers = {"name": source}
fileobj = file(source, "rb")
closefileobj = True
else:
if hasattr(source, "name"):
headers = {"name": source.name}
fileobj = source
closefileobj = False
client = OBEXClient(address, channel)
client.connect()
try:
resp = client.put(headers, fileobj)
finally:
if closefileobj:
fileobj.close()
try:
client.disconnect()
except:
pass # always ignore disconnection errors
if resp.code != _obexcommon.OK:
raise OBEXError("server denied the Put request")
def delete(self, headers):
self.__checkconnected()
try:
resp = self.__client.request(_lightblueobex.PUT,
self.__convertheaders(headers), None)
except IOError, e:
raise OBEXError(str(e))
def connect(self, headers={}):
if self.__client is None:
self.__setUp()
try:
resp = self.__client.request(_lightblueobex.CONNECT,
self.__convertheaders(headers), None)
except IOError, e:
raise OBEXError(str(e))
def sendfile(address, channel, source):
if not isinstance(source, (types.StringTypes, types.FileType)):
raise TypeError("source must be string or built-in file object")
if isinstance(source, types.StringTypes):
try:
_socket.bt_obex_send_file(address, channel, unicode(source))
except Exception, e:
raise OBEXError(str(e))
def get(self, headers, fileobj):
if not hasattr(fileobj, "write"):
raise TypeError("file-like must have write() method")
self.__checkconnected()
try:
resp = self.__client.request(_lightblueobex.GET,
self.__convertheaders(headers), None,
fileobj)
except IOError, e:
raise OBEXError(str(e))
def disconnect(self, headers={}):
self.__checkconnected()
self.__reset()
try:
headerset = _headersdicttoset(headers)
r = self.__client.sendDisconnectRequestWithHeaders_(headerset)
if r != _kOBEXSuccess:
raise OBEXError(
r, "error starting Disconnect request (%s)" % errdesc(r))
_macutil.waituntil(self._done)
if self.__error != _kOBEXSuccess:
raise OBEXError(
self.__error, "error during Disconnect request (%s)" %
errdesc(self.__error))
finally:
# close channel regardless of disconnect result
self.__closetransport()
return self.__getresponse()
def get(self, headers, fileobj):
if not hasattr(fileobj, "write"):
raise TypeError("file-like object must have write() method")
self.__checkconnected()
self.__reset()
headerset = _headersdicttoset(headers)
delegate = _macutil.BBFileLikeObjectWriter.alloc().initWithFileLikeObject_(fileobj)
outstream = BBStreamingOutputStream.alloc().initWithDelegate_(delegate)
outstream.open()
r = self.__client.sendGetRequestWithHeaders_writeToStream_(
headerset, outstream)
if r != _kOBEXSuccess:
raise OBEXError(r, "error starting Get request (%s)" % errdesc(r))
_macutil.waituntil(self._done)
if self.__error != _kOBEXSuccess:
raise OBEXError(self.__error, "error during Get request (%s)" %
errdesc(self.__error))
return self.__getresponse()
def run(self):
self.__server.run()
# wait until client sends a file, or an error occurs
_macutil.waituntil(lambda: self.__gotfile or self.__error is not None)
# wait briefly for a disconnect request (client may have decided to just
# close the connection without sending a disconnect request)
if self.__error is None:
ok = _macutil.waituntil(lambda: self.__gotdisconnect, 3)
if ok:
_macutil.waituntil(lambda: self.__disconnected)
# only raise OBEXError if file was not received
if not self.__gotfile:
if self.__error is not None:
raise OBEXError(self.__error[0], self.__error[1])
# if client connected but didn't send PUT
raise OBEXError(_kOBEXGeneralError, "client did not send a file")
def put(self, headers, fileobj):
if not hasattr(fileobj, "read"):
raise TypeError("file-like object must have read() method")
self.__checkconnected()
self.__reset()
headerset = _headersdicttoset(headers)
self.fileobj = fileobj
self.__fileobjdelegate = _macutil.BBFileLikeObjectReader.alloc().initWithFileLikeObject_(fileobj)
self.instream = BBStreamingInputStream.alloc().initWithDelegate_(self.__fileobjdelegate)
self.instream.open()
r = self.__client.sendPutRequestWithHeaders_readFromStream_(
headerset, self.instream)
if r != _kOBEXSuccess:
raise OBEXError(r, "error starting Put request (%s)" % errdesc(r))
_macutil.waituntil(self._done)
if self.__error != _kOBEXSuccess:
raise OBEXError(self.__error, "error during Put request (%s)" %
errdesc(self.__error))
return self.__getresponse()
def disconnect(self, headers={}):
self.__checkconnected()
try:
try:
resp = self.__client.request(_lightblueobex.DISCONNECT,
self.__convertheaders(headers),
None)
except IOError, e:
raise OBEXError(str(e))
finally:
# close bt connection regardless of disconnect response
self.__closetransport()
return self.__createresponse(resp)
def setpath(self, headers, cdtoparent=False, createdirs=False):
self.__checkconnected()
flags = 0
if cdtoparent:
flags |= 1
if not createdirs:
flags |= 2
import array
setpathdata = array.array('B', (flags, 0)) # zero for constants byte
try:
resp = self.__client.request(_lightblueobex.SETPATH,
self.__convertheaders(headers),
buffer(setpathdata))
except IOError, e:
raise OBEXError(str(e))
def run(self):
timeout = 60
self.__gotfile = False
self.__disconnected = False
self.__error = None
while True:
result = self.__server.process(timeout)
if result < 0:
#print "-> error during process()"
if self.__error is None:
self.__error = (OBEXError, "error while running server")
break
if result == 0:
#print "-> process() timed out"
break
if self.__gotfile:
#print "-> got file!"
break
if self.__error is not None and not self.__busy:
#print "-> server error detected..."
break
if self.__gotfile:
# wait briefly for disconnect request
while not self.__disconnected:
if self.__server.process(3) <= 0:
break
if not self.__gotfile:
if self.__error is not None:
exc, msg = self.__error
if exc == IOError:
exc = OBEXError
raise exc(msg)
raise OBEXError("client did not send a file")
def __checkconnected(self):
if self.__client is None:
raise OBEXError(_kOBEXSessionNotConnectedError,
"must connect() before sending other requests")
def __checkconnected(self):
if self.__client is None:
raise OBEXError("must connect() before sending other requests")
else:
# given file object
if hasattr(source, "name"):
localpath = _tempfilename(source.name)
else:
localpath = _tempfilename()
try:
# write the source file object's data into a file, then send it
f = file(localpath, "wb")
f.write(source.read())
f.close()
try:
_socket.bt_obex_send_file(address, channel, unicode(localpath))
except Exception, e:
raise OBEXError(str(e))
finally:
# remove temporary file
if os.path.isfile(localpath):
try:
os.remove(localpath)
except Exception, e:
print "[lightblue.obex] unable to remove temporary file %s: %s" %\
(localpath, str(e))
def recvfile(sock, dest):
if not isinstance(dest, (types.StringTypes, types.FileType)):
raise TypeError("dest must be string or built-in file object")
if isinstance(dest, types.StringTypes):