So I have created a sample C project for webOS 2 that bundles all your python files into an ipk (so you can distribute this app using the App Catalog) and also launched the Python interpreter when you click on it!
The only condition is that you have to copy all the Python interpreter + WebOS API + PyGame into /media/internal. You can do this just following this simple steps
1] Download this compressed files that contains: Python, PyGame and WebOS API to your computer
Python + PyGame for WebOS (Binaries)
2] Unpack and copy “python” directory to the root directory of your SD Card (must previously mount the phone as Mass Storage Device)
3] Download PDL-Python Template
PDL Template Project
4] Modify, add source code…. IMPORTANT: modify app name, package name
5] Copy the binary to “release”
6] Copy all python source code to “release” (or just work in that directory
7] Create a package with palm-package
8] Install it with palm-install
Have fun!
Category: webOS Programming
A picture is worth a thousand words…
Running Python from a SSH session on the Pre2
The python program…
Running a simple Python program on the Mac
Running the same simple Python program on the Pre2
The C code that launches the Python script (this code was embedded into a ipk file with the Python code)
Python and PyGame meet WebOS =)
The PalmPDK includes a toolchain of GCC in order to build C and C++ applications, and Python is a nice one. The idea behind this is to allow webOS to run Python apps, but what is more important for my is PyGame. If Python is able to run in webOS and PyGame works without much modifications, then a lot of game can be ported to webOS, and very nice applications can be done.
I wrote this idea in the Palm WebOS C/C++ a long time ago, and after a few tries without success, Thomas Perl got it working with the help of the WebOS Internals PDK http://thp.io/2011/webos/) He did a great job there, and also he is making a library for binding the Plug-In API using SWIG.
My idea now that this is working, and it works nice as you can see in Thomas’ website, is to create a “Python environment” application and a “template application”. The Python environment application will just check if you have the lastest binaries of Python + PyGame inside your SD Card (The complete Python and PyGame lib is nearly 27MBytes). If not, it will download it, and install in on the SD Card.
Once this is done, then it comes the time for the “template application”. This will be a standard SDL project, that will check if you have the “Python environment”. If not it will redirect you to the App. Catalog in order to install it. But if you have it, it will launch “main.py”, a file bundled in this project from where you can start writing your own python application.
The idea behind this is to make Python a popular language for creating games and application for WebOS. May be in a future even it’s bundled by default in WebOS and this will turn into a nice experience but useless. Until that happens, this solution seems to be very good.
webOS low level programming – basic app
For Windows and Mac OS, Palm provides a low level SDK called Plug-in Development Kit (PDK) which allows you to develop C and C++ native applications or plug-ins that can be called from a web app. In the OS X version of the PDK, a plug-in is installed in XCode (yes, you can use another IDE, but the installer gives a beautiful wizard for Xcode). So let’s create a simple application!
Inside Xcode, go to ‘File’ and click on ‘New Project’ (or Shift + Command + N). You will see a new template called SDL Application, and that is what we are going to create.
This action will create a project with a simple structure that includes some necessary files in order to run the application on your Mac. Yes, you can (fully) develop an SDL application in your Mac (or PC) and then use nearly the same code inside the Palm Pre. What is interesting about this project wizard is that includes all the header files needed, and a script file to build the project for the device.
I will add ‘-lpdl’ to ‘Other Linker Flags’which will let me do some specific calls to the OS. This has to be handle will care. Due to the fact that this functions are only available in webOS, you should place some define to avoid executing and compiling that code when building the app for the desktop simulator.
Let’s create an empty main.cpp file with it’s header file, and the start building the application step by step
Main.h includes SDL header file and also some Palm’s headers. What is more important, it will have definitions that will help running the app in the Mac and in the device properly.
Main.cpp has functions to initialize the screen, setup the device and handles events from the user interface.
The most important part of this tutorial comes now. How it looks like in the emulator? and how to build and deploy this application into the device?
For running this application on the emulator, comment the RUNNING_ON_DEVICE definition and press ‘Build and Run’ or ‘Build and Debug’ in Xcode. You will only see something a blank screen of 320×480 pixels as this application doesn’t do something more instersting.
Running inside the Palm Pre requires going to the terminal and editing a few script files. The wizard generates a file called ‘buildit_for_device.sh’ that gives us a hand with the build process but doesn’t help too much in the deployment process. This file must be editing in order to know where is the source code and how the output file is called. It will looks similar to this
As you may noticed, if you run this script, you will get a binary file called ‘simple’ app. Eventhough you can copy this file to the device and run the code, the recommended way is to generate a package and install that package using palm tools. So the next step involves packaging the application. As in the web application a description file is requiered. I created a STAGING directory and inside that directory created a file called ‘appinfo.json’ with the following content.
As this is a native application it is very important to make our binary fila as executable, using ‘echo filemode.755=simpleapp > package.properties’.
Once this files are created, we can call palm-package with STAGING as argument, and the install the package using palm-install.
This action installs the application and places an icon in the launcher. Clicking the icon runs the full screen application.
First webOS (web) App
So finally I have started to play with some programming on the Palm Pre 2. It is interesting to find that web applications runs as smooth as native onces in this device. What is more interesting is that, like Android, you can program in Windows, Linux and Mac. It is nice to know you have official tools that runs in all platforms, and you don’t have to stick with XCode or Visual Studio.
Apart from web applications, Palm’s (now HP) webOS let’s you program in C/C++ with native SDL and OpenGL 1 and 2 support. Most of low level hardware of the device can be access using standard linux procedure to open a stream and write or read. This is particularly interested because because it changes the mobile world a bit in two ways. You don’t have to root your phone (like in Android OS) or jailbreak it (like in iPhone) to access low level functions. webOS is built over a standard Linux, so if you want to take Python sources, compile it for ARM and put the library inside your C/C++ project (something I’m planning to do in the few months) YOU CAN, and it’s legal in the Application Catalog!
The second good thing about having such a strong native part in the platform is not only that web applications can make use of low level functions written in C or C++, But also that in average a C/C++ application with SDL or OpenGL can be ported to webOS in 5 hours. I tried making a simple C++ program, and the same program that runs on my Mac, runs in the Palm Pre with only two lines of code modified. So even though te platform is oriented to a high level development based on HTML, CSS and JavaScript, there is a string background that can be used without limitations by programmers used to deal with low-level software (like me).
The lastest SDK, emulators and documentation of webOS can be found at Palm’s Developer Site. These tools are completely free and you only have to sign-up to get them, no need of 99U$D per year. Just download the tools for your platform, read the tutorials, understand what MOJO is about, and go on! It also has a development tool called ARES, which is a full feature IDE in the web, so may be you can even program in an iPad using Safari.
This first and very simple program is a web app that converts decimal to hex and binary and viceversa. It is very simple and I bet in runs in a browser with a small modifications to the HTML, and a few lines in Javascript.
Creating an (empty) application
Let’s run Eclipse with Palm SDK plug-in and create a basic application.
Once created, you will see a project structure like this:
webOS development is MVC oriented. Inside “app” you will find views, models and assistants. Views are HTML files that represents a scene (in webOS applications have stages/cards and scenes, learn more about The Anatomy of a webOS App). An assistant is a Javascript file that contains the controller. As you may guess, some applications also have a model folder, but this is not necessary to build an application. The basic stuffs are Views and Assistants, and the plug-in provides a Wizzard for that.
A basic (and empty) scene can be created by clicking on the Palm icon, and selecting. I will name this scene “home”
The “home” scene recently created adds two files to the project. “home-asssiant.js” (aka. a Controller for the Home scene) and “home-scene.html” (the view). So now the project looks like this
from now on, everything is HTML CSS and Javascript. You will see a few more screenshots with HTML and Javascript code from this app. But the most important part is the deploying of the application into the device.
From a terminal window (or command line) , place in a directory before the project directory and type
palm-package <name of the project>
This will generate a “ipk” file which is the application packaged. Then in order to install the package into the device, just type
palm-install <ipk file>
This will produce the output you will see in the following screenshot
Now, a few screenshots that shows interesting parts of the view and the controller. There is not much to say about this, it’s just HTML and the MOJO framework that webOS uses in Javascript is very well documented on Palm’s website.
Here you will see the setup method of the assistant, widgets should be initialized here, and you can add some validations methods inside this setup. Like, for example, chars allowed in a TextField.
In the setup method you can also declare event handlers for the widgets, as I do in this piece of code
A function that handles one of these events, it’s like any other javascript function. In this case, it takes the value from a TextField, makes some transformations, and update the value of others TextFields.
The view of this project it’s quite simple as you can see in this screenshot. Everything is HTML, every widget is identified by id, and you will use that id with the MOJO framework to customize the widget and manage it. The most relevant part if that you define a x-mojo-element property that tells the framework which type of object it is.
The final app looks like this without modifying the stylesheet or applying any custom style.
Tech Blog 