A New Version of MediaBox Media Center

Finally, after several months of work I have now released MediaBox 0.96, which was really overdue... ;)

A lot of people were very helpful and regularly tried out the code fresh from SVN during the last few months and provided lots of feedback. Thanks to you all!
Special thanks also go to Hugo Baldasano for his work on asynchronous networking and for good help with UPnP event handling!

The long wait is now over and MediaBox 0.96 is available in the maemo-extras repository for Chinook and Diablo. The .deb packages for users of OS 2006 (yes, that's Nokia 770) and OS 2007 will be made available soon on the MediaBox homepage.

UPnP Streaming



UPnP/DLNA is a great technology for streaming music, videos, and photos to your
tablet. Simply put an UPnP media server in your home network and MediaBox
will discover it automatically for browsing and streaming its contents.

Playlists and media bookmarks

Playlists can be created and edited and are saved automatically. You can reorder the items at any time, and you can mix audio, videos, and images in a playlist.

You can now also set media bookmarks in any (seekable) file to mark the best spots and to find the place where you stopped listening to your audio book or podcast the last time. Simply click on the star-button to set a media bookmark for the current position.

Shuffle and Repeat

I don't think I need to say much about these features anymore, except that MediaBox can do it now, too.

Car-Mode


Car-mode is what I call the fullscreen mode of the music player because it's very handy to use while driving a car. Big buttons for previous, next, and play/pause, along with big cover-art and a big title label make MediaBox perfect for this situation. I use this mode frequently with a shuffled playlist when driving.

Themes



It seems like every media center these days needs to be themable. MediaBox follows this fad so you can give it a new skin by downloading themes from the maemo-extras repository.
The first extra theme available is called "DarkBox", and hopefully others and betters will follow. I'm going to give more details on theming and building theme packages later. It's really easy, so get your GIMP or Photoshop ready! :)

Plugins



MediaBox can be extended with plugins, and I'm going to cover plugin development later. Some plugins are already available for download:

• a FM radio (for the N800),


• a YouTube browser


• and internet radio with SHOUTcast directory.

Tablet Python #4 - Sources of Memory Leaks

Marius Gedminas blogged an interesting article about memory leaks in Python. On the tablet you don't have much memory available, so memory leaks will annoy the users very quickly.

Python is a garbage-collected language (like Java or C#), so memory leaking is normally not an issue, but there are situations where you should be careful.

Bindings to C libraries

Many modules are bindings to C or C++ libraries, and memory leaking is unfortunately quite common in those languages, esp. in complex libraries. A hot candidate for memory leaking on the maemo platform are the GdkPixbuf operations.

GdkPixbufs get not automatically garbage collected by Python. Always use del on a GdkPixbuf explicitly when you don't need it any longer.


The __del__ destructor method

Classes can have some sort of destructor method in Python.

  def __del__(self):
  
      ...

This is called when you use del on the last reference you are holding. But be very careful! Classes overriding this destructor method are not eligible for breaking reference cycles by the garbage collector anymore! They have to be released manually. It's normally not necessary to override the __del__ method, so you better stay away from it.

Always take special care when dealing with classes overriding the __del__ method. Cyclic references involving such classes cannot be resolved by the garbage collector automatically.

Tablet Python #3 - List Comprehension

A Happy New Year to everyone! In today's episode of Tablet Python I'm going to tell you more about list comprehension which we were already using in the last episode.

Introduction

List comprehension is a unique feature of the Python language (correct me if I'm wrong). It might look intimidating at first, but believe me, it can soon become one of your best friends in Python. It's so elegant and simple!

But let's approach this step by step.

Step 1: You can copy lists

Let's define a list

a = [1, 2, 3]

You can make a copy of a by iterating through the elements in a, like this:

copy_of_a = []
for element in a:
    copy_of_a.append(element)

This is about the way you would do it in any other language. But with list comprehension, you would simply write:

copy_of_a = [ element for element in a ]

This simply says, build a list and for every element in a, put element into this list. Then assign the new list to the variable copy_of_a.

For completeness, I want to tell you, however, that the easiest way to copy a list in Python goes by "slicing":copy_of_a = a[:]

Step 2: You can build modified copies

Let's assume you have a list of filesystem paths and would like to strip off the path so that only the filename remains.

This is our list:

a = ["/home/user/file1", "/media/mmc1/file2", "/media/mmc2/file3"]

And this is what we want to get:

["file1", "file2", "file3"]

The classic way goes like this:

b = []
for element in a:
    b.append(os.path.basename(element))

But with list comprehension, you'd do it like this:

b = [ os.path.basename(element) for element in a ]

Or in words: build a list, and for every element in a, apply os.path.basename() on element and put the result into the new list. Then assign the new list to the variable b.

Step 3: You can filter lists

Now let's take a look at the list comprehension construct from the last episode:

resources = [ f for f in os.listdir(_RESOURCE_PATH) if f.endswith(".png") ]

Can you guess what it does?
Build a list, and for every f in the result of os.listdir(_RESOURCE_PATH), put f into the new list if f.endswith(".png") returns True. Then assign the new list to the variable resources.
It's the same as:

resources = []
for f in os.listdir(_RESOURCE_PATH):
    if f.endswith(".png"):
        resources.append(f)

... but way shorter, less error-prone, and easier to read!

Step 4: You can combine modifying and filtering

Let's take this to the extreme by modifying and filtering a list at the same time:

a = [ str(c) for c in range(100) if (c % 5 == 0) ]

This builds a list a which contains as strings those numbers in the range between 0 and 99, which can be divided by 5.
This would be

a = []
for c in range(100):
    if (c % 5 == 0):
        a.append(str(c))

for all those poor people who cannot use list comprehension.

Step 5: Still confused? It's simply a mathematical set notation!

Do you remember this notation?

List comprehension in Python is just the same!

B = [ x*x for x in A if (x % 5 == 0) ]

And that's the secret key which helps you understand it.

Conclusion

Generally, list comprehension helps you write cleaner code. It expresses how you think about solving the problem instead of describing every step necessary to solve the problem. Once you get used to it, it's a much more intuitive way of working with lists.
A feature of higher-level (functional) languages is that you can make the computer solve problems by describing what you want, instead of giving step-by-step instructions on how to solve it.
However, as with every powerful tool, use it wisely. It's e.g. generally not a good idea to use list comprehension to shorten code with side-effects. Don't use list comprehension to make your code shorter, but to make it understandable.

Tablet Python #2 - Resource Modules

Introduction

In this second episode of Tablet Python, I'm going to tell you about an easy way to make resource modules. A resource module is a Python module which you can import for loading resources such as images, fonts, or whatever you want.

For example:

import graphics
  
img = gtk.Image()
img.set_from_pixbuf(graphics.icon)

Implementation

In episode #1 we talked about writing relocatable software. We are going to apply the same technique for resource modules, since they will be relocatable as well.

Our resource modules are Python packages, i.e. a subdirectory with a __init__.py file in it. The name of the directory will be the module's name. Be careful to only use valid characters (characters valid for Python variables) in the directory name and the filenames of the resource files (e.g., my_icon.png is OK, while my-icon.png would be not!).

Let's assume the following filesystem structure for our example:

  graphics/
    + __init__.py
    + icon.png
    + logo.png
    + background.png
        
  test.py

The package directory will also contain the resource files. In order to access them, we'll have to put them into the module namespace. Write the following into graphics/__init__.py:

import os
import gtk

_RESOURCE_PATH = os.path.dirname(__file__)

def _load_resources():

    # Find all .png files in the resource directory. This construct is called
    # "list comprehension" and will be covered in detail in episode #3.
    # This returns a list of the names of all files in the resource directory
    # ending with ".png".
    resources = [ f for f in os.listdir(_RESOURCE_PATH)
                  if f.endswith(".png") ]
                    
    # load resources into module namespace
    for r in resources:

        # the filename without extension will be the name to access the
        # resource, so we strip off the extension
        name = os.path.splitext(r)[0]
          
        # this is the full path to the resource file
        path = os.path.join(_RESOURCE_PATH, r)
          
        # Now we can load the resource into the module namespace.
        # globals() gives us the dictionary of the module-global variables,
        # and we can easily extend it by assigning new keys.
        globals()[name] = gtk.gdk.pixbuf_new_from_file(path)

    #end for

# load the resources when importing the module
_load_resources()

That's all. Let's test it with a tiny test program test.py:

import gtk
import graphics
  
win = gtk.Window(gtk.WINDOW_TOPLEVEL)
img = gtk.Image()
img.set_from_pixbuf(graphics.logo)
win.add(img)
win.show_all()
  
gtk.main()

You may put as many resource files as you want into the resource directory and simply access them by their name. The files are loaded only once when the module gets imported the first time. Subsequent import statements reuse the module without reloading the resources. I'm going to talk about the "singleton" nature of Python modules in a later episode.

A more sophisticated example of resource modules can be found in the theming engine of MediaBox (the subdirectory called theme).

Tablet Python #1 - Relocatable Software

Python is becoming more and more popular for development on the Nokia internet tablets. It is indeed a very powerful and clear language and makes it easy to write applications that work on all internet tablet versions.

With this post I'm starting a new series on nice Python tricks which might be interesting to tablet software developers. So, if you're doing something in Python on your tablet, this series is for you!

In this first episode I will talk about writing relocatable software. This is software which works no matter where it's installed. There are no hardwired absolute paths to resources in relocatable software.

Knowing where you are

Every Python module knows the path where it's installed. You can retrieve the module's path by reading the __file__ variable.

print "This module resides at:", __file__

This makes it easy to find the directory where your app is installed:

import os
path = os.path.dirname(__file__)

Finding your resources

So if you want to load bundled resources into your application, you know where to find them:

path = os.path.dirname(__file__)
image_file = os.path.join(path, "images", "foo.png")
img = gtk.Image()
img.set_from_file(image_file)

Starting the application

This is the way I use to make my programs executable on the tablet. All of the program files and resources are within a subdirectory (e.g. /usr/lib/myapp/) together with the executable start module, which could look like this:

#! /usr/bin/env python

from mediabox.App import App

app = App()
app.run()

Let's assume this file is /usr/lib/mediabox/MediaBox. Then I make a symbolic link to this file as /usr/bin/MediaBox, and it's all done.

If I move my software to another place, I would just have to update this link.