srplab's blog - Yahoo! Blog

Writing android gui using python(menu scroll view and popup window)

srplab — Wed, 2 May 2012 21:09:00 +0800

Introduction

The examples in this article will create menu, scroll view and popup window. For menu widget, programmer should override android functions of activity, which are “onCreateOptionsMenu”, “onPrepareOptionsMenu”, “onOptionsItemSelected”. Using python, the same functions should be defined and assigned to activity object. Popup window is often used to show information or perform some interactions with customer. Python permits define functions in another function, which is convenient to define widgets in popup window.

Scroll View

Creating scroll view is more directly and simple.

Create scroll view object

MyScroll = Service.ScrollViewClass._New(MyLayout);

MyScroll.setLinearLayoutParams(Service.FILL_PARENT,Service.WRAP_CONTENT);

Create root layout in the scroll view

MyScrollLayout = Service.LinearLayoutClass._New(MyScroll);

MyScrollLayout.setOrientation("VERTICAL");

MyScrollLayout.setFrameLayoutParams(Service.FILL_PARENT,Service.WRAP_CONTENT);

Create a button, when is clicked, we create a new button in scroll view.

MyButtonIndex = 1;

//#set onClick event listener

def MyButton_onClick(self,Ev) :

global MyButtonIndex;

//#Create a new button in scroll view

b = Service.ButtonClass._New(MyScrollLayout);

//#Set text content and color

b.setText("Button" + str(MyButtonIndex));

b.setTextColor(0xFFFF0000);

b.setLinearLayoutParams(Service.FILL_PARENT,Service.WRAP_CONTENT);

MyButtonIndex = MyButtonIndex + 1;

return;

//#assign event listener to object

MyButton.onClick = MyButton_onClick;

Popup window

Popup window is often used to show information or perform some interactions with customer.

Create a button, when is clicked, we create a popup window.

OpenPopWindowButton = Service.ButtonClass._New(ButtonLayout);

OpenPopWindowButton.setText("Open popup window");

OpenPopWindowButton.setLinearLayoutParams(Service.WRAP_CONTENT,Service.WRAP_CONTENT);

def OpenPopWindowButton_onClick(self, Ev):

…

return;

OpenPopWindowButton.onClick = OpenPopWindowButton_onClick

In onClick event function, a popup window is created

Because python permits to define function in another function, we can create popup window and create functions for it.

def OpenPopWindowButton_onClick(self, Ev):

//#create popup window

MyPopupWindow = Service.PopupWindowClass._New()

//#set onDismiss event listener

def MyPopupWindow_onDismiss(self, Ev):

Service.ToastClass._New().makeText("PopupWindow is dismiss",0).show();

return;

MyPopupWindow.onDismiss = MyPopupWindow_onDismiss;

//#create root layout for popup window

PopupLayout = Service.LinearLayoutClass._New();

PopupLayout.setBackgroundColor(0xFF0000FF) #--blue

//#create a button

MyButton = Service.ButtonClass._New(PopupLayout);

def MyButton_onClick(self, Ev) :

//#when is clicked, we show information and close the popup window

Service.ToastClass._New().makeText("Button is click",0).show();

MyPopupWindow.dismiss();

return;

MyButton.onClick = MyButton_onClick;

MyButton.setText("CloseWindow");

MyButton.setLinearLayoutParams(Service.WRAP_CONTENT,Service.WRAP_CONTENT);

//#assign layout to popup window.

MyPopupWindow.setContentView(PopupLayout);

MyPopupWindow.setWidth(200);

MyPopupWindow.setHeight(200);

MyPopupWindow.setFocusable(True);

MyPopupWindow.showAtLocation(self,17,0,0);

//#prevent garbage collected by python.

MyPopupWindow._LockGC();

return;

Screenshot:

Examples download:

http://www.srplab.com/android/pythongui_menu_scrollview_popupwindow.rar

Writing android gui using lua(introduction)

srplab — Fri, 27 Apr 2012 23:51:00 +0800

Introduction

Lua is more like python. Both are all dynamic languages, with little difference in syntax. Therefore these series of articles are similar to "write android gui using python" series.
Using CLE and wrapandroid project, programmers can also write android gui applications with lua. CLE supports interaction between lua and java, gives a common interface for multiple programming languages. Wrapandroid project encapsulates android java class with cle objects. This article is an introduction. There will have series of articles to further explain how to programming android applications using lua.

Preparing environment

Unlike python, for lua engine has been embedded in CLE, you do not need to install other support packages.

a: CLE may install from network by application automatically, you need only include starcore_android_r5.jar in the project. The file is in starcore_devfiles_r5.zip, which can be download from http://code.google.com/p/cle-for-android

b: Wrapandroid has two files: wrapandroid.jar and SRPWrapAndroidEngine.xml, which can be download from http:/code.google.com/p/wrapandroid-for-multilaguage/download/wrapandroid_devfiles_0_8_2.rar

Begin programming

a. Open eclipse, create a new android project, for example, “introduction”

b. Add Permission, which is used to download and install cle for the application

c. copy files : starcore_android_r5.jar and wrapandroid.jar into the project directory, and add them to java build path, as shown below.

d. copy file : SRPWrapAndroidEngine.xml to assets directory.

e. edit IntroductionActivity.java

import com.srplab.wrapandroid.*;

public class IntroductionActivity extends WrapAndroidActivity {

/** Called when the activity is first created. */

@Override

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

//setContentView(R.layout.main);

StarActivity._Call("DoAssetsFile", "lua", "code.lua");

}

f. create new text file code.lua in assets directory.

code.lua

get current service maintained by cle

SrvGroup = libstarcore._GetSrvGroup()

Service = SrvGroup:_GetService("","")

get current activity, which is created by wrapandroid at init stage

StarActivity = Service.ActivityClass:getCurrent();

from now on, we can create gui elements. The first element should be layout element, which may be linear layout, absolute layout, etc. In this example, we create linear layout, which contains an edit text and buttons.

create root layout

MyLayout = Service.LinearLayoutClass:_New(StarActivity);

MyLayout:setOrientation("VERTICAL");

create title layout and gui elements

MyTitleLayout = Service.LinearLayoutClass:_New(MyLayout);

MyTitleLayout:setLinearLayoutParams(Service.FILL_PARENT,Service.WRAP_CONTENT);

UrlEdit = Service.EditTextClass:_New(MyTitleLayout);

UrlEdit:setText("http://www.google.com");

UrlEdit:setLinearLayoutParams(StarActivity:getWidth()-200,Service.WRAP_CONTENT);

GoButton = Service.ButtonClass:_New(MyTitleLayout);

GoButton:setText("go");

GoButton:setLinearLayoutParams(100,Service.FILL_PARENT);

function GoButton:onClick(ev)

MyWebView:loadUrl(UrlEdit:getText());

end

ExitButton = Service.ButtonClass:_New(MyTitleLayout);

ExitButton:setText("exit");

ExitButton:setLinearLayoutParams(100,Service.FILL_PARENT);

function ExitButton:onClick(ev)

StarActivity:exit(0);

end

create webview layout and webview instance

MyTitleLayout1 = Service.LinearLayoutClass:_New(MyLayout);

MyTitleLayout1:setLinearLayoutParams(Service.FILL_PARENT,Service.FILL_PARENT);

MyWebView = Service.WebViewClass:_New(MyTitleLayout1)

MyWebView:setLinearLayoutParams(Service.FILL_PARENT,Service.FILL_PARENT);

MyWebSettings = MyWebView:getSettings();

MyWebSettings:setJavaScriptEnabled(true);

MyWebSettings:_Free();

The screenshot is as shown below:

Example can be downloaded from http://www.srplab.com/android/luagui_introduction.rar

Writing android gui using python(list view and custom view)

srplab — Thu, 26 Apr 2012 20:00:00 +0800

Introduction

The examples in this article will create a listview and a custom view. Android listview often uses adapter such as “ArrayAdapter(…)”. The syntax is java generic, which may have no corresponding types in dynamic script languages, such as python, lua, etc. Therefore, we have to give specific class, such as StringArrayAdaper, for it can be used in these dynamic languages. For StringArrayAdapter, we can override function getView to return little more complex view for listview. For custom view, we can create instance of View, and override its function onDraw. In function onDraw, we may draw text or bitmaps using function of canvas.

List View

We first create an instance of StringArrayAdapterClass, which is defined wrapandroid.jar package. And then create a list view.

Create StringArrayAdapter and override its function getView

//#create instance of StringArrayAdapterClass

MyStringArrayAdapter = Service.StringArrayAdapterClass._New();

//#override function getView

def MyStringArrayAdapter_getView(self,position, convertView, parent) :

global Service;

//#create linearlayout

i = Service.LinearLayoutClass._New();

px = i.dp2px(5);

//#set padding

i.setPadding(px,px,px,px);

//#set layout parameters, here we should uses function “setAbsListViewLayoutParams”

i.setAbsListViewLayoutParams(Service.WRAP_CONTENT,Service.WRAP_CONTENT);

//#create an imageview

imageView = Service.ImageViewClass._New(i);

//#set padding

imageView.setPadding(5,5,5,5);

//#set layout parameters. Because imageView is child of LinearLayout, we should use function “setLinearLayoutParams”.

imageView.setLinearLayoutParams(i.dp2px(24),i.dp2px(24));

//#create TextView

itextview = Service.TextViewClass._New(i);

//#set layout parameter

itextview.setLinearLayoutParams(Service.WRAP_CONTENT,Service.WRAP_CONTENT);

//#set size of font.

itextview.setTextSize(i.sp2px(18))

//#set content of textview and imageview based on position

if( position == 0 ) :

itextview.setText("Android");

imageView.setImageResource(StarActivity.getResource("drawable/android_logo"));

if( position == 1 ) :

itextview.setText("WindowsMobile");

imageView.setImageResource(StarActivity.getResource("drawable/windowsmobile_logo"));

if( position == 2 ) :

itextview.setText("iOS");

imageView.setImageResource(StarActivity.getResource("drawable/ios_logo"));

if( position == 3 ) :

itextview.setText("Blackberry");

imageView.setImageResource(StarActivity.getResource("drawable/blackberry_logo"));

//#call _LockGC function before function returns to prevent the object GC by python.

i._LockGC();

return i;

MyStringArrayAdapter.getView = MyStringArrayAdapter_getView;

#add string values to StringArrayAdapter.

MyStringArrayAdapter.add("Android");

MyStringArrayAdapter.add("WindowsMobile");

MyStringArrayAdapter.add("iOS");

MyStringArrayAdapter.add("Blackberry");

Create ListView and set its adapter

//#create ListView

MyListView = Service.ListViewClass._New(MyLayout);

//#set its onItemClick event listener.

def MyListView_onItemClick(self, Ev,objid,position,id) :

Service.ToastClass._New().makeText("[MyListView] event on click is onItemClick "+objid,0).show();

MyListView.onItemClick = MyListView_onItemClick;

//#set layout prameter

MyListView.setLinearLayoutParams(Service.FILL_PARENT,150);

//#set adapter

MyListView.setAdapter(MyStringArrayAdapter);

Custom View

For custom view, we can create instance of View, and override its function onDraw. In function onDraw, we may draw text or bitmaps using function of canvas.

Create a Paint and BitmapFactory for using in next step.

MyPaint = Service.PaintClass._New();

MyBitmapFactory = Service.BitmapFactoryClass._New();

Create View and override its function onDraw

def myView_onDraw(self,canvas) :

global MyBitmapFactory,MyPaint

//#call parent onDraw function

self.onSuperDraw(canvas);

//#set color of Paint

MyPaint.setColor(0xFFFF0000);

//#draw a rect on canvas

canvas.drawRect(10, 20, 100, 100, MyPaint);

//#get bitmap from resources.

MyBitmap = MyBitmapFactory.decodeResource(StarActivity.getResource("drawable/aqua02"));

//#draw the bitmap on canvas

canvas.drawBitmap(MyBitmap, 100, 100, None);

//#create an matrix object

matrix=Service.MatrixClass._New();

//#set rotation parameter of matrix

matrix.postScale(0.8, 0.8);

matrix.postRotate(45);

//create a new bitmap and set to the result of previous bitmap with matris

dstbmp=Service.BitmapClass._New();

dstbmp.createBitmap0(MyBitmap,0,0,MyBitmap.getWidth(),MyBitmap.getHeight(),matrix,True);

//#draw the bitmap

canvas.drawBitmap(dstbmp, 300, 100, None);

//#free object created locally

matrix._Free();

dstbmp._Free();

MyBitmap._Free();

myView.onDraw = myView_onDraw;

//#set layout parameter.

myView.setLinearLayoutParams(Service.FILL_PARENT,Service.FILL_PARENT);

Screenshot:

Examples download:

http://www.srplab.com/android/listandcustomview.rar

Writing android gui using python(gallery)

srplab — Sun, 22 Apr 2012 19:39:00 +0800

Introduction

Wrapandroid version is updated to 0.8.2. Please uses this version.

We might write python code outside eclipse. In this case, we have no logcat window to show print message from python. Do not worry about, cle supports syslog. The message can be output to syslog server. Using the following sentence to open syslog client:

SrvGroup._SetOutputPort("192.168.0.129",514)
The ipaddress should be adjusted based on your environment.

Output likes this:

Android gallery is a little more complicate gui element. In order to use gallery, we should first create an adapter, override its functions. And then, gallery object uses the adapter to obtain the content to be drawn.

Create adapter object

Wrapandroid’s adpterClass encapsulates android java class adapter. It has functions can be override, such as getCount, getItem, getItemId, getView,etc. Detailed explains of these functions, please refer to android documents.

1. Create bitmap object

Bitmap0 = StarActivity.getBitmapDrawable(StarActivity.getResource("drawable/aqua02")).getBitmap();
Bitmap1 = StarActivity.getBitmapDrawable(StarActivity.getResource("drawable/aqua03")).getBitmap();
Bitmap2 = StarActivity.getBitmapDrawable(StarActivity.getResource("drawable/aqua04")).getBitmap();
Bitmap3 = StarActivity.getBitmapDrawable(StarActivity.getResource("drawable/aqua05")).getBitmap();

Bitmap resources locates in project directory res\drawable-hdpi.

2. getCount, getItem,and getItemId function

MyAdapter = Service.AdapterClass._New()
def MyAdapter_getCount(self) :
return 4;
MyAdapter.getCount = MyAdapter_getCount;
def MyAdapter_getItem(self,position) :
return position;
MyAdapter.getItem = MyAdapter_getItem;
def MyAdapter_getItemId(self,position) :
return position;
MyAdapter.getItemId = MyAdapter_getItemId;

3. getView function

def MyAdapter_getView(self,position,convertView,parent) :
global Service;
i = Service.ImageViewClass._New();
if( position == 0 ) :
i.setImageBitmap(Bitmap0);
if( position == 1 ) :
i.setImageBitmap(Bitmap1);
if( position == 2 ) :
i.setImageBitmap(Bitmap2);
if( position == 3 ) :
i.setImageBitmap(Bitmap3);
i.setGalleryLayoutParams(Service.FILL_PARENT,Service.FILL_PARENT);
i.setScaleType("FIT_XY");
i.setBackgroundResource(StarActivity.getResource("mGalleryItemBackground"));
i._LockGC();
return i;
MyAdapter.getView = MyAdapter_getView;

Because imageview object is created by python, when function returns. the object will be freed by GC. So, we should call _LockGC before function return.

Create Gallery object

MyGallery = Service.GalleryClass._New(MyLayout)
def MyGallery_onItemClick(self,event,objid,position,id ):
Service.ToastClass._New().makeText("[MyGallery] event on onItemClick is trigger "+objid+str(position)+str(id),0).show();
MyGallery.onItemClick = MyGallery_onItemClick;
MyGallery.setAdapter(MyAdapter);
MyGallery.setLinearLayoutParams(Service.FILL_PARENT,Service.FILL_PARENT);

Screenshot:

Examples download:

http://www.srplab.com/android/pythongui_gallery.rar

Writing android gui using python(basic gui elements)

srplab — Wed, 18 Apr 2012 21:28:00 +0800

Let’s continue the topic. In this article, we gives example of basic android gui elements created and controlled using python, which may be buttons, textviews, checkboxs, radiobuttons.

Before the topic, we discuss how to create timer using python. Python script code runs in the thread context of android main activity. Therefore, we can not use local loop statement for example, “while”, to wait some actions, such as waiting response from remote server. In this case, a timer may be used. Based on the support of CLE, create a timer using python is simple, there are three steps:

1. create an object.

2. define a timer function and assign to the object.

3. create an object’s timer.

The detailed code example is as follow

timerobj = Service._New();

def timerobj _timerfunc(self,arg1,arg2) :

print(“timer is trigger”);

timerobj.timerfunc = timerobj _timerfunc;

timerobj._SetTimer(100, timerobj.timerfunc,0,0); # timer triggered per second.

For basic android gui elements, the corresponding cle class name are “ButtoClass”, “TextViewClass”, “EditClass”, “CheckBoxClass”, “RadioGroupClass”, “RadioButtonClass”. The naming rules is android java class name with suffix “Class”, which is easy to remember. Functions and events are similar to android class. So, for detailed information about the class, you can refer to android development kit documents. By now, wrapandroid project is in progress, it wrap general used functions and events of the class. Which are wrapped, please refer to document wrapandroid.chm.

In order to place gui elements on the screen, we first should create layout, which may by Linear Layout or Absolute Layout. In the example, we use Linear Layout.

1. Create LinearLayout

MyLayout = Service.LinearLayoutClass._New(StarActivity);

MyLayout.setOrientation("VERTICAL");

2. Create a button, set text, and textcolor

Button = Service.ButtonClass._New(MyLayout);

Button.setText("hello button");

Button.setTextColor(0xFF0000FF);

Button.setLinearLayoutParams(Service.FILL_PARENT,Service.WRAP_CONTENT);

def Button_onClick(self,ev) :

Service.ToastClass._New().makeText("button is clicked",0).show();

Button.onClick = Button_onClick;

3. Create a textview

Text = Service.TextViewClass._New(MyLayout);

Text.setText("hello text");

Text.setTextColor(0xFFFF0000);

Text.setTextSize(30);

Text.setLinearLayoutParams(Service.WRAP_CONTENT,Service.WRAP_CONTENT);

4. Create an EditText

MyEdit = Service.EditTextClass._New(MyLayout);

MyEdit.setLinearLayoutParams(Service.FILL_PARENT,Service.WRAP_CONTENT);

5. Create an RadioGroup

MyRadioGroup = Service.RadioGroupClass._New(MyLayout);

MyRadioGroup.setLinearLayoutParams(Service.FILL_PARENT,Service.WRAP_CONTENT);

def MyRadioGroup_onCheckedChanged(self,Event,objid) :

Service.ToastClass._New().makeText("[MyRadioGroup] event on click is trigger"+objid,0).show();

return;

MyRadioGroup.onCheckedChanged = MyRadioGroup_onCheckedChanged;

6. Create RadioButton in the group

MyRadioButton1 = Service.RadioButtonClass._New(MyRadioGroup);

MyRadioButton1.setText("RadioButton1");

MyRadioButton2 = Service.RadioButtonClass._New(MyRadioGroup);

MyRadioButton2.setText("RadioButton2");

7. Create a timer, in timer, we update content of textview.

Index = 1;

def Text_timerfunc(self,TimerID,arg1,arg2) :

global Index

self.setText("hello text "+str(Index));

Index = Index + 1;

Text.timerfunc = Text_timerfunc;

Text._SetTimer(1, Text.timerfunc,0,0);

Screenshot:

Examples download:
http://www.srplab.com/android/pythongui_basicguielements.rar

Writing android gui using python(introduction)

srplab — Sun, 15 Apr 2012 17:05:00 +0800

PythonForAndroid provides support for python script language on android. CLE project supports interaction between python and java, gives a common interface for multiple programming languages. And wrapandroid project encapsulates android java class with cle objects. Using the three components, programmers can write android gui programs with python directly. This article is an introduction. There will have series of articles to further explain how to programming android applications using python.

1. Preparing environment.

a: install PythonForAndroid from http://code.google.com/p/android-scripting

b: CLE may install from network by application automatically, you need only include starcore_android_r5.jar in the project. The file is in starcore_devfiles_r5.zip, which can be download from http://code.google.com/p/cle-for-android

c: Wrapandroid has two files: wrapandroid.jar and SRPWrapAndroidEngine.xml, which can be download from http:/code.google.com/p/wrapandroid-for-multilaguage/download/wrapandroid_devfiles_0_8_1.rar

2. Begin programming

a. Open eclipse, create a new android project, for example, “introduction”

b. Add Permission, which is used to download and install cle for the application

c. copy files : starcore_android_r5.jar and wrapandroid.jar into the project directory, and add them to java build path, as shown below.

d. copy file : SRPWrapAndroidEngine.xml to assets directory.

e. edit IntroductionActivity.java

import com.srplab.wrapandroid.*;

public class IntroductionActivity extends WrapAndroidActivity {

/** Called when the activity is first created. */

@Override

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

//setContentView(R.layout.main);

StarActivity._Call("DoAssetsFile", "python", "code.py");

}

f. create new text file code.py in assets directory.

3. code.py

a. get current service maintained by cle

SrvGroup = libstarpy._GetSrvGroup()

Service = SrvGroup._GetService("","")

b. get current activity, which is created by wrapandroid at init stage

StarActivity = Service.ActivityClass.getCurrent();

c. create root layout

MyLayout = Service.LinearLayoutClass._New(StarActivity);

MyLayout.setOrientation("VERTICAL");

d. create title layout and gui elements

MyTitleLayout = Service.LinearLayoutClass._New(MyLayout);

MyTitleLayout.setLinearLayoutParams(Service.FILL_PARENT,Service.WRAP_CONTENT);

UrlEdit = Service.EditTextClass._New(MyTitleLayout);

UrlEdit.setText("http://www.google.com");

UrlEdit.setLinearLayoutParams(StarActivity.getWidth()-200,Service.WRAP_CONTENT);

GoButton = Service.ButtonClass._New(MyTitleLayout);

GoButton.setText("go");

GoButton.setLinearLayoutParams(100,Service.FILL_PARENT);

def GoButton_onClick(self,ev) :

global MyWebView;

MyWebView.loadUrl(UrlEdit.getText());

GoButton.onClick = GoButton_onClick;

ExitButton = Service.ButtonClass._New(MyTitleLayout);

ExitButton.setText("exit");

ExitButton.setLinearLayoutParams(100,Service.FILL_PARENT);

def ExitButton_onClick(self,ev) :

global StarActivity;

StarActivity.exit(0);

ExitButton.onClick = ExitButton_onClick;

e. create webview layout and webview instance

MyTitleLayout1 = Service.LinearLayoutClass._New(MyLayout);

MyTitleLayout1.setLinearLayoutParams(Service.FILL_PARENT,Service.FILL_PARENT);

MyWebView = Service.WebViewClass._New(MyTitleLayout1)

MyWebView.setLinearLayoutParams(Service.FILL_PARENT,Service.FILL_PARENT);

MyWebSettings = MyWebView.getSettings();

MyWebSettings.setJavaScriptEnabled(True);

MyWebSettings._Free();

The screenshot is as shown below:

examples can be download from : http://www.srplab.com/android/pythongui_introduction.rar

Let android support multiple programming languages

srplab — Wed, 11 Apr 2012 20:58:00 +0800

Java is used as main language on android to write applications. Although ndk is provided, but it is difficult to write native GUI applications. Can we write programs with other languages? The answer is yes. We can wrap android java classes to expose to special languages, and then uses that language to develop applications. The work should be done once instead of doing it for each language again and again. Using middleware named CLE(common language extension) is able to achieve this. Using CLE, all the work needed to do is encapsulated android class into cle objects, then, multiple languages are supported through cle interface.

Using a figure to illustrate, as shown below:

Wrapping an android class into cle object, there are four steps:

1. Create CLE service and object description

2. Implement Object’s OnCreate and OnDestroy event. In procedure of OnCreate event, we create and record a corresponding instance of android class, and OnDestroy event, we free the instance.

3. In the handler of OnCreate event, after created the android instance, we add event listeners to it. When the listener is triggered, we generate cle event, and the event will be routed by cle to application layer.

4. Write interface functions, for each function, we first get the recorded android instance, and then calls the corresponding functions of the instance.

Based on the support of cle, the work is relatively simple. In this process, we can use ecllipse and java language to write and test. After finish, the result can be called with lua, python, or native c++.

Here uses a simple example to explain the above procedure in details. In this example, we encapsulate a button class.

1. Create CLE service and object description, we can do this with srpdebug tools.

2. OnCreate event of button

/* _OnCreate Event */

public Object[] _OnCreate(Hashtable Ev){

StarObjectClass self = (StarObjectClass)Ev.get("_DesObject");

StarObjectClass parent = (StarObjectClass)self._Get("_Parent");

StarObjectClass activity = (StarObjectClass)self._Call("getActivity");

/* create android button instance */

StarCLEButton button = new StarCLEButton((Activity)WrapAndroidClass.GetAndroidObject(activity,"AndroidObject"),self);

/* record android button instance */

WrapAndroidClass.SetAndroidObject(self,"AndroidObject",(Object)button);

/* set android button instance’s parent */

if( parent != null ){

if( activity == parent ){

Activity android_activity = (Activity)WrapAndroidClass.GetAndroidObject(parent,"AndroidObject");

android_activity.setContentView(button);

}else{

ViewGroup android_viewgroup = (ViewGroup)WrapAndroidClass.GetAndroidObject(parent,"AndroidObject");

android_viewgroup.addView(button);

}

self._LockGC();

self._Call("decAndroidRef"); // release with parent

}

/* Add event listener */

button.setOnClickListener(new View.OnClickListener(){

public void onClick(View v) {

StarObjectClass self = ((BasicAndroidInterface)v).getBasicAndroid().getStarObject();

/* trigger CLE object’s event onClick */

self._ProcessEvent("onClick");

}

});

return null;

}

3. set Text function of Button.

public void setText(StarObjectClass self,String Text){

/*get recorded android instance*/

TextView textview = (TextView)WrapAndroidClass.GetAndroidObject(self,"AndroidObject");

if( textview != null )

/*call android instance’s function setText*/

textview.setText(Text);

}

4. export to jar files: “wrapandroid.jar”

Finish the above steps, we can obtain jar files “wrapandroid.jar” and service description files “WrapAndroidService.xml”. And then, we can write programs with other languages using eclipse.

5. Programming with lua.
a.    Create android project named “myluaexample”
b.    copy “wrapandroid.jar” and “starcore_android_r5.jar” to your project directory. add jar library to your project.

c.    Copy “WrapAndroidService.xml” to assets directory of your project
d.    Add Permission

e.    Create code.lua file in asserts directory, input text
SrvGroup = libstarcore._GetSrvGroup()
Service = SrvGroup:_GetService("","")

--get activity
StarActivity = Service.ActivityClass.getCurrent();

--create AbsoluteLayout
MyLayout = Service.AbsoluteLayoutClass:_New(StarActivity);

--create Button
MyButton = Service.ButtonClass:_New(MyLayout);
MyButton:setText("Hello");
function MyButton:onClick(Event)
self:setText("Is Clicked");
end
f.    Edit “MyluaexampleActivity”, as follow:
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// setContentView(R.layout.main);
StarActivity._Call("DoAssetsFile", "lua", "code.lua");
}
6.    Programming with python.
a.    Install SL4A
b.    Create android project named “mypythonexample”
c.    Create code.py file in asserts directory, input text

SrvGroup = libstarpy._GetSrvGroup()
Service = SrvGroup._GetService("","")

#--get activity
StarActivity = Service.ActivityClass.getCurrent();

#--create AbsoluteLayout
MyLayout = Service.AbsoluteLayoutClass._New(StarActivity);

#--create Button
MyButton = Service.ButtonClass._New(MyLayout);
MyButton.setText("Hello");
def MyButton_onClick(self,Event) :
self.setText("Is Clicked");
MyButton.onClick = MyButton_onClick

d.    Edit “MypythonexampleActivity”, as follow:

public class MypythonexampleActivity extends WrapAndroidActivity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
//setContentView(R.layout.main);
StarActivity._Call("DoAssetsFile", "python", "code.py");
}
}
other steps are same as lua example.
7.    Programming with native c.
a.    Create android project named “mycexample”
b.    Create jni directory, enter jni, and create header files from xml file, using command
star2h ..\assets\WrapAndroidService.xml
c.    create Code.cpp source file
#include "WrapAndroidService_VSDHeader.h"

static class ClassOfSRPInterface *SRPInterface;
static void *StarActivity;

static VS_INT32 MyButton_onClick(VS_ULONG FunctionChoice,void *EventPara)
{
VS_EVENTPARAM *EventParam;

EventParam = (VS_EVENTPARAM *)EventPara;
SRPInterface -> ScriptCall(EventParam->SrcObject,NULL,"setText","(s)","Is Clicked");
return 0;
}

VS_BOOL StarCoreService_Init(class ClassOfStarCore *starcore)
{
class ClassOfBasicSRPInterface *BasicSRPInterface;

//--init star core
BasicSRPInterface = starcore ->GetBasicInterface();
SRPInterface = BasicSRPInterface ->GetSRPInterface(BasicSRPInterface->QueryActiveService(NULL),"","");

void *ActivityClass;
ActivityClass = SRPInterface -> GetObjectEx(NULL,"ActivityClass");
StarActivity = (void *)SRPInterface -> ScriptCall(ActivityClass,NULL,"getCurrent","()O");
SRPInterface -> Print("Get Main Activity = %s", SRPInterface -> GetName(StarActivity));

//--create AbsoluteLayout
void *MyLayout = SRPInterface->MallocObject(StarActivity,VSATTRINDEX_ACTIVITYCLASS_VIEWGROUPQUEUE,&VSOBJID_AbsoluteLayoutClass,0,NULL);

//--create Button
void *MyButton = SRPInterface->MallocObject(MyLayout,VSATTRINDEX_ABSOLUTELAYOUTCLASS_VIEWQUEUE,&VSOBJID_ButtonClass,0,NULL);
SRPInterface -> ScriptCall(MyButton,NULL,"setText","(s)","Hello");
SRPInterface -> RegEventFunction(MyButton,&VSOUTEVENTID_ButtonClass_onClick,MyButton,(void *)MyButton_onClick,0);

return VS_TRUE;
}

void StarCoreService_Term(class ClassOfStarCore *starcore)
{
SRPInterface -> Release();
return;
}

d.    create Android.mk.

LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)

# Here we give our module name and sourcefile(s)
LOCAL_CFLAGS += -Wno-write-strings -DENV_ANDROID
LOCAL_CPPFLAGS += -Wno-write-strings -fexceptions -DENV_ANDROID
LOCAL_LDFLAGS += -Wno-write-strings -DENV_ANDROID

LOCAL_C_INCLUDES += cle_files/include

#--------source file
MODULE_CXXSRCS := Code.cpp WrapAndroidService_UUIDDef.cpp

LOCAL_SRC_FILES := ${MODULE_CXXSRCS}
LOCAL_LDLIBS := cle_files/libs/armeabi/libstarlib.a

LOCAL_MODULE := Code

include $(BUILD_SHARED_LIBRARY)
e.    Edit “MycexampleActivity”, as follow:

public class MycexampleActivity extends WrapAndroidActivity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
//setContentView(R.layout.main);
StarActivity._Call("DoFile","","/data/data/com.srplab.mycexample/lib/libCode.so");
}
}

The example can be download from :
http://www.srplab.com/android/wrapandroid.rar
An open source project http://code.google.com/p/wrapandroid-for-multilanguage is in progress. Anyone who has interest can join the project.

Calling C/C++ from java android using CLE

srplab — Sun, 4 Mar 2012 16:14:00 +0800

There are lots of resources written in C/C++ languages. But on android platform, Java is major language. Developers have to using JNI to wrap the interface of c/c++ codes. JNI is suitable for simple case. For more complicate application, programmers have to maintain references of c++ objects to java objects, process callback functions from c/c++ to java, etc, which are not easy. Using CLE, these works will be done by CLE, programmers only need to focus on specific functions.

For java calls c/c++ using CLE, method is not directly as java calls scripts, such as lua, python, etc. Because, script languages are all have reflection mechanism. We can get functions and attributes definition dynamically. But for C/C++, there has no similar mechanism. All definitions in source code will be compiled into binary code. Therefore, we need descript functions and attributes of objects first, if CLE is used.

There are two methods to descript object’s attributes and functions.

First method, using interface functions of CLE.

void *AtomicClass,*Add_AtomicFunction,*Print_AtomicFunction;

AtomicClass = SRPInterface ->CreateAtomicObjectSimple("TestItem","TestClass","VS_INT32 CValue",NULL,NULL);

Add_AtomicFunction = SRPInterface ->CreateAtomicFunctionSimple(AtomicClass,"CAdd","VS_INT32 CAdd(VS_INT32 x,VS_INT32 y);",NULL,NULL,VS_FALSE,VS_FALSE);

Print_AtomicFunction = SRPInterface ->CreateAtomicFunctionSimple(AtomicClass,"CPrint","void CPrint(VS_INT32 x,VS_INT32 y);",NULL,NULL,VS_FALSE,VS_FALSE);

Second method, using xml string generates object’s attributes and functions.

void *AtomicClass,*Add_AtomicFunction,*Print_AtomicFunction;

class ClassOfSRPSXMLInterface *SXMLInterface;

SXMLInterface = BasicSRPInterface -> GetSXMLInterface();

SXMLInterface -> LoadFromBuf(

" <?xml version=\"1.0\" encoding=\"utf-8\" ?>\n"

" <sysrootitem>\n"

" <TestItem>\n"

" <object>\n"

" <TestClass ID=\"ed51e615-e548-442e-8802-a99b2fa8fe15\">\n"

" <attribute>\n"

" <CValue Type=\"VS_INT32\" />\n"

" </attribute>\n"

" <function>\n"

" <CAdd ID=\"f402fd47-8bea-4136-b7f7-45bb7fb51b14\">\n"

" <input Name=\"x\" Type=\"VS_INT32\" />\n"

" <input Name=\"y\" Type=\"VS_INT32\" />\n"

" <output Type=\"VS_INT32\" />\n"

" </CAdd>\n"

" <CPrint ID=\"da44c24e-f20a-46e3-8d37-49c3b90c6c05\">\n"

" <input Name=\"x\" Type=\"VS_INT32\" />\n"

" <input Name=\"y\" Type=\"VS_INT32\" />\n"

" </CPrint>\n"

" </function>\n"

" </TestClass>\n"

" </object>\n"

" </TestItem>\n"

" </sysrootitem>\n"

,NULL);

SRPInterface -> XmlToSysRootItem(SXMLInterface,NULL,"",NULL,0);

AtomicClass = SRPInterface ->GetAtomicObject(_UUIDPTR("ed51e615-e548-442e-8802-a99b2fa8fe15"));

Add_AtomicFunction = SRPInterface ->GetAtomicFunction(_UUIDPTR("f402fd47-8bea-4136-b7f7-45bb7fb51b14"));

Print_AtomicFunction = SRPInterface ->GetAtomicFunction(_UUIDPTR("da44c24e-f20a-46e3-8d37-49c3b90c6c05"));

After finish object’s attributes and functions, we can attach functions body address:

//---Set Function Address

SRPInterface -> SetAtomicFunction(Add_AtomicFunction,(void *)CAdd);

SRPInterface -> SetAtomicFunction(Print_AtomicFunction,(void *)CPrint);

By now, the functions and attributes can be accessed from java.

java code:

StarObjectClass a = Service._GetObject("TestClass")._New();

a._Call("CAdd",12,34));

Callback of c/c++ to java:

java call back function:

StarObjectClass a = Service._GetObject("TestClass")._New()._Assign(new StarObjectClass(){

public int JavaAdd(StarObjectClass self,int x,int y){

return x+y;

}

});

c code:

VS_INT32 ScriptStack;

ScriptStack = SRPInterface -> ScriptGetStack(); //----save script stack

SRPInterface -> Print( "Function result from java %d",SRPInterface -> ScriptCall(Object,NULL,"JavaAdd","(ii)i)",x,y) );

SRPInterface -> ScriptSetStack(ScriptStack);

source code ( integrate CLE with your project):

1. Download devfiles from http://code.google.com/p/cle-for-android, and then Open Eclipse

2. Create project for android.

3. Add CLE jar to project as follows:

4. c++ codes

#include "vsopenapi.h"

class ClassOfSRPInterface *SRPInterface;

struct StructOfTestClass{

VS_INT32 CValue;

};

static VS_INT32 CAdd(void *Object,VS_INT32 x,VS_INT32 y)

{

struct StructOfTestClass *TestClass;

TestClass = (struct StructOfTestClass *)Object;

TestClass -> CValue = 200;

SRPInterface -> Print("Call c function...");

return x+y;

}

static void CPrint(void *Object,VS_INT32 x,VS_INT32 y)

{

VS_INT32 ScriptStack;

ScriptStack = SRPInterface -> ScriptGetStack(); //----save script stack

SRPInterface -> Print( "Value defined in java is %d",SRPInterface -> ScriptGetInt(Object,"JavaValue") );

SRPInterface -> Print( "Function result from java %d",SRPInterface -> ScriptCall(Object,NULL,"JavaAdd","(ii)i)",x,y) );

SRPInterface -> ScriptSetStack(ScriptStack); //----restore script stack

}

VS_BOOL StarCoreService_Init(class ClassOfStarCore *starcore)

{

void *AtomicClass,*Add_AtomicFunction,*Print_AtomicFunction;

class ClassOfBasicSRPInterface *BasicSRPInterface;

//--init star core

BasicSRPInterface = starcore ->GetBasicInterface();

SRPInterface = BasicSRPInterface ->GetSRPInterface(BasicSRPInterface->QueryActiveService(NULL),"","");

//---Create Atomic Class, for define function,

AtomicClass = SRPInterface ->CreateAtomicObjectSimple("TestItem","TestClass","VS_INT32 CValue",NULL,NULL);

Add_AtomicFunction = SRPInterface ->CreateAtomicFunctionSimple(AtomicClass,"CAdd","VS_INT32 CAdd(VS_INT32 x,VS_INT32 y);",NULL,NULL,VS_FALSE,VS_FALSE);

Print_AtomicFunction = SRPInterface ->CreateAtomicFunctionSimple(AtomicClass,"CPrint","void CPrint(VS_INT32 x,VS_INT32 y);",NULL,NULL,VS_FALSE,VS_FALSE);

//---Set Function Address

SRPInterface -> SetAtomicFunction(Add_AtomicFunction,(void *)CAdd);

SRPInterface -> SetAtomicFunction(Print_AtomicFunction,(void *)CPrint);

return VS_TRUE;

}

void StarCoreService_Term(class ClassOfStarCore *starcore)

{

SRPInterface -> Release();

return;

}

Compile code into share library using NDK, the Android.mk is:

LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)

# Here we give our module name and sourcefile(s)

LOCAL_CFLAGS += -Wno-write-strings -DENV_ANDROID

LOCAL_CPPFLAGS += -Wno-write-strings -fexceptions -DENV_ANDROID

LOCAL_LDFLAGS += -Wno-write-strings -DENV_ANDROID

LOCAL_C_INCLUDES += ../../cle_files/include

#--------source file

MODULE_CXXSRCS := AddFunction.cpp

LOCAL_SRC_FILES := ${MODULE_CXXSRCS}

LOCAL_LDLIBS := ../../cle_files/libs/armeabi/libstarlib.a

LOCAL_MODULE := AddFunction

include $(BUILD_SHARED_LIBRARY)

5. Java Codes:

package com.cle.cfromjava;

import android.app.Activity;

import android.os.Bundle;

import com.srplab.www.starcore.*;

import com.srplab.netinst.*;

public class CfromjavaActivity extends Activity {

/** Called when the activity is first created. */

@Override

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.main);

//--init CLE

starcore_net_inst.InstallZipFile(this,"libstarcore.so","http://www.srplab.com/android/starcore_armeabi_r3.zip", "/data/data/com.cle.cfromjava/files");

StarCoreFactoryPath.StarCoreShareLibraryPath = "/data/data/com.cle.cfromjava/files";

StarCoreFactoryPath.StarCoreOperationPath = "/data/data/com.cle.cfromjava/files";

StarCoreFactory starcore= StarCoreFactory.GetFactory();

StarServiceClass Service=starcore._InitSimple("test","123",0,0);

Service._CheckPassword(false);

Service._DoFile("","/data/data/com.cle.cfromjava/lib/libAddFunction.so","");

StarObjectClass a = Service._GetObject("TestClass")._New()._Assign(new StarObjectClass(){

public int JavaAdd(StarObjectClass self,int x,int y){

System.out.println("Call java function...");

return x+y;

}

});

a._Set("JavaValue",100);

System.out.println(a._Call("CAdd",12,34));

System.out.println(a._Get("CValue"));

a._Call("CPrint",56,78);

starcore._ModuleExit();

}

}
examples can be downloaded from http://www.srplab.com/android/calling_c_from_java.rar

Calling lua from java android using CLE

srplab — Tue, 28 Feb 2012 22:51:00 +0800

Java is major language to develop applications on android platform. But, in some case, programmers want to call lua code from java to perform some functions. There are many articles discussing this topic. Here, we present another method, which uses CLE middleware to call lua from java application on android.

CLE(Common Language Extension) is developed by srplab which presents functions to aid multi-language calls between scripts, including java, python, lua, etc. A lua engine has been compiled into cle core library. Using CLE, java calls lua code becomes very easy. Architecture of CLE is as follow:

Java calls lua functions:

lua function:

Obj=Service:_New("TestClass");

function Obj:LuaAdd(x,y)

return x+y;

end

java code:

StarObjectClass a = Service._GetObject("TestClass")._New();

a._Call("LuaAdd",12,34));

Callback of lua to java:

java call back function:

StarObjectClass a = Service._GetObject("TestClass")._New()._Assign(new StarObjectClass(){

public int JavaAdd(StarObjectClass self,int x,int y){

return x+y;

}

});

lua code:

Obj:JavaAdd(x,y)

Java gets object’s attributes defined in lua

Lua: Obj.LuaValue = 200;

Java: a._Get("LuaValue")

Lua gets object’s attributes defined in java

Java : a._Set("JavaValue",100);

Lua : self.JavaValue

Method1 source code ( intergrate CLE with your project):

1. Download devfiles from http://code.google.com/p/cle-for-android, and then Open Eclipse

2. Create project for android.

3. Add CLE libraries to project as follows:

4. Lua codes

SrvGroup = libstarcore._GetSrvGroup()

Service = SrvGroup:_GetService("","")

--Create objects

Obj=Service:_New("TestClass");

--Define functions

function Obj:LuaAdd(x,y)

print("Call lua function...");

return x+y;

end

--Call java functions

function Obj:LuaPrint(x,y)

print( "Value defined in java is ",self.JavaValue );

print( "Function result from java ",self:JavaAdd(x,y) );

end

--define Attributes

Obj.LuaValue = 200;

5. Java Codes:

package com.cle.luafromjava;

import android.app.Activity;

import android.os.Bundle;

import android.content.res.AssetManager;

import java.io.IOException;

import java.io.InputStream;

import com.srplab.www.starcore.*;

public class LuafromjavaActivity extends Activity {

/** Called when the activity is first created. */

@Override

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.main);

//--init CLE

StarCoreFactoryPath.InitDefault(Runtime.getRuntime(),"/data/data/com.cle.luafromjava");

StarCoreFactory starcore= StarCoreFactory.GetFactory();

StarServiceClass Service=starcore._InitSimple("test","123",0,0);

Service._CheckPassword(false);

AssetManager assetManager = getAssets();

try{

String luabuf;

InputStream dataSource = assetManager.open("code.lua");

int size=dataSource.available();

byte[] buffer=new byte[size];

dataSource.read(buffer);

dataSource.close();

luabuf=new String(buffer);

Service._RunScript("lua",luabuf,"cmd","");

}

catch(IOException e ){

}

StarObjectClass a = Service._GetObject("TestClass")._New()._Assign(new StarObjectClass(){

public int JavaAdd(StarObjectClass self,int x,int y){

System.out.println("Call java function...");

return x+y;

}

});

a._Set("JavaValue",100);

System.out.println(a._Get("LuaValue"));

System.out.println(a._Call("LuaAdd",12,34));

a._Call("LuaPrint",56,78);

}

Method2 source code ( install cle from http://code.google.com/p/cle-for-android independently):

1. Install CLE from http://code.google.com/p/cle-for-android/downloads/list

2. Download devfiles from http://code.google.com/p/cle-for-android, and then Open Eclipse

3. Create project for android.

4. Add starcore_android_r3.jar to project

5. Lua codes

same as method 1

6. Java codes

delete the following code line. others are same as method1

StarCoreFactoryPath.InitDefault(Runtime.getRuntime(),"/data/data/com.cle.luafromjava");

examples can be downloaded from http://www.srplab.com/android/calling_lua_from_java.rar

Calling python from java for android using CLE and SL4A

srplab — Mon, 27 Feb 2012 23:45:00 +0800

Java is major language to develop applications on android platform. But, in some case, programmers want to call python code from java to perform some functions. By now, there is no direct method to write program with python.

SL4A is an open project, which supports script languages including python, lua, etc. But calling python from java has not been supported directly. Programmers have to use JNI method, and native code to write interface for python. This is more difficult, you have to manage relationship between java objects and python objects, kinds of references, interface parameters conversion, and callback functions from python to java.

CLE(Common Language Extension) is a middleware which presents functions to aid multi-language calls between scripts, including java and python. Using CLE, the above problems can be solved easily. Architecture of CLE is as follow:

Java calls python functions:

python function:

Obj=Service._New("TestClass");

def Obj_PythonAdd(self,x,y) :

return x+y;

Obj.PythonAdd = Obj_PythonAdd;

java code:

StarObjectClass a = Service._GetObject("TestClass")._New();

a._Call("PythonAdd",12,34));

Callback of python to java:

java call back function:

StarObjectClass a = Service._GetObject("TestClass")._New()._Assign(new StarObjectClass(){

public int JavaAdd(StarObjectClass self,int x,int y){

return x+y;

}

});

python code:

Obj.JavaAdd(x,y)

Java gets object’s attributes defined in python

Python: Obj.PythonValue = 200;

Java: a._Get("PythonValue")

Python gets object’s attributes defined in java

Java : a._Set("JavaValue",100);

Python: self.JavaValue

Method1 source code ( intergrate CLE with your project):

1. Install SL4A from http://code.google.com/p/android-scripting/downloads/list

2. Download devfiles from http://code.google.com/p/cle-for-android, and then Open Eclipse

3. Create project for android.

4. Add CLE libraries to project as follows:

5. Python codes

SrvGroup = libstarpy._GetSrvGroup()

Service = SrvGroup._GetService("","")

#Create objects

Obj=Service._New("TestClass");

#Define functions

def Obj_PythonAdd(self,x,y) :

print("Call python function...");

return x+y;

Obj.PythonAdd = Obj_PythonAdd;

#Call java functions

def Obj_PythonPrint(self,x,y) :

print( "Value defined in java is ",self.JavaValue );

print( "Function result from java ",self.JavaAdd(x,y) );

Obj.PythonPrint = Obj_PythonPrint;

#define Attributes

Obj.PythonValue = 200;

6. Java Codes:

package com.cle.pythonfromjava;

import android.app.Activity;

import android.os.Bundle;

import android.content.res.AssetManager;

import java.io.IOException;

import java.io.InputStream;

import com.srplab.www.starcore.*;

public class PytonfromjavaActivity extends Activity {

/** Called when the activity is first created. */

@Override

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.main);

//--init CLE

StarCoreFactoryPath.InitDefault(Runtime.getRuntime(),"/data/data/com.cle.pythonfromjava");

StarCoreFactory starcore= StarCoreFactory.GetFactory();

StarServiceClass Service=starcore._InitSimple("test","123",0,0);

Service._CheckPassword(false);

AssetManager assetManager = getAssets();

try{

String pythonbuf;

InputStream dataSource = assetManager.open("code.py");

int size=dataSource.available();

byte[] buffer=new byte[size];

dataSource.read(buffer);

dataSource.close();

pythonbuf=new String(buffer);

Service._RunScript("python",pythonbuf,"cmd","");

}

catch(IOException e ){

}

StarObjectClass a = Service._GetObject("TestClass")._New()._Assign(new StarObjectClass(){

public int JavaAdd(StarObjectClass self,int x,int y){

System.out.println("Call java function...");

return x+y;

}

});

a._Set("JavaValue",100);

System.out.println(a._Get("PythonValue"));

System.out.println(a._Call("PythonAdd",12,34));

a._Call("PythonPrint",56,78);

}

Method2 source code ( install cle from http://code.google.com/p/cle-for-android independently):

1. Install SL4A from http://code.google.com/p/android-scripting/downloads/list

2. Install CLE from http://code.google.com/p/cle-for-android/downloads/list

3. Download devfiles from http://code.google.com/p/cle-for-android, and then Open Eclipse

4. Create project for android.

5. Python codes

same as method 1

6. Java codes

delete the following code line. others are same as method1

StarCoreFactoryPath.InitDefault(Runtime.getRuntime(),"/data/data/com.cle.pythonfromjava");

Examples may be downloaded from http://www.srplab.com/android/calling_python_from_java.rar

Wrapping Irrlicht For Android

srplab — Sun, 19 Feb 2012 19:37:00 +0800

Irrlicht is well-known open source 3D engine, which supports multiple platforms. It has been ported to android by Laurent Mallet, source code can be obtained from https://gitorious.org/irrlichtandroid/. The code is written in c++ language, but android mainly supports the java language. Using native c++ on android to develop applications is more difficult, and not convenient, especially to debug. For developer to use irrlicht easily, it is best to provide java interfaces.

The work here is wrapping irrlicht engine to enable it to provide the java interface. Traditional method for java calling native code is using the jni mechanism. But irrlicht engine is big and has many render objects. Using jni directly to wrap irrlicht will be a hard work. We have to define classes in java, create c++ code skeleton, maintain global reference of java object to irrlicht render object, process callback, etc. In order to simplify programming, CLE is used as middleware to help java to call native code.

CLE(common language extension) is developed by srplab( http://www.srplab.com ), which presents a general method for mixed language calls. It supports distributed object technique, which objects as medium to implement the mixed call between languages. Programming with cle, you need not care about details of special script languages, and the wrapping supports many languages such as java, lua, python, etc.

Wrapping irrlicht with cle, the first step is to create interface description using xml language, as follows:

……

……

……

The above xml description can also be created using tools srpdebug, which can be downloaded from srplab web site. After finishing the description, uses srpdebug tool or star2c command line tool to create c/c++ code skeleton.

Each object will be associated with one or more irrlicht objects. For above “IrrDeviceClass”, when is activated, an irrlicht device object will be created, as follows :

SRPIrrlichtES2EngineBasicModule_IrrDeviceClass.cpp:

….

case VSEVENT_SYSTEMEVENT_ONACTIVATE:

//TriggerForLoadFlag = LocalEventParaPtr -> RequestParam -> LParam;

{

IrrlichtDeviceClassLocalBuf = (struct StructOfIrrlichtDeviceClassLocalBuf *)pSRP -> GetPrivateBuf( IrrDeviceClassPtr, IrrlichtDeviceClass_ClassLayer,IRRLICHTDEVICECLASS_LOCALVARINDEX, NULL );

if( IrrlichtDeviceClassLocalBuf -> SRPEventReceiver == NULL )

IrrlichtDeviceClassLocalBuf -> SRPEventReceiver = new class ClassOfSRPEventReceiver();

if( IrrlichtDeviceClassLocalBuf ->IrrlichtDevice == NULL ){

irr::SIrrlichtCreationParameters param;

param.DriverType = video::EDT_OGLES2;

param.WindowId = (void *)IrrDeviceClassPtr ->RenderWnd;

param.WindowSize = core::dimension2d(IrrDeviceClassPtr->Width, IrrDeviceClassPtr->Height);

param.Bits = 16;

param.Fullscreen = false;

param.Stencilbuffer = false;

param.Vsync = false;

param.AntiAlias = false;

param.HighPrecisionFPU = false;

param.EventReceiver = IrrlichtDeviceClassLocalBuf -> SRPEventReceiver;

IrrlichtDeviceClassLocalBuf ->IrrlichtDevice = irr::createDeviceEx(param);

#if( VS_OS_TYPE == VS_OS_WINDOWS)

_control87( _MCW_EM,0x801f );

#endif

}

pSRP ->GetID(IrrDeviceClassPtr,&g_DeviceObjectID);

break;

Finish the c++ code, create project to generate SRPIrrlichtES2EngineBasicModule.dll for windows, or libSRPIrrlichtES2EngineBasicModule_android.so for android.

For java to call above library, code is as follow:

starcore= StarCoreFactory.GetFactory();

Service=starcore._InitSimple("test","123",0,0,"SRPIrrlichtES2Engine.xml");

SrvGroup = (StarSrvGroupClass)Service._Get("_ServiceGroup");

Device=Service._GetObject("IrrDeviceClass")._New();

Device._Set("Width",800);

Device._Set("Height",480);

Device._Set("Color",0x7F7F7F7F);

Device._Active();

When Device._Active() is called, the c++ event VSEVENT_SYSTEMEVENT_ONACTIVATE will be generated, then, the corresponding irrlicht device is created.

An example Helloworld:

The wrapping work is in progress, you can download full source code from http://code.google.com/p/wrapirrlicht-for-android

A simple opengl example of android using cle

srplab — Mon, 21 Nov 2011 21:49:00 +0800

Using common language extension(cle) as interface middleware, you need not care about JNI. The programming may be simple. This example is copied from ndk example hello-gl2 with small change to use cle.

c code is as follows:

++ #include "vsopenapi.h"

…

-- bool setupGraphics(int w, int h) {

++ bool setupGraphics(void *object,int w, int h) {

…

}

-- void renderFrame() {

++ void renderFrame(void *object) {

…

}

-- extern "C" {

-- JNIEXPORT void JNICALL Java_com_android_gl2jni_GL2JNILib_init(JNIEnv * env, jobject obj, jint width, jint height);

-- JNIEXPORT void JNICALL Java_com_android_gl2jni_GL2JNILib_step(JNIEnv * env, jobject obj);

--};

-- JNIEXPORT void JNICALL Java_com_android_gl2jni_GL2JNILib_init(JNIEnv * env, jobject obj, jint width, jint height)

-- {

-- setupGraphics(width, height);

-- }

-- JNIEXPORT void JNICALL Java_com_android_gl2jni_GL2JNILib_step(JNIEnv * env, jobject obj)

-- {

-- renderFrame();

-- }

++ VS_BOOL StarCoreService_Init(class ClassOfStarCore *starcore)

++ {

++ void *AtomicClass,*step_AtomicFunction,*init_AtomicFunction;

++ class ClassOfBasicSRPInterface *BasicSRPInterface;

++ class ClassOfSRPInterface *SRPInterface;

++ //--init star core

++ BasicSRPInterface = starcore ->GetBasicInterface();

++ SRPInterface = BasicSRPInterface ->GetSRPInterface(BasicSRPInterface->QueryActiveService(NULL),"","");

++ //---Create Atomic Class, for define function, no attribute

++ AtomicClass = SRPInterface ->CreateAtomicObjectSimple("TestItem","GLTestClass",NULL,NULL,NULL);

++ step_AtomicFunction = SRPInterface ->CreateAtomicFunctionSimple(AtomicClass,"step","void step();",NULL,NULL,VS_FALSE,VS_FALSE);

++ init_AtomicFunction = SRPInterface ->CreateAtomicFunctionSimple(AtomicClass,"init","VS_BOOL init(VS_INT32 width,VS_INT32 height);",NULL,NULL,VS_FALSE,VS_FALSE);

++ //---Set Function Address

++ SRPInterface -> SetAtomicFunction(init_AtomicFunction,(void *)setupGraphics);

++ SRPInterface -> SetAtomicFunction(step_AtomicFunction,(void *)renderFrame);

++ SRPInterface -> Release();

++ return VS_TRUE;

++ }

++ void StarCoreService_Term(class ClassOfStarCore *starcore)

++ {

++ return;

++ }

Android.mk：

LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)

# Here we give our module name and sourcefile(s)

LOCAL_CFLAGS += -Wno-write-strings -DENV_ANDROID

LOCAL_CPPFLAGS += -Wno-write-strings -fexceptions -DENV_ANDROID

LOCAL_LDFLAGS += -Wno-write-strings -DENV_ANDROID

LOCAL_C_INCLUDES += ../../../../../android/workspace/include

#--------source file

MODULE_CXXSRCS := gl_code.cpp

LOCAL_SRC_FILES := ${MODULE_CXXSRCS}

LOCAL_LDLIBS := ../../../../../android/workspace/libs/armeabi/libstarlib.a -llog -lGLESv2

LOCAL_MODULE := gltest

include $(BUILD_SHARED_LIBRARY)

java code:

…

++ import com.srplab.www.starcore.*;

…

class GL2JNIView extends GLSurfaceView {

…

++ StarCoreFactory starcore;

++ static StarObjectClass GlObject;

…

private void init(boolean translucent, int depth, int stencil) {

…

++ StarCoreFactory starcore= StarCoreFactory.GetFactory();

++ StarServiceClass Service=starcore._InitSimple("test","123",0,0,"");

++ Service._CheckPassword(false);

++ Service._DoFile("","/data/data/com.srplabgl.gltest/lib/libgltest.so","");

++ GlObject = Service._GetObject("GLTestClass")._New();

…

}

…

private static class Renderer implements GLSurfaceView.Renderer {

public void onDrawFrame(GL10 gl) {

++ GlObject._Call("step");

}

public void onSurfaceChanged(GL10 gl, int width, int height) {

++ GlObject._Call("init",width,height);

}

public void onSurfaceCreated(GL10 gl, EGLConfig config) {

// Do nothing.

}

}

example code can be downloaded from : http://www.srplab.com/android/gltest.rar

In more complicated case, using jni method will be much more difficult. Because programmer have to manager references, callbacks, parameter translations. cle provides powerful and flexible method for java call other languages such as c/c++.

The follow picture is a wrap library for android of anti-grain geomet, which will be released soon after.

please visited http://code.google.com/p/cle-for-android to get more information about cle.

Common Language Extension : For Android

srplab — Tue, 15 Nov 2011 22:00:00 +0800

For android version, CLE is complete free, and current version supports java in calling lua, c/c++, and python(need SL4A). CLE is very easy to use and greatly simplify the programming for java with different other languages. With the help of CLE, programmers can written c/c++ share modules without any knowledge about JNI, can call lua or python and provide callback functions of java to these languages easily.

CLE supports android version android 2.1/2.2/3.0/3.2/4.0. The install package includes a simple lua console.

* Main interface

* Lua console

Project Link: http://code.google.com/p/cle-for-android

Common Language Extension : Architecture

srplab — Tue, 15 Nov 2011 21:53:00 +0800

Common Language Extension(CLE) is a realization of common object environment. It manages interface objects and presents interface to c/c++, lua, java, python, php, c#, etc. Through these interface, special language can create, define, and control interface objects, define their functions and events, or call their functions.

Architecture of objects in CLE is as follows,

Objects are grouped into four kinds: service group object, service object, service item object, object, where service item object may be not existed if you do not develop distributed applications.

Applications based on CLE, mainly is create and init the above four kinds of object. Specific functions or events are provided by object.

The following code is a simple example for java calling lua.

String LuaString;

LuaString = "SrvGroup = libstarcore._GetSrvGroup()\n";

LuaString = LuaString + "Service = SrvGroup:_GetService(\"\",\"\")\n";

LuaString = LuaString + "Obj=Service:_New(\"TestClass\");\n";

LuaString = LuaString + "function Obj:Add(x,y)\n";

LuaString = LuaString + " return x+y;\n";

LuaString = LuaString + "end\n";

Service._CheckPassword(false);

SrvGroup._RunScript("lua",LuaString,"");

StarObjectClass Obj = Service._GetObject("TestClass")._New();

System.out.println(Obj._Call("Add",234,567));

In above example, Interface object “TestClass” is defined by lua, for java to call its function “Add”, a new instance of TestClass is created using java language.

Multi-Language Programming : Distributed Object

srplab — Sun, 30 Oct 2011 22:18:00 +0800

If common object enivronment is deployed on different computers, it will become a distributed object environment. For the environment holds all information and parameters of interface objects, it can act as a proxy for distributed functions of objects. As a result, applications access these distributed objects as if they are located at local, and programmers do not need face with kinds of standards or interface of different languages. For environment supports multi-language, you can developed service using java, c/c++,lua,python,etc, and call it from client side with other languages.

Above figure is a normal function call. If we distribute the environment on two computers, it will be a distributed environment, which is shown as follow:

The changes only occur on the environment. For applications, no matter they are client or server, may be not aware of these changes. For programmers, the environment helps them to solve many problems such as how to select standards and interfaces, or how to programming, especially in the case when client side needs to communicates with different servers of different languages.

We put objects together, describe them, manage them and provide an environment to them. More and more functions can be added to the environment, rather than special languages realizing these objects. Common interface, common architecture, and all of these will simply programming and freeing programmers from meaningless work.

Think about: you write a library in c/c++, then you have to rewrite it for java,python,etc at some time later. Is it meaningful?

Multi-Language Programming : Simplifying web service programming

srplab — Wed, 26 Oct 2011 19:27:00 +0800

Let’s go deeper into common object environment. The environment manages interface objects of multiple different languages and provides interface to these languages to define object’s attributes, functions and events. It holds all information and parameters about the objects. Therefore, it can act as a proxy to other applications outside to complete some functions or function calls.

Web service is a popular method of remote call, which uses SOAP as interface standard. Common object environment can implement SOAP interface, and thus become a proxy for web service. This will simply the development of web service. The applications, components or libraries developed based on the environment may not aware of web service call. There are no difference between web service calls and normal calls. Let’s use a diagram to further illustrate.

In above figure, a class object defined in java language has a function “Add”. For its c/c++ instance, application can call “Add” function through environment as previously talked about. The “Add” function of c/c++ instance can also be used as web service. In this case, the WSDL file can be generated automatically by environment proxy. Other application can get WSDL of the instance by http post request. Then, they can initiate web service call, and the proxy routing the call to the function of the class object. The class object does not know whether the call is web service call or normal function call. It only needs to implement the “Add” function body using java. Is it simple?

Common object environment holds all information of interface. Thus, it can act as a proxy and generate WSDL file to provide web service function to outside applications, which will simply the development of web services.

Multi-Language Programming : Common Object’s Event_6

srplab — Sun, 23 Oct 2011 09:57:00 +0800

Object may generate or handle events. This feature should continue to be supported in common object environment. Event is not an entity. It is a set of information. If the event information is described by special language, then it can not be triggered or handled by other languages. Therefore, environment should present a common model to describe events and provide a dispatcher to schedule these events.

In the environment, event may be identified by UUID or name. UUID uniquely corresponds to an event. Different languages can use interface of environment to find the event defined, and then trigger the event. Event may also have parameters or have response results from the handler. These parameters should be converted by environment when passed to different languages.

Common object environment should support to define object’s event and event handler. Object’s event may be handled by itself. For example, we click button, trigger a click event, then the button’s click function is called to process the event. Object’s event may also be handled by other objects. These objects can register handler function to capture events interested. These two kinds of event handling method should be supported.

Using UUID to identify an event enables events defined in one language to be found or triggered by other defined languages. For events, environment is responsible for parameter conversion between different languages, and dispatching event to objects which may be defined by different languages.

In above figure, Click event and its handler are defined for class object of java. If a c/c++ module needs to trigger the event, it finds the event first. Then it triggers “OnClick” event. Event dispatcher is responsible for routing the event to correct handler, which will call OnClick_Handler of java. The handler returns results. The dispatcher translates results to c/c++ language format, and then return the results to c/c++ module.

Summary: common object environment supports defining object attributes, functions, and events. It also supports function overloading, event dispatching, and parameters/arguments conversion between different languages. It is an object-oriented runtime environment.

Multi-Language Programming : More Complicated Function Call Between Languages_5

srplab — Wed, 19 Oct 2011 19:22:00 +0800

Components or libraries provide some functions. Other modules may access these functions through their interface. In some cases, the interface functions may be simple. The caller constructs input arguments, calls the function, and gets the return value. These type interfaces are easy to define and no more restrictions. But in other cases, interface functions may be more complicated. Let’s use an example to explain in detail.

Supposing there is a c/c++ component. It provides a function to draw and fill a circle into memory pixel buffer. If the component uses a simple interface, it should take parameters as input arguments, such as line type, color, width, fill color, fill pattern, fill bitmap, etc. We define an interface object contains this function in common object environment. The function may be called by other languages, for example java.

In this case, there are some disadvantages. First, interface function may have many input arguments, and for each call, these arguments should be input although their values do not change. Second, if a new parameter is added, all related functions must be changed. This will increase the burden of software maintenance.

In general, we often define two other objects: pen and brush objects. The draw function takes pen and brush object as input arguments. The pen object has attributes color, type and width, and brush object has attributes color, pattern, image, etc. We also define an interface object contains the draw function in common object environment. As result, there are three objects defined by c/c++ language in environment, which are pen, brush, and object containing the draw function. For other languages using the function, for example java, it should create instances of the three interface class objects. And the instances can be accessed by c/c++ and java language base on the support of the environment.

In this case, the function call is more complicated. The caller needs to create instances of objects defined in c/c++ languages. The instances can be accessed by the two languages. They are used as input arguments of draw function. Without the support of common object environment, it is difficult to realize in this way, especially to support the call from applications programmed with multiple different languages.

It is clear that the c/c++ service can be call by any other languages. Is it easy and concise? You can compare it with traditional method using JNI interface.

Multi-Language Programming : Accessing Interface Objects Defined In Other Language_4

srplab — Mon, 17 Oct 2011 21:51:00 +0800

Common object environment provides run-time support. Based on support of the environment, applications can access interface objects defined in other language. There are two methods, we introduce them one by one in detail

First method, application can find interface object defined in other language using the function of environment. And then, it can access object’s attributes or call object’s functions. Interface objects may be identified by its UUID or name. Object’s name should be used carefully because there may have multiple objects with the same name.

Second method, for environment supporting object-oriented programming, application can create an instance of entity class object of other language as talking about previously. The instance can be accessed by the two languages simultaneously. This method is more flexible. Application can create overloading functions of class object to support callback. For examples, if an object with function “Add” is defined in python language, application in java can create an instance of it and overloading the function “Add”. Then, python can callback to java through the “Add” function.

In above figure, python class object defines two functions “Add” and “Dec”. The “Add” function is overridden by java instance. The instance is managed by environment, and is visible to java and python. Python can call “Add” function of java instance to perform callback function. For “Dec” function, because instance does not override this function, the call will be redirected to class object of python.

Common Language Extension Programming, Starting here

srplab — Sun, 16 Oct 2011 11:26:00 +0800

Common Language Extension(CLE) is a realization of common object environment by srplab. Its idea, interface, problems, and how to use will be discussed in this category.
Please visit our site : http://www.srplab.com.
Thanks for supporting.

srplab's blog - Yahoo! Blog

Writing android gui using python(menu scroll view and popup window)

Introduction

Scroll View

Create scroll view object

Create root layout in the scroll view

Create a button, when is clicked, we create a new button in scroll view.

Menu

Override function “onCreateOptionsMenu”

Override function “onPrepareOptionsMenu”

Override function “onOptionsItemSelected”

Popup window

Create a button, when is clicked, we create a popup window.

In onClick event function, a popup window is created

Writing android gui using lua(introduction)

Introduction

Preparing environment

Begin programming

code.lua

get current service maintained by cle

get current activity, which is created by wrapandroid at init stage

create root layout

create title layout and gui elements

create webview layout and webview instance

Writing android gui using python(list view and custom view)

Introduction

List View

Create StringArrayAdapter and override its function getView

Create ListView and set its adapter

Custom View

Create a Paint and BitmapFactory for using in next step.

Create View and override its function onDraw

Writing android gui using python(gallery)

Introduction

Create adapter object

Create Gallery object

Writing android gui using python(basic gui elements)

Writing android gui using python(introduction)

Let android support multiple programming languages

Calling C/C++ from java android using CLE

Calling lua from java android using CLE

Calling python from java for android using CLE and SL4A

Wrapping Irrlicht For Android

A simple opengl example of android using cle

Common Language Extension : For Android

Common Language Extension : Architecture

Multi-Language Programming : Distributed Object

Multi-Language Programming : Simplifying web service programming

Multi-Language Programming : Common Object’s Event_6

Multi-Language Programming : More Complicated Function Call Between Languages_5

Multi-Language Programming : Accessing Interface Objects Defined In Other Language_4

Common Language Extension Programming, Starting here