HabraKarma - writing a Python application for s60

After we have developed an appetite for Python for s60 and started learning how to write applications, I want to offer to continue to understand programming for symbain in the wonderful programming language python.

This time we’ll do something useful, namely write an application that will show karma. Not just to show, but to display on top of all the “windows” a plate on which the karma value and the difference with the previous value will be. In addition, the program will publish a winning gong when karma rises and a cry of despair when it drops. In addition, we will launch it as a server, that is, it will not be displayed in the list of running programs.

For those who are more interested in the result than the process, you are welcome to the end of the article, where you are expectedfinished application HabraKarma 1.0 !!!

This time, I will not comment on every line in the program. I mean that you are at least a little familiar with python, can read the documentation , and at least understand something from my previous article .

General principles of work

The program itself will consist of 2 parts: the server itself, which does all the work, and the GUI, in which we will configure the server, start it and stop it.

The server itself is started by the start_server function from the e32 module. The function has only one parameter - the full path to the Python script, which should be run as a server. Yes, yes, everything is so simple, but with some limitations.

Since the server is running in the background, it cannot use the appuifw module, which is responsible for the UI. But we don’t need it either, as we will demonstrate the result of the work using the topwindow module, which allows you to display images on top of all “windows”. In addition, we have access to another module, called globalui, which also allows us to display things such as different requests, warnings, notifications, etc. on top of all “windows”. We will also use this, demonstrating the fact of starting and stopping the server.

Another limitation is the inability to access files located in the application folder (x: / private / UID). Therefore, if we want to use various multimedia files, settings files, we must put this in some neutral place, for example, in the x: / system / data / AppName folder. This folder has the “hidden” attribute, therefore the pictures placed there will not be visible in galleries, but audio files in the library.

Another problem is the "isolation" of the server from the main program. That is, we can start it, but we can’t find out if it is running, or stop it using standard modules. In our program, we will proceed as follows:

The server, at startup, creates a file called habra_flag in the root of drive D. When the server is shut down, this file will be deleted. Now, when you run the shell, check to see if the file you are looking for exists. If yes, then we consider the server running. In addition, you need the ability to stop the server. To do this, we’ll write something into this file, but on the server, in a loop, we will check. If the file length is greater than zero, we stop work.

Some may ask what kind of drive D we are going to write the habra_flag file to. This is a ram disk, of small volume, which is cleared upon reboot. Using it, we kill two birds with one stone: when the phone is rebooted, our server is manually terminated, the file with the flag disappears, and the file system on the ram disk has great performance. For more complex interaction with the server, you can use sockets.

Writing UI

The face of the application, which will be launched by "clicking" on the program icon, will be the Form class, which is described almost completely and completely in this wiki article . It looks like this:



And here is the program code itself with my comments:

1. #coding: utf-8
2. from appuifw import *
3. import e32
4. import os
5. # the folder in which the settings files, media files, etc.
6. data_path = os.getcwd () [0] + u ': \\ System \\ data \\ HabraKarma \\'
7.  
8. class Main:    
9.     def __init __ (self):
10.         app.screen = 'normal'
11.         # read the settings file, which is a dictionary,
12.         # stupidly saved via repr :)
13.         self.settings = eval (open (data_path + 'set.dat'). read ())
14.         # List of fields for our form, insert the saved values ​​into its fields.
15.         self.fields = [
16.                 (u'Habrauser ',' text ', self.settings [' user ']),
17.                 (u "Auto-update (min.)", 'number', self.settings ['time']),
18.                 (u "Turn on sound?", 'combo', ([u'Yes ', u'No'], int (self.settings ['sound']))),
19.                 (u "Count the difference", 'combo', ([u'S the beginning of work ', u'S the last update'], int (self.settings ['diff']))),
20.                 (u "Position X", 'number', self.settings ['X']),
21.                 (u "Position Y", 'number', self.settings ['Y']),
22.  
23.                 ]
24.         # create a form with flags
25.         self.form = Form (self.fields, flags = FFormDoubleSpaced | FFormEditModeOnly)
26.         # define a function that will save values ​​from the form
27.         self.form.save_hook = self.save
28.         # if the server is already running, then the menu should be “stop” and vice versa
29.         if os.path.exists (u'd: \\ habra_flag '):
30.             self.form.menu = [(u'Stop ', self.stop)]
31.         else:
32.             self.form.menu = [(u'Start ', self.start_server)]
33.         # "execute" the form, that is, it will be displayed on the screen until
34.         # we won’t get out of it.
35.         self.form.execute ()
36.         # after exiting the form, check if the server is running and offer to start it
37.         if not os.path.exists (u'd: \\ habra_flag '):
38.             if query (u 'Run?', 'query'):
39.                 self.start_server ()
40.  
41.     def start_server (self):
42.         # Actually the server start function
43.         self.form.menu = [(u'Stop ', self.stop)]
44.         e32.start_server (data_path + 'server.py')
45.  
46.     def stop (self):
47.         # server stop function.
48.         self.form.menu = [(u'Start ', self.start_server)]
49.         open (u'd: \\ habra_flag ',' w '). write (' stop ')
50.  
51.     def save (self, arg = None):
52.         # take the values ​​from the form and save them to the settings file.
53.         self.settings ['user'] = arg [0] [2]
54.         self.settings ['time'] = arg [1] [2]
55.         self.settings ['sound'] = arg [2] [2] [1]
56.         self.settings ['diff'] = arg [3] [2] [1]
57.         self.settings ['X'] = arg [4] [2]
58.         self.settings ['Y'] = arg [5] [2]
59.         open (data_path + 'set.dat', 'w'). write (repr (self.settings))
60.         return true        
61.  
62. a = Main ()

It remains to write a server :)

1. # - * - coding: utf-8 - * -
2. import os
3. import e32
4. import sys
5. # redirect errors to a file.
6. sys.stderr = open ('d: \\ err.txt', 'w')
7. import globalui as ui
8. import topwindow
9. from graphics import *
10. import urllib
11. import audio
12. open (u'd: \\ habra_flag ',' w '). write (' ')
13.  
14.  
15. data_path = os.getcwd () [0] + u ': \\ System \\ data \\ HabraKarma \\'
16. # showing that we started.
17. ui.global_note (u'Habrastart! ')
18.  
19. class Habra:
20.  
21.     def __init __ (self):
22.         # open images
23.         self.habr_img = Image.open (data_path + 'habr.png')
24.         self.update_img = Image.open (data_path + 'update.png')
25.         # read the settings
26.         self.settings = eval (open (data_path + 'set.dat'). read ())
27.         self.last_karma = eval (open (data_path + 'karma.dat'). read ())
28.         # open sound
29.         self.bad_sound = audio.Sound.open (data_path + 'bad.wav')
30.         self.good_sound = audio.Sound.open (data_path + 'good.wav')
31.         self.loop = True
32.         # create a TopWindow window
33.         self.top = topwindow.TopWindow ()
34.         # indicate rounding
35.         self.top.corner_type = 'corner5'
36.         self.top.size = (170.35)
37.         # set the position from the settings file
38.         self.top.position = (self.settings ['X'], self.settings ['Y'])
39.         self.top.show ()
40.         self.karma_screen ()
41.         self.mainloop ()
42.  
43.     def stop (self):
44.         self.loop = False
45.         self.top.hide ()
46.  
47.     def karma_screen (self):
48.         # function called to update
49.         self.update_screen ()
50.         e32.ao_sleep (0.2)
51.         # pull info with harba api
52.         data = urllib.urlopen ('http://habrahabr.ru/api/profile/'+self.settings [' user ']) .read ()
53.         # I’m probably stumbled, but I don’t want to pull in this
54.         # case library for parsing xml
55.         karma = float (data.split ('') [1] .split ('') [0])    
56.         # compare the new karma with the old and 
57.         # depending on the situation, collect the text, specify the color
58.         # and play sound, if set in the settings
59.         if self.last_karma
60.             karma_diff = u '(+' + str (abs (self.last_karma-karma)) + u ')'
61.             karma_color = 0x009f31
62.             if not self.settings ['sound']:
63.                 self.good_sound.play ()
64.         elif self.last_karma> karma:
65.             karma_diff = u '(-' + str (abs (self.last_karma-karma)) + u ')'
66.             karma_color = 0xc30202
67.             if not self.settings ['sound']:
68.                 self.bad_sound.play ()
69.         else:
70.             karma_diff = u ''
71.             karma_color = 0xffffff
72.  
73.         if self.settings ['diff']:
74.             self.last_karma = karma
75.         open (data_path + 'karma.dat', 'w'). write (repr (karma))
76.  
77.         # here we will find out how many pixels in width will occupy text
78.         karma_width = self.img.measure_text (unicode (karma)) [0] [2]
79.         diff_width = self.img.measure_text (karma_diff) [0] [2]
80.         # and then a matter of technology :)
81.         self.img = Image.new ((45 + karma_width + diff_width, 35))
82.         self.top.size = (self.img.size [0], 35)
83.         self.img.text ((35.25), unicode (karma))
84.  
85.         self.img.text ((35 + karma_width + 5.25), karma_diff, fill = karma_color)
86.         self.img.blit (self.habr_img)
87.         self.top.add_image (self.img, (0,0))
88.  
89.     def update_screen (self):
90.         # this will be displayed during the update
91.         self.img = Image.new ((165.35))
92.         self.top.size = (self.img.size [0], 35)
93.         self.img.blit (self.update_img)
94.         self.img.text ((35.25), u'Updated ')
95.         self.top.add_image (self.img, (0,0))
96.  
97.     def mainloop (self):
98.         # and start the main server loop
99.         interval = self.settings ['time'] * 60
100.         count = 0
101.         while self.loop:
102.             # if so ordered, stop the server
103.             if open (u'd: \\ habra_flag '). read ():
104.                 os.remove (u'd: \\ habra_flag ')
105.                 ui.global_note (u'Habrastop! ')
106.                 self.loop = False
107.             count + = 1
108.             # if it’s time, we expose karma.
109.             if count> interval:
110.                 count = 0
111.                 self.karma_screen ()
112.             e32.ao_sleep (1)
113.  
114.  
115. habr = Habra ()

It remains to collect the whole thing in sis and watch karma :)

Sources, along with pictures, sounds, an icon can be taken HERE . In ensymble, in the assembly options, write:
--extrasdir = data --lang = RU --icon = icon_path

And take the result ...

So, I present to your attention the HabraKarma application for symbain 9.x
Install the application, enter your username, configure the update time, window position. Now you can start the server, which will display your karma on top of all windows. After that, the program can be closed, the window will remain until you turn it off by entering the program again.
Download HERE (sis, 56 kb, no signature required)
Do not forget that Python Runtime no lower than version 1.9.7 is required to work ( download ).
Put Python and the program on the same drive!