Please note that as of October 24, 2014, the Nokia Developer Wiki will no longer be accepting user contributions, including new entries, edits and comments, as we begin transitioning to our new home, in the Windows Phone Development Wiki. We plan to move over the majority of the existing entries. Thanks for all your past and future contributions.

Archived:How to develop a Geo-scheduler application - Part 1

From Wiki
Jump to: navigation, search

Archived.pngAquivado: Este artigo foi arquivado, pois o conteúdo não é mais considerado relevante para se criar soluções comerciais atuais. Se você achar que este artigo ainda é importante, inclua o template {{ForArchiveReview|escreva a sua justificativa}}.

All PySymbian articles have been archived. PySymbian is no longer maintained by Nokia and is not guaranteed to work on more recent Symbian devices. It is not possible to submit apps to Nokia Store.

Article Metadata
Created: croozeus (11 Jul 2008)
Last edited: hamishwillee (31 May 2013)
Featured Article
10 Aug



Do you want to develop location-based applications?

This article is the first in a series approaching all the basics for developing a location-based application for mobile devices. The application can be defined as a Geo-Scheduler or a Location scheduler. The simplest rapid mobile application development tool, PySymbian, is used to develop the application.

The following modules are used when developing this application:

  • appuifw module
  • audio module
  • e32 module
  • time module
  • os module
  • location module

The extensions listed above can be downloaded from the Archived:PySymbian C++ Extensions.

Development tools

1) A text editor

(Preferred editor: Python's IDLE - Integrated DeveLopment Environment)

2) PySymbian

(Preferred version: latest release 1.4.4)

3) PySymbian script shell

(Preferred version: Latest release 1.4.4)

4) Extensions listed above which are not bundled with PySymbian

The PySymbian tools can be downloaded from Sourceforge resources.

Basic approach

In this application, localization is done using the network information. The network information can be provided using the location module, cellid. If you are not familiar with retrieving the cellid using Pys60, using the appswitch module, or using the envy module, read the following articles before you proceed.

Archived:How to switch application in foreground using PySymbian

Archived:How to use the PySymbian Envy module

Archived:How to get info on cell location in PySymbian

Methods and functions

The following methods or functions are used:

File functions

1) save_location: Save location information into file

2) load_location: Read location information into variables

3) save_reminder: Save reminder information into a file

4) load_reminder: Read reminder information into variables

5) dictionary_copy: Dictionary copy

6) location_list: Return the location names

Feature functions

1) add_location: Add a new location

2) edit_location: Edit a location

3) add_reminder: Add a new reminder

4) edit_reminder: Editing screen function

5) edit_reminder_bylocation: Edit reminder by location function

6) edit_reminder_byreminder: Edit reminder by reminder function

Application operations

1) ms_handler: MS option handler

2) main: Start program

3) tracker: Main tracker function

4) background_handler: Background handler options

Part 1

This article - Part 1 - discusses the File functions in detail.


This function adds the location information to the database file. A file handler named file_handler is created to handle file operations. A .dat file specified by the variable file_handler_location is accessed here. In this example, the location.dat file is in C:, and it is assigned to the file_handler_location.

Note: location.dat contains locations added by the save_location() function.

file_handler_location = "c:\\location.dat"

The geo and cellids are populated before running the file functions to NULL.

Note: The geo and cellids must be cleared by using the clear() function so that they do not contain any previously used values.

The definition for the save_location() function is as follows:

def save_location():
file_handler = file(file_handler_location, "w")
temporary = dictionary_copy(cellids)
for cell, loc in temporary.items():
file_handler.write(str(cell) + ':' + str(loc) + '\n')
cellids[cell] = loc
geo[loc] = cell

The function dictionary_copy(cellids) is defined here.


This function is responsible for loading the locations into variables. Here the value of the cellid is stored into variables.

The same file_handler and the file_handler_location are used to access the location.dat this time to read the location values.

 file_handler = file(file_handler_location, "r")

Using iterations, location.dat is read for locations/values of cellid. The values are loaded to variable geo[loc].

geo and cellids variables are populated before calling the load function.

 cellids = {}
 geo = {}

The definition for the load_location() function is as follows:

def load_location():
file_handler = file(file_handler_location, "r")
for line in file_handler:
cell, loc = line.split(":")
cell = cell.strip()
loc = loc.strip()
cellids[cell] = loc
geo[loc] = cell


The save_reminder() function adds a new reminder to the file.

The file_handler_reminder is referenced in the .dat file used to record reminders.

In the following example, the reminder.dat file is in C:, and it is assigned to the variable file_handler_reminder.

file_handler_reminder = "c:\\reminder.dat"

dictionary_copy(items) is defined here. It returns the value of the temporary variable which was initialized as NULL in the scope of the dictionary_copy(dictionary) function.

The reminder string and the value of the cell are written to the file reminder.dat.

The definition for the save_reminder() function is as follows:

def save_reminder():
file_handler = file(file_handler_reminder, "w")
temporary = dictionary_copy(rems)
for i, value in enumerate(temporary.values()):
file_handler.write(str(i) + ':' + str(value['cell']) + ':' + str(value['date']) + ':' + value['desc'] + '\n')
rems[str(i)] = {'cell':value['cell'], 'date':value['date'], 'desc':value['desc']}


This function reads the reminders in the file_handler_reminder, that is, from the reminder.dat file.

file_handler is used to open the reminder.dat to read values.

The values of the </tt>reminder.dat (description) are loaded into the variable <tt>rems (reminders).

rems[id] = {'cell':cell, 'date':str(date), 'desc':desc}

Finally, the definition for load_reminder() is as follows:

def load_reminder():
temporary = {}
file_handler = file(file_handler_reminder, "r")
for line in file_handler:
id, cell, date, desc = line.split(":")
id = id.strip()
cell = cell.strip()
date = date.strip()
desc = desc.strip()
rems[id] = {'cell':cell, 'date':str(date), 'desc':desc}


In save_location and save_reminder, the function returns the value of the temporary variable.

A parameter must be passed to the dictionary function.

For example, in the ave_location() function it is used as follows:

temporary = dictionary_copy(cellids)

The definition of dictionary_copy() is:

def dictionary_copy(dictionary):
return dict(dictionary)


location_list(): Return the location names

There is no need to pass a parameter to this function. However, the variable cellids can always be passed for its global. However, the preferred way is to have it without the parameters.

In the same way as the function dictionary_copy(dictionary), this also returns the temporary variable, but from the items of the cellids variable.

The definition for the location_list() function is:

def location_list():
return [unicode(loc) for loc in cellids.values()]

That finishes the file functions (Part 1) for the Geo-scheduler.

These functions are called when the user selects an action from a custom menu.


These screenshots demonstrate the menu and how these functions are be used. The screenshots are relevant only to Part 1.

Screenshot0016.jpg Screenshot0017.jpg

Screenshot0021.jpg Screenshot0022.jpg

See also

This page was last modified on 31 May 2013, at 01:08.
72 page views in the last 30 days.