Thursday, April 14, 2011

game Tutorial

URL:http://www.quesucede.com/page/show/id/conway_game_of_life_android
URL:http://www.androidpit.de/de/android/wiki/view/Spieleentwicklung_101



 

Twitter Updates

  • A personal challenge: build a #topicmap application (viewer) with #GWT within a week with no prior knowledge of GWT whatsoever. 239 days ago
  • Test tweet from #Flex application. 251 days ago
  • Test tweet from #Flex application. 253 days ago
follow me on Twitter
hacker emblem
Page trailPage trail: Google Android tutorial pa...

Google Android tutorial part 1 - Conway's Game of Life

IconDetails...

Android tutorial part 1 - Conway's Game of Life

Content
  • Day One - Why build Conway's Game of Life for Google Android?
  • Day Two - Starting to build the application
  • Day Three - First run
  • Day Four - Wiring the initial UI together
This tutorial has a second part: Android tutorial part 2 - Conway's Game of Life.
Update on Wednesday, January 26, 2011:
Update on Monday, December 20, 2010:
Update on Saturday, November 13, 2010:
Update on Monday, July 12, 2010:
Update on Friday, June 18, 2010:

Survey - ProjectMappr

ProjectMappr is an application that enables the user to both quickly and easily create and subsequently visualize, explore and extend a network of related topics.
The application enables the user to harness both content and context to make the use of knowledge much easier contributing to the increase of contextual intelligence.
Features include:
  • Visual exploration of the (topic map) graph contributing to the discovery of information.
  • Ability to add arbitrary data to topics, including (but not limited to): text, images, PDF files, videos, Twitter searches, meta data, etcetera.
  • The ability to create semantically rich relationships between topics.
  • Program data is stored locally making it unnecessary to have an Internet connection to work with the application.
  • Automatically build context around user interactions, e.g., topics are optionally linked within a timeline.
  • Automatic categorization and self-organization of topics by means of tagging.
Target users:
  • Students.
  • Knowledge workers.
  • Researchers.
  • Hobbyists.
Basically anyone that needs to map one or more areas of domain knowledge ensuring that the appropriate information can be easily found and extended within the context of said information can be considered a target user.
Interested in ProjectMappr? Please fill out the (the very short) survey. Thanks in advance :-)

Day One - Why build Conway's Game of Life for Google Android?

For reference sake, I've based a lot of the code in the initial part of this tutorial on what I read from the book "Hello, Android - Introducing Google's Mobile Development Platform," from The Pragmatic Programmers. However, the second part of the tutorial is completely unrelated to before-mentioned book and unique to my own learning experience.
Basically, my initial motivation to write this tutorial was one of self-interest, that is, when you are forced to document something that you are in the process of learning, it helps to reinforce said learning experience.
As a developer, I am always looking out for new and interesting technologies and it takes no real leap of faith to see that mobile computing (in all its forms) is going to outright dominate the field of software development for the foreseeable future - mobile is going to be big... really, really BIG!
Furthermore, in my opinion, the writing is on the wall, that is, Google's Android platform will be established as a major player if not the player within the mobile market within the next couple of years, eventually overtaking both Apple and RIM within the smartphone market. We're not there yet (and perhaps we shouldn't ever 'get there' completely - competition is good), but I do see it happening sooner or later.
Hence, this tutorial is aimed at developers that know how to download and install SDKs, have a reasonable level of experience with Eclipse and specifically Java (the language) but at the same time do not have any real experience (like me) at building applications targeting Google Android.
Why Conway's Game of Life? Well, Conway's Game of Life is a very simple cellular automaton (for a more in-depth overview of the game, check out the article at Wikipedia for Conway's Game of Life) - the problem space is small enough to allow me to only focus on Google Android while still including sufficient elements to make for both an interesting and valid learning experience. For example, the application includes:
  • a 'game' loop (in its own thread):
    • update state
    • update input
    • update calculations
    • update animations
  • GUI components with binding
  • a custom GUI component

Overview of application

Conway's Game of Life Java applet
Looking at the screen shot of my original Java applet-version of the Game of Life, the following components have been laid out (from top to bottom):
  • the actual (infinite) two-dimensional orthogonal grid of square cells
  • 'minimum' or underpopulation variable spinner (see Game of Life rules below)
  • 'maximum' or overpopulation variable spinner (see Game of Life rules below)
  • 'hit' or spawn (new cell) variable spinner (see Game of Life rules below)
  • animation speed or evolution speed variable spinner
  • cell shape drop-down (not to be implemented)
  • colour coded tick box (mapping the rate of survival to colours, that is, number of iterations that a cell has survived to a distinct colour) - to be implemented in version 1.1
  • iteration or generation counter
If you look at the above list of components, they are all standard widgets except for the first one - the two-dimensional grid. Off the top of my head after having skimmed over the Android Developer's Guide, I think I will need to implement my own custom component that will draw with a Canvas on a View or SurfaceView - not sure yet.
Furthermore, the actual layout declaration is very simple: a vertical layout containing the custom grid component, several (embedded) horizontal layouts for the sliders and their corresponding labels, the tick-box for enabling or disabling the colour-coding and the generation counter.

Algorithm

The actual algorithm used to generate each successive generation is (perhaps) surprisingly simple: the Life patterns are represented as two-dimensional arrays. Two arrays are used, the first one to hold the current generation and the second one in which the next generation is calculated. Obviously, a zero will be used to represent dead cells and a one will represent live cells.
Each cell will be iterated over - an inner loop will be used to count the number of live neighbours to decide if the corresponding cell will 'live or die' in the next generation. Once all cells of the current generation have been iterated over and the corresponding successor array has been calculated, the successor array becomes the current (generation) array and is displayed, i.e., the two arrays swap roles.
With regards to the edges, in theory, the Life grid is infinite - this however, is not practical. Hence, I have adopted the strategy of wrapping the grid around, that is, both the top and bottom and left and right edges run over into one another - a toroidal array (check out the article in Wikipedia, if for no other reason than that there is a cool animated GIF of a punctured torus been turned inside-out).
Basically, there are only four methods of importance from the point of view of the algorithm as outlined above:
  • nextGeneration: the so called driver method (the following three methods/functions are called from the nextGeneration method)
  • calc: this function actually determines how many live neighbours each individual cell has
  • duplicateGrid: this method copies the contents of one array to another array
  • initGrid: this method 'resets' an array, that is, it sets all of the elements of the array to zero
Obviously, it makes sense to encapsulate all of the above methods and any other helper methods into their own class.

Game of Life rules

See Wikipedia (copied here for reference purposes): Game of Life's rules.
The universe of the Game of Life is an infinite two-dimensional orthogonal grid of square cells, each of which is in one of two possible states, live or dead. Every cell interacts with its eight neighbors, which are the cells that are directly horizontally, vertically, or diagonally adjacent. At each step in time, the following transitions occur:
  • any live cell with fewer than two live neighbours dies, as if caused by underpopulation
  • any live cell with more than three live neighbours dies, as if by overcrowding
  • any live cell with two or three live neighbours lives on to the next generation
  • any dead cell with exactly three live neighbours becomes a live cell

Day Two - Starting to build the application

Today, I am actually going to start to lay out the application. I initially envisage the application having a main screen with the following UI elements laid out vertically from top to bottom:
  • A TextView component - the name of the application.
  • A Continue button - display the application's principal screen with the grid of cells (to display the Life patterns) and the various components that will allow the user to interact with the Life patterns - allowing the user to continue where she left off.
  • A New Game button - reset both the Life pattern and the accompanying components to their initial state.
  • An About button - self explanatory.
  • An Exit button - self explanatory.
Implementing the application as described above means that I will need to cover several important concepts of Android's application development model, specifically:
  • Activities: the application's presentation layer. Each and every screen in an application has to extend the Activity class. Activities use Views to make up graphical user interfaces.
  • Views: views are the graphical user interface (GUI) elements that make up the basic building blocks of a user interface. Each component knows how to draw itself - views themselves are hierarchical.
  • Intents: Intents are a message-passing mechanism that works both within an application, and between applications. One of the most common uses for Intents is to start new Activities.
  • The application manifest (AndroidManifest.xml): the manifest file defines both the content and behaviour of the application. For example, it lists the application's activities, services, and corresponding permissions.
Anyway, let's start...
I'll create the project with the following values:
Conway's Game of Life for Android - Eclipse New Project wizard
After having stepped through the New Project wizard, the project is created with the following files:
Conway's Game of Life for Android - Initial project files

Day Three - First run

Initially, the files of interest are:
  • MainActivity.java - as the name implies, the main activity/screen of the application.
  • res/layout/main.xml - the MainActivity's accompanying layout resource. If you think about it, UIs can be implemented using one of two methods: procedural (like Swing) and declarative (like HTML). With Android you can use both methodologies - in this case main.xml is the MainActivity's UI in declarative XML.
  • strings.xml - instead of hard-coding (in this case, English) text into the layout files, with Android you use the @string/resid syntax to reference strings in the res/values/strings.xml file (we will see examples of this in a minute).
  • AndroidManifest.xml - every activity (among other things) needs to be declared in AndroidManifest.xml.
Let's start looking at some code. I'll start with MainActivity.java:

MainActivity.java

package com.quesucede.gameoflife;

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

public class MainActivity extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }
}
There are a couple of important things going on here:
  • the MainActivity class extends the Activity class
  • the onCreate method is overridden; within said method a call to the super method is called with the appropriate parameter (savedInstanceState).
  • within the onCreate method, a call to setContentView fills in the contents of the activity's screen with an Android view; in this case, said view is defined in res/layout/main.xml.

main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:background="@color/background" android:layout_height="fill_parent"
    android:layout_width="fill_parent" android:padding="30dip"
    android:orientation="horizontal">
    <LinearLayout android:orientation="vertical"
        android:layout_height="wrap_content" android:layout_width="fill_parent"
        android:layout_gravity="center">
        <TextView android:text="@string/main_title"
            android:layout_height="wrap_content" android:layout_width="wrap_content"
            android:layout_gravity="center" android:layout_marginBottom="25dip"
            android:textSize="24.5sp" />
        <Button android:id="@+id/continue_button" android:layout_width="fill_parent"
            android:layout_height="wrap_content" android:text="@string/continue_label" />
        <Button android:id="@+id/new_button" android:layout_width="fill_parent"
            android:layout_height="wrap_content" android:text="@string/new_game_label" />
        <Button android:id="@+id/about_button" android:layout_width="fill_parent"
            android:layout_height="wrap_content" android:text="@string/about_label" />
        <Button android:id="@+id/exit_button" android:layout_width="fill_parent"
            android:layout_height="wrap_content" android:text="@string/exit_label" />
    </LinearLayout>
</LinearLayout>
Relevant URLs
Again, let's take a look at a couple of interesting things in the main.xml file:
  • LinearLayout - layouts are hierarchical containers for objects with an associated positioning behaviour, e.g., LinearLayout positions its embedded objects in a single column or row.
  • A new syntax, @+id/resid - basically, this syntax allows us to create an ID in-line instead of referring to a resource ID defined somewhere else. For example, @+id/continue_button actually defines the ID for the Continue button so that we can reference it, later on.
  • android:layout_width="fill_parent" and android:layout_height="fill_parent" - indicates that the layout should take up the entire width and height of the parent view.
  • units of measurements, e.g., dip and sp - Android supports several screen resolutions and corresponding densities. The density of a screen is important because, other things being equal, a UI element (such as a button) whose height and width are defined in terms of screen pixels will appear larger on the lower density screen and smaller on the higher density screen. Resolution-independent measurements help solve this problem. Android supports all the following units:
    • px (pixels) - dots on the screen.
    • in (inches) - size as measured by a ruler.
    • mm (millimeters) - size as measured by a ruler.
    • pt (points) - 1/72 of an inch.
    • dp or dip (density-independent pixels) - the density-independent pixel is equivalent to one physical pixel on a 160 dpi screen, the baseline density of Android. The conversion of dip units to screen pixels is simple: pixels = dips * (density / 160). For example, on 240 dpi screen, 1 dip would equal 1.5 physical pixels.
    • sp (scale-independent pixels) - similar to dp but also scaled by the user’s font size preference.
Using dp units and sp units (for text) to define your application's UI is highly recommended, as a way of ensuring that your interface is scalable to any current and future type of display.

strings.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="app_name">Android Game of Life</string>
    <string name="main_title">Android Game of Life</string>
    <string name="continue_label">Continue</string>
    <string name="new_game_label">New Game</string>
    <string name="about_label">About</string>
    <string name="exit_label">Exit</string>
</resources>
Relevant URLs
The application's resource strings are defined in the res/values/strings.xml file. Each resource string has an accompanying name attribute for reference purposes. For example, within the main.xml, the TextView widget references the resource string main_title as follows: @string/main_title.
Basically, what this accomplishes is a decoupling of an application's resource strings making hard-coding of resource strings unnecessary. From a maintenance point of view of the source-code (or translation point of view of the UI) I can imagine that this is a real time-saver.

colors.xml

<?xml version="1.0" encoding="UTF-8"?>
<resources>
    <color name="background">#596f87</color>
</resources>
The res/values/colors.xml fulfills a similar purpose as res/values/strings.xml.

AndroidManifest.xml

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.quesucede.gameoflife" android:versionCode="1"
    android:versionName="1.0">
    <application android:icon="@drawable/icon" android:label="@string/app_name">
        <activity android:name=".MainActivity" android:label="@string/app_name">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>
Relevant URLs
Each Android project has a manifest file, AndroidManifest.xml located in the root of the project hierarchy. It governs both how your application's components (Activities, Content Providers, Broadcast Receivers, and Services) interact with one another and with other applications on the device by means of Intent Filters and Permissions.
In addition, the manifest also includes attributes to define application metadata (e.g., icon), and additional tags for security settings, hardware and platform requirements, etcetera.
It's important to remember that the Android Development Tools (ADT) plugin includes a visual manifest editor so that you don't have to edit the underlying XML directly.

Creating a new Android Virtual Device (AVD)

Conway's Game of Life for Android - Create new Android Virtual Device
Relevant URLs
Obviously, unless you have a physical Android device, you will need to prototype, debug and test your application on a virtual device with the Android emulator. The emulator enables the creation of Android Virtual Devices (AVDs) - a combination of a specific version of the Android platform, hardware options and emulator skin.
With regards to screen size (or emulator skin), I have opted for HVGA (320 x 480), 3.0"-3.5" diagonal - the Android's platform baseline screen (because all applications written against Android 1.5 or earlier are written for the HVGA screen used on the T-Mobile G1 and similar devices).

The application's initial screen

Conway's Game of Life - First Android screen shot
With the code as provided above, running the application from within Eclipse will deploy the application to the Android emulator and subsequently execute the application. The screen shot provided above shows the UI of the application's main screen. Obviously, at this stage, clicking on the buttons does not perform any kind of action within the application.

Day Four - Wiring the initial UI together

The first screen that I am going to wire up is the About screen. Initially, all that is needed is the About Activity (AboutActivity.java file) and its accompanying resource file (res/layout/about.xml).

AboutActivity.java

package com.quesucede.gameoflife;

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);
    }
}
Nothing of interest here... move on ;-)

about.xml

<?xml version="1.0" encoding="utf-8"?>
<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent" android:layout_height="fill_parent"
    android:padding="10dip">
    <TextView android:id="@+id/about_content"
        android:layout_width="wrap_content" android:layout_height="wrap_content"
        android:text="@string/about_text" />
</ScrollView>
The only thing of interest in the about.xml file (provided above) is the in-line creation of a new resource ID (@+id/about_content) and an additional reference to a resource string (@string/about_text) meaning that I will have to add it to the res/values/strings.xml file.

strings.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="app_name">Android Game of Life</string>
    <string name="main_title">Android Game of Life</string>
    <string name="continue_label">Continue</string>
    <string name="new_game_label">New Game</string>
    <string name="about_label">About</string>
    <string name="exit_label">Exit</string>
    <string name="about_title">About Android Game of Life</string>
    <string name="about_text">
The Game of Life, also known simply as Life, is a 
<i>cellular automaton</i> devised by the British mathematician 
John Horton Conway in 1970. It is the best-known example 
of a cellular automaton.
    </string>
</resources>
Finally, this is where things start to get interesting... an action needs to be performed when the user clicks on the About button. This is where intents come into the picture. Let's take a look at the modified MainActivity.java file.

MainActivity.java

package com.quesucede.gameoflife;

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

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

        // click-handlers for buttons
        View aboutButton = findViewById(R.id.about_button);
        aboutButton.setOnClickListener(this);
    }

    public void onClick(View v) {
        switch (v.getId()) {
        case R.id.about_button:
            Intent i = new Intent(this, AboutActivity.class);
            startActivity(i);
            break;
        }
    }
}
Relevant URLs
Let's take a closer look at MainActivity:
  • both android.content.Intent and android.view.View.OnClickListener are imported
  • the MainActivity class declares to implement the OnClickListener interface, specifically the onClick method is implemented
  • an OnClickListener is set for the About button (which is located by its ID (R.id.about_button)
  • within the onClick method a switch statement is used to determine which view (button) was clicked and depending on the button clicked (in this case, we have only set up a listener for the About button), an Intent object is created and the appropriate activity (AboutActivity.class) is passed to it followed by the activity being started by passing in the, previously created, Intent object
Running the application again and clicking on the About button will give you an error.
Conway's Game of Life - Android application error
What happened? Easy... every activity has to be declared in the AndroidManifest.xml file. So, let's add the appropriate entry to the manifest file:

AndroidManifest.xml - AboutActivity

<activity android:name=".AboutActivity" android:label="@string/about_title"
    android:theme="@android:style/Theme.Dialog">
</activity>
Furthermore, if you take a closer look at the above entry you will see that there is also a reference to a predefined style (@android:style/Theme.Dialog). What this means is that the AboutActivity will take on the look-and-feel defined by Android (with the @android prefix) instead of an arbitrary style defined by the application.
Executing the application and clicking the About button will display the screen as show.
Conway's Game of Life - About screen
Relevant URLs
This basically concludes the first part of this tutorial. The next part is going to be much more interesting and will include, among others, the development of a custom component (the two-dimensional orthogonal grid), binding components to data and threads.
This tutorial has a second part: Android tutorial part 2 - Conway's Game of Life.

Comments
A note of warning@ 10-05-31 23:08:04 by Admin user a.k.a. Brett Kromkamp
For anyone that stumbles onto this page... please keep in mind that this is a work in progress. Something that will be added to and updated over the course of the next few weeks starting from May 30, 2010.

Site comment system and moderation tool@ 10-06-02 23:43:37 by Admin user a.k.a. Brett Kromkamp
I intend to integrate DISQUS (a comment system and moderation tool) into my site within the next couple of days for feedback purposes. In the meantime, if you want to contact me with regards to the tutorial, send a mail to brettkromkamp@gmail.com.

Acknowledgement@ 10-06-02 23:19:09 by Admin user a.k.a. Brett Kromkamp
I've based a lot of the code in the initial part of this tutorial on what I am reading from the book Hello, Android - Introducing Google's Mobile Development Platform, from The Pragmatic Programmers.


Click here to be able to create pages, upload images and file attachments, and link to other users and their pages.

Glad you liked it. Would you like to share?

Sharing this page …
Thanks! Close

Add New Comment

Image

Showing 22 comments

Sort by   Subscribe by email   Subscribe by RSS
  • EtWilkinson 3 weeks ago
    if anybody need more information on how to program screen independent, this book seems a good starting point...
    Device and Display Independent Programming in Android
    [Screen, resolution, density & API level independent applications]
    Read More her:
    http://androidforums.com/class...
    Buy Here:
    http://schogini.com/shop/nano-...
  • Hyunjungsoh 2 months ago
    0 down vote favorite


    I guess this is just a simple question (I’m such a noob…) I have this custom dialog box that has 3 buttons in it.

    Now I want to call an activity from one of the buttons so I tried this:
    [code]
    public class picturedialog extends Dialog implements OnClickListener {
    Button Camera;

    public picturedialog (Context context){
    super (context);
    setContentView(R.layout.picturedialog);

    Camera = (Button) this.findViewById(R.id.pdButton1);

    Camera.setOnClickListener(new View.OnClickListener() {
    public void onClick(View view) {
    dismiss();

    Intent myIntent = new Intent(view.getContext(), CameraActivity.class);
    startActivity(myIntent);

    }
    });
    ...
    }[/code]

    Then the red squiggly line appears on startActivity(myIntent). Upon hovering on it, eclipse tells me this: “The method startActivity(Intent) is undefined for the type new View.OnClickListener(){}” Ehhh? Please orient me on how to do this properly. Any help would be appreciated.
  • I am beginner for android.. this tutorial is very easy to learn... I like this very much..
  • this is awesomeeeeee .... plz plz plz upload more of these ..... :)
  • Bloody fantastic tutorial! Excellent explanations every step of the way. I hope to see more from you!
  • Wfilla 2 weeks ago
    I never get past the "application has stopped unexpectedly error." Any ideas on what would cause it? Tried 3 times recreating this project. Happens every single time.
  • Wfilla 2 weeks ago
    I never get past "Day3" because of the error about the application stopping unexpectedly. Any ideas?
  • Nice copy paste from one of the most famose android BOOKs on the market...lol
  • Hi lol,

    You're right, specifically the first part of the tutorial is based on the book "Hello Android" from the Pragmatic Programmers. I explicitly acknowledge that fact in a comment, just below the end of the first part of the tutorial: "I've based a lot of the code in the initial part of this tutorial on what I am reading from the book Hello, Android - Introducing Google's Mobile Development Platform, from The Pragmatic Programmers." Said acknowledgement has been there since I published the tutorial. However, the second part of the tutorial is completely unrelated to before-mentioned book and unique to my own learning experience.

    But thanks for the comment, anyway.

    Brett
  • This is excellent. I'm just starting out with Android & Java (after 20+ years of asm, C, C++ & C#) and this is a fantastic introduction. Many thanks for sharing!
  • Thanks for the tutorial, this is amazing! However I'm having a problem, after creating the colors.xml file in the values folder it keeps moving the strings.xml out of the value folder and won't let put it back in. Help please?
  • Varandtin 5 months ago
    can I do something that Dialog appearing on About button, has Close button?
  • Arulselvam 5 months ago
    how to exit in multiple intent
  • Best tutorial to understand the basics instead of going through the long tutorial at google site. Kudos to you man. Thank you very much for sharing.
  • Likewise... thanks for your kind words. Again, knowing that the tutorial has been useful makes the time spent on it worth while.

    Cheers,

    Brett
  • Codecoaster 9 months ago
    best android tutorial I've seen so far!
  • Glad you enjoyed the tutorial, Codecoaster. As I learn new stuff, I will be writing more. Knowing that it is appreciated makes it worth the while.

    Regards,

    Brett
  • Codecoaster,

    Thanks for your kind words... feedback like this really encourages me to continue with the third part of the tutorial.

    Brett
  • Girish601 9 months ago
    Hi
    It was a good tutorial.
    But i wanted to know, how did you changed the emulator screens.(Emulator Screen no.2)
    I liked it, can you tell more on that
  • Hi Girish601,

    On the home screen, press the Menu button, followed by selecting Wallpaper... a dialog box appears asking you to select either a live wallpaper, picture, or (static) wallpaper.

    Brett
  • brettkromkamp 10 months ago
    Hi Jonathan,

    I'm going to implement Conway's Game of Life in Flex 4... when it's finished, it will obviously deploy it on to my site. Thanks for your interest.

    Brett
  • Jonathan 10 months ago
    Be really neat if you had a little mini-demo of life running on the home screen.

Reactions

  • anoop_ch 3 weeks ago
      From  twitter
    Google Android tutorial part 1 - Conway's Game of Life: http://www.quesucede.com/page/show/id/conway_game_of_life_android
  • bubbl 10 months ago
      From  twitter
    Google Android tutorial part 1 - Conway's Game of Life http://ff.im/-m4Oah
  • well_well_well 10 months ago
      From  reddit
    hopefully eclipse will have finished loading by the time the article is completed!
  • AndroidMexico 10 months ago
      From  twitter
    Google Android tutorial part 1 - Conway's Game of Life - http://goo.gl/UwR2
  • ljohndotnet 10 months ago
      From  twitter
    Google Android tutorial part 1 - Conway's Game of Life - http://is.gd/cGsE3
  • delicious50 10 months ago
      From  twitter
    Google Android tutorial part 1 - Conway's Game of Life http://bit.ly/9XLY6z
  • zanthraxnl 10 months ago
      From  reddit
    That's what the 'save' button is for.
  • rlaksana 10 months ago
      From  twitter
    A comprehensive Android development tutorial - http://su.pr/2o423K
  • kissenlall 10 months ago
      From  twitter
    RT @quesucede: Started writing what should eventually be a comprehensive #Android development tutorial: http://bit.ly/abNsYJ
  • modulus 10 months ago
      From  reddit
    Mark.
Trackback URL 
blog comments powered by Disqus




Posted by at

1 comment:

  1. UnknownJuly 20, 2012 at 7:32 PM

    Philippine blogger Bryan Yambao went from reading his mother magazines to the front rows of the world top catwalks at warp speed, as the Internet demolishes the exclusive barriers of high fashion.
    dsafqqzzxxccasasa isabel marant willow sneaker

    ReplyDelete

Subscribe to: Post Comments (Atom)