Tim Layton - IT & Technology Blog

How to Make a Custom Icon for Your Android App & Design Considerations

noreply@blogger.com (Display Name) — Sun, 06 Nov 2011 14:54:00 +0000

In this video lesson Tim Layton walks you through how to make a custom icon for your Android app and the variables that you need to consider for different resolutions and formats. Tim also discusses the current population of devices by OS version and hardware type to help you form a strategy for your development efforts.

The "Android Programming in 10 Days" series helps developers learn the skills they need to write Android applications for mobile phones, tablets and devices. Android has never been more popular and with the release of API 14 "Ice Cream Sandwich" developers can now create applications for all Android devices in a single environment.

Android 4.0 brings a unified UI framework that lets developers create elegant, innovative apps for phones, tablets, and more. It includes all of the familiar Android 3.x interface elements and APIs — fragments, content loaders, Action Bar, rich notifications, resizable home screen widgets, and more — as well as new elements and APIs.

For developers, the unified UI framework in Android 4.0 means new UI tools, consistent design practices, simplified code and resources, and streamlined development across the range of Android-powered devices.

For Android specific information visit Tim's portal at http://www.learnandroidsdk.com and for all of Tim's IT tips and programming lessons visit http://techtips.timlaytonllc.com.

Tim Layton

Testing Your Android Development Environment

noreply@blogger.com (Display Name) — Fri, 04 Nov 2011 22:19:00 +0000

In this training video Tim Layton walks you through testing your installed and configured Android development environment before moving onto the programming lessons.

The "Android Programming in 10 Days" series helps developers learn the skills they need to write Android applications for mobile phones, tablets and devices. Android has never been more popular and with the release of API 14 "Ice Cream Sandwich" developers can now create applications for all Android devices in a single environment.

Android 4.0 brings a unified UI framework that lets developers create elegant, innovative apps for phones, tablets, and more. It includes all of the familiar Android 3.x interface elements and APIs — fragments, content loaders, Action Bar, rich notifications, resizable home screen widgets, and more — as well as new elements and APIs.

For developers, the unified UI framework in Android 4.0 means new UI tools, consistent design practices, simplified code and resources, and streamlined development across the range of Android-powered devices.

For Android specific information visit Tim's portal at http://www.learnandroidsdk.com and for all of Tim's IT tips and programming lessons visit http://techtips.timlaytonllc.com.

Tim Layton

How to Install Eclipse and the Android Developer Tool (ADT) Plugin

noreply@blogger.com (Display Name) — Fri, 04 Nov 2011 01:41:00 +0000

In this training video Tim Layton presents and then walks you through the process of installing Eclipse and the ADT (Android Developer Tool) plugin for your Android development environment.

The "Android Programming in 10 Days" series helps developers learn the skills they need to write Android applications for mobile phones, tablets and devices. Android has never been more popular and with the release of API 14 "Ice Cream Sandwich" developers can now create applications for all Android devices in a single environment.

Android 4.0 brings a unified UI framework that lets developers create elegant, innovative apps for phones, tablets, and more. It includes all of the familiar Android 3.x interface elements and APIs — fragments, content loaders, Action Bar, rich notifications, resizable home screen widgets, and more — as well as new elements and APIs.

For developers, the unified UI framework in Android 4.0 means new UI tools, consistent design practices, simplified code and resources, and streamlined development across the range of Android-powered devices.

For Android specific information visit Tim's portal at http://www.learnandroidsdk.com and for all of Tim's IT tips and programming lessons visit http://techtips.timlaytonllc.com.

Tim Layton

How to Configure AVD (Android Virtual Devices)

noreply@blogger.com (Display Name) — Thu, 03 Nov 2011 22:10:00 +0000

In this training video Tim Layton presents and then walks you through the process of configuring AVD's (Android Virtual Devices) for your Android development environment.

The "Android Programming in 10 Days" series helps developers learn the skills they need to write Android applications for mobile phones, tablets and devices. Android has never been more popular and with the release of API 14 "Ice Cream Sandwich" developers can now create applications for all Android devices in a single environment.

Android 4.0 brings a unified UI framework that lets developers create elegant, innovative apps for phones, tablets, and more. It includes all of the familiar Android 3.x interface elements and APIs — fragments, content loaders, Action Bar, rich notifications, resizable home screen widgets, and more — as well as new elements and APIs.

For developers, the unified UI framework in Android 4.0 means new UI tools, consistent design practices, simplified code and resources, and streamlined development across the range of Android-powered devices.

For Android specific information visit Tim's Android portal at http://www.learnandroidsdk.com and for all of Tim's IT tips and programming lessons visit http://techtips.timlaytonllc.com.

Tim Layton

How to Install Android SDK

noreply@blogger.com (Display Name) — Thu, 03 Nov 2011 14:11:00 +0000

In this training video Tim Layton walks you through the system requirements and how to install the Android SDK tools on your system as part of the Android system development environment.

In this video Tim walks you through the process of installing the most current release of the Android SDK.

The "Android Programming in 10 Days" series helps developers learn the skills they need to write Android applications for mobile phones, tablets and devices. Android has never been more popular and with the release of API 14 "Ice Cream Sandwich" developers can now create applications for all Android devices in a single environment.

Android 4.0 brings a unified UI framework that lets developers create elegant, innovative apps for phones, tablets, and more. It includes all of the familiar Android 3.x interface elements and APIs — fragments, content loaders, Action Bar, rich notifications, resizable home screen widgets, and more — as well as new elements and APIs.

For developers, the unified UI framework in Android 4.0 means new UI tools, consistent design practices, simplified code and resources, and streamlined development across the range of Android-powered devices.

For Android specific information visit Tim's portal at http://www.learnandroidsdk.com and for all of Tim's IT tips and programming lessons continue to visit http://techtips.timlaytonllc.com.

Tim Layton

Using the New Samsung Galaxy 4 Player for Android Development

noreply@blogger.com (Display Name) — Wed, 02 Nov 2011 21:21:00 +0000

If you are exploring Android development or even a seasoned Android developer, you have had limited and very expensive options for testing your applications on a real device until now. If you have done much development you know the simulator, even though it has been improved, is still a long stretch from speed and viability as compared to a real device. The new Samsung Galaxy 4 Player is the perfect option for Android developers in my opinion. I picked one up today and I will keep you posted as I use it in my development efforts. Samsung also made a 5" version as well. The 4" version was $229 USD at my local Best Buy and the 5" was $269. I personally elected to go with the 4" version because it was more like a typical phone size and I felt this was more flexible for my testing process.

Both of these Android Gingerbread-based devices (2.3.5) closely resemble an Android smartphone, and that is why I think either one of these devices can be a good option for developers. The equivalent smartphone was $350 more, making this even more attractive.

The Galaxy Players can be a great choice for someone who already has a phone but wants all the perks of Android as well as access to the apps in Android Market without having to sign a two-year contract and deal with the horrific termination fees that continue to grow from the various service providers.

Both devices have a 1 GHz CPU, 512 MB of RAM, 8 GB of storage memory, expandable with microSD memory cards (up to 32 GB) and cameras on the front and back of the unit. The Player 4 has a WVGA 4.0" display (800x480) in addition to a handy FM tuner, GPS, and a multi-touch screen. The 4 inch unit weighs in at a whopping 4.27 ounces!

One of the things that I like is being able to view Adobe® Flash® Player compatible websites. Both units are fully integrated with services like Google Maps™ and YouTube™, and you can search, view, and easily download any of the over 250,000 apps available in Android Market.

For a full listing of technical specifications visit the Samsung site.

For Android specific information visit my portal at http://www.learnandroidsdk.com and for all of my IT tech tips and programming lessons visit http://techtips.timlaytonllc.com.

Tim Layton

Introducing "Learn Android Programming in 10 Days"

noreply@blogger.com (Display Name) — Wed, 02 Nov 2011 16:31:00 +0000

I am publishing a new series "Android Programming in 10 Days" helping developers learn the skills they need to write Android applications for mobile phones, tablets and devices. Android has never been more popular and with the release of API 14 "Ice Cream Sandwich" developers can now create applications for all Android devices in a single environment.

Android 4.0 brings a unified UI framework that lets developers create elegant, innovative apps for phones, tablets, and more. It includes all of the familiar Android 3.x interface elements and APIs — fragments, content loaders, Action Bar, rich notifications, resizable home screen widgets, and more — as well as new elements and APIs.

For developers, the unified UI framework in Android 4.0 means new UI tools, consistent design practices, simplified code and resources, and streamlined development across the range of Android-powered devices.

For Android specific information visit my portal at http://www.learnandroidsdk.com and for all of my IT tech tips and programming lessons visit http://techtips.timlaytonllc.com.

Tim Layton

Java Fundamentals - Lesson 2 (Coding Basics)

noreply@blogger.com (Display Name) — Fri, 29 Apr 2011 01:48:00 +0000

Java Fundamentals is a modular series of programming lessons designed by Tim Layton to help you learn Java fundamentals which are required for effective Android mobile programming. If you want to pursue other Java related programming opportunities then this series will also prove to be helpful for you as well.

In Lesson 2 of Java Fundamentals Tim Layton helps you begin to get your arms around Java development by walking you through some important programming basics. Before you can develop real-world OOP programs in Java or Android a developer must understand the foundational topics in the target language and be able to use this knowledge as second nature. Tim introduces several key topics in Lesson 2 to include: identifiers, code blocks, class declaration, primitive data types (int and double), numeric variables, arithmetic operators, if and for statements and string variables.

You can download Java Fundamentals - Lesson 2 - (Coding Basics) in ePub format from my lulu storefront. It is also available in PDF format for those that don't have the ability to read digital ePub files. The Amazon Kindle book can be purchased directly from amazon.com. The Kindle book can be viewed on any device and computing platform supported. The Kindle application works on the PC, Mac, iPhone, iPad, iPod, Blackberry, Android devices.

You can also download the HD video lesson from my lulu store.

If you have read the Introduction lesson you may want to do that now and also make sure your software is installed and configured as outlined in this lesson.

Introduction

In lesson 2 of Java Fundamentals Tim Layton helps you begin to get your arms around Java development by walking you through some important programming basics. Before you can develop real-world OOP programs in Java or Android a developer must understand the foundational topics in the target language and be able to use this knowledge as second nature. Tim introduces several key topics in Lesson 2 to include: identifiers, code blocks, class declaration, primitive data types (int and double), numeric variables, arithmetic operators, if and for statements and string variables. As with all of Tim’s Java Fundamentals lessons he also shows you how to use these concepts via a customized video tutorial.    One advantage of the Java Fundamentals series being published in electronic format is the ability to provide links to external resources allowing you to quickly follow them within the context of the lesson.

I want to remind the readers of my Java Fundamentals series that I created this series of lessons specifically for aspiring Android mobile developers. At first glance new Android developers may think they can jump right in after they get Eclipse installed and the ADT plugin working. While that may be true for a few seasoned OOP developers most will find they keep falling short because of the obvious Java underpinnings.

My goal with this series is to find the right balance of information to help make you a better Android mobile application developer by teaching you what I believe to be the most important fundamentals of Java that relates to real-world Android programming. If I were trying to teach you how to become a Java SE or EE developer I would dig much deeper on certain topics. For example, when I discuss reading input from the Scanner class I don’t explain this in depth because as an Android mobile developer you will not be using this class, however you benefit from this information at a high level because it teaches you the basics of getting input from your user and coding statements around your requirements.

I want you to think about your future Android mobile application projects from an Object-Oriented Design and Analysis mindset. I will organically help you do that by introducing and discussing the key aspects of OOP programming throughout the series. The knowledge you gain about classes, objects, methods, inheritance and traditional procedural programming constructs will make you a strong OOP and Android developer. However, I am delivering basic procedural programming concepts such as variables, strings, if/else statements, for loops, and while statements in this series before delving too deeply into OOP. I don’t need to teach you the Java specific OOP programming to make you a great Android developer but it will make your learning curve much shorter once you dig into the Android SDK. You simply need to fully understand the theory and know how to mechanically implement these concepts in the context of the Android SDK.

I hope you find the balance I have chosen to be helpful and I am always interested in your feedback and comments. After I complete the Java Fundamentals series I will publish a series specifically targeting Android mobile developers with the sole purpose of showing you how to code with the Android SDK in Eclipse. This is where the rubber meets the road for Android developers. For now, press on and build a strong foundation as your hard work will pay off.

Based on experience you must possess the following Java skills in order to develop real Android applications: flow control (if, if/else, while, case, for loops, etc); OOP experience with classes, objects, methods, packages and data members; a working understanding of public, private and protected; scope of variables; threads; file i/o; generics; interfaces. If you have not mastered these skills then you need to develop them at least on a conceptual level and understand them before you can develop any type of unique and custom Android mobile application. I am not suggesting that you must possess gross experience in these areas, but at a minimum fully understand them and then be ready to add a lot more from an Android SDK perspective.

Each lesson includes an electronic lesson document in PDF, ePub and Kindle formats which are supported by video tutorials hosted on my public YouTube channel. The Java Fundamentals series is available via Amazon.com for Kindle supported devices (e.g., Kindle reader, PC, Mac, etc.). Any book reader device that supporting ePub files will also be compatible. Keep in mind that Kindle readers are not able to play the YouTube videos so I would suggest using the Kindle application that is available for your computer or device that can play YouTube videos. Access to the video tutorials are limited to the availability of YouTube and your local Internet access. If you desire you can download any of the lessons in the Java Fundamentals series for $4.99 each in any of the support formats which includes the full lesson text and links to the video tutorials. If you only want the videos, you can download them in HD format for $2.99 each from my lulu storefront.

Coding Basics

In this chapter I will introduce you to some very important coding basics and walk you through some example code to illustrate the lesson objectives. I will discuss identifiers, statements, class declaration, numeric variables, primitive data types, arithmetic operators, order of precedence, and string variables.   These concepts are core to any type of programming and will start you off on the right path. It would be impossible to develop Android mobile applications without this type of knowledge.

A Few Reminders

In the last lesson I introduced how to create comments in your code and the difference between single line comments with the double-slash “//” and comment blocks using the “/* ... */” . If you recall the double-slash approach comments directly after the slashes to the end of the line and the comment block approach works best for large comment areas as well as Javadoc entries. My point for bringing this up is to remind you to comment your code aggressively because as time passes you won’t likely even remember writing your own code. Get in the habit of commenting from the beginning and all will be good.

I also wanted to remind you that Java is case sensitive. This might sound very obvious but I promise you that all of us make simple mistakes like not paying attention to case sensitivity and in the beginning it can be a huge waste of time tracking down these errors. My advice is to take your time and be careful. I usually keep a piece of scratch paper next to my desktop where I jot down the variables or constants that I am working with as a way to keep them straight in my mind.
Identifiers & Java Keywords

Java identifiers are literally the names that you use within your programs. The one catch is that you cannot use an identifier that is already a Java keyword. Keywords are reserved identifiers that Java has set aside for the language. There are only 50 of them so you will quickly start to remember them off the top of your head without much trouble. Oracle provides a full list of the Java keywords and the history of when they were introduced. There are a couple of things you should know before we jump in and start using identifiers. Even though const and goto are not currently used they are still keywords and considered reserved. Literals such as null, true and false cannot be used as identifiers in your programs as well. There is a listing on Wikipedia that you may want to refer to as well so I have included the link here and provided the listing below for your reference. The definitive source is always the documentation for the language itself so keep that in mind.

Statements

When we refer to statements in Java we are referring to your “code”. A statement has a purpose in your program and is to be executed and at times based on criteria. An example from our first program Hello Java would be the System.out.println(“Hello Java!); statement. These types of statements must be terminated with a semi-colon. Another example would be the creation of an object: Car myCar = new Car;. These types of statements are considered to be expression statements.
There are also declaration and control flow statements. In a declaration statement you would be declaring a variable. For example: int a = 1;. A control flow statement which we have not covered yet would be a block of code between braces. An example would be an if/else statement that executes a segment of code based on the current state of your test. Don’t worry about the specifics right now because I will be covering all of this in detail in the lesson series. My goal was to introduce you to the term “statement” so that when I make reference to it in the future you will understand.

Declaring a Class

You were introduced to the concept of a class and you actually created two classes in lesson 1 for our Hello Java program. I wanted to provide you with the key points around declaring a class so that you will be comfortable when we write our programs throughout this series. All class files must be stored as a .java extension. The class name must start with a capital letter and you can only use letters and numbers in the name. You learned in lesson 1 when we compiled our two class files with the .java extensions that the compiler made two files with the exact same name but with .class extensions. This is the program code that is executed by the Java runtime. Remember to think of your class as a blueprint. You create your classes so that you can create instances of your object. If we were an airplane manufacturer we would have blueprints for the wheel on our 747 jet. There may be many other 747 jet’s in your fleet and even though each wheel is unique they were built from the same blueprint (class). Each wheel is a unique instance of our Wheel class.

Your Wheel class would likely have fields (variables) representing its state and you would also likely define methods to interact with the world. I will explain this in detail in the OOP Theory lesson so don’t worry too much about it right now. I wanted to give you a little context about classes since we are working on the syntax right now.

The syntax to declare a class is as follows:
public | private class Classname {
     .... statements here ....
}

The access modifiers public and private controls the scope of your class. In practical terms if you class is public then all of your code to include various packages have access to it. If it is private then you would need to specify and belong to the same package. When I introduce OOP theory in the next lesson I will be discussing scope, classes, packages and other related terms. Keep in mind that a class must either be public or private and at least one class must be public for every Java program. For now, I just want to make sure you know the syntax of how to declare a new class and the rest of the information will be presented as needed.

Numeric Variables

A variable in Java is used to store a value. This value can be changed throughout the life of the program. In order to use a variable you must declare its type and assign it a value to initialize it. In some cases if you don’t initialize the value a default value will be assigned and likely not the one you wanted.

It is beyond the scope of this lesson right now, no pun intended, but Java actually have four different kinds of variables that we will be using throughout the series. Instance variables are not static, meaning they have a unique value for each instance of a class. Don’t worry if you don’t fully understand this right now because all of this will make sense as I introduce it at the right time in the series. Class variables are considered static because there is only one copy of the variable in existence. For example if you had a class for a bicycle rim, you might have a static variable for the spokes because you would want it to always have the same number of spoke on the rim. Local variables do not require any special keyword to declare them as local and they are only visible to the methods in which they are declared. An example would be an integer that you would declare for a for loop. The last type of variable is a parameter. In our Hello Java program args is technically a parameter in the main method. The main method was:    public static void main(String[] args). In this case the args variable was the parameter to this method.

Variable Naming Rules

There are a few rules you must follow when naming variables:
variable names are case-sensitive
can begin with letter, $ sign or underscore (convention is to use letters)
subsequent characters can be letters, $ sign or underscore but avoid this
white space is not permitted
variables cannot be a keyword or reserved word
if your variable only consists of one work, make it all lower case (int car)
If your variable consists of multiple words, capitalize subsequent words first letter (int carSpeed)

Primitive Data Types

Primitive data types is something that you will likely use on a daily basis in your programming experience. In this lesson I will be discussing two of the primitive types, but you may want to review the full list of eight to get a little bit of a head start on future lessons.

int Data Type

The first primitive data type that we will study is int because it is likely the most common. Int is short for integer and represents a range of values from -2,147,483,648 to 2,147,483,647. For most of your applications the int data type should be large enough. As you can tell by reviewing the range of values there are no decimal places indicating we are dealing with a whole number. The default value for the int data type is 0.

In the video lesson I code a simple program to help illustrate the declaration and use of integer data types.

public class JFL2a {
    public static void main(String[] args)
        int var1; //declared a variable
        int var2;
        int var3, var4; // two vars on the same line
        int var5 = 99; // declared and assigned on the same line.
        var1 = 100; // assigned var1 a value of 100
        System.out.println("var1 contains: " + var1);
        var2 = var1 / 2; //var2 should hold the value of 50
        System.out.println("var2 contains: " + var2);
    }
}

Double Data Type

The double data type is used for decimal values and is considered to be a floating point type. Its range of values is specified in section 4.2.3 of the Java Language Specification. For decimal values, this data type is generally the default choice. This data type should never be used for precise values, such as currency. If you need very price currency values then you would need to use the BigDecimal Class. The java.math.BigDecimal class is beyond the scope of this lesson. The default value for the double data type is 0.0d.
Assigning Values

In order to assign a value to our int or double data types we will use the equals “=” sign. The equals sign is an operator that is used and does not literally mean equals like you might think. the assignment operator assigns the value on its right to the operand on its left. To declare an int type and assign a value you would write the following statement:

int studentExam = 1; // variable name is studentExam and has a value of 1.
For the double data type we would declare and initialize it in the same way:
double finalGrade = 88.90; // variable name is finalGrade and has a value of 88.90.

Basic Arithmetic Operators

Now that you now how to declare and initialize int and double variables I will show you how to use some basic arithmetic operators with them.
Java has special operators to perform addition, subtraction, multiplication, and division.   OI am sure you can guess which ones they are.

+     addition operator (can also be used for string concatenation--see next chapter)
-     subtraction operator
*    multiplication operator
/     division operator
%    remainder operator

Example Program Using Integer Variables

If we look at a simple class example the basic operators will be revealed. Open up Eclipse and start a new project or use your favorite text edit and create a new class called MathFun.
Refer to my code below and type it in now.

class MathFun {
     public static void main (String[] args){ // our main method
          int result = 2 + 2; // result = 4
          System.out.println(result);
          result = result - 1; // result = 3
          System.out.println(result);
          result = result * 3; // result = 9
          System.out.println(result);
          result = result / 2; // result = 4
          System.out.println(result);
          result = result + 11; // result = 15
          result = result % 7; // result = 1
          System.out.println(result);
     }
}

Now that you have the code entered into your editor compile it and run the application. You should know how to do this, but if you can’t remember refer back to lesson 1 - Hello Java where I walk you through compiling the application. Run your application and make sure the results are what your expected. Use this class as a model and create your own application with new variables and values. The more time you invest in writing your own code the faster you will reach your goal of programming on your own.

This application was part of the video lesson. This application should be helpful in pointing out the differences between the integer and double data types.

public class JFL2b {
    public static void main(String[] args) {
        int var1 = 100;
        double var2 = 100.99;

        System.out.println("value of the int var is: " + var1);
        System.out.println("value of the dbl var is: " + var2);
        var1 = var1 / 3;
        var2 = var2 / 3;

        System.out.println("new value of the int var is: " + var1);
        System.out.println("new value of the dbl var is: " + var2);
        System.out.println(); //force new line
        System.out.println("Notice that var1 dropped the remainder and only"
                    + " displayed the whole number.");
    }
}

Using if and for Statements

Basic if Statement

The basic if statement is very simple and is a tool that all programmers use to test logic within their applications of all kinds and types. The syntax is easy and logical. You simply use the keyword if followed by a boolean condition enclosed in a pair of parentheses. If the boolean test is true the the following statement is executed, if false it is skipped. For example: if(a < b) System.out.println("a was less than b...");

public class JFL2c {
    public static void main(String[] args) {
        int a, b, c; //declared three int vars
        a = 1;
        b = 10;
        c = 20;

        //if(condition) statement
        // boolean <, <=, >, >=, ===, !=

        if(a < b) System.out.println("a was less than b...");
        if(a > b) System.out.println("This should not display...");
    }
}

Basic for Statement

The for statement is another procedural classic that is as timeless as the if statement. The for statement is a little more complex than the if statement, but still very easy to understand.
Text here...

public class JFL2d {
    public static void main(String[] args) {
        //for(init; condition; iteration) statement;
        int count;
        for(count=0; count<5; count++)
            System.out.println("This is the loop counter value: " + count);

        System.out.println();
        System.out.println("The loop has executed 5 times as directed...");

    }
}

Strings
String variables are very common and you will be using them all of the time within the context of your applications. I use strings for testing and debugging as well. When we get further in the lesson series I will show you how and why I do that. I wanted to introduce Strings just briefly in this lesson and also make sure you understand the difference between String variables and string literals that we have been using in our example programs.

When you create a new string they are part of the String class as you might have guessed. Another clue that String was a class was the capital S. Another example from our first program “Hello Java” in lesson 1 was the System class that we used to output our string to the console: System.out.println(“Hello Java!”);. Where println is a method that we use to output to the console and println is part of the PrintStream class. In this example “Hello Java!” is a string literal that is a an argument to the println() method.

You may want to take a break for a moment and go follow the links to the classes that I have provided. Just familiarize yourself with the documentation and how to navigate around. If you are curious search for something else while you are there. We will be learning all about String variables in the the coming lessons.

Summary
We covered a lot of information in this lesson. My intention is to open up the world of Java programming in a way that is accessible and ultimately helps you to become a programmer that can create your own real applications. Learning and mastering the basics is key in any profession and in programming it is critical in my opinion. Once you have mastered the basics and can think through how to create your own applications anything that you don’t know you should have the ability to just look up the information and apply it within the context of your specific needs. I encourage you to create some of your own simple applications based on the information you learned in these first two lessons. You know how to create your own classes, declare two data types and apply variables. While the examples so far have been simple, they will become increasingly more difficult in the forthcoming lessons. The more time that you invest writing your own applications will directly relate to your ability to not only master the lesson material but create your own applications. In the coming lessons my plan is to continue to build on the current materials in a way that is logical and clear. Feel free to email me with any comments or suggestions at any time.

-Tim Layton Sr.

Video Lesson

Tim Layton

How to Install Java JDK, Android SDK, Eclipse and ADT on Windows 7

noreply@blogger.com (Display Name) — Wed, 20 Apr 2011 16:08:00 +0000

I have received a lot of requests from Windows 7 users to help get their Java and Android development environments setup. I have created this specific video for Windows users but you should also refer to my detailed step-by-step article as well.

I walk you through how to install and configure your Windows 7 system for Java and Android development using the Java JDK, Android SDK, Eclipse EE IDE and ADT plugin for Android development. I show you how to configure your PATH environment variable so Java and Android tools work properly and then I walk you through how to update the Android SDK to the latest API's as well as configuring the Android emulator. Next, I step you through how to configure Eclipse for Android development. I discuss a known bug with installing the Android SDK on Windows as well.

I have a free programming series aimed at preparing aspiring Android developers by learning the Java Fundamentals as a precursor before trying to approach Android SDK app development. You can find all of those lesson here on my blog and can download the lessons and HD video for local use via my lulu store.

Tim

Android is Everywhere (or will be very soon)

noreply@blogger.com (Display Name) — Mon, 11 Apr 2011 19:52:00 +0000

Android is literally just about everywhere or will be very soon. As you would expect Android has exploded in the mobile phone arena and now we are seeing success with Android powered tablets, tv's, e-reader devices like the Barnes and Noble NOOKcolor, Netbooks, MP4 Players and a host of other devices. With Java as its base Android as a very bright future in my humble opinion. With the Java creator James Gosling working for Google now, I think we will see Android and Java taken to new heights.

There are times in business when we look back and realize there was a window of opportunity right in front of us and we missed it. I firmly believe that any developer that wants to harness the power and momentum of Google and Android should act now before it is too late. In an effort to help I am currently publishing a Java Fundamentals series of lessons to help aspiring developers learn the underpinnings and basics of Java so they can be successful with Android in the real world. Learning a new skill takes time, dedication and effort. The sooner you start the faster you will acquire the real-world experience that it takes to produce meaningful applications. I wish we could all snap our fingers and be Java and Android guru's, but unfortunately it doesn't work that way. Since all of the development tools are literally free the only real requirement is to have access to a PC, Mac, Linux or Solaris system.

You may want to follow me and interact with me on my twitter feed because I will be including a lot of unique information regarding Java, Android and the courses I am developing specifically for my Twitter friends.

If you have any questions or comments regarding my Java Fundamentals lesson series let me know.

Tim

Java Fundaments - Further Explanation

noreply@blogger.com (Display Name) — Mon, 11 Apr 2011 13:58:00 +0000

I have received several emails from readers and I wanted to take this opportunity to further define and clarify the goals of my Java Fundamentals series.

I created this series of lessons specifically for aspiring Android mobile developers. At first glance new Android developers may think they can jump right in after they get Eclipse installed and the ADT plugin working. While that may be true for a few seasoned OOP developers most will find they keep falling short because of the obvious Java underpinnings.

My goal with this series is to find the right balance of information to help make you a better Android mobile application developer by teaching you what I believe to be the most important fundamentals of Java that relates to real-world Android programming. If I were trying to teach you how to become a Java SE or EE developer I would dig much deeper on certain topics. For example, when I discuss reading input from the Scanner class I don’t explain this in depth because as an Android mobile developer you will not be using this class, however you benefit from this information at a high level because it teaches you the basics of getting input from your user and coding statements around your requirements.

I want you to think about your future Android mobile application projects from an Object-Oriented Design and Analysis mindset. I will organically help you do that by introducing and discussing the key aspects of OOP programming throughout the series. The knowledge you gain about classes, objects, methods, inheritance and so on will make you a strong OOP and Android developer. However, I am delivering basic procedural programming concepts such as variables, strings, if/else statements, for loops, and while statements in this series before delving too deeply into OOP. I don’t need to teach you the Java specific OOP programming to make you a great Android developer. You simply need to fully understand the theory and know how to mechanically implement these concepts in the context of the Android SDK.

Based on experience you must possess the following Java skills in order to develop real Android applications: flow control (if, if/else, while, case, for loops, etc); OOP experience with classes, objects, methods, packages and data members; a working understanding of public, private and protected; scope of variables; threads; file i/o; generics; interfaces. If you have not mastered these skills then you need to develop them at least on a conceptual level and understand them before you can develop any type of unique and custom Android mobile application. I am not suggesting that you must possess gross experience in these areas, but at a minimum fully understand them and then be ready to add a lot more from an Android SDK perspective.

I hope you find the balance I have chosen to be helpful and I am always interested in your feedback and comments. After I complete the Java Fundamentals series I will publish a series specifically targeting Android mobile developers with the sole purpose of showing you how to code with the Android SDK in Eclipse. This is where the rubber meets the road. For now, press on and build a strong foundation as your hard work will pay off.

Tim

Java Fundamentals - Lesson 1 - Hello Java!

noreply@blogger.com (Display Name) — Mon, 11 Apr 2011 00:37:00 +0000

Java Fundamentals - Introduction

noreply@blogger.com (Display Name) — Thu, 07 Apr 2011 01:32:00 +0000

The JVM executes platform independent code?
The Java compiler converts the program source code into machine code?
Java uses References instead of memory pointers to access objects?
Bytecode is executed by the JVM?
The JRE includes everything a user needs to execute your Java programs?

It is beyond the scope of this lesson series to discuss software development lifecycle methodologies but I do strongly suggest that you research this topic and apply it to your projects. If you google “software development lifecycle” or “software development methodologies” you will be presented with many results to review and consider.

The words or phrasing may differ among authors or formal methodologies but I would generally characterize the basic software development lifecycle as follows: Analysis, Design, Software Development, Testing, Implementation, Maintenance, and Product end-of-life.

Java Technology Product Groups

Java is also considered to be a platform. A platform is actually a virtual platform as opposed to a physical platform eliminating the need for specific hardware to execute the code. Software Development Kits (SDKs) are used for each product group. Assuming you are on a platform that requires the download (i.e., not a Mac) of the SDK you will notice several different product groups.
You are going to see Jave SE, Jave EE, and Jave ME in your travels through Java land. Java SE simply stands for Standard Edition and is used for developing stand-alone or desktop applications. You can also develop Java applets which are Java programs that run in your web browser. If you need a database in your desktop application then it will be embedded in your application as opposed to making calls to a database server.

Java EE is the Enterprise Edition is actually built on top of Java SE and is mostly used for large scale enterprise software development. You can also develop Java Servlet’s which are Java server-based programs that are built on the EE API libraries.

Java ME is the Micro Edition and is used to develop applications for mobile devices and embedded devices like DVD/BlueRay players, etc. Don’t confuse Java ME with Android development because these are two different things entirely. For Android development you will need the Google Android SDK available at http://developer.android.com in addition to the JDK.

Defining Your Solution in Object-Oriented Terms

One of the most important aspects of programming does not involve the act of writing code as you might expect. You must be a clear thinker and able to define a solution to the problem you are trying to solve. It could be as simple as organizing your DVD movie collection or you are a retailer and need a software solution to manage your inventory. You will use Object-Orient Analysis (OOA) to define your problem. You may also see OOA referred to as OOAD (Object-Oriented Analysis and Design). You will essentially be defining the classes you need for your application. If these terms seem foreign to you, just read on and I will explain.

Case Study - ABC Company

I will explain how to use OOAD through a case study for ABC Company. ABC Company is a non-profit organization that collects used clothing and then resells to via a small retail shop to fund their mission. ABC Company has grown to the point where they need a formal system to track their inventory for the purpose of collection forecasts and sales projections. They also accept donations in the form of checks, credit cards and cash.

Problem Domain

We first start by defining the problem domain. We do this by gathering formal requirements, defining the scope of the problem we are trying to solve, state what we hope to achieve by this project, and last but not least we will want to define the objects to help solve our problem.

Identifying Required Objects

To identify the objects in a problem domain we need to write down the properties and operations of all relevant objects. This could be anything from physical to conceptual. For example, let’s take the example of a shoe. Shoes are considered to be physical objects because we can touch them. ABC Company collects all types of shoes in their operations. Therefore, shoe is an object. An attribute of the shoe object could be: size, color, etc. Attributes in OOAD lingo are considered to be current state. The current state of the shoe is blue and its size is 11. We need to consider if our shoe object possesses any operations. Operations are activities that an object can perform. Operations of an object is defined as a behavior. In our shoe example you might not think we would have any operations. We actually do but I will explain in a later section. For the sake of clarity if we used a car as our example then the operations might be speed or acceleration.

If we build on our example of collecting shoes and reselling them, our objects in the problem domain would be: shoe, customer, and order. Now we need to define the attributes and operations for each of our objects.

Shoe would have size and color attributes. Customer would have name and address attributes and Order would have OrderID, CustomerID, TotalPrice attributes. The operation for an Order object would be if a sales representative added another pair of shoes to the order. The operation in this case belongs to the order object.

Attributes may also have a reference to another object. In our example you should have noticed CustomerID in our order object. If we were really designing this solution we would be building out our relational database tables. Our Orders table would have OrderID as the primary key, and other fields such as date and total price. There would also be fields for shoes which is a reference to another object.
Now that you have the background let’s dig in and define our objects along with their attributes and operations in a little more details and by use of a standardized method. You can do that in any form you like but it is traditional in OOAD standards to use a table as follows:

Object (class)
attributes (variables)
operations (methods)

Using this table above our shoe object would be displayed as follows:
Shoes
ShoeID
Description
Price
Size
Color

CalculateShoeID()
DisplayShoeInfo()

I use the approach above when I am designing applications. It naturally flushes out the objects we need to create classes for and the field names in our database along with the operations and attributes of each object. I could spend several lessons on the background and requirements for using OOAD in your development journey. My goal in this lesson was to open your eyes up to what OOAD is and how you should be using it in the future when you are defining and delivering your applications. If your application requires the use of very much data it is likely you will need to design a database to manage it. As you can see we could spend countless lesson in many different directions (e.g., OOAD, database design theory, etc). I need to keep us focused on building our core Java skills so you can create your Android mobile application.

If there is enough demand for separate courses on OOAD, database design, or others I am always open to receiving your suggestions and developing new courses and lessons. You can email me directly at any time at my email address of tim@timlaytonllc.com with suggestions or comments.

Custom Class Definition

I would be remiss if I didn’t address the topic of defining custom classes for your applications. Classes are at the very core of Object-Oriented Programming (OOP) and this is a concept that you must master because you will be using this from the original design phase all the way through writing your code.
A class can thought of as a blueprint for each object in your system. Think of an aircraft manufacturer. They would create a class for each object in the aircraft. The classes are the basis for each part in the airplane. Let’s say they created a class for wheels. Each object (wheel) created from the class (blueprint) is called an instance and can have a specific state or value for each of its attributes. Keep in mind each object will always have the same attributes and operations, just like we designed in the OOA chapter. You could have multiple instances of the wheel object in memory with the exact same attributes and operations but they would be handled as unique instances. In our example each wheel created from the class is a unique instance and could be a certain size and color. The class is your blueprint for each wheel that is created.

In Java attributes are represented using variables and operations are represented using methods. Variables in Java hold data and methods perform an operation. When we get into the programming part of the lessons I will walk you through the syntax and logic of how to do all of these things.

Java Development Tools

In this chapter I will help you get your Java development environment setup and ready for our lessons. You can watch my video tutorial on setting up your system. Next, I will show you how to configure your new software for Android programming. You may want to watch both of the video lessons and then refer to the text below.

Setup & Installation

You can develop Android applications on Windows, Mac and Linux. And all of the tools you need are free! Yes, free. No annual fees, or expensive IDE's to purchase. In a nutshell any version of windows starting from XP on will work, Mac 10.4.8 and above and Linux. It wouldn't hurt to have an Android phone to test on, but it isn't absolutely required. It would be a very good idea to test your apps on real devices first because the emulator is just that--an emulator. Also, if you are an every day user of an Android phone you are more likely to be able to related to your users and create useful or entertaining applications that might appeal to them.

The full list of requirements can be found on the Android Developer site.

Go to my "Getting Setup for Android Development" article for step-by-step instructions of setting up and configuring your system for Java and Android development.

After your system and environment is setup I developed a video showing you how to test your environment so that you can properly develop Java and ultimately Android applications. Refer to my "Configuring Eclipse" article.

True-False Answers
All of the answers to the true-false questions are true.

Summary

You should have a good idea of what we are going to cover in the Java Fundamentals series and why it is important for Android mobile development. I walked you through installing and configuring your Java and Android development tools and creating a test application verifying your system is ready to code Java and Android applications. You should have a basic idea of the various Java products and how that relates to the various JDKs. I also introduced you to basic OOP concepts that you will be learning and using in your Android Mobile development.

Get ready for the first lesson and if you have any questions, comments or suggestions always feel free to contact me at one of my mediums.

Tim

Java Fundamentals Playlist & Lesson Update

noreply@blogger.com (Display Name) — Fri, 01 Apr 2011 13:56:00 +0000

I wanted to let everyone know that I have created a playlist for the Java Fundamentals on my YouTube channel to make it easy to follow the lessons. You should start with the Introduction lesson and then progress sequentially through each lesson. I will number each lesson starting at 0 for the introduction. I am working on the first lesson this week and should be publishing it very soon. There is a lot of work that goes into the planning and content development. After that is done the lessons are the easy part and should move along quickly. You can click on the "Java Fundamentals" logo on the right side of the blog to filter all lessons and articles for this course.

For the Java Fundamentals lessons I will post the lesson text in an article on the blog for you along with links to the video lessons on my YouTube channel. I've received a lot of previous requests that people want to download the lessons and view them locally on their computers or devices (iPad, mobile smart phones, etc). In response to this I am packaging the lessons and video for you to download. The lesson text will be available on Amazon as a Kindle book and on iTunes as an iBook for a minimal fee. This will allow you to read each lesson on the most popular platforms (Kindle, iBook) on a host of devices and systems.

The distribution channels have minimum requirements on fee structure and I will try and keep the costs to a minimum. Keep in mind the content is completely free on my blog and on my YouTube channel. The publishing mediums are for those what want that option, but it is not required. The lessons will have direct links to the video tutorials that will play on your computer or device. If you want to download the video tutorials and view them locally with no requirement for an Internet connection I will make them available for download from my lulu storefront.

Stay tuned and I will provide you with all the information you need for the downloads very soon.

Tim

New Lessons - Java Fundamentals

noreply@blogger.com (Display Name) — Thu, 31 Mar 2011 17:42:00 +0000

I wanted to let everyone know that based on my last poll and my pilot YouTube channel that by overwhelming majority most people want to learn about Android mobile programming right now. Based on the amount of emails I get on a regular basis I realized that I needed to develop two courses.

First I will be publishing a Java Fundamentals course that will help you develop the core Java knowledge required to develop real world Android applications. I have found that way too many people think they can jump straight into Android development and I hate to say that rarely works out for the majority of people.

I am working on the lessons right now and will start publishing them within the next few weeks. After I complete the Java Fundamentals course I will begin publishing a formal course on Android development that assumes you have completed the Java Fundamentals course.

Tim

New Content

noreply@blogger.com (Display Name) — Mon, 28 Mar 2011 15:19:00 +0000

I wanted to let everyone know that I am in the middle of redoing my video programming tutorial videos. I have a brand new youtube channel that I am working on and also a new twitter account. The YouTube channel is youtube.com/timlaytonllc and for twitter I am at twitter.com/timlaytonllc and on Facebook I am at facebook.com/timlaytonsr. The social icons at the top right of the blog should take you to all of these sites too.

If you have any suggestions for new topics and content now is the time to speak up. My last pole indicated an overwhelming desire to learn Java and Android programming so that is where I plan to start with the new content.

Tim

What Would You Like to Learn About?

noreply@blogger.com (Display Name) — Wed, 23 Feb 2011 19:40:00 +0000

I've been busy in the new year and wanted to reach out to all of my readers and subscribers to ask what you want to learn about most?

Use the poll that I have listed on the right side of the site here and cast your vote.

Tim

Best Wishes in the New Year

noreply@blogger.com (Display Name) — Fri, 31 Dec 2010 23:10:00 +0000

I wanted to wish everyone a safe and happy new year and thank all of my family, friends and blog followers for a great year in 2010. There are a lot of exciting things happening in technology right now so I am sure 2011 will prove to be a great year.

Happy New Year!

Tim

How to Make an App Icon for Mac OSX Programs (Lesson 2)

noreply@blogger.com (Display Name) — Thu, 11 Nov 2010 23:13:00 +0000

In Lesson 2 of the How to Create Mac OSX Apps, Tim Layton walks you through the steps to create your application icon for your Mac OSX application. This icon will be used for the application we create in lesson 3 where I walk you through how to code actions and outlets, how to wire together the UI with XCode and Interface Builder and I discuss the concept of App Delegates.

Let me know if you have any questions and stay tuned for lesson 3.

Tim

Getting Ready for The New Mac App Store

noreply@blogger.com (Display Name) — Thu, 11 Nov 2010 01:10:00 +0000

Apple announced the new Mac App Store on October 20th, 2010 at the Keynote address. Apple has already opened up the submission process so the gates are open. While I don't know the exact date of the official launch Steve Jobs said it would be 90 days from October 20th when he revealed the Mac App Store at the keynote. The revenues for the Mac division of Apple was $22 Billion for FY2010. To put this into context, if the Mac division were a standalone company they would be 110 on the Fortune 500 list. Think about that when you are deciding where to invest your time as a developer in the future.

Getting Ready for the Mac App Store

I have outlined the general steps you will need to follow in order to submit your new app to the Mac App Store. Some of the links below require you to be a registered developer. Please note that some of these steps require many tasks as this is just a general outline to get you thinking about the bigger picture.

Step 1 - Watch the keynote to fully understand the opportunity (link above)

Step 2 - Register as a Mac App Developer.

Step 3 - Setup your iTunes account and get all of the "paperwork" completed.

Step 4 - Download and install XCode 3.2.5.

Step 5 - Develop your killer app in accordance with Apple guidelines.

Step 6 - Register your application ID.

Step 7 - Download and install your developer signing certificate.

Step 8 - Review your application against the submission guidelines checklist.

Step 9 - Submit your app via XCode per Apple's very specific instructions.

A benefit of the Mac Developer program is you get access to the very latest Mac OSX software and development tools. Included in the $99 annual fee you get two technical support incidents. It is good to know if you get backed in a corner that Apple is there to help. You can also purchase additional incidents if needed. There is a very active developer support forum where you can ask questions and help other Mac developers. There are a wide array of developer videos on iTunes that are very helpful, especially to a new developer.

Apple provides a list of benefits for becoming a registered Mac developer . In a nutshell I see the Mac App Store as a free market enterprise. If you have a great idea and you are willing to work hard and deliver a quality product then you are rewarded with sales. The build once sell many times model is your best friend. If you write crappy apps then you sleep in the street. I love this model because it thins out the dedicated from the talkers.

You set the price of your applications
You get 70% of sales revenue
Receive payments monthly
No charge to publish free apps
No credit card fees
No hosting fees
No marketing fees

Let me know what you think and stay tuned for a wide variety of Mac OSX developer tutorials on Objective-C and Cocoa using XCode and Interface Builder.

Tim

10.6.5 Update for Mac OSX AvailableToday

noreply@blogger.com (Display Name) — Wed, 10 Nov 2010 23:00:00 +0000

If you haven't already checked for software update on your Mac running Snow Leopard then you may want to do so.

The 10.6.5 update includes:

Improves reliability with Microsoft Exchange servers.
Addresses performance of some image-processing operations in iPhoto and Aperture.
Addresses stability and performance of graphics applications and games.
Resolves a delay between print jobs.
Addresses a printing issue for some HP printers connected to an AirPort Extreme.
Resolves an issue when dragging contacts from Address Book to iCal.
Addresses an issue in which dragging an item from a stack causes the Dock to not automatically hide.
Resolves an issue in which Wikipedia information may not display correctly in Dictionary.
Improves performance of MainStage on certain Macs.
Resolves spacing issues with OpenType fonts.
Improves reliability with some Bluetooth braille displays.
Resolves a VoiceOver issue when browsing some websites with Safari 5.
Improves Bluetooth pairing with Magic Trackpad.
Resolves performance issues with third-party displays that use InstaPort technology.
Add SSL support for transferring files with iDisk.
Resolves an issue when opening 4-up Photo Booth pictures in Preview.
Addresses keyboard responsiveness issues in the Dock when Spaces is turned on.
Resolves an issue syncing Address Book with Google.
Fixes an issue when replying to a Mail message sent by a person whose name contains certain characters such as é or ü.
Improves performance for users bound to an Active Directory domain.
Improves reliability of Ethernet connections.
Systems with a Mac Pro RAID Card (Early 2009) installed can now be put to sleep. For more information, see Mac Pro RAID Card (Early 2009): Enabling system sleep.
Improves reliability of fibre channel connections, resolving a potential Xsan volume availability issue.
Adds RAW image compatibility for additional digital cameras.
Security improvements; for information about the security content of this update, please visit this article.

For more detailed information visit Apple directly.

Tim

Cocoa 101 - The Mac OSX and iOS GUI Backbone

noreply@blogger.com (Display Name) — Tue, 09 Nov 2010 06:56:00 +0000

If you are new to Mac OSX or iOS (iPhone/iPod/iPad) programming then Cocoa is a topic that you must become knowledgeable about very quickly. As many of your may already know Apple announced the new Mac App Store which will be launched in the next couple of months. There has never been a better time to get your Apple developer skills in order to take advantage of this new opportunity.

Apple Documentation
The central resource for all Apple programming documentation is at the Apple Developer site. From here you can go to the iOS Dev Center if you are developing iPhone/iPod/iPad apps or to the Mac Dev Center if you are developing for Mac OSX. As crazy as it sounds I highly recommend that you go to the appropriate site for your development needs and read the "Getting Started" and "Required Reading" documents before you pass go. These are documents that set the foundation to everything Apple. You will find yourself reading and referring to them over and over. They will make more sense as you get more experience. There are a couple intro and getting started tutorials in the Getting Started documents that are an absolute must.

Objective-C
I will tell you up front Apple is very clear about understanding C programming before jumping off the cliff to tackle OOP programming with Objective-C 2.0 and Cocoa. In the real world you will see C code mixed with Objective-C.

My personal opinion is that you don't have to be a C guru, but you should definitely understand the basics of C programming if you hope to go beyond the basics of OSX and iOS apps. Objective-C extends the standard ANSI C language by providing syntax for defining classes, and methods, as well as other constructs that promote dynamic extension of classes. A typical warning label on Apple Objective-C documentation goes something like this: "This document doesn’t attempt to teach any aspects of the C language. If you’re not familiar with C, you should learn about the basics before you proceed." Get the hint? If you don't know the basics of C such as functions, variables, operators, data types and data structures you are doing yourself a disservice and will only make it very hard on yourself when progressing into more advance OOP topics such as Cocoa or Cocoa Touch.

Cocoa
You can build Cocoa applications for two platforms: the Mac OS X operating system and iOS, the operating system for multi-touch devices such as iPhone, iPad, and iPod touch. Your first order of business is to go read "Cocoa Fundamentals Guide" on the Apple Developer site.

What is Cocoa? Cocoa is a programming toolset for the Mac OS X operating system and iOS. Cocoa includes a rich suite of object-oriented software libraries, a runtime, and an integrated development environment. Safari and Mail on Mac OSX are examples of Cocoa applications. Cocoa is a set of object-oriented frameworks that provides a runtime environment for applications running on Mac OS X and iOS.

Cocoa is a suite of object-oriented software components and classes enabling developers to quickly create full featured GUI applications on Mac OSX. Think of Cocoa as a set of tools and building blocks that a developer uses to create their vision.

The most important Cocoa class libraries that you should learn about in the beginning is packaged in two core frameworks for each platform: Foundation and Application Kit for Mac OS X and Foundation and UIKit for iOS. To learn about the many other Cocoa Frameworks read the Cocoa Fundamentals Guide located on the Mac Developer site.

Workflow for Mac OSX
Since I am covering the basics of Cocoa in this article I think it is important to summarize the develppment workflow for OSX and iOS.

In Xcode, create a project using a template from the Mac OS X SDK.
Write code and, using Interface Builder, construct your application’s user interface.
Define the targets and executable environment for your project.
Test and debug the application using the Xcode debugging facilities.
As part of debugging, you can check the system logs in the Console window.
Measure application performance using one or more of the available performance tools.

Workflow for iOS

Configure the remote device. This results in the required tools, frameworks, and other components being installed on the device.
In Xcode, create a project using a template from the iOS SDK.
Write code, and construct your application’s user interface.
Define the targets and executable environment for the project.
Build the application (locally).
Test and debug the application, either in the iOS Simulator or remotely in the device. (If remotely, your debug executable is downloaded to the device.)
As you debug, you can check the system logs for the device in the Console window.
Measure application performance using one or more of the available performance tools.

Foundation Framework
The illustration below of the Foundation Framework rooted in NSObject is a great place to visually take in this fundamental set of classes.

My goal with this article is to inspire you to build a strong foundation before trying to build your "killer app". If you do the hard work up front and take the time to build a strong foundation, the fruits of your labor will surpass anything you can image.

Tim

How to Create Mac OSX Apps for the Mac App Store (Lesson 1 - Getting Started)

noreply@blogger.com (Display Name) — Sat, 30 Oct 2010 16:00:00 +0000

As many of you know Apple recently announced the new Mac App Store I have written about this in two other articles and now I am developing a series of programming lessons to help you create and ultimately publish your Mac OSX apps on the Mac App Store.

In this video below I walk you through creating your first app "Hello Cocoa!". This is obviously a very simple example but you will learn some very important concepts in this lesson.

You will learn how to create a new project, launch Interface Builder and create the user interface, you will assign a unique icon for your program and then you will learn how to distribute your app to other users.

All of this is very important and we will be using all of the concepts taught here in future lessons. I will be teaching you Objective-C and Cocoa along this journey so that you can build your own OSX applications. If you are starting this journey with any iOS (iPhone/iPad/iPod) experience then you have a leg up. Likewise if you want to pursue iOS developing in the future this experience will significantly reduce your learning curve.

You can download this video from my lulu storefront for a small fee to use and save on your local system.

Overview of steps from the video lesson:

Open XCode (Note I am using 3.2.5 so that I can sign my apps for the new Mac App Store)
File - New Project
Name it Hello Cocoa
Double-Click MainMenu.xib (nib file) to launch Interface Builder
Find “Window” This represents our new apps main application window
Drag a Label from the library to our Window.
Note: You are dragging an instance of the NSTextField class.
Double-Click on the Label and change text to Hello Cocoa!
With the Label selected go to the Inspector Window (CMD 1) and change the color to whatever you like.
Next with the Label selected do CMD + T to change the size of your font, etc.
Find the Menu Editor and just be aware this is where you would build your menu system
Create icon for your app (512 x 512 pixels) in Photoshop, GIMP, etc and save as a PSD, TIFF or PNG. I would suggest using a .PNG to keep the file size small.
Note: for the sake of time I created this icon for this lesson and used Icon Composer to convert it to the proper format (.icns). This is a utility that ships comes with the development software. I will walk you though how to create your own icon in the next lesson.
Drag icon file into Resources folder. A dialog box will appear. Select copy and add to project.
Click on info.plist and type in name of icon file here and save.
Get ready to run app. From XCode do Build & Run from menu or CMD + R
Select About Hello Cocoa and you should see your icon file.
To distribute your app you need to change from debug mode to Release.
Now rebuild your app again and then right-click on Hello Cocoa at the very top of Groups & Files window and select Reveal in Finder. Navigate to Build->Release folders and you will see your app “Hello Cocoa”. If you double-click it, it will run! You could send this to any other use on the target platform and it will run.

Don’t forget to switch modes back to debug if you want to make changes to your app.

This is a very fast overview of how to build a simple OSX app from inception to production. This should serve as a conceptual framework for future lessons as we begin to dig in deeper to Objective-C and the Cocoa SDK.

I hope this was helpful and stay tuned for the next lesson where I will show you how to create your app icon from scratch.

Tim

XCode 3.2.5 Now Available -- Get Ready to Sign Your Mac App Store Apps!

noreply@blogger.com (Display Name) — Sat, 30 Oct 2010 02:16:00 +0000

Xcode 3.2.5 now supports the signing of Mac OS X applications for submission to the new upcoming Mac App Store. So, if you are interested in jumping on the Mac App Store wagon, you will need to get this update.

Go to the Mac developer page, sign in and download the update if you need it.

Application submissions will be open in November so here is a checklist to get you pointed in the right direction.

However, be careful if you are also developing for iOS applications.

The Xcode 3.2.5 GM seed can be used for Mac OS X app development only. These tools do not contain the iOS SDK, and cannot be used for iOS development. If you already have iOS SDK 4.2 beta 3 installed, download and install the Application Tools package on top of your existing toolset, do not install the full Xcode 3.2.5 GM Seed.

There will be more to follow as all of this unfolds.

Tim

The New Mac App Store Coming Soon!

noreply@blogger.com (Display Name) — Fri, 29 Oct 2010 03:59:00 +0000

Developers will have a new opportunity with Apple in the very near future. The Mac App Store is just like the "app store" as we all know and love on the iPhone/iPod/iPad, but for the Mac.

To learn more about the new Mac App Store you can watch the latest Apple Keynote from Steve Jobs and the Apple team. You can visit the Keynote Events page to check out all of the latest Keynotes.

In a nutshell developers will earn the same 70/30 split just like they do for the current iPhone App Store. Instead of developing apps for the mobile devices you will be developing apps for OSX. The Mac App Store will be integrated into the next release of OSX, called Lion which is scheduled to be released in the Summer of 2011. This might be a good time to really brush up on Objective-C and get the fundamentals under wraps.

If you want me to develop a series of video tutorials on C and Objective-C on the Mac then send me an email and if there is enough demand I will create the lessons.

Be sure to vote over in the right sidebar which topic you would like new programming lessons on the most.

In order to be a developer for the Mac App Store you will need to be a registered developer, just like for the iPhone/iPod/iPad. According to the Keynote on October 20th, Steve Jobs said the new Mac App Store would be launched in 90 days from that day and developers could submit applications in November.

All of the features that you love about the app store for the mobile devices is being brought to the Mac App Store too. All of your applications will auto-install, have a home screen with folders, auto update for the users, etc. If you watch the keynote message listed above you will understand Apple's logic. They are taking all of the innovation and success from the mobile devices and bringing it back to the Mac platform. The best part for users is that users can use the Mac App Store apps on every Mac they own.

Apple also launched the new MacBook Air that sports all flash memory and looks and smells like a traditional notebook but is built like an iPad. I think this will be a product to keep an eye on and see how well it fares in the market. I can see iPad users that want more of a notebook experience going after the the MacBook Air and at the same time I can see MacBook users that need a little less storage and want the super fast flash technology making the system lightening fast. I booted one of the units at a local Apple store and it was fully on and ready to go within 9 seconds of hitting the on button. The response time to load all of the apps was basically instantly.

If you want to keep riding the Apple developer wave the new Mac App Store might be perfect for you. Keep in mind that you will need to be a registered developer for this app store in addition to the iPhone program. The cost is the same at $99. I foresee many different opportunities for developers to create apps for all of the Apple devices that ultimately enable Apple users to new levels unlike any other platform. I think this is the "next big thing" for developers and I will be interested to see if my gut is right over time. Brush up on your Objective-C programming skills and let me know if you start developing apps for the new Mac App Store.

Tim