(define-syntax run-ui
  (syntax-rules ()
   ((run-ui activity body ...)
    (android.app.Activity:runOnUiThread activity
     (runnable
      (lambda ()
        body ... ))))))

To test the macro (from Kawa)

(require 'syntax-utils)
(display (expand
 '(run-ui *activity*
   (android.util.Log:v "kawa-hello" "test log")
    ((Toast:makeText *activity* "Good Morning Australia" Toast:LENGTH_LONG):show))))

To run it:

java -jar kawa-1.11.jar -f test.scm

Note: don’t do this,

java -jar kawa-1.11.jar test.scm 

as expand mysteriously doesn’t expand.

Reference

An anonymous class is commonly used in the Java platform where a function language would use a lambda expression. Examples are call-back handlers, events handlers, and run methods. In these cases Kawa lets you use a lambda expression as a short-hand for an anonymous class. For example:

(button:addActionListener
  (lambda (e) (do-something)))

is equivalent to:

(button:addActionListener
  (object (java.awt.event.ActionListener)
    ((actionPerformed (e ::java.awt.event.ActionEvent))::void
     (do-something))))

The magic starts at gnu/kawa/reflect/CompileBuildObject.java, where findMember looks up a setXXXX or addXXXX member on a class. Next, buildSetter calls CompileReflect.makeSetterCall…. (I haven’t traced through)… that calls gnu/expr/InlineCalls.java that examines for SAM checkSingleAbstractMethod, and that creates a new anonymous class (new ObjectExp) ?

However, on Android, Kawa is unable to create new classes on the fly. Instead, we need to create a proxy and a custom InvocationHandler that calls our lambdas.

The following works for me:

(define (Enumeration->list (enum :: java.util.Enumeration)) :: list
  (let loop ((ls '()))
    (if (enum:hasMoreElements)
      (loop (cons (enum:nextElement) ls))
      (reverse ls))))

(require 'srfi-1)
(define (enumerate-network-interfaces)
 (map (lambda (x :: java.net.InetAddress) x:host-address)
  (filter (lambda (x :: java.net.InetAddress) (not (x:is-loopback-address)))
    (concatenate
       (map (lambda (x :: java.net.NetworkInterface) (Enumeration->list x:inet-addresses))
         (Enumeration->list java.net.NetworkInterface:network-interfaces))))))

… which is the functional equivalent of the following in Java

    for (Enumeration<NetworkInterface> en = NetworkInterface.getNetworkInterfaces(); en.hasMoreElements();) {
	            NetworkInterface intf = en.nextElement();
	            for (Enumeration<InetAddress> enumIpAddr = intf.getInetAddresses(); enumIpAddr.hasMoreElements();) {
	                InetAddress inetAddress = enumIpAddr.nextElement();
	                if (!inetAddress.isLoopbackAddress()) {
	                    return inetAddress.getHostAddress().toString();
	                }
	            }
	        }

Unfortunately, the Scheme version isn’t much more readable than the Java one.

Here’s another version in Scheme, using named let.

(let loop ((interfaces :: java.util.Enumeration[java.net.NetworkInterface] java.net.NetworkInterface:network-interfaces))
   (if (interfaces:has-more-elements)
       (let ((interface (interfaces:next-element)))
         (if (not (interface:is-up))
             (loop interfaces))
         (if (interface:is-virtual)
             (loop interfaces))
         (display interface:display-name) (newline)
         (let loop ((inet-addresses :: java.util.Enumeration[java.net.InetAddress] interface:inet-addresses))
             (if (inet-addresses:has-more-elements)
                 (let ((inet-address (inet-addresses:next-element)))
                      (display "--")
                      (display inet-address:host-address)
                      (newline))
                 (loop inet-addresses)))
         (loop interfaces))))

(define-syntax try-with-resources
  (syntax-rules ()
    ((try-with-resources () body ...)
     (begin body ...))
    ((try-with-resources ((var val) (vars vals) ...) body ...)
     (let ((var val))
       (try-finally
        (try-with-resources ((vars vals) ...) body ...)
        (invoke var 'close)))))) 

(define (msg (fstring string) #!rest args)
  (android.util.Log:v "kawa-hello" (apply format fstring args))) 

(define (start-telnet-repl (socket java.net.Socket))
  (let ((lang (gnu.expr.Language:getDefaultLanguage)))
    (msg "starting telnet repl ~a ~a" socket lang)
    (kawa.TelnetRepl:serve lang socket))) 

(define (start-repl port)
  (try-with-resources ((server (java.net.ServerSocket port)))
   (let loop ()
     (msg "listing on ~a (~a)" port server)
     (let ((socket (server:accept)))
       (msg "connected ~a " socket)
       (start-telnet-repl socket)
       (loop))))) 

(define-variable *activity* #f) 

(define (init-kawa activity)
  (kawa.standard.Scheme:registerEnvironment)
  (set! gnu.expr.ModuleExp:compilerAvailable #f)
  (set! gnu.expr.ModuleExp:alwaysCompile #f)
  (set! *activity* activity)
  (future (start-repl 4444))) 

(define-simple-class hello (android.app.Activity)
  ((onCreate saved-state ::android.os.Bundle) ::void
   (let ((self (this)))
     (invoke-special android.app.Activity self 'onCreate saved-state)
     (init-kawa self)
     (self:setContentView
      (android.widget.TextView
       self
       text: "Hello, Android from Kawa Scheme!")))))

The good news with this implementation is now I can reconnect to telnet multiple times, and the *activity* global variable is defined, which allows me to do this from REPL.

#|kawa:76|# (*activity*:run-on-ui-thread
             (runnable
               (lambda ()
                 ((android.widget.Toast:makeText
                     *activity*
                     "Hello from REPL"
                     android.widget.Toast:LENGTH_LONG):show))

Here’s one where we change the UI on the fly from the REPL

#|kawa:78|#
(*activity*:runOnUiThread
  (runnable
     (lambda ()
        (*activity*:setContentView
          (android.widget.TextView *activity* text: "Changed Content")))))

Patch Kawa

Use default classloader instead of the android specific one. There are preprocessors involved, so the only way is to modify ifdef Android to ifdef xxAndroid.

  /* #ifdef JAVA2 */
  public static ClassLoader getContextClassLoader ()
  {
    try
      {
        /* #ifdef xxAndroid */
        //return ClassLoader.getSystemClassLoader();
        /* #else */
        return Thread.currentThread().getContextClassLoader();
        /* #endif */
      }
    catch (java.lang.SecurityException ex)
      {
        /* The .class syntax below also works for JDK 1.4, but it's just
           syntactic sugar, so there is no benefit in using it. */
        /* #ifdef JAVA5 */
        return ObjectType.class.getClassLoader();
        /* #else */
        // return thisClassLoader;
        /* #endif */
      }
  }
  /* #endif */

Set up Scheme project

Set up a Scheme-based Android project as per Per Bothner’s instructions.

Source for repl.scm (don’t use hello.scm)

(module-static #t)

(module-compile-options
 warn-unknown-member: #t
 warn-undefined-variable: #t
 )

(require 'android-defs)

(define (msg (fstring string) #!rest args)
  (android.util.Log:v "kawa-hello" (apply format fstring args)))

(define (start-repl port)
  (begin
    ; required! otherwise the getLanguage() call will fail
    (kawa.standard.Scheme:registerEnvironment)
    ; required! as Android cannot compile to java
    (set! gnu.expr.ModuleExp:alwaysCompile #f)
    (let* ((server (java.net.ServerSocket port)))
      (msg "listing on ~a (~a)" port server)
      (let ((socket (server:accept)))
        (msg "connected ~a " socket)
        (let ((in (gnu.mapping.InPort (socket:getInputStream)))
              (out (gnu.mapping.OutPort (socket:getOutputStream))))
          (parameterize ((current-input-port in)
                         (current-output-port out))
            (do () (#f)
              (try-catch
               (begin
                 (format #t "\n> " )
                 (force-output)
                 (let ((form (read)))
                   (format #t "form: ~s\n" form)
                   (format #t "~s" (eval form (interaction-environment)))))
               (e java.lang.Exception
                  (e:printStackTrace out))))))))))

(activity hello
  (on-create-view
    (begin
      (java.lang.Thread:run (java.lang.Thread:new (runnable (start-repl 4444))))
      (android.widget.TextView (this)
         text: "Hello, Android REPL from Kawa Scheme!"))))

Modify the start up file

In build.xml

   <arg value="-C"/>
   <arg file="src/kawa/android/repl.scm"/>

Deploy

Deploy and view the logs

ant debug; adb uninstall kawa.android; adb install bin/KawaHello-debug.apk; adb logcat

Test

; Do this if you are running on physical hardware
adb forward tcp:4444 tcp:4444

telnet localhost 4444
(+ 1 1)

Still to be resolved

• Text label doesn’t show up
• Compiling classes and libraries quite slow, why is it being repeated?
• Start repl after showing text label?
• How do I make UI calls back on the main thread?

Troubleshooting

unable to resolve static field 9 (Lit0)

Rename your scheme file from hello.scm to hello2.scm as there is a name-clash – I’m not sure why yet.

These tells you what the script is trying to do.

bash -x script/deps
bash -x script/run

Here’s mine once cleaned up. I used java.ext.dirs as I don’t think wildcards on classpath worked.

$ java -server -cp 'lib;lib/dev;lib/clojurescript/src/clj;lib/clojurescript/src/cljs;lib/clojurescript/test/cljs;lib/do
mina/src/cljs;src/app/clj;src/app/cljs;src/app/cljs-macros;src/lib/clj;src/lib/cljs;test;templates' '-Djava.ext.dirs=li
b;lib/dev;lib/clojurescript/src/clj;lib/clojurescript/src/cljs;lib/clojurescript/test/cljs;lib/domina/src/cljs;src/app/
clj;src/app/cljs;src/app/cljs-macros;src/lib/clj;src/lib/cljs;test;templates' jline.ConsoleRunner clojure.main -e '(use
 '\''one.sample.dev-server)
 (run-server)
 (println "The application is being served from localhost:8080")' --repl

public int Total
{
  get { return A + B; }
}

public int A
{
  get { return m_A; }
  set { m_A = value; RaisePropertyChanged("A"); RaisePropertyChanged("Total"); }
}

public int B
{
  get { return m_B: }
  set { m_B = value; RaisePropertyChanged("B"); RaisePropertyChanged("Total"); }
}

We can solve this by using a helper attribute, so that the new code looks like this. Notice the increased clarity and ease of adding more dependent variables:

[DependsOn("A")]
[DependsOn("B")]
public int Total
{
  get { return A + B; }
}

public int A
{
  get { return m_A; }
  set { m_A = value; RaisePropertyChanged("A"); }
}

public int B
{
  get { return m_B: }
  set { m_B = value; RaisePropertyChanged("B"); }
}

Here’s the supporting code

        internal Dictionary<string, IEnumerable<string>> m_DependentAttributes = new Dictionary<string, IEnumerable<string>>();
        private void SetupDependentAttributes()
        {
            foreach (var property in this.GetType().GetProperties())
            {
                string propertyName = property.Name;

                DependsOnAttribute[] attrs = (DependsOnAttribute[])property.GetCustomAttributes(typeof(DependsOnAttribute), true);
                foreach (var dependOnAttr in attrs)
                {
                    foreach (string dependsOnPropertyName in dependOnAttr.DependsOnPropertyNames)
                    {
                        if (!m_DependentAttributes.ContainsKey(dependsOnPropertyName))
                            m_DependentAttributes[dependsOnPropertyName] = new List<string>();
                        (m_DependentAttributes[dependsOnPropertyName] as List<string>).Add(propertyName);
                    }
                }

                // If a property is ObservableCollection, then CollectionChanged should also raise PropertyChanged.
                object obs = property.GetGetMethod().Invoke(this, null);
                if (obs != null && obs is System.Collections.Specialized.INotifyCollectionChanged)
                {
                    EventInfo collectionChanged = obs.GetType().GetEvent("CollectionChanged");
                    if (collectionChanged != null)
                    {
                        (obs as System.Collections.Specialized.INotifyCollectionChanged).CollectionChanged +=
                            (s, e) => { RaisePropertyChanged(propertyName); };
                    }
                }
            }
        }

        public void RaisePropertyChanged(string propertyName)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
                if (m_DependentAttributes.ContainsKey(propertyName))
                    foreach (var dependentPropertyName in m_DependentAttributes[propertyName])
                    {
                        RaisePropertyChanged(dependentPropertyName);
                    }
            }
        }

    [AttributeUsage(AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
    sealed class DependsOnAttribute : Attribute
    {
        // See the attribute guidelines at
        //  http://go.microsoft.com/fwlink/?LinkId=85236
        readonly string[] dependsOnPropertyNames;

        // This is a positional argument
        public DependsOnAttribute(params string[] dependsOnPropertyNames)
        {
            this.dependsOnPropertyNames = dependsOnPropertyNames;
        }

        public string[] DependsOnPropertyNames
        {
            get { return dependsOnPropertyNames; }
        }

        // This is a named argument
        public int NamedInt { get; set; }
    }

Andrew over at Builders Discount Warehouse over at Slacks Creek have refused to accept any responsibility, so it is off to the Fair Trading Commission.

I hope it doesn’t turn into a saga.

<ListBox x:Name="TestList" SelectionMode="Multiple">
    <ListBox.ItemTemplate>
        <DataTemplate>
            <CheckBox
               IsChecked="{Binding RelativeSource={RelativeSource AncestorType=ListBoxItem}, Path=IsSelected}"
               Content="{Binding}" />
        </DataTemplate>
    </ListBox.ItemTemplate>
</ListBox>

And here’s a bit of sample code to set it up

public MainPage()
{
    InitializeComponent();
    SetupListBox();
}

public void SetupListBox()
{
    TestList.ItemsSource = new String[]
    {
        "Andrew", "Frasier", "Mellon", "Dale"
    };
}

1. Damon Payne | Run time is design time for AGT [0]
2. Damon Payne | Run time is design time for AGT [1]
3. Damon Payne | Run time is design time for AGT [2]
4. Run time is design time for AGT [3]
5. Damon Payne | AGT[1] and AGT[2]
6. Damon Payne | Run time is design time for AGT [4]
7. Damon Payne | Run time is design time for AGT [5]
8. Damon Payne | AGT[4] and AGT[5]
9. Damon Payne | Run time is design time for AGT [6]
10. Damon Payne | Run time is design time for AGT [7]
11. Damon Payne | Run time is design time for AGT [8]
12. Run time is design time for AGT[9]
13. Damon Payne | Run time is design time for AGT [10]
14. Damon Payne | Run time is design time for AGT [11]
15. Damon Payne | Run time is design time for AGT [12]
16. Damon Payne | Run time is design time for AGT [13]
17. Damon Payne | Run time is design time for AGT [14]
18. Run time is design time for AGT [15]
19. Damon Payne | Run time is design time for AGT[16]
20. Damon Payne | Run time is design time for AGT[17]
21. Damon Payne | Argentum Tela Design Surface[18]
22. Damon Payne | Argentum Tela Design Surface[19]
23. Argentum Tela Design Surface [20] – Getting up to speed
24. Argentum Tela Design Surface [21] – Name Provider
25. SIG talk