In this post we’re going to see how to implement search functionality to search for entries stored in a databaseand display them in a ListView.

Creating database:

our database has two tables: Countries and Names:

public class DBHelper extends SQLiteOpenHelper {

	public DBHelper(Context context) {
		super(context, "DemoDB", null, 1);
	}

	@Override
	public void onCreate(SQLiteDatabase db) {
		StringBuilder builder=new StringBuilder();
		// countries table
		builder.append("CREATE TABLE Countries ");
		builder.append("(_id INTEGER PRIMARY KEY AUTOINCREMENT,");
		builder.append("NAME TEXT) ");
		db.execSQL(builder.toString());
		// Names table
		// Virtual table for full text search
		builder.setLength(0);
		builder.append("CREATE VIRTUAL TABLE NAMES USING FTS3");
		builder.append("(");
		builder.append("name TEXT) ");		
		db.execSQL(builder.toString());
		builder=new StringBuilder();

		//dummy  data
		InsertData(db);

	}

	 void InsertData(SQLiteDatabase db)
	 {
		 ContentValues cv=new ContentValues();
			cv.put("NAME","USA");
			db.insert("Countries", "NAME", cv);
			cv.put("NAME","UK");
			db.insert("Countries", "NAME", cv);
			cv.put("NAME","Spain");
			db.insert("Countries", "NAME", cv);
			cv.put("NAME","ITALY");
			db.insert("Countries", "NAME", cv);
			cv.put("NAME","Germany");
			db.insert("Countries", "NAME", cv);

			 cv=new ContentValues();
				cv.put("name","John");
				db.insert("NAMES", "name", cv);
				cv.put("name","Jack");
				db.insert("NAMES", "name", cv);
				cv.put("name","Ann");
				db.insert("NAMES", "name", cv);
				cv.put("name","Adam");
				db.insert("NAMES", "name", cv);
				cv.put("name","Sarah");
				db.insert("NAMES", "name", cv);

	 }

	@Override
	public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
		// TODO Auto-generated method stub

	}
}

notice that the Names table is a VIRTUAL table. we created it as virtual to make use of Full Text Search (FTS3) feature in SQLite. this feature makes queries faster than that in regular tables.

then we add two functions to retrieve all rows from both tables:

/**
	 * Return all countries
	 * @return
	 */
	public ArrayListgetCountries(){
		ArrayList countries=new ArrayList();
		SQLiteDatabase db=this.getReadableDatabase();
		Cursor c=db.rawQuery("select * from Countries", null);
		while(c.moveToNext()){
			String country=c.getString(1);
			countries.add(country);
		}
		c.close();
		return countries;
	}
/**
	 * Return all names
	 * @return
	 */

	public ArrayListgetNames(){
		ArrayList names=new ArrayList();
		Cursor c=this.getReadableDatabase().rawQuery("select * FROM Names", null);
		while(c.moveToNext()){
			String name=c.getString(0);
			names.add(name);
		}
		c.close();
		return names;
	}

and another two functions to retrieve data based on a search string:

/**
	 * Return all countries based on a search string
	 * @return
	 */
	public ArrayListgetCountriesSearch(String query){
		ArrayList countries=new ArrayList();
		SQLiteDatabase db=this.getReadableDatabase();
		Cursor c=db.rawQuery("select * from Countries where NAME LIKE '%"+query+"%'", null);
		while(c.moveToNext()){
			String country=c.getString(1);
			countries.add(country);
		}
		c.close();
		return countries;
	}
/**
	 * Return all names based on a search string
	 * we use the MATCH keyword to make use of the full text search
	 * @return
	 */
	public ArrayListgetNamesSearch(String query){
		ArrayList names=new ArrayList();
		Cursor c=this.getReadableDatabase().rawQuery("select * FROM Names WHERE name MATCH '"+query+"'", null);
		while(c.moveToNext()){
			String name=c.getString(0);
			names.add(name);
		}
		c.close();
		return names;
	}

Implementing The activity:

then we will create our activity that has a list view like this:

<?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"
    >
<ListView
android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:id="@+id/list"/>
</LinearLayout>

we load data from database like this:

public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        list=(ListView)findViewById(R.id.list);

            DBHelper helper=new DBHelper(this);
            ArrayList items=helper.getNames();
            ArrayAdapter adapter=new ArrayAdapter(this, android.R.layout.simple_list_item_1,items);
            list.setAdapter(adapter);
}

Handling the search dialog:

In order to handle the search dialog ourselves we need to create a xml file with search configurations such as the search dialog title, voice search capabilities, content provider for auto complete and so on. we create a file with the name searchable.xml in res/xmldirectory:

<?xml version="1.0" encoding="utf-8"?>
<searchable xmlns:android="http://schemas.android.com/apk/res/android"
    android:label="@string/app_name"
    android:hint="@string/hint"  >
</searchable>

the android:hint attribute denotes a string that acts as a water mark on the search text box.
then we need to add an Intent Filter in out app’s AndroidManifest.xml file to our activity to handle the search dialog:

<activity android:name=".MainActivty"
                  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.SEARCH" />
        </intent-filter>
        <meta-data android:name="android.app.searchable"
                   android:resource="@xml/searchable"/>
        </activity>

Understanding the Search process:

when you press the search button, type some text and click on search the activit’s onSearchRequested() function is called, then an Intent with the action Intent.ACTION_SEARCH is created and you activity is re-created with this intent.
the search intent has you search string as a string extra with the name SearchManager.QUERY. also it can carry a bundle of other extras with the name SearchManager.APP_DATA.

what if the device doesn’t have a Search button:

not all Android devices have a search button, so we can start the search dialog manually by calling the activity’s onSearchRequested() from a button or a menu item:

@Override
    public boolean onCreateOptionsMenu(Menu menu) {
    	menu.add("Search").setOnMenuItemClickListener(new OnMenuItemClickListener() {

			@Override
			public boolean onMenuItemClick(MenuItem item) {
                                //launch the search dialog
				onSearchRequested();
				return true;
			}
		});
    	return true;
    }

adding extras to the search dialog:

we can pass some extra data as a bundle with our search dialog or an initial search string by overriding the activity’s onSearchRequested():

@Override
    public boolean onSearchRequested() {
    	Bundle bundle=new Bundle();
		bundle.putString("extra", "exttra info");
		// search initial query
		startSearch("Country", false, bundle, false);
		return true;
    }

Handling the search query:

we said before that the search query is passed as a String extra when our activity is re-created. so we can handle the searcgh string in our onCreate() like this:

@Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        list=(ListView)findViewById(R.id.list);

        DBHelper helper=new DBHelper(this);
        Intent intent=getIntent();
        // if the activity is created from search
        	if(intent.getAction().equals(Intent.ACTION_SEARCH)){
        		// get search query
        		String query=intent.getStringExtra(SearchManager.QUERY);
        		ArrayList items=helper.getNamesSearch(query);
        		//get extras, just for demonstration
        		Bundle bundle=intent.getBundleExtra(SearchManager.APP_DATA);
        	    String info=bundle.getString("extra");
        		Log.v("extra", info);
        		//bind the list
                ArrayAdapter adapter=new ArrayAdapter(this, android.R.layout.simple_list_item_1,items);
                list.setAdapter(adapter);
        	}
        //activity created normally
        else{
        	ArrayList items=helper.getNames();
            ArrayAdapter adapter=new ArrayAdapter(this, android.R.layout.simple_list_item_1,items);
            list.setAdapter(adapter);
        }
        helper.close();
    }

we just extract the search string and any other extras and perform our search logic based on the search string.
and that’s was all about implementing search, stay tuned for another Android tutorial

Dad to son: “Don’t spend it all in one place”

I remember as a child, although infrequently, receiving money from my parents for a number of reasons. Monetary reward would come from performing chores, good grades and birthday events. Receiving this fine coinage would always be accompanied with the phrase “Don’t spend it all in one place!”…. and while my father’s intentions really weren’t for me to spread my cash across multiple places, he did attempt to warn me against spending my money foolishly. Growing up my father was always delivering sound bites on money management regardless of how much they were ignored, but the point was eventually digested and I soon better understood how to spend my money. In the way that my father educated me, we as game developers need to educate our users on how to operate or “spend” money in the virtual game economies that we create.

Currency introduced through gameplay

The best way to teach is through action. Encourage your user to take action that requires spending virtual currency. Always reinforce the spending with a positive experience so that a user knows spending money is valuable. All successful simulation games on the mobile market today introduce currency as unique steps in their tutorial… or at least require it be used within the first few sessions of gameplay.

Quarters, Nickels and Dimes

Many games these days have multiple currency types know as premium (primary) currency and secondary currency. Primary currency typically is defined as being rare and tightly tied to real dollar value while secondary currency can be easy to earn and readily accessible. Depending on the game, you can choose to charge real dollars for both premium and secondary currencies or simply just premium. Make sure to introduce both currencies during game but do so separately. Be careful to introduce users to your currency all in one step or action. Spread out the introduction over a series of steps so that they can fully grasp how the decisions they make regarding their purchases affect gameplay.

Missions vs. Tutorial

Next week we will talk about the differences of missions vs. tutorials and the value each play in a mobile gaming environment.

Do you have a question about freemium gaming or a topic you’d like us to explore? Let us know in the comments or catch us on twitter @rechargestudios or @w3i.

Freemium Game Blogs are published in partnership with the series on W3i’s corporate blog.

Matt Tubergen heads Recharge Studios, a wholly owned subsidiary of W3i that invests in the development and marketing/distribution of freemium mobile games.  W3i is a market leader in distributing and monetizing apps with over 500 million apps distributed for W3i clients. Recharge Studios is actively seeking new investment opportunities, if you have a great idea for a game contact us.

AIDL is a java like language that enables you to define an interface that both the application defining the service and the client application implement it.

the interface defines the functions that are needed to be called in the client application.

Defining the AIDL file:

AIDL syntax is similar to that of Java, we can use the following data types in AIDL:

1. primitive data types: int, long, char, boolean,….
2. String.
3. CharSequence.
4. List (ArrayList,Vector,…).

1. the AIDL file is defined as follows:
   open a notepad file and paste the following code in it:

   package com.mina.servicedemo;
   
   // service interface
   interface IRemoteService {
       //sample method
       String sayHello(String message);
   }

   take care of the package name com.mina.servicedemo.
   we defined a methods sayHello(String message) that returns a string.

    

2. save the file with the name IRemoteService and change it’s extension to .aidl.
3. copy the file to the src folder of your project.
4. once you save and build the file, Android generates an interface java file with the name IRemoteService.java in the gen folder if the project.

Defining the Service:

now we want our service to expose this interface to client applications, so we return an implementation of the service in the onBind() method of our service:

package com.mina.servicedemo;

import com.mina.servicedemo.IRemoteService.Stub;

import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.os.RemoteException;
import android.widget.Toast;

public class DemoService extends Service {

	@Override
	public IBinder onBind(Intent arg0) {
		return mBinder;
	}

	// implementation of the aidl interface
	private final IRemoteService.Stub mBinder=new Stub() {

		@Override
		public String sayHello(String message) throws RemoteException {
			return "Hello "+message;

		}
	};

	}
}

the last thing to do in the service is to make its exported attribute in the AndroidManifest.xml file set to true like this:

<service android:name="DemoService" android:exported="true"></service>

our app structure can be like this:

Consuming the service at the client application:

now to our client application where we want to invoke methods from our service. the client application is a separate application with a different package name than that where the service is defined.

the client application needs a reference to the AIDL interface defined in the original applcation, this is done through the following steps:

1. in the client applicatio create a package with the same package name of that the service is defined in: com.mina.servicedemo.
2. copy the AIDL file in this package.
3. save and build and a new file called IRemoteService.java is generated. your app structure should be like this:

and we invoke the servcice methods in our activity like this:

package com.mina.serviceclient;

import com.mina.servicedemo.IRemoteService;

import android.app.Activity;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.os.RemoteException;
import android.util.Log;

public class MainActivity extends Activity {

	IRemoteService mRemoteService;

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

        Intent serviceIntent=new Intent();
        serviceIntent.setClassName("com.mina.servicedemo", "com.mina.servicedemo.DemoService");
        boolean ok=bindService(serviceIntent, mServiceConnection,Context.BIND_AUTO_CREATE);
        Log.v("ok", String.valueOf(ok));
    }

    private ServiceConnection mServiceConnection=new ServiceConnection() {

		@Override
		public void onServiceDisconnected(ComponentName name) {
			// TODO Auto-generated method stub

		}

		@Override
		public void onServiceConnected(ComponentName name, IBinder service) {
			// get instance of the aidl binder
			mRemoteService = IRemoteService.Stub.asInterface(service);
			try {
				String message=mRemoteService.sayHello("Mina");
				Log.v("message", message);
			} catch (RemoteException e) {
				Log.e("RemoteException", e.toString());
			}

		}
	};
}

and that’s was all about calling remote services with AIDL, stay tuned for another Android tutorial

we need to distinguish between A Service and a Thread or an AsyncTask: Threads or Async task perform their tasks in a background thread thus they do not block the main thread, while a service performs it’s work in the main thread. so if a service is performing an intensive task such as calling a web service, it may block the main thread until it finishes. So for intensive tasks a service should run it’s work in a background thread.

A service runs in the same process of the application and keeps running until stopped by itself, stopped by the user or killed by the system if it needs memory.

Creating a service:

to create a service we create a class that extends android.app.Service and it would be like this:

public class DemoService extends Service {

	@Override
	public IBinder onBind(Intent arg0) {
		// TODO Auto-generated method stub
		return null;
	}

}

next we need to define our service in our AndroidManifest.xml file:

<service android:name="DemoService"></service>

The service life cycle has the following events

• onCreate(): called when the service is created.
• onStart(): Called when the service starts by a call to startService(Intent intent).
• onDestroy(): Called as the service is terminates.

Calling a service:

A service can be called from an activity in two ways:

1. By calling startService(Intent intent).
2. By binding to the service through an Binder object.

calling startService(Intent intent):

to start a service from an activity using this method, we create an intent and start the service like this:

Intent intent=new Intent(this,DemoService.class);
startService(intent);

the startService(intent) method causes the onStart() method of the service to be called, so the service can execute it’s work like this:

public class DemoService extends Service {

	@Override
	public IBinder onBind(Intent arg0) {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public void onStart(Intent intent, int startId) {
		super.onStart(intent, startId);
		doSomething();
	}

	public void doSomething(){
		// do some work
	}

}

the service will keep running until it stops itself via stop stopSelf() after finishing work:

@Override
	public void onStart(Intent intent, int startId) {
		super.onStart(intent, startId);
		doSomething();
		stopSelf();
	}

or it can be stopped from the activity via stopService(Intent intent).

Binding to a service through an Binder object:

As the service runs in the same process of the application the service has only one instance (singleton) instance running. you may want to keep reference to this instance to perform periodical tasks or to call the service methods themselves.

to make the service bind-able we extends Binder class and return an instance of it in the service’s onBind(Intent intent) method:

public class DemoService extends Service {

	private final IBinder binder = new LocalBinder();
	@Override
	public IBinder onBind(Intent arg0) {
		return binder;
	}

	public class LocalBinder extends Binder {
		DemoService getService() {
            return DemoService.this;
        }
    }

	@Override
	public void onStart(Intent intent, int startId) {
		super.onStart(intent, startId);
		doSomething();
		stopSelf();
	}

	public void doSomething(){
		// do something
	}

}

then we bind the service from our activity by first creating a ServiceConnection object to handle the service connection/disconnection then binding to the service by an intent like this:

public class MainActivity extends Activity {

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

    ServiceConnection serviceConn=new ServiceConnection() {

                /**
                * service unbound, release from memory
                **/
		@Override
		public void onServiceDisconnected(ComponentName name) {
			mService=null;
		}

                /**
                * service is bound, start it's work
                **/
		@Override
		public void onServiceConnected(ComponentName name, IBinder service) {
			mService=((LocalBinder)service).getService();
			mService.doSomething();

		}
	};

    @Override
    protected void onResume() {
    	super.onResume();
        // bind to the service by an intent
    	Intent intent=new Intent(this,DemoService.class);
        // AUTO CREATE: creates the service and gives it an importance so that it won't be killed
        // unless any process bound to it (our activity in this case) is killed to
    	bindService(intent, serviceConn, Context.BIND_AUTO_CREATE);
    }

    @Override
    protected void onDestroy() {
    	super.onDestroy();
        / unbind the service whena ctivity is destroyed
    	unbindService(serviceConn);
    }
}

notice that we unbind the service in the activity’s onDestroy() method to disconnect from the service and stop it from executing any further

and that’s was all about Android services, stay tuned for another Android tutorial.

1. XML.
2. SOAP.
3. JSON.

Parsing XML

Android offers three types of XML parsers:

1. DOM Parser.
2. Pull Parser.
3. SAX Parser.

we’ll demonstrate each using the following xml example:

<?xml version="1.0"?>
<person>
    <firstname>Jack</firstname>
    <lastname>smith</lastname>
    <age>28</age>
</person>

which we need to parse to create an object from Person class:

public class Person{
    	public String firstName;
    	public String lastName;
    	public int age;
    }

Parsing the response with DOM Parser:

Android provides org.w3c.dom library that contains classes used to parse xml by constructing a document and
matching each node to parse the info.
to parse our example response with DOM parser, we implement a function like this

void parseByDOM(String response) throws ParserConfigurationException, SAXException, IOException{
    	Person person=new Person();
    	DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
    	DocumentBuilder db = dbf.newDocumentBuilder();
    	Document doc = db.parse(new InputSource(new StringReader(response)));
    	// normalize the document
    	doc.getDocumentElement().normalize();
    	// get the root node
    	NodeList nodeList = doc.getElementsByTagName("person");
    	Node node=nodeList.item(0);
    	// the  node has three child nodes
    	for (int i = 0; i < node.getChildNodes().getLength(); i++) {
    	Node temp=node.getChildNodes().item(i);
    	if(temp.getNodeName().equalsIgnoreCase("firstname")){
    		person.firstName=temp.getTextContent();
    	}
    	else if(temp.getNodeName().equalsIgnoreCase("lastname")){
    		person.lastName=temp.getTextContent();
    	}
    	else if(temp.getNodeName().equalsIgnoreCase("age")){
    		person.age=Integer.parseInt(temp.getTextContent());
    	}

    	}

    	Log.e("person", person.firstName+ " "+person.lastName+" "+String.valueOf(person.age));
    }

The previous method is good, it retrieves the info correctly, but it requires that you are familiar with the xml structure so that you know the order of each xml node.
luckily Android provides a better approach of parsing using SAX parser.

Parsing the response with SAX Parser:

Android provides org.xml.sax package that has that provides the event-driven SAX parser.
to parse the previous response with SAX parser, we have to create a class extending DefaultHandler and override the following methods:

1. startDocument(): invoked when the xml document is open, there we can initialize any member variables.
2. startElement(String uri, String localName, String qName, Attributes attributes): invoked when the parser encounters a xml node, here we can initialize specific instances of our person object.
3. endElement(String uri, String localName, String Name): invoked when the parser reaches the closing of a xml tag. here the element value would have been completely read.
4. characters(char[] ch, int start, int length): this method is called when the parser reads characters of a node value.

so our parsing class will be like this:

/*
	 * SAX parser to parse persons response
	 */
	public class PersonParser extends DefaultHandler
	{

		// arraylist to store person objects
		ArrayList persons;
		// temporary person object
		Person tempPerson;
		// string builder acts as a buffer
		StringBuilder builder;

		/**
		 * Initialize the arraylist
		 * @throws SAXException
		 */
		@Override
		public void startDocument() throws SAXException {
			pesons=new ArrayList();

		}

		/**
		 * Initialize the temp person object which will hold the parsed info
		 * and the string builder that will store the read characters
		 * @param uri
		 * @param localName
		 * @param qName
		 * @param attributes
		 * @throws SAXException
		 */
		@Override
		public void startElement(String uri, String localName, String qName,
				Attributes attributes) throws SAXException {

			if(localName.equalsIgnoreCase.equals("person")){
				tempPerson=new Person();
				builder=new StringBuilder();
			}

		}
		/**
		 * Finished reading the person tag, add it to arraylist
		 * @param uri
		 * @param localName
		 * @param qName
		 * @throws SAXException
		 */
		@Override
		public void endElement(String uri, String localName, String qName)
				throws SAXException {
			// finished reading a person, add it to the arraylist
			if(localName.toLowerCase().equals("person"))
			{
				this.persons.add(tempPerson);
			}
			// finished reading "firstname" tag assign it to the temp person
			else if(localName.toLowerCase().equals("firstname")){
				tempPerson.firstName=builder.toString();
			}
			// finished reading "lastname" tag assign it to the temp person
			else if(localName.toLowerCase().equals("lastname")){
				tempPerson.lastName=builder.toString();
			}
			// finished reading "age" tag assign it to the temp person
			else if(localName.toLowerCase().equals("age")){
				tempPerson.age=Integer.parseInt(builder.toString());
			}
		}

		/**
		 * Read the value of each tag
		 * @param ch
		 * @param start
		 * @param length
		 * @throws SAXException
		 */
		@Override
		public void characters(char[] ch, int start, int length)
				throws SAXException {
			// read the characters and append them to the buffer
			String tempString=new String(ch, start, length);
			 builder.append(tempString);
		}
	}

the code is pretty easy, the parser iterates over each node, you check the current node name and take an action.

then we call the parser like this:

 public ArrayList getPersons(final String response) throws ParserConfigurationException, SAXException, IOException
	{
		BufferedReader br=new BufferedReader(new StringReader(response));
		InputSource is=new InputSource(br);
		PersonParser parser=new PersonParser();
		SAXParserFactory factory=SAXParserFactory.newInstance();
   		SAXParser sp=factory.newSAXParser();
   		XMLReader reader=sp.getXMLReader();
   		reader.setContentHandler(parser);
   		reader.parse(is);
   		ArrayList persons=parser.persons;

		return persons;

	}

Parsing JSON respone:

what if our repspone was JSON instead of xml. it would be something like this:

"persons"
[
{
"person"{
"firstName": "John",
     "lastName": "Smith",
     "age": 25
}
}
{
"person"{
"firstName": "Catherine",
     "lastName": "Jones",
     "age": 35
}
}
]

this response is a JSON Array with the name “persons”, this array consists of “person” JSON Objects.
to parse such a reponse:

public ArrayList<Person> getMessage(String response){
		JSONObject jsonResponse;
		ArrayList<Person> arrPersons=new ArrayList<Person>;
		try {
			// obtain the reponse
			jsonResponse = new JSONObject(response);
			// get the array
			JSONArray persons=jsonResponse.optJSONArray("persons");
			// iterate over the array and retrieve single person instances
			for(int i=0;i<persons.length();i++){
				// get person object
				JSONObject person=persons.getJSONObject(i);
				// get first name
				String firstname=person.optString("firstname");
				// get last name
				String lastname=person.optString("lastname");
				// get the age
				int age=person.optInt("age");

				// construct the object and add it to the arraylist
				Person p=new Person();
				p.firstName=firstname;
				p.lastName=lastname;
				p.age=age;
				arrPersons.add(p);
			}

		} catch (JSONException e) {

			e.printStackTrace();
		}

		return arrPersons;
	}

much easier than the previous methods.
notice that we used the methods optJSONArray,optString,optInt instead of using getString,getInt because the opt methods return empty strings or zero integers if no elements are found. while the get methods throw an exception if the element is not found.

and that was all about parsing web service reponses, stay tuned next week for another tutorial

Everywhere we go we read about the battle between Android and iOS. It’s simply impossible to get away from the conversation of which platform is better, where’s the money, which monetizes better, what the cost of porting is and even which OS is sexier…  Setting all the noise aside I wanted to do a simple comparison to see what the actual popularity is for freemium on each platform.

In my search I choose to do a simple count of the top grossing free apps. I also segregated the counts out by relative deck placement (i.e. top 10 apps vs. top 200).

iOS has twice the amount of freemium apps in the top 200 grossing yet both have similar ratios in the top 10 grossing. What does this tell me? Freemium opportunities on Android exist, but the market has yet to meet the demand. See below for full details.

Android versus iOS market share for freemium game apps

Why go freemium on Android?

Beyond the fact that freemium has exploded on iOS, there are many other reasons to go freemium on Android. The first and foremost reason to move your business model to Android is due to the ramped increase in piracy. I have heard multiple horror stories from AAA premium developers that for every 1 paid install they are seeing 100 pirated installs…. Ouch!

Other reasons for going freemium on Android include cost of user acquisition. Predictable user acquisition and discoverability is far worse in the Androids market comparable to iOS. Going free allows for a greater opportunity to increase distribution without risking cash for means of unknown distribution sources.

Do you have a question about freemium gaming or a topic you’d like us to explore? Let us know in the comments or catch us on twitter @rechargestudios or @w3i.

Freemium Game Blogs are published in partnership with the series on W3i’s corporate blog.

Requesting SOAP web service:

Before proceeding to the code, let’s take a look at the SOAP structure:

A soap request can be something like this:

POST /InStock HTTP/1.1
Host: www.example.org
Content-Type: application/soap+xml; charset=utf-8
Content-Length: length
SOAPAction: "http://www.w3schools.com/GetItems"

<?xml version="1.0"?>
<soap:Envelope
xmlns:soap="http://www.w3.org/2001/12/soap-envelope"
soap:encodingStyle="http://www.w3.org/2001/12/soap-encoding">
<soap:Header>
  <m:Trans xmlns:m="http://www.w3schools.com/transaction/"
  soap:mustUnderstand="1">234
  </m:Trans>
</soap:Header>
<soap:Body>
  <m:GetPrice xmlns:m="http://www.w3schools.com/prices">
    <m:Item>Apples</m:Item>
  </m:GetPrice>
</soap:Body></soap:Envelope>

The SOAP request/response is sent as a SOAP Envelope which consists of a SOAP Header and a SOAP Body.

1. SOAP Header: optional component of the envelop, contains application specific information, such as authentication.
2. SOAP Body: the actual message sent to/received from the service.
3. The header can contain a SOAP Action which identifies the desired function to be called by the service.

Calling the service:

To call the SOAP web service you have to do the following:
First: construct the SOAP envelope manually like this:

String envelope="<?xml version=\"1.0\" encoding=\"utf-8\"?>"+
"<soap:Envelope xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"

xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\"

xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\">"+
  "<soap:Body>"+
    "<GetItems xmlns=\"http://tempuri.org/\">"+
      "<startDate>%s</ startDate>"+
      "<getAll>%s</getAll>"+
    "</Items>"+
  "</soap:Body>"+
"</soap:Envelope>";

where %s are place holders where you substitute request parameters in like this

String requestEnvelope=String.format(envelope, "10-5-2011","true");

Second: call the web service like this:
Second: call the web service like this:

String CallWebService(String url,
    String soapAction,
   String envelope)  {
  final DefaultHttpClient httpClient=new DefaultHttpClient();
  // request parameters
  HttpParams params = httpClient.getParams();
     HttpConnectionParams.setConnectionTimeout(params, 10000);
     HttpConnectionParams.setSoTimeout(params, 15000);
     // set parameter
  HttpProtocolParams.setUseExpectContinue(httpClient.getParams(), true);

  // POST the envelope
  HttpPost httppost = new HttpPost(url);
  // add headers
     httppost.setHeader("soapaction", soapAction);
     httppost.setHeader("Content-Type", "text/xml; charset=utf-8");

     String responseString="";
     try {

      // the entity holds the request
   HttpEntity entity = new StringEntity(envelope);
   httppost.setEntity(entity);

   // Response handler
   ResponseHandler<string> rh=new ResponseHandler<string>() {
    // invoked when client receives response
    public String handleResponse(HttpResponse response)
      throws ClientProtocolException, IOException {

     // get response entity
     HttpEntity entity = response.getEntity();

     // read the response as byte array
           StringBuffer out = new StringBuffer();
           byte[] b = EntityUtils.toByteArray(entity);

           // write the response byte array to a string buffer
           out.append(new String(b, 0, b.length));
           return out.toString();
    }
   };

   responseString=httpClient.execute(httppost, rh); 

  }
     catch (Exception e) {
      Log.v("exception", e.toString());
  }

     // close the connection
  httpClient.getConnectionManager().shutdown();
  return responseString;
 }

After calling this function, you will have the response as a String, something like this:

<?xml version="1.0" encoding="utf-8"?>
<soap:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
  <soap:Body>
    <GetItemsResponse xmlns="http://tempuri.org/">
      <GetItemsResult>

        <Items>
          <Item>
            <name>string</name>
            <description>string</ description >
          </iPhoneCategory>
          <iPhoneCategory>
            <name>string</name>
            <description>string</ description >
          </ Item >
        </Items>
      </GetItemsResult>
    </ GetItemsResponse >
  </soap:Body>
</soap:Envelope>

This response needs to be parsed to extract the data.

Requesting REST web service:

REST web services are much simpler, you request the service by calling a URL with the parameters. like this

http://example.com/resources/getitems

an example of calling a REST web service:

String callWebErvice(String serviceURL){
		// http get client
        	HttpClient client=new DefaultHttpClient();
        	HttpGet getRequest=new HttpGet();

        	try {
        		// construct a URI object
				getRequest.setURI(new URI(serviceURL));
			} catch (URISyntaxException e) {
				Log.e("URISyntaxException", e.toString());
			}

			// buffer reader to read the response
        	BufferedReader in=null;
        	// the service response
        	HttpResponse response=null;
			try {
				// execute the request
				response = client.execute(getRequest);
			} catch (ClientProtocolException e) {
				Log.e("ClientProtocolException", e.toString());
			} catch (IOException e) {
				Log.e("IO exception", e.toString());
			}
        	try {
				in=new BufferedReader(new InputStreamReader(response.getEntity().getContent()));
			} catch (IllegalStateException e) {
				Log.e("IllegalStateException", e.toString());
			} catch (IOException e) {
				Log.e("IO exception", e.toString());
			}
        	StringBuffer buff=new StringBuffer("");
        	String line="";
        	try {
				while((line=in.readLine())!=null)
				{
					buff.append(line);
				}
			} catch (IOException e) {
				Log.e("IO exception", e.toString());
				return e.getMessage();
			}

        	try {
				in.close();
			} catch (IOException e) {
				Log.e("IO exception", e.toString());
			}
        	// response, need to be parsed
        	return buff.toString();
	}

Connecting to a web service over a Secure Sockets Layer (SSL): protocol:

Android default HttpClinet does not support SSL connections, so if you have a secured web service, you need to connect to it via javax.net.ssl.HttpsURLConnection.
if you want to call a SSL SOAP web service:

String CallWebService(String url,
			 String soapAction,
			String envelope) throws IOException  {
		URL address=new URL(url);
		URLConnection connection=address.openConnection();
		HttpsURLConnection post=(HttpsURLConnection)connection;
		post.setDoInput(true);
		post.setDoOutput(true);
		post.setRequestMethod("POST");
		post.setRequestProperty("SOAPAction", soapAction);
		post.setRequestProperty( "Content-type", "text/xml; charset=utf-8" );
		post.setRequestProperty( "Content-Length", String.valueOf(envelope.length()));
		post.setReadTimeout(4000);

		OutputStream outStream=post.getOutputStream();
		Writer out=new OutputStreamWriter(outStream);
		out.write(envelope);
		out.flush();
		out.close();

		InputStream inStream = post.getInputStream();
		BufferedInputStream in = new BufferedInputStream(inStream,4);
		StringBuffer buffer=new StringBuffer();
		// read 4 bytes a time
		byte[] buffArray=new byte[4];
		int c=0;
			while((c=in.read(buffArray))!=-1){
				for(int i=0;i<c;i++)
					buffer.append((char)buffArray[i]);
			}

			return buffer.toString();
	}

In this post we saw how to request a web service, in the next post we’re going to see how to parser the different (SOAP, XML, JSon) types of responses.

Android preferences is a key/value entries that store data that can be specific to a certain activity or shared among all activities within the application.
the data are stored in a xml file within the application folders.

Saving Preferences

We can save preferences in three ways:

1. Preferences can be retrieved only by a single activity.
2. Preferences can be shared and retrieved among all activities within the application.
3. Preferences can be shared and retrieved through all applications on the device.

Saving Activity-level preferences:

To save preferences that are accessed only from a single activity, we do it like this:

SharedPreferences prefs=getPreferences(Context.MODE_PRIVATE);
        SharedPreferences.Editor editor=prefs.edit();
        editor.putString("pref 1", "some text");

        editor.commit();

We get a SharedPreferences object by calling getPreferences(int mode) method which takes an integer value as a parameter, the mode value can be one of the following:

1. Context.MODE_PRIVATE (0): a file creating mode that makes the created file only accessible by applications with the same user ID (access the file from the same application context, will desctribe later).
2. Context.MODE_WORLD_READABLE (1): file mode makes the file readable from other applications.
3. Context.MODE_WORLD_WRITEABLE (2): file mode allows other applications to write to the file.

Then we get an instance of SharedPreferences.Editor and write the preference value with editor.putString(String key, String value) method.
shared preferences allows you to insert preferences using the following methods:

1. editor.putBoolean(String key, boolean value).
2. editor.putFloat(String key,float value).
3. editor.putInt(String key, int value).
4. editor.putLong(String key, long value)
5. editor.putString(String key, String value)

Then we call edit.commit() to save the preferences to the file. commit returns a boolean indicating the result of saving, true if successful and false if failed.

Reading preferences values:

To read preferences values:

SharedPreferences prefs=getPreferences(Context.MODE_PRIVATE);
String val=prefs.getString("pref 1", "some text");

We use sharedpreferences.getString(String key, String defaultValue) (or get boolean/float/int) to return the value stored with a specific key or defaultValue if not found.

Saving Application-level preferences:

To save preferences that can be retrieved from all activities in the application we do it like this:

SharedPreferences prefs= getSharedPreferences("demopref", Context.MODE_WORLD_READABLE);
        SharedPreferences.Editor editor=prefs.edit();
        editor.putString("demostring", "hello");
        editor.commit();

Same as the code above, but the difference is that we give our preferences file a name (demopref in this case) so that other activities can reference that preferences file.

Sharing preferences across applications:

We can store preferences in one application and read them in another application, this is done reading the preferences file by loading them through the first application’s context.

Let’s assume we have two applications:

1. Application 1 with package name “com.mina.prefdemo”.
2. Application2 with package name “com.mina.demoapp”.

If application1 creates a preferences file with the name “demopref” and inserts a String preference with the key/value “demostring/hello”.
now we access this file and value from application 2 like this:

Context con;
  try {
   con = createPackageContext("com.minasamy.prefdemo", 0);
   SharedPreferences pref=con.getSharedPreferences("demopref", Context.MODE_PRIVATE);
   String x=pref.getString("demostring", "not found");
   txt.setText(x);
  } catch (NameNotFoundException e) {
   Log.e(Tag, e.toString());
  }

Creating Preferences Activities:

Android provides another nice way of presenting and saving preferences. you can create Activities that extend PreferenceActivity.
PreferenceActivity is an activity that displays a set of built-in preferences related widgets that are defined in xml file.

The preference activity can be divided to several PreferenceCategory each containing a set of related preferences.
The preferences widgets that Android provide are:

1. CheckBoxPreference: displays a check box widget.
2. EditTextPreference: displays an EditText widget to save user prefs.
3. RingtonePreference: displays a list with the  ringtones on the device.
4. ListPreference: displays a list of key/value items.

Each one of these preferences widgets is associated with a preference key. it’s value is persisted instantly as the widget selection changes.
we can construct our preferences screen xml (saved in res/xml directory) layout like this:

<?xml version="1.0" encoding="utf-8"?>
<PreferenceScreen
  xmlns:android="http://schemas.android.com/apk/res/android">
    <PreferenceCategory
    android:title="Catogory one"
    android:summary="sample summary">
        <CheckBoxPreference
         android:title="Enable"
         android:key="pref_enable"
         android:summary="enables a preference"/>
        <EditTextPreference
        android:summary="Edit text prefrence"
        android:title="Edit"
        android:key="pref_edit"/>

    </PreferenceCategory>
    <PreferenceCategory
    android:title="Category2"
    android:summary="sample summary">
        <RingtonePreference
        android:key="pref_ring"
        android:title="Ringtones preference"/>

        <ListPreference
        android:key="pref_list"
        android:title="List Preference"
        android:dialogTitle="List Pref Dialog"
        android:entries="@array/pref_items"
        android:entryValues="@array/pref_items_values"/>
    </PreferenceCategory>

Then from our activity:

public class PrefActivity extends PreferenceActivity {
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		addPreferencesFromResource(R.xml.prefs);

	}
}

The activity will look like this:

The ListPreference can be associated with String array resources as it’s key/value entries

<string-array name="pref_items">
    <item>Item1</item>
    <item>Item2</item>
    <item>Item3</item>
    <item>Item4</item>
    <item>Item5</item>
    </string-array>

    <string-array name="pref_items_values">
    <item>1</item>
    <item>2</item>
    <item>3</item>
    <item>4</item>
    <item>5</item>
    </string-array>

To reference the preference widgets programmatically:

EditTextPreference pref_edit=(EditTextPreference)findPreference("pref_edit");

And that’s was all about Android preferences. stay tuned for another tutorial next week

AsyncTask is an abstract class that provides several methods managing the interaction between the UI thread and the background thread. it’s implementation is by creating a sub class that extends AsyncTask and implementing the different protected methods it provides.

Let’s demonstrate how to user AsyncTask by creating a simple activity that has two buttons and a progress bar:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
  xmlns:android="http://schemas.android.com/apk/res/android"
  android:layout_width="match_parent"
  android:layout_height="match_parent"
  android:orientation="vertical"
  >
  <Button
  android:id="@+id/btn"
  android:layout_width="fill_parent"
  android:layout_height="wrap_content"
  android:text="Show Progress"
  ></Button>
  <ProgressBar
  android:layout_width="fill_parent"
  android:layout_height="wrap_content"
  android:id="@+id/progress"
  style="?android:attr/progressBarStyleHorizontal"
  ></ProgressBar>
  <Button
  android:id="@+id/btnCancel"
  android:layout_width="fill_parent"
  android:layout_height="wrap_content"
  android:text="Cancel"
  ></Button>
</LinearLayout>

Here we have two buttons: one to start progress and the other to stop it.

Creating the AsyncTask sub class:

The first step in implementing AsyncTask is to create a sub class like this:

class ProgressTask extends AsyncTask<Params, Progress, Result>{
}

The AsyncTask declaration has three Varargs parameters which are:

1. Params: parameter info passed to be used by the AsyncTask.
2. Progress: the type of progress that the task accomplishes.
3. The result returned after the AsyncTask finishes.

These parameters are of type Varargs which provide the flexibility to pass dynamic sized arrays as parameters.

In our example our class will be like this:

class ProgressTask extends AsyncTask<Integer, Integer, Void>{
}

The parameter and the progress are of type Integer and the result is Void as our tasks does not return anthing (returns null).

The second step is overriding the protected methods defined by the AsyncTask class that handle the execution life cycle of the AsyncTask.

We have five methods to implement which are:

1. onPreExecute: the first method called in the AsyncTask, called on the UI thread.
2. doInBackground: the method that executes the time consuming tasks and publish the task progress, executed in background thread.
3. onProgressUpdate: method that updates the progress of the AsyncTask, run on the UI thread.
4. onPostExecute: the final method that gets called after doInBackground finishes, here we can update the UI with the results of the AsyncTask.
5. onCancelled: gets called if the AsyncTask.cancel() methods is called, terminating the execution of the AsyncTask.

Starting the AsyncTask:

To start the AsyncTask we create an instance of it, then call the execute() method passing the initial parameters like this:

ProgressTask task=new ProgressTask();
// start progress bar with initial progress 10
task.execute(10);

Implementing the AsyncTask:

class ProgressTask extends AsyncTask<Integer, Integer, Void>{

		@Override
		protected void onPreExecute() {
			// initialize the progress bar
			// set maximum progress to 100.
			progress.setMax(100);

		}

		@Override
		protected void onCancelled() {
			// stop the progress
			progress.setMax(0);

		}

		@Override
		protected Void doInBackground(Integer... params) {
			// get the initial starting value
			int start=params[0];
			// increment the progress
			for(int i=start;i<=100;i+=5){
				try {
					boolean cancelled=isCancelled();
					//if async task is not cancelled, update the progress
					if(!cancelled){
						publishProgress(i);
						SystemClock.sleep(1000);

					}

				} catch (Exception e) {
					Log.e("Error", e.toString());
				}

			}
			return null;
		}

		@Override
		protected void onProgressUpdate(Integer... values) {
			// increment progress bar by progress value
			progress.setProgress(values[0]);

		}

		@Override
		protected void onPostExecute(Void result) {
			// async task finished
			Log.v("Progress", "Finished");
		}

	}

Here are the steps:

1. onPreExecute() method first gets called initializing the maximum value of the progress bar.
2. doInBackground(Integer… params) methods gets called by obtaining the initial start value of the progress bar then incrementing the value of the progress bar every second and publishing the progress as long as the async task is not cancelled.
3. onProgressUpdate(Integer… values) method is called each time progress is published from doInBackground, thus incrementing the progress bar.
4. onPostExecute(Void result) is called after doInBackground finished execution.
5. void onCancelled() is called if task.cancel(true) is called from the UI thread. it may interrupt the execution preventing onPostExecute from being executed.

The onClick handler of our buttons is like this:

@Override
	public void onClick(View v) {
		ProgressTask task=new ProgressTask();
		switch(v.getId()){
		case R.id.btn:
			task.execute(10);
			break;
		case R.id.btnCancel:
			task.cancel(true);		
			break;
		}

	}

The Difference between Handler and AsyncTask:

After we saw both Handlers and AsyncTasks a question may evolve: what’s the difference between the two and when to use one of them over the other ?

The Handler is associated with the application’s main thread. it handles and schedules messages and runnables sent from background threads to the app main thread.

AsyncTask provides a simple method to handle background threads in order to update the UI without blocking it by time consuming operations.

The answer is that both can be used to update the UI from background threads, the difference would be in your execution scenario. You may consider using handler it you want to post delayed messages or send messages to the MessageQueue in a specific order.

You may consider using AsyncTask if you want to exchange parameters (thus updating UI) between the app main thread and background thread in an easy convinient way.

We hope you fund this tutorial on Android AsyncTask helpful, stay tuned for another tutorial next week.

Android provides threading techniques to perform time consuming tasks in a background thread with coordination with the UI thread to update the UI.

Android provides the following methods of threading:

1. Handlers.
2. Async. Tasks.

Handlers:

When you create an object from the Handler class, it processes

Messages and Runnable objects associated with the current thread MessageQueue. the message queue holds the tasks to be executed in FIFO (First In First Out) mannser. you will need only ine Handler per activity where the background thread will communicate with to update the UI.

The Handler is associated with the thread from which it’s been created

We can communicate with the Handler by two methods:

1. Messages.
2. Runnable objects.

In this post we will demonstrate how to use both using a simple example which is updating the text of a TextView using multiple threads.

Using Messages:

The steps of using a Handler are as follows:

1. You create a Handler object with an asscociated callbackmethod to handle the received messages (it is the method where the UI updatewill be done).
2. From the background thread you will need to send messages to thehandler.

Here’s the code of our activity:

public class MainActivity extends Activity {
TextView txt;
// our handler
 Handler handler = new Handler() {
  @Override
  public void handleMessage(Message msg) {

//display each item in a single line
  txt.setText(txt.getText()+"Item "+System.getProperty("line.separator"));
     }
 };

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

 @Override
 protected void onStart() {
  super.onStart();
              // create a new thread
  Thread background=new Thread(new Runnable() {

   @Override
   public void run() {
    for(int i=0;i<10;i++)
    {
     try {
      Thread.sleep(1000);        b.putString("My Key", "My Value: 

"+String.valueOf(i));
// send message to the handler with the current message handler          

handler.sendMessage(handler.obtainMessage());
     } catch (Exception e) {
      Log.v("Error", e.toString());
     }
    }
   }
  });

  background.start();
 }
}

After running the following code the TextView will display the following,

Each second a new line is written:

This example is pretty basic, it just sends the same message for a number of times.

What if we want the message sent to hold data that’s changed each time the message is sent, the answer is to use Message.setData(Bundle bundle) method by creating a Bundle object and adding the data to it like this:

public class MainActivity extends Activity {
 TextView txt;
 // our handler
 Handler handler = new Handler() {
  @Override
  public void handleMessage(Message msg) {
   // get the bundle and extract data by key
   Bundle b = msg.getData();
   String key = b.getString("My Key");
   txt.setText(txt.getText() + "Item " + key
   +System.getProperty("line.separator"));
  }
 };

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

 @Override
 protected void onStart() {
  super.onStart();
  // create a new thread
  Thread background = new Thread(new Runnable() {

   @Override
   public void run() {
    for (int i = 0; i < 10; i++) {
     try {
      Thread.sleep(1000);
                                        Message msg = new Message();
      Bundle b = new Bundle();
      b.putString("My Key", "My Value: " + String.valueOf(i));
      msg.setData(b);
      // send message to the handler with the current message handler
      handler.sendMessage(msg);
           } catch (Exception e) {
      Log.v("Error", e.toString());
     }
    }
   }
  });

  background.start();
 }
}

We put a string to the bundle and send a message with that bundle. in the handler method we receive the bundle and get the value with the predefined key.

After executing that code the text view would look like this:

Using Runnables:

another way to use Handlers is to pass them a Runnable by using the

Handler.post() method like this:

Runnable r=new Runnable() {

   @Override
   public void run() {
    txt.setText("Runnable");

   }
  };

  handler.post(r);

This will add the Runanble object to the message queue to be executed by the handler.

Sending Messages in a timely manner:

we can use handlers to send messages or post runnables at time intervals using

The following methods:

1. handler.sendEmptyMessageAtTime(int what,long uptimeMillis):sends an
   empty message at a specific time in milli-seconds, can be defined by using the
   SystemClock.uptimeMillis() method to get the time since the device boot
   in milli-seconds and concatinating to it.
2. handler.sendEmptyMessageDelayed(int what,long delayMillis):sends an
   empty message after a certain amount of time in milli-seconds.
3. handler.sendMessageAtTime(Message msg,long uptimeMillis).
4. handler.sendMessageDelayed(Message msg,long delayMillis).
5. handler.postAtTime(Runnable r,long uptimeMillis).
6. handler.postAtTime(Runnable r,Object token,long uptimeMillis):posts a
   runnable with an object as a distinguishing token.
7. handler.postDelayed(Runnable r,long delayMillis).

All the above messages return a boolean indicating whether the message or the runnable has been placed successfully in the message queue.

Removing Call backs:

If you want to remove a runnable or a message from the message queue, you can use the following methods:

1. handler.removeCallbacks(Runnable r).
2. handler.removeCallbacks(Runnable r,Object token).
3. handler.removeCallbacksAndMessages(Object token).
4. handler.removeMessages(int what).
5. handler.removeMessages(int what,Object object)

That’s was all about handlers, stay tuned for another tutorial next week.