JPGF ANDROID TUTORIAL

Let's now take a look a the java code for the application. In the current state, the interfce should display properly and let ou enter text but it doesn't do much. It even crashes if you press the button.

This is because we didn't implement the translation() function that is specified as onClick parametter for the button. Let's add a dummy function for now, to understand how it works.

Open the file Translate.java file located in src/com/example/translateapp/, it should look like that:

package com.example.translateapp;

import android.app.Activity;
import android.os.Bundle;

public class Translate extends Activity
{
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }
}

Let's add our translate function. According to the android developer documentation, it should have the following signature: public void translate(View v) Since we don't have to return anything, we can just add an empty function:

public void translate(View v) {

}

For this to work, we need to include the View class from the android library:

import android.view.View;

Your code should now look like this:

package com.example.translateapp;

import android.app.Activity;
import android.os.Bundle;
import android.view.View;

public class Translate extends Activity
{
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }
    
    public void translate(View v) {

    }
}

The application doesn't crash anymore but it still doesn't do anything… let's look at this.

We will update our translate function so that it grabs the input text and copies it 10 times in the list. Reading the input text is done by first getting a handle to the coresponding view and then getting the text:

TextView tv = (TextView)findViewById(R.id.edittext);
String input = tv.getText().toString();

And import the necessary class:

import android.widget.TextView;

Now, we can copy it in the list. First, we should setup a data structure for the list, we will use a ArrayAdapter in this example. In the onCreate function, just add:

mArrayAdapter = new ArrayAdapter(this, R.layout.listitem);
ListView list = (ListView)findViewById(R.id.list);
list.setAdapter(mArrayAdapter);

Again we need to import some classes from the code to work:

import android.widget.ListView;
import android.widget.ArrayAdapter;

and we need a new class member:

private ArrayAdapter mArrayAdapter;

The resource id R.layout.listitem references a new layout that controls how each item is displayed in the list. Let's use a very simple TextView. Create the file res/listitem.xml whith this content:

<?xml version="1.0" encoding="utf-8"?>
<TextView
   xmlns:android="http://schemas.android.com/apk/res/android"
   android:layout_width="wrap_content"
   android:layout_height="wrap_content"/>

Finally, we can populate the list in the translate function:

//... getting the input string
mArrayAdapter.clear();
for (int i = 0; i < 10 ; i++)
    mArrayAdapter.add(input);

Now your Translate.java file should look like this:

package com.example.translateapp;

import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.widget.TextView;
import android.widget.ListView;
import android.widget.ArrayAdapter;

public class Translate extends Activity
{
    
    private ArrayAdapter mArrayAdapter;

    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        mArrayAdapter = new ArrayAdapter(this, R.layout.listitem);
        ListView list = (ListView)findViewById(R.id.list);
        list.setAdapter(mArrayAdapter);
    }
    
    public void translate(View v) {
        TextView tv = (TextView)findViewById(R.id.edittext);
        String input = tv.getText().toString();
        mArrayAdapter.clear();
        for (int i = 0; i < 10 ; i++)
            mArrayAdapter.add(input);
    }
}

Run and test your application, you should be able to get something like the following screenshot.

PGF operations are costly. On a cell phone, reading a PGF can take several seconds, depending on the size of the grammar and it is not unusual for parsing to take 1 or two seconds as well.

If we do that in the main thread for our application, called the UI thread, we will block the user interface. This is not very good practice and it could even lead the OS to believe that our application is stalled and to display an error message.

To avoid this problem we need to put the PGF computations in other threads. The android framework offers different ways to do that. In this tutorial, we'll use the AsynTask class.

Explaining who to use this class is not in the scope of this tutorial so I invite interested readers to look at the class documentation.

There is only three important method for our example in this class:

onPreExecute

used to setup the interface when the task start (e.g. displaying a progress window.)

doInBackground

used to do the expensive computation. This cannot modify the UI.

onPostExecute

used to update the UI when the task is completed (e.g. removing the progress window.)

Loading a PGF file is done with the class PGFBuilder. It offers two static methods that both return a PGF object: fromFile and fromInputStream. The first expect a file name. Since, i android project, our file are better accessed by resource id, we will use the second one and open an InputStream. This is done like this:

InputStream is = getResources().openRawResource(R.raw.foods);

Then we give this stream to PGFBuilder. In addition we give the list of desired concrete grammar so only those will be kept in memory, this allow us to be more efficient in memory usage.

PGF pgf = PGFBuilder.fromInputStream(is, new String[] {"FoodsEng", "FoodsCat"});

Now, as explained above, we will not do this directly in onCreate to avoid blocking the UI. Instead we need to subclass AsyncTask and read the PGF in the doInBackground method. In addition, we add the code for the progress window:

/**
 * This class is used to load the PGF file asychronously.
 * It display a blocking progress dialog while doing so.
 */
private class LoadPGFTask extends AsyncTask<Void, Void, PGF> {

    private ProgressDialog progress;

    protected void onPreExecute() {
        // Display loading popup
        this.progress =
            ProgressDialog.show(Translate.this,"Translate","Loading grammar, please wait",true);
    }
    
    protected PGF doInBackground(Void... a) {
        int pgf_res = R.raw.foods;
        InputStream is = getResources().openRawResource(pgf_res);
        try {
            PGF pgf = PGFBuilder.fromInputStream(is, new String[] {"FoodsEng", "FoodsCat"});
            return pgf;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    protected void onPostExecute(PGF result) {
        mPGF = result;
        if (this.progress != null)
            this.progress.dismiss(); // Remove loading popup
    }
}

Finally, we need a new class member for the PGF

private PGF mPGF;

and we need to launch the task from onCreate :

new LoadPGFTask().execute();

Translation is just the combination of parsing and linearization. In JPGF, those tasks are respectevly done with a Parser and a Lnearizer object. Those are easily created given the PGF and the concrete grammar:

Parser mParser = new Parser(mPGF, "FoodsEng");
Linearizer mLinearizer = new Linearizer(mPGF, "FoodsCat");

The parser object expect an array of tokens, which means that we need to tokenize the sentence first:

String[] tokens = entence.split(" ");

and returns a ParseState object from which we can retreive parse trees:

ParseState mParseState = parser.parse(token);
Tree[] trees = (Tree[])mParseState.getTrees();

The Linearizer takes a tree and return a string:

String s = mLinearizer.linearizeString(trees[0]);

Finally, once enclosed in an AsyncTask sub-class with the code for the progress window and some boilerplate code we get:

/**
 * This class is used to parse a sentence asychronously.
 * It display a blocking progress dialog while doing so.
 */
private class TranslateTask extends AsyncTask<String, Void, String[]> {

    private ProgressDialog progress;

    protected void onPreExecute() {
        // Display loading popup
        this.progress =
            ProgressDialog.show(Translate.this,"Translate","Parsing, please wait",true);
    }
    
    protected String[] doInBackground(String... s) {
        try {
            // Creating a Parser object for the FoodEng concrete grammar
            Parser mParser = new Parser(mPGF, "FoodsEng");
            // Spliting the input (basic tokenization)
            String[] tokens = s[0].split(" ");
            // parsing the tokens
            ParseState mParseState = mParser.parse(tokens);
            Tree[] trees = (Tree[])mParseState.getTrees();

            String[] translations = new String[trees.length];
            // Creating a Linearizer object for the FoodCat concrete grammar
            Linearizer mLinearizer = new Linearizer(mPGF, "FoodsCat");
            // Linearizing all the trees
            for (int i = 0 ; i < trees.length ; i++) {
                try {
                    String t = mLinearizer.linearizeString(trees[i]);
                    translations[i] = t;
                } catch (java.lang.Exception e) {
                    translations[i] = "/!\\ Linearization error";
                }
            }
            return translations;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    protected void onPostExecute(String[] result) {
        mArrayAdapter.clear();
        for (String sentence : result)
            mArrayAdapter.add(sentence);
        if (this.progress != null)
            this.progress.dismiss(); // Remove loading popup
    }
}

and again, we launch the task when appropriate: in the translate method

public void translate(View v) {
    TextView tv = (TextView)findViewById(R.id.edittext);
    String input = tv.getText().toString();
    new TranslateTask().execute(input);
}

Add the right classes to the imports:

import android.app.ProgressDialog;
import android.os.AsyncTask;
import java.io.InputStream;
import org.grammaticalframework.Linearizer;
import org.grammaticalframework.PGF;
import org.grammaticalframework.PGFBuilder;
import org.grammaticalframework.Parser;
import org.grammaticalframework.parser.ParseState;
import org.grammaticalframework.Trees.Absyn.Tree;

Here is the final Translate.java for this tutorial.

package com.example.translateapp;

import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.widget.TextView;
import android.widget.ListView;
import android.widget.ArrayAdapter;

import android.app.ProgressDialog;
import android.os.AsyncTask;
import java.io.InputStream;
import org.grammaticalframework.Linearizer;
import org.grammaticalframework.PGF;
import org.grammaticalframework.PGFBuilder;
import org.grammaticalframework.Parser;
import org.grammaticalframework.parser.ParseState;
import org.grammaticalframework.Trees.Absyn.Tree;

public class Translate extends Activity
{
    private ArrayAdapter mArrayAdapter;
    private PGF mPGF;

    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        new LoadPGFTask().execute();

        mArrayAdapter = new ArrayAdapter(this, R.layout.listitem);
        ListView list = (ListView)findViewById(R.id.list);
        list.setAdapter(mArrayAdapter);
    }
    
    public void translate(View v) {
        TextView tv = (TextView)findViewById(R.id.edittext);
        String input = tv.getText().toString();
        new TranslateTask().execute(input);
    }


    /**
     * This class is used to load the PGF file asychronously.
     * It display a blocking progress dialog while doing so.
     */
    private class LoadPGFTask extends AsyncTask<Void, Void, PGF> {
        
        private ProgressDialog progress;
        
        protected void onPreExecute() {
            // Display loading popup
            this.progress =
                ProgressDialog.show(Translate.this,"Translate","Loading grammar, please wait",true);
        }
        
        protected PGF doInBackground(Void... a) {
            int pgf_res = R.raw.foods;
            InputStream is = getResources().openRawResource(pgf_res);
            try {
                PGF pgf = PGFBuilder.fromInputStream(is, new String[] {"FoodsEng", "FoodsCat"});
                return pgf;
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
        
        protected void onPostExecute(PGF result) {
            mPGF = result;
            if (this.progress != null)
                this.progress.dismiss(); // Remove loading popup
        }
    }
    
    /**
     * This class is used to parse a sentence asychronously.
     * It display a blocking progress dialog while doing so.
     */
    private class TranslateTask extends AsyncTask<String, Void, String[]> {

        private ProgressDialog progress;

        protected void onPreExecute() {
            // Display loading popup
            this.progress =
                ProgressDialog.show(Translate.this,"Translate","Parsing, please wait",true);
        }
        
        protected String[] doInBackground(String... s) {
            try {
                // Creating a Parser object for the FoodEng concrete grammar
                Parser mParser = new Parser(mPGF, "FoodsEng");
                // Spliting the input (basic tokenization)
                String[] tokens = s[0].split(" ");
                // parsing the tokens
                ParseState mParseState = mParser.parse(tokens);
                Tree[] trees = (Tree[])mParseState.getTrees();
                
                String[] translations = new String[trees.length];
                // Creating a Linearizer object for the FoodCat concrete grammar
                Linearizer mLinearizer = new Linearizer(mPGF, "FoodsCat");
                // Linearizing all the trees
                for (int i = 0 ; i < trees.length ; i++) {
                    try {
                        String t = mLinearizer.linearizeString(trees[i]);
                        translations[i] = t;
                    } catch (java.lang.Exception e) {
                        translations[i] = "/!\\ Linearization error";
                    }
                }
                return translations;
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
        
        protected void onPostExecute(String[] result) {
            mArrayAdapter.clear();
            for (String sentence : result)
                mArrayAdapter.add(sentence);
            if (this.progress != null)
                this.progress.dismiss(); // Remove loading popup
        }
    }
}

If you compile and test your application now, you should be able to translate sentences from the Foods grammar from English to Catalan. Feel free to play with other languages and other grammars.