Taking a Close Look at Google Lollipop

Multi-tasking is nothing just a critical function that is associated with every mobile. Users always expect to perform frivolously and jump from one task to other. They often get frustrated if they have to wait for content to re-load when moving from one application to another.

Keeping mind of the users demands Android introduced their latest version – LOLLIPOP

Google Lollipop is the latest version of the Android mobile operating system developed by Google, unveiled on June 25, 2014 during Google I/O. Instead of just dropping the user back into the app, it allows developers to break apart the tasks and make it appear as a cascade in distinct windows.

Lollipop gives the devs more power to increase the productivity of the apps they design. The combination of this new Material Design is aesthetically pleasing and allows the Android Apps to get the similar kind of polish and elegance, which you can typically find in an iOS app.

Material Design – A Close Look

Material design is the buzzing topic in the air and plenty of people have written about it. This new aesthetics from the house of Google for Android 5.0 ramps up the elegance, relying on more touch events, more animation, increased white space and allusions to real objects.

It is the most radical design for the Android and shows major improvement in the look and functionality of Google’s mobile operating system. You might have taken dived in the important features of Google Lollipop, but the goal for this stress on the multitasking aspect.

Let us look at the Material Design in terms of multitasking. The paradigm has shown a quick shift from moving from one app to another instead moving between the tasks. The recent apps now have renamed as Overview gives the users a survey of the work they are doing instead of the list of apps opened on their device.

Activities Associated with Overview

You will find that esthetically the overview turns the app-switching screen into a series of cards. Look at this diagram below to get a good grasp of the thing:
image
Similar to Google Search Google Now has also adopted transformation into cards. You are going to see the apps listed in this way frozen in their recent state. It goes a little deeper to break apart their activities into their own cards.

It was just yesterday we took a dip in the chocolaty goodness of Android 4.4 KitKat, and now we got the new and tastier version Android 5.0 Lollipop. It has received new polished design, features and some catching up iOS makes it an essential download.

Things you need to know about Android 5.0 Lollipop –

  • EVERYTHING IS SO FRESH:

    Look & Feel – Apps on Android’s new version Google’s Lollipop looks bolder, colorful, and has a responsive UI design for consistent, intuitive experiences across all your devices.

  • Font & Typography: Remember your default Android font “Roboto” it too has received some favorable tweaks to make it curvier and wider. It is now looking clean and the white space as well as navigation buttons have a PlayStation controller-style with minimalist makeover.
  • Shortcut Buttons: The favorite addition is the new floating action button in each app Google choose what it think as the most suitable shortcut and sticks in it in a colorful circular icon making everything FAST.
  • SMARTY NOTIFICATIONS:

    Notification system grows out to be prettier as you get new and smart ways to control when and how you receive messages.

  • 1. Notifications now sit as white ‘cards’ just below the quick settings panel
  • 2. View and respond to messages directly from your lock screen. Now it includes the ability to hide sensitive content for these notifications.
  • 3. Notification now drops from the top of the screen so that you can carry on playing game or watch movie in relative peace. These notifications banner jumps straight into action open, delete, reply etc a feature that Google uses to catch up iOS8.
  • 4. Latest and a great feature named as the Lollipop’s new management of ‘interruptions’ where you can turn on the priority mode of your device so that only some people and notification can get through. This is a version of Do Not Disturb on iOS and Assist on the Moto X.
  • 5. It helps to control the notifications triggered by apps. Users can now hide sensitive contents and prioritize or turn off the app’s notification.

PROJECT VOLTA

All hail for the long power haul, as Google inputs many details around in their battery life. It increases efficiency optimizations and increases stamina as a part of Project Volta.

  • 1. This includes apps that conserve more battery. The battery saving feature extends device use by up to 90 minutes.
  • 2. You will find the estimated time to fully charge when you plug-in the device
  • 3. Even you can find estimated time left on your device before you need to charge again is now in your battery settings.

SECURITY METER GETS SOME MORE BROWNIES!

You will witness a number of behind the scene changes in Android 5.0 Lollipop version. Now it is a great stuff to keep you safe.

  • 1. As new devices come with encryption automatically turned on to, help protect data on lost or stolen devices.
  • 2. SELinux enforces on all apps to have even better protection against vulnerabilities and malware.
  • 3. Now you can use Android Smart Lock to secure your phone or tablet by pairing it with a trusted device like your wearable or your car.
  • 4. Android 5.0 adds a guest mode functionality that is simple to use. It makes sure that your app in constantly under monitoring and there is no malware lurking and doing damage.
  • 5. It adds user profiles for the first time on Smartphones, until the date it was only available on the tablets. You can now add or switch between multiple users and guest session clicking on the icon at top right of the notification pull-down.

TWEAKS IN DEVICE SHARING

Makes sharing more easy and flexible.

  • a. Users can now enjoy the new goodies such as multiple users for phones. If you forget your phone, you still can call any of your friends or access any of your messages, photos and more, simply logging into another Android phone running Lollipop. This facility is perfect for the families who want to share a phone, but not their stuff.
  • b. Google makes the setup and transfer of apps and wallpapers from other Androids easier than ever.
  • c. The new feature also allows screen pinning, so that other users can access just a particular content without messing other stuffs of the user who pinned the content.

BOOST IN PERFORMANCE AND RUNTIME

It’s time to get excited as Google has made to the performance of Android 5.0 and they thanks ART wholeheartedly for this exclusive add-on.

  • 1. ART is the new default runtime; the engine running behind the scenes completely renewed, improves application performance and responsiveness.
  • 2. Apps and animations run at a much more fluid 60fps, and ART offers over twice the speed of its previous runtime indicating 4X performance improvements.
  • 3. It shows improvement in the graphics performance. Google worked with Nvidia and Qualcomm to improve optimizations within their own processors.
  • 4. Gives access to smoother User Interface for complex, visually rich applications
  • 5. Compact backgrounded apps and services allows you to access a lot more
  • 6. Lollipop also supports 64-bit processing, SoCs and native apps like Chrome, Gmail, Calendar, Google Play Music, and more
  • 7. Pure Java language apps run as 64-bit apps automatically

BOLDER GOOGLE APPS

  1. MEDIA
  • A. You can notice some bolder graphics, improved audio, video, and camera capabilities
  • B. Lower latency audio input ensuring that music and communication apps provides an amazing real-time experience
  • C. Multi-channel audio stream mixing allows professional audio applications to mix eight channels including 5.1 and 7.1 channels
  • D. Android extension pack and OpenGL ES 3.1 brings Android to the front of mobile graphics on par with desktop and console
  • E. As for camera, you get features such as full resolution frames around 30 fps, support raw formats like YUV and Bayer RAW, control capture settings for sensor, lens, and flash, capture metadata like noise models and optical information
  • F. Use of the state-of-the-art technology in videos with support for HEVC to allow for UHD 4K video playback, tunneled video for high-quality video playback on Android TV and improved HLS support for streaming
  1. OK GOOGLE
  • A. Even if the screen is off, you can say “OK Google” on devices with the help of digital signal processing
  • B. You can talk to the Google on the way and send a text or get directions
  1. ANDROID TV
  • A. You get a cool and attractive support for living room devices with adapted user interface
  • B. Users now need to browse less, watch more with personalized recommendations for content such as movies, TV shows.
  • C. Now you just need to say what you want to see with voice search for Google Play, YouTube
  • D. They have enabled console-style Android gaming on TV with a gamepad
  • E. Users can cast their favorite entertainment apps on big screen with Google Cast support for Android TV devices
  1. ACCESSIBILITY & LANGUAGES
  • A. Now the new Android version allows low vision and colorblind capabilities
  • B. Helps to boost contrast or invert colors to improve legibility
  • C. Users can adjust display to improve color differentiation
  • The new version is available in 68+ languages with 15 new addition – Basque, Bengali, Burmese, Chinese (Hong Kong), Galician, Icelandic, Kannada, Kyrgyz, Macedonian, Malayalam, Marathi, Nepali, Sinhala, Tamil, Telugu
  • D. The version allows your new Android phone or tablet instant set up by simply tapping it to your old one
  1. QUICK SETTINGS AND CONNECTIVITY
  • A. You would come across handy controls such as flashlight, hotspot, screen rotation and cast screen controls
  • B. Now users can get to the most frequently used settings with just two swipes down from the top of the screen
  • C. You would find it easier on/off toggles for Wi-Fi, Bluetooth and location
  • D. You can adjust the brightness manually, and it will kick it based on ambient lightning
  • E. Now you can expect a better connection and more powerful Bluetooth low energy capabilities
  • F. Now users can continue their video chat or VoIP calls without interruption, whether you leave the house and switch from Wi-Fi and then back to cellular
  • G. Help to improve the selection logic so that the device connects only if there is a verified internet connection
  • H. Allows power-efficient scanning for nearby Bluetooth low energy like wearables or beacons
  • I. User also gets a new BLE peripheral mode
  1. SOME MORE ANDROID VERDICTS
  • 1. Now users can easily manage multiple payment apps by quickly switching between them
  • 2. You get access to print preview and page range support
  • 3. You will find a revamped display for battery, Bluetooth, data usage, and Wi-Fi settings and new search functionality
  • 4. Get access to Android Beam that let you share a file with someone nearby by gently tapping the two devices at a time
  • 5. If supported with hardware, your device will wake up and soon pick it up or you need to tap the screen twice
  • 6. The newest version also allows improved hardware keyboard accessory support including multilingual support, emoji input, search key, and improved app and system key

Swift Development Services – Apple’s Journey from Objective-C to Swift

Back in 2008, Apple announced and released iPhone SDK 2.0. With this event sparked yet another revolution in software development, giving birth to a new breed of developers, called the iOS developers.

Many developers among them never used Objective-C prior to that and it was the first challenge Apple blew out to them. Despite the unfamiliar syntax and manual memory management, it was successful enough to populate the App Store with ten thousand apps. Apple kept on improving Objective-C and with each release, kept on adding block and literals, simplified memory management with automatic reference counting, and many other features pinpointing a modern programming language.

swift-objective-c-comparasion

In 2010, when iPhone was just 3 years old, the ability to code native apps was still nascent and iPhone came up with version 4 of the iPhone OS that included tantalizing new features like multitasking, fast app switching, and background services. Apple came back with a bombshell in iPhone OS 4 SDK and it was not in the software but in the usage agreement. It stated –

Applications must be originally written in Objective-C, C and C++, and only code written in C, C++, and Objective-C may compile and directly link against the Documented APIs.” – Section 3.3.1 of the iPhone OS 4 SDK Developer Agreement.

This new restriction took developers by surprise, but we heard Steve Jobs claiming it as a step to prevent the usage of cross-platform tools. However, Objective-C contributed largely towards the growth of the app ecosystem, but many developers started feeling dissatisfied in 2010 as a result alternative ways to write iPhone apps in other programming languages were cropping up.

After working with Objective-C for past 6 years, Apple decided to throw away yet another challenge this year in 2014 at WWDC. Yes, once again the iOS developers will need to learn an entirely new language called the Swift.

Swift – The New Apple Language

Learn-Swift-Programming-Language

Four years after 2010, Apple introduced developers to its new language, Swift. And this proved that Apple was ready to accept the truth that Objective-C might not be the best language for writing mobile apps. Swift is more a modern language compared to Objective-C. If new to Swift then you would have keen interest to know how to move from Objective-C to Swift.

You would notice two important differences between Swift and Objective-C –

Swift is not a strict superset of the C language – This denotes that Swift is free to make use of syntax constructs that was not in use. This helps to implement custom operators in Swift.

Swift is not dynamically typed, but typed statically – Statically typed means you can take the advantage of pioneered languages such as Haskell.

The Swift Launch Pad

In order to start exploring Swift you need to download XCode 6 from App Store and start experimenting. You can go to the home page of Apple’s Swift to find the best reference to facilitate Swift Development Services. To create a playground for your Swift Development here is a guide –
Variables and Constants
Declaring a variable in Swift profusely uses the VAR keyword.

var y = 1
var z = “Hello”

We choose two variable “y” and “z”. Swift is a safe language, it will deduce variable types from the assigned values. If you wish to make codes more readable, you can annotate the variable’s type.

var y: Int
y = 2

Constants are more or less similar, but you declare them using LET instead of VAR. The value of a constant does not need to be known at a compile time, but you must assign the value once.

let c1 = 1 // Constant known at compile time
var v = arc4random()
let c2 = v // Constant known only at run time

As their number suggest they are immutable so following the code is surely going to cause a compile-time error.

let c = 1
c = 3 // error

You can also declare other types as constant. As in this example, you can find that the following code an array declared as constant and if you try to modify it, the Swift compiler would fire an error:

Other types can also be declared as constant. For example, the following code declares an array as a constant, and if you attempt to modify any of the elements, the Swift compiler will report an error:

var arr2 = [4, 5, 6]
arr2[0] = 8
print (arr2) // [8, 5, 6]
let arr = [1, 2, 3]
a[0] = 5 // error

Optionals

You need to initialize constants when you declare them and for variables, you need to initialize them before you use. You cannot find it in Objective-C, but in Swift since optional values can have a value or be nil, but Objective-C cannot be nil equivalent. Look at the following code you will notice that that “x” assigned an optional value of 2015 at the same time this means Swift compiler was aware that “x” might be nil.

var s = “2015”
var x = s.toInt()
print(x) // Optional(2015)

If you introduce changes in this code and assign value “xyz” to “s” which cannot convert to integer, you will notice that “x” becomes NIL.

var s = “abc”
var x = s.toInt()
print(x) // nil

The return type of “toInt()” function is “Int?” which serves as the optional “Int”. Let us now consider a standard function on “x”:

var x = “2015”.toInt()
print(x.successor()) // error

Now the compiler sends signals as error, since “x” is optional and potentially NIL, we have to test “x” first and make sure that the successor function invokes a real number and not a NIL value.

var x = “2014”.toInt()
if x != nil
{
Print(x!.successor()) // 2015
}

We have to unwrap “x” by appending it with an exclamation mark (!). When we get sure that “x” contains a value we can easily access it, otherwise we can get runtime error. We also perform that function which Swift calls as optional binding, converting optional into a non-optional variable.

let x = “123”.toInt()
if let y = x
{
print(y)
}

The code will run if the “x” has a value to execute and will assign it to “y”. We do not need to unwrap “y” for that, as it is not optional as “x” is not NIL.Look at the Apple manual to read more details about Optional Chaining.

String Interpolation
When you use Objective-C, you usually do it with “stringWithFormat:” method

NSString *user = @”Gabriel”;
int days = 3;
NSString *s = [NSString stringWithFormat:@”posted by %@ (%d days ago)”, user, days];

Swift has a feature called string interpolation to do the same function, but it is easier to do and refined.

let user = “Gabriel”
let days = 3let s = “posted by \(user) \(days) ago”

You can also use expressions such as:

let width = 2
let height = 3
let s = “Area for square with sides \(width) and \(height) is \(width*height)”

Read more on string interpolation at Apple.

Functions
From Objective-C, the definition of function is different in Swift. Here is a sample function:

func someFunction(s:String, i: Int) -> Bool
{
… // code}

In Swift, the functions are of first-class types. This indicates that you can assign functions to variables, pass them as parameters to other functions, and make them returns types:

func stringLength(s:String) -> Int
{
return countElements(s)
}
func stringValue(s:String) -> Int
{
if let x = s.toInt()
{
return x
}
return 0
}
func doSomething(f:String -> Int, s:String) -> Int
{
return f(s).successor()
}
let f1 = stringLength
let f2 = stringValue
doSomething(f1, “123”) // 4
doSomething(f2, “123”) // 124

Again, in Swift you will find types of f1 and f2, although it is not possible to define them explicitly.
Functions can also return other functions:

let f1:String -> Int = stringLength
func compareGreaterThan(a: Int, b: Int) -> Bool
{
return a > b
}
func compareLessThan(a: Int, b: Int) -> Bool
{
return a < b
}
func comparator(greaterThan:Bool) -> (Int, Int) -> Bool
{
if greaterThan
{
return compareGreaterThan
}
else
{
return compareLessThan
}
}
let f = comparator(true)
println(f(5, 9))

Get to know more about functions at Apple’s Library.

Enumerations
Enumerations in Swift are powerful compared to Objective-C. Swift easily forms a structure, they can have methods to lie down and passes value:

enum MobileDevice : String
{
case iPhone = “iPhone”, Android = “Android”, WP8 = “Windows Phone8”, BB = “BlackBerry”
func name() -> String
{
return self.toRaw()
}
}
let m = MobileDevice.Android
print(m.name()) // “Android”

Compared to Objective-C, the enumerations in Swift can assign Strings, characters or floats as values for each member apart from the integers. You can find the convenient “toRaw()” method that returns the value assigned to each member. Enumerations also include parameters –

enum Location
{
case Address(street:String, city:String)
case LatLon(lat:Float, lon:Float)
func description() -> String
{
switch self
{
case let .Address(street, city):
return street + “, ” + city
case let .LatLon(lat, lon):
return “(\(lat), \(lon))”
}
}
}
let loc1 = Location.Address(street: “20, Connaught Place”, city: “New Delhi”)
let loc2 = Location.LatLon(lat: 28.6328, lon: 77.2197)
print(loc1.description()) // “20, Connaught Place, New Delhi ”
print(loc2.description()) // “(28.6328, 77.2197)”

Get information about enumerations here.

Tuples
Tuples are a group of several values turns into a single compound value. You can find that the value within the Tuples can be of any type and do not have to be of same type as each other.

let person = (“Thomas”, “Hardy”)print(person.0) // Thomas

You can also name the individual elements in Tuple:

let person = (first: ” Thomas “, last: ” Hardy”)print(person.first)

Tuples are extremely convenient options as their return types for functions that return more than one value.

func intDivision(a: Int, b: Int) -> (quotient: Int, remainder: Int)
{
return (a/b, a%b)
}
print(intDivision(11, 3)) // (3, 2)
let result = intDivision(15, 4)
print(result.remainder) // 3

Swift supports a pattern matching a switch statement, which you cannot find in Objective-C.

let complex = (2.0, 1.1) // real and imaginary partsswitch complex
{
case (0, 0):
println(“Number is zero”)
case (_, 0):
println(“Number is real”)
default:
println(“Number is imaginary”)
}

In the second example, we do not look into the number, so we use _ to match. You can also check additional conditions in each case as well. For that instance, we need to bind the pattern value to constants:

let complex = (2.0, 1.1)
switch complex
{
case (0, 0):
println(“Number is zero”)
case (let a, 0) where a > 0:
println(“Number is real and positive”)
case (let a, 0) where a < 0:
println(“Number is real and negative”)
case (0, let b) where b != 0:
println(“Number has only imaginary part”)
case let (a, b):
println(“Number is imaginary with distance \(a*a + b*b)”)
}

To know more on Tuples browse the Apple Library.

Classes
Swift does not require creating separate interfaces and implementing files for customized class or structures. In Swift, you can easily define a class or a structure within a single file and the external interface to that class or structure is made available automatically for other code to use.

Class definitions are very simple in Swift:

class Bottle
{
var volume: Int = 600func description() -> String
{
return “This bottle has \(volume) ml”
}
}
let b = Bottle()
pri
nt(b.description())

As you can see, declaration and implementation are in the same file. Swift no longer uses header and implementation files. Let us add a label to our example:

class Bottle
{
var volume: Int = 600
var label:String
func description() -> String
{
return “This bottle of \(label) has \(volume) ml”
}
}

The compiler will report the label is a non-optional variable and will not hold any value when a Bottle initialize.

class Bottle
{
var volume: Int = 600
var label:String
init(label:String)
{
self.label = label}
func description() -> String
{
return “This bottle of \(label) has \(volume) ml”
}
}

Well, we can also use optional type for a property we do not need to initialize that. In the following example, we made volume as the optional integer.

class Bottle{
var volume: Int?
var label:String
init(label:String)
{
self.label = label
}
func description() -> String
{
if self.volume != nil
{
return “This bottle of \(label) has \(volume!) ml”
}
else
{
return “A bootle of \(label)”
}
}
}

Structures
Swift also has structures just like Objective-C but it more flexible. Look at this example to get to know what structure defines in Swift:

struct Seat
{
var row: Int
var letter:String
init (row: Int, letter:String)
{
self.row = row
self.letter = letter
}
func description() -> String
{
return “\(row)-\(letter)”
}
}

Structures

Swift has structures that have methods, properties and intializers and some protocols as well. The difference between classes and structures is that classes pass on reference but structures pass by value.

let b = Bottle()
print(b.description()) // “b” bottle has 1000 ml
var b2 = b
b.volume = 750
print(b2.description()) // “b” and “b2” bottles have 750 ml

If we try out the similar case for instance with the structures, you will notice that it will pass by values:

var s1 = Seat(row: 14, letter:”A”)
var s2 = s1
s1.letter = “B”
print(s1.description()) // 14-B
print(s2.description()) // 14-A

Now, a question arises when we should use class or structure. In Objective-C and C, we used structures when we need to group multiple values and copy them rather than reference For example, complex numbers, 2D or 3D points, etc. However, class is traditionally the object. In Swift, we have seen that class and structure compared closely to other languages and much functionality can apply to either of the class or structure. As a result, general term used in Swift reference is “instance” which doth applies in any of these two.

You can read about Classes and Structures of swift at Apple Library.

Finding the Compatibility of Objective-C and Swift

    • A. iOS shares a common background with OS X and both hang on with the NeXTSTEP OS released in 1989. The later written in Objective-C and many of the core libraries trace their roots in these original implementations. Swift does not have its roots their but in future it will have to interface Objective-C.

    • B. Swift has enabled painless interactions with Objective-C, but that does not denote the process to be painless. Apple has given access to a helpful guide that explains how to call Objective-C code from Swift and vice versa. You will also come across some important impedance mismatch and must stay aware of them.

    • C. The most obvious mismatch that you might find here relates to the header files. Objective-C that has its root in C still needs their functioned to declare rather calling them. When you can out to a library, you would find the declarations found in the library’s header files. As for Swift, they do not use header files. If you want to call Swift Code from Objective-C, you need to create bridging header. Conceptually this may not seem complex, but it can be a tough task.

    • D. Another set of complication between Swift and Objective-C lies in their type systems. Swift that takes a various concept from other modern languages done away with the concept of NIL. In its place come Swift’s optional types. As for example, a method used to open a file only if it already exists would have a return type of a “File?” in Swift. By tacking all those places where types are optional, Swift compiler can effectively make it possible to encounter dreaded “Null Pointer Error”. Objective-C makes no guarantee about not returning nil. Rather Swift comes with special category of types called Implicitly Unwrapped Optional often used to call Objective-C code. These types treated as optional in Swift, along with overhead required for existence checking. You can use it alternately and can use the same as non-optional type, but if Objective-C does return, a “nil” will end up with a runtime error. Therefore, there are chances some of Swift’s compile-time safety guarantees.

    • E. Another subtle mismatch between Swift and Objective-C has to do away with how objects and classes created under the covers in the two programming languages from Apple. Objective-C due to their dynamic nature utilizes the dynamic dispatch to call methods on objects (via “objc_msgSend”). Swift definitely uses dynamic dispatch, but since it is statically typed it also get the option of using a “vtable” to store function pointers for each calling method. The two mechanisms that Swift uses depend on a number of factors Plane Old Swift Objects will use the “vtable” mechanism, unless the class or methods within the class annotates using the “@objc” Swift attribute.

    • F. Swift classes that have a chance to inherit from Objective-C classes will use dynamic dispatch for inherited methods. However, it is not possible for any new methods introduced by the subclass (well, you can force the use of dynamic dispatch with the “@objc” attribute). It is needless to say Swift code will be able to work with Swift classes, but Objective-C code can only utilize Swift objects and methods if annotated.

Swift is evolving daily at Apple’s Lab. You would come across a number of new things to learn about Swift. These include Generics, interaction with Objective-C libraries, closures, optional chaining, and operator overloading. It is not possible to discuss all of them in one article to describe thoroughly a new language.

Well, this quick read will help many developers get to know Objective-C, especially for those who have not yet managed time to learn details of Swift language can get on track.