roadtodroid

Flick Cam on Play Store

noreply@blogger.com (Anonymous) — Tue, 03 Feb 2015 11:27:00 +0000

Download my app the Flick Cam from Play Store using the link below:

https://play.google.com/store/apps/details?id=in.blogdpot.r2d.com.flip_control

Enjoy the app and Rate it.

Launching Flick Cam app

noreply@blogger.com (Anonymous) — Sat, 31 Jan 2015 03:15:00 +0000

Flick Cam

This is the Flick Cam app, which is going to be my first app on the Play Store. The app is still in alpha version, so it will take time to release. Stay tuned for updates.

To apply for alpha testing send a request to ;-

flick-cam-alpha@googlegroups.com

Flashlight Part II (BatteryStats and Notifications)

noreply@blogger.com (Anonymous) — Sat, 03 Jan 2015 06:50:00 +0000

FlashLight Part II

(Battery Stats and Notifications)

Picking up from where we left from Part I, we are going to add some pretty cool design elements to the UI. It's quite simplistic and just shows the battery stats to the user so as to notify him/her about the battery percentage and temperature etc. Also we implement Notifications for the app so it can notify the user about whether the light is on or off. So let's begin with designing part first.

1. Add three TextViews to the layout from PartI

Drag and drop three text views in the Graphical Layout of the app (activity_main.xml).
Edit the xml as shown below.

App layout

2. Changes to the Manifest file

In the Manifest file of the previous part we make our activity launchMode as singleTask. This is required as we are going to implement the same activity as the Pending Intent to our Notification.
In the activity tag of the manifest file add the line - android:launchMode="singleTask".

3. Display a Notification

To display a notification when the on button is pressed use the following function in the OnClickListner of the button.
The function uses the NotificationCompat.Builder class to create a notification.
The Pending Intent class is used to create a link to the same class (MainActivity) when the notification is clicked on.
Finally the number_notifications variable is used to count the number of notification are there.

4. Cancel a Notification or all of them

5. Create a Broadcast Receiver for battery stats

6. MainActivity.java file

Download Code

Goto Part I

Flashlight Part I (Working with flash)

noreply@blogger.com (Anonymous) — Fri, 26 Dec 2014 17:42:00 +0000

FlashLight Part I

(Working with Camera Flash and MediaPlayer sounds)

Hi everyone and welcome to another fun Android project at roadtodroid. This time we are going to make a Flash light app which is very easy and fun to make. I am going to complete this app in two parts, first with only the basic app with only flash and second with notifications and all other battery related stats. So stay tuned for part 2 and hope you like the post.

1. Create a new Android Application Project

Go to File > New > Android Application Project.
Give appropriate name for the project and move forward (I'm using API 19 for this project).
In the succeeding dialogs just click next and make sure to create an Empty Activity name MainActivity.java or of any name you want.
Finally click finish.

2. Design the layout of the App

Open res > layout > activity_main.xml.
Add one Button to it, as shown below.
Use the code provided to format the elements.

App layout

3. Design the Button Background

For designing our custom button we use a xml . All xmls here are in res/drawable folder.
The selector defines three items which are for state_focused="true" ,state_focused="false"and default state.
Custom drawables are used to make circular button and with given width and stroke.
The examples are as below.
For more download the code and see the res > drawable-hdpi folder.
To add the xml with selector to our button background use android:background="@drawable/multi_buttom.xml".

4. Adding Sounds to the button

Add the sounds you like in the res > raw folder (if not there create a new one).
Then use the MediaPlayer class as shown in the code below.

5. Lets move to the coding part

In the Manifest file add the following permission-

android:name="android.permission.CAMERA" />

In MainActivity.java in the onCreate method, bind the button to its layout counterpart using findViewById and set an OnClickListner for it.
In the OnClickListner, check for the availability of flash light on the device using getPackerManager().hasSystemFeature(PackageManager.FEATURE_CAMERA_FLASH).
We create methods each for playing sound on button pressed , changing button layout, getting the camera and releasing camera.All these are as shown below.

Stay tuned for Part 2

THE CLOCK WIDGET

noreply@blogger.com (Anonymous) — Thu, 11 Dec 2014 16:09:00 +0000

THE CLOCK WIDGET

Sup everyone! Happy Holiday to all.This time r2d is back with another cool android project. We are going to make a digital clock widget of our own. Isn't that cool!

Note that Android has an in-built Digital Clock widget in its layouts , but we want more customization so we are implementing our own version of it. So let's roll.

1. Create a new Android Application Project

Go to File > New > Android Application Project.
Complete the wizard and create a new Activity (MainActivity.java).
In the activity_main.xml file under res/layout, create two TextView s to be used to show time and date.
The code and the resulting layout will be like this-

Layout of the widget

2. Add a new AppWidgetProvider resource to res/xml

Create the res/xml folder if not available already.
Add a new xml to this folder and name it widget_xml.xml (or anything you like).
Add the code given below to the xml file.The Structure is also shown if figure below.
The fields are as described below:

Min Width/Height - min. width/height with which the widget will be drawn.
Min. Resize Width/Height - width/height to which it can be re-sized.
Initial layout - the layout which is used to draw the widget.
Resize Mode - direction in which re-size is allowed.

Fields in the AppWidgetProvider

3. Make changes to the Manifest XML

Add the following permissions the manifest file as they will be used to access some features of Android system later while coding.


<uses-permission android:name="com.android.alarm.permission.SET_ALARM" />

<uses-permission android:name="android.permission.WAKE_LOCK" />

Remove the <activity> tag from your  <application> tag as our app doesn't implement an activity.Instead add a receiver for the widget as shown below:-






Final view of the Project Explorer





4. Code the MainActivity

The MainActivity extends AppWidgetProvider so that it can use the services of the Android API.
The various methods such as OnReceive(), OnUpdate() , OnEnabled(), OnDisabled() of the AppWidgetProvider are overridden , to apply widget life cycle methods.
More in the last section.


MainActivity.java

--Code Explained --


The OnReceive() method is called when the widget receives call to update its contents. Here we get all the id(s) for all the instances of our widget , and call updatetime() method the we defined, to update time in every instance.
The createClockIntent() method is used by the AlarmManager to send a pending Intent to our widget every 1000 msec. The Android system only allows to update a widget every 30min (due to several reasons). So we use Alarm Manager to update it each second.
The OnEnabled() method is used to start the Alarm Manger and the method OnDisabled() is where the timer is disabled.
Finally in the OnUpdate() method we acquire a Wake Lock, to keep the CPU on (Note that this is not necessary here ,but I thought to show it's use here). the it uses RemoteViews to send Pending Intent to each TextView to open ALARM Intent. Finally the Wake Lock is released. 
The updatetime() method is just filling the TextViews with the required time and date.

Download Code

SCREENSHOTS

SignIt! Part III (Alert Dialog and HashMap )

noreply@blogger.com (Anonymous) — Fri, 28 Nov 2014 18:17:00 +0000

SIGN IT PART III

Hey everyone! Welcome to the final part of the Sign It series. In this section we will add the functionality to let the user select the stroke width and color of the paint object. Also the method of saving different styled paths to the bitmap is also demonstrated.

Before moving any further, it's highly recommended to go through the previous pars of the series for the basic code. Let's go now.

1. Add the function to change the Stroke Width

Add this function in our CanvasView.java class.
In this function we create an AlertDialog using AlertDialog.Builder.
The setPositiveButton() is used to add the "OK" button to the dialog. In the same way a negative or "Cancel" button can be added using setNegativeButton().
setSingleChoiceItems() is used to add the CharSequence declared before to the addded to the Alert Dialog.
Finally we show the Alert Dialog using the show() member function.

2. Add the function to change the Paint Color

Same as what we have done with stroke width , we are going to do with paint color.
We create the Alert Dialog in same way as before.
In setSingleChoiceItems() we just use a switch-case construct to set the paint color accordingly.

3. Change the onTouchEvent() method to store path and paint in Hash Map

We use a private Map pathMap to store each path with its own paint settings.
The values are put on the Hash Map on ACTION_UP, using the pathMap.put(key,value).

4. Change the onDraw() accordingly

In the onDraw() method just add for loop to loop through all the key-value pairs in our Hash Map.
Draw all the paths using their own specific paints, both on the canvas and on the singleusecanvas (to store it on the bitmap as in Part II).

5. Change the set_erase_on() method to clear all paths in Map

Add the method to clear the hash map so as to clear all the paths stored.

Sample Screenshots

Stroke width selection

Color selection

Download Source Code

Sign It! Part II (Saving the Canvas & Updating Gallery)

noreply@blogger.com (Anonymous) — Tue, 04 Nov 2014 10:16:00 +0000

Welcome to the part 2 of the Sign It! app series on roadtodroid. In this post we explore the method to save our drawing from the canvas to a bitmap image & also to store that image onto the system storage.
For this part I will use the app made till the previous post and build onto it only. So I recommend your to go through that one first.

1. Update the onDraw() method to create Bitmap for the canvas

In the onDraw() method , previously we only drew to the view using canvas.drawPath(path, paint);
We now create a new temporary canvas and call it singleuseCanvas.
Also we create a global Bitmap called myBitmap to store each update to singleuseCanvas.
We first set myBitmap to singleuseCanvas using singleuseCanvas.setBitmap(myBitmap).
We then draw to the new canvas using singleuseCanvas.drawPath(path, paint).
And finally we draw to the Bitmap using singleuseCanvas.drawBitmap(myBitmap, 0, 0, paint).

2. Save the Bitmap when Save on Action Bar is pressed

When the save button is pressed we call the function saveMyBitmap(); in the CanvasView.
Here we first create an empty FileOutputStream (For more visit : http://developer.android.com/reference/java/io/FileOutputStream.html).
Now we get the root path for the External SD card using Environment.getExternalStorageDirectory().
After this we create a new File object giving its constructor the path of the directory we want our images to be stored on. This is done by appending root string to "Sign It" folder(You can give any name). The File.separator is the devices' default & specific file separator .
Then we just create the string containing the name we want to give our file (I have used the systems current date & time), create another file containing root and file name, give that to the FileOutputStream.
We use compress method on myBitmap to compress and put it on the output stream.
Finally we flush and close the stream.

Also remember to add the following line to the manifest file:

3. Update Gallery

Now the next thing is to notify the gallery to update its data when we save a new image to our phone storage. To accomplish this we MediaScannerConnection class.
The context used in the function is the context of our MainActivity which we will pass later in the MainActivity.
The code is quite straight forward.

4. Modify the MainActivity

In the main activity just add the corresponding function calls in the onOptionsItemSelected.
Also here we add a new method called opengallery() to open gallery from our app only. The ACTION_VIEW specifies that some data is to be shown to user of which the Uri we have parsed. Also we add a flag to the intent Intent.FLAG_ACTIVITY_NO_HISTORY , which restricts gallery to be kept in stack.
And now just run the project.

PREVIEW:

Scribble down

Click Save icon

Images stored in gallery

Voila!!

Download Code:

CLICK THE ICON

Query optimization & Transactions

noreply@blogger.com (Anonymous) — Mon, 13 Oct 2014 18:49:00 +0000

This post explores some of the concepts of query optimization & transaction management for Android apps. Most of the applications won't be using so much of the SQLite features but it's always good to know about possible optimizations when you deal with databases. I referenced the book Pro Android Apps Performance Optimization by published Apress.

1. Basic SQLite Statements

The basic SQLite statements are simple strings like-

CREATE TABLE phone(devicename TEXT, company TEXT)
INSERT INTO phone VALUES('M8','HTC')

The above statements are just simple strings & they have to be interpreted,or compiled before they can be executed. The compilation of these statements is down internally when we call the .execSQL().

The following code demonstrates how these statements are executed.

The problems with the above implementation is that SQLite statements takes some quite some time to execute. In addition to the compilation, the statements themselves may need to be created. String is also immutable(String is immutable means that you cannot change the object itself, but you can change the reference ) ,which poses performance issues here.

2. The INSERT Statement String

INSERT is the most used statement in any SQLite database as you are bound to insert several entries into the database.A basic implementation of inserting several values into the database is shown below.

The problem with the above implementation is that for every insert statement, a String would be created and execSQL would be called.This prcedure takes a lot of time and memory.

One solution for this problem is to avoid using the + operator for String concatenation & instead use a StringBuilder object or calling String.format.The two new methods are shown below

3. The Compile Statement

Now since we have addressed the issue of using & interpreting the sting statements, the next issue is of execSQL method.The execSQL does the actual compilation(parsing) of the statement.In the above examples the execSQL statement is called for every insertion to the database. All this can be avoided by only compiling the statement once & binding later.This is depicted below.

4. Using ContentValues

As we avoided the use of execSQL staement above, the same can be achieved using a ContentValues object. Its not better than the Compile statement method. but either way its an elegant method of getting things done.

5. Transactions

Transactions are automatically created when we perform any read/write from the the database. But creating explicit transaction can improve the performance tremendously.The implementation of explicit transaction on compile statement is depicted below.

Sign It ! Part I (Drawing on the Canvas)

noreply@blogger.com (Anonymous) — Fri, 10 Oct 2014 16:38:00 +0000

Hello & welcome to the very first Android Project of roadtodroid. In this section we explore various new functionality under the hood of Android & learn how to use all of them to make our app work effortlessly.
So let me first tell you about the things we are gonna explore with Sign It!

How to draw on canvas in Android?
How to clear a canvas?
How to use action bar icons to inflate menus?
How to save the contents of the canvas to the phone memory?
How to change the pen size and color using action bar icon selections? and many more....

This whole app will be demonstrated in several parts, so be patient & go through everything thoroughly.This part demonstrates how to give your app the functionality of a canvas to draw upon. Also how to erase the whole canvas will also be discussed. All this plus adding icons to action bar and using them is also demonstrated. So get ready for this action packed ride to program Android apps & hope you will enjoy it. Feel free to post any constructive comments.

1. Create a new Android Application Project

Go to File > New > Android Application Project.
In the dialog displayed, enter a name for your app(Sign It!).
Select a target SDK version to make the app targeted for a particular Android distribution.
Also select a Minimum Required SDK to make the app backward compatible as far back as you want.
You may also select a Theme for the app if you like.
Do not change anything if you don't want to as it is pre-selected accordingly. Then click Next.

Give a name to the app

In the next dialog just click next or if you want your project to be save elsewhere(other than the current work space ) choose that from the option provided.Click next.
Next dialog allows you to select a custom icon for your app. Select one if you like, fiddle with background color and other options and click next.

Select icon

In the next dialog box select Empty Activity and click next. Similarly click next in the last dialog box.
This would create a project file in the Package Explorer of Eclipse.

2. MainActivity.java

In the MainActivity.java file copy the code shown below to your activity and change the package name to that of your's if any error is shown.
For now just copy the code & go to the end of this post in the Code Explained section to discuss more on the code.

3. Create a new Class for the Custom View implementation

Go to the package in your project, right-click on it and select New> Class.
Give a name for the class(I have used CanvasView.java), & click Finish.
Once the class is created , open it & copy the code below to it.
For more in-depth discussion go to the end of this post.

4. Create a menu to use in Action Bar

In the res folder under your project, create a new folder by right clicking on res and selecting New Folder.
Change the name of the folder to 'menu'.
Now right click on this menu folder and select a new Android XML file from there. Name it my_menu.xml (or anything).
Now to this xml file copy the code shown below to create some of the menu elements & icons.
I have also added two pngs to the res/drawable-hdpi folder as shown below. The icons are downloaded from www.iconarchive.com & can be downloaded from the Download Code section at the end.

menu folder in res

icons in the drawable-hdpi folder

5. Everything is ready

You are now done with the coding part. The only thing left is to test the app either on a real physical device or on an AVD.
To setup an AVD see my previous post.
To run on a physical device connect the device through USB. Make sure the developer options are enabled & the USB Debugging is checked.
Also make sure that the drivers for your device are installed properly. To do this I used the software named moborobo .You can get is from www.moborobo.com.
After all this just press CTRL + F11 in Eclipse & you are done.

App launch view

Scribble around!

Erase anytime

And many more to come!

Code Explained

CanvasView.java

This is a class which extends the View class of Android which means that it can be used for managing drawings on the main UI thread & also handle user interactions. For more on this check out http://developer.android.com/reference/android/view/View.html
Firstly we create three global variables paint,path & a Boolean flag. The Paint class holds the style and color information about how to draw geometries, text and bitmaps.The Path class encapsulates compound (multiple contour) geometric paths consisting of straight line segments, quadratic curves, and cubic curves.
Don't get confused just stay focused here.
The class CanvasView has a constructor with the same name which initializes the paint object using the member functions of the Paint class.The functions are quite obvious to understand from their name only. For any kind of suggestions just press Ctrl + Space in Eclipse.
Next in the onDraw() method we just draw the path to which we will add points later.The path is drawn on the canvas using drawPath(,) method on canvas object.
In the next method i.e. onTouchEvent() which is used to handle user interactions, we add to the path the points the user touches or moves to.This is pretty simple:

a.) We get the current touch position using the getX() & getY() methods on the event object.

b.) Then we use a switch on the the type of event or interaction the user has performed.

It can be either the touching of the screen or moving around on it. The names are fairly obvious,

c.) On MotionEvent.ACTION_DOWN we simply add X & Y to the path using moveTo(X,Y) on path object.

d.) On MotionEvent.ACTION_MOVE we draw a line to X,Y using lineTo(X,Y).

e.)Finally to force a view to draw, we call invalidate().

my_menu.xml

This is the xml file used to tell Android about the content to be drawn in the Action Bar.
The xml contains four item tags, all having different id & title.
An icon is provided using the android:icon property.
The android:showAsAction="ifRoom" or android:showAsAction="always" are used to make items hidden if no room is available or to show them anyway.

MainActivity.java

The main activity in the onCreate() method initializes the global CanvasView object and used it in the setContentView() to make it the main UI view of the application.
Then in the onCreateOptionsMenu() method we create a MenuInflator object and we inflate our menu using its inflate() method.
Lastly in the onOptionsItemSelected() method we use a switch on the item id we provided in the my_menu.xml & perform required operations accordingly.
The rest of the code is pretty straight forward & can be done in multiple ways.

Download Code

Android Database Part II

noreply@blogger.com (Anonymous) — Wed, 01 Oct 2014 16:14:00 +0000

Hello World! Welcome back to Android Database series to learn some basic database features of the SQLite in Android. This post builds on the concepts and classes made in the previous part , i.e, Android Database Part I. So I would recommend you to go through it before reading this one.

Now I would assume that you have read the previous post on database & already have the classes and activities implemented there, cause we are gonna add to them in this part. So let's begin:

1. Changes in MainActivity.java

There are as such no big changes in this main activity. I only removed all the code from the onClickListner of sign in button , and created a new function to increase readability.

2. Changes in My_DbHelper.java class

We created two new methods here in this class , one to delete selected users from the database , & other to update any selected user info from the list.
In the delete-user() method we just get an object of SQLiteDatabase for our class in the writable mode using getWritableDatabase(). Then we pass the id value passed to the method, to the .delete() method.
In the same way we create update_user() method and create a ContentValues object using the parameters passed. The .update() method is then used.

3. Changes in Admin login (R2D_login.java) activity

In this layout of this activity we add two new buttons to the activity_r2d_login.xml file.They are named Update & Delete.
We bind the variable created in r2d_login.java , to the xml elements using findViewById() method. The methods under the corresponding onClickListner s & other are explained at the end in the last section.
For now just copy & paste the code if you want to.

4. Create a new activity named Update_form

This activity uses the layout of our MainActivity so we don't need to create a separate xml layout for this. If one is created, just delete it.
We re-use the layout by just setting it in the setContentView() method. We also change the text displayed on the button using the setText(" string ") method on the button object.
In the onClickListner() of the button, we call the same function used in the MainActivity to for the basic form verification.The only difference here is instead of inserting into the table we update the selected (selected in the r2d_login activity )user' s info.
To help us do this we used the intuitive method on putting extras into the intents. We put the id of the user when selected in r2d_login activity & put it in the intent using .putExtra("name",value) method.
We get the extra value back using the getExtras().get("id") method. Then we simply call the update_user method with mail_id, pass & id from intent.
Finally we close the activity using finish() method.

5. Run the project

Simply run the app using CTRL+F11.

Admin login id

Users in database

Try select more than one user

Get a notification

Select a user to update

Enter new details & Update

Updated list

Select users to delete

List after deletion

Code Explained:

The methods update_user and delete_user are quite straight forward. They are explained in point 2 above.
The main magic happens in the r2d_login activity.
The overridden onResume() method calls the update_list() method in which we just create a new arrayadapater and use show_in_list() method (as in previous post) to initialize the list. We then set the grid view with the array adapter.
Both the onClickListner s of the buttons use their own logics by calling remove_logic() & update_logic() respectively. They also call the same update_list() method to make updation happen.
In the remove_logic() method we first create a SparseBooleanArray and set to checked grid positions as before. We then loop through the arrayadapater and check if the item is checked. If its checked we get its id by getting the characters from the list data up to the first space (' '). This is done using the substring() method.We then call the delete_user(user_id) method.
The update logic is more or less the same. The only difference is that we first check if more than one list item is checked & if so we prompt the user.
Then using the same looping logic we find the checked list item id and put it int the extras field and start the activity.

Download Code:

Android Database Part I

noreply@blogger.com (Anonymous) — Mon, 29 Sep 2014 12:33:00 +0000

Welcome again to road to droid. In this section I am going to discuss about the the ways to implement a SQLite database on you android device. To demonstrate the concept I am creating an app which makes user fill a form and then inserts the details into a database. So hop in for a ride!

1. Create a new Android Application Project

Go to File > New > Android Application Project.
Fill in the name for the app as you like and click Next.
In the next few dialogs click Next and in the one with Activity Types select Empty Activity.
In the final dialog box click Finish.

Enter a name for the app

2. Add elements to the activity_main.xml file

In the activity_main.xml file (name may be different in case you named your main activity differently), add two EditTexts & one Button. (I have also added two ImageViews for the Mail & Password fields, you may omit them).
Insert a android:hint field to give hints on what to enter in the EditTexts.

Graphical Layout

3. Add a DbHelper class to the package

Right Click on the package under the src folder in your apps Package Explorer and add a new Class to it.
This class extends SQLiteOpenHelper which encapsulates all methods for creating and managing SQLite database in android.
For more explanation go to the end of the post to the Code Explained section.

My_DbHelper class creation

4. Code away the MainActivity.java

In our main activity we first create an object of My_DbHelper to handle database operations.
In onCreate() we bind the layout elements to variables and in the onClickListner of the button we check if the EditTexts are empty by using .getText().toString().equalsIgnoreCase("").
If the both the fields are not empty then we check if there is a Admin login attempt with "r2d" as both mail id and password . If so we empty the EditTexts (using setText()) and launch an Intent to another activity which we will create below.
We also check for the validity of the email id entered using a regular expression. The .match(regex) method returns true if there is match.

5. Add an Admin login portal for the next tutorial

Add another Android activity to the package by right clicking it and selecting New > Other > Android Activity.
The implementation of this activity is same as that demonstrated in previous posts on List Views.The only difference is in the show_in_list() method which uses an object of My_DbHelper to get all users in the database using the method we created (get_all_user()).

6. Enter GridView to xml of Admin login activity

In the xml file of this new activity add a grid view to show the entries of the database.

Grid View

7. Run the App

Launch the app on an AVD or on a physical device by pressing CTRL + F11.

Code Explained:

In the My_DbHelper class which extends a SQLiteOpenHelper to manage database creation and version management. For more on SQLiteOpenHelper go to http://developer.android.com/reference/android/database/sqlite/SQLiteOpenHelper.html.
In the class the DATABASE_VERSION variable is used if we have several versions or instances of our database.We can change the version at any time or save any version for future use.For assign any number to this variable.
The String variables DATABASE_NAME & TABLE_NAME are used to give a name to our database and to a table in it. You can have more than one tables in your database. Create a new String to store each ones name.
Now we create a String query to create a new table.We define three attributes for any tuple. One is 'user_id' which is of type INTEGER and is set to AUTOINCREMENT, also it is the PRIMARY KEY for the table. Another attribute is 'mail_id' which is of type TEXT and is set to NOT NULL. The is the case for the attribute 'pass'.
In the onCreate() method of the class we create the table using execSQL() method.
In the onUpgrade() method we can either load an older version of the database or just drop everything and create a new one. And that is what we have done here.
We have also created two methods to insert tuples into the table & to retrieve tuples from the table.
The insert_user(String ,String) method takes as argument two strings and inserts them into the table using a ContentValues object. First we get a SQLiteDatabase object for our table in the writable mode using getWritableDatabase() method.
We create a new ContentValues object and put in it the Strings m & p with the respective attribute names for the table. Note we didn't put the user_id in values as it is set to AUTOINCREMENT. Finally we insert the values into the table using insert() method.
In the get_all_user method we first define a List ro store all the tuples in the database in string form. Then we create the search query which is SELECT * FORM TABLE_NAME.
Now we get a SQLiteDatabase object which is only readable using getReadableDatabase() method. We then create a cursor to move around in our table. A cursor is just like a pointer to the tuples in the table.
We move this cursor forward into the table using moveToNext() on cursor object. We first also make sure if the cursor is at the starting of the table by calling moveToFirst() on cursor, Finally we go in a loop to get user_id, mail_id & pass from the cursor using getString()/getInt() & getColumnIndex() methods. We add each of these values to out List object.
Finally we return the List to the calling Activity.

Download Code:

Android Activity Life Cycle

noreply@blogger.com (Anonymous) — Sat, 27 Sep 2014 17:43:00 +0000

In this section I am going to discuss the activity life cycle.So let us first wrap our heads around the concept of activities in Android.

What's an Activity?

Activities are an unusual programming concept specific to Android. In traditional application development there is usually a static main method, which is executed to launch the application. With Android, however, things are different; Android applications can be launched via any registered activity within an application.

What's an Activity's Lifecycle?

The Android activity life-cycle comprises a collection of methods exposed within the Activity class that provide the developer with a resource management framework. This framework allows developers to meet the unique state management requirements of each activity within an application and properly handle resource management.

When an activity’s state is changing, the activity is notified by the OS, which calls specific methods on that activity. The following diagram illustrates these methods in relationship to the Activity Lifecycle:

Start-up Sequence:

OnCreate: Called when the activity is first created. This is where you should do all of your normal static set up: create views, bind data to lists, etc. This method also provides you with a Bundle containing the activity's previously frozen state, if there was one. Always followed by onStart().
OnStart: Called when the activity is becoming visible to the user. Followed by onResume() if the activity comes to the foreground, or onStop() if it becomes hidden.
OnResume: Called when the activity will start interacting with the user. At this point your activity is at the top of the activity stack, with user input going to it. Always followed by onPause().

Configuration Change Sequence:

OnPause: Called as part of the activity lifecycle when an activity is going into the background, but has not (yet) been killed. The counterpart to onResume().
OnStop: Called when you are no longer visible to the user. You will next receive either onRestart(), onDestroy(), or nothing, depending on later user activity.
OnDestroy: The final call you receive before your activity is destroyed. This can happen either because the activity is finishing (someone called finish() on it, or because the system is temporarily destroying this instance of the activity to save space
OnCreate : (Same as before)
OnSart : (Same as before)
OnResume : (Same as before)

For more detailed information on activity life-cycle refer the following links:

Or watch these videos on YouTube:

Hope this helped you! Continue reading.

Android ListView Part III

noreply@blogger.com (Anonymous) — Tue, 23 Sep 2014 19:09:00 +0000

Hi everyone! Welcome again to roadtodroid for another fun Android tutorial. In this post I am gonna tech you how to create your own customized list views. Along the way some new things such the vibrator class and the action bar methods are also introduced. So let's start building this fun app.

1. Create a new Android Application Project

Go to File > New > Android Application Project.
Give a suitable name and proceed as before.

New app dialog

2. Add a ListView to activity_main.xml

From the palette, go to the composite tab and select a ListView from there. Place it inside the graphical layout in activty_main.xml.
Remember to make the android:id="@android:id./list".

activity_main.xml

3. Create a rowlayout.xml file

In the Package Explorer, under you app folder, add a new rowlayout.xml to res/ layout folder (where activity_main.xml is present).
To do this right-click on layout folder and go to new and select Android XML File.
In the rowlayout.xml file add the following code, to add an image and text to our list adapter.

4. Create the Custom Adapter MyCustomAdapter.java

Now its' time to define the view of the list according to our needs. So go to the src folder under our project name in the package present right-click and add a new Class to it.
For now just copy the code below and change the package name to your's package name. For more explanation check the bottom of the post.

Adding new Custom Adapter Class

5. Code the MainActivity.java

In our main java file we first make our main class extend ListActivity to get all list handling functionality.
Then we made an object of our Custom Adapter and sent the values to it.
Finally we set the Custom Adapter to our list.
Also onListItemClick is also used to do some processing when the list item is clicked.

6. Run the app

Launch the app by pressing CTRL+F11.
A physical device can be connected through USB or an AVD can be configured as shown in http://roadtodroid.blogspot.in/2014/09/lets-start-with-setting-up-with.html.

Launch page

Search for list item

Code Explained:

Our main goal in this activity is to group an image and text in the same list area. To do this our normal ArrayAdapter will not do as it only contains only in type of object . So in our Custom Adapter (which basically extends ArrayAdapter to get the text data) we create a new class ViewHolder to encapsulate image & text. MyCustomAdapter class has a constructor which receives the list of sites in our case, and store it in a local variable.
If the getView() method is not there in your class add it by -> Right-click > Source > Override/implement Methods.
Now in the getView() method we first create a View object 'myview' and set it to convertView. This is basically an optimization step using which we save the inflating of the view on very redraw (or scroll ) of the list. If initially convertView is null (which it will be), a new layout inflator is inflated and attached to our view using the setTag() method.
After this the string from the local variable is added to our viewHolder using <Holder name>.<Text Object>.setText(String).
Then the corresponding images are loaded from the res/drawable-hdpi folder.
Now in the main activity we create an object of MyCustomAdapter , sending it the String[], and setting it to our ListView.
getActionBar().hide() is used in onCreate() to hide the action bar at the top so as to get more screen space (Requires android:minSdkVersion="11" in AndroidManifest.xml).
Also a Vibrator object is created in onListItemClick() to make the device vibrate on item click.To be able to use this service do the following:

import android.os.Vibrator;
In the AndroidManifest.xml file add

Download Code:

Android ListView Part II

noreply@blogger.com (Anonymous) — Sun, 21 Sep 2014 15:28:00 +0000

Welcome again to Android ListView. What we are gonna do is build up on the progress of Part I, and add some new concepts such as Intents and SearchManager to it. So let's begin:

1. Create a new Android Application Project

Follow up on Part I for the basic app setup process or create new by going to File > New > Android Application Project.

New Android Appication

2. Add List View to activity_main.xml

Add the ListView to the graphical layout of the app from the Palette by dragging and dropping from the Composite Section.
Remember to set the android:id to "@andorid:id/list".

Empty ListView

3. Code away the MainActivity.java

Add the code below to your MainActivity.java.
For code explanation scroll to the end of the post.

4. Run the app

Launch the app in an AVD or on a physical device by pressing CTRL + F11.

Main Screen

Search Results

Code Explained:

The java code in this tutorial builds up on the ListView Part I. The new thing here is that this app now can search the name in the list item clicked onto the Internet.
This is accomplished by adding an Intent to the app. Intents are used to describe run time actions to be done by the app. Through Intents we can call any other activity or perform any default actions provided by the system (e.g, Intent.ACTION_WEB_SEARCH).
We add this Intent in the onListItemClick() method of the ListActivity which is called when any list item is selected by clicking touching.
Another new thing here are the Toasts. A Toast is like a real toast which pops up to notify you about your choices or any thing else. The function Toast.makeText( Context, String, Length).show() is used to display Toasts.
Now we make a search string, put it in the Extras field of our intent under the SearchManager.Query name. Its similar to a name:value pair.
Finally we start the intent by calling startActivity(my_intent).

Download Code:

Android ListView Part I

noreply@blogger.com (Anonymous) — Sun, 21 Sep 2014 07:28:00 +0000

List Views are the most versatile of the widgets in Android as they can be used in many ways and customized according to need.List Views are used to list various options to the user or to show what's already there with the system and update it with time to time.Let's have a closer look at List Views.

Be patient and follow the road:

1. Create a new Android Application Project

Go to File > New > Android Application Project.
Provide a name for the app and proceed as shown in previous blogs.
Select Empty Activity under the activity type.

Naming the app

2. Add a list view to activity_main.xml

Remove the Text View from the graphical layout saying Hello World.
In the Palette go to Composite > ListView.
Drag and drop the list view to the graphical window.
Re-size it accordingly.

Empty ListView

3. Make some changes to activity_main.xml

Firstly change the background color of your relative layout to black(#000000), as shown in code below.
Secondly change the id of the ListView to "@andorid:id/list".

4. Open the MainActivity.java file

Open the MainActivity,java file from src folder in the package explorer.
Add the code shown below. Remember to change the package name.

5. Run the app

Run the app on a AVD or a physical device as demonstrated in previous blogs.

Run As Android Application

ListView app

Code Explained:

The MainActivity class of the app extends a ListActivity. ListActivity has a default layout that consists of a single, full-screen list in the center of the screen.
We create a private ArrayAdapter to bind the data to the List View using a ListAdapter interface.
The function show_in_list() declares a List object containing names of movies.
.add(String ) is used to add Strings to the arrayadapter.
Finally in onCreate we set the data in the list using the setListAdapter(arrayadapter) function.

Download Code:

Android Buttons and TextViews

noreply@blogger.com (Anonymous) — Fri, 19 Sep 2014 19:18:00 +0000

After testing the basic environment of the Android SDK , its time to start fiddling around with some cool user interactions provided by Android.
In this post I will demonstrate using Android widgets such as Buttons and TextViews.

Just be patient and follow the steps below:

1. Create a new Android Application Project

Go to File > New > Android Application Project.
Give a name to your app and proceed forward as in the last post (First App).
Remember to select an Empty Activity in activity type.

Naming the app

2. Open the activity_main.xml file

Open the activity_main.xml file from the Package Explorer , if not already open.
This file is located res > layout folder under your project in Package Explorer.

Package Explorer

3. Add Button and TextView

Remove the TextView showing "Hello World" by selecting it and pressing Delete.
Now in the Palette click on From Widgets tab and drag and drop a button to the Graphical Layout.
Re-size and re-position it any way you like.
Similarly drag and drop a TextView (Large Text or any other) to the Graphical Layout.
You can tinker around with the self generated xml code by clicking on the activity_main.xml tab at the bottom of the eclipse window.

Final Layout

4. Open the MainActivity.java file

If not already open, go to Package Explorer and under your project go to src > (Package Name) > MainActivity.java.
Copy the java code below to your MainActivity.java (Remember to change the package name to your package name).

5. Run the Application

Build and run the app by pressing CTRL + F11 or click Run > Run.
Remember to configure AVD as shown in previous post or connect your own device to install and run the app.

Launch Screen

On Button Click

Code Explained:

The first few lines of the code has some import statements which are auto included or can be included by clicking on error suggestions popups on the left of the code window.
Our main activity is that class which has the main GUI thread. Its the first screen which the user sees when the app is launched. In this example, the main activity extends ActionBarActivity to suggest that it shows an action bar on the top of the app with and methods OnCreateOptionsMenu creates the list icon on the right of the action bar.
In out MainActivity class we create two private variables my_button & my_textView to point out button and textview in our xml file (activity_main).
The method OnCreate is called when the Android system wants to draw something related to the app on the main screen.
The OnCreate method first sets the view of the app to activity_main.xml by callins setContentView(R.layout.activity_main);
The we bind our variables my_button & my_textView to corresponding id's in main xml file.

Note: The R.java file is a self updating file which the SDK maintains to collect all the resources and properties of the app at one place. Do not try to edit it at any time , as there may be consequences!

7. Next we bind a event listener to our button which is called when the user clicks it.

8. Here we set the text of the TextView to whatever we want.

Download Code:

Android SDK Setup and First App

noreply@blogger.com (Anonymous) — Fri, 19 Sep 2014 14:52:00 +0000

Let’s start with setting up with the development environment for Android app development and make our first “Hello World” app.

1. Download and Install Eclipse IDE

Download the Android SDK from https://developer.android.com/sdk/index.html

Note: Many of you might know that Android Studio , which is currently in its Beta, is going to be the official IDE for Android .But nonetheless I am going to demonstrate setting up Eclipse ADT bundle.

Extract the zip file.

2. Download and Install JDK and Java SE Platform

Download and Install JDK from http://www.oracle.com/technetwork/java/javase/downloads/jdk7-downloads-1880260.html

Download and install Java SE from http://www.oracle.com/technetwork/java/javase/downloads/index.html

3. Start Eclipse

Go to the directory where you have unzipped the adt bundle and then go to eclipse folder and start eclipse.

4. Install any updates from the SDK manager (may skip this at first)

In eclipse go to Window > Android SDK Manger.

Check and install any update for the environment you want.

SDK Manager

5. Create your first Android App

Go to File > New > Android Application Project.

Enter your Application’s Name (Remember the first letter of the name must be capital).

Select Minimum supported SDK for your app and also the Target SDK

Select a theme if you want.

Click Next.

New Andriod Applicatoin

6. Select a path to store the project

Select a custom path, if you want for your app.

Click Next.

App Configuration

7. Select an Icon for the app

You may want to select your own icon in this dialog box or use the default one.

Other icon properties can also be fiddled with.

When you are done click Next.

Select an Icon

8. Select an Activity type

Select an activity type such as blank, empty and others.

For now select an Empty Activity.

Click Next.

Select Activity Type

9. Choose a name for the Main Activity

Give a name you like to the main activity for the app.

Click Finish.

Activity Name

10. Launch your first app

To launch your first app you can either use your physical android device via USB or use the emulator provided by the SDK.

To run the app on physical device just connect the device and make sure that all its drives are installed correctly. Then press CTRL + F11 and select run as an Android Application.

To run on an emulator setup an AVD (Android Virtual Device) by going to Window > Android Virtual Device Manger. Then click on Create and fill in the dialog box for the properties on the AVD. Now select the AVD and click on Start. And to run the app press CTRL + F11.

If there are no errors (which won’t be the case), then the app will launch either on the device you connected or on an AVD.