Guide: Android Emulator Speed-Up and Google Map V2:

Today I want to talk about the Android AVD – Android Virtual Device, or as
everyone call it the Emulator. I am developing for the Android Platform for about a
year now and only recently come to my ears that this emulator can be Accelerated on
Processors that support Virtual Acceleration. So I have looked at my Lenovo G580 specs,
and luckily the Core I3 sierras supports it.

I have became really interested to know is there really a big difference between
an accelerated machine and one that is not, because every single person who develops for
Android know how slow is the emulator. So I Goggled it and found the following page:
Intel® HAXM – Hardware Accelerated Execution Manager.

There is a great explanation there for what you should do in order to download
and install the HAXM. and how you can turn it on and off and I have to tell the
process of installing this is nothing compare to what you are getting back.
The AVD runs almost fluently like a real device. I was shocked that I didn’t discovered
this earlier. That would save me a lot of nerves while dealing with the painfully slow Android

So for every one that develops for Android and going nuts for waiting a couple of second
for every action you make on the emulator I am totally recommending to spend 15 minutes,
find out if you machine support Hardware Acceleration and install the manager in order
to the get rid of this annoying problem.

Last thing if you know that you machine support Hardware Acceleration and still when you
try to install it you get a message that is not support, most likely you need to enable it from
the Bios of you machine.

Now that we covered Hardware Acceleration I want to talk about Google Map V2 support
in AVD.

NOTE: A quick but a very important note, from a further check I made this will work only if you are using google-play-service lib revision #4 in your application (and workspace). If you have already updated google-play-services using the SDK Manager to the latest version (Currently: revision #6) you will receive an error telling you that you that the google-play-services used by your application is too old and needs to be updated:

Google Play services out of date. Requires 3025100 but found 2012110 .

in order to make this guide work you can remove the new google-play-service library from you workspace and download revision #4 from the following link. After downloading reference this project instead of the newer one and then try to implement this guide.

Anyone that tried to develop an application that uses Google’s great new API
for maps has encountered the following message instead of a map:

get google play services

Pressing the “Get Google Play Services” button won’t do you any good and most likely
will crash your application. After some time that I was searching for a solution I
have stumbled on few post on Stack Overflow where people managed to get Google Maps
running by installing the apk of Google Services that are relevant for Google Maps.
Did the same and it works, now I am able to develop my map application even
without an Android device always by my side.

So the steps to enable Google Maps API V2 in the emulator are as following:

1. You need to download 2 apk files: and

2. Open eclipse and the AVD Manager and create an AVD with the following configuration:


3. Start the AVD and wait for it to finish booting, next open you command prompt and install
both apk’s using the “adb install” command. for example:

C:\Users\<your user name>\Downloads\adb install

you should receive “SUCCESS” message at the end of the installation process (that may take some time).

4. When you finish installing both apk files, close the AVD and reopen it. Now you should see a
map in your application when you use the AVD instead of this annoying message.

That’s it for today, Enjoy.

February 11, 2013Emil Adjiev 45 Comments »
FILED UNDER :Guide , Guide - Android Development

Guide: Google Maps V2 for Android : Creating your Google Map Application:

If you already got your Google Maps Android API V2 key then you are ready to create
your map application. If you don’t head to my Guide: Google Maps V2 for Android :
Getting the API key
post to read how to get it.

So lets start:
1. Open Eclipse and create a new Android project.
The first thing that we will handle is the import of Google Map classes.
To get the Google Maps files we need to download the last version of
Google Play Services via the Android SDK Manager.

2. After you downloaded the Google Play Services, restart Eclipse and
in the Package Explorer Right-Click –> Import….
In the opened windows choose “Existing Android Code into Workspace” and click “Next”.
Click the “Browse…” Button and head to the location of your SDK folder.
in it find the following folder:


and press “OK”, check the V next to it in the window and press the “Finish” button.

3. Now you added Google Play Services to your work space, we have to create a reference
from our project to this library. Right-Click your project and choose “Properties” go
to the Android section, in the lower part press the “Add…” button and add a reference
to that library. Your result should be as in the screen shot bellow:

adding google play services library

Note: If you try to reference google-play-service library and you receive a red X next to this
reference, what you should do is to move the .jar file to a location where it’s path will be shorter
and then reference it again.

4. Another import we have to make in order to make our application work on
Operation system prior to API11 is to import the support library this can be done very easily
using Eclipse: Right-Click you project and choose “Android Tools” and then choose
“Add Support Library…”:


When you finish those import you should have the following libraries (Red) in the
Android Dependencies folder (Green) of your project:

5. We are now ready for some codding: First of all open the Android Manifest file:
add the following permissions:

<permission android:name="your.application.package.permission.MAPS_RECEIVE" android:protectionLevel="signature"/>
<uses-permission android:name="your.application.package.permission.MAPS_RECEIVE"/>
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
<uses-permission android:name=""/>
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />

Important: Replace your application package instead of the current “your.application.package” string.

As mentioned in the comments by @Keilaron it looks like since the Google Play Services
3.1.59 update the MAPS_RECEIVE permissions are completely unnecessary and as a result
they can be removed.

6. Next, Google Maps uses OpenGL so we have to add OpenGL support to our application
by adding this to the Manifest file:


7. Finally add your key to you application right before you close your “application” node
in the Manifest file:

android:value="Your Google Maps API V2 Key" />

8. Now create an Activity that extends from “FragmentActivity”:

import android.os.Bundle;

public class MapActivity extends FragmentActivity {

    protected void onCreate(Bundle savedInstanceState) {

9. Finally for map_layout, XML layout file that was set
as a content view of the map activity write the following:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android=""
    android:orientation="vertical" >

        android:layout_height="match_parent" />

10. UPDATE: The last update for Google Play Services library revision 13 introduced
a new meta-data tag that should be added as well to your Android Manifest file.
So go ahead and add this right next to your API key meta-data code:

android:value="@integer/google_play_services_version" />

And that’s it, run the application and you should see a full screen map:


Remember that if you want to run the application in the emulator you should install
Google Play Services first.

Enjoy and stay tuned.

Guide: Google Maps V2 for Android : Getting the API key

Since I have been working on an Android application that uses Google map
services I have decided to write a couple of posts on this topic.
The application will be posted here as well in the near future.

The first thing you have to know when implementing Google Maps for android is
that you have to produce your own Google Map Android API V2 key.
Now there is a reason that I’m marking this name, take a careful look that you turning on
the right Key in you API Console and that you have chosen the API for Android
and not the Google Maps API V2 or V3 for example.

So how do we get an API key, you ask? Well it’s a few steps task:
1. First of all we need to find our SHA1 key. For debugging
purposes we will use the debug.keystore file to get our SHA1 key. to do that
we will use a tool named ‘Keytool‘ that come with Java installation.
so open you command prompt, head to the following location:

C:\Program Files\Java\<your JDK or JRE instllation>\bin>

and run the next command:

keytool -list -v -keystore C:\Users\<your user name>\.android\debug.keystore -storepass android -keypass android

You will recive the following output:

SHA1 key pic
Copy the SHA1 key by right-clicking the command prompt choosing ‘Mark’, then
mark the all key and right-click again on the marked text to copy it.

2. Now that we have the SHA1 key we can head to the Google API’s Console,
sign-in with our Google account and create a new project by clicking the drop box
in the upper-left corner of the screen and choosing the ‘Create…’ option:

create in google api

Give a name to your project and create it.

3. Once you have done that head to the Services section and turn on the Google Map Android API V2:

api service

4. Now open the API Access section and press the Create new Android key… button.

In the window that opens you will have to enter you SHA1 key you got in the 1. section adding
to it your application package name after a semicolon as in the example:


After pressing the Create button you will recieve you own Google Maps API V2 key for Android.

My next post will explain how to use this key to create a Google map in your application.

Guide: c3p0 – JDBC3 Connection and Statement Pooling

After I uploaded my JavaEE course project to Openshift hosting service as you
could do using the Guide: Introduction to Openshift hosting Apache Tomcat, I thought
that my work with this project is done. But strangely for me I started to encounter
database connectivity issues. I done a little research and realized that the reason for
those problems is the default MySQL configuration for closing inactive connections to
the database. MySQL automatically closes any inactive connections to the database
after the default 8 hours. Unfortunately Hibernate ins’t aware of that and still thinks
that the connection is open when trying access the database to perform a query.
Of course Hibernate will fail to perform that task and we will be given the following exception:

[org.hibernate.exception.JDBCConnectionException: could not execute query] with root cause Can not read response from server. Expected to read 4 bytes, read 0 bytes before connection was unexpectedly lost.

To fix this issue as it’s done in production environments it is important to implement
some sort of connection pool mechanism that will always keep open shared connections
to the database for all application users. Here I’m going to show you how to implement the
c3p0 – JDBC3 Connection and Statement Pooling mechanism in your project with
Hibernate already implemented:

1. So clearly the first thing that needs to be done is to download the c3p0 project files.
Use the following link to download the latest version from Source-forge.

2. Extract the files from the zip archive and copy the c3p0-0.9.2-pre7.jar
and mchange-commons-java- to the lib folder of your project.

3. Edit your hibernate.cfg.xml and add the following infomation under the
<session-factory> hive:

<!-- important to specify c3p0 as your connection provider -->
<property name="connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property>

<!-- configuration for connection pool via c3p0 -->
<property name="c3p0.min_size">3</property>
<property name="c3p0.max_size">20</property>
<property name="c3p0.acquire_increment">1</property>
<property name="c3p0.max_statements">50</property>
<property name="c3p0.timeout">14400</property>
<property name="c3p0.idle_test_period">3600</property>

It is really important to specify the “connection.provider_class” property as:
org.hibernate.connection.C3P0ConnectionProvider or hibernate will continue using it’s
own default mechanism. Other properties may be customized to your liking.
Eventually your hibernate configuration file should look like this one:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        <!-- default hibernate connection settings -->
		<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
		<property name="connection.url">jdbc:mysql://localhost:3306/database</property>
		<property name="connection.username">user</property>
		<property name="connection.password">password</property>
		<!-- for MySQL users specify the following dialect -->
		<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
		<property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>
		<property name="show_sql">true</property>
		<property name="">update</property>
		<!-- inmportant to specify c3p0 as your connection provider -->
		<property name="connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property>
		<!-- configuration for connection pool via c3p0 -->
		<property name="c3p0.min_size">3</property>
		<property name="c3p0.max_size">20</property>
		<property name="c3p0.acquire_increment">1</property>
		<property name="c3p0.max_statements">50</property>
		<property name="c3p0.timeout">14400</property>
		<property name="c3p0.idle_test_period">3600</property>
		<!-- end of configuration -->
		<mapping class="com.eadesign.hibernate.CouponDetails"/>
		<mapping class="com.eadesign.hibernate.Company"/>
		<mapping class="com.eadesign.dto.User"/>
		<mapping class="com.eadesign.dto.Administrator"/>
		<mapping class="com.eadesign.hibernate.Feedback"/>	

And that’s it, now you have connection pool in your project.

more information can be found in the c3p0 manual.
As this Appendix C: Hibernate-specific notes:

Appendix C-Hibernate of c3p0

December 19, 2012Emil Adjiev 1 Comment »
FILED UNDER :Guide , Guide - Java Development

Guide: WordPress hosting on OpenShift

Actually in my opinion this is one of the simplest ways to get your WordPress blog/site
up and running in no time. in just few simple commands you have a Blog in the air that
you can customize and edit to you liking. I am counting that you already have created your
own OpenShift account and installed the rhc Client Tools. If not please head to my
Guide: Introduction to Openshift hosting Apache Tomcat post and follow the first two
paragraphs to open the account and install the tools. I would recommend to read all of it
as it holds great information regarding tools that will simplify your work with OpenShift.

Now you are ready to create our own WordPress application container on OpenShift.
Open your command prompt and head to the location were you want your git repository
for this project to be created and enter the following command:

rhc app create -a <name for your container> -t php-5.3

Name your application container as you wish. This name will be part of the URL for accessing your application.
So now we allocated resources to ourselves in Red Hut’s cloud with php 5.3 application
already installed. WordPress needs a database to store it’s data and can’t live without
it so we will add MySQL database to this configuration using the next command:

rhc cartridge add -a <name of your container> -c mysql-5.1

And finally I always add the phpMyAdmin application to make it easier on me to manage my
databases. To do that run the following command:

rhc cartridge add -a <name of your container> -c phpmyadmin-3.4

Save your database credentials produced at the end of this process.

Now we are ready to install WordPress. There are two ways you can do that:

1. The first and the easy way to get a WordPress installation is to pull it from a git repository.
Head to your application folder using the next command:

cd <name of your container>

Now set the remote git repository to pull it’s stream from it:

git remote add upstream -m master git://

Pull the stream/content:

git pull -s recursive -X theirs upstream master

And push it to your repository on the cloud:

git push

To access your WordPress application use the default credentials:

User name: admin
Password: OpenShiftAdmin

The problem is that the version of WordPress now hosted on this repository is 3.4 and there
is a new 3.5 WordPress installation available. You could upgrade your WordPress version
using it’s Dashboard interface, but now you will have 2 different versions of WordPress
on your local git repository (3.4) and the clouded one (3.5). I will explain how to fix this
problem in the update section.

2. Alternatively you could push you own WordPress installation to your cloud repository.
Head to and download the latest version of WordPress.
Copy the downloaded content to the php folder in your local repository and open the
command prompt. Head to your local git repository folder and enter the following command:

git add .

For letting git know of all the changes that were made to that folder, then:

git commit -m "added wordpress3.5"

Committing the changes to the local repository. And finally Pushing the changes to the cloud:

git push

And that’s it, now you can access your new WordPress application using the URL
you are provided on OpenShift and start customize it.

Updating your local repositry with the changes made by WordPress in the cloud:

When you will update you WordPress installation in the future or maybe you would want to
change the looks of your blog/site by adding a sleek Theme or maybe a Widget and you’ll do
that using the Dashboard interface, you would have to update your local repository with
those changes. In that case what you need to do is to take a snapshot of your machine on
OpenShift using the next command:

rhc snapshot save -a <name of your container>

this will download a <name of your container>.tar.gz to you local git repository
containing a snapshot of your files from the clouded repository. Extract the files to a folder
with the same name and head to:
<name of your container>\<your OpenShift ID>\app-root\repo\
Copy the content of this folder to your local git repository folder and commit the changes
using the following commands:

git add .
git commit -m "wordpress updated"
git push

That way the files on your local repository will be identical to those in the cloud.

December 15, 2012Emil Adjiev No Comments »
FILED UNDER :Guide , Guide – Web Development

Guide: Introduction to Openshift hosting Apache Tomcat

To present my Java EE course project in this blog I had to find another
Apache Tomcat hosting service since the one we got during education was
not responding anymore. That’s how my search for a free Apache Tomcat
hosting service started. I contacted with my hosting service where i host
this blog and I was quickly explained that this kind of service is not
supported there. Next i went to the web (Goggled) to search for such free
service just to find out that there are not that many of them at all.
And then I saw that Red Hat offering Apache Tomcat service and much more
with their OpenShift PaaS – Platform as a Service. They basically give you
a platform (clouded resources) to deploy your applications and this platform
supports Node.js, Ruby, Python, PHP, Perl, and Java technologies and much more.

So how is it done?
1. The first thing is to go to and create an account.
Once you have created an account you can publish 3 application for free.
During the creation of your account you will have to specify you Namespace
that latter on will be used for your application URL’s.

2. Install the OpenShift client tools. For that you need to install Git for Windows
and a Ruby and configure them. This is explained in the following link.
During the configurations of Git you will create an ssh key for connecting
to your repository on Red Hat.

3. Now that you installed the client tools you are ready to create your first
application container on OpenShift. Actually this can be done using their web
interface but it’s faster to do that with the command line. To create your
application container with Apache Tomcat already installed you need to run to
following commands in the command prompt:

rhc app create -a tomcat -t diy-0.1

this will create for you your DIY (do it yourself) application container on
Red Hat’s servers with the name “tomcat” and a local Git repository in your
current location at the command prompt with the same name. now all you need
to do is to edit your local repository and to push changed to the server
uisng git.

Enter your repository folder by entering:

cd tomcat

and then enter the following commands:

1.git remote add upstream -m master git://
2.git pull -s recursive -X theirs upstream master
3.git push

what we are doing here is configuring a remote upstream and we pull it’s content from it
to our local git repository. finally we push this changes to our own application container.
at the end of this process we will have a DIY application with Apache Tomcat 7 installed.

4. Now we need to connect to our application container to copy there our application files.
There are 3 way to do that: we can copy the files to our local git repository and push the
changes to the server, we can use an SSH terminal (like PUTTY) and edit the files using
commands from the command line or we can use an SSH based FTP tool (like WinSCP)
to manage files as you would do in a commander interface.

you can download PUTTY from here. You should download the zipped file for all PUTTY package.
you can download WinSCP from here.

putting your project into the webapps folder of your local application repository and pushing
it to the server will put your files in the following location:

/var/lib/openshift/<your openshift userID>/app-root/

and this is not the right webapps folder for the installed Apache Tomcat.
That is the reason I prefer to use the WinSCP application. So lets open WinSCP and
the first window you will receive is the WinSCP Login window:

enter the following information:

  1. Your full application container URL – you can get it from OpenShift.
  2. Your Username – again you can find it on your application page on OpenShift under the “GIT REPOSITORY” section.
  3. Your OpenShift password.
  4. You have to supply your ssh key, you can create it using puttygen.exe application that you can download from the PUTTY link. Open puttygen.exe:

  1. Click the “Load” button and go to your C:\Users\<your windows username>\.ssh folder. Chose the id_rsa file (without extension) and press Open. you will be notified that this is a security key.
  2. Click the “Save private key” button to save a new private key (.ppk) file.

5. Now you can supply your security key and connect via WinSCP to your machine on Openshift.
When you connected you will receive a commander window. The right pane connected to
your OpenShift repository at the following location:

/var/lib/openshift/<your openshift userID>/

Head to:

/var/lib/openshift/<your openshift userID>/app-root/

and copy your project files here.
Head to:

/var/lib/openshift/<your openshift userID>/app-root/

and copy your project resource files (your Jars necessary for the project).

6. Finally open command prompt again and run:

rhc app restart tomcat

to restart your container and let the changes take affect. now you can access you project
using the application URL you can get on OpenShift.

December 11, 2012Emil Adjiev 2 Comments »
FILED UNDER :Guide , Guide - Java Development

Java EE Course Project: Location based Coupons

In my Java EE course we had to make a combined server and client applications.
I have decided to created a web location based coupons application.
While for the server I have created an MVC based application that allowed me as
an administrator to add, remove and change the coupons. For that i used Servelts,
JSPs and Hibernate technologies, for the client application i developed a small web
based application that allowed the user to display a Google map with only the relevant
coupons to the user’s specified distance from his current location and this was
achieved using HTML 5, jQuery Mobile and Ajax. The information passed from the server
to the client by an XML file. The main goal of this project was to learn the server/client
programming so both the server and the client applications are fairly simple.

Client application screenshots:


you can enter the client application using the next link.

the server application is a very simple one as well and it’s practically consists only
from forms for inserting, removing and editing data in the databases. All coupons in the
application are fabricated and created only for the sake of practice.

December 9, 2012Emil Adjiev No Comments »

C++ Course Project: Painter Application

This was one of my first programming projects during my education.
We were required to build a Painter application using C++ while the
main goal was to learn and practice Object Oriented programming.
the application is fairly simple. It allows you to create your painting
and save it into a file, you can also use the Redo and Undo options.
Nevertheless this application served it’s purpose greatly at the time
and i have learned a lot from creating it.

here a screenshot of the application:

and you can donwload the executable from here.

December 3, 2012Emil Adjiev No Comments »

Java SE Course Project: Client Application for Google Calendar

In this project the main goal was to get to know Google’s API.
Then we had to create windows client application that allows
the user to connect to his Google Calendar account and to perform
actions like: adding, changing and removing appointments from the
calendar. Off-curse the application was created using Java, for
the user interface i used an Eclipse plugin called Jigloo.
The application interface is plain and simple as you can see:

You can download the application from here.

December 2, 2012Emil Adjiev No Comments »

Android Course Project: YAMBA

During my Android course i created a client application for a Twitter based service.
It’s was created with a great deal of help from Marakana classes. The name
of this application is: YAMBA, that stands for “Yet another micro bloging application”
I have added some more features and upgraded the application even further.
I learned a lot from creating this application and used all the main Android building
blocks as: Services, Threads, Content Providers, Activities, Intents. I have even created
a Widget for this application that will always show the last twitte in the service.

you can download the application here


you can use the application with the default credentials:
User: student
Password: password

Or you can head to and create your own user.

December 1, 2012Emil Adjiev No Comments »