Now assuming you have installed everything required. You can go a head and open up Eclipse and we can create a simple application. So simply click on file > new > Android Project (If you don’t see Android Project then you have not installed it correctly)

Once we select that we then get a new popup to name our project. Just give it a name (anything you want, i called mine HelloWorldApp).

Now it asks for us to select an API target. Of course selecting the correct one is important. If you want your app to work on older phones, then you will need to select a low API number. For the sake of this tutorial i used Android Open Source Project – API 7. You can of course use anyone you want.

Application Information

Application Name: This is just the name of your app
Package Name: This is just the package all your code will be put into
Create Activity: This will be the main Activity of your application. This will be the first Activity loaded and will basically be the start point.
Minimum SDK: This is the Minimum version of Android needed to use your app.

Don’t worry about Create a Test Project

Getting Started

Now your workspace should be set up and in your Package Explorer (usually on the Left) you should see your App folder set up. You should see the following Folder set up.

src - This is where your java files will be for your app. You will notice the Activity you created is in there.
gen – This is not important, only you will be using the R.java file to access resources
Android 2.1 (or whatever version you picked) - Dont worry about it
Assets - Not needed in this tutorial. If you use PhoneGap, this folder will be used to store html files and so on.
bin – Not needed in this tutorial
res - This is the resource folder and will contain all your applications images, icons and layouts. These resources can be accessed using the R.java file (more on that later).

AndroidManifest.xml

Before the Android system can start an application component, the system must know that the component exists by reading the application’s AndroidManifest.xml file (the “manifest” file). Your application must declare all its components in this file, which must be at the root of the application project directory.

You can find out more here

Resources

Under the res folder you will notice a couple of other folders. All these resources can be accessed using the R.java file (explained later).

drawable-hdpi - high quality images here
drawable-ldpi - low quality images here
drawable-mdpi – medium quality images here
layout – stores XML layouts (made up of buttons, lists and so on).
values - this stores values that can be used in the game. For instance if you wanted to support other languages. This could store values that can be referenced in your app.

Looking at code

Go ahead and open up the Activity file that was automatically created when you created the project. This is under the src > package name folder and you should see something as follows:

package hello.world.app;

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

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

When the application is started the onCreate method is always run first when an Activity starts. So this is a good place to do some setting up. You can also see that our HelloWorldActivity extends Activity and that we are overriding the Activity classes version of onCreate, but still sending data up to it.

You will also notice that we have set a content view and also used the R.java file as mentioned before (R.layout.main). This means we have loaded the layout file in the folder layout with the name main (with extension .xml). You can also open this file and mess with the layout. Luckily eclipse does allow you to view it as it would look on the phone and also allow you to click and drag new things onto it. (It can take a couple seconds to load the main.xml file).

We can also view the code of the file by selecting the the main.xml tab (next to Graphical Layout). The code looks like:

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

    <TextView
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:text="@string/hello" />

</LinearLayout>

You will notice a couple things. Where it says android:text”@string/hello”. Well this simply refers to the value stored in “hello” within the values folder and in the file strings.xml.

<?xml version="1.0" encoding="utf-8"?>
<resources>

    <string name="hello">Hello World, HelloWorldAppActivity!</string>
    <string name="app_name">HelloWorldApp</string>

</resources>

Thats the reason when in the graphical view of the main.xml file. We can see the text that is stored in the strings.xml file.

Activity

An Activity is an application component that provides a screen with which users can interact in order to do something, such as dial the phone, take a photo, send an email, or view a map. Each activity is given a window in which to draw its user interface. The window typically fills the screen, but may be smaller than the screen and float on top of other windows.

So our application will be made from a number of different Activities. You remember that we had in our activity onCreate method, but we can also override other methods (that should be implemented when cleaning up things)

@Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // The activity is being created.
    }
    @Override
    protected void onStart() {
        super.onStart();
        // The activity is about to become visible.
    }
    @Override
    protected void onResume() {
        super.onResume();
        // The activity has become visible (it is now "resumed").
    }
    @Override
    protected void onPause() {
        super.onPause();
        // Another activity is taking focus (this activity is about to be "paused").
    }
    @Override
    protected void onStop() {
        super.onStop();
        // The activity is no longer visible (it is now "stopped")
    }
    @Override
    protected void onDestroy() {
        super.onDestroy();
        // The activity is about to be destroyed.
    }

You don’t have to implement them all, but you should be aware of them and understanding them will help you stop errors. You can understand how the life cycle works by looking at this picture.

Making a new activity

You can make a new activity simply by adding a new Java file (in the same folder the first Activity). There are a couple things you need to consider doing before it will work though. Whenever you add a new Activity, you need to add it to the AndroidManifest otherwise it won’t recognize it.

You can add a new Activity by right clicking on the package name under the src folder and click New > Class. When the popup appears simply give it a name. Its a good idea to give it a meaningful name and also finish it with Activity so, AboutActivity.java or something similar. This Activity will display show the about information.To make it easier you should place android.app.Activity in the superclass field provided.

When it is created it be as follows:

package hello.world.app;

import android.app.Activity;

public class AboutActivity extends Activity {

}

It is missing the onCreate method of course.

package hello.world.app;

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

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

As mentioned before we need to register that new Activity in the Manifest, so open the AndroidManifest and select the AndroidManifest.xml tab to view the code. We simply add a new Activity tag as follows.

<activity
   android:name=".AboutActivity" >
</activity>

So now our manifest looks like

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="hello.world.app"
    android:versionCode="1"
    android:versionName="1.0" >

    <uses-sdk android:minSdkVersion="7" />

    <application
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name" >
        <activity
            android:label="@string/app_name"
            android:name=".HelloWorldAppActivity" >
            <intent-filter >
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
         <activity
            android:name=".AboutActivity" >
         </activity>
    </application>

</manifest>

We also need to add a new layout file for our new Activity. This is the layout that will be loaded when the Activity is created. So you can right click on the Layout folder in the Res folder > New > Android XML file. Then its a matter of selecting some settings to make it easier for yourself.

Now we have a new layout and tell our AboutActivity to load that layout using the R.java file as used before. Now out AboutActivity code would like the following

package hello.world.app;

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

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

We have used R.layout.about to refer to our new layout file.

Switching between Activities

So now we can switch between the two activities. We shall create a button in our main.xml file as follows

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

    <TextView
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:text="@string/hello" />

    <Button
        android:id="@+id/button1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Show About" />

</LinearLayout>

So we now have a TextView and a button underneath it. Now we need to write the code to make that button do something when clicked. So we go back to our MainActivity java file and update it

package hello.world.app;

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

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

        //Our button in main.xml with the id button1
        Button aboutButton = (Button) this.findViewById(R.id.button1);
        aboutButton.setOnClickListener(new OnClickListener(){
		@Override
		public void onClick(View arg0) {

		}
        });
    }
}

So we have created a new variable with the data type Button (we have to import the library also). Then we use findViewById method to find the button we are looking (we reference to it by its id as defined in the XML file). Then we cast it to a Button.

Now we set the OnClickListener and create an instance of the OnClickListener interface and implement the required method onClick. Within this onClick method we simply put the code to jump to the other Activity we have created. Now when ever that button is clicked. That onClick method will be run and any code within it.

Intent

In order to switch between Activities and load other programs and so on. We need to use a thing known as an Intent. This is basically something that is passed to and from Activities to say you want to do something. So we want to load a new Activity. So we need to create an Intent and pass it to a function called startActivity and we need to pass it an Intent with the details of the intent we wish to run.

@Override
public void onClick(View view) {
    view.getContext().startActivity(new Intent(view.getContext(), AboutActivity.class));
}

Now our onClick method looks as above. You will also need to important the Intent library to the top. You are to provide the Context and the name of the class of the Activity you wish to load (as shown above). Now when you run the code (it should load up Emulator, but you can connect your phone to test the app, which is faster)

I think that’s a good start. I shall continue soon

Dreamweaver CS5.5

I have noticed that the newer version of Dreamweaver now allows you to create apps.

And the thing is that although i found installing the Android SDK onto your machine and setting it up via Eclipse can be a pain, but with Dreamweaver its no problem at all. Of course the fact you have to pay for Dreamweaver is a pain i know, but hey, its worth a trial run.

Things to look into

If you find yourself interested in learning how to make apps for your phone. Then i can suggest looking at the following:

http://phonegap.com/
http://jquerymobile.com/

I think at some point i shall write a small tutorial on how to make a simple app with the tools mentioned. So i guess watch this space.

* Comments can now be toggled (hidden)
* WYSIWYG editor has now been added to allow for HTML (safely)
* Style has been updated
* JQuery is now used to make system flow better and look better
* Copyright has been added to system (with link to my website)

Download
Downloaded 6229 times

You can find more information on the NewsBook page

Dr Paul Stysley says

“Experiments have shown that laser-based trapping of particles is not beyond us”

Who is the principal investigator on tractor beam research at NASA’s Goddard Space Flight Center.

“If we can figure out the best way to do it, then scale it up, we could collect samples from, say, comet tails over greater distances and longer time periods than is possible.”

The first technique being explored is “optical tweezers”, which is already used on Earth. Others include solenoid beams, Bessel beam, but of course it’s still early days.

Just trying to move tiny particles at the distances required for sample collection is an ambitious goal, which is probably 10 years away”

Apparently it was first thought to use it for cleaning up orbital debris. But to control something so large is far beyond current technology. So it would seem that soon Star Trek will become a thing of fact, rather than fiction! (in terms of actually producing the technology involved in Star Trek).

After a while the trend died down, but a lot of people thought it was because Twitter censored it, but that is not the case. They have nothing to do with trends and preventing them, they simply use an algorithm and because trends never last that long, so it was of course obvious that it would eventually die down. You can read more here.

Some shameful reactions

WHAT THE FUCKING FUCK?, Whoever started #GodIsNotGreat needs the shit beat out of them! >:I HOW DARE YOU!

#GodIsNotGreat Gotta kill the person who said this..!

If you’re really comin up with reason why #GodIsNotGreat, kill yourself.

My favorite of course, which just proves my point about being glad to be an atheist.

#Whoever said #GodIsNotGreat shoot yourself! U sound real stupid. His the Greatest:*

The educational system at its best there. I could more than likely make a safe bet that most of these comments are from the pleasant people of the USA, but that’s just a guess of course.