Any new technology needs a good “Hello World” example, bada shall not be an exemption. From a source I have received a sample “Hello World” app. Here it comes…

First thing you have to be familiar with is the c++ programming language. The example code provided here has been developed on the Visual Studio 2005 platform + bada wizard and tested with the bada simulator. The following files are observed:

• HelloWorld.h
• HelloWorld.cpp
• HelloWorldEntry.cpp

There are also two XML files in the project called application.xml and manifest.xml. Those will not be subject of this post though.

First things first – you need a central class for your application. Let’s start with its header.

HelloWorld.h

#ifndef __HELLOWORLD_H__
#define __HELLOWORLD_H__

#include <FBase.h>
#include <FGraphics.h>;
#include <FLocales.h>
#include <FSystem.h>
#include <FApp.h>

using namespace Osp::Base;
using namespace Osp::Graphics;
using namespace Osp::Locales;
using namespace Osp::System;
using namespace Osp::App;

class HelloWorld :
	public Application // must inherit from Application class
{
public:
	// The application must have a factory method that creates an instance of the application.
	static Application* CreateInstance(void);

public:
	HelloWorld();
	~HelloWorld();

public:
	// The application must provide its name.
	String GetAppName(void) const;

protected:
	// The application must provide its ID.
	AppId GetAppId(void) const;

	AppSecret GetAppSecret(void) const;

public:
	// This method is called when the application is initializing.
	bool OnAppInitializing(AppRegistry& appRegistry);

	// This method is called when the application is terminating.
	bool OnAppTerminating(AppRegistry& appRegistry);

	// Thie method is called when the application is brought to the foreground
	void OnForeground(void);

	// This method is called when the application is sent to the background.
	void OnBackground(void);

	// This method is called when the application has little available memory.
	void OnLowMemory(void);

	// This method is called when the device's battery level changes.
	void OnBatteryLevelChanged(BatteryLevel batteryLevel);
};

#endif

Most of the stuff in this header file should be self-explanatory, especially for those of us who work frequently with c++. There are a few things to note though.

There is a bunch of different headers you will want to use in almost any app.  These are, e.g.:

• Base - basic features and interfaces (especially bada-specific datatypes)
• Graphics – allows drawing on the screen (note that these are plain low-level drawing operations – User Interface features are in another package called Osp::UI)
• Locales – for culture-related features/information (e.g. for correct date, currency and number formats)
• System – For basic system interaction (e.g. alarms, battery levels, etc.)
• App – allows you to manage your own application and its settings as well as starting and running other apps

The class of your application must inherit from the Application class defined somewhere within the Osp::App namespace. This also assumes that your class must implement some functions, like:

• A static factory function that returns instances of the application’s class
• A constructor and a destructor function
• Some basic information functions that return the name, id or the secret code of your app
• Some obligatory event handlers that are called on important events like the application start or change in the battery levels.

This is the minimum skeleton of any application you will develop under bada.

The definitions are also straight forward:

HelloWorld.cpp

#include "HelloWorld1.h"

HelloWorld1::HelloWorld()
{
}

HelloWorld1::~HelloWorld()
{
}

Application*
HelloWorld::CreateInstance(void)
{
	// You can create the instance through another constructor.
	return new HelloWorld();
}

String
HelloWorld::GetAppName(void) const
{
	static String appName(L"HelloWorld");
	return appName;
}

AppId
HelloWorld::GetAppId(void) const
{
	static AppId appId(L"93bt1p123e");
	return appId;
}

AppSecret
HelloWorld::GetAppSecret(void) const
{
	static AppSecret appSecret(L"9C645DDBA19C71BAD1204DA4DAA7A0B9");
	return appSecret;
}

bool
HelloWorld::OnAppInitializing(AppRegistry& appRegistry)
{
	// TODO:
	// Initialization including UI construction can be done here.
	// Load the application's latest data, if necessary.
	// If this method is successful, return true; otherwise, return false.
	return true;
}

bool
HelloWorld::OnAppTerminating(AppRegistry& appRegistry)
{
	// TODO:
	// Deallocate or close any resources still alive.
	// Save the application's current states, if applicable.
	// If this method is successful, return true; otherwise, return false.
	return true;
}

void
HelloWorld::OnForeground(void)
{
	result r = E_SUCCESS;

	Canvas* pCanvas = GetAppFrame()->GetCanvasN();
	if(pCanvas == null)
		return;

	Font* pFont = new Font();
	pFont->Construct(FONT_STYLE_PLAIN | FONT_STYLE_BOLD, 50);
	pCanvas->SetFont(*pFont);

	r = pCanvas->DrawText(Point(30, 30), GetAppName());
	if (IsFailed(r))
	{
		AppLog("pCanvas->DrawText() failed.\n");
		delete pCanvas;
		return;
	}

	r = pCanvas->Show();
	if (IsFailed(r))
	{
		AppLog("pCanvas->Show() failed.\n");
		delete pCanvas;
		return;
	}

	delete pCanvas;

}

void
HelloWorld::OnBackground(void)
{
}

void
HelloWorld::OnLowMemory(void)
{
	// TODO:
	// Deallocate as many resources as possible.
}

void
HelloWorld::OnBatteryLevelChanged(BatteryLevel batteryLevel)
{
	// TODO:
	// It is recommended that the application save its data,
	// and terminate itself if the application consumes much battery
}

There is probably nothing to explain here, seems simple and straight to the point. Finally you need an entrance point of the app (like main(…)). This is done in a separate file:

HelloWorldEntry.cpp

/**
* OSP Application entry point(OspMain) introduced.
*/
#include <fapp.h>
#include "HelloWorld.h"

using namespace Osp::Base::Collection;

extern "C"
{
	__declspec(dllexport) void OspMain(int hInstance, int argc, char *argv[]);
}

/**
* Entry function of OSP Application which is called by the operating system.
*/
extern "C" {
void OspMain(int hInstance, int argc, char *argv[])
{
	AppLog("OspMain() Started. \n");

	result r = E_SUCCESS;

	ArrayList* pArgs = new ArrayList();
	pArgs->Construct();
	for (int i = 0; i < argc; i++)
	{
		String* pEachArg = new String(argv[i]);
		pArgs->Add(*pEachArg);
	}

	r = Osp::App::Application::Execute(HelloWorld::CreateInstance, pArgs);
	if (IsFailed(r))
	{
		AppLog("Application execution has failed.\n");
	}

	if (pArgs)
	{
		pArgs->RemoveAll(true);
		delete pArgs;
	}

	AppLog("OspMain() Ended. \n");
}
}

Interesting points to note here. The OspMain(), which is the main entrance point called by the bada OS, has to be exported (made visible/callable by the outside world) through the __declspec(dllexport) call.  Another interesting thing are the arguments passed to the program. I suspect that you can pass some data here if you start an app from another app. These arguments are stored in an ArrayList, one of bada datatypes defined in Osp::Base namespace.

Finally you see where exactly the factory method of HelloWorld class is used to start the execution of the app.

So there it is! I couldn’t test it myself, since I do not have an SDK, so bear with me, if I have made false assumptions somewhere. Nevertheless, I guess this is enough to get a first taste!

Related posts:

1. Bada sample project: Simple Greeting
2. Forms Management in Bada (part 3) – Managing Forms
3. Bada Tutorial: UI Lists (part 2) – Custom List