Som's Tech World...

FFT based simple Spectrum Analyzer

2012-01-17T06:59:00.006+05:30

i am writing this blogpost to pay homage to my alma mater... i was not at my level best to understand all aspects of Electonics & Telecommunication, the Microprocessor, the Digital Communication, the Digital Signal processing as taught by my professors... however, after so many years while playing around with different software, i understand how valuable was their contribution to make me an engineer. i remember, how important was the lesson of digital communication, and digital signal processing taught by Dr. T.K.Sen... i remember how important was the lesson of Microprocessor taught by A.R.... i remember how important was the lectures of Maths during our engineering course... i remember how important were the concepts of Fourier Transformation, FFT, DFT, Laplace Transformation, Matrix algebra and Complex Algebra...Hats off to all those professors who in spite of all odds helped a small town boy see the outer world...

Here goes the apk of my FFT based simple Spectrum Analyzer for an Android device with a sampling frequency of 8 KHz and audio encoding as 16 bit PCM...

i was so excited when i finished the coding part (of course with the help of Google...) and saw its working on a real device...

here are the two screenshots i have taken from an Android device...

How to set up proxy for Android emulator behind a firewall...

2011-12-21T09:08:00.002+05:30

Here is how i had set up my emulator's network settings for browsing the internet on a Windows 7 machine. for linux the same principle applies...

Make the emulator pass through the firewall

if you are behind a proxy go to settings and set up your proxy for the emulator through the following steps-

Open the emulator and click on Menu

Click on Settings

Click on Wireless & Networks

Go to Mobile Networks

Go to Access Point Names and click on it

Click on Telkila Internet

In the Edit Access Point, input Proxy server and Port

Also provide the User Name and Password

Keep rest of the fields blank

Sometimes the DNS of the host PC is not recognized by the emulator... in that case use the following command in the command prompt...emulator -avd -dns -server 8.8.8.8 (8.8.8.8 is the Googles default DNS) and change the DNS server of your machine to 8.8.8.8. otherwise you may opt for the DNS your company is using in the emulator -avd -dns -server command...

Hope this discussion comes handy for the Android newbies...

An implementation of Finite State Machine in Android using Handler...

2011-11-21T19:12:00.004+05:30

As i was doing some research on different concepts in Android, i came out with this implementation of Finite State Machine using the Handler class... i would like to share it with you... the state diagram of the application will look as the following:

The main Activity class looks like the following:

package com.android.training.statepattern;

import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;

public class StatePatternActivity extends Activity implements View.OnClickListener{
private Button startStatePattern;
private MyHandler handler;
   /** Called when the activity is first created. */
   @Override
   public void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.main);

       startStatePattern = (Button)findViewById(R.id.button1);

       startStatePattern.setOnClickListener(this);
       handler = new MyHandler(this);
   }

   public void onClick(View v){
    if(v.equals(startStatePattern)){
    handler.sendEmptyMessage(1);
    }
   }
}

And the other class is as follows;

package com.android.training.statepattern;

import android.os.Handler;
import android.os.Message;
import android.widget.Toast;

public class MyHandler extends Handler {
private StatePatternActivity MainActivity;

MyHandler(StatePatternActivity a){
this.MainActivity = a;
}
//state transition logic is strongly coupled with the different states...
public void handleMessage(Message msg){
switch(msg.what){
case 1:
////do the processing
Toast.makeText(MainActivity.getApplicationContext(),"Inside State 1", 2000).show();
this.sendEmptyMessage(2);
break;
case 2:
///do the processing
Toast.makeText(MainActivity.getApplicationContext(),"Inside State 2", 2000).show();
this.sendEmptyMessage(3);
break; case 3:
///do the processing
Toast.makeText(MainActivity.getApplicationContext(),"Inside State 3", 2000).show();
this.sendEmptyMessage(4);
break;
case 4:
break;
default:
break;
}
}
}

Let me explain the code a bit... here the crux of the solution lies in the MyHandler class derived from Handler.. The main activity class HAS MyHandler..

We start the State machine by sending a message (integer 1) through the function SendEmptyMessage called on MyHandler object. As a result, the callback function called handleMessage of the Handler is called and we handle this state's functionality here... the next all starte transitions happen sequentially from this callback function...

Hope this throws some lights on a specific design concept in Android...

Robotium - automated unit test tool for Android...

2011-11-17T14:15:00.002+05:30

the following text explains how to use Robotium in Eclipse.. Robotium is an automated unit testing tool for Android...

for this we need to download the Robotium.jar file from here...
setting up the environment is easy...

put the above jar in the build path’s library section...

add the following lines of code in the manifest.xml file in the manifest section (i.e. outside the app section)...

(instrumentation android:name="android.test.InstrumentationTestRunner"
android:targetPackage="training.android.trainingunitconverter"
android:label="1" /)

the below snippet of code is to test the UnitConverter app...

create a file(say UnitConverterTest.java) and add the following piece of code...

package training.android.trainingunitconverter;


import java.util.ArrayList;
import android.test.ActivityInstrumentationTestCase2;
import android.test.suitebuilder.annotation.Smoke;
import android.widget.EditText;
import android.widget.Spinner;
import com.jayway.android.robotium.solo.Solo;

public class UnitConverterTest extends ActivityInstrumentationTestCase2{
 private Solo solo;
 public UnitConverterTest() {
  super("training.android.trainingunitconverter", UnitConverter.class);
 }
 public void setUp() throws Exception {
  solo = new Solo(getInstrumentation(), getActivity());
 }
 @Smoke
 public void testUnitDropDown() throws Exception {
  
  solo.assertCurrentActivity("Expected UnitConverter activity", "UnitConverter"); 
  solo.pressSpinnerItem(0, 1);
  solo.sleep(2000);
  EditText value = (EditText)solo.getView(R.id.EditTextValue);
  solo.enterText(value, "1");
  solo.pressSpinnerItem(1,0);
  solo.sleep(1000);
  solo.pressSpinnerItem(2,1);
  solo.sleep(1000);
  solo.clickOnButton(0);
  assertTrue(solo.searchText("1000.0"));
 }
 @Override
 public void tearDown() throws Exception {
  //Robotium will finish all the activities that have been opened
  solo.finishOpenedActivities();
 }
}

however, it seems that the solo.PressSpinnerItem() is not functioning properly on the emulator (either Android 2.2 or Android 1.6)... hopefully this issue will be fixed in the next release of Robotium...

to run it in the emulator, right click on the Project... go to Run As.. and press Android JUnit Test...

the screen shot for the above test condition is

as from the test case
@Smoke
public void testUnitDropDown() it is clear, that we are first asking the test framework to select the item having index 1 (that is Weight) from the first spinner. then we are asking the framework to put a value 1 in the edittext. we are then asking the test framework to select item with 0th index (that is Kg) from the second spinner and item with index 1 (that is gm) from the third spinner... and we are asking the framework to press Convert button... so the expected result will be 1000.0... and we search in the test case if it has the value 1000.0. then the test case will PASS …
similarly we can test different scenarios automatically by having more such functions as testUnitDropDown...

note: the source code of the UnitConverter App can be cloned from https://github.com/sommukhopadhyay/UnitConverter

Git & GitHub

2011-11-17T11:35:00.001+05:30

i think by now most of the people know about Git and Github. however, as i am still not very much hands-on vis-a-vis contributing in the open source community, i think this piece of information will be useful to others...

Git is an opensource version comtrol system developed by the same person who had created Linux. And using free version of Github, we can share our source code to the open source community.

For this one will just have to open an account at www.github.com, create his own repository. However, to push your source code to this github repository, one has to install Git in the local machine. The latest version of eclipse comes with EGit plugin, which is of great help to push the project from the eclipse workspace.

i think its a good step towards contributing in the open source community...

here are the step by step screenshots of how one can push his project into the GitHub directly from the eclipse workspace...

step1

step 2

step 3

step 4

step 5

step 6

step 7

step 8

Handling exception at construction in C++ using Boost's shared_ptr

2011-11-10T05:32:00.016+05:30

Its a very common problem in C++ that if a class's constructor throws an exception (say memory allocation exception) how we should handle it. Think about the following piece of code. Here class A's constructor has thrown an exception.. so the best way to handle such situation is to instantiate A inside a try block...if exception is thrown in the constructor of A, i will be destroyed by stack unwinding and the thrown exception will be caught... try-catch block in exception is very important as constructor cannot return anything to indicate to the caller that something wrong has happened...

#include (iostream)

#include (string)
#include (memory)

class MyException(string str){
private:

string msg;

public:

MyException(string str){

msg = str;

}

void printerrmsg(){

cout((msg.c_str()((endl;

}

}

class A{
private: int i;

//if exception is thrown in the constructor of A, i will de destroyed by stack unwinding
//and the thrown exception will be caught
A()
{
i = 10;
throw MyException(“Exception thrown in constructor of A()”);

}

};
void main(){
try{

A();

}
catch(MyException& e){

e.printerrmsg();

}

}

now there is another point... suppose we need to allocate some dynamic memory in the constructor... and while doing that the constructor throws a memory exception... so the stack based pointer which was referencing the heap based memory will be destroyed because of the stack unwinding... so we will have some memory which is referenced by no pointer and hence we cannot access that... so obviously its a memory leak... so, how can we handle that...

the best way to handle this kind of situation in modern C++ is to use auto_ptr/shared_ptr/shared_array ... so the solution will look something as the following:

#include (iostream)
#include (string)
#include (memory)
#include (boost/shared_ptr.hpp)
#include (boost/shared_array.hpp)

using namespace std;

class SomeClass{
public:
SomeClass(){}
~SomeClass(){};
};

typedef boost::shared_ptr(SomeClass) pSomeClass;
typedef boost::shared_ptr(char) pChar;
typedef boost::shard_array(char) charBuff;

class MyException{
public:
MyException(string str){
msg = str;
}
void printerrmsg(){
cout((msg.c_str()((endl;
}
private:
string msg;
};

class A{
private:
int i;
pChar m_ptrChar;
pSomeClass m_ptrSomeClass;
charBuff m_pcharBuff;

//if exception is thrown in the constructor of A, i will be destroyed by stack unwinding
//and the thrown exception will be caught
public:
A():m_ptrChar(new char),m_ptrSomeClass(new SomeClass),m_pcharBuff(new char[100])
{
i = 10;
throw MyException("Exception at A's constructor");
}
};

int main(){
try{
A objA;
}
catch(MyException& e){
e.printerrmsg();
}
return 1;
}

In Symbian C++, it is handled by a concept called two phase constructor... (it came into the picture because there was no template concept in earlier Symbian C++, and hence there was no auto_ptr)... in this process, if we want to create a dynamic memory allocation at the heap pointed by say *pMem, then in the first phase of construction we initialize the *pMem by NULL. obviously this cannot throw exception...then this pMem is pushed to a cleanupstack(this is something new in Symbian) so that we have a reference in the CleanupStack for future reference... and in the second phase of construction, we allocate memory pointed by pMem... so, if the constructor fails, we still have a reference of pMem in the cleanup stack... we just need to pop it and destroy it... hence there is no chance of memory leak...

hope this discussion comes handy for C++ learners...

How to launch an Android App from the Browser

2011-11-05T10:10:00.003+05:30

As i was doing some experimentation with android, i tried to launch a native app from a browser link... and i was successful... i would like to share whatever i have done with you..

The first thing one has to do to launch an app from a browser’s link is to add an additional intent filter in the app’s Manifest file... for example to launch my native app (called UnitConverter) i have added the following few lines in the App’s manifest...

                  <data android:scheme="unitconverter" />
                  <action android:name="android.intent.action.VIEW" />
                  <category android:name="android.intent.category.BROWSABLE" />
                  <category android:name="android.intent.category.DEFAULT" />

and in the web app i have added html code as (a href="unitconverter://")Launch UnitConverter App(/a)
and it has worked fine..
however, sometimes we may need to pass some query parameters in the html query tag like
(a href="unitconverter://?param1key=param1value&param2key=param2value)Launch UnitConverter App(/a)
to catch these query parameters inside the Android app, i have written the following piece of code and added it in the onCreate function of the main Activity just after the line super.onCreate(savedInstanceState).


//to get the parameter passed from the URI that has launched this app
     final Intent intent = getIntent();
     String scheme = intent.getScheme();
     if(scheme != null){
             final Uri myURI=intent.getData();
             String queryString = new String();
                
             if(myURI!=null)
             {
               queryString = myURI.getQuery();
             }
             String split1 = "&";
             String split2 = "=";
             
             if (queryString != null)
             {
                 final String[] arrParameters = queryString.split("&");
                 for (final String tempParameterString : arrParameters)
                 {
                     final String[] arrTempParameter = tempParameterString.split("=");
                     if (arrTempParameter.length( )== 2)
                     {
                         final String parameterKey = arrTempParameter[0];
                         final String parameterValue = arrTempParameter[1];
                         //do something with the parameters
                         Toast.makeText(this, parameterValue, 500).show();
                     }
                 }
             }    
     }

And voila!!! it has worked perfectly...
Hope this discussion comes handy for the Android learners...

Tackling the Circular Dependency in Java...

2011-10-31T19:45:00.010+05:30

Let me first define what we mean by circular dependency in OOAD terms vis-a-vis Java.

Suppose we have a class called A which has class B’s Object. (in UML terms A HAS B). at the same time we class B is also composed of Object of class A (in UML terms B HAS A). obviously this represents circular dependency because while creating the object of A, the compiler must know the size of B... on the other hand while creating object of B, the compiler must know the size of A. this is something like egg vs. chicken problem...

this may be possible in real life situation as well. for example suppose a multi storied building has a lift. so in the UML terms, the building HAS lift... but at the same time, suppose, while constructing the lift object, we need to give it the information about the building object to access various functionalities of the Building class... for example, suppose the speed of the lift is set depending on the number of floors of the Building... hence while constructing the Lift object it must access the functionalities of the Building object which will give the number of floors the building has got...hence in UML terms the lift HAS building... so this is a sure case of circular dependency...

in real java code it will look something as follows:

public class Building {
private Lift lift;
private int floor;
public Building(){
lift = new Lift();
setFloor(15);
}
public int getFloor(){
return floor;
}

public void setFloor(int floor){
this.floor = floor;
}
}//end of class building

//class Lift
public class Lift {
private Building building;
private int Speed;
public Lift(){
building = new Building();
setSpeed();
}

public void setSpeed(){
if (building.getFloor()>20){
//one set of functionalities
//may be the the speed of the lift will be more
this.Speed = 10;
}
else {
//different set of functionalities
//may be the speed of the lift will be less
this.Speed = 5;
}
}

public int getSpeed(){
return Speed;
}
}//end of class Lift

As it becomes clear from the above code, that while creating the Building object it will create the Lift object, and while creating the Lift object, it will try to create a Building object to access some of its functionalities... So, ultimately it will go out of memory and we get a StackOverflow runtime exception...

So how do we handle this problem in Java? We actually tackle this problem by declaring an IBuildingProxy interface and by deriving our Building class from that... the lift class, instead of Having Building object, it Has IBuildingProxy...

the source code of the solution looks like the following...

//IBuildingProxy
public interface IBuildingProxy {

int getFloor();
void setFloor(int floor);
}//IBuildingProxy

//class Building
public class Building implements IBuildingProxy{
private Lift lift;
private int floor;
public Building(){
lift = new Lift(this);
setFloor(15);
}
public int getFloor(){
return floor;
}

public void setFloor(int floor){
this.floor = floor;
}
}

//class Lift
public class Lift {
private IBuildingProxy building;
private int Speed;
public Lift(Building b){
this.building = b;
setSpeed();
}
public void setSpeed(){
if (building.getFloor()>20){
//one set of functionalities
//may be the the speed of the lift will be more
this.Speed = 10;
}
else {
//different set of functionalities
//may be the speed of the lift will be less
this.Speed = 5;
}
}

public int getSpeed(){
return Speed;
}
}

and the code of the main class is

public class CircularDependencyTest {
public static void main(String[] args){
Building b = new Building();
Lift l = new Lift(b);
}
}

So whats the principle behind such work around... It will be clear soon...

As it becomes clear from the code that Building HAS Lift... That is not a problem... Now when it comes to solve the part that Lift HAS Building, instead of the Building object, we have created an IBuildingProxy interface and we pass it to the Lift class... what it essentially means, that the building class knows the memory requirement to initialize the Lift object, and as the Lift class HAS just a proxy interface of the Building, it does not have to care for the Building's memory requirement... and that solves the problem...

Hope this discussion becomes helpful for Java learners...

My Android AsyncTask implementation vis-a-vis Command Pattern...

2011-10-05T13:23:00.082+05:30

As i was developing a sample Android App to showcase the Android AsyncTask, i found it very much similar to the Command design pattern. i would like to share this with you...

Let me first state about the Command design pattern. The purpose of the command pattern is to associate a command object with its receiver where the receiver knows what to do when this command is called... We have an interface called command, from where we deduce different concrete commend classes... The client creates the concrete command objects passing the information of the receiver for that command... And when the invoker ( which is generally a framework object) calls the execute method of the command, the concrete command actually executes it with the help of the Receiver’s functionalities...

The class diagram of the command pattern is as follows:

And the sequence diagram is as follows:

Now let me decipher my App to show how it implements the command pattern... the class diagram of this application looks like the following:

As it becomes clear from the code, the client (which is the Activity class) creates a concrete command class, the Callback interface through the concept of Anonymous inner class (see the code c = new CallBack() {.....}; it then stores this command in the invoker (the MyAsyncTask class) by passing the reference to the invoker (see the line of code aTask = new MyAsyncTask(c)).. . the invoker (the MyAsyncTask class here) stores a reference to this command object... then if something interesting happens, the invoker calls the functionality from the callback interface (the command)... the functionality of the callback interface have been implemented in the Client (the Activity class)...

hence i think that my implementation of the Asynctask is very similar to the Command design pattern implementation...

Hope this discussion helps the android learners...

Here is my AsyncTask implementation.. Here you can find the callback interface... And you can find the main Activity class here.

And here goes the apk of the sample app... You can clone the whole source from here...

Observer Pattern in MFC

2011-08-05T14:26:00.003+05:30

As I walk through the different design concepts of the Design Pattern book by GoF, I usually try to find from my past experience about any practical implementation of these patterns. This way I found out one practical implementation of the Observer Pattern in microsoft foundation class (MFC) library which I would like to share with you.

Before explaining the application of Observer Pattern in MFC, let me give you a brief introduction of this pattern. Observer pattern helps you in notifying and updating all the dependent objects, if one object changes state. This pattern has two main objects – Subject and Observer. Multiple number of observers can be attached to a particular Subject. All the observers are notified and in turn gotten updated if the Subject changes its state. This is also known as the publish-subscribe. The subject is the publisher of changes, and the Observers are the subscribers to those changes.

The class diagram will look like the following.

And the sequence diagram of this pattern is like this.

What these two diagrams essentially depict is that in the Observer Pattern, we have a Subject, which can attach one or more Observers through its Attach() function. Whenever it changes its state it Notifies all the attached Observers through its Notify function. The observers in turn synchronize their states with that of the Subject through the GetSubjectState function.

Now let me dissect the MFC's Document-View architecture and explain how the Observer Pattern has been implemented there. In MFC, the Document acts as the Subject and the views attached to it act as the observers. The Document (Subject) has to notify and update the views (observers) whenever it changes its state. This is done through the function UpdateAllViews () of the CDocument class.

Let me show you the actual code of the UpdateAllViews from doccore.cpp under the MFC folder.

void

CDocument :: UpdateAllViews(CView* pSender,

LPARAM lHint,

CObject* pHint)

{

ASSERT(pSender == NULL || !m_viewList.IsEmpty());

POSITION pos = GetFirstViewPosition();

while (pos != NULL)

{

CView* pView = GetNextView(pos);

ASSERT_VALID(pView);

if (pView != pSender)

pView->OnUpdate(pSender, lHint, pHint);

}

As you can see from the code that UpdateAllViews function actually traverses through all the views attached through it and call the view's OnUpdate function. Hence UpdateAllViews acts as the Notify function of the Observer pattern.

Let me show you the actual code of OnUpdate from viewcore.cpp. It goes like this:

void

CView :: OnUpdate(CView* pSender,

LPARAM

CObject*

{

ASSERT(pSender != this);

UNUSED(pSender);

Invalidate(TRUE);

}

As its is clear from the above code, that the OnUpdate function will actually invalidate the view area, which will force the views to redraw themselves synchronizing their states with the current state of the Document.

This is all about the notification from Document to View. But what about the Attach and Detach function of the Subject. We have similar functions in the Document class which are as follows:

void CDocument :: AddView(CView* pView)

{

ASSERT_VALID(pView);

ASSERT(pView->m_pDocument == NULL);

ASSERT(m_viewList.Find(pView, NULL) == NULL);

m_viewList.AddTail(pView);

ASSERT(pView->m_pDocument == NULL);

pView->m_pDocument = this;

OnChangedViewList();

}

void CDocument :: RemoveView(CView* pView)

{

ASSERT_VALID(pView);

ASSERT(pView->m_pDocument == this);

m_viewList.RemoveAt(m_viewList.Find(pView));

pView->m_pDocument = NULL;

OnChangedViewList();

}

As this is clear from the above listings that CDocument :: AddView is similar to the Attach function of the Subject, and RemoveView is like the Detach function as in the Observer Pattern.

Similar to the Observer Pattern, the Document has a list of its attached views through its m_viewList member and each view has a reference to its document through its m_pDocument member.

From the above discussion, it has become clear that the MFC's Document- View architecture is one of the applications of the Observer Pattern.

SMS Scheduler App for Android...

2011-07-11T05:40:00.002+05:30

I have developed a rudimentary SMS Scheduler App... Here is the link to download it... i will work on it to give finer touches... hope you enjoy it...

Here are the screenshots of the App

i would like to share something more with you guys about what i have learnt while doing this project... i had to run two android emulators on my Ubuntu machine for testing the SMS...i tried but it was giving error messages like data image is used by other... after i Googled it i could not find any satisfactory answer... so i pondered on this subject a little bit and thought if somehow i could create different data image for different emulator, the problem will go... similarly for the cache image...

so i tried the following two commands to run two different emulators on my Ubuntu machine...

$ emulator -avd Android2.2 -data ~/workspace/Android/dataimg1 -cache ~/workspace/Android/cacheimage1 -port 5554

$ emulator -avd Android2.2 -data ~/workspace/Android/dataimg2 -cache ~/workspace/Android/cacheimage2 -port 5556

So the above two commands are basically responsible for running two emulators on console 5554 and 5556 with different data and cache files namely dataimg1 and cacheimage1 for the first one and dataimg2 and cacheimage2 for the second one... and it was a success!!!

hope this discussion becomes useful for Android learners...

My good days with Ubuntu...

2011-07-08T21:34:00.001+05:30

i have now almost completely switched over from Windows to Ubuntu... when the google page first comes out in the chrome browser, or the test page prints Ubuntu, the feeling is of sheer joy... i am loving it... no fear of spyware, no fear of virus... no headache for installing spybot or spyware doctor... no worry about how to install malware bytes... hopefully my days with Ubuntu will pass by peacefully...

CS != Programming

2011-06-27T08:31:00.001+05:30

While teaching the Computer Science students in an engineering college, i had this strange feelings that CS != Programming... The theoretical aspects of computer science which the students usually learn in the engineering college will never help them become proficient programmers... many people would shun this point of view... some times back i interacted with one of my colleagues who insisted that programming is only small part of computer science world... however i feel that it is the most important part of the computer science... with the wake of Test Driven Development and other Agile processes, when the long quality process is loosing its significance, its only good efficient programming that remains the most significant factor of the software project development... i believe that one can get a CS degree without even having a computer... but one cannot develop and design software that runs without getting his hands dirty with debugger, breakpoint, issues with memory leaks and so on...

Patent and Copyright - from my perspective

2011-06-08T19:32:00.019+05:30

today during our breakfast my wife asked me a question about the difference between patent and copyright... while answering her queries, i reminded her how the way we create patents of software these days has become an hindrance to innovation... if one is not convinced see this or this... think about the situation had all the basic scientific theories (e.g. newton’s law of motion and gravity, Archimedes's principles, Einstein's theory of relativity, the knowledge of periodic table and in-numerous chemical reactions or the basic ideas of zero and decimals) being patented and copyrighted, where would our scientific exploration have gone so far? from another angle had the Almighty patented air, water, earth, fire or so many of His living creatures on whom we do scientific experimentation, where would our mankind and civilization stand today?or even had we have to pay royalty to the community of cows for their milk or to the community of plants and vegetables for their own products, where would we go for the money?

Eye opener for educators...

2011-04-07T18:26:00.002+05:30

“Intellect has been cultured with the result that hundreds of sciences have been discovered,

and their effect has been that the few have made slaves of the many – that is all the good
that has been done. Artificial wants have been created; and every poor man, whether he
has money or not, desires to have those wants satisfied, and when he cannot, he struggles,
and dies in the struggle” - Swami Vivekananda.
Is the mad rush towards consumerism of the modern day a product of such faulty education system?

Unit Converter App with Source Code

2011-03-24T19:24:00.004+05:30

For the past few days i was in a dilemma about ethics, openness and honesty... the reason behind this was should i show the whole world the source code of my Android apps? as i don’t have a job, i thought of earning some money for my family by offering training to the people who want to learn how to develop Android apps... but then i thought that as i am using an open source platform to develop the Android App, i should show the source code to the others so that if someone really wants to learn, he can learn it from this source code... being a believer in Swamy Vivekananda, i thought not to do business just by selling knowledge...if i face difficulty in feeding my family in the future, there is definitely another way to earn money, but not by selling the knowledge which i got because of the Almighty.

So here goes the source code of an Unit Converter App which i started developing to help some of my students... if somebody can learn from it, i will be the happiest person...

Here is a screenshot of this app...

i have used Strategy Pattern to develop this App.

Hope this helps others.

Unfolding the mystery...

2011-03-10T04:34:00.001+05:30

There is an absolute ecstasy in unfolding the mystery...i know it from my own experience... when i first came to the IT industry, i used to wonder how things actually work inside... however, with experience and knowledge, these days i can decipher a fragment of code of a working system...today i know a little bit of why an OOAD system has been designed the way it is....and when this mystery gets unfolded, the joy is no less than that of a scientist’s discovery... probably this is the only reason i love software...

How to become a software developer without spending a penny...

2011-03-09T13:34:00.018+05:30

This post is for all those engineering students of computer science in remote places of India who cannot afford hefty amount to buy licensed software... i faced this dilemma when i first started my software career... i would like to share my experience with you...

the best way to learn software is to use Linux. i use Ubuntu. hence i can advise on this. anyone can order an Ubuntu CD from the https://shipit.ubuntu.com/ . if someone has a braodband connection he can download Ubuntu from http://www.ubuntu.com/desktop/get-ubuntu/download. however, installing Ubuntu is not the end... one will have to install the necessary package for C/C++ developement. These packages can be installed over the internet through the Synaptic Package Manager in Ubuntu desktop menu. The package for C/C++ is the build essential package... one may like to install the eclipse IDE from the software repository... the next thing is to install the OPEN-JDK package for working using Java... Once these things are done, the basic development environment for a student is done.

However, there are still some people who are simply familiar with Windows and do not have the money to buy Visual Studio...many poor students fall in the trap of pirated version of Visual Studio... but that is unethical... right....for those students i would suggest to go for Eclipse as the IDE... For a C/C++ compiler in a Windows machine one may go for Cygwin... this is how i have configured my Windows development environment...

however, its not only the development environment a student looks for... he needs a productivity tool... here again i would like to suggest the poor students not to fall in the trap of pirated MS-Office CD...if you want an offline productivity tool, go for free OpenOffice... and if you have a broadband connection, you may opt for Google Docs...

i think for a poor student in India, the tug of war between zeal to learn and ethics always plays havoc...i hope i have thrown some lights how to quench the thirst for knowledge without compromising on ethics...

Meaning of education to me...

2011-02-23T19:05:00.002+05:30

From the very beginning of my graduation day, i was in a dilemma about the meaning of education. Education, to me is an enabler, and all other means to educate people are facilitators. i was baffled by the very basic question what i will be able to do hands-on after i got a BE degree. i didn't want to become a theory-mugging Babu like so many engineering graduates in India. To me if a software engineer is not able to write good programs of a running application, there is no meaning of his education. it does not matter how much theory one churns out, the way to practice that theory should be the motto of education...

As Swami Vivekananda said, "We may talk and reason all our lives, but we shall not understand a word of truth, until we experience it ourselves. You cannot hope to make a man a surgeon by simply giving him a few books. You cannot satisfy my curiosity to see a country by showing me a map; I must have actual experience. Maps can only create curiosity in us to get more perfect knowledge. Beyond that they have no value whatever... "

i am damn sure if someone looks into the IT industry, he will find lot of middle level managers and senior managers who just can't decipher a simple programming concept... They can be termed as Babus in the IT industry.. if an automobile engineer has to call a mechanic every time his car falters, his engineering degree does not serve the basic purpose...

Here in India we give more importance to marks... A student scoring 90% might not be an effective engineer...i know there are a number of engineers who would not have become engineers had they been guaranteed jobs in other industries...i know there are few people who want others to remain in dark and make profit out of their ignorance... under any circumstances they cannot be termed as good human beings...

thats the only reason probably i have embraced open source technologies to work on my software passion... because it gives freedom... i think FOSS is more about freedom than about free of cost...however, there are some limitations in the open source technologies as well... the limitation is that one has to overcome a steep learning curve to contribute a little to the learning society... and there is no hand-holding for a new comer... so far i have just used some of the open source technologies like Ubuntu, eclipse, android... but i have not been able to contribute any thing in terms of bug fixing of an open source project... however, i try to contribute to the learning society, in whatever little form it may be, through my technical blog...

i know i am an insignificant guy to change the way education is being practiced here in India...i know its not easy to become Jonathon Livingstone Seagull... however, i want someone influential to think the way i have thought about education....

Freeware Android Paint with source code...

2010-12-27T08:53:00.020+05:30

Here is one of my freeware android apps called AndroidPaint. This can be downloaded from here. Before running this application one has to install the ColorPicker app which can be downloaded from here.

Using the Android Paint app, one can draw geometrical shapes and free hand drawing on an Android device. In the future version i will refine the app to give the user more drawing options and more regular shapes to draw.

To start with, one will have to choose from the menu options and then draw.

The screenshot of this application is as follows:

Here goes the source code of this application...

There are lots of scopes to re-factor this application... for example we can introduce a singleton factory class which will be responsible for creating different shapes... i thought of making the source code available to everyone after i did these kinds of refactoring... but i have lost the momentum... it will be really nice if someone works upon these...

Structure Alignment - my understanding...

2010-10-04T20:59:00.027+05:30

The data should be properly aligned for better efficiency. The CPU accesses the memory on WORD (4 byte) boundary...
Thats the reason we add padding bytes in a structure for proper alignment...

The the result of my research on structure alignment using a gcc compiler is given below... The alignments of the structures are implementation specific... Typically a char will be 1 byte aligned, a short will be 2 byte aligned, an int will be 4 byte aligned and a pointer will be 4 byte aligned... this means that a char can appear at any boundary, a short can appear at any even boundary, and an int can appear at a four byte boundary...

To test the alignment of a structure and the offset of one of its member, i wrote this code:

And the result of alignment was 4.

The result of offset of the integer was 4.

If we use gcc, the size of a long double will be 12 bytes whereas its alignment will be 4 for a IA32 machine.

For different structures, the alignment of its members have influenced the size of them as follows:

typedef struct XYZ

{

//total 12 bytes

/*char c;//1 byte + 3 padding bytes

int x;//4 bytes

short s;//2 bytes

char d;//1 byte + 1 padding byte

}MyStruct1;

typedef struct XYZ

{

//total 8 bytes

/*short s;//2 bytes

char c;//1 byte + 1 padding bytes

int x;//4 bytes*/

}MyStruct2;

typedef struct XYZ

{

//total 12 bytes

/*char a;//1 byte

char c;//1 byte

short s;//2 bytes

int x;//4 bytes

char d;//1 byte + 1 padding byte

short s1;//2 bytes*/

}MyStruct3;

typedef struct XYZ

{

//total 12 bytes

/*char a;//1 byte

char c;//1 byte

short s;//2 bytes

int x;//4 bytes

char d;//1 byte

char e;//1 byte + 2 padding bytes*/

}MyStruct4;

typedef struct XYZ

{

//total 16 bytes

char a;//1 byte + 1 padding byte

short s1;//2 bytes

char c;//1 byte + 1 padding byte

short s;//2 bytes

int x;//4 bytes

char d;//1 byte + 3 padding byte

}MyStruct5;

typedef struct XYZ

{

//total 20 bytes

char a;//1 byte + 1 padding byte
short s1;//2 bytes
char c;//1 byte + 1 padding byte
short s;//2 bytes
double x;//8 bytes
char d;//1 byte + 3 padding bytes

}MyStruct6;

We can use #pragma pack(1) directive to force the compiler to avoid the padding of the structure elements. Hence with #pragma pack (1) directive, the MyStruct5 will give the size of 11 bytes.

I would like to end this discussion with an example of how the alignments of the structure members affect the size of a structure.

Consider the following structure MyStruct1.

typedef struct XYZ

{

//total 12 bytes

/*char c;//1 byte + 3 padding bytes

int x;//4 bytes

short s;//2 bytes

char d;//1 byte + 1 padding byte

}MyStruct1;

its total size is 12 bytes because of padding.

Now let us reorder the members of the same structure as follows:

typedef struct XYZ

{

//total 8 bytes

/*char c;//1 byte

char d;//1 byte

short s;//2 bytes

int x;//4 bytes

}MyStruct1;

The size becomes 8 bytes. So there is a reduction of 4 bytes by just reordering the members of the structure. If we happen to do embedded programming or programming for small devices, we need to take care of this fact because memory is a major constraint in these devices...

Merge Sort - for my students...

2010-09-28T13:19:00.005+05:30

Using divide-and-conquer policy we can solve a sorting problem. The divide-and-conquer method suggests the sorting algorithm with the following structure.: if n is one, terminate; otherwise partition the collection of elements into two or more sub collections.; sort each; combine the sub collections into a single sorted collection.

It can be depicted as follows:

void Sort(a[], n)

{

if(n>= k) { //k is global

i = n/k;

j = n-i;

Let A consist of the first i elements in a[]

Let B consists of the remaining j elements in E

Sort(A,i);

Sort(B,j);

merge(A,B,a,i,j); //merge A and B into a[]

}

else sort a[] using insertion sort.

}

In the above pseudo code, if we make k = 2, we get merge sort.

The complete source code of Merge Sort can be found here.

Analysis of Merge Sort:

From the following algorithm of Merge Sort, the run time T(n) can be deduced as follows:

void MergeSort(int a[], int low, int high)

{

int mid;

if(low(high))

{

mid = (low+high)/2; ==> Θ(1)

MergeSort(a,low,mid); ==>T(n/2)

MergeSort(a,mid+1,high);==>T(n/2)

merge(a,low,mid,high);==>Θ(n)

}

Therefore we can write T(n) = 2T(n/2) + Θ(n)

Comparing it with the Master theorem, we get a = 2, b = 2 and d = 1. Hence a = b^d which means it is the second condition of the Master Theorem.

Thus we get T(n) = Θ (n log n)

Quick Sort - for my students...

2010-09-24T16:32:00.003+05:30

Quick Sort is a sorting algorithm where we apply Divide and Conquer policy. In this sorting algorithm, the n elements to be sorted are partitioned into three segments - a left segment, a middle segment and a right segment. The middle segment is called pivot. The middle segment exactly contains one element. The partition is done in such a way so that all the elements in the left segment have key less than the pivot and all the elements in the right segment have keys greater than the pivot. As a result, the left segment and the right segment can be sorted independently.

The basic principle of Quick sort is as follows:

Select an element from a[0:n-1] for middle. This element is called pivot.
Partition the remaining element in such a fashion that all elements in the left of the pivot have keys less than the pivot, and all the elements in the right segment have keys greater than the pivot.
Sort left segment using quick sort recursively
Sort right segment using quick sort recursively
The answer will be left followed by middle followed by right.

The algorithm of the quick sort can be found here.

Debugging of the Algorithm of the code:

Step I: To begin with we get m = 0, n = 6, hence k = 3. After doing swap(&list[m],&list[k]), we get key = 5. The following two steps make i = 1 and j = 6.

Step II: Now the loop starts.

II while loop fails as list[i] (7) is not less than key (5). Hence i does not increase and it remains 1. The III while loop succeeds (as list[j] > key)and hence j is decremented. So j becomes 5. In the next iteration of the III while loop, the list[j]>k condition fails, hence j remains 5 and we exit the III while loop. So we exchange list[i] and list[j] and the array becomes {5,1,8,3,2,7,9}

Next the II while loop succeeds and we increment i. Hence i becomes 2. The III while loop also succeeds and hence j becomes 4. So list[i] = list [2] = 8 and list[j] = list[4] = 2. So when we swap between list[i] and list[j], the array becomes list {5,1,2,3 8,7,9}.

Next the II while loop succeeds two times and we get i = 4. The III while loop also succeeds and we get j = 3. As j becomes larger than i, we come out of the I while loop.

Next we do swap(&list[m],&list[j]). And the list becomes list {3,1,2,5,8,7,9}

After that we recursively sort list{3,1,2}, the left segment and list{8,7,9}, the right segment.

See how all the elements of the left segment are less than 5 and all the elements in the right segment are greater than 5.

This is how we achieve the Quick Sort.

Pointer Semantics Vs Value Semantics

2010-09-19T06:47:00.000+05:30

Value semantics means we directly deal with the values and we pass copies of that value around. We can say that nobody will change the value.

However, in pointer semantics we deal with pointer, and anyone can change the value at the pointer location.

Consider the following program.

* main.c

* Created on: Sep 18, 2010

* Author: administrator

#include

void f (int * p, int * q) {

p = q;

*p = 2;

}

int i = 0, j = 1;

int main ( )

{

f(&i, & j);

printf("%d %d\n", i, j) ;

return 0;

}

The result will be 0 and 2. Why? Let me explain it to you.

We have two global variable i and j and we pass the pointer of these two variables to the function f. When we do p = q, we actually loose the reference of i, and we get two pointers namely p and q both pointing to j. then when we do * p = 2, we actually change the value of j to 2.

The whole thing can be depicted by the following diagram...

However, as we lost the reference of i in the step p = q, in the main program, the value of i that gets printed is the global variable that is 0. Hence we get the result as i = 0 and j = 2.

Hope this explains the pointer arithmetic to my students...

Handy Maths to solve Data Structure Problem

2010-08-25T16:19:00.007+05:30

Let me first define the problem:

Prob: F(n) is a function defined as :

F(n) = 1 ; n = 1

F(n) = F(n-1) + 1/n ; n>1

Prove that Big Oh of F(n) is log n

Solution:

F(n) = F(n-1) + 1/n

= F(n-2) + 1/(n-1) + 1/n

=F(n-3) + 1/(n-2) + 1/(n-1) + 1/n

This kind of series is called the Harmonic Series and can be represented as 1 + 1/2 + 1/3 + 1/4 + ......+ 1/n

Mathematically we can prove that the sum of an Harmonic series is ln n + gamma( a constant). This constant is called Euler's constant and its approx value is 0.57721

Therefore, we can say limit f(n) = limit ln n + gamma

n->infinity n->infinity

Hence limit f(n)/log n

n->infinity

= limit (ln n + gamma)/log n

n->infinity

= limit ln n/log n + gamma/limit log n

n->infinity n->infinity

= ln 2 + 0

= ln 2

Hence we can say F(n) = O(log n)

You can find the document here.

For my Data Structure Students - Insertion Sort

2010-08-19T11:56:00.003+05:30

The Algorithm -

Lets define a function to insert an integer into a non-decreasing sorted array. See the function void insert(int x[], int& length, int& number_to_be_inserted). What it does, is that it starts scanning the array from the end - the maximum number (as it is a non-decreasing array). Whenever it finds that the number_to_be_inserted is less than than the number in the array, it shifts the position of that number in the array towards right. Otherwise it inserts the new number in that position. This principle can be applied to Sort an array. We will start with an one element array. It is obviously sorted. We will pick up the next element and put it in the right place of the sorted array. Thus we get a two element sorted array. Similarly we can get a sorted array of size n.

In the following code snippet, the Method I is the Algorithm with a separate Insert Function. The method II is the sorting algorithm with the Insert function inbuilt into it.

The source code of Method I can be found here.

The output of this program is as given below

The source code of Method II can be found here.

The output of this program is given below

Hope you enjoy this study.

For my Data Structure Students - Selection Sort

2010-08-19T10:50:00.006+05:30

As mentioned earlier, i have started writing code and analyzing of various data structure area of computer science... Here is one such Sorting Algorithm called Selection Sort. In the first pass, it just finds the minimum number and exchanges it with the first place, in the second pass it finds out the second most minimum number and exchanges it with the second position.

Please find the source code of the Selection Sort from here.

The result of the code is as shown below. Please look at how at each outer loop pass, the small numbers occupy the places in the beginning of the sorted array...

Analysis:

For first outer loop, the inner loop goes for n-1 times, for the second outer loop, the inner loop goes for n-2 times and so on. The outer loop itself goes for n-1 times.

Hence f(n) = (n-1) + (n-2) + (n-3) + ....+ 2+1 = n*(n-1)/2

Hence O(n) = n^2

Hope you enjoy this...

For my Data Structure Students - Bubble Sort...

2010-08-19T10:22:00.007+05:30

As a professor of computer science i have started recapitulating the basic theoretical computer science. Few days back i have written the code for bubble sort and did its analysis. I would like to share it with the student community...

You can find the source code from here.

The result of the above program is shown below.

Please have a look at how at each pass of the outer loop the large numbers are pushed towards the end.

Analysis:

The outer loop of the bubblesort algorithm does n times. For first outer loop the inner loop is for n-1 times, for second outer loop the inner loop is for n-2 times and so on.

Hence total loop count is (n-1) + (n-2) +........+2+1 = n*(n-1)/2

Hence O(n) = n^2

Hope this discussion helps the student community...

For my Microprocessor Students

2010-08-13T13:52:00.011+05:30

I got this resource by googling. Hope this helps the student community.

Microprocessor Training

A good simulator for 8085 programming on PC is GNUSIM8085 and it is available at http://gnusim8085.org/

The interface of GNUSIM8085 looks like the following.

How to Import the Bookmarks from Chrome to Firefox

2010-07-22T07:24:00.001+05:30

From almost the two years I have been using Ubuntu. I have installed Google's chrome browser in Ubuntu and I mostly use this one for browsing. However, yesterday I was thinking how I can import the bookmarks from Chrome to the Firefox, which is the browser that comes pre-installed with Ubuntu...Then I devised the following simple way to do that which I would like to share with you...

You must be aware that we can do syncing of our own browsing data from Chrome. When we do syncing, one document called Bookmarks is created in the Google Chrome folder of My folders section of Google Docs of the synchronized Google account. Select that Bookmarks folder and go the More Action menu. At the bottom of that menu, there is a menu item called Export. Click that item and export and download the favorites as an HTML file.

Now open the Firefox browser and go to Organize Bookmarks under the Bookmarks menu. There click Import and Backup and import the HTML file you have just exported and downloaded from Chrome.

Voila.... All your Bookmarks will be imported to the Firefox browser....

Ubuntu video screen capture - XVidCap

2010-07-19T08:14:00.003+05:30

I was wondering if i could get any tool for video screen capturing for Ubuntu. With a little bit of googling, i found XVidCap. Here is my first experience with the video screen capture of one of my Android Applications.

Hope this information helps others...

My first experience with OpenCV

2010-03-29T14:45:00.010+05:30

OpenCV is an opensource library for computer vision. It is available at http://sourceforge.net/projects/opencvlibrary/

With the help of some of the internet samples, i tried to play around with OpenCV from past two days. And here is one such application. It actually plays an AVI file.

You can find a nice tutorial on OpenCV at http://www.site.uottawa.ca/~laganier/tutorial/opencv+directshow/cvision.htm

Here is a glimpse of how my application will look like.

Hope it gives some insights to others who are interested in computer vision.

Cubicles in Indian IT companies...

2010-03-12T16:42:00.002+05:30

The way we behave in a crowd or in solitude is totally different from the way we behave in a place surrounded by few known people... In the first case we become carefree and tend to break all sorts of barriers... in the second case we restrict ourselves to some extent... in the first case when we break free, we may create something new, do something highly innovative... however its just not possible in the second case....hence i believe to get some Aha-product from our IT companies, we must first break the cubicle culture that exists now and let the developers become care-free...

Voting in India through mobile phones

2010-03-10T07:53:00.000+05:30

Yesterday i saw a digged article in which Sam Pitroda was trying to mention about voting in a democracy through mobile phones. And before going to sleep, i thought of this crazy idea about how it may be implemented... Let me share it with you...

As you know India is going to give a national id card to everyone. I was thinking how about having an ID card which will have an encrypted image on it which will store all sorts of data, be it biological or anything one can imagine... One national team will develop a mobile application which will decrypt the image to extract all the information... The telecom regulatory authority may issue a law that to sell a mobile phone in India, the manufacturer will have to install this application and it will be secured so that no one can uninstall it from the phone.

Now what this application will do... Once we take a shot of that encrypted image on the ID card with the phone camera, the application will decipher all the data stored on it...

So we will have a secured voting website...The person who wants to vote will go to that site which will ask the user to launch that application...Once it is launched the user will simply take a shot of the encrypted image on his ID card... And thats it... The application will feed all the data to the server through a secured connection and the website will take the user to the right constituency... And then he can simply choose his candidate...

As the blog title says its my own world of technology and software, this is my crazy idea...

Let me know what you think about it...

Training on C++, Android, UML and Design Pattern

2010-03-04T22:19:00.006+05:30

I am interested in providing training on subjects like C++, UML, Android, Design Pattern, Java/J2SE etc. Please have a look at my training website

http://sites.google.com/a/som-itsolutions.com/som-itsolutions/Home

to get an idea.

If you are interested, please email me.

The Importance of Google...

2010-02-23T06:22:00.004+05:30

The usefulness of Google is not very surprising to many...however, for me its one of the greatest democratizing tools...it has democratized the concept that is called knowledge which was once a well guarded property in the hands of a few...

let me elaborate it a bit...i think whatever little related to technology i have learnt so far, is simply by means of Googling... even these days to remove the programming errors i take the help of mighty Google...to elaborate it more, for example, today i became curious about the way WiFi can be used in the industrial automation domain... so i googled it and got a fair amount of idea which includes ZigBee to Cisco's Wireless Plant Solution...I became curious about whether the data collected by sensors in a plant can be processed via cloud...i am interested in this topic because of its social implication...think about it that if the plant's data can be processed across the continent, then no one will have to do night shift duty... So i googled about that and got some idea about Helios platform from Eurotech... when i want to know if the 802.11n has been officially released, i just google that...when i want to know if there is anything similar or dissimilar between new(noThrow) of C++ and new(ELeave) of Symbian C++, i simply google that...when i want to know about the smart pointers in boost, i just google that...

the google doc or the other tools like picasa and google map have come recently... but i am an ardent fan of Google from its inception because i think its only because of google i did not have to depend on anybody to learn about my technological area...

My First Experience with Ubuntu QT

2010-02-18T05:48:00.002+05:30

I had installed Ubuntu quite sometimes back. I had also installed QT. However, i got my hands dirty in QT programming in the Ubuntu environment for the first time today. Let me share my experience with you.

First i opened the QTCreator from the Applications->Programming menu. Then went to File->New. And followed the steps as shown in the pictures.

After the project is created, i opened the mainwindow.ui and dragged a PushButton to the center of the main window. From the property, i changed the display text of the button as Hello World. its name is changed to HelloWorldBtn.

Then i added a private slot in the mainwindow.h file as follows:

private slots:
void on_HelloWorldBtn_clicked();

It means the signal connection is automatic.

Then i added the following handler function in the mainwindow.cpp file:

void MainWindow::on_HelloWorldBtn_clicked()
{
QMessageBox::information(this,"Som", "Hello World");
}

And its done... Of course to compile this code, i had to do #include (QMessageBox) in the mainwindow.cpp file...

i ran the application... And when i clicked the button it showed the messagebox as the following picture...

Android Graphics

2010-01-25T07:28:00.009+05:30

I was curious about the graphical programming in Android... Fortunately i have found the library aChartEngine... As i was trying to play around with it, i came up with few trigonometric graphs... Hope this would give some pointers to the new comers about graphical programming in Android...

The application looks like the following...

And the graphs are like the following:

Sin Curve

Cosine Curve

Tangent Curve

Sinc Curve

Damped Sin Curve

Android HomeScreen Management

2010-01-19T09:46:00.024+05:30

As i was trying to play around with Android HomeScreen, i came up with this application to add any application to the HomeScreen. I think it can work as a good project for the beginner of Android programming.

The home screen looks like the following after i added two of the applications to the HomeScreen -one is my own KeyPadDialer and the other is the AlarmClock.

And the HomeScreen Management Application looks like the following in the beginning:

And after clicking the Spinner it looks this:

The complete source code for my application can be found here.

The manifest file for this application can be found here.

And the layout of the application is given here.

Hope this idea helps others...

My first experience with Java

2010-01-02T19:47:00.002+05:30

As most of my experience lies in C++, when i started gaining interest in Java/J2SE i started looking at it from a C++ programmers point of view. Hence the first thing i googled was how to create a canonical class in Java. And i was astonished to find out that the way we do Assignment operator in C++ is not the same in Java. After some more googling i came to know about the clonable interface in Java. And it gave me the right direction...

Then i googled about the String class in Java and found out that a String object in Java is immutable... i became curious and opened the String class of Java... And voila... no wonder... the character array that holds the contents of the String object is final... hence it is immutable... So i asked myself what happens when we do String newString = oldString in Java. And i got the answer... As the String class is not implementing the Clonable interface, when we do String newString = oldString, the oldString's contents get a new reference in newString... We loose any reference to oldString.

But then i wondered how String S1 = oldString + "abc" would work. Because as i was googling i found out that Java does not support operator overloading... so how come the + operator is working fine for the String class? my first stumbling block... fortunately i found out the document at http://java.sun.com/docs/books/jls/third_edition/html/expressions.html#15.18.1 and my doubts were gone...

So i wondered if Strings are immutable in Java, are not there any way to change the contents of a String object without creating a new object? i googled a little more and came to know about StringBuffer and StringBuilder classes and their mutable char array which will store that data... i delved into the classes a little more and found out about their append function.

So far my investigation into the Java source code is fruitful...

Hopefully i will be able to delve more into it and find out the nitty-gritties about the Java language...

Experimentation with Design Pattern

2009-11-17T06:42:00.012+05:30

I am yet to study the book Pattern Hatching. However, i tried to accumulate all my knowledge on Design Pattern and solved a problem of Accountancy. i would like to share it with you. Let me, first of all, state the problem.

The Problem :

Basic sales tax is applicable at a rate of 10% on all goods, except books, food, and medical products that are exempt. Import duty is an additional sales tax applicable on all imported goods at a rate of 5%, with no exemptions. Also the Sales Tax should be rounded off to the nearest 0.05.

This being the problem, we need to come out with a solution for this problem.

Now let me tell you how my thought process went into it to think it at an abstract level.

First of all, i thought to make two top level classes. One that will define the Items having different benchmarks for Sales Tax and Import Duty; i.e.

1. Food, Medical and Book items which are not imported and hence exempted from both sales tax and import duty
2. Non Food Book and Medical items which are not imported and hence will have just the Sales Tax
3. Food Book and Medical items which are imported and hence will have only import duty
4. Non food book and medical items which are imported and hence will have both Sales Tax and Import Duty

And the other for the Tax Calculation algorithm for different items.

Then i thought this is a perfect match for Strategy Pattern that i had studied in the GoF book. I thought about that pattern keeping in mind for the future expansion of the Tax Calculation Algorithm. What i mean is that for the present problem, the calculation is simple. And hence it does not need any other Strategy. However, for the future purpose if the Tax Calculation Algorithm is changed to some complicated one, then we can just Subclass the Tax Calculation class and attach that strategy to the Item Class.

Next i thought, won't it be nice to get a Factory Class through which the client can create different Items on the fly. Hence i have decided to create an ItemCreator class which is nothing but a parameterized factory class for creating different Items on the fly.

And i came out with the following solution.

The Item class Hierarchy:

File: Item.h
#ifndef ITEM_H
#define ITEM_H

class SalesTax;

//This represents the Items which don't have an Import duty or any sales tax
class Item
{
public:

//Constructors
Item();
Item (SalesTax* aSalesTax);

//Interface Functions for Item

//To calculate the price after tax and import duty
virtual void CalculateTotalPrice();

//To calculate the total tax and import duty
virtual void CalculateTotalTax();

//To set the price of the Items
void SetPrice(double aPrice);

//To get the price of the Items before tax
double getPrice();

//To get the price of the items after tax
double getTotalPrice();

//To get the total tax and import duty of the items
double getTax();

//Data
protected:
//Works as the Strategy of the Sales Tax problem.
//If in future the tax calculation becomes more complicated for different Items
//we will just have to change this Strategy. We can also subclass this Strategy class
//for future expansion of the tax calculation strategy
SalesTax* iSalesTax;
//Data
protected:

//These are the basic properties of any Item.
//Hence these are made protected members so that the subclasses of Item can inherit
//these properties
double iPrice;
double iTotalPrice;
double iTotalTax;
};

//This class represents the Items which have only Import Duty
class ImportedItem : virtual public Item
{
public:
//Constructors
ImportedItem();

//This constructor helps to create Items having only Import duty
ImportedItem(SalesTax* aSalesTax, double aImportDuty);

//Override
virtual void CalculateTotalTax();

protected:
double iImportDuty;
};

//This class represents the Items which have only Sales Tax but no Import Duty
class NonFoodBookMedicalItem : virtual public Item
{
public:
//Constructors
NonFoodBookMedicalItem();

//This constructor helps to create Items having only Sales tax
NonFoodBookMedicalItem(SalesTax* aSalesTax, double aRate);
//Override
virtual void CalculateTotalTax();

protected:
double iRate;
};

//This class represents the Items which have got both Import Duty as well as sales Tax
class NormalItem: public ImportedItem, public NonFoodBookMedicalItem
{
public:
NormalItem();
//This constructor helps to create Items having both Sales tax and Import duty
NormalItem(SalesTax* aSalesTax, double aRate, double aImportDuty);

//Override
virtual void CalculateTotalTax();
};

#endif

As you can see the four classes solve the hierarchy for different items having different benchmark for Sales Tax and import Duty.

The Item.cpp file looks like the following:

File: Item.cpp
#include "stdafx.h"

#include "SalesTax.h"
#include "Item.h"

Item::Item(){}

Item::Item(SalesTax* aSalesTax):iSalesTax(aSalesTax),iPrice(0),iTotalPrice(0),iTotalTax(0)
{
}

void Item::CalculateTotalPrice()
{
iTotalPrice = iPrice + iTotalTax;
}

double Item::getTotalPrice()
{
return iTotalPrice;
}

void Item::CalculateTotalTax()
{
iTotalTax = iSalesTax->ComputeSalesTax(iPrice, 0, 0);
}

void Item::SetPrice(double aPrice)
{
iPrice = aPrice;
}

double Item::getPrice()
{
return iPrice;
}

double Item::getTax()
{
return iTotalTax;
}
ImportedItem::ImportedItem(){}

ImportedItem::ImportedItem(SalesTax* aSalesTax, double aImportDuty):Item(aSalesTax)
{
iImportDuty = aImportDuty;
}
void ImportedItem::CalculateTotalTax()
{
iTotalTax = iSalesTax->ComputeSalesTax(iPrice, 0, iImportDuty);

}
NonFoodBookMedicalItem::NonFoodBookMedicalItem(){}

NonFoodBookMedicalItem::NonFoodBookMedicalItem(SalesTax* aSalesTax, double aRate):Item(aSalesTax)
{
iRate = aRate;
}

void NonFoodBookMedicalItem::CalculateTotalTax()
{
iTotalTax = iSalesTax->ComputeSalesTax(iPrice, iRate, 0);

}
NormalItem::NormalItem() {}

NormalItem::NormalItem(SalesTax* aSalesTax, double aRate, double aImportDuty):Item(aSalesTax)
{
iRate = aRate;
iImportDuty = aImportDuty;
}
void NormalItem::CalculateTotalTax()
{
iTotalTax = iSalesTax->ComputeSalesTax(iPrice, iRate, iImportDuty);
}

Now let us concentrate on the Sales Tax class

file: SalesTax.h

//This class works as the Strategy of the Sales tax problem
class SalesTax
{
public:

//Default constructor
SalesTax();

//This function helps to compute the Sales Tax
virtual double ComputeSalesTax(double aPrice, double aRate, double aImportduty);

private:
//This is an helper function which will round off the sales tax
double RoundOff(double aTax);
};

And the implementation of the Sales tax is as follow:

file: SalesTax.cpp

#include "stdafx.h"
#include "SalesTax.h"

SalesTax::SalesTax(){}

double SalesTax::ComputeSalesTax(double aPrice, double aRate, double aImportduty)
{
double tx = (aPrice*aRate/(double(100))) + (aPrice*aImportduty/(double(100)));
return RoundOff(tx);
}
//private:
double SalesTax::RoundOff(double aTax)
{
int taxTemp = (int)aTax;

double decimaltaxTemp = (double)(aTax - (int)taxTemp);

int tempy = (int)(1000*decimaltaxTemp)/100;

int tempz = (int)(1000*decimaltaxTemp - tempy*100);

int temp = (int)(tempz/10);

int t = tempz%10;

if (t >= 5)
temp+=1;

return (double)(taxTemp + tempy*(0.1) + temp*(0.01));
}

As you can see the the data for calculation are being passed from the Item class.

Hence we can say this is in abstract form an implementation of the Strategy Pattern where the Item class is working as the Context and the Sales Tax class is acting as the sole Strategy interface.

Now lets concentrate on the creation of the Items.

As i have already mentioned, this is done through a Parameterized factory class called ItemCreator.

This class looks like the following:

File: ItemCreator.h

#include "Item.h"

const int ITEM_WITH_NOSALESTAX_AND_IMPORTDUTY = 1;
const int ITEM_WITH_NOSALESTAX_ONLY_IMPORTDUTY = 2;
const int ITEM_WITH_ONLY_SALESTAX_AND_NOIMPORTDUTY = 3;
const int ITEM_WITH_BOTH_SALESTAX_AND_IMPORTDUTY = 4;

const double SALES_TAX_RATE = 10;
const double IMPORT_DUTY_RATE = 5;

class Not_A_Standard_Item_Type_Exception
{
public:
void printerrormsg();
};
class ItemCreator
{
public:
virtual Item* Create(int aItemId);

};

And the implementation of this ItemCreator is as follow:

file: ItemCreator.cpp

#include "stdafx.h"
#include

#include "ItemCreator.h"
#include "Item.h"
#include "SalesTax.h"

using namespace std;

void Not_A_Standard_Item_Type_Exception::printerrormsg()
{
cout (("Not the right Item Type..." ((endl;
}

Item* ItemCreator::Create(int aItemId)
{
SalesTax* st = new SalesTax();

switch(aItemId)
{
case ITEM_WITH_NOSALESTAX_AND_IMPORTDUTY:
return new Item(st);
break;

case ITEM_WITH_NOSALESTAX_ONLY_IMPORTDUTY:
return new ImportedItem(st,IMPORT_DUTY_RATE);
break;

case ITEM_WITH_ONLY_SALESTAX_AND_NOIMPORTDUTY:
return new NonFoodBookMedicalItem(st,SALES_TAX_RATE);
break;

case ITEM_WITH_BOTH_SALESTAX_AND_IMPORTDUTY:
return new NormalItem(st,SALES_TAX_RATE,IMPORT_DUTY_RATE);
break;

default:
throw Not_A_Standard_Item_Type_Exception();
}
}

And the client program will look like the following:

#include "stdafx.h"

#include "SalesTax.h"
#include "Item.h"
#include "ItemCreator.h"

#include (vector)
#include

using namespace std;

void main()
{
typedef vector(Item*) listOfItem;
listOfItem::iterator theIterator;

listOfItem Basket;
char answer = 'n';

double totalprice = 0;
double totaltax = 0;

do
{
int type_of_item;

cout (("Enter the type of Item...1,2,3,4" ((endl;

cout (("1 for ITEM_WITH_NOSALESTAX_AND_NOIMPORTDUTY" ((endl;

cout (("2 for ITEM_WITH_NOSALESTAX_ONLY_IMPORTDUTY" ((endl;

cout (("3 for ITEM_WITH_ONLY_SALESTAX_AND_NOIMPORTDUTY" ((endl;

cout (("4 for ITEM_WITH_BOTH_SALESTAX_AND_IMPORTDUTY" ((endl;

cin ))type_of_item;

ItemCreator* itemCreator = new ItemCreator();

try
{
Item* item = itemCreator->Create(type_of_item);

cout (("Enter the price of the Item" ((endl;

double price;

cin ))price;

item->SetPrice(price);

Basket.push_back(item);
}

catch(Not_A_Standard_Item_Type_Exception& e)
{
e.printerrormsg();
}

cout (("Do you want to continue... Y/N" ((endl;
cin ))answer;
}
while (answer =='y');

theIterator = Basket.begin();

int pos = 0;
while (theIterator != Basket.end())
{
Basket.at(pos)->CalculateTotalTax();
totaltax+=Basket.at(pos)->getTax();

Basket.at(pos)->CalculateTotalPrice();

double price = Basket.at(pos)->getPrice();

double price_after_tax = Basket.at(pos)->getTotalPrice();

totalprice+=price_after_tax;

cout (("Item" ((pos+1 ((" price " ((price ((endl;
theIterator++;
pos++;
}
cout (("------------" ((endl;
cout (("Toal tax " ((totaltax ((endl;
cout (("Total price " ((totalprice ((endl;
}

Thus the problem is solved using two common design pattern concepts - Strategy Pattern and Parameterized Factory Pattern.

This is the way i am trying to move from the problem domain to the solution domain using design pattern concepts.

Hope this helps others who are studying Design Pattern.

My first experience with Ubuntu Karmic kola

2009-11-09T08:27:00.007+05:30

I felt very excited after i read the review comments about Ubuntu 9.1, the Karmic Kola distribution of Ubuntu... However with over enthusiasm i could not wait for the official release... I downloaded the release candidate few days before the official release of Ubuntu 9.1...

As i have used only Windows so far, i was a bit worried about my transition to Ubuntu... However, so far it was smooth...

After downloading the release candidate of the Ubuntu 9.1, i had to burn the CD... I used ImgBurn to do that... What one needs is a blank 700 MB writable CD... The burning process did not take much time...

Then with caution i inserted the CD for the installation... The installation got started... And it hardly took 20 minutes to completely install it...

I restarted my computer... There were two options to boot up - one for my old Windows XP and the other was Ubuntu... I chose the second one... The log in screen came in no time... i entered my password... And voila... The system came up within a flash... I thought i need to do lot of configuration for my internet connection... To test it i just clicked the firefox menu on the top of the desktop... And no wonder, the Ubuntu Google came up in a flash...

I was delighted...

With a little help through googling, i found that for a developer, the build essential package is a must... After that i did a research and found the Synaptic Package Manager Under System.. i opened it... Searched for build essential... Marked it... And installed it...

Then i installed Git... And Eclipse... And yesterday i installed QTCreator IDE... And the development environment is ready...

I started gaining interest in Linux because i wanted to compile the Android source code... so far my experience with Ubuntu is very good... its update manager is working for me...The synaptic package manager is fantastic...

I installed HPLIP... However i could not set up my HP 656C printer... Its saying the driver is different... I hope even that will be sorted out within a couple of weeks...

I can say that for me its been a smooth transition to Ubuntu...And the best part is that neither i had to install SpyBot... nor do i have to scan with SpyWare doctor every time i start my PC...and of course i don't have to care about Malwarebytes to fight against virtumunde...

WiFi Subsystem in Android

2009-10-10T06:06:00.000+05:30

As i was trying to understand the WiFi subsystem of Android i came out with a diagram to depict the flow of events between different functional blocks of it. I would like to share it with you.

It goes like this:

Hope it will help the Android developers' community.

Tabs in Android - through an example

2009-10-08T17:07:00.000+05:30

As i was trying to experiment with the different widgets of Android, i developed this example to show how Tab works in Android.

And the application looks like the following:

And the next tab looks like:

The first thing we need to to do is working on the XML layout.

The XML code of the layout my example is as follows:

(?xml version="1.0" encoding="utf-8"?)
(LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
)

(TabHost android:id="@+id/TabHost01" android:layout_width="wrap_content" android:layout_height="wrap_content")
(TabWidget android:id="@android:id/tabs" android:layout_width="wrap_content" android:layout_height="wrap_content" /)
(FrameLayout android:id="@android:id/tabcontent" android:layout_width="wrap_content" android:layout_height="wrap_content" android:paddingTop="65px")
(AnalogClock android:id="@+id/AnalogClock01" android:layout_width="wrap_content" android:layout_height="wrap_content")(/AnalogClock)
(DigitalClock android:text="DigitalClock01" android:id="@+id/DigitalClock01" android:layout_width="wrap_content" android:layout_height="wrap_content")(/DigitalClock)
(/FrameLayout)
(/TabHost)
(/LinearLayout)

And the Java code for this example is as follws:

import android.app.Activity;
import android.os.Bundle;
import android.widget.TabHost;

public class tabexample extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);

TabHost tabs = (TabHost)findViewById(R.id.TabHost01);

tabs.setup();

TabHost.TabSpec spec1 = tabs.newTabSpec("tag1");

spec1.setContent(R.id.AnalogClock01);
spec1.setIndicator("Analog Clock");

tabs.addTab(spec1);

TabHost.TabSpec spec2 = tabs.newTabSpec("tag2");
spec2.setContent(R.id.DigitalClock01);
spec2.setIndicator("Digital Clock");

tabs.addTab(spec2);
}
}

Hope this helps the newcomers of Android...

Inter Process Communication in Android through Intent

2009-08-15T23:34:00.000+05:30

In Android, one of the nice ways for passing data between different processes is through the help of Intent. In the following example i have tried to explain it by two different applications. One application is called the IntentSupplier. This is started from another application called IntentExample. The application IntentSupplier passes some string data to the IntentExample app through the help of an Intent object which the IntentSupplier application displays in a message box.

The IntentSupplier application looks like the following.

When we click one of the buttons it passes its string data to the IntentExample which looks like the following.

The source code for IntentSupplier is as follows:

package android.training.intentsupplier;

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;

public class IntentSupplier extends Activity {

/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);

Button button1 = (Button)findViewById(R.id.Button01);

Button button2 = (Button)findViewById(R.id.Button02);

button1.setOnClickListener(onClickButton1);
button2.setOnClickListener(onClickButton2);

}

private OnClickListener onClickButton1 = new OnClickListener() {

public void onClick(View v){

if (v.getId() == R.id.Button01){

returnResult("Message1 coming from IntentSupplier");
}
}
};

private OnClickListener onClickButton2 = new OnClickListener() {

public void onClick(View v){

if (v.getId() == R.id.Button02){

returnResult("Message2 coming from IntentSupplier");
}
}
};

void returnResult(String msg) {

Intent i = new Intent();

i.putExtra("android.training.intentsupplier.resultfromintentsupplier", msg);

setResult(RESULT_OK, i);

finish();
}

}

Look at the function

void returnResult(String msg).

Here at the line i.putExtra("android.training.intentsupplier.resultfromintentsupplier", msg), we are basically parceling the data (msg) and giving it a label called resultfromintentsupplier. Please see how the package info is prefixed with this label.

The source code for the IntentExample is as follows:

package android.training.intentexample;

import android.app.Activity;
import android.app.AlertDialog;
import android.content.ActivityNotFoundException;
import android.content.DialogInterface;
import android.content.Intent;
import android.os.Bundle;
import android.util.Log;

public class IntentExample extends Activity {

static final int REQUEST_CODE = 1001;

/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);

setContentView(R.layout.main);

Intent getMessageFromIntentSupplier = new Intent();

getMessageFromIntentSupplier.setClassName("android.training.intentsupplier", "android.training.intentsupplier.IntentSupplier");

getMessageFromIntentSupplier.setAction("android.training.intentsupplier.android.intent.action.INTENTSUPPLIERTEST");

getMessageFromIntentSupplier.addCategory("CATEGORY_DEFAULT");

getMessageFromIntentSupplier.setType("vnd.example.greeting/vnd.example.greeting-text");

try {
startActivityForResult(getMessageFromIntentSupplier,REQUEST_CODE);

}

catch(ActivityNotFoundException e) {
Log.e("IntentExample", "Activity could not be started...");
}

}
}

public void onActivityResult(int requestcode, int resultcode, Intent result ) {

if(requestcode == REQUEST_CODE){
if(resultcode == RESULT_OK){
message = result.getStringExtra("android.training.intentsupplier.resultfromintentsupplier");

new AlertDialog.Builder(this)
.setTitle("Msg from Intent Supplier")
.setMessage(message)
.setNeutralButton("Close", new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dlg, int sumthin) {
// do nothing – it will close on its own
}
})
.show();
}
}
}

}

The AndroidManifest.xml file of the IntentSupplier application looks like the following:

(** Please replace the "(" & ")" brackets with the angular brackets to xmlize the file contents)

(?xml version="1.0" encoding="utf-8"?)
(manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="android.training.intentsupplier"
android:versionCode="1"
android:versionName="1.0")
(application android:icon="@drawable/icon" android:label="@string/app_name")
(activity android:name=".IntentSupplier"
android:label="@string/app_name")

(intent-filter)
(action android:name="android.intent.action.MAIN" /)
(category android:name="android.intent.category.LAUNCHER" /)
(/intent-filter)

(intent-filter)
(action android:name="android.intent.action.INTENTSUPPLIERTEST" /)
(category android:name="android.intent.category.DEFAULT" /)
(data android:mimeType="vnd.example.greeting/vnd.example.greeting-text" /)
(/intent-filter)
(/activity)
(/application)
(uses-sdk android:minSdkVersion="3" /)
(/manifest)

The main.xml file of the IntentSupplier application looks like the following:

(?xml version="1.0" encoding="utf-8"?)
(LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
)
(TextView
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="@string/hello"
/)
(Button android:text="Message1" android:id="@+id/Button01" android:layout_width="fill_parent" android:layout_height="wrap_content")(/Button)
(Button android:text="Message2" android:id="@+id/Button02" android:layout_width="fill_parent" android:layout_height="wrap_content")(/Button)
(/LinearLayout)

In this example we have started the IntentSupplier app through the function startActivityForResult. It then waits for the result from the child activity, and once the result arrives, the callback function onActivityResult is called. in this function we extract the data sent from the child activity (by using the function getStringExtra) and show it in a message box.

To run this application we need to run once the IntentSupplier application first.

Hope this discussion becomes helpful for the newbies of Android.

My first time experience with Android Webkit

2009-07-05T21:28:00.000+05:30

As I was trying to play around with WebKit, I tried to load an web page through it in Android. A good starting point for WebKit may be found at

http://developer.apple.com/documentation/Cocoa/Conceptual/DisplayWebContent/DisplayWebContent.html .

The source code of my android application is pretty straight forward.

It goes like this:

public class WebKitExample extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);

WebView webView;

setContentView(R.layout.main);

webView = (WebView)findViewById(R.id.appView);

webView.getSettings().setJavaScriptEnabled(true);

webView.loadUrl("http://www.google.com");
}
}

We need to add the XML resource in the main.layout as the following:

(WebView android:id="@+id/appView"
android:layout_height="wrap_content"
android:layout_width="fill_parent" /)

We also need to add the permission to the manifest file as the following:

(uses-permission android:name = "android.permission.INTERNET" /)

And the application will look like the following in the emulator.

Although the example shown here is pretty simple but it can be a starting point in learning Webkit in Android. Hope this helps the newbies of Android.

The flow of events during the Media Player Creation in Android Framework

2009-06-20T10:32:00.000+05:30

The flow of events of the Android media player is complex. Moreover as i don't have a Linux machine, i have to depend on the careful study of the framework source code. i think i have got a strong enough reason to buy an Ubuntu machine.

Lets come to the fact findings. There are two sides of the Android Media Framework. What we as an user see is the Java interface which is called the Mediaplayer.java. However, this java interface interacts with a native mediaplayer object through Java Native Interface (JNI) mechanism. This interaction is done through the functionalities defined in Android_media_Mediaplayer.cpp. In this file the framework engineers have kept all the necessary JNI functions.

Now when we are about to start the MediaPlayer, the JNI function that is called is the

private native final void native_setup.

This function is actually responsible for creating a C++ mediaplayer object in the native side and storing an opaque reference to it in the Java client side. So when we interact with the client side Java mediaplayer object, we internally interact with this native C++ object.

The JNI layer actually delegates its task to a Mediaplayer object. The functionalities of this C++ class are defined in the file Mediaplayer.cpp.

Now the next step is that we set a data source in the Java side using the function setDataSource function in which the URI of the data source is passed. This in turn calls the native function

android_media_MediaPlayer_setDataSource(JNIEnv *env, jobject thiz, jstring path)

In the native source, this function is defined as

android_media_MediaPlayer_setDataSource(JNIEnv *env, jobject thiz, jstring path)
{
sp(MediaPlayer) mp = getMediaPlayer(env, thiz);
........
........

........
........
status_t opStatus = mp->setDataSource(pathStr);

process_media_player_call( env, thiz, opStatus, "java/io/IOException", "setDataSource failed." );
}

Look at the line :

status_t opStatus = mp->setDataSource(pathStr);

This function is defined as

status_t MediaPlayer::setDataSource(const char *url)
{
......
......

if (url != NULL) {
const sp(IMediaPlayerService)& service(getMediaPlayerService());
if (service != 0) {
sp(IMediaPlayer) player(service->create(getpid(), this, url));
err = setDataSource(player);
}
}
return err;
}

Look at the line :

sp(IMediaPlayer) player(service->create(getpid(), this, url));

It actually takes the help of the IMediaPlayerservice layer and calls the create function on this. This function can be found in \\base\media\libmedia\IMediaPlayerService.cpp file.

The create function of the MediaPlayerService looks like the following.

sp MediaPlayerService::create(pid_t pid, const sp(IMediaPlayerClient)& client, const char* url)
{
.....

sp(Client) c = new Client(this, pid, connId, client);

.....

.....

if (NO_ERROR != c->setDataSource(url))
{
c.clear();
return c;
}
wp(Client) w = c;

Mutex::Autolock lock(mLock);

mClients.add(w);

return c;
}

Now look at the following line of sp(IMediaPlayer) MediaPlayerService::create(pid_t pid, const sp(IMediaPlayerClient)& client, const char* url)

if (NO_ERROR != c->setDataSource(url))

So we are basically calling the setDataSource on the Client.

This function is like the following:

status_t MediaPlayerService::Client::setDataSource(const char *url)
{
.....

.....

if (strncmp(url, "content://", 10) == 0) {

// get a filedescriptor for the content Uri and
// pass it to the setDataSource(fd) method

String16 url16(url);
int fd = android::openContentProviderFile(url16);
if (fd < 0)
{
LOGE("Couldn't open fd for %s", url);
return UNKNOWN_ERROR;
}
setDataSource(fd, 0, 0x7fffffffffLL); // this sets mStatus
close(fd);
return mStatus;
} else {
player_type playerType = getPlayerType(url);

.....

.....

// create the right type of player
sp(MediaPlayerBase) p = createPlayer(playerType);
......

......
mStatus = p->setDataSource(url);

if (mStatus == NO_ERROR) mPlayer = p;

return mStatus;
}
}

From the above code snippet it becomes clear that we do

either:

if (strncmp(url, "content://", 10) == 0) {

// get a filedescriptor for the content Uri and
// pass it to the setDataSource(fd) method

String16 url16(url);
int fd = android::openContentProviderFile(url16);
if (fd < 0)
{
LOGE("Couldn't open fd for %s", url);
return UNKNOWN_ERROR;
}
setDataSource(fd, 0, 0x7fffffffffLL); // this sets mStatus
close(fd);
return mStatus;

or:

else {
player_type playerType = getPlayerType(url); //here it extracts the Player Type from the URL.
LOGV("player type = %d", playerType);

// create the right type of player
sp(MediaPlayerBase) p = createPlayer(playerType);

..............
..............

}

In the first case the setDataSource function looks like the following:

status_t MediaPlayerService::Client::setDataSource(int fd, int64_t offset, int64_t length)
{
.......

.......

//here it gets the file type from the File descriptor
player_type playerType = getPlayerType(fd, offset, length);

// create the right type of player
sp(MediaPlayerBase) p = createPlayer(playerType);
........

.........

.........
}

Look at the line :

sp(MediaPlayerBase) p = createPlayer(playerType).

It becomes clear that we create the player here.

The sp(MediaPlayerBase) p = createPlayer (playerType) actually creates the right player. And we get the playertype from the file descriptor.

In the second case (the else part) we call sp p = createPlayer(playerType). We extract the file type from the URL. This helps us in creating the right player object.

The createPlayer function looks like the following:

sp(MediaPlayerBase) MediaPlayerService::Client::createPlayer(player_type playerType)
{
......

......

if (p == NULL) {
p = android::createPlayer(playerType, this, notify);
}
return p;
}

Hence it actually delegates the task to p = android::createPlayer(playerType, this, notify);

The above function is as follows;

static sp(MediaPlayerBase) createPlayer(player_type playerType, void* cookie,
notify_callback_f notifyFunc)
{
.....

switch (playerType) {
#ifndef NO_OPENCORE
case PV_PLAYER:

p = new PVPlayer();

break;
#endif
case SONIVOX_PLAYER:

p = new MidiFile();

break;

case VORBIS_PLAYER:

p = new VorbisPlayer();

break;
}
......

......

return p;
}

Thus we find that the right player is created through the parameterized factory function createPlayer.

i hope this explains how the right mediaplayer is created from the Uri that we pass in the client side java interface of the Mediaplyer.

Parameterized factory design pattern in Android Media Service Framework

2009-06-14T06:36:00.000+05:30

As i was going through the Media framework of Android, i have found the implementation of a parameterized factory pattern in the way MediaPlayerService class creates the concrete media players.

Let me give an idea of the parameterized factory implementation as discussed in the GoF book. It goes like this.

class Creator {

public:

virtual Product* CreateProduct( ProductId id);

};

And the implementation will look like the following:

Product* Creator :: CreateProduct (ProductId id)
{

if (id == Product1) return new Product1;

if (id == Product2) return new Product2;

//repeat for the other products

return 0;

}

Product1, Product2 etc are all derived from the base class Product.

Now let us dissect the Media Framework of Android to see how this design pattern has been implemented to create the different Media players.

The base class of all the players are MediaPlayerInterface which is again derived from MediaPlayerBase.

MediaPlayerService has got a static function called

"static sp createPlayer(player_type playerType, void* cookie, notify_callback_f notifyFunc)"

which actually takes care of the creation of the concrete players namely PVPlayer, MidiFile and VorbisPlayer.

Hence the class MediaPlayerService works as the Factory class for creating the Concrete Players besides handling other responsibilities.

The class MediaPlayerService can be found at \base\media\libmediaplayerservice of the Android source code.

The createPlayer function goes like the following :

static sp(MediaPlayerBase) createPlayer(player_type playerType, void* cookie,
notify_callback_f notifyFunc)
{
sp(MediaPlayerBase) p;
switch (playerType) {
#ifndef NO_OPENCORE
case PV_PLAYER:
LOGV(" create PVPlayer");
p = new PVPlayer();
break;
#endif
case SONIVOX_PLAYER:
LOGV(" create MidiFile");
p = new MidiFile();
break;

case VORBIS_PLAYER:
LOGV(" create VorbisPlayer");
p = new VorbisPlayer();
break;
}
if (p != NULL) {
if (p->initCheck() == NO_ERROR) {
p->setNotifyCallback(cookie, notifyFunc);
} else {
p.clear();
}
}
if (p == NULL) {
LOGE("Failed to create player object");
}
return p;
}

As we can see from the above code that MediaPlayerBase here works as the base class Product. And we create different products (different concrete media players) through the function createPlayer which works as the CreateProduct function in the example at the beginning.

The above similarity shows how a Parameterized Factory Pattern has been implemented in the Android Media Framework by MediaService layer to create different Media Players.

Composite Design Pattern in Android View and Widget

2009-06-03T16:43:00.000+05:30

The Intent of this design pattern is stated in the GoF book as "Compose Objects into tree structures to represent part-whole hierarchies. Composite lets clients treat individual objects and compositions of objects uniformly".

To explain it in a simpler fashion, let me give the same example as given in the GoF book. Suppose there is an object called Picture, a graphics object. This picture may consist of other pictures recursively as well as primitive objects like line, rectangle objects etc. All of these part objects which make the whole picture conform to the same Graphic interface. Hence to the client, a part object appears same as the whole picture consisted of other part objects. To draw a whole object, the client simply traverses through the whole picture and draws different parts.

The class diagram of the composite design pattern will look like the following:

The following participants take part in this design pattern:

Component -

it declares the interface for the objects ( part as well as whole)
helps in managing the objects (adding, removing)

Leaf -

represents leaf objects which don't have any children
these are the primitive objects

Composite -

defines behavior for components having children
stores the children

Client -

takes help of the Component interface to manipulate different objects

Its all about the theoretical side of the Composite Design Pattern. Now let us try to dissect the Android View and the Widget folders (which are available at \\base\core\java\android) to see how this design pattern has been implemented there.

In Android, the View class works as the Component class. However, the child management part (add component, remove component) has been moved to the Composite class which is the ViewGroup class. Actually the Add and Remove of a component has been declared in an interface called ViewManager and the ViewGroup implements that interface. Also the interface for a Composite object is declared as ViewParent interface and the ViewGroup (the Composite object) implements that as well.

The leaf classes like Button, ImageView etc are deduced either by directly subclassing the View (Component) or from the subclasses of the View (for example, the Button class is derived from TextView class which in turn is directly derived fron the View class). The Composite Class (ViewGroup) is deduced by directly subclassing the View and by implementing the two interfaces namely ViewParent (which defines the interface of a composite object) and ViewManager (which defines the interface from adding and removing components).

As expected the getParent function which is needed to get the Parent of a component is put in the View class (the Component).

The Composite object (ViewGroup) has an array to hold its children.

The simplified version of the class diagram of the Android View and Widgets are as follows:

For simplicity i have not shown the two interfaces namely ViewManager and ViewParent.

Now let us consider the class diagram as presented in the beginning of this discussion. There is a function called Operation. In Android implementation, the onDraw function in the Component (View) plays this role. The DispatchDraw function (which is called when the children are to be drawn) in the composite (ViewGroup) object actually traverses through the list of the objects and calls draw on each of the child object. For simplicity, in the class diagram it is shown that the dispatchDraw function is directly calling the onDraw function. However it actually takes help of another function called drawChild which is called on each child object of the ViewGroup object.

This way we can say that Android View and Widgets are some sort of implementation of the Composite Design Pattern.

Observer Pattern in Java

2009-05-31T21:34:00.004+05:30

As i was going through the different source code files of the Java Util package, i found the implementation of the Observer Pattern ( see the GoF book for more information on this pattern) in the two classes - namely Observer.java and Observable.java. i would like to throw some lights on these two classes. These two classes can be found in the Java\j2se\src\share\classes\java\util folder of the JDK source code.

Before explaining the application of Observer Pattern in Java, let me give you a brief introduction of this pattern. Observer pattern helps you in notifying and updating all the dependent objects, if one object changes state. This pattern has two main objects – Subject and Observer. Multiple number of observers can be attached to a particular Subject. All the observers are notified and in turn gotten updated if the Subject changes its state. This is also known as the publish-subscribe. The subject is the publisher of changes, and the Observers are the subscribers to those changes.

The class diagram will look like the following.

And the sequence diagram of this pattern is like this.

What these two diagrams essentially depict is that in the Observer Pattern, we have a Subject, which can attach one or more Observers through its Attach() function. Whenever it changes its state it Notifies all the attached Observers through its Notify function. The observers in turn synchronize their states with that of the Subject through the GetSubjectState function.

Now let me try to dissect the Java observer pattern.

Let us first start with the Observable.java class. As the name suggests it is the class which will implemented functionalities for being observed. Or in other words it is the class which helps in designing the Subject class of the Observer pattern discussion of the GoF book. We need to extend this class to get the Subject class.

Let us try to dissect this class. The following functions are there in this class:

Data Members: It has a vector to hold all the observers that are interested in observing this observable class. It has another boolean data member called "changed" to indicate if anything has changed in the Subject class ( which will be derived from this Observable class).

Constructor : This class has a no argument constructor to construct an empty vector of Observers.

Member Functions :
addObserver : To add an observer to its list of Observers.

deleteObserver : To delete a particular observer from the list of the observers

notifyObservers : there are two overloaded versions of this function. One takes an Object parameter as an argument and the other does not take any argument. The task of this function is to notify all the attached observers when any data of the subject gets changed. To check whether the data is changed it evaluates the boolean "changed" data member. This function also calls the update function of each observer objects to ask them to get in sync with the subject's changed state. The overloaded version that takes an one argument parameter is used to let the observers know about which attribute is changed. And the other version of this function which does not take any argument does not let the observer know about which attribute is changed.

deleteObservers : This function removes all the observers attached to this subject.

setChanged : This function sets the boolean data member "changed".

clearChanged : This function resets the boolean data member "changed".

hasChanged : This function helps us to know whether the data of the subject has been changed or not.

countObservers : This function returns the number of observers attached to this subject.

This is all about the Observable class which helps us to define to Subject class.

The Observer.java defines an interface called Observer having just one abstract function called update (Observable o, Object arg). As the name suggests, the Observer class that will implement this interface will override the update function to set the attribute passed as an argument (arg) from the Subject class. This method is called whenever any attribute in the Subject class gets changed.

Now let us try to see an example to understand how this Observer Pattern is used.

Let us first extend the Observable class to create the Subject class.

import java.util.Observable;

public class Subject extends Observable {
private String name;
private float price;

public Subject(String name, float price) {
this.name = name;
this.price = price;
}

public String getName() {return name;}

public float getPrice() {return price;}

public void setName(String name) {
this.name = name;
setChanged();
notifyObservers(name);
}

public void setPrice(float price) {
this.price = price;
setChanged();
notifyObservers(new Float(price));
}
}

As this is clear from the implementation of the Subject class, that whenever we call the setter function to change the attributes of the Subject's object, we call the notifyObservers and pass that attribute as a parameter.

Now let us see how we create two different observers namely NameObserver and PriceObserver to observe these two attributes of the Subject class.

// An observer of name changes.

import java.util.Observable;
import java.util.Observer;

public class NameObserver implements Observer {
private String name;

public NameObserver() {
name = null;
System.out.println("NameObserver created: Name is " + name);
}

public void update(Observable obj, Object arg) {

if (arg instanceof String) {
name = (String)arg;
System.out.println("NameObserver: Name changed to " + name);
}
}
}

// An observer of price changes.

import java.util.Observable;
import java.util.Observer;

public class PriceObserver implements Observer {
private float price;
public PriceObserver() {
price = 0;
System.out.println("PriceObserver created: Price is " + price);
}

public void update(Observable obj, Object arg) {
if (arg instanceof Float) {
price = ((Float)arg).floatValue();
System.out.println("PriceObserver: Price changed to " +
price);
}
}
}

As it has become clear from the above two implementations that the update function actually helps in synchronizing the state of the concrete observers with that of the Subject.

Now the client of the Observer framework will look like the following :

// Test program for Subject, NameObserver and PriceObserver
public class TestObservers {

public static void main(String args[]) {

// Create the Subject and Observers.
Subject s = new Subject("Corn Pops", 20.5f);
NameObserver nameObs = new NameObserver();
PriceObserver priceObs = new PriceObserver();

// Add those Observers!
s.addObserver(nameObs);
s.addObserver(priceObs);

// Make changes to the Subject.
s.setName("Frosted Flakes"); // It prints NameObserver: Name changed to Frosted Flakes

s.setPrice(30.6f); //It prints PriceObserver: Price changed to 30.6

s.setPrice(50.8f); //It prints PriceObserver: Price changed to 50.8

s.setName("Sugar Crispies"); // It prints NameObserver: Name changed to Sugar Crispies
}
}

Hope the above discussion will help people understand of how the Java supports implementing the Observer pattern.

Bridge Pattern

2009-03-12T17:38:00.000+05:30

Android Widget - through Java Code

2009-01-25T16:12:00.000+05:30

There are two ways to create android resources/view - either through the XML layout or through pure java code. In this article I have tried to implement the android view through the second method - i.e. through Java code. I have implemented a Table Layout and few widgets like static text, edit box and slider bar. There are three sets of all these widgets - namely Red, Green and Blue. These three are the percentage of the RGB color code. For example if we make Red as 100, and Green and Blue as 0, it will paint the background of the device with Red. It has also shown how to create a prompt dialog when you enter a value more than 100 in any of the edit boxes.

The application will look like the following:

The code for this application is as follow -

import android.app.Activity;
import android.app.AlertDialog;
import android.content.DialogInterface;
import android.content.pm.ActivityInfo;
import android.graphics.Color;
import android.os.Bundle;
import android.view.View;
import android.view.ViewGroup.LayoutParams;
import android.widget.Button;
import android.widget.EditText;
import android.widget.LinearLayout;
import android.widget.SeekBar;
import android.widget.TableLayout;
import android.widget.TextView;
import android.widget.SeekBar.OnSeekBarChangeListener;

public class Widget extends Activity implements View.OnClickListener /*, View.OnKeyListener */{
/** Called when the activity is first created. */

private final static int idLayout = 1;
private final static int idTitle = 2;

private final static int idTextRed = 3;
private final static int idTextGreen = 4;
private final static int idTextBlue = 5;

private final static int idEditRedText = 6;
private final static int idEditGreenText = 7;
private final static int idEditBlueText = 8;

private final static int idSeekBarRed = 9;
private final static int idSeekBarGreen = 10;
private final static int idSeekBarBlue =11;

private final static int idButtonOK = 12;

private final static int MaxColorValue = 255;

private int RedProgress = 0;
private int GreenProgress = 0;
private int BlueProgress = 0;

private int RedValue = 0;
private int GreenValue = 0;
private int BlueValue = 0;

@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);

setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);

TableLayout layout = new TableLayout(this);
layout.setId(idLayout);
layout.setLayoutParams(
new LayoutParams(LayoutParams.FILL_PARENT,android.view.ViewGroup.LayoutParams.FILL_PARENT));
layout.setFocusable(true);

TextView title = new TextView(this);
title.setText(R.string.title);
title.setLayoutParams(
new LinearLayout.LayoutParams(
LinearLayout.LayoutParams.FILL_PARENT,
LayoutParams.WRAP_CONTENT));
//title.s(Alignment.ALIGN_CENTER);
title.setId(idTitle);
layout.addView(title,0);

//For Item 1
TextView ItemRed = new TextView(this);
ItemRed.setFocusable(true);
ItemRed.setText("% RED");
ItemRed.setTextColor(Color.LTGRAY);
ItemRed.setLayoutParams(
new TableLayout.LayoutParams(
TableLayout.LayoutParams.FILL_PARENT, TableLayout.LayoutParams.WRAP_CONTENT));

//Give the menu item an ID for tracking reasons.
//The ID is a static int defined locally to the class
ItemRed.setId(idTextRed);
//Add it to our linear layout
layout.addView(ItemRed, 1);

EditText EditTextRed = new EditText(this);
EditTextRed.setFocusable(true);
EditTextRed.setLayoutParams(
new TableLayout.LayoutParams(TableLayout.LayoutParams.FILL_PARENT, TableLayout.LayoutParams.WRAP_CONTENT));
EditTextRed.setId(idEditRedText);

layout.addView(EditTextRed, 2);

SeekBar SeekBarRed = new SeekBar(this);
SeekBarRed.setFocusable(true);
SeekBarRed.setLayoutParams(
new TableLayout.LayoutParams(TableLayout.LayoutParams.FILL_PARENT, TableLayout.LayoutParams.WRAP_CONTENT));
SeekBarRed.setMax(MaxColorValue);
SeekBarRed.setId(idSeekBarRed);

layout.addView(SeekBarRed, 3);

//For item 2
TextView ItemGreen = new TextView(this);
ItemGreen.setFocusable(true);
ItemGreen.setText("% GREEN");
ItemGreen.setTextColor(Color.LTGRAY);
ItemGreen.setLayoutParams(
new TableLayout.LayoutParams(
TableLayout.LayoutParams.FILL_PARENT, TableLayout.LayoutParams.WRAP_CONTENT));

//Give the menu item an ID for tracking reasons.
//The ID is a static int defined locally to the class
ItemGreen.setId(idTextGreen);
//Add it to our linear layout
layout.addView(ItemGreen, 4);

EditText EditTextGreen = new EditText(this);
EditTextGreen.setFocusable(true);
EditTextGreen.setLayoutParams(
new TableLayout.LayoutParams(TableLayout.LayoutParams.FILL_PARENT, TableLayout.LayoutParams.WRAP_CONTENT));
EditTextRed.setId(idEditGreenText);

layout.addView(EditTextGreen, 5);

SeekBar SeekBarGreen = new SeekBar(this);
SeekBarGreen.setFocusable(true);
SeekBarGreen.setLayoutParams(
new TableLayout.LayoutParams(TableLayout.LayoutParams.FILL_PARENT, TableLayout.LayoutParams.WRAP_CONTENT));
SeekBarGreen.setMax(MaxColorValue);
SeekBarGreen.setId(idSeekBarGreen);
layout.addView(SeekBarGreen, 6);

TextView ItemBlue = new TextView(this);
ItemBlue.setFocusable(true);
ItemBlue.setText("% BLUE");
ItemBlue.setTextColor(Color.LTGRAY);
ItemBlue.setLayoutParams(
new TableLayout.LayoutParams(
TableLayout.LayoutParams.FILL_PARENT, TableLayout.LayoutParams.WRAP_CONTENT));

//Give the menu item an ID for tracking reasons.
//The ID is a static int defined locally to the class
ItemBlue.setId(idTextBlue);
//Add it to our linear layout
layout.addView(ItemBlue, 7);

EditText EditTextBlue = new EditText(this);
EditTextBlue.setFocusable(true);
EditTextBlue.setLayoutParams(
new TableLayout.LayoutParams(TableLayout.LayoutParams.FILL_PARENT, TableLayout.LayoutParams.WRAP_CONTENT));
EditTextBlue.setId(idEditBlueText);

layout.addView(EditTextBlue, 8);

SeekBar SeekBarBlue = new SeekBar(this);
SeekBarBlue.setFocusable(true);
SeekBarBlue.setLayoutParams(
new TableLayout.LayoutParams(TableLayout.LayoutParams.FILL_PARENT, TableLayout.LayoutParams.WRAP_CONTENT));
SeekBarBlue.setMax(MaxColorValue);
SeekBarBlue.setId(idSeekBarBlue);
layout.addView(SeekBarBlue, 9);

Button OKBtn = new Button(this);
OKBtn.setFocusable(true);
OKBtn.setLayoutParams(
new TableLayout.LayoutParams(TableLayout.LayoutParams.FILL_PARENT, TableLayout.LayoutParams.WRAP_CONTENT));
OKBtn.setId(idButtonOK);
OKBtn.setText("OK");
layout.addView(OKBtn,10);

setContentView(layout);

OKBtn.setOnClickListener(this);

SeekBarRed.setOnSeekBarChangeListener(OnSeekBarProgress);
SeekBarGreen.setOnSeekBarChangeListener(OnSeekBarProgress);
SeekBarBlue.setOnSeekBarChangeListener(OnSeekBarProgress);
}

OnSeekBarChangeListener OnSeekBarProgress =
new OnSeekBarChangeListener() {

public void onProgressChanged(SeekBar s, int progress, boolean touch){

if(touch){
TableLayout layout = (TableLayout)s.getParent();

EditText Red = (EditText)layout.getChildAt(2);
EditText Green = (EditText)layout.getChildAt(5);
EditText Blue = (EditText)layout.getChildAt(8);

if(s.getId()== idSeekBarRed ){
RedProgress = progress;
Red.setText(Integer.toString(RedProgress*100/254));
}

if(s.getId()== idSeekBarGreen ){

GreenProgress = progress;
Green.setText(Integer.toString(GreenProgress*100/254));
}

if(s.getId()== idSeekBarBlue ){

BlueProgress = progress;
Blue.setText(Integer.toString(BlueProgress*100/254));
}

int color = Color.rgb(RedProgress, GreenProgress, BlueProgress);
layout.setBackgroundColor(color);

}
}

public void onStartTrackingTouch(SeekBar s){

}

public void onStopTrackingTouch(SeekBar s){

}
};

public void onClick(View v){

Button b = (Button)v;

if(b.getId() == idButtonOK){

TableLayout layout = (TableLayout)(v.getParent());

EditText Red = (EditText)layout.getChildAt(2);
EditText Green = (EditText)layout.getChildAt(5);
EditText Blue = (EditText)layout.getChildAt(8);

SeekBar SeekBarRed = (SeekBar)layout.getChildAt(3);
SeekBar SeekBarGreen = (SeekBar)layout.getChildAt(6);
SeekBar SeekBarBlue = (SeekBar)layout.getChildAt(9);

String RedText = Red.getText().toString();
String GreenText = Green.getText().toString();
String BlueText = Blue.getText().toString();

if(!("".equals(RedText))) {
try {
RedValue = Integer.parseInt(RedText);
}
catch (NumberFormatException e) {
}
}
else
RedValue = 0;

if(!("".equals(GreenText))) {
try {
GreenValue = Integer.parseInt(GreenText);
}
catch (NumberFormatException e) {
}
}
else
GreenValue = 0;

if(!("".equals(BlueText))) {
try {
BlueValue = Integer.parseInt(BlueText);
}
catch (NumberFormatException e) {
}
}
else
BlueValue = 0;

if( RedValue>=0 && RedValue<=100) {
RedProgress = 254*RedValue/100;
SeekBarRed.setProgress(RedProgress);
}

else {
new AlertDialog.Builder(this)
.setTitle("Alert!")
.setMessage("Please enter a value between 0 and 100 for RED...")
.setNeutralButton("Close", new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dlg, int sumthin) {
// do nothing – it will close on its own
}
})
.show();
}

if( GreenValue>=0 && GreenValue<=100) {
GreenProgress = 254*GreenValue/100;
SeekBarGreen.setProgress(GreenProgress);
}

else {
new AlertDialog.Builder(this)
.setTitle("Alert!")
.setMessage("Please enter a value between 0 and 100 for GREEN...")
.setNeutralButton("Close", new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dlg, int sumthin) {
// do nothing – it will close on its own
}
})
.show();
}

if(BlueValue>=0 && BlueValue<=100) {
BlueProgress = 254*BlueValue/100;
SeekBarBlue.setProgress(BlueProgress);
}

else {
new AlertDialog.Builder(this)
.setTitle("Alert!")
.setMessage("Please enter a value between 0 and 100 for BLUE...")
.setNeutralButton("Close", new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dlg, int sumthin) {
// do nothing – it will close on its own
}
})
.show();
}

int color = Color.rgb(RedProgress, GreenProgress, BlueProgress);
layout.setBackgroundColor(color);

}

};
}

Play around with it.

Feel happy to work in Android...

Composite Design Pattern

2008-12-04T06:52:00.002+05:30

Composite design pattern is a structural pattern in which we compose the whole-part relationship in a symmetric hierarchy. The client of the composite treats all the objects in the same fashion.
The whole concept of this design pattern lies in the fact that we can treat a composite object which consists of several other objects the same way as a leaf object. The client never knows that it is working on an object which has many other objects inside it.

Let us try to understand the composite pattern with an example. Here we have defined a class namely Shape, which is acting as the root of all the objects in the example. We have put all the basic functionalities of a graphical object in this class. These functions are Add (for adding a component), Remove (for removing a component), GetChild (for getting a pointer to a child), GetParentOfComponent (which will return the parent of a component) and Draw (to draw a component).

#include (iostream)
#include (vector)
#include (map)

using namespace std;

class Shape
{
public:
Shape(){}
virtual void Add(unsigned int id)
{
throw LeafClassTypeException();
};
virtual void Remove(unsigned int id){};

//leaf classes will not override it..however, it will be overridden by the composite class.
virtual Shape* GetChild(unsigned int id)
{
throw LeafClassTypeException();
};

//Using this reference the "Chain of Responsibility" can be implemented
virtual Shape* GetParentOfComponent()
{
return ParentOfComponent;
};

virtual void SetParentOfComponent(Shape* s)
{
ParentOfComponent = s;
}

virtual void Display(){};

virtual Shape* FindItem(unsigned int id); //implementation afterwards

virtual ~Shape(){};

protected:
Shape* ParentOfComponent;
unsigned int resource_id;
};

typedef map (unsigned int, Shape*, less(unsigned int) ) theMap;

theMap Resource_Map;
theMap::iterator theIterator;

Shape* Shape::FindItem(unsigned int id)
{
theIterator = Resource_Map.begin();
while (theIterator != Resource_Map.end())
{
theIterator = Resource_Map.find(id);
Shape* s = (*theIterator).second;
theIterator++;
return s;
}

return NULL;
}

Now from the Shape class, we have derived other graphic classes, like Point, Line and Rectangle. Among these classes, class Point is working as an helper class to define classes like Line and Rectangle. We have deduced another class called Picture which is composed of these component classes.

class Point : public Shape
{
public:
Point():x_Coord(0),y_Coord(0){}
Point(int x, int y):x_Coord(x), y_Coord(y){}
Point(const Point& p)
{
x_Coord = p.x_Coord;
y_Coord = p.y_Coord;
}
Point& operator = (const Point& p)
{
x_Coord = p.x_Coord;
y_Coord = p.y_Coord;

return *this;
}

virtual void Display()
{
cout(("X Coordinate is:"((x_Coord((endl;
cout(("Y Coordinate is:"((y_Coord((endl;
}

int X_COORD()
{
return x_Coord;
}

int Y_COORD()
{
return y_Coord;
}

virtual ~Point(){}
private:
int x_Coord;
int y_Coord;
};

class Line : public Shape
{
private:
Line(unsigned int id):begin(0,0),end(0,0)
{
resource_id = id;
Resource_Map.insert(theMap::value_type(resource_id,(Shape*)this));
}

Line(unsigned int id, Point a, Point b):begin(a),end(b)
{
resource_id = id;
Resource_Map.insert(theMap::value_type(resource_id,(Shape*)this));
}

public:
virtual void Display()
{
cout(("Begining point is:";
begin.Display();
cout(("End Point is:";
end.Display();
}
static Line* CreateLine(unsigned int id, Point a, Point b)
{
return new Line(id,a,b);
}

virtual ~Line(){}
private:
Point begin;
Point end;
};

class Rectangle : public Shape
{
private:
Rectangle(unsigned int id, Point& p, int width, int height)
{
top_left = p;
top_right = Point(p.X_COORD() + width, p.Y_COORD());
bottom_left = Point(p.X_COORD() , p.Y_COORD() + height);
bottom_right = Point(p.X_COORD() + width, p.Y_COORD() + height);
resource_id = id;
Resource_Map.insert(theMap::value_type(resource_id,(Shape*)this));

}

public:
static Rectangle* CreateRectange(unsigned int id, Point& p, int width, int height)
{
return new Rectangle(id, p, width, height);

}
virtual ~Rectangle(){}
virtual void Display()
{
cout(("The four vertices are:"((endl;
cout(("Top Left :" ;
top_left.Display();
cout (("Top Right :";
top_right.Display();
cout(("Bottom Left :";
bottom_left.Display();
cout(("Bottom Right :";
bottom_right.Display();

}

//Attributes
private:
Point top_left;
Point top_right;
Point bottom_left;
Point bottom_right;
};

The interesting point here is that, we have tried to implement the leaf classes, namely Line and Rectangle as final classes by making their constructors private and providing static member functions to create them.

The Picture class is composed of these leaf objects (Line and Rectangle).

class Picture : public Shape
{
public:
Picture(unsigned int id)
{
resource_id = id;
Resource_Map.insert(theMap::value_type(resource_id,(Shape*)this));
}
virtual void Display()
{
vector(Shape*)::iterator p = Components.begin();
while (p != Components.end())
{
(*p)-)Display();
p++;
}
}

//Adds the component with the resource id equal to the passed parameter
virtual void Add (unsigned int id)
{
Shape* s = FindItem(id);

Components.push_back(s);

s-)SetParentOfComponent(this);

}

//removes the component from the list with the resource_id equal to the parameter passed
virtual void Remove(unsigned int id)
{
Shape* s = FindItem(id);
vector(Shape*)::iterator p = Components.begin();
int pos = 0;
while (p != Components.end())
{
if(Components.at(pos) == s)
break;
pos++;
p++;
}
Components.erase(p);
s-)SetParentOfComponent(NULL);
}

//will return the chile having the id equal to the passed value.
virtual Shape* GetChild (unsigned int id)
{
return FindItem(id);
}

virtual ~Picture()
{
vector(Shape*)::iterator p = Components.begin();

int pos = 0;
while (p != Components.end())
{
delete(Components.at(pos));
p++;
pos++;
}

Components.clear();
}
private:
vector(Shape*) Components;
};

The Shape class is called as the Component class, the Line and Rectangle classes are called the Leaf classes and the Picture class is called the Composite class.

Another interesting part of the example is that here every component is identifiable through its resource id. Whenever we create an object (leaf or composite object), it creates a key pair of the id and the pointer to that object and pushes this key into a MAP, from which we can easily search for that component in later times through its resource id.

There are many issues to consider when implementing the composite pattern.

We have defined one function called GetParentOfComponent. This can be useful to traverse the whole hierarchy of parent-child relationship. We have to make sure that any child can have only a composite object as its parent. We have ensured it by defining an Exception class which will be thrown the moment we want to add a component to a leaf object. The exception class can be defined as follows:
class LeafClassTypeException
{
public:
void printerrormsg()
{
cout(("This is a leaf class"((endl;
}
};
It should be noted that the functions like Add and Remove have been defined in the root class. Although for leaf classes, it does not do any meaningful things except throwing an exception, but it gives us transparency, because we can treat all components uniformly.
If we define these functions at the composite class level, then it would give the safety, because any attempt to Add or Remove from the leaf classes would give compile time error, but we would loose the transparency. The composite and the leaf classes will have different interfaces in this case.

The main participants in this design pattern are
Component (Shape) : It basically works as an abstract class which provides a common interface which will be used by the client to treat different classes uniformly. The common functionalities (e.g. Display) have been defined here. Other functionalities like Add, Remove, etc have been put in this class to maximize the role of this interface. The default behavior for Add and Remove has been implemented in such a fashion that for a leaf class, these functions will throw exceptions.
Leaf (Line, Rectangle, etc) : It represents a leaf objects in the composition. Leaf objects cannot have any children.
Composite (Picture) : It stores child components.
Client: It manipulates the objects through the common interface exposed by the Component class.

Test Driven Development

2008-11-14T05:00:00.001+05:30