meta data for this page
  •  

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revision Previous revision
Next revision 		Previous revision
maemo:shared_code [2011/08/18 13:50]
japskua [Template] 		maemo:shared_code [2011/08/18 23:19] (current)
grp4
Line 5: Line 5:
 So, add the codes underneath. You can copy the template underneath and just add to the line: So, add the codes underneath. You can copy the template underneath and just add to the line:
  
-===== Template =====+===== Tutorial for PyGtk ===== 
 +http://www.pygtk.org/pygtk2tutorial/
  
-  * Group: Group name +though not every function in pygtk library does work in maemo as developer were too lazy and didn't import them. like no scrollbar or slidebar exist in maemo.
-  * Description: What this snippet does+
  
-<code python example.py> +some examples 
-# This is just a print hello world! example +<code python examples.py> 
-print "Hello World"+            def main(self): 
 +        # place where fin info about pygtk http://www.pygtk.org/pygtk2tutorial/ 
 +        win = hildon.StackableWindow() 
 +      
 +        # Create and pack labels 
 +        vbox = gtk.VBox(False, 10) 
 +        hbox = gtk.HBox(False, 10) 
 +      
 +        #interface.. buttons, labels ,... etc 
 +        labelHeader = gtk.Label("MeHear") 
 +        labelSubHeader = gtk.Label("voice amplifier") 
 +      
 +#        buttonGTK1 = gtk.Button("Record") 
 +#        buttonGTK1.connect("clicked", self.record_button_clicked, labelSubHeader) 
 +      
 +        buttonGTK = gtk.ToggleButton("AMPlify") 
 +        buttonGTK.connect("clicked", self.amplify_button_clicked, labelSubHeader) 
 +         
 +        #a= gtk.CheckButton("check button 1") 
 +        #hbox.pack_start(a, True, True, 0) 
 +         
 +        #b= gtk.ToggleButton("check button 1") 
 +        #hbox.pack_start(b, True, True, 0) 
 +         
 +        #c = gtk.RadioButton(None, "radio button1") 
 +        #hbox.pack_start(c, True, True, 0) 
 +         
 +        #adjus = gtk.Adjustment(value=60, lower=0, upper=100, step_incr=1, page_incr=0, page_size=0) 
 +        #d = gtk.SpinButton(adjustment= adjus, climb_rate=0.1, digits=5) 
 +        #hbox.pack_start(d, True, True, 0) 
 +        #hscrollbar = gtk.HSscrollbar(adjustment) 
 +         
 +        #http://www.pygtk.org/pygtk2tutorial/sec-ComboWidget.html 
 +        combo = gtk.Combo() 
 +        combo.entry.set_text("text") 
 +        slist = [ "String 1", "String 2", "String 3", "String 4" ] 
 +        combo.set_popdown_strings(slist) 
 +        hbox.pack_start(combo, True, True, 0) 
 +         
 +        hbox.pack_start(buttonGTK, True, True, 0) 
 +      
 +        vbox.pack_start(labelHeader, True, True, 0) 
 +        vbox.pack_start(labelSubHeader, True, True, 0) 
 +        vbox.pack_start(hbox, True, True, 0) 
 +         
 +         
 +      
 +        # Add label's box to window 
 +        win.add(vbox) 
 +      
 +        win.connect("delete_event", gtk.main_quit) 
 +      
 +        win.show_all() 
 +      
 +        gtk.main() 
 +</code> 
 + 
 +===== Software playtrought ===== 
 + 
 +  * Group: Esa-Petri and Hilmi 
 +  * Description: program to play voice from mic 
 +  
 + 
 +<code python MeHear.py> 
 +from optparse import OptionParser 
 +from time import sleep 
 + 
 +import sys, os 
 +import pygtk, gtk, gobject  
 +import dbus 
 +import gst 
 +import pygst 
 +import sys 
 +import time 
 +import gtk  
 +import hildon 
 + 
 + 
 +class Record(): 
 +    mic = None 
 +     
 +    def __init__(self, sink): 
 +        """ 
 +        @summary: The Constructor class, that searches for the microphone on initialization 
 +        """ 
 +        bus = dbus.SystemBus() 
 +        hal_manager = bus.get_object("org.freedesktop.Hal", 
 +                                     "/org/freedesktop/Hal/Manager") 
 +        hal_manager = dbus.Interface(hal_manager, "org.freedesktop.Hal.Manager") 
 +  
 +        print hal_manager 
 +        devices = hal_manager.FindDeviceStringMatch("alsa.type", "capture") 
 +  
 +        identifiers = [] 
 +  
 +        for dev in devices: 
 +            device = bus.get_object("org.freedesktop.Hal", dev) 
 +  
 +            card = device.GetAllProperties(dbus_interface="org.freedesktop.Hal.Device") 
 +            if card["alsa.card"] not in identifiers: 
 +                print "%d. %s" % (card["alsa.card"], card["alsa.card_id"]) 
 +                identifiers.append(card["alsa.card"]) 
 +  
 +        self.mic = identifiers[0]  
 +         
 +        """ 
 +        @attention: this is important it initializes softfare playtrought (audioconvert is not nesesity) 
 +        @summary: takes stream from mic to autosink 
 +        """ 
 +        self.pipeline = gst.parse_launch("""alsasrc device=hw:%d  ! audioconvert ! autoaudiosink location=%s""" % (self.mic, sink)) 
 +                    
 +         
 +    def rec(self): 
 +        """ 
 +        @summary: sets recording on 
 +        """ 
 +        self.pipeline.set_state(gst.STATE_PLAYING) 
 +        print "" 
 +        print "recording started" 
 +             
 +             
 +    def stoprec(self):     
 +        """ 
 +        @summary: sets recording off 
 +        """   
 +        self.pipeline.set_state(gst.STATE_NULL) 
 +        print "" 
 +        print "recording, stoped" 
 +         
 +         
 +class Prosesor(): 
 +    """ 
 +    @summary: Takes care of prossesing the sound 
 +    """ 
 +     
 +     
 +    def __init__(self): 
 +        volume=0 
 +        gain =0 
 +        CutThereshold=0 
 +         
 +         
 +    def proses(self,volume, gain, comp): 
 +        a=1 
 +         
 +         
 +         
 +         
 +class player(): 
 +    def __init__(self): 
 +        """ 
 +        @summary: player part 
 +        """         
 +        self.player = gst.element_factory_make("playbin2", "player") 
 +        fakesink = gst.element_factory_make("fakesink", "fakesink") 
 +        self.player.set_property("video-sink", fakesink) 
 +         
 +        audiosink = gst.element_factory_make("autoaudiosink", "audio-output") 
 +        self.recorder=Record(audiosink) 
 +        """ 
 +        @attention: next links raw data from mic to player mekanism of gstreamer  
 +        """ 
 +        self.player.set_property("audio-sink",audiosink) 
 +        self.playmode = True 
 +         
 +        bus = self.player.get_bus() 
 +        bus.add_signal_watch() 
 +        bus.connect("message", self.on_message) 
 +         
 +         
 + 
 +    def on_message(self, bus, message): 
 +        t = message.type 
 +        if t == gst.MESSAGE_EOS: 
 +            self.player.set_state(gst.STATE_NULL) 
 +            self.playmode = False 
 +        elif t == gst.MESSAGE_ERROR: 
 +            self.player.set_state(gst.STATE_NULL) 
 +            err, debug = message.parse_error() 
 +            print "Error: %s" % err, debug 
 +            self.playmode = False 
 +                 
 +    def play(self): 
 +        self.recorder.rec() 
 +        self.player.set_state(gst.STATE_PLAYING) 
 +        print "playing" 
 +         
 +         
 +    def stop(self): 
 +        #self.playmode = False 
 +        self.player.set_state(gst.STATE_NULL) 
 +        self.recorder.stoprec() 
 +        print "stoped" 
 + 
 + 
 + 
 + 
 + 
 +class MeHear(hildon.Program): 
 +    def __init__(self): 
 +        self.pl= player()   
 +                        
 +         
 +    def amplify_button_clicked(self,button, label):    
 +        buttontext = button.get_label() 
 +        text =  buttontext 
 +        if text == "AMPlify" : 
 +            label.set_text("") 
 +            button.set_label("Stop") 
 +            self.pl.play() 
 +            print "play button pressed" 
 +             
 +        if text == "Stop" : 
 +            label.set_text("Stopped") 
 +            button.set_label("AMPlify") 
 +            self.pl.stop() 
 +            print "stop button pressed" 
 +             
 +         
 +             
 +    def main(self): 
 +        win = hildon.StackableWindow() 
 +      
 +        # Create and pack labels 
 +        vbox = gtk.VBox(False, 10) 
 +        hbox = gtk.HBox(False, 10) 
 +      
 +        #interface.. buttons, labels ,... etc 
 +        labelHeader = gtk.Label("Application header") 
 +        labelSubHeader = gtk.Label("-") 
 +      
 +#        buttonGTK1 = gtk.Button("Record") 
 +#        buttonGTK1.connect("clicked", self.record_button_clicked, labelSubHeader) 
 +      
 +        buttonGTK = gtk.Button("AMPlify") 
 +        buttonGTK.connect("clicked", self.amplify_button_clicked, labelSubHeader) 
 +      
 +#        hbox.pack_start(buttonGTK1, True, True, 0) 
 +        hbox.pack_start(buttonGTK, True, True, 0) 
 +      
 +        vbox.pack_start(labelHeader, True, True, 0) 
 +        vbox.pack_start(labelSubHeader, True, True, 0) 
 +        vbox.pack_start(hbox, True, True, 0) 
 +         
 +         
 +      
 +        # Add label's box to window 
 +        win.add(vbox) 
 +      
 +        win.connect("delete_event", gtk.main_quit) 
 +      
 +        win.show_all() 
 +      
 +        gtk.main() 
 +     
 +     
 +if __name__ == "__main__":   
 +     
 +    app = MeHear()  
 +    app.main() 
 +</code> 
 + 
 + 
 + 
 +===== Sending SMS ===== 
 + 
 +  * Group: Japskua 
 +  * Description: Sends a text message to a given number 
 + 
 +<code python sms.py> 
 +import dbus 
 + 
 +############################################################################################ 
 +""" HERE IS THE VERY EVIL PART OF THE CODE! DON'T TOUCH! WILL PROBABLY MESS THE PHONE!!!!""" 
 + 
 +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  
 + 
 + 
 +################################################### 
 +""" VERY EVIL PART OVER, NOW TO THE NORMAL PART """ 
 + 
 + 
 + 
 +class Messager(object): 
 +    """ 
 +    @summary: This is the Messager class, that handles sending SMS messages 
 +    """ 
 +     
 +    def __init__(self): 
 +        """  
 +        @summary: The Constructor, initializes the dbus  
 +        """ 
 +        self.bus = dbus.SystemBus() 
 +        self.smsobject = self.bus.get_object('com.nokia.phone.SMS', '/com/nokia/phone/SMS/ba212ae1') 
 +        self.smsiface = dbus.Interface(self.smsobject, 'com.nokia.csd.SMS.Outgoing') 
 + 
 +     
 +    def Send(self, message, number): 
 +        """  
 +        @summary: The Send function, that actually sends the given message 
 +        @param message: The message to be sent 
 +        @type message: String 
 +        @param number: The number to send the message to (can be with country code also) 
 +        @type number: String 
 +        """ 
 +        arr = dbus.Array(createPDUmessage(number.replace('+', '00'), message)) 
 +        msg = dbus.Array([arr]) 
 +        self.smsiface.Send(msg, '') 
 +         
 +if __name__ == "__main__": 
 +    messager = Messager() 
 +    messager.Send("Hello man, testing", "0400558160") 
 +</code> 
 + 
 + 
 +===== Making Phone Calls ===== 
 + 
 +  * Group: Japskua 
 +  * Description: Makes a phone call to given number 
 + 
 +<code python call.py> 
 +''' 
 +Created on Aug 18, 2011 
 + 
 +@author: Japskua 
 +''' 
 + 
 +import dbus 
 + 
 +class Caller(object): 
 +    """  
 +    @summary:  This is the Caller class that makes the phone calls 
 +    """ 
 +     
 +    def __init__(self): 
 +        """  
 +        @summary: The Constructor  
 +        """ 
 +        # Do nothing 
 +        self.bus = dbus.SystemBus() 
 +        self.csd_call = dbus.Interface(self.bus.get_object("com.nokia.csd", 
 +                                                      "/com/nokia/csd/call"), 
 +                                                      "com.nokia.csd.Call") 
 +         
 +    def Call(self, number): 
 +        """  
 +        @summary: The function to Call to a given number  
 +        @param number: The number to call to 
 +        @type number: String 
 +        """ 
 +        self.csd_call.CreateWith(str(number), dbus.UInt32(0)) 
 +     
 + 
 +if __name__ == '__main__': 
 +    caller = Caller() 
 +    caller.Call("0400558160") 
 +</code> 
 + 
 +===== Creating Buttons with Images ===== 
 + 
 +  * Group: Japskua 
 +  * Description: How to create buttons with functions, data and images 
 +  *   * Creating multiple buttons 
 +  *   * Adding functions to buttons 
 +  *   * Adding images to buttons 
 + 
 +The image used here: {{:maemo:preview.jpg|The "Home" Button}} 
 + 
 +<code python window_with_buttons.py> 
 + 
 +# First import all the neccesary libraries 
 +import gtk 
 +import hildon 
 +  
 +# This is an example callback function that can be put to a button and used to receive stuff 
 +# All buttons print hello world, but if it has data included, will print that aswell 
 +def hello(widget, data): 
 +    print "Hello World!" 
 +    if data != None: 
 +        print "Data: ", data 
 +  
 +def main(): 
 +    # Get an instance of HildonProgram. It is an object used to represent an 
 +    # application running in the Hildon framework. 
 +    program = hildon.Program.get_instance() 
 +  
 +    # create a new hildon window 
 +    window = hildon.Window() 
 +  
 +    # Registers a window as belonging to the program 
 +    program.add_window(window) 
 +  
 +    # When the window is given the "delete_event" signal (this is given by the 
 +    # window manager, usually by the "close" option, or on the titlebar), we 
 +    # ask it to call the delete_event () function as defined above. The data 
 +    # passed to the callback function is None and is ignored in the callback 
 +    # function. 
 +    window.connect("delete_event", gtk.main_quit, None) 
 +  
 +    # Create three different buttons: 1st with no data, 2nd with data and 3rd as an Image 
 +    button1 = hildon.Button(gtk.HILDON_SIZE_AUTO, hildon.BUTTON_ARRANGEMENT_VERTICAL, "First Button, no data") 
 +    button2 = hildon.Button(gtk.HILDON_SIZE_AUTO, hildon.BUTTON_ARRANGEMENT_VERTICAL, "Second Button, with data") 
 +    button3 = hildon.Button(gtk.HILDON_SIZE_AUTO, hildon.BUTTON_ARRANGEMENT_VERTICAL, "") 
 +  
 +    # When the button is given the "clicked" signal, we ask it to call the 
 +    # hello () function as defined above. If the data passed to the callback 
 +    # function is None and is ignored in the callback function. 
 +    button1.connect("clicked", hello, None) 
 +    button2.connect("clicked", hello, "a lot of numbers here") 
 +    button3.connect("clicked", hello, None) 
 +     
 +    # Set the button to have an image 
 +    # First we need to load the image from file 
 +    image = gtk.image_new_from_file("preview.jpg") 
 +    # and then to set it to the button 
 +    button3.set_image(image) 
 +     
 +    # Now we create a button box, which is an container that can have multiple buttons in it 
 +    # The one used here is Vertical box, that places the buttons on top of each other, but 
 +    # you could create HButtonBox() that is a horizontal box, that puts buttons next to 
 +    # each other 
 +    buttonBox = gtk.VButtonBox() 
 +     
 +    # Here the layour is defined to spread the buttons evenly, options to use here are 
 +    # gtk.BUTTONBOX_SPREAD, gtk.BUTTONBOX_EDGE, gtk.BUTTONBOX_START and gtk.BUTTONBOX_END 
 +    buttonBox.set_layout(gtk.BUTTONBOX_SPREAD) 
 +    
 +    # And then finally add all the buttons to the buttonBox 
 +    buttonBox.add(button1) 
 +    buttonBox.add(button2) 
 +    buttonBox.add(button3) 
 +    # And then the buttonBox to the window 
 +    window.add(buttonBox) 
 +     
 +     
 +  
 +    # The final step is to display this newly created widget and all widgets it 
 +    # contains. 
 +    window.show_all() 
 +  
 +    # All GTK+ applications must have a gtk_main(). Control ends here and waits 
 +    # for an event to occur (like a key press or mouse event). 
 +    gtk.main() 
 +  
 +if __name__ == "__main__": 
 +    main() 
 +</code> 
 + 
 +===== Creating buttons ===== 
 + 
 +  * Group: Group 2 
 +  * Description: It creates 2 buttons and 2 labels, pressing the buttons change the text of one of the labels. 
 + 
 +<code python buttons.py> 
 +''' 
 +Created on Aug 18, 2011 
 + 
 +@author: Group 2 
 +@summary: Button example 
 +''' 
 + 
 +import sys 
 +import gtk 
 +import hildon 
 +  
 +def menu_button_clicked(button, label): 
 +    buttontext = button.get_label() 
 +    text = "Last option selected:\n%s" % buttontext 
 +    label.set_text(text) 
 +  
 +def main(): 
 +    win = hildon.StackableWindow() 
 +  
 +    # Create and pack labels 
 +    vbox = gtk.VBox(False, 10) 
 +    hbox = gtk.HBox(False, 10) 
 +    
 +    #interface.. buttons, labels ,... etc 
 +    labelHeader = gtk.Label("Application header") 
 +    labelSubHeader = gtk.Label("-") 
 +   
 +    buttonGTK1 = gtk.Button("None") 
 +    buttonGTK1.connect("clicked", menu_button_clicked, labelSubHeader) 
 +     
 +    buttonGTK2 = gtk.Button("Hello") 
 +    buttonGTK2.connect("clicked", menu_button_clicked, labelSubHeader) 
 +     
 +    hbox.pack_start(buttonGTK1, True, True, 0) 
 +    hbox.pack_start(buttonGTK2, True, True, 0) 
 +     
 +    vbox.pack_start(labelHeader, True, True, 0) 
 +    vbox.pack_start(labelSubHeader, True, True, 0) 
 +    vbox.pack_start(hbox, True, True, 0) 
 +     
 +    # Add label's box to window 
 +    win.add(vbox) 
 +  
 +    win.connect("delete_event", gtk.main_quit) 
 +  
 +    win.show_all() 
 +  
 +    gtk.main() 
 +  
 +if __name__ == "__main__": 
 +    main()
 </code> </code>