def mms_menu_button_clicked(self, button, fname):
""" actions for mms menu """
buttontext = button.get_label()
if buttontext == self.headerstxt:
ret = self.create_headers_dialog(fname)
elif buttontext == self.replytxt:
number = self.cont.get_replyuri_from_transid(fname)
fMMSSenderUI.fMMS_SenderUI(spawner=self.window, tonumber=number).run()
elif buttontext == self.replysmstxt:
number = self.cont.get_replyuri_from_transid(fname)
if "@" in number:
note = osso.SystemNote(self.osso_c)
note.system_note_dialog(gettext.ldgettext('rtcom-messaging-ui', "messaging_fi_smsc_invalid_chars") , 'notice')
else:
rpc = osso.Rpc(self.osso_c)
nr = "sms:%s" % str(number)
args = (nr, "")
rpc.rpc_run('com.nokia.MessagingUI', '/com/nokia/MessagingUI', 'com.nokia.MessagingUI', 'messaging_ui_interface_start_sms', args, True, True)
elif buttontext == self.forwardtxt:
tbuffer = self.textview.get_buffer()
msg = tbuffer.get_text(tbuffer.get_start_iter(), tbuffer.get_end_iter())
fn = self.attachment
fMMSSenderUI.fMMS_SenderUI(spawner=self.window, withfile=fn, message=msg, forward=True)
elif buttontext == self.deletetxt:
self.delete_dialog(fname)
elif buttontext == self.copytxt:
clip = gtk.Clipboard(display=gtk.gdk.display_get_default(), selection="CLIPBOARD")
tbuffer = self.textview.get_buffer()
msg = tbuffer.get_text(tbuffer.get_start_iter(), tbuffer.get_end_iter())
clip.set_text(msg, -1)
elif buttontext == self.saveattachments:
self.save_attachments(fname)
def _send_mce_request(self, request):
rpc = osso.Rpc(self._osso_context)
rpc.rpc_run(self._MCE_SERVICE, \
self._MCE_REQUEST_PATH, \
self._MCE_REQUEST_IF, \
request, \
use_system_bus=True)
def test_set_rpc_default_callback(self):
rpc = osso.Rpc(self.ctx)
# register callback
rpc.set_rpc_default_callback(lambda i, m, a, u: None, "abc")
# unregister callback
rpc.set_rpc_default_callback(None, "abc")
# check for callable callback
self.assertRaises(TypeError, rpc.set_rpc_default_callback, 123, "abc")
def test_rpc_run_with_defaults(self):
# Delay for some time before calling rpc_run_with_defaults().
# Otherwise, this error might occur:
# Message did not receive a reply (timeout by message bus)
import time
time.sleep(0.5)
rpc = osso.Rpc(self.ctx)
ret = rpc.rpc_run_with_defaults(self.program, "do_something",
("xyz", -1, 1, True, False, 1.0), True)
def test_set_rpc_callback(self):
self._set_dbus_data(self.program)
rpc = osso.Rpc(self.ctx)
# register callback
rpc.set_rpc_callback(self.service, self.object_path, self.interface,
lambda i, m, a, u: None, "abc")
# unregister callback
rpc.set_rpc_callback(self.service, self.object_path, self.interface,
None, "abc")
# check for callable callback
self.assertRaises(TypeError, rpc.set_rpc_callback, self.service,
self.object_path, self.interface, 123, "abc")
def mms_img_clicked(self, widget, data):
""" action on click on image/button """
log.info("img clicked: %s", data)
path = str("file://" + data)
# gnomevfs seems to be better than mimetype when guessing mimetype for us
file_mimetype = gnomevfs.get_mime_type(path)
log.info("path: %s", path)
log.info("mimetype: %s", file_mimetype)
if file_mimetype != None:
if file_mimetype.startswith("video") or file_mimetype.startswith("audio"):
rpc = osso.Rpc(self.osso_c)
rpc.rpc_run("com.nokia.mediaplayer", "/com/nokia/mediaplayer", "com.nokia.mediaplayer", "mime_open", (str, path))
elif file_mimetype.startswith("image"):
rpc = osso.Rpc(self.osso_c)
ret = rpc.rpc_run("com.nokia.image_viewer", "/com/nokia/image_viewer", "com.nokia.image_viewer", "mime_open", (str, path))
elif "vcard" in file_mimetype:
rpc = osso.Rpc(self.osso_c)
ret = rpc.rpc_run("com.nokia.osso_addressbook", "/com/nokia/osso_addressbook", "com.nokia.osso_addressbook", "mime_open", (str, path))
else:
# TODO: how to solve this?
# move .mms to ~/MyDocs? change button to copy file to ~/MyDocs?
#rpc = osso.Rpc(self.osso_c)
#path = os.path.dirname(path).replace("file://", "")
log.info("path %s", str(path))
def open_website(url):
"""
Opens the specified URL using the default system web
browser. This uses Python's "webbrowser" module, so
make sure your system is set up correctly.
"""
if gpodder.ui.maemo:
import osso
context = osso.Context('gPodder', gpodder.__version__, False)
rpc = osso.Rpc(context)
rpc.rpc_run_with_defaults('osso_browser', \
'open_new_window', \
(url,))
else:
threading.Thread(target=webbrowser.open, args=(url,)).start()
def gui_open(filename):
"""
Open a file or folder with the default application set
by the Desktop environment. This uses "xdg-open" on all
systems with a few exceptions:
on Win32, os.startfile() is used
on Maemo, osso is used to communicate with Nokia Media Player
"""
try:
if gpodder.ui.maemo:
try:
import osso
except ImportError, ie:
log('Cannot import osso module on maemo.')
return False
log('Using Nokia Media Player to open %s', filename)
context = osso.Context('gPodder', gpodder.__version__, False)
filename = filename.encode('utf-8')
# Fix for Maemo bug 7162 (for local files with "#" in filename)
if filename.startswith('/'):
filename = 'file://' + urllib.quote(filename)
rpc = osso.Rpc(context)
app = 'mediaplayer'
_unneeded, extension = os.path.splitext(filename.lower())
# Fix for Maemo bug 5588 (use PDF viewer and images app)
if extension == '.pdf':
app = 'osso_pdfviewer'
elif extension in ('.jpg', '.jpeg', '.png'):
app = 'image_viewer'
svc, path = (x % app for x in ('com.nokia.%s', '/com/nokia/%s'))
rpc.rpc_run(svc, path, svc, 'mime_open', (filename,))
elif gpodder.win32:
os.startfile(filename)
def get_sim_imsi(self):
osso_c = osso.Context('fMMSconfig', '1.0', False)
rpc = osso.Rpc(osso_c)
imsi = rpc.rpc_run('com.nokia.phone.SIM', '/com/nokia/phone/SIM', 'Phone.Sim', 'get_imsi', (), True, True)
return imsi
global count
try:
plugin = plugins.pop()
except:
return
print "executing:", plugin
plug.plugin_execute(plugin, True, app)
print "saving..."
plug.plugin_save_state(plugin)
c = osso.Context("test_client", "0.0.0", False)
as = osso.Autosave(c)
applic = osso.Application(c)
rpc = osso.Rpc(c)
print "as.get_name() ->", as.get_name()
print "as.get_version() ->", as.get_version()
print "rpc.get_rpc_timeout() ->", rpc.get_rpc_timeout()
print "rpc.set_rpc_timeout(15) ->", rpc.set_rpc_timeout(15)
print "rpc.get_rpc_timeout() ->", rpc.get_rpc_timeout()
timenot = osso.TimeNotification(c)
timenot.set_time_notification_callback(handler_test_time_notification, "Notification Callback!")
timenot.set_time(time.localtime())
plug = osso.Plugin(c)
ss = osso.StateSaving(c)
local = osso.Locale(c)
# Interface
app = hildon.App()
def send_rpc(widget, osso_c):
osso_rpc = osso.Rpc(osso_c)
osso_rpc.rpc_run("spam.eggs.osso_test_receiver",
"/spam/eggs/osso_test_receiver",
"spam.eggs.osso_test_receiver", "do_something")
print "RPC sent"
def __init__(self):
""" Initializes the GUI, creating all widgets. """
self.cont = fMMSController.fMMS_controllerGTK()
self.config = self.cont.config
self.ch = ContactH.ContactHandler()
self.osso_c = osso.Context("se.frals.fmms", self.config.get_version(),
False)
self.osso_rpc = osso.Rpc(self.osso_c)
self.osso_rpc.set_rpc_callback("se.frals.fmms", "/se/frals/fmms",
"se.frals.fmms", self.cb_open_fmms,
self.osso_c)
self.refreshlistview = True
self.viewerimported = False
self.senderimported = False
self._screenwidth = 800
self.avatarlist = {}
self.namelist = {}
self.nrlist = {}
hildon.Program.__init__(self)
program = hildon.Program.get_instance()
self.window = hildon.StackableWindow()
hildon.hildon_gtk_window_set_portrait_flags(
self.window, hildon.PORTRAIT_MODE_SUPPORT)
gtk.set_application_name("fMMS")
self.window.set_title("fMMS")
program.add_window(self.window)
self.window.connect("delete_event", self.quit)
self.pan = hildon.PannableArea()
self.pan.set_property("mov-mode", hildon.MOVEMENT_MODE_VERT)
# wonder how much memory this is wasting
self.iconcell = gtk.CellRendererPixbuf()
self.photocell = gtk.CellRendererPixbuf()
self.textcell = gtk.CellRendererText()
self.photocell.set_property('xalign', 1.0)
self.textcell.set_property('mode', gtk.CELL_RENDERER_MODE_INERT)
self.textcell.set_property('xalign', 0.0)
self.liststore = gtk.ListStore(gtk.gdk.Pixbuf, str, gtk.gdk.Pixbuf,
str, str, str)
self.treeview = hildon.GtkTreeView(gtk.HILDON_UI_MODE_NORMAL)
self.treeview.set_property("fixed-height-mode", True)
self.treeview.set_model(self.liststore)
# create ui
self._create_ui()
self.treeview.tap_and_hold_setup(self.liststore_mms_menu())
self.treeview.tap_and_hold_setup(None)
self.tapsignal = self.treeview.connect('hildon-row-tapped',
self.show_mms)
self.treeview.connect('button-press-event', self.cb_button_press)
mmsBox = gtk.HBox()
icon_theme = gtk.icon_theme_get_default()
envelopePixbuf = icon_theme.load_icon("general_sms_button", 48, 0)
envelopeImage = gtk.Image()
envelopeImage.set_from_pixbuf(envelopePixbuf)
envelopeImage.set_alignment(1, 0.5)
mmsLabel = gtk.Label(
gettext.ldgettext('rtcom-messaging-ui', "messaging_ti_new_mms"))
mmsLabel.set_alignment(0, 0.5)
mmsBox.pack_start(envelopeImage, True, True, 0)
mmsBox.pack_start(mmsLabel, True, True, 0)
newMsgButton = hildon.Button(gtk.HILDON_SIZE_FINGER_HEIGHT,
hildon.BUTTON_ARRANGEMENT_HORIZONTAL)
newMsgButton.add(mmsBox)
newMsgButton.connect('clicked', self.new_mms_button_clicked)
""" gets the newMsgButton on top of the treeview """
actionbox = self.treeview.get_action_area_box()
self.treeview.set_action_area_visible(True)
actionbox.add(newMsgButton)
self.pan.add(self.treeview)
self.livefilter = hildon.LiveSearch()
modelfilter = self.liststore.filter_new()
modelfilter.set_visible_func(self.cb_filter_row)
self.treeview.set_model(modelfilter)
self.livefilter.set_filter(modelfilter)
self.livefilter.widget_hook(self.window, self.treeview)
contBox = gtk.VBox()
contBox.pack_start(self.pan, True, True, 0)
contBox.pack_start(self.livefilter, False, False, 0)
align = gtk.Alignment(1, 1, 1, 1)
align.set_padding(2, 2, 10, 10)
align.add(contBox)
self.window.add(align)
menu = self.cont.create_menu(self.window)
self.window.set_app_menu(menu)
self.window.connect('focus-in-event', self.cb_on_focus)
self.window.connect('configure-event', self._onOrientationChange)
self.window.show_all()
self.add_window(self.window)
#!/usr/bin/python2.5
import osso
import gtk
def callback_func(interface, method, arguments, user_data):
print "RPC received"
osso_c = user_data
osso_sysnote = osso.SystemNote(osso_c)
osso_sysnote.system_note_infoprint(
"osso_test_receiver: Received an RPC to %s." % method)
osso_c = osso.Context("osso_test_receiver", "0.0.1", False)
print "osso_test_receiver started"
osso_rpc = osso.Rpc(osso_c)
osso_rpc.set_rpc_callback("spam.eggs.osso_test_receiver",
"/spam/eggs/osso_test_receiver",
"spam.eggs.osso_test_receiver", callback_func,
osso_c)
gtk.main()
def test_rpc_async_run(self):
self._set_dbus_data(self.async_program)
rpc = osso.Rpc(self.ctx)
rpc.rpc_async_run(self.service, self.object_path, self.interface,
"do_something", test_async_cb, "abc",
("xyz", -1, 1, True, False, 1.0))
def test_constructor(self):
rpc = osso.Rpc(self.ctx)
self.assertTrue(isinstance(rpc, osso.Rpc))
def test_get_set_timeout(self):
rpc = osso.Rpc(self.ctx)
rpc.set_rpc_timeout(100)
i = rpc.get_rpc_timeout()
self.assertEqual(i, 100)
