We’ve seen Open Mobile’s implementation of brining Android apps to Tizen before, but that method involves deployment on a platform level. The Open Mobile code needs to be a part of the Tizen code before the Android apps can be run on Tizen. Infraware, the company behind the Polaris App Player has a different approach.

The way this works in that they have a solution called PAG (Polaris App Generator) that lets the developer upload an Android app (APK) and it converts it into a TPK file that can be installed on the Tizen device. Then to run this modified TPK, you need to have the PAP (Polaris App Player) installed on the phone. Once that’s present, the modified TPK that you just installed will launch inside the PAP, and behave like a native Tizen app.

The company is giving away the Polaris App Player to users for free, in the hope that developers will use their service to deploy their Android apps to Tizen, thus making them money. While I have my doubts about Android Apps ‘officially’ being supported on Tizen, Infraware has a chance of succeeding as they don’t need to be a part of the platform, and have a business model as long as the developers and users are on board. Here is a video of the implementation in action:

While there is a noticeable slow down while running high performance games, most apps should run fine. Although, there will always be the issue of not all UI elements working properly because the app was originally made for Android in mind. The current implementation is based on Android 2.3 Gingerbread, so that means none of the ICS and up only apps, will be available. According to the company, PAG can port 80~90% of Android apps to Tizen app without re-compiling. Some examples include games such as Angrybird series, Counter Terrorist, Treasure Detective, Fruit Slice, Drag Racing, Shut Bubble Deluxe, Cut the Rope Free, Air Hockey etc.

Similar Posts:

• Running Android Apps On Tizen
• Tizen: State of The Union
• Tizen Conference Schedule Announced
• Tizen Gets An Asia Summit: December 8-9, Beijing
• MeeGo Makes Way For Tizen, An All New HTML5 Centered OS

Back in the day Intel had Moblin (PC and tablet OS), and Nokia had Maemo. Both of which came together to form MeeGo, an effort which has since been abandoned. Instead we have Tizen, a OS targeted at not just mobile phones, but also in vehicle systems, tablets and the PCs. While we’ve seen it running on mobile phone hardware (ARM chips), there has so far been nothing on the PC front, that was until today.

At the Tizen Conference 2013, I got a look at Tizen running on Intel’s Ivy Bridge ultrabook. While the PC release of Tizen is still some time away, the following video should give you a good idea of what to expect in terms of the UI and functionality.

The free to download Tizen images for laptops will be made available through Tizen.org website. While the best platform to run that release would be Ivy Bridge and up, I’m told that work is being done to support older chips and netbooks (in a limited way) as well.

(YouTube link)

Thanks to Patrick from Intel for the demo.

Similar Posts:

• Tizen Gets An Asia Summit: December 8-9, Beijing
• Running Android Apps On Tizen
• A Detailed Look At Tizen on Samsung’s First Prototype Device
• Tizen Conference Schedule Announced
• Tizen: State of The Union

I am looking for Javascript software engineers. You need to have expertise in Javascript, HTML5, CSS,  and high-level programming concepts. Developing experience on  Webkit or Firefox engine as well as a strong understanding of browser rendering is obviously a plus.  You need to be knowledgeable on the common JavaScript Libraries (jQuery, Sencha, Enyo,etc...). This would essentially be to build a team to work on web UX technologies and interfaces.
On a similar subject, I am also looking to expand our research activity around Javascript itself and Javascript tools (first result to come soon). So if you have deeper knowledgeable about the language itself or the frameworks, do not hesitate to contact me as well or meet me at the Tizen developer conference.

I would like to share with you this port of SeriesFinale for Blackberry.

Unlike the other versions, I was not involved in the development of this one. It was developed by Micke Prag, who also started the Meego/N9 port back in the day.
I developed the first version of SeriesFinale in 2009 for the defunct Maemo system and released also a version for the N9/Meego in 2011 (there was also a version for GNOME but I never finished it…). It is very good to see that it continues its life even if I am not involved this time.

I don’t own a BlackBerry so I am not able to try it but judging from this video, it definitely looks good so if you’re a BB user, check it out!

Judging from the success that a clone for Android and a similar online service have, it seems like I could have started a whole business out of it…

The logical step after the "Volume+ as Camera Button" app (Nokia Store link) for the N9 is another app that allows you to take photos while not touching your N9 at all. While time-triggered photos are fun, remote-triggered photos are.. erm.. "funner"? So what kind of remote "buttons" can we easily get on the N9? The remote control button on the headset is both "remote" and a "button". Also, as seen in Panucci and gPodder versions since the N900, Bluetooth headset buttons can also be queried by applications. So what do we get by combining remote control and photo taking? The Headset Camera app (Nokia Store link) for the N9! Or - for the visual reader - this:



If you want to integrate such features into your own app, the code for querying the headset buttons is readily available in the gPodder source tree (src/gpodder/qmlui/helper.py):

import dbus

class MediaButtonsHandler(QtCore.QObject):
    def __init__(self):
        QtCore.QObject.__init__(self)
        headset_path = '/org/freedesktop/Hal/devices/computer_logicaldev_input_0'
        headset_path2 = '/org/freedesktop/Hal/devices/computer_logicaldev_input'

        system_bus = dbus.SystemBus()
        system_bus.add_signal_receiver(self.handle_button, 'Condition',
                'org.freedesktop.Hal.Device', None, headset_path)
        system_bus.add_signal_receiver(self.handle_button, 'Condition',
                'org.freedesktop.Hal.Device', None, headset_path2)
 
    def handle_button(self, signal, button):
        if signal == 'ButtonPressed':
            if button in ('play-cd', 'phone'):
                self.playPressed.emit()
            elif button == 'pause-cd':
                self.pausePressed.emit()
            elif button == 'previous-song':
                self.previousPressed.emit()
            elif button == 'next-song':
                self.nextPressed.emit()

    playPressed = QtCore.Signal()
    pausePressed = QtCore.Signal()
    previousPressed = QtCore.Signal()
    nextPressed = QtCore.Signal()

MediaButtonsHandler is already a QObject subclass, so you can easily expose an instance of this class to your QDeclarativeView rootContext() and connect to the signals in QML (such a "headset button handler" might actually be a good candidate for inclusion into nemo-qml-plugins in Sailfish OS and Nemo Mobile?). As it's really just using the Python D-Bus bindings to get property changes from Hal devices, the code above should be easy (read: trivial) to port from Python to Qt/C++. Be aware that you need to connect to both .../computer_logicaldev_input_0 and .../computer_logicaldev_input, which can both exist if you have a cable headset and a Bluetooth headset connected at the same time.

You can get the Headset Camera App for the N9 in Nokia Store now, there is also a video on YouTube showing the app. Or start integrating headset button features into your own app or scripts by adapting the code above. One use case that comes to mind is using the previous/next buttons on a Bluetooth headset to control a photo slideshow on the N9 connected to TV-Out. Enjoy :)

Get out your Buzzword Bingo cards, we're talking HTML5. And Canvas2D. And WebGL. See? Check them off and then continue reading. So, while writing "native" apps using JavaScript is definitely possible and works great with QML, some games are just simple enough (or want to have a broad enough audience) to warrant writing everything in HTML5.

The Tizen Developer Conference is coming up from the 22nd of May until the 24th of may 2013 - It is in Downtown San Francisco (https://www.tizen.org/)I will be there the whole 3 days but I might be hard to grab as I will be running around. If you want to touch base - just contact me through linked in, email or twitter (https://twitter.com/yapellet).
If you are going there, go and check out the following talks from my lab (SRA's Advanced Software Platform). One is "Accelerated HTML5 Rendering for the Tizen Platform" by Henry Song. The other is "WebKit for Tizen" by Laszlo Gombos. Both of those talks are on the WebKit track. Though they are litteraly the top of the iceberg when it comes to our activity, it gives you an idea of what some our interests are.

There is also a presentation around a service prototyping for social appointment entitled Rendez-vous  under the Tizen Collaboration Projects. This is presented by Stanford students. It is a small project that we kick-started and sponsored last February as part of the CS210 Stanford Class.
On side note:  Art Dahm is giving a talk about building Tizen apps using Enyo & Phonegap. Art - now working for LG - used to be part of my team working  when I was working on webOS at HP. I will be sure to check this one out to see if I can meet some of the old team :)

See you there.

After the QUItIndicator trilogy which introduced idea, design and performance of a specific Qt5 QML component there's room for more, right?! Something like this:


This time we have a dynamic QML component for showing the remaining power of your mobile device battery. As a recap, with "Dynamic QML component" I mean someting which utilizes not only basic QML animation properties (position, opacity, scale etc.) but also new Qt5 features (shaders, particles, scenegraph powa!) to appear "more dynamic". Maybe it's just me, but I would love to see UIs really utilizing modern GPUs... and accelerating this progress is one of the reasons why I code these examples and blog about them. Another reason being to rule-the-world, obviously ;-P

Instead of explaining design & features of QUItBattery component I'll let this video to do that:





If you want to use this liquid battery component in your UI: Download the sources from here, copy QUItBatteryComponent directory, import it in your QML and off you go. Happy hacking!

I’m thrilled to announce that my paper “Block Coordinate Descent Algorithms for Large-scale Sparse Multiclass Classification” (published in the Machine Learning journal) is now online: PDF, BibTeX [*].

Abstract

Over the past decade, l1 regularization has emerged as a powerful way to learn classifiers with implicit feature selection. More recently, mixed-norm (e.g., l1/l2) regularization has been utilized as a way to select entire groups of features. In this paper, we propose a novel direct multiclass formulation specifically designed for large-scale and high-dimensional problems such as document classification. Based on a multiclass extension of the squared hinge loss, our formulation employs l1/l2 regularization so as to force weights corresponding to the same features to be zero across all classes, resulting in compact and fast-to-evaluate multiclass models. For optimization, we employ two globally-convergent variants of block coordinate descent, one with line search (Tseng and Yun, 2009) and the other without (Richtárik and Takáč, 2012). We present the two variants in a unified manner and develop the core components needed to efficiently solve our formulation. The end result is a couple of block coordinate descent algorithms specifically tailored to our multiclass formulation. Experimentally, we show that block coordinate descent performs favorably to other solvers such as FOBOS, FISTA and SpaRSA. Furthermore, we show that our formulation obtains very compact multiclass models and outperforms l1/l2- regularized multiclass logistic regression in terms of training speed, while achieving comparable test accuracy.

Code

The code of the proposed multiclass method is available in my Python/Cython machine learning library, lightning. Below is an example of how to use it on the News20 dataset.

from sklearn.datasets import fetch_20newsgroups_vectorized
from lightning.primal_cd import CDClassifier
 
bunch = fetch_20newsgroups_vectorized(subset="all")
X = bunch.data
y = bunch.target
 
clf = CDClassifier(penalty="l1/l2",
                   loss="squared_hinge",
                   multiclass=True,
                   max_iter=20,
                   alpha=1e-4,
                   C=1.0 / X.shape[0],
                   tol=1e-3)
clf.fit(X, y)
# accuracy
print clf.score(X, y) 
# percentage of selected features
print clf.n_nonzero(percentage=True)

To use the variant without line search (as presented in the paper), add the max_steps=0 option to CDClassifier.

Data

I also released the Amazon7 dataset used in the paper. It contains 1,362,109 reviews of Amazon products. Each review may belong to one of 7 categories (apparel, book, dvd, electronics, kitchen & housewares, music, video) and is represented as a 262,144-dimensional vector. It is, to my knowledge, one of the largest publically available multiclass classification dataset.

[*] The final publication is available here.

Next up in my list of things I did in the last weeks/months and never blogged about is Petals (Nokia Store link), a "beautiful, brain-teasing puzzle game for 1-4 players" if the game's website is to be believed (I would like to think it is...). As always, there's some technical details about the porting and creation of this game. While another recent game (Tetrepetete) has been done on a low level (C++ using no frameworks, and interfacing with multiple front-ends directly, including an OpenGL ES frontend, a console-based ncurses frontend(!) as well as a server-sent events/XHR/Canvas2D-based HTML5 frontend(!!)), this one is approaching things from a very high level: JavaScript.

Petals: A puzzle game written in pure JavaScript and QMLThe gameplay logic of the game is implemented in pure JavaScript (without any QML dependencies), so it could easily be ported to, say, HTML5, but for integration reasons, QML seemed like the better choice for a release on the N9/Harmattan. Also, writing things in JavaScript wouldn't preclude a console-based frontend using nodejs and node-ncurses from happening should the need arise (making the flowers look good in ASCII art would be the challenge there - or cheating by using libcaca). Ok, ok - stop cursing, I'll stop talking about curses (cue laugh track).

Writing pure QML applications has the advantage of easing porting to Qt 5. While QtQuick 1.1 still exists on Qt 5 (and is the only QML option at the moment if you are also targetting iOS), QtQuick 2.0 is usually the better choice for performance reasons.

In my case, the changes necessary to port from QtQuick 1.1 to QtQuick 2.0 were:

• Change "import QtQuick 1.1" to "import QtQuick 2.0" (sed(1) helps here)
• Instead of assigning a JavaScript function to a property to create a dynamic property binding (item.someprop = function() { return otheritem.otherprop * 3.0; }), this function has to be wrapped in a call to Qt.binding() in Qt 5 (see "Creating Property Bindings from JavaScript" in the Qt 5 docs)
• Instead of using SQL Local Storage directly as in QtQuick 1.1, use QtQuick.LocalStorage 2.0, which you can still do in your .js files - use ".import" as described in this blog post
• In your C++ launcher (in case you need one), QApplication becomes QGuiApplication, and QDeclarativeView becomes QQuickView
• Use "QT += quick qml" instead of "QT += declarative" in your qmake project file

And that's basically it. Of course, as this is a full-screen game with custom UI, no platform-specific components (such as Harmattan Components or Sailfish Silica) are used, so porting is a bit easier there (no need to "wait" for specific components to be compatible with QtQuick 2.0, which might realistically not happen at all for Harmattan Components). More screenshots of Petals and download links for multiple platforms can be found on the Petals Website.