• Intro
• Downloads
• Community
• Development
• News
• TALK

Phone control

Revision as of 13:34, 12 October 2010

Please be aware that the recommended way to use the phone functionality is Telepathy: Telepathy wiki Telepathy-glib API RTCOM architecture

D-Bus

These D-Bus commands can be run from terminal or as shell scripts. Useful for scheduling events with fcron, executing from Desktop Command Execution Widget or Queen BeeCon Widget, startup events, install scripts, etc. They should be run as:

run-standalone.sh SCRIPT.sh
run-standalone.sh dbus-send COMMAND

This is important to set up the environment correctly otherwise they may barf. If run as user "user" this is not needed.

Also note that most commands don't need "--print-reply" option. Those that don't need it should be tested without it and this page should be edited.

Phone

Open Phone application

dbus-send --type=method_call --dest=com.nokia.HildonDesktop.AppMgr /com/nokia/HildonDesktop/AppMgr com.nokia.HildonDesktop.AppMgr.LaunchApplication string:"rtcom-call-ui"

Make a phone call

dbus-send --system --type=method_call --print-reply --dest=com.nokia.csd.Call /com/nokia/csd/call com.nokia.csd.Call.CreateWith string:"$NUMBER" uint32:0

Change $NUMBER to phone number you want to call.

End current phone call

dbus-send --system --print-reply --dest=com.nokia.csd.Call /com/nokia/csd/call com.nokia.csd.Call.Release

This will release/end/hangup/reject the current call (or possibly all calls if more then one call is active) or do nothing if no calls are active.

Answer current phone call

dbus-send --system --print-reply --dest=com.nokia.csd.Call /com/nokia/csd/call/1 com.nokia.csd.Call.Instance.Answer

This will answer/pickup the current (first) call.

If you answer the call immediately as you receive the Call Coming DBUS message the phone seems to be in a specific call state where answering yields a com.nokia.csd.Call.Error.NotAllowed exception.

You need to answer the call after a delay of e.g. 1 s.

Another (probably better) approach is to register to the CallStatus DBUS message (com.nokia.csd.Call, /com/nokia/csd/call/1, com.nokia.csd.Call.Instance.CallStatus) and wait for a call status >= 2 (=CSD_CALL_STATUS_COMING) after the "Coming" message.

Get IMEI

dbus-send --system --type=method_call --print-reply --dest=com.nokia.phone.SIM /com/nokia/phone/SIM/security Phone.Sim.Security.get_imei

Get IMSI

dbus-send --system --type=method_call --print-reply --dest=com.nokia.phone.SIM /com/nokia/phone/SIM Phone.Sim.get_imsi

Get cellular signal strength

dbus-send --system --print-reply --dest=com.nokia.phone.net /com/nokia/phone/net Phone.Net.get_signal_strength

First line is percentage, second is dBm, third unknown.

Get cellular registration status

dbus-send --system --print-reply --dest=com.nokia.phone.net /com/nokia/phone/net Phone.Net.get_registration_status

Turn loudspeaker on

dbus-send --type=method_call --dest=com.nokia.osso_hp_ls_controller /com/nokia/osso_hp_ls_controller com.nokia.osso_hp_ls_controller.loudspeaker.force_loudspeaker_on

Turn loudspeaker off

dbus-send --type=method_call --dest=com.nokia.osso_hp_ls_controller /com/nokia/osso_hp_ls_controller com.nokia.osso_hp_ls_controller.loudspeaker.force_loudspeaker_off

Start vibrating

dbus-send --system --print-reply --dest=com.nokia.mce /com/nokia/mce/request com.nokia.mce.request.req_vibrator_pattern_activate string:PatternIncomingCall

Stop vibrating

dbus-send --system --print-reply --dest=com.nokia.mce /com/nokia/mce/request com.nokia.mce.request.req_vibrator_pattern_deactivate string:PatternIncomingCall

Profiles

Set General

dbus-send --type=method_call --dest=com.nokia.profiled /com/nokia/profiled com.nokia.profiled.set_profile string:"general"

Set Silent

dbus-send --type=method_call --dest=com.nokia.profiled /com/nokia/profiled com.nokia.profiled.set_profile string:"silent"

Query current profile

dbus-send --type=method_call --print-reply --dest=com.nokia.profiled /com/nokia/profiled com.nokia.profiled.get_profile

List all profiles

dbus-send --type=method_call --print-reply --dest=com.nokia.profiled /com/nokia/profiled com.nokia.profiled.get_profiles

LED

Activate LEDs

dbus-send --system --type=method_call --dest=com.nokia.mce /com/nokia/mce/request com.nokia.mce.request.req_led_pattern_activate string:"PatternCommunicationIM"

Deactivate LEDs

dbus-send --system --type=method_call --dest=com.nokia.mce /com/nokia/mce/request com.nokia.mce.request.req_led_pattern_deactivate string:"PatternCommunicationIM"

Messaging

New e-mail

dbus-send --type=method_call --dest=com.nokia.modest /com/nokia/modest com.nokia.modest.MailTo string:"mailto:"

Send and receive e-mail

It works, but it takes up to 2 minutes for modest to start refreshing and after that it depends on the speed of the connection how fast it is going to be completed, usually up to 5 seconds, 2G can be a bit slower.

dbus-send --type=method_call --dest=com.nokia.modest /com/nokia/modest com.nokia.modest.SendReceive

Set presence

dbus-send --type=method_call --print-reply --dest=org.freedesktop.Telepathy.MissionControl /org/freedesktop/Telepathy/MissionControl org.freedesktop.Telepathy.MissionControl.SetPresence uint32:2 string:"I'm here"

Change peak_schedule settings

Check:

run-standalone.sh gconftool-2 -R /apps/activesync

Set (check if yours is named ActiveSyncAccount1):

run-standalone.sh gconftool-2 --set /apps/activesync/ActiveSyncAccount1/schedule/peak_schedule --type=int 15

Where the last number is one of the following (as standard in GUI):

0 = Always on

-1 = Manual

15 = Every 15 minutes

30 = Every 30 minutes

60 = Every hour

240 = Every 4 hours

720 = Every 12 hours

Media player

Open file in media player

dbus-send --print-reply --dest=com.nokia.mediaplayer /com/nokia/mediaplayer com.nokia.mediaplayer.mime_open string:"file:///$1"

Pause what's currently playing

dbus-send --dest=com.nokia.mafw.renderer.Mafw-Gst-Renderer-Plugin.gstrenderer /com/nokia/mafw/renderer/gstrenderer com.nokia.mafw.renderer.pause

Stop what's currently playing

dbus-send --dest=com.nokia.mafw.renderer.Mafw-Gst-Renderer-Plugin.gstrenderer /com/nokia/mafw/renderer/gstrenderer com.nokia.mafw.renderer.stop

Play what's currently selected

dbus-send --dest=com.nokia.mafw.renderer.Mafw-Gst-Renderer-Plugin.gstrenderer /com/nokia/mafw/renderer/gstrenderer com.nokia.mafw.renderer.play

Unpause what's currently selected

dbus-send --dest=com.nokia.mafw.renderer.Mafw-Gst-Renderer-Plugin.gstrenderer /com/nokia/mafw/renderer/gstrenderer com.nokia.mafw.renderer.resume

Play next mediafile

dbus-send --dest=com.nokia.mafw.renderer.Mafw-Gst-Renderer-Plugin.gstrenderer /com/nokia/mafw/renderer/gstrenderer com.nokia.mafw.renderer.next

Play previous mediafile

dbus-send --dest=com.nokia.mafw.renderer.Mafw-Gst-Renderer-Plugin.gstrenderer /com/nokia/mafw/renderer/gstrenderer com.nokia.mafw.renderer.previous

Notifications

Send notification (orange one line popup)

dbus-send --type=method_call --dest=org.freedesktop.Notifications /org/freedesktop/Notifications org.freedesktop.Notifications.SystemNoteInfoprint string:"NOTIFICATION"

Send dialog notification (orange multi line popup requiring user interaction)

dbus-send --type=method_call --dest=org.freedesktop.Notifications /org/freedesktop/Notifications org.freedesktop.Notifications.SystemNoteDialog string:"QUESTION?" uint32:0 string:"OK"

Not sure what string "OK" does, but it is needed and can be anything.

Securing

Lock

dbus-send --system --type=method_call --dest=com.nokia.system_ui /com/nokia/system_ui/request com.nokia.system_ui.request.devlock_open string:"com.nokia.mce" string:"/com/nokia/mce/request" string:"com.nokia.mce.request" string:"devlock_callback" uint32:'3'

Unlock

dbus-send --system --type=method_call --dest=com.nokia.system_ui /com/nokia/system_ui/request com.nokia.system_ui.request.devlock_close string:"com.nokia.mce" string:"/com/nokia/mce/request" string:"com.nokia.mce.request" string:"devlock_callback" uint32:'0'

Lock screen and keys

dbus-send --system --type=method_call --dest=com.nokia.mce /com/nokia/mce/request com.nokia.mce.request.req_tklock_mode_change string:"locked"

Unlock screen and keys

dbus-send --system --type=method_call --dest=com.nokia.mce /com/nokia/mce/request com.nokia.mce.request.req_tklock_mode_change string:"unlocked"

Networking

Connect to specific saved connection

dbus-send --system --type=method_call --dest=com.nokia.icd /com/nokia/icd com.nokia.icd.connect string:"IAP_ID" uint32:0

IAP_ID is internet access point identifier and can be obtained with the following command:

gconftool -R /system/osso/connectivity/IAP

Find lines which matches /system/osso/connectivity/IAP/<IAP_ID>

For GPRS connections replace "@32@" with a space in IAP_ID string.

Keep in mind that phone has to be disconnected in order to connect via this call. If not, an error message will occur if you add --print-reply to the dbus-send command.

Connect to any saved connection

dbus-send --system --type=method_call --dest=com.nokia.icd /com/nokia/icd com.nokia.icd.connect string:"[ANY]" uint32:0

Disconnect internet

ICD2

dbus-send --print-reply --system --dest=com.nokia.icd2 /com/nokia/icd2 com.nokia.icd2.disconnect_req uint32:0x8000

ICD

dbus-send --system --dest=com.nokia.icd /com/nokia/icd_ui com.nokia.icd_ui.disconnect boolean:true

On PR1.2 : Error org.freedesktop.DBus.Error.UnknownMethod: Method "disconnect" with signature "b" on interface "com.nokia.icd_ui" doesn't exist

Connect (show change connection UI)

dbus-send --system --type=method_call --dest=com.nokia.icd_ui /com/nokia/icd_ui com.nokia.icd_ui.show_conn_dlg boolean:false

If "boolean:true" at the end, one-line notification saying "No saved connections available" appears. Maybe affects more than that?

Enable cellular radio

dbus-send --system --type=method_call --dest=com.nokia.phone.SSC /com/nokia/phone/SSC com.nokia.phone.SSC.set_radio boolean:true

Disable cellular radio

dbus-send --system --type=method_call --dest=com.nokia.phone.SSC /com/nokia/phone/SSC com.nokia.phone.SSC.set_radio boolean:false

Radio mode

2G

dbus-send --system --type=method_call --dest=com.nokia.phone.net /com/nokia/phone/net Phone.Net.set_selected_radio_access_technology byte:1

3G

dbus-send --system --type=method_call --dest=com.nokia.phone.net /com/nokia/phone/net Phone.Net.set_selected_radio_access_technology byte:2

Dual

dbus-send --system --type=method_call --dest=com.nokia.phone.net /com/nokia/phone/net Phone.Net.set_selected_radio_access_technology byte:0

Bluetooth

Identify adapter path

You need to know adapter path in order to send D-Bus call to the right place. You can get it with entering this command into the terminal:

dbus-send --system --print-reply --dest=org.bluez / org.bluez.Manager.ListAdapters | awk -F'"' '/at/ {print $2}'

Enable

Using the adapter path value returned with previous command, for example /org/bluez/906/hci0.

dbus-send --system --type=method_call --dest=org.bluez /org/bluez/906/hci0 org.bluez.Adapter.SetProperty string:Powered variant:boolean:true

This one automatically inserts adapter path:

dbus-send --system --type=method_call --dest=org.bluez $(dbus-send --system --print-reply --dest=org.bluez / org.bluez.Manager.ListAdapters | awk -F'"' '/at/ {print $2}') org.bluez.Adapter.SetProperty string:Powered variant:boolean:true

Disable

dbus-send --system --type=method_call --dest=org.bluez /org/bluez/906/hci0 org.bluez.Adapter.SetProperty string:Powered variant:boolean:false

With auto-discovery of adapter path:

dbus-send --system --type=method_call --dest=org.bluez $(dbus-send --system --print-reply --dest=org.bluez / org.bluez.Manager.ListAdapters | awk -F'"' '/at/ {print $2}') org.bluez.Adapter.SetProperty string:Powered variant:boolean:false

Connect to specific device

devmac=00:11:22:33:44:55
service=AudioSink

adapter=$(dbus-send --system --print-reply --dest=org.bluez / org.bluez.Manager.ListAdapters | awk -F'"' '/at/ {print $2}')
device=$(dbus-send --system --print-reply --dest=org.bluez ${adapter} org.bluez.Adapter.FindDevice string:${devmac} | sed -ne 's/^.*object path //p' -e 's/"//g')
dbus-send --system --type=method_call --print-reply --dest=org.bluez ${device} org.bluez.${service}.Connect

Change the AudoSink to any service and the devmac to the MAC of bluetooth device.

Check for updates

dbus-send --type=method_call --dest=com.nokia.hildon_application_manager /com/nokia/hildon_application_manager com.nokia.hildon_application_manager.check_for_updates

Open link in browser

dbus-send --system --type=method_call --dest=com.nokia.osso_browser /com/nokia/osso_browser/request com.nokia.osso_browser.load_url string:"google.com"

Set volume

dbus-send --type=method_call --dest=com.nokia.mafw.renderer.Mafw-Gst-Renderer-Plugin.gstrenderer /com/nokia/mafw/renderer/gstrenderer com.nokia.mafw.extension.set_extension_property string:volume variant:uint32:50

The value can be between 0 and 100.

Reboot

dbus-send --system --type=method_call --print-reply --dest=com.nokia.mce "/com/nokia/mce/request" com.nokia.mce.request.req_reboot

This is same as rebooting from power key menu (needs uncommenting in certain XML file to appear) and has been identified as insecure way to reboot the device (no filesystem synchronization, etc.). Better command is to simply enter "reboot" in root terminal.

Shutdown

dbus-send --system --type=method_call --print-reply --dest=com.nokia.mce "/com/nokia/mce/request" com.nokia.mce.request.req_shutdown

See warning at reboot D-Bus call (needs testing).

Show dashboard

dbus-send /com/nokia/hildon_desktop com.nokia.hildon_desktop.exit_app_view

Other

D-Bus Scripts

You can also use dbus-scripts to execute any command when various actions are triggered on D-Bus.

Panucci (pause)

dbus-send --type=method_call --dest=org.panucci.panucciInterface /panucciInterface org.panucci.panucciInterface.playPause

GConf

Reset GPRS data counter

The commands are PR1.2 compliant and do not work on previous versions.

gconftool-2 -u /system/osso/connectivity/network_type/GPRS/gprs_home_rx_bytes
gconftool-2 -u /system/osso/connectivity/network_type/GPRS/gprs_home_tx_bytes
gconftool-2 -s /system/osso/connectivity/network_type/GPRS/gprs_home_reset_time --type=string $(date +%s)

Command line

Enable FM Transmitter

/usr/bin/fmtx_client -p 1

Disable FM Transmitter

/usr/bin/fmtx_client -p 0

GStreamer

Take a picture with front camera

gst-launch v4l2src device=/dev/video1 num-buffers=1 ! ffmpegcolorspace ! jpegenc ! filesink location=frontcam.jpg

Shoot photo after 10 seconds

The camera application must be off for it to work. And of course the camera shutter must be open...gst-launch comes with gstreamer-tools (or gst-launch-0.10 and gstreamer0.10-tools)

/bin/sleep 10 ; /usr/bin/gst-launch v4l2camsrc device=/dev/video0 num-buffers=1 \! video/x-raw-yuv,width=2592,height=1968  \! ffmpegcolorspace \! jpegenc \! filesink location=/home/user/MyDocs/DCIM/photo.jpg

To shoot from the front camera, change /dev/video0 to /dev/video1 and the proper resolution:

/bin/sleep 10 ; /usr/bin/gst-launch v4l2camsrc device=/dev/video1 num-buffers=1 \! video/x-raw-yuv,width=640,height=480  \! ffmpegcolorspace \! jpegenc \! filesink location=/home/user/MyDocs/DCIM/photo.jpg

Other way:

/bin/sleep 10; /usr/bin/gst-launch v4l2camsrc ! ffmpegcolorspace ! jpegenc ! identity error-after=1 ! filesink location=/home/user/MyDocs/DCIM/photo.jpg

Python

Make a phone call via the cellular network

import dbus
def place_call(number):
  bus = dbus.SystemBus()
  csd_call = dbus.Interface(bus.get_object('com.nokia.csd',
                                           '/com/nokia/csd/call'),
                                           'com.nokia.csd.Call')
  csd_call.CreateWith(str(number), dbus.UInt32(0))

Make a phone call via SIP

#!/usr/bin/python
 
import dbus
import sys
 
# Get the target phone number (or SIP address) from the command line
TARGET = sys.argv[1];
 
# Configure the telepathy path to the SofiaSIP account that we wish to use.
# Use "mc-tool list" (from the libmissioncontrol-utils package) to see your accounts.
SIP_ACCOUNT = 'sofiasip/sip/_31234567_40sipgate_2eco_2euk0'
 
# This gets us a connnection to the session bus
bus = dbus.SessionBus()
 
# This sets up a path to the SIP account within telepathy.
PATH = '/org/freedesktop/Telepathy/Account/'
PATH += SIP_ACCOUNT
 
# This sets up a proxy object as a "handle" to the AccountManager of our target account
account = bus.get_object('org.freedesktop.Telepathy.AccountManager', PATH)
 
# This launches the actual SIP call with a method call to EnsureChannel on that object
account.EnsureChannel( \
        dbus.Dictionary({
                dbus.String(u'org.freedesktop.Telepathy.Channel.TargetHandleType'): dbus.UInt32(1),
                dbus.String(u'org.freedesktop.Telepathy.Channel.ChannelType'): dbus.String(u'org.freedesktop.Telepathy.Channel.Type.StreamedMedia'),
                dbus.String(u'org.freedesktop.Telepathy.Channel.TargetID'): dbus.String(TARGET),
        }, signature='sv'),
        dbus.UInt64(0),
        dbus.String(''),
        dbus_interface='com.nokia.Account.Interface.ChannelRequests')
 
sys.exit(0)

Send SMS

ssms.py using new QtMobility bindings by ossipena:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
#ssms Ossipena/TimoP
#send smses from command line
#licence : Do whatever you want
#deps:
#pyside-qt4
#pyside-mobility
 
'''imports'''
from QtMobility.Messaging import *
from PySide.QtCore import *
import sys
from PyQt4 import QtCore
 
 
app = QCoreApplication(sys.argv)
 
'''get number and name'''
stringit = sys.argv
numpertemp = str(stringit[1:2])
mesits = str(stringit[2:])[2:-2]
 
num = str(numpertemp[2:-2])
 
if (mesits == ""):
  print "Usage:"
  print "python ssms.py 01234567 'message text here'"
  sys.exit(69)
else:
  print "number is " + str(num)
  print "message is " + str(mesits)
 
'''define message to be sent'''
numperi = QtCore.QString(num)
 
numper = QMessageAddress(QMessageAddress.Phone, numperi)
mesitsi = QMessage()
mesitsi.setType(QMessage.Sms)
mesitsi.setTo(numper)
mesitsi.setBody(mesits)
 
'''send message'''
sender = QMessageService()
if (sender.send(mesitsi)):
  print "success"
else:
  print "fail"

From: http://talk.maemo.org/showpost.php?p=548948&postcount=52

#!/usr/bin/env python2.5
 
import pexpect
import time
from subprocess import *
 
child = pexpect.spawn('pnatd');
child.send('at\r');
time.sleep(0.25);
child.send('at+cmgf=1\r');
time.sleep(0.25);
child.send('at+cmgs="+XXXXXXX"\r');
child.send('SMSTEXTSMSTEXTSMSTEXT');
child.send(chr(26));
child.send(chr(26));
child.sendeof();

There's also a python script that uses DBUS instead from http://talk.maemo.org/showpost.php?p=558430&postcount=57:

#!/usr/bin/env python2.5          
import sched, time                
import dbus                       
import gobject                    
from dbus.mainloop.glib import DBusGMainLoop
 
def octify(str):
        '''     
        Returns a list of octet bytes representing
        each char of the input str.               
        '''                                       
 
        bytes = map(ord, str)
        bitsconsumed = 0     
        referencebit = 7     
        octets = []          
 
        while len(bytes):
                byte = bytes.pop(0)
                byte = byte >> bitsconsumed
 
                try:                       
                        nextbyte = bytes[0]
                        bitstocopy = (nextbyte & (0xff >> referencebit)) << referencebit
                        octet = (byte | bitstocopy)                                     
 
                except:
                        octet = (byte | 0x00)
 
                if bitsconsumed != 7:
                        octets.append(byte | bitstocopy)
                        bitsconsumed += 1               
                        referencebit -= 1               
                else:                                   
                        bitsconsumed = 0                
                        referencebit = 7                
 
        return octets
 
def semi_octify(str):
        '''          
        Expects a string containing two digits.
        Returns an octet -                     
        first nibble in the octect is the first
        digit and the second nibble represents 
        the second digit.                      
        '''                                    
        try:                                   
                digit_1 = int(str[0])          
                digit_2 = int(str[1])          
                octet = (digit_2 << 4) | digit_1
        except:                                 
                octet = (1 << 4) | digit_1      
 
        return octet
 
 
def deoctify(arr):
 
        referencebit = 1
        doctect = []    
        bnext = 0x00    
 
        for i in arr:
 
                bcurr = ((i & (0xff >> referencebit)) << referencebit) >> 1
                bcurr = bcurr | bnext                                      
 
                if referencebit != 7:
                        doctect.append( bcurr )
                        bnext = (i & (0xff << (8 - referencebit)) ) >> 8 - referencebit
                        referencebit += 1                                              
                else:                                                                  
                        doctect.append( bcurr )                                        
                        bnext = (i & (0xff << (8 - referencebit)) ) >> 8 - referencebit
                        doctect.append( bnext )                                        
                        bnext = 0x00                                                   
                        referencebit = 1                                               
 
        return ''.join([chr(i) for i in doctect])
 
 
def createPDUmessage(number, msg):
        '''                       
        Returns a list of bytes to represent a valid PDU message
        '''                                                     
        numlength = len(number)                                 
        if (numlength % 2) == 0:                                
                rangelength = numlength                         
        else:                                                   
                number = number + 'F'                           
                rangelength = len(number)                       
 
        octifiednumber = [ semi_octify(number[i:i+2]) for i in range(0,rangelength,2) ]
        octifiedmsg = octify(msg)                                                      
        HEADER = 1                                                                     
        FIRSTOCTETOFSMSDELIVERMSG = 10                                                 
        ADDR_TYPE = 129 #unknown format                                                
        number_length = len(number)                                                    
        msg_length = len(msg)                                                          
        pdu_message = [HEADER, FIRSTOCTETOFSMSDELIVERMSG, number_length, ADDR_TYPE]    
        pdu_message.extend(octifiednumber)                                             
        pdu_message.append(0)                                                          
        pdu_message.append(0)                                                          
        pdu_message.append(msg_length)                                                 
        pdu_message.extend(octifiedmsg)                                                
        return pdu_message                                                             
 
 
def sendmessage(number, message):
 
        bus = dbus.SystemBus()
        smsobject = bus.get_object('com.nokia.phone.SMS', '/com/nokia/phone/SMS/ba212ae1')
        smsiface = dbus.Interface(smsobject, 'com.nokia.csd.SMS.Outgoing')
        arr = dbus.Array(createPDUmessage(number.replace('+', '00'), message))
 
        msg = dbus.Array([arr])
        smsiface.Send(msg,'')
 
 
def callback(pdumsg, msgcenter, somestring, sendernumber):
 
        msglength = int(pdumsg[18])
        msgarray = pdumsg[19:len(pdumsg)]
 
        msg = deoctify(msgarray)
 
        if msg > 0:
               print 'New message received from %s' % sendernumber
               print 'Message length %d' % msglength
               print 'Message: %s' % msg
 
               if msg == "ping":
                       print "Sending reply: pong"
                       sendmessage(sendernumber.replace("+","00"), "pong")
               else:
                       print "Unknown command"
 
 
def listen():
        DBusGMainLoop(set_as_default=True)
        bus = dbus.SystemBus() #should connect to system bus instead of session because the former is where the incoming signals come from
        bus.add_signal_receiver(callback, path='/com/nokia/phone/SMS', dbus_interface='Phone.SMS', signal_name='IncomingSegment')
        gobject.MainLoop().run()
 
 
if __name__ == '__main__':
  import time
 
  def schedule_task(schedule, fn, *args):
      import sched
      s = sched.scheduler(time.time, time.sleep)
      startTime = time.mktime(time.strptime(schedule, '%b %d %H:%M %Y'))
      s.enterabs(startTime, 0, fn, args)
      s.run()
 
  import getopt, sys
  try:  
    opts, args = getopt.getopt(sys.argv[1:],"hlt:", ["help","listen","time="])
 
  except getopt.GetoptError, err:
    # print help information and exit:
    print str(err) # will print something like "option -a not recognized"
    usage()
    sys.exit(2)  
  listening = False 
  timeofday = ''
  for opt, arg in opts:
    if opt in ("-h", "--help"):
      usage()                     
      sys.exit()                  
    elif opt in ("-l", "--listen"):
      listening = True                 
    elif opt in ("-t", "--time"):
      timeofday = arg                           
    else:
      assert False, "unhandled option"
 
  number = args[0]           
  msg = args[1]
  if msg != '':
    if timeofday == '':
        sendmessage(number, msg)
    else:
        today = time.strftime('%b %d x %Y', time.localtime())
        schedule = today.replace('x', timeofday)
        schedule_task(schedule, sendmessage, number, msg)
  if listening:
    listen()

Send dialog notification (orange multi line popup requiring user interaction)

import dbus
def show_notification_dialog(message, mode="single"):
  bus = dbus.SystemBus()
  iface = dbus.Interface(bus.get_object('org.freedesktop.Notifications',
                                        '/org/freedesktop/Notifications'),
                                        'org.freedesktop.Notifications')
  if mode == "single":
      iface.SystemNoteInfoprint(message)
  elif mode == "multiline":
      iface.SystemNoteDialog(str(message), dbus.UInt32(0), 'Ok')

This function allows you to show notification either with multiline (on maemo pre-5 it will show a dialog with an "Ok" button) or single line (tiny notifications hiding automatically).

Take a screenshot

 import gtk.gdk
 
 w = gtk.gdk.get_default_root_window()
 sz = w.get_size()
 print "The size of the window is %d x %d" % sz
 pb = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB,False,8,sz[0],sz[1])
 pb = pb.get_from_drawable(w,w.get_colormap(),0,0,0,0,sz[0],sz[1])
 if (pb != None):
   pb.save("screenshot.png","png")
   print "Screenshot saved to screenshot.png."
 else:
   print "Unable to get the screenshot."

Credits: took code from here, where there is also a Qt way to do it.

Make an "Email Style" notification dialog

import dbus
 
bus = dbus.SessionBus()
proxy = bus.get_object('org.freedesktop.Notifications', '/org/freedesktop/Notifications')
interface = dbus.Interface(proxy,dbus_interface='org.freedesktop.Notifications')
interface.Notify('Notification', 0, 'control_bluetooth_paired', 'Testing 123', 'Hello World', [], {}, 0)

Credits: MohammadAG (on irc).