HabraKarma - writing an application in Python for s60

After we warmed up the appetite for Python for s60 and started learning to write applications, I want to suggest continuing to comprehend programming for symbain in the wonderful programming language python.

This time we will do something useful, namely, we will write an application that will show karma. Do not just show, but display on top of all the “windows” a sign, on which will be the value of karma and the difference with the previous value. In addition, the program will publish a victorious gong with an increase in karma and a cry of despair as it decreases. Everything else, we run it as a server, that is, it will not appear in the list of running programs.

For those who are more important result than the process, welcome to the end of the article, where you expect a ready 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, know how to 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 restrictions.

Since the server is running in the background, it cannot use the appuifw UI module. But we don’t need it, because we’ll show the result of work using the topwindow module, which allows you to display images on top of all the “windows”. In addition, another module is available to us, called globalui, which also allows you to display such things as various requests, warnings, notifications, etc. on top of all the “windows”. This will also be used to demonstrate the start and stop of 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, configuration files, we need to put it in some neutral place, for example, in the x: / system / data / AppName folder. This folder has the attribute "hidden", so the pictures placed there will not be visible in the gallery, and the audio files in the library.

Another problem is the “isolation” of the server from the main program. That is, we can start it, but it is impossible to find out whether it is running or to stop when using standard modules. In our program we will proceed as follows:

The server, when launched, creates a file with the name habra_flag in the root of drive D. When the server is shut down, this file will be deleted. Now, when starting the shell, check if the file you are searching for exists. If yes, then the server is considered running. In addition, you need the ability to stop the server. For this, in this very file we will write down something, and on the server, in a loop, we will check. If the file is longer than zero, stop the work.

Some may have a question, what kind of disk D, to which we are going to write the file habra_flag. This is a ram disk, of small volume, which is cleared on reboot Using it, we kill two birds with one stone: when you restart the phone, manually shut down our server, the flag file will disappear, 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 muzzle of the application, which will be launched by clicking on the program icon, will be the Form class, which is practically completely described 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. # folder in which settings files, media files, etc. are located.
6. data_path = os . getcwd ( ) [ 0 ] + u ': \\ System \\ data \\ HabraKarma \\ '
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 'Habrayuzer' , 'text' , self . settings [ 'user' ] ) ,
17. ( u "Auto update (min.)" , 'number' , self . settings [ 'time' ] ) ,
18. ( u "Enable sound?" , 'combo' , ( [ u 'Yes' , u 'No' ] , int ( self . settings [ 'sound' ] ) ) ) ,
19. ( u "Count the difference" , 'combo' , ( [ u 'Since the beginning of work' , u 'Since last update' ] , int ( self . settings [ 'diff' ] ) ) )
20. ( u "Position X" , 'number' , self . settings [ 'X' ] ) ,
21. ( u "Position Y" , 'number' , self . settings [ 'Y' ] ) ,
23. ]
24. # create a form with flags
25. self . form = Form ( self . fields , flags = FFormDoubleSpaced | FFormEditModeOnly )
26. # set the function that will save the 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 'Run' , self . start_server ) ]
33. # "execute" the form, that is, it will be displayed on the screen, as long as
34. # we will not leave it.
35. self . form . execute ( )
36. # after exiting the form, check if the server is running and suggest to start it
37. if not os . path . exists ( u 'd: \\ habra_flag' ) :
38. if query ( u 'Run?' , 'query' ) :
39. self . start_server ( )
41. def start_server ( self ) :
42. # actually server startup function
43. self . form . menu = [ ( u 'Stop' , self . stop ) ]
44. e32. start_server ( data_path + 'server.py' )
46. def stop ( self ) :
47. # server stop function.
48. self . form . menu = [ ( u 'Run' , self . start_server ) ]
49. open ( u 'd: \\ habra_flag' , 'w' ) . write ( 'stop' )
51. def save ( self , arg = None ) :
52. # take 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
62. a = Main ( )

It remains to write the server :)

1. # - * - coding: utf-8 - * -
2. import os
3. import e32
4. import sys
5. # redirect errors to the 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 ( '' )
15. data_path = os . getcwd ( ) [ 0 ] + u ': \\ System \\ data \\ HabraKarma \\ '
16. # show that we started.
17. ui. global_note ( u 'Habrastart!' )
19. class Habra:
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 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. # specify 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 ( )
43. def stop ( self ) :
44. self . loop = False
45. self . top . hide ( )
47. def karma_screen ( self ) :
48. # function called for update
49. self . update_screen ( )
50. e32. ao_sleep ( 0.2 )
51. # pull info from harba api
52. data = urllib . urlopen ( 'http://habrahabr.ru/api/profile/' + self . settings [ 'user' ] ) . read ( )
53. # they probably stumble me, but I don't want to drag it
54. # case library for parsing xml
55. karma = float ( data. split ( '<karma>' ) [ 1 ] . split ( '</ karma>' ) [ 0 ] )
56. # compare new karma with old and
57. # depending on the situation, collect the text, specify the color
58. # and play the sound, if it is set in the settings
59. if self . last_karma < 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
73. if self . settings [ 'diff' ] :
74. self . last_karma = karma
75. open ( data_path + 'karma.dat' , 'w' ) . write ( repr ( karma ) )
77. # here we will find out how many pixels the width of the text to occupy
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 the 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 ) )
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 ) )
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 ) )
97. def mainloop ( self ) :
98. # and let the main server loop
99. interval = self . settings [ 'time' ] * 60
100. count = 0
101. while self . loop :
102. # if we are ordered to 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 the time is right, we expose karma.
109. if count > interval:
110. count = 0
111. self . karma_screen ( )
112. e32. ao_sleep ( 1 )
115. habr = Habra ( )

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

Sources, along with pictures, sounds, an icon can be taken HERE . In ensymble in the build options to register:
--extrasdir = data --lang = RU --icon = path_to_connect

And take the result ...

So, I present to your attention the application HabraKarma for symbain 9.x
Install the application, enter your username, configure the update time, the position of the window. 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 going back to the program.
Download from here (sis, 56 kb, does not require a signature)
Do not forget that the work requires Python Runtime at least version 1.9.7 ( download ).
Python and the program to put on the same disk!