test/map-client

   1 #!/usr/bin/python
   2
   3 from __future__ import absolute_import, print_function, unicode_literals
   4
   5 from optparse import OptionParser
   6 import os
   7 from pprint import pformat
   8 import sys
   9 import dbus
  10 import dbus.mainloop.glib
  11 try:
  12   from gi.repository import GObject
  13 except ImportError:
  14   import gobject as GObject
  15
  16 BUS_NAME='org.bluez.obex'
  17 PATH = '/org/bluez/obex'
  18 CLIENT_INTERFACE = 'org.bluez.obex.Client1'
  19 SESSION_INTERFACE = 'org.bluez.obex.Session1'
  20 MESSAGE_ACCESS_INTERFACE = 'org.bluez.obex.MessageAccess1'
  21 MESSAGE_INTERFACE = 'org.bluez.obex.Message1'
  22 TRANSFER_INTERFACE = 'org.bluez.obex.Transfer1'
  23
  24 def unwrap(x):
  25     """Hack to unwrap D-Bus values, so that they're easier to read when
  26     printed. Taken from d-feet """
  27
  28     if isinstance(x, list):
  29         return map(unwrap, x)
  30
  31     if isinstance(x, tuple):
  32         return tuple(map(unwrap, x))
  33
  34     if isinstance(x, dict):
  35         return dict([(unwrap(k), unwrap(v)) for k, v in x.iteritems()])
  36
  37     for t in [unicode, str, long, int, float, bool]:
  38         if isinstance(x, t):
  39             return t(x)
  40
  41     return x
  42
  43 def parse_options():
  44         parser.add_option("-d", "--device", dest="device",
  45                         help="Device to connect", metavar="DEVICE")
  46         parser.add_option("-c", "--chdir", dest="new_dir",
  47                         help="Change current directory to DIR", metavar="DIR")
  48         parser.add_option("-l", "--lsdir", action="store_true", dest="ls_dir",
  49                         help="List folders in current directory")
  50         parser.add_option("-v", "--verbose", action="store_true", dest="verbose")
  51         parser.add_option("-L", "--lsmsg", action="store", dest="ls_msg",
  52                         help="List messages in supplied CWD subdir")
  53         parser.add_option("-g", "--get", action="store", dest="get_msg",
  54                         help="Get message contents")
  55         parser.add_option("-p", "--push", action="store", dest="push_msg",
  56                         help="Push message")
  57         parser.add_option("--get-properties", action="store", dest="get_msg_properties",
  58                         help="Get message properties")
  59         parser.add_option("--mark-read", action="store", dest="mark_msg_read",
  60                         help="Marks the messages as read")
  61         parser.add_option("--mark-unread", action="store", dest="mark_msg_unread",
  62                         help="Marks the messages as unread")
  63         parser.add_option("--mark-deleted", action="store", dest="mark_msg_deleted",
  64                         help="Deletes the message from the folder")
  65         parser.add_option("--mark-undeleted", action="store", dest="mark_msg_undeleted",
  66                         help="Undeletes the message")
  67         parser.add_option("-u", "--update-inbox", action="store_true", dest="update_inbox",
  68                         help="Checks for new mails")
  69
  70         return parser.parse_args()
  71
  72 def set_folder(session, new_dir):
  73         session.SetFolder(new_dir)
  74
  75 class MapClient:
  76         def __init__(self, session_path, verbose=False):
  77                 self.progress = 0
  78                 self.transfer_path = None
  79                 self.props = dict()
  80                 self.verbose = verbose
  81                 self.path = session_path
  82                 bus = dbus.SessionBus()
  83                 obj = bus.get_object(BUS_NAME, session_path)
  84                 self.session = dbus.Interface(obj, SESSION_INTERFACE)
  85                 self.map = dbus.Interface(obj, MESSAGE_ACCESS_INTERFACE)
  86                 bus.add_signal_receiver(self.properties_changed,
  87                         dbus_interface="org.freedesktop.DBus.Properties",
  88                         signal_name="PropertiesChanged",
  89                         path_keyword="path")
  90
  91         def create_transfer_reply(self, path, properties):
  92                 self.transfer_path = path
  93                 self.props[path] = properties
  94                 if self.verbose:
  95                         print("Transfer created: %s (file %s)" % (path,
  96                                                         properties["Filename"]))
  97
  98         def generic_reply(self):
  99                 if self.verbose:
 100                         print("Operation succeeded")
 101
 102         def error(self, err):
 103                 print(err)
 104                 mainloop.quit()
 105
 106         def transfer_complete(self, path):
 107                 if self.verbose:
 108                         print("Transfer finished")
 109                 properties = self.props.get(path)
 110                 if properties == None:
 111                         return
 112                 f = open(properties["Filename"], "r")
 113                 os.remove(properties["Filename"])
 114                 print(f.readlines())
 115
 116         def transfer_error(self, path):
 117                 print("Transfer %s error" % path)
 118                 mainloop.quit()
 119
 120         def properties_changed(self, interface, properties, invalidated, path):
 121                 req = self.props.get(path)
 122                 if req == None:
 123                         return
 124
 125                 if properties['Status'] == 'complete':
 126                         self.transfer_complete(path)
 127                         return
 128
 129                 if properties['Status'] == 'error':
 130                         self.transfer_error(path)
 131                         return
 132
 133         def set_folder(self, new_dir):
 134                 self.map.SetFolder(new_dir)
 135
 136         def list_folders(self):
 137                 for i in self.map.ListFolders(dict()):
 138                         print("%s/" % (i["Name"]))
 139
 140         def list_messages(self, folder):
 141                 ret = self.map.ListMessages(folder, dict())
 142                 print(pformat(unwrap(ret)))
 143
 144         def get_message(self, handle):
 145                 self.map.ListMessages("", dict())
 146                 path = self.path + "/message" + handle
 147                 obj = bus.get_object(BUS_NAME, path)
 148                 msg = dbus.Interface(obj, MESSAGE_INTERFACE)
 149                 msg.Get("", True, reply_handler=self.create_transfer_reply,
 150                                                 error_handler=self.error)
 151
 152         def push_message(self, filename):
 153                 self.map.PushMessage(filename, "telecom/msg/outbox", dict(),
 154                                 reply_handler=self.create_transfer_reply,
 155                                 error_handler=self.error)
 156
 157         def get_message_properties(self, handle):
 158                 self.map.ListMessages("", dict())
 159                 path = self.path + "/message" + handle
 160                 obj = bus.get_object(BUS_NAME, path)
 161                 msg = dbus.Interface(obj, "org.freedesktop.DBus.Properties")
 162                 ret = msg.GetAll(MESSAGE_INTERFACE)
 163                 print(pformat(unwrap(ret)))
 164
 165         def set_message_property(self, handle, prop, flag):
 166                 self.map.ListMessages("", dict())
 167                 path = self.path + "/message" + handle
 168                 obj = bus.get_object(BUS_NAME, path)
 169                 msg = dbus.Interface(obj, MESSAGE_INTERFACE)
 170                 msg.SetProperty (prop, flag);
 171
 172         def update_inbox(self):
 173                 self.map.UpdateInbox()
 174
 175
 176 if  __name__ == '__main__':
 177
 178         dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
 179
 180         parser = OptionParser()
 181
 182         (options, args) = parse_options()
 183
 184         if not options.device:
 185                 parser.print_help()
 186                 exit(0)
 187
 188         bus = dbus.SessionBus()
 189         mainloop = GObject.MainLoop()
 190
 191         client = dbus.Interface(bus.get_object(BUS_NAME, PATH),
 192                                                         CLIENT_INTERFACE)
 193
 194         print("Creating Session")
 195         path = client.CreateSession(options.device, { "Target": "map" })
 196
 197         map_client = MapClient(path, options.verbose)
 198
 199         if options.new_dir:
 200                 map_client.set_folder(options.new_dir)
 201
 202         if options.ls_dir:
 203                 map_client.list_folders()
 204
 205         if options.ls_msg is not None:
 206                 map_client.list_messages(options.ls_msg)
 207
 208         if options.get_msg is not None:
 209                 map_client.get_message(options.get_msg)
 210
 211         if options.push_msg is not None:
 212                 map_client.push_message(options.push_msg)
 213
 214         if options.get_msg_properties is not None:
 215                 map_client.get_message_properties(options.get_msg_properties)
 216
 217         if options.mark_msg_read is not None:
 218                 map_client.set_message_property(options.mark_msg_read, "Read", True)
 219
 220         if options.mark_msg_unread is not None:
 221                 map_client.set_message_property(options.mark_msg_unread, "Read", False)
 222
 223         if options.mark_msg_deleted is not None:
 224                 map_client.set_message_property(options.mark_msg_deleted, "Deleted", True)
 225
 226         if options.mark_msg_undeleted is not None:
 227                 map_client.set_message_property(options.mark_msg_undeleted, "Deleted", False)
 228
 229         if options.update_inbox:
 230                 map_client.update_inbox()
 231
 232         mainloop.run()