I really haven’t had a lot of time to spend on new things, I’ve had a lot of personal distractions over the past 2-3 years that have really limited my time and interest in learning new things.

I have however spent a little time looking at HTML5 game engines.  Not that I would have time to actually write a game but I always like reading about and experimenting with graphics and HTML5 seems quite suited to that.  I only experimented with a few game engines, I looked at quite a few but the two that I found the easiest to use and understand were http://www.kiwijs.org/ and http://www.pixijs.com/.

I spent the most time using pixijs simply because there were enough tutorials and web resources to get a better understanding how the pieces tied together.  It’s one thing to write your own engine that you think other people can use, it’s another to actually show people how to use it rather than assume they want to spend hours pulling it apart and actually understanding how things fit together.

Eventually I would like to get back using pixijs and modify the pixelsystems.net logo a the top of this page to make it animated, perhaps some simple 2D effect from the good old Amiga demo/intro days.  I’m just surprised how far browsers have gone where you can write a legitimately good looking and fun game in a web based language instead of C++.

I finally released SudoTape to the market.  The last stretch was around testing and getting some of the final artwork done.

I initially listed it in the photography section of the market but this morning I revised it and put it in the tools section.  You don’t really need to have a camera on your device in order to use it so it makes more sense to put it in the tools section.  I don’t know if the market automatically filters stuff out so even if you don’t have a camera and the app doesn’t really need a camera I’m not sure if you’d see it as available to download or not.  Not that it matters though, I presume most devices come with at least one camera now anyway.

I had problems creating a signed APK, I never really read anything about it and Google’s information online is sketchy at best, at whatever documentation I found was related to Eclipse so it wasn’t much help since I use IntelliJ.  Luckily IntelliJ’s created signed APK wizard wasn’t too tricky so I uploaded the app and some art/screenshots last night.

Going to see if anyone downloads it to see how much I want to support it.  I’d like to add some other features like saving the files to DropBox, perhaps unit conversions on the define markers options dialog, etc.  If there is little interest I’ll hold off adding more features and think of a new project.

You can find SudoTape on the market here:  https://market.android.com/details?id=net.pixelsystems.sudotape

You can read SudoTape’s basic documentation here: http://pixelsystems.net/?page_id=66

I finally figured out how to use GitHub.  It didn’t work well at all with IntelliJ, mostly because the learning curve is pretty vertical regarding to setting up permissions and connecting github with your machine (pgp keys, etc).

You can read about my first github project here and all the trouble I had getting camera images from the camera functionality on your Android phone into my Android app.

My project is coming along nicely.  I learned the hard way that the Android emulator is quite different than an actual device so when I got my phone back running my project on it pointed out a number of issues that I hadn’t thought of because they weren’t exposed with the emulator.

Here are some issues I tackled with recently:

• If you have multiple <intent-filter sections in yourAndroidManifest.xml defining:

<action android:name=”android.intent.action.MAIN” />

<category android:name=”android.intent.category.LAUNCHER” />

then each of those sections will create icons for your application with no other identification saying which is which.. Can be a bit confusing on which icon to press to run what main mechanism

• If you are launching an custom intent/activity from preferences DO NOT specify data= in your preferences.xml unless you are set to handle it, otherwise you will get a “cannot find activity” exception.  This took me several hours to discover, a lot of head scratching and swearing because I got lazy and never deleted the data= part that I copied from Google’s example code.
• The bundle as the argument to onCreate() for your activity is actually very useful and tied to onSaveInstanceState(), this I supposed is common sense but no example I read actually showed them being used together so some digging exposed to me how to use it, very handy.
• PreferenceManager.getDefaultSharedPreferences() is super easy to use, beats property file loading/saving which I use at work a lot.
• My app is targeting Android 2.1 so I couldn’t use Camera.getNumberOfCameras().  I was using Camera.open() to find out if the device has a camera but not calling Camera.release() which caused some really strange exceptions later on in my code
• this information on screens proved very important to several UI problems I was having (multi-touch), should be fundamental reading for anyone learning Android programming.

I started writing code a long time ago, so I went through the days where you had to worry about how much memory you had available to you and how you could get your data into your application without causing out of memory issues.  With all the windowing environments and new object oriented languages it’s easy to forget “the good ole days”.

I was reminded this week when I was working on an app I’m writing for Android.  The software I want to write deals with images saved from the device’s camera (or hopefully other images on the device that the user may have imported,etc).  Android has a lot of great functionality around reading and importing bitmaps but I underestimated how well those bitmaps are kept in memory.  I was running out of memory when I wanted to save my manipulated bitmap based off it’s full original size.  I wasn’t sure how I was going to solve the problem until I found this post on the Google forums:

Yes, the images from the camera are 2048px by 1536px.  If you convert

to a bitmap, thats 2048 x 1536 x 2 = 6291456, or 6MB.  This is right

at the allotted space an Activity gets.  If you can live with smaller

images, I would suggest using a sampleSize of > 1 when decoding the

image.  This will result in a smaller image size, thus less memory

used.  I have used the following code in the past to keep my images

under a set byte count.  Alternatively, you could forget about

calculating the sample size and just set it to 2.  This would use

1.5MB instead of 6MB on a standard image.

6MB, that’s not that much, but for a mobile device, yeah I suppose I can see how that is overkill.  I was unaware that the ‘allotted space an Activity gets’ was around 6MB so that is why my app is running out of memory (basically I was trying to allocated 2 uncompressed images in memory.

The posting on Google gives a solution which I’ve tried.  I haven’t spent any time playing with the calculation but I plan on it as the default sizing loses a lot of the image detail.  I have some wiggle room in there because at any one time I’ll only be using 2 images so I can probably bump up the quality/sizing a bit.

I use Jetbrains IntelliJ Idea at work.  I have for quite a while now.  In the early days they didn’t really exist but since starting college and TurboC I’ve used an IDE.  Since I’m spending my free time learning Android development and I know that Jetbrains have an Android plugin for Idea I figured it would be natural to use IntelliJ.  Unfortunately the plugin for Android is pretty simplistic.  It’s not bad (the recent community beta for Idea is pretty flakey) but it leaves a lot to be desired as filling out the XML files for configuration can be a pain without examples.

I know Google recommends Eclipse so I downloaded it instead and while it’s integration with Android is awesome I find the IDE too cluttered, it does TOO many things.  I never though that I’d say it, but sometimes you can have too much functionality and the user can get confused.  Regularly at work I’ve got into arguments with product managers with my statement  “If the user doesn’t want to use the functionality they’ll just ignore it” but in the case of Eclipse you’re so surrounded by all these features that you can’t really escape it.

I don’t really like how projects are laid out either in Eclipse.  It seems like they try to hide the directory structure/layout of your build process with their “projects” mentality but likely it’s because I’m so used to having my code laid out a different way that it’s just foreign to me.

Either way, learning new stuff is fun but can be frustrating when you just learning to walk and you want to run.

So I finally got back into developing some Android code, I have some projects in mind but since I”m a lazy mofo I won’t talk about them until I feel like they’re turning out how I want.  Typically when I start a new project I think of splitting the key functionality of the application into pieces then start doing some reading and googling to see how to do those pieces.  Then it becomes a matter of taking those pieces and putting them together.

I did some reading on how to do multi-touch.  Pinch to zoom, drag, that sort of thing.  I downloaded the latest beta for JetBrain’s IntelliJ because I knew they had the Android framework included, and I had used their framework in an earlier version (8.x) and it worked fine with the emulator, albeit slow.

I found an interesting article online regarding how to do multi-touch and proceeded to copy/paste some of the code into my project.  After getting everything built properly I proceeded to run my app.  For some reason my app wasn’t showing up.  I know the emulator is slow but damn..  I started looking through IntelliJ’s logs to see if I was missing something and the log says .. my app is running.   WTF?!  Well it turns out that I had my phone plugged in and the Android SDK connector (ADB) automatically uploaded my app to the phone.  I turn the screen on and there it is.  Funny that I totally forgot that the phone was plugged in and that I had USB debugging turned on by default.  Even more exciting was that the process was instant, no more waiting 5 minutes for the emulator to start.  Fantastic stuff.

I found this interesting post on another Android developer’s website (Steven Osborn):

Android 2.2 isUserAMonkey() check

Per the documentation: Returns “true” if the user interface is currently being messed with by a monkey.

There is another gem in the Log class, they’ve added a new log level ‘wtf‘ which in this case means “What a Terrible Failure”

Great stuff, pretty easy to tell the Google developers are geeks like myself, I love shit like that in source code, makes writing stuff a lot more fun.

When working on my own applications at home I realize how much infrastructure code I take for granted from my full time job.  For example, my application at home needed to display a table of data.  Java tables by themselves are pretty ugly, they work but they look very boring, offer very little in ways of formatting and require you to reinvent the wheel in order to get some nice functionality behind them.

I figured “surely there must be some open source tools/code that I can use”.  Well I stumbled upon only ONE that actually seems pretty decent.  Objectplanet has a decent table but if you dig around you can see that you need to buy a commerical license to get full access to it.  And the price for that?  A cool $1000.  This is a reasonable price really considering the amount of work to write a full-fledged table kit on your own but MAN.  We have our own set of table tools in my full-time job that walks circles around Objectplanet’s offering that I never think about when working but in reality it alone would be worth thousands of dollars and it’s such a tiny piece of all the software we use/have developed.

The same goes for a wizard framework.  Again it was one of the first things I helped write when I moved over from MFC->Java back in 2002 in my full time job.  Looking around now there are very few examples/working prototype code that I imagine something I wrote as a requirement at work would likely be worth a lot of money out in the wild.

I’m not really sure why I thought about these things when I worked on native code type applications.  Perhaps because the controls in Java are so bare-bones that to get something really usable/pretty you have to put a lot of effort into it, whereas for win32/MFC type applications the base controls will do 80% of what you really get done and that last 20% is a luxury that most people won’t miss.

Doesn’t really make me want to go back to MFC though.  My skills on Windows development now are probably so far behind now I doubt I’d even remember where to begin.