• New User Features
• New Platform Technologies
• New Developer Services
• New Developer APIs

New User Features

Home

New Home screen tips widget assists new users on how to configure the home screen with shortcuts and widgets and how to make use of multiple home screens.The Phone, applications Launcher, and Browser now have dedicated shortcuts on the Home screen, making it easy to access them from any of the 5 home screen panels.

Exchange support

Improved security with the addition of numeric pin or alpha-numeric password options to unlock device. Exchange administrators can enforce password policy across devices.Remote wipe: Exchange administrators can remotely reset the device to factory defaults to secure data in case device is lost or stolen. Exchange Calendars are now supported in the Calendar application. Auto-discovery: you just need to know your user-name and password to easily set up and sync an Exchange account (available for Exchange 2007 and higher). Global Address Lists look-up is now available in the Email application, enabling users to auto-complete recipient names from the directory.

Camera and Gallery

Gallery allows you to peek into picture stacks using a zoom gesture.Camera onscreen buttons provide easy access to a new UI for controling zoom, flash, white balance, geo-tagging, focus and exposure. Camcorder also provides an easy way to set video size/quality for MMS and YouTube. With the LED flash now enabled for the Camcorder, videos can be shot at night or in low light settings.

Portable hotspot

Certain devices like the Nexus One can be turned into a portable Wi-Fi hotspot that can be shared with up to 8 devices.You can use your Android-powered phone as a 3G connection for a Windows or Linux laptop by connecting their phone to the computer with a USB cable. The connection is then shared between the two devices.

Multiple keyboard languages

Multi-lingual users can add multiple languages to the keyboard and switch between multiple Latin-based input languages by swiping across the space bar. This changes the keys as well as the auto-suggest dictionary.

Improved performance

Performance of the browser has been enhanced using the V8 engine, which enables faster loading of JavaScript-heavy pages.Dalvik Performance Boost: 2x-5x performance speedup for CPU-heavy code over Android 2.1 with Dalvik JIT. The graph to the right shows the performance speedup from Android 2.1 to Android 2.2 using various benchmark tests. For example, LinPack is now more than 5 times faster. Kernel Memory Management Boost: Improved memory reclaim by up to 20x, which results in faster app switching and smoother performance on memory-constrained devices.

New Platform Technologies

Media framework

• New media framework (Stagefright) that supports local file playback and HTTP progressive streaming
• Continued support for OpenCore in Android 2.2

Bluetooth

• Voice dialing over Bluetooth
• Ability to share contacts with other phones
• Support for Bluetooth enabled car and desk docks
• Improved compatibility matrix with car kits and headsets

2.6.32 kernel upgrade

• HIGHMEM support for RAM >256MB
• SDIO scheduling and BT improvements

New Developer Services

Android Cloud to Device Messaging

Apps can utilize Android Cloud to Device Messaging to enable mobile alert, send to phone, and two-way push sync functionality.

Android Application Error Reports

New bug reporting feature for Android Market apps enables developers to receive crash and freeze reports from their users. The reports will be available when they log into their publisher account.

New Developer APIs

Apps on external storage

Applications can now request installation on the shared external storage (such as an SD card).

Media framework

Provides new APIs for audio focus, routing audio to SCO, and auto-scan of files to media database. Also provides APIs to let applications detect completion of sound loading and auto-pause and auto-resume audio playback.

Camera and Camcorder

New preview API doubles the frame rate from ~10FPS to ~20FPS. Camera now supports portrait orientation, zoom controls, access to exposure data, and a thumbnail utility. A new camcorder profile enables apps to determine device hardware capablities.

Graphics

New APIs for OpenGL ES 2.0, working with YUV image format, and ETC1 for texture compression.

Data backup

Apps can participate in data backup and restore, to ensure that users maintain their data after performing a factory reset or when switching devices.

Device policy manager

New device policy management APIs allow developers to write “device administrator” applications that can control security features on the device, such as the minimum password strength, data wipe, and so on. Users can select the administrators that are enabled on their devices.

UI framework

New “car mode” and “night mode” controls and configurations allow applications to adjust their UI for these situations. A scale gesture detector API provides improved definition of multi-touch events. Applications can now customize the bottom strip of a TabWidget.

Google Tech Talks December 7, 2006 ABSTRACT Adwords introduced a Scrum implementation at Google in small steps with remarkable success. As presented at the Agile 2006 conference this exemplifies a great way to start up Scrum teams. The inventor and Co-Creator of Scrum will use this approach in building the Google Scrum implementation to describe some of the subtle aspects of Scrum along with suggested next steps that can help in distributing and scaling Scrum in a “Googly way”.

Why Agile? and Why not waterfall?

This was my first question while I was stepping towards Agile methodology. I would not say that I don’t like waterfall, but it would be worth while to look in what difference you would see while moving to Agile.

Waterfall has it’s strength in believing what logical path a project can take. Looking at the requirements, all great ideas can be implemented well in design phase, code and test and deliver. All those deliverables are given to customer that were planned. But any ideas that are introduced say later in the testing phase, might make you think 10 times whether to incorporate and how to incorporate without affecting schedule and cost of the project. You might remember the cost of defect equation which stresses upon defects found in later stage of the project cost much more than in design phase. Now you can compare good ideas coming at the later stage that require lot of change in system design with defects. Sometimes even good ideas coming up in later stages of the project could prove to be threat instead of doing any good for the project. Unfortunately it happens more often than expected as not all good ideas are brought up at start of the project itself.

At the same time, biggest strength in Scrum framework lies in adapting change and it becomes easier with it’s interative approach. Agile suggests to work in rapid iterations, deliver working product and get as much as inputs from customers on the way as possible (or product owner if he can play the role of a customer). This feedback loop is very important to make sure that the product delivery is as expected by customer.

Business value from Scrum

I remember a very good difference between these two, waterfall and scrum – business value at some moment of time in project life cycle.

If I remember correctly, it was explained by my scrum trainer. In this example, we run two projects for identical requirements, same time period (For example: say 1 year) with same team, but one in waterfall way and another in scrum.

Assuming you know how scrum and waterfall both work, if you look at the project delivery after 6 months, it would be very interesting output. In the 6 months, the waterfall project might have reached a stage where the requirement analysis is fully complete, design is complete, programming has started and half way through. If I am a customer, how much business value this stage would give me, think about it.

At the same time, the scrum project team would have against prioritized product backlog and started delivering shippable product after every sprint (say of 1 month each). If as a customer, I ask them to stop working after 6 months, they would have at least bunch of product backlog items done, and shipped as workable product. Simply because it focuses on shippable product in small iterations, and that not only gives the best business value at certain moment in project life cycle but also allows change during the development process that can be taken up in future sprints.

This is huge difference between what Scrum can do, and what Waterfall might not help in.

Credit: Abhijeet’s Blog (Certified ScrumMaster)

http://www.ted.com/talks/lang/eng/pranav_mistry_the_thrilling_potential_of_sixthsense_technology.html

The most eagerly anticipated product launch of 2010 was met with a couple of iPhone 4G defects, but this development can work to your advantage, as several free iPhone 4G Test & Own offers are being re-promoted to help identify these bugs and defects. Want to own a unit for free? Read on and find out how.

Okay, so the Apple iPhone 4G was finally released last June 23, 2010. Instead of satisfied owners, however, cities were filled with purchasers who noticed one humongous flaw with the new mobile phone: signal disappears when you hold it in your palm.

What makes matters worse is Apple’s rather nonchalant reply, which eventually became a PR disaster: “you’re holding it the wrong way.”

What the heck, right? Are you supposed to hold the cellphone with 2 fingers? Every single second?

Additionally, there have been numerous reports that some units have yellow discoloration on their screens. Experts say that this problem was expected, as the iMac 27″, the first one to implement the Retina Display that is being introduced to mobile phones courtesy of the newest Apple mobile phone, has the same defect in many of the units sold.

So, the eagerly anticipated launch turned out to be a bust, but it is nothing to be worried about as an emergency firmware update is sure to fix the mentioned defects. The system’s signal reception, after all, can be manipulated by the firmware as the 4G model shares the same physical engineering (albeit sleeker than previous entries) as earlier iPhone units.

But how can these iPhone 4G defects lead to an amazing opportunity for you to own a free iPhone 4G unit?

Well, are you familiar with the free iPhone 4G offers all over the web? The legitimate ones, at least?

These offers are initiated by companies which have great interest on the success of Apple’s newest flagship product. They may be suppliers for Apple, third party developers, prospective advertisers, business partners, and the likes. Regardless of who they are, they want to ensure that the newest version of the product line succeed, and they need your help.

Now more than ever, apparently.

Prior to the newest model’s release, these companies gave away thousands of units for volunteers to test. These volunteers were supposed to report bugs and defects they found with their iPhones. To compensate these testers, they were allowed to keep the units they tested.

Neat, right?

Were you able to avail of such an offer?

If yes, then congratulations on your brand new free iPhone 4G.

But if you didn’t manage to jump aboard one of these offers, don’t worry. More such free iPhone 4G offers are on the way.

Why?

Because the aforementioned interested companies can’t afford more bugs and defects found on the system they’re heavily investing on.

The iPhone SDK was announced officially on March 6, 2008, the first beta release was on July 11, 2008 which demanded a firmware update for all iPhone and iPod users. The SDK continued to develop with time until the Beta3 update to the 2.1 SDK was released on August 8, 2008.

Here is a small timeline.

The iPhone SDK package contents

The SDK is broken down to the following:

Cocoa Touch

The Cocoa Touch layer is one of the most important layers in iPhone OS. It comprises the UIKit and Foundation frameworks (UIKit.framework and Foundation.framework), which provide the basic tools and infrastructure you need to implement graphical, event-driven applications in iPhone OS.

It also includes several other frameworks that provide key services for accessing device features, such as the user’s contacts.

This framework is used to implement the core set of features.

• Application management
• Graphics and windowing support
• Event-handling support
• User interface management
• Objects representing the standard system views and controls
• Support for text and web content
• Accelerometer data
• The built-in camera (where present)
• The user’s photo library
• Device-specific information

Media

The graphics and media technologies in iPhone OS are geared toward creating the best multimedia experience available on a mobile device. More importantly, these technologies were designed to make it easy for you to build good-looking and -sounding applications quickly. The high-level frameworks in iPhone OS make it easy to create advanced graphics and animations quickly, while the low-level frameworks provide you with access to the tools you need to do things exactly the way you want.

• OpenAL
• Audio mixing and recording
• Video playback
• Image file formats
• Quatrz
• Core Animation
• OpenGL ES

Core Services

The Core Services layer provides the fundamental system services that all applications use. Even if you do not use these technologies directly, every other technology in the system is built on top of them.

• Networking
• Embedded SQLite database
• GeoLocation
• Threads

OS X Kernel

The Core OS layer encompasses the kernel environment, drivers, and basic interfaces of the operating system. The kernel itself is based on Mach and is responsible for every aspect of the operating system. It manages the virtual memory system, threads, file system, network, and inter-process communication.

The drivers at this layer also provide the interface between the available hardware and the system frameworks that vend hardware features. Access to kernel and drivers is restricted to a limited set of system frameworks and applications. iPhone OS provides a set of interfaces for accessing many low-level features of the operating system.

Your application accesses these features through the LibSystem library. The interfaces are C-based and provide support for the following:

• Threading (POSIX threads)
• Networking (BSD sockets)
• File-system access
• Standard I/O
• Bonjour and DNS services
• Locale information
• Memory allocation

Develop your first iPhone application:

Things you need before going any further:

• A “MAC OS X” platform of version 10.5.3 or later. You can get an original MAC box or you can simply get one of the hacked versions of the MAC OS, for more information click here.
• The iPhone SDK “Software Development Kit” you can get one from the iPhone developer program home page, or simply click here.
• Xcode, the IDE “Integrated Development Environment” used to develop applications and software for MAC based platforms. Although one of Xcode’s goals is to reduce the time you spend writing code, you still devote a considerable part of your development in the text editor. To that end, the text and source editor provide many features with the aim of making your source-code editing a productive and efficient endeavor. Code folding, code completion, Edit All in Scope, Refactoring, and other features allow you to focus your attention on the right areas and to use your time as efficiently as possible. It’s packed with the iPhone installer, so no need to worry about it.
• Interface builder, this application lets you design compelling user interfaces graphically. Your work is saved as nib files that your application loads at runtime. This means that you what you design is exactly what users of your application see; you work with the actual controls that iPhone OS places on the users’ screens. It also means that you spend less effort codifying the user-interface–related aspects of your application in source code. It’s also supplied in the SDK package.

Other developing applications you may use:

• Debugger, as you start testing your application, you may need to step through your code to the cause of unexpected behavior. Xcode’s debugging facilities provide the usual debugging features, such as breakpoints, viewing variables, and so forth. But Xcode provides these and other debugging features right in the text editor. That is, you can make a change in your code, add a breakpoint, start your application, and perform most debugging tasks in the same window.
• Instruments, as you near the end of the development process, you must ensure your application uses the resources of the device on which it’s running as efficiently as possible, so that battery power is not wasted and your application does not gather system resources unnecessarily. “Instruments” shows your application’s resource usage, including memory, CPU, and network, in a graphical timeline that lets you see how your application behaves over time.

The MVC design pattern:

The structure of iPhone applications is based on the Model-View-Controller (MVC) design pattern because it benefits object-oriented programs in several ways. MVC–based programs tend to be more adaptable to changing requirements—in other words, they are more easily extensible than programs that do not use MVC. Furthermore, the objects in these programs tend to be more reusable and their interfaces tend to be better defined.

In the MVC design pattern, the model layer consists of objects that represent the data your application manages. The objects in this layer should be organized in the way that makes the most sense for the data. External interactions with model objects occur through a well-defined set of interfaces, whose job is to ensure the integrity of the underlying data at all times.

The view layer defines the presentation format and appearance of the application. This layer consists of your application’s windows, views, and controls. The views can be standard system views or custom views you create. You configure these views to display the data from your model objects in an appropriate way. In addition, your view objects need to generate notifications in response to events and user interactions with that data.

The controller layer acts as the bridge between the model and view layers. It receives the notifications generated by the view layer and uses them to make the corresponding changes in the data model. Similarly, if the data in the data layer changes for other reasons (perhaps because of some internal computation loop), it notifies an appropriate controller object, which then updates the views.

Developing the iCalculator application:

Here is a fast overview of what we will do:

• Creating the project.
• Implementing the Model Object.
• Implementing the Controller Object.
• Implementing the View Object by use of the “Interface Builder”.
• Customizing the app delegate to incorporate the view controller object, and add it to the application window.
• Connecting the view controller to its view.
• Finalizing the application and setting its icon.

Creating the project

1) Launch Xcode. You can find it in the developer folder > Applications > Xcode.

2) Choose File > New Project.

3) Choose from the iPhone OS templates.

4) Choose Window-Based Application.

5) Name your project “iCalculator”.

Figure 1: New Project.

Figure 2: The iCalculator Project.

Note:

■ iCalculator.app: The application binary, the project’s product. It’s in red because the product hasn’t been built yet.

■ iCalculatorAppDelegate.h, iCalculatorAppDelegate.m: The files that implement the application’s delegate.

■ MainWindow.xib: The nib file that defines the application’s main window. Despite its name, iPhone applications normally have only one window.

Implementing the Model Object

We will create a new class whose instance represents an object of the calculator, follow the following steps:

1) Click on the “Classes” folder.

2) Choose File > New File.

3) Choose Cocoa Touch Classes > NSObject subclass.

4) Name the class “iCalculator”, make sure that creating the header file option is selected.

5) Insert the following Code into iCalculator.h:

Figure 3: iCalculator.h.

6) Insert the following Code into iCalculator

Figure 4: iCalculator.m part I.

Notes for newbies:

1) The “retain” and “release” methods are used mainly in the memory management of iPhone applications, that’s because there isn’t any garbage collection in the iPhone OS.

Thus, memory management is done manually; you can’t simply call “dealloc” to free the resources and references of a certain object, because this object may contain references to other objects that will not be de-allocated, and thus will cause memory leaks, so we use retain which will increment the value of a certain variable for this instantiated object, and release decrements the value, and when it reaches zero, the referenced object is de-allocated.

For more information about this topic, read more about memory management in Objective C++ 2.0.

2) If ( Self = [ super init ] )

What does this mean? This means that init of the parent class “NSObject” function will be called and if self is not equals to null do the following.

Figure 5: iCalculator.m part II.

Figure 6: iCalculator.m part III.

Implementing the controller object:

1) Click on classes.

2) Choose File > New File

3) Choose iPhone OS> Cocoa Touch Classes > UIViewController subclass.

4) Name the class “iCalcViewController”.

5) Modify the iCalcViewController.h header file as the following:

Figure 7: iCalcViewController.h

6) Modify the iCalcViewController.m file as the following:

Figure 8: iCalcViewController.m part I.

Figure 9: iCalcViewController.m part II.

Implementing the View Object

To get users excited about your application, it should have the best user interface possible. Interface Builder allows you to build beautiful, more importantly, useful user interfaces by dragging controls from a library of user-interface elements and laying them out n a view as you want them to appear to the user, your user-interface designs are known nib files. Your application loads these resources at runtime to reconstitute the use interface you designed. This means that you can make substantial changes to the user interface layout (and even some behavior) without having to edit source code. This is the main benefit of the Model-View-Controller paradigm.

1) Expand the “Resources” folder.

2) Double click on “mainWindow.xib” and the interface builder will open.

3) From the interface builder choose File > New file.

4) Choose Cocoa Touch and then press on View.

Figure 10: iPhone OS UI templates.

5) Choose save, name it as “CalcView” and navigate till you reach the location of your project and save it under the “Resources” folder and press ok.

6) Xcode will ask you to update the project to accommodate the new file, confirm this process.

7) Press on the File’s Owner icon.

a. Choose Tools > Inspector.

b. Display the identity pane.

c. In the Class text field enter “iCalcViewController”, note that it will auto-complete.

And by this way, we’ve connected between our view object and the controller object.

Figure 11: “calcView”’s Components.

Press on the View icon.

a. Choose the Inspector Attribute pane.

b. Customize your view as you desire, here we changed the background’s color to black.

Figure 12: “calcView”’s View designer.

9) Add input and output controls to the view

a. Choose tools > Library.

b. In the organization pane, select Library > Cocoa Touch Plug-in > Inputs & Values.

c. Select the Text Field item and drag it to the View.

Figure 13: Drag and drop components.

d. Resize the text field, by enlarging it, such that it contained by most of the view’s width.

Figure 14: resize text field.

e. Display the Inspector Attribute pane.

f. Set the text field text to 0.

g. Set the alignment to right-align.

h. Set the title typeface and size, by setting the focus on the text field in the view > Choose Fonts, set it to bold and size 36.

Figure 15: Set font.

i. Add a rectangular button.

• Choose “Round Rect Button” from the library and drag and drop.
• In the inspector size pane, set the button’s width to 64 and height to 70.

Figure 16: Set font.

• Connect the button’s “Touch Down” event to the “press:” action method of the “iCalcViewController” class.
• Select the button in the view
• Display the Inspector Attributes pane.
• Set the title color to black.
• Set the button title to 7.
• Set the font size to 48.

Figure 17: Set button attributes.

j. Create the button grid:

• Choose the button from the view.
• Choose Edit > Duplicate.
• Position the clone beside the original button.

Figure 18: Clone the button.

• Select both buttons and do exactly as the previous steps.

Figure 19: Clone the two buttons.

• Select the four buttons and with the same steps we can generate the following view.
• But by changing the text of each button and making sure that the action event of each button is the “press” method

Figure 20: The final calculator view.

Editing the application delegate:

1) Double click on the iCalculatorAppDelegate.h to modify it, edit it to look like this:

Figure 21: iCalculatorAppDelegate.h.

2) Double click on the iCalculatorAppDelegate.m to modify it, edit it to look like this:

Figure 22: iCalculatorAppDelegate.m.

Connecting the View controller to the View

As mentioned before, we have connected between the view and the controller, but that was an initial connection.

We have to be more precise, for example we have to mention which controls do certain actions, and which preview certain data, so here is what we have to do:

1. In the CalcView.xib window, select the File’s Owner proxy (which represents an instance of the “CalcViewController” class).

2. In the Inspector Connections pane, connect the displayField outlet to the text field in the view.

Figure 23: Connecting the view with the controller.

3. Connect the view outlet to the view.

4. Save the “CalcView.xib” file.

Note: If you pressed on one of the buttons, you will find that their action event handler is already set, as we set it before during designing the view to the “press” function.

Setting the application icon

1. In Interface Builder, take a snapshot of the Calc button grid:

a) Place the pointer at the top-left corner of the grid.

b) Press Shift-Comand-4 and hold down the mouse button.

c) Drag the pointer to the bottom-right corner of the grid and release the mouse button.

Figure 24: Taking a snapshot.

Mac OS X places the snapshot file in your desktop using the name Picture 1.jpg (or a name with a higher number if you’ve captured other snapshots).

2. Rename the snapshot file, icon.jpg.

3. In the Groups & Files list, select Resources.

4. Choose Project > Add to Project.

5. Navigate to your Desktop directory and choose icon.jpg.

6. In the dialog that appears, ensure the copy option is selected, and click Add.

7. In the Groups & Files list, double-click Resources > Info.plist.

8. In the editor window, set the value of the Icon file key to icon.jpg,

Figure 24:Info.plist.

9. Save the Info.plist file.

Running your application

Build your application and run it on your simulator, if you have an iPhone connected to Xcode you can choose to deploy and run on it.

Please not that, you have to have a developer’s certificate from apple to develop for iPhones, which will cost you $99 or $299 a year depending on what kind of certificate you want, for more details click here.