Archive for the ‘ CG ’ Category

Installing the Android Scripting Environment on the Android Emulator

Update:  I have a newer post here describing how I got the SL4A installed on an actual phone.  More work than I expected…

Based on my previous post, the thought of being able to run Python on an Android Device via the Android Scripting Environment seems… enticing.  However, I personally do not own an Android Device, nor have plans to get one anytime soon (ah, love those AT&T contracts…).  But there is the Android Emulator which I can run on my PC, why not use that in the meantime?

What I expected to be easy turned into quite a quest.  But I got it working, and the steps are listed below.  Specifically, this is a walkthrough on installing the Android SDK, creating an ‘Android Virtual Device’, launching the Android Emulator, installing the appropriate scripting language data on it, and running that language on the emulator.  This was done on a WinXP system.  I should also point out that this was my first foray into anything Android related, so I am quite a bit of a noob at this point.  My knowledge does not stretch far beyond this tutorial :-)

Finally, while my goal was to get Python running, you can use these steps to (presumably) get other languages (Lua, Perl, jRuby, BeanShell, Rhino) installed as well.  My tutorial below will be based around Python and its associated dependencies, but you should be able to mentally replace that with the language of your choice.

#1: Install the Android SDK:

Based on this post, I got the SDK installed.  I’d recommend you follow it as well.  You can stop at their “Step6: Create a new Android Virtual Device”, since that’s what we’ll cover below.  Note that this install process was done with version Android v2.0, can’t vouch for earlier versions.

  • It ended up being installed here:  C:\android-sdk-windows
  • Not sure of the importance, but I read online that you need to add a Windows System Variable named ‘SDK_ROOT’ with the value of the tools dir in the SDK install location, which for me is ‘C:\android-sdk-windows\tools’

#2: Create an Android Virtual Device (AVD):

  • I first created a shortcut on my desktop to this bat file which I use to launch the ‘Android SDK and AVD Manager’:
    • C:\android-sdk-windows\tools\android.bat
  • Under ‘Virtual Devices’, I created a new AVD, named it ‘ASE_test’.  Specifics in the image:
  • createNewAVD
  • After creation, pick the AVD in the ‘List of existing Android Virtual Devices”, and “Start…”
  • This will launch the Android Emulator:
  • emulatorScreen
  • Getting closer…

#3: Install the Android Scripting Environment (ASE):

It’s important that the Android Emulator is open (& unlocked) and running while the below steps are performed.

I read a lot of documentation about making a disk image of a memory card that the AVD could load in place of a real one.  I spent two hours trying to get this to work… it just didn’t happen.  Then I learned that you can install the ASE via the ‘Android Debug Bridge’ (adb) in a shell, and everything got a lot easier…

  • Download the ASE, and appropriate scripting language data.  Find them at the ‘Android Scripting’ download page here:
  • These files specifically: (note: since the time of authoring this post, the below apk and zip files have been updated… be sure to grab the latest versions)
  • After downloaded, for convenience, copy them to your SDK\tools dir:
    • C:\android-sdk-windows\tools
  • Install the ASE:
    • Make sure the Android Emulator is up and running (& unlocked).
    • In an OS shell, change directory to the SDK\tools directory.
    • Execute these commands to install the ASE on the emulated Android Device (running in the background): 
      • C:\android-sdk-windows\tools>adb install ase_r14.apk
    • Then, use these commands to copy the Python data to the virual sdcard on the emulator: 
      • C:\android-sdk-windows\tools>adb push python_scripts_r0.zip  /sdcard
C:\android-sdk-windows\tools>adb push python_extras_r0.zip  /sdcard
C:\android-sdk-windows\tools>adb push python_r0.zip  /sdcard
    • That should do it!  Your shell should look something like this when complete: 
      • C:\android-sdk-windows\tools>adb install ase_r14.apk
570 KB/s (127785 bytes in 0.218s)  pkg: /data/local/tmp/ase_r14.apk
Success 

C:\android-sdk-windows\tools>adb push python_scripts_r0.zip  /sdcard
133 KB/s (4280 bytes in 0.031s)  

C:\android-sdk-windows\tools>adb push python_extras_r0.zip  /sdcard
502 KB/s (2460097 bytes in 4.781s)  

C:\android-sdk-windows\tools>adb push python_r0.zip  /sdcard
360 KB/s (1726792 bytes in 4.671s)

#4: Configure the ASE:

At this point, the ASE should be installed in the running Android Emulator, and the Python data (or whatever scripting language you’re using) copied to the virtual SD card.

  • Expand the Application Tab.  You should see the “ASE” icon.  This means a successfull .apk install!
  • aseInstalled
  • Select the ASE icon.  This will launch the Android Scripting Environment, and give you a screen saying “Start adding scripts and Interpreters by pressing the menu button”.  We need to install the Python interpreter, so, press “MENU”.
  • Along the bottom of the UI three buttons will pop up.  Press the middle one “Interpreters”.
  • This will clear the screen with only one option; “Shell”.  Press the “MENU” button again.
  • New buttons along the bottom, press “Add”
  • AH, a big list of stuff to install!  Scroll down to ‘Python 2.6.2’ and press it.
  • This will start an extraction process, and you should see it extract the various Python .zip files you had put on the virtual SD card earlier.
  • Now the UI has two options, “Shell” and “Python 2.6.2”.  Press Python…
  • This launches a Python shell.  Success!
  • pythonShell
  • Hitting the return button twice will take you to another menu that has all the default Python modules previously installed: notify_weather.py, saychat.py, etc.  Press ‘test.py’:
  • This will run that module, executing a variety of test suites on the emulated device.
  • Pressing menu can take you into a module edit mode as well:
  • testPy
  • That’s pretty cool… 😛

In Conclusion…

What to do now?  First step, will be to go over all this info on the ‘Android Scripting Groups Wiki’:  http://code.google.com/p/android-scripting/w/list

I have to say, interaction in the emulator itself  is really slow, with lots of lag.  I also had a weird issue where all the text I tried to type was being converted into Japanese.  I had to go into my emulator’s Settings -> Language Keyboard -> And uncheck the first two options under “Text settings”.  I don’t know what they are, since they’re in JAPANESE.  But that fixed it.

Thus, it begins.

Index of reference pages:

These are pages I pulled a lot of info from to figure all of this out:

2009
11/25
CATEGORY
CG
TAGS












48 comments

Android anyone?

android01While I’ve really been enjoying coding with Pygame and Python… one thing they don’t seem to be able to do is play well with mobile phones.  Specifically things like the iPhone and Android devices.  Everyone I show my BubblePaint Pygame program to has the same comment:  You should put that on the iPhone!  And I’d love to!  But I don’t see Python entering into the iPhone’s future anytime soon, and I have no real want to learn Objective-C or C++ for iPhone dev.  Plus, I really don’t want to have to buy a Mac just to release my iPhone apps :-S

Enter Android.  Can develop for it on the PC (plus!).  Uses Java as its programming language.  And now appears to support Python scripting!  So far so good! (well, other than the fact I signed a 2-year deal with AT&T so my wife could get an iPhone <wink> )

I’m a bit warmer to Java than other languages based on my familiarity with Processing.  But I still really don’t “know Java” (however I have to say that Processing was a gentle introduction).  So I went out this weekend and picked up these books:

Then I:

  • Installed Eclipse IDE, since the Android platform has some Eclipse-specific plugins to aid in it’s development.
  • Installed the Android SDK (thanks to this post)

And finally I:

  • Started reading the Java book.

I’m now on… day 3… of 21.  It’s going pretty fast since Java is not so unlike Python in many regards.  The only thing I find unfortunate is that the more I learn of Java… the more I miss Python.  Python’s dynamic typing is sooooo much more conducive to my brain than Java’s static typing, and the stripped down syntax of Python just makes me feel… cleaner, compared to all the brackets, semi-colons, variable casting and whatnot needed in Java.  Bah!  End rant.

We’ll see where this leads:  I really like the idea of making games on mobile devices, and Android seems like an accessible platform.  I just hope AT&T starts selling the devices soon (the emulator will only get me so far) and learning Java doesn’t  cause me to rant too much….

:-)

2009
11/24
CATEGORY
CG
TAGS






2 comments

Open for business

…thanks to today’s press release:  Sledgehammer Games is official.  But we still don’t have a web site 😛

I started work here a couple months ago after departing EA (after 7.5 years, wow!), and it’s been a great experience.  Making that change was one of the hardest things I’ve ever had to do: leaving great friends, years of tech, and job stability.  But onwards and upwards!

Here’s what Kotaku has to say on it <link>

2009
11/17
CATEGORY
CG
TAGS

Comments Off on Open for business

Mel command argument passing in Python

From over on my mel wiki…

Python has some shortcuts you can implement when passing arguments to mel commands (or other Python functions).
Take for example a sphere (named pSphere1) that you want to scale. Here is the basic mel to do so:

float $scaleVals[] = {1.0, 2.0, .5};
// optionA:
setAttr pSphere1.scale -type double3 $scaleVals[0] $scaleVals[1] $scaleVals[2];
// optionB also works:
setAttr pSphere1.scale $scaleVals[0] $scaleVals[1] $scaleVals[2];

Likewise in Python, you can do something very similar:

import maya.cmds as mc

scaleVals = [1, 2, .5]
# optionA:
mc.setAttr("pSphere1.scale", scaleVals[0], scaleVals[1], scaleVals[2], type="double3")
# optionB also works:
mc.setAttr("pSphere1.scale", scaleVals[0], scaleVals[1], scaleVals[2])

However, in Python you can pass all the args in as a list\tuple variable by prefixing the variable name with an asterisk ‘*’. The function (mel command) will unpack the variable as individual positional arguments. It’s important that the variable have the same number of items as the command expects argument values, or a Python RuntimeError exception will be raised:

# option C, much cleaner!:
mc.setAttr("pSphere1.scale", *scaleVals)

You can see more about how this argument system works over on my Python Wiki.

2009
11/06
CATEGORY
CG
TAGS



Comments Off on Mel command argument passing in Python

Just ran into HYPE

HYPE appears to be to ActionScript 3 as Procesing is to Java.  I like seeing these higher-level wrappers of the languages available to the user community:  I was really excited when I first started using Processing, it opened a lot of doors for me creatively.  Looking forward to seeing what the HYPE user-community produces.

2009
11/05
CATEGORY
CG
TAGS



Comments Off on Just ran into HYPE