Elucidsoft - Inside a Micro-ISV

Mono Android: Working with SQLite

Eric Malamisura — Sat, 31 Dec 2011 22:27:17 +0000

If you are using Mono for Android and need to use SQLite you are in luck since the platform fully supports this scenario. In fact you don’t even need to do anything special, and this post also applies if you are developing for Android in Java using Eclipse. What’s different however is Eclipse will let you copy files from your Android device, in Mono you are using Visual Studio which at this time does not have that capability.

The preferred method (but not the only one) of creating, and managing a SQLite DB in Android is to create a class and inherit from SQLiteOpenHelper, which is in the namespace ‘Android.Database.Sqlite’, you will also need to add the references to assemblies: ‘Mono.Android’, ‘Mono.Data.Sqlite’

Below is an example of where you inherit SQLiteOpenHelper and then override two methods: ‘OnCreate’ and ‘OnUpgrade’

public class Database : Android.Database.Sqlite.SQLiteOpenHelper, IDatabase
{
private const string DATABASE_NAME = "MyDatabase";
private const int DATABASE_VERSION = 1;

public Database(Android.Content.Context context)
: base(context, DATABASE_NAME, null, DATABASE_VERSION)
{
}

public override void OnCreate(SQLiteDatabase db)
{
db.ExecSQL(@"CREATE TABLE MyTable (id INT PRIMARY KEY, comments TEXT NOT NULL");
}

public override void OnUpgrade(SQLiteDatabase db, int oldVersion, int newVersion)
{
db.ExecSQL("DROP TABLE IF EXISTS MyTable");
OnCreate(db);
}
}

public class Database : Android.Database.Sqlite.SQLiteOpenHelper, IDatabase

{

private const string DATABASE_NAME = "MyDatabase";

private const int DATABASE_VERSION = 1;

public Database(Android.Content.Context context)

: base(context, DATABASE_NAME, null, DATABASE_VERSION)

{

}

public override void OnCreate(SQLiteDatabase db)

{

db.ExecSQL(@"CREATE TABLE MyTable (id INT PRIMARY KEY, comments TEXT NOT NULL");

}

public override void OnUpgrade(SQLiteDatabase db, int oldVersion, int newVersion)

{

db.ExecSQL("DROP TABLE IF EXISTS MyTable");

OnCreate(db);

}

It is important to note that OnCreate is ONLY called when the database is accessed for the very first time, subsequent calls are ignored. If the DB already exists, it is ignored, OnUpgrade is called only if the version number has been incremented, the database already exists and when the database is accessed for the first time per that instance. Also to note is that I am taking an extremely lazy approach to upgrade where I simply drop the tables and re-create them, obviously not ideal for real world scenario because you would lose all your data.

At the top of the file I am defining two constants, DATABASE_NAME and DATABASE_VERSION which I mentioned above briefly is used for upgrade scenarios. The name is the actual name the DB file will end up being names on the Android file system. In order to browse the file system you will need to have your Android device rooted or you will need to have a developer Android device that you obtained directly from Google.

These instructions pertain to (Windows users only, the commands will be similar however on OSX)

Open cmd
Type ‘adb shell’, if you get an error type ‘adb kill-server’ and try again.
Type ‘su’ (for super user access, your phone must be rooted or be dev phone)
Once you are in the shell, type ls (you will notice its a linux shell)
Type ‘cd data/data’, it will list out all of the directories
Type ‘ls data’, and find your applications directory
Type cd
Type cd ‘databases’
Type ‘ls’ to look at your databases
Note the name of your database matches your constant defined above (if everything worked…)
Type ‘pwd’ (print working directory)
Copy the path of this directory to Notepad or somewhere safe

To browse the database you can download SQLite Database Browser for free, and do the following.

In order to browse the database your must copy the db file from your Android device onto your computer, I created a batch file for this and I run it when I need to take a look at something.
Open ‘cmd’ prompts
Type ‘adb pull ’ for example ‘adb pull /data/data/com.elucidsoft.myapp/databases/MyDatabase D:\MyDatabase
Open up SQLite Database Browser
File -> Open -> D:\MyDatabase
Whenever you need to see the new version you need to File -> Close Database, and repeat step 3, otherwise it can not copy over an in-use database file

I hope this helps you when working with SQLite on Android, it definitely helps me!

Mono Android: Using Logcat Effectively

Eric Malamisura — Sun, 27 Nov 2011 21:13:53 +0000

In my previous post I showed how you can use adb and logcat to help debug your Mono Android application. Well I have further refined the ability to use logcat with filters to get rid of all the cruft, with the following command you will only see Mono Android related issues for your application:

cmd /c "C:\Program Files (x86)\Android\android-sdk\platform-tools\adb.exe" logcat setprop debug.mono.trace ActivityManager:* WindowManager:* AndroidRuntime:* MonoDroid:* dalvikvm:* mono *:E *:S

1	cmd /c "C:\Program Files (x86)\Android\android-sdk\platform-tools\adb.exe" logcat setprop debug.mono.trace ActivityManager:* WindowManager:* AndroidRuntime:* MonoDroid:* dalvikvm:* mono :E :S

Each filter is defined by :, so this filters logcat by “ActivityManager”, “WindowManager”, “AndroidRuntime”, “dalvikvm”, “mono” and the “E”, and “S” are types of log activity which are reversed because we don’t care what they come from since we already defined that filter, but instead we want ALL types for “E” and “S” of the filters we just defined.

Just drop it in a batch file on your desktop and launch it, keep it open the entire time you do your development. Occasionally you might lose your adb connection, if that happens just type adb logcat in the shell to restart it over again.

Update: Added MonoDroid:* to capture some missing log information…

Mono Android: Marquee Text View

Eric Malamisura — Fri, 11 Nov 2011 05:22:14 +0000

On mobile devices you have a limited set of real estate on the screen, often the text you need to display is to long to be shown. You have several options, you can wrap it and take up additional vertical space, you ellipse it and expand it in a dialog, or you can scroll it marquee style to display it. Android supports all of these options, the one I chose to use for certain situations is marquee because its unobtrusive and can easily display the data to the user with zero interaction on their part.

There are some issues with the control unfortunately, one of them being the default behavior is to not marquee the text unless the TextView has focus. The fix to this in Android is easy, inherit from TextView and override a couple of methods. In Mono Android it was not so clear, I fussed with this for a while before diving into reflection to actually figure out how to get this to work.

Here is the code to allow a Marquee TextView in Mono Android:

  public class MarqueeTextView : TextView
    {
        [Register(".ctor", "(Landroid/content/Context;)V", "")]
        public MarqueeTextView(Context context)
            : base(context) { }

        public MarqueeTextView(IntPtr doNotUse)
            : base(doNotUse) { }

        [Register(".ctor", "(Landroid/content/Context;Landroid/util/AttributeSet;)V", "")]
        public MarqueeTextView(Context context, IAttributeSet attrs)
            : base(context, attrs) { }

        [Register(".ctor", "(Landroid/content/Context;Landroid/util/AttributeSet;I)V", "")]
        public MarqueeTextView(Context context, IAttributeSet attrs, int defStyle)
            : base(context, attrs, defStyle) { }

        protected override void OnFocusChanged(bool gainFocus, FocusSearchDirection direction, Android.Graphics.Rect previouslyFocusedRect)
        {
            if (gainFocus)
                base.OnFocusChanged(gainFocus, direction, previouslyFocusedRect);
        }

        public override void OnWindowFocusChanged(bool hasWindowFocus)
        {
            if (hasWindowFocus)
                base.OnWindowFocusChanged(hasWindowFocus);
        }

        public override bool IsFocused
        {
            get
            {
                return true;
            }
        }
    }

public class MarqueeTextView : TextView

{

[Register(".ctor", "(Landroid/content/Context;)V", "")]

public MarqueeTextView(Context context)

: base(context) { }

public MarqueeTextView(IntPtr doNotUse)

: base(doNotUse) { }

[Register(".ctor", "(Landroid/content/Context;Landroid/util/AttributeSet;)V", "")]

public MarqueeTextView(Context context, IAttributeSet attrs)

: base(context, attrs) { }

[Register(".ctor", "(Landroid/content/Context;Landroid/util/AttributeSet;I)V", "")]

public MarqueeTextView(Context context, IAttributeSet attrs, int defStyle)

: base(context, attrs, defStyle) { }

protected override void OnFocusChanged(bool gainFocus, FocusSearchDirection direction, Android.Graphics.Rect previouslyFocusedRect)

{

if (gainFocus)

base.OnFocusChanged(gainFocus, direction, previouslyFocusedRect);

}

public override void OnWindowFocusChanged(bool hasWindowFocus)

{

if (hasWindowFocus)

base.OnWindowFocusChanged(hasWindowFocus);

}

public override bool IsFocused

{

get

{

return true;

}

Site Redesign Done…

Eric Malamisura — Wed, 07 Sep 2011 23:19:46 +0000

I have been working on the new site design for what seems ages now and its finally up! The changes are subtle but noticeable, there may be some caching issues with your browser if it looks all crazy. I tried to mitigate this with some htcaccess rules but due to the way I handled caching prior it may cause issues this time around, lesson learned. Just refresh your browser if something looks broken to get the new content.

As for the changes, I cleaned up the site quite a bit, everything aligns to the grid more evenly now. Cleaned the logo up, reduced number of fonts down to two or three depending on the page. Also cleaned up the blog theme to match the site, fixed some sizing issues, added gzip compression, and the backbone is powered by a custom php templating engine I slapped together.

Oh, and I also finally added the BlackOut product page!

InfiniteListView Mono Android

Eric Malamisura — Thu, 01 Sep 2011 01:49:44 +0000

Been working with Mono Android a lot lately and thought I would give a quick example at something that I think is very useful. I have created a quick example of how to create an InfiniteListView using Mono for Android and the .NET Framework.

It’s pretty simple, but at the same time kind of hard to get right. You can download the example here. It is commented in the sections that I think are relevant to describe exactly what to watch out for and how/why it is that way.

More Mono Android Debugging Tips

Eric Malamisura — Fri, 26 Aug 2011 21:10:39 +0000

Install the new Mono Android release 1.0.3, which substantially improves debugging performance and various other problems. You can read more about it, and download it from here.
If you followed the instructions of my previous post, I have gathered even more information on how to improve the logcat experience. Create a bat file on your desktop and add the following lines:

cmd /C “C:\Program Files (x86)\Android\android-sdk\platform-tools\adb.exe” adb shell setprop debug.mono.trace E:all

cmd /K “C:\Program Files (x86)\Android\android-sdk\platform-tools\adb.exe” logcat

The first command enables verbose logging for mono, note that I do not know if this will decrease performance but I can only imagine it will since it has to log more often and in more places. If you are testing performance in your app I suggest you do not keep this enabled. If you are testing memory usage, or you want the FULL details of every single stack trace, crash, etc than definitely keep this setting.

Now to launch logcat I simply double click the bat file, much easier….

Mono Android Debugging

Eric Malamisura — Sun, 14 Aug 2011 20:14:46 +0000

I thought I would share a series of tips what I have found to most useful while working with Mono Android. I will post them as I discover new ways, for now I am going to start with the most basic version of debugging on Android and its using LogCat. To get the most out of LogCat there are several tweaks I recommend, these instructions apply to Windows since I use Visual Studio as my development IDE.

First, have a multi-monitor development environment. I have three monitors, which is ideal since you can browse the web for help, documentation, etc. on minitor 1, do all your coding & work on monitor 2, and have your logging and other various diagnostic windows on window 3.

LogCat is a program located in the adb shell for Android, adb is a program located at Android-SDK\android-sdk\platform-tools directory. To execute LogCat,

Open a cmd prompt
Change directory to the adb applications in the Android-SDK folder
Type: adb logcat

For an optimal experience I suggest you tweak the cmd windows options, to do this click in the upper left hand window of the cmd window on the icon itself and choose properties. I set my cmd window properties as such and then set LogCat maximzed to the entire screen. LogCat is realtime, so you will see every event that is occuring on your Android device which is extremely helpful.

My cmd properties:

Occasionally LogCat may disconnect, or lost connection. Simply type adb logcat again in the cmd window to relaunch it. If you are experiencing issues where it can’t connect load Task Manager and kill adb.exe and try again.

Mono Android Linking (Xamarin)

Eric Malamisura — Sat, 13 Aug 2011 03:30:24 +0000

As mentioned on this blog post, setting Linking to Sdk and User Assemblies for Mono Android is a good idea. It not only reduces the overall footprint of your application, but it drastically increases performance as well. I noticed a pretty substantial difference in both when I turned it on. I also noticed my application crashed, it crashed because I have an assembly where I keep all of my serializable xml types. If you take a look at Xamarin help, you will see where there are several solutions to this, in fact the blog post I mentioned also discusses a couple.

For my situation, I have an assembly that only contains serializable classes. So the best course of action is to simply exclude this assembly entirely from Linking, you can do this easily by download MonoDevelop and installing the Android package. Then open up your solution, go to project options for your main project (start project), select “Mono for Android Build” and set “Extra arguments” to “-linkskip=

You can also do this much easier in Visual Studio by simply right clicking on your main project (start project), choose “Unload Project”, at which point it will appear grayed out, then right click it again and choose “Edit”. This will open it up in the text editor. Find the PropertyGroup with the Condition of ‘$(Configuration)|$(Platform)’ == ‘Debug|AnyCPU’ and at the bottom add the following line:

-linkskip=MyApp.Services.Metadata

You may want to repeat this for the ‘$(Configuration)|$(Platform)’ == ‘Release|AnyCPU’ block as well so the release build will also do the link skipping of this assembly.

Still Alive and Kicking!

Eric Malamisura — Wed, 22 Jun 2011 21:30:42 +0000

Its been a while since I have posted anything, just wanted to let you know that I am still alive and kicking. Working very hard on the next application and its coming along nicely. It is the largest application that Elucidsoft will have to offer up to this point and I am very excited about it. I hope to have it on the market by August and hopefully sooner. The first release of the application will be for Android, with Windows Phone to follow shortly after, to be followed up by iPhone and iPad versions. I plan to pull this cross platform deployment to all future applications we release!

So keep an eye out, I will post something as soon as its available.

Mobile Platforms and Vertical Markets

Eric Malamisura — Tue, 26 Apr 2011 01:48:02 +0000

Let’s face it, mobile application development is targeted to a very small vertical market. Each platform being its own unique and distinct vertical market with some very minor horizontal growth. If you focus on a single platform, you are not only limiting your applications growth to that market, but you are limiting your companies. So how do you expand horizontally, without incurring massive expense? Developing for multiple platforms is expensive, and time consuming. Each platform has its own language, its own development tools, and their own unique constraints. The three platforms that IMO are worth discussing and targeting are Android, iOS, and Windows Phone 7.

For instance on Android you have to handle several different types of handsets, each with a unique screen type and resolution. Each device may have some hardware components, while others may not, you may have a lot of memory on one and very little on the other, etc. Android is also developed using Java with a custom framework.

The iOS devices on the other hand are an entirely different spectrum and at first glance bare nearly no similarities. The iPhone has almost nearly the same specifications for all models, you know exactly what you are designing against. iOS development is done using Objective-C with a custom framework, and you MUST have an Apple computer to do any kind of iOS development.

Next is Windows Phone 7 (WP7), which has a strong similarity to the way Android is handled but with key differences. When Microsoft developed WP7 they setup a set of strict criteria that each WP7 handset must adhere to as a minimum specification. So while you may not know exactly what you are targeting, you do know the minimum spec and you can develop against that in the very least. WP7 development is done using the .NET Framework, with a custom framework for the phone.

So how do you target all three, without re-writing your code? There are two solutions that I have found, and one that IMO is far superior and preferred.

The first option is to use Appcelerator Titanium, its free and supports iPhone, iPad, and Android. I would imagine when WP7 releases IE9 with HTML 5 support they may also be able to support WP7, but this speculation on my part. The way Titanium works is you develop your app using JavaScript and a custom JavaScript Framework that they have developed. You then compile your JavaScript using a custom compiler they have designed, it will then output a native Objective-C application (iPhone, iPad) from your JavaScript, or a native Java application (Android). I have several problems with this, first you are developing everything in JavaScript.

It is very difficult to develop a rich application entirely in JavaScript, it is not very object oriented and just a pain. Also based on my experience, their framework has several bugs and if you write the app for iPhone and expect it to work on Android as they advertise it doesn’t always turn out that way and you may end up tweaking things.

The second option, and the preferred in my opinion is to use Mono. Mono is a project by Novell to develop an open source version of .NET that is nearly 100% compatible with Microsoft .NET. Mono has released MonoTouch which is for iPad, iPhone and iPod; and Mono Android which is for Android. The beauty of this is that you write a Windows Phone 7 app in native code, take that code and it will work with both MonoTouch and Mono Android with some exceptions.

The exception here is that you will need to build a separate UI for each platform, but the rest of your code such as the Data Layer, Business Layer, Domain Model, etc. can be reused. Another caveat is that they are not free, they cost quite a bit of money. But the reason I think this option is superior, especially if you are a .NET developer is that you get to work with the .NET Framework. It is object oriented, is very feature rich, and you can bring in already built frameworks in most cases to use in your project. It has things like OData, Serialization, WebServices, out of the box.

As you can see there is no perfect option, each one has its pros and cons. But if you plan to succeed, you must target multiple platforms, try to spread your application horizontally across multiple verticals. If you do this you can potentially increase your target audience from 2 million to 200 million.

You may be thinking some developers have made huge money and only targeted one platform, you may have read about them in the news in fact! But these successes are extremely rare, so rare that they are published in the news, otherwise it wouldn’t be newsworthy material. You have about the same odds of having that kind of success as winning the lottery, its far and few between. But by being smart, increasing your target audience, you can still do very well!