After four or so months, it’s time for another Hecl “checkpoint”. Those who are seriously interested really ought to be getting Hecl from subversion, however, it’s a good idea to tie up the loose ends every now and then, and put something that’s easy to fetch for the casual user.

https://sourceforge.net/project/showfiles.php?group_id=122383

This release contains a number of interesting things:

• Alpha support for Java integration. For example:

    java java.lang.System sys
    set ms [sys currentTimeMillis]
  

• Alpha support for Google Android. This utilizes the Java integration system above heavily. What sets it apart from just writing code in Java is that on top of the building blocks, I’ve started to write little bits of Hecl code to make common things very straightforward, layering on top of the Java API.

• Numerous fixes in the code, documentation, and build system.

Credit for finding out how to do this goes to dims, who has been doing lots of cool Android hacking lately:

http://davanum.wordpress.com/2007/12/18/android-task-manager-primitive-prototype/

If you’re interested in Android and what it can do, you should be following his online journal!

As a way to keep pushing and testing Hecl, I decided to see if I could copy what he’d done in Hecl. It has indeed produced a few improvements to the Java code. That done, making it work was short and sweet:

set layoutparams [linearlayoutparams -new {FILL_PARENT WRAP_CONTENT}
set layout [linearlayout -new $context]
$layout setorientation VERTICAL

# Create ourselves some commands to access Android internals.
java android.app.ActivityManagerNative activitymanagernative
java android.app.IActivityManager iactivitymanager
java {android.app.IActivityManager$TaskInfo} taskinfo
java android.content.ComponentName componentname

java java.util.List javalist
set am [activitymanagernative getdefault]
set tasks [$am gettasks 10 0 [null]]
set len [$tasks size]
set tasklist [list]
for {set i 0} {< $i $len} {incr $i} {
    set baseactivity [[$tasks get $i] -field baseactivity]
    lappend $tasklist "Task: [$baseactivity getpackagename]"
}

$layout addview [textview -new $context -layoutparams $layoutparams 
         -text "Currently running tasks"]

set lview [basiclist $context $tasklist -layoutparams $layoutparams]
$layout addview $lview
$lview requestfocus

set callback [callback -new [list [list SelectTask]]]
$lview setonitemclicklistener $callback

heclcmd setcontentview $layout

proc SelectTask {parent view position id} {
    [activitymanagernative getdefault] movetasktofront $position
}

It could have been squeezed further by avoiding some of the temporary variables, and perhaps also by implementing a mapping between java.util.List and Hecl lists.

I think one of the next things I want to do is work on some infrastructure so that people will be able to actually work on scripts on their phone. That’s sort of a departure from the past (most phone keyboards would be sheer torture for inputting long scripts), but it’s a cool demo in any case.

Alpha Android Hecl

I’m a little bit nervous about the idea, but I decided that I might as well release early, because for the foreseeable future, there’s always going to be “one more feature” I could add.

So, without further ado, I’m going to announce that I have a version of Hecl running on Android that has a access to a number of Android wigets. It is available here:

http://www.hecl.org/Hecl.apk

However: this is an alpha release, for those interested in hacking on it. If you are bothered by broken code, don’t like to report bugs, don’t want to think about how to improve it, complain loudly about missing features, then this code is not for you yet. Soon, I hope, it will be stable and useful for many more people, but for the moment, a lot of things are up in the air:

• Hecl’s java reflection interaction code, which lets us interact with Android’s API without writing wrappers for all of it, is very new. It was written specifically to facilitate the Android port. So it might change. For hackers, the opportunity is to be able to take part in shaping it.

• More work needs to go into the threading model. Wolfgang Kechel built a nice system of timers and events into Hecl, but work will be needed to make those play nicely with Android.

• More API coverage is needed. We have a number of the basic widgets, but more are needed.

• Storage is still something being worked on. I want to have a Hecl script Provider so that other applications can access Hecl scripts, as well as Hecl commands to access the various types of permanent storage that Android makes available.

• Phone features – we want to have callbacks and commands to deal with phone features like sms, phone calls, the camera, and so on.

• Needless to say, none of what currently exists is documented besides some comments in the code!

Of course… Hecl itself is a pretty cool language, I like to think, and the fact that it’s interpreted means that you don’t have to recompile anything, you just

1. Edit your script.
2. Replace the script in the zip file: zip -r bin/Hecl.apk res/raw/script.hcl
3. Load it up on the emulator: /opt/android_sdk_linux_m3-rc37a/tools/adb install bin/Hecl.apk

You can do other cool things too, like downloading bits of code over http and running them.

Hecl @ Android Developer Challenge

I hope that people interested in hacking on Hecl will do so because it’s fun and interesting. Being an early adopter means you have a lot of influence in shaping the future of this programming language, and the API’s to interact with Android (or Java ME if that’s your thing).

However, seeing as how Google has put together this contest:

http://code.google.com/android/adc.html

I have decided to submit the Android port of Hecl, and split the prize money, should we win any, with those who have contributed to Hecl. That includes any and all contributions to Hecl, whether or not it’s directly related to Android or not. So, with documentation, Java code, Hecl code, tests, and even improvements to the web page as valid things, there’s room for everyone to get involved. Of course, in order not to paint myself into a corner, I reserve the right to make final decisions about percentages, but it should be roughly equivalent to lines of code added, deleted or modified (yes, deleted counts too – if you make the project that much slimmer without sacrificing functionality, that’s wonderful!).

Also more than welcome are people who want to submit their own projects to the developer challenge based on Android. We make no claim to your winnings, and we’ll be happy to give you a hand.

Interested?

Join the Hecl mailing list, that’s where all our discussions take place:

http://sourceforge.net/mailarchive/forum.php?forum_name=hecl-devel

Hope to see you there!

This was informally confirmed by someone at Google:

Given this layout code:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  android:orientation="vertical"
  android:layout_width="fill_parent"
  android:layout_height="fill_parent"
  id="@+id/ll">
</LinearLayout>

And this Java code:

public void onCreate(Bundle icicle)
{
    super.onCreate(icicle);
    setContentView(R.layout.main);

    LinearLayout ll = (LinearLayout)findViewById(R.id.ll);

    RadioGroup rg = new RadioGroup(this);
    rg.setLayoutParams(new LinearLayout.LayoutParams(
            LinearLayout.LayoutParams.WRAP_CONTENT,
            LinearLayout.LayoutParams.WRAP_CONTENT));

    ll.addView(rg);

    RadioGroup.LayoutParams rlp = new RadioGroup.LayoutParams(
        RadioGroup.LayoutParams.WRAP_CONTENT,
        RadioGroup.LayoutParams.WRAP_CONTENT);

    RadioButton foo = new RadioButton(this);
    foo.setText("foo");
    foo.setLayoutParams(rlp);
    rg.addView(foo);

    RadioButton bar = new RadioButton(this);
    bar.setText("bar");
    bar.setLayoutParams(rlp);
    rg.addView(bar);

    RadioButton baz = new RadioButton(this);
    baz.setText("baz");
    baz.setLayoutParams(rlp);
    rg.addView(baz);
}

The resulting radio buttons fail to be mutually exclusive. This is a bit frustrating, as Hecl doesn’t utilize the XML layout system. Or rather, you can use that if you want, or you can create everything in Hecl.

The individual at Google says the problem will be fixed in a future SDK release, so hopefully things will work in the near future. I also hope it’s open sourced soonish, so that problems like this can be fixed without requiring the intervention of “the hand of Google”. Of course, in this market, there’s also the issue of things being shipped on hardware, where open source or not doesn’t matter much if the bug is out there, because you simply can’t fix it on millions of devices. Hopefully the product that ships will be very solid.