Basic iPhone Interview Questions And Answers

How many bytes we can send to apple push notification server.

256bytes.

 

What are sensors in iPhone?

The proximity sensor immediately turns off the display when the iPhone is lifted to ear. With this sensor the power is saved and accidental dialing is prevented.

The display is automatically brightens the iPhone by the ambient light sensor when the sunlight or bright rooms and dims in darker places.

How can you respond to state transitions on your app? 
On state transitions can be responded to state changes in an appropriate way by calling corresponding methods on app's delegate object.
For example: 
applicationDidBecomeActive method can be used to prepare to run as the foreground app. 
applicationDidEnterBackground method can be used to execute some code when app is running in the background and may be suspended at any time.
applicationWillEnterForeground method can be used to execute some code when your app is moving out of the background 
applicationWillTerminate method is called when your app is being terminated.

List down app's state transitions when it gets launched.
Before the launch of an app, it is said to be in not running state.
When an app is launched, it moves to the active or background state, after transitioning briefly through the inactive state.
Who calls the main function of you app during the app launch cycle? 
During app launching, the system creates a main thread for the app and calls the app’s main function on that main thread. The Xcode project's default main function hands over control to the UIKit framework, which takes care of initializing the app before it is run.
Give example scenarios when an application goes into InActive state? 
An app can get into InActive state when the user locks the screen or the system prompts the user to respond to some event e.g. SMS message, incoming call etc.
When an app is said to be in active state?
An app is said to be in active state when it is running in foreground and is receiving events.
Name the app sate which it reaches briefly on its way to being suspended. 
An app enters background state briefly on its way to being suspended.
Assume that an app is not in foreground but is still executing code. In which state will it be in? 
Background state.
An app is loaded into memory but is not executing any code. In which state will it be in?
An app is said to be in suspended state when it is still in memory but is not executing any code.
Assume that system is running low on memory. What can system do for suspended apps? 
In case system is running low on memory, the system may purge suspended apps without notice. 

You wish to define your custom view. Which class will be subclassed?
Custom views can be defined by subclassing UIView.   

What is push notification? 

Imagine, you are looking for a job. You go to software company daily and ask sir “is there any job for me” and they keep on saying no.  Your time and money is wasted on each trip.(Pull Request mechanism).

So, one day owner says, if there is any suitable job for you, I will let you know. In this mechanism, your time and money is not wasted. (Push Mechanism).

What is Automatic Reference Counting (ARC) ?

ARC is a compiler-level feature that simplifies the process of managing the lifetimes of Objective  C objects. Instead of you having to remember when to retain or release an object, ARC evaluates the lifetime requirements of your objects and automatically inserts the appropriate method calls at compile time.

What is polymorphism?

This is very famous question and every interviewer asks this. Few people say polymorphism means multiple forms and they start giving example of draw function which is right to some extent but interviewer is looking for more detailed answer.

Ability of base class pointer to call function from derived class at runtime is called polymorphism. 

Whats fast enumeration?

Fast enumeration is a language feature that allows you to enumerate over the contents of a collection. (Your code will also run faster because the internal implementation reduces
message send overhead and increases pipelining potential.)

Whats a struct?

A struct is a special C data type that encapsulates other pieces of data into a single cohesive unit. Like an object, but built into C. 

Whats the difference between frame and bounds?

The frame of a view is the rectangle, expressed as a location (x,y) and size (width,height) relative to the superview it is contained within. The bounds of a view is the rectangle, expressed as a location (x,y) and size (width,height) relative to its own coordinate system (0,0).

 

 

 

What are KVO and KVC?

KVC: Normally instance variables are accessed through properties or accessors but KVC gives another way to access variables in form of strings. In this way your class acts like a dictionary and your property name for example “age” becomes key and value that property holds becomes value for that key. For example, you have employee class with name property.

You access property like

NSString age = emp.age;

setting property value.

emp.age = @”20″;

Now how KVC works is like this

[emp valueForKey:@"age"];

[emp setValue:@"25" forKey:@"age"];

KVO : The mechanism through which objects are notified when there is change in any of property is called KVO.

For example, person object is interested in getting notification when accountBalance property is changed in BankAccount object.To achieve this, Person Object must register as an observer of the BankAccount’s accountBalance property by sending an 

addObserver:forKeyPath:options:context: message.

Difference between shallow copy and deep copy?

Shallow copy is also known as address copy. In this process you only copy address not actual data while in deep copy you copy data.

Suppose there are two objects A and B. A is pointing to a different array while B is pointing to different array. Now what I will do is following to do shallow copy.
Char *A = {‘a’,’b’,’c’};
Char *B = {‘x’,’y’,’z’};
B = A;
Now B is pointing is at same location where A pointer is pointing.Both A and B in this case sharing same data. if change is made both will get altered value of data.Advantage is that coping process is very fast and is independent of size of array.

while in deep copy data is also copied. This process is slow but Both A and B have their own copies and changes made to any copy, other will copy will not be affected.

Delegation in iOS

When you first start out programming iOS application, you’ll most likely notice the continued use of “delegates” throughout the SDK. The delegation pattern is not a pattern specific to iOS, but depending on what programming background you’ve had, it might not be immediately obvious as to what advantages this pattern provides, and why it seems to be used so often.
The basic idea of delegation, is that a controller defines a protocol (a set of method definitions) that describe what a delegate object must do in order to be allowed to respond to a controller’s events. The protocol is a contract where the delegator says “If you want to be my delegate, then you must implement these methods”. What this does is allows the controller to call methods on it’s delegate with the knowledge that the delegate will respond to the method calls. The delegate can be of any object type, so the controller is not coupled to a particular Object, but it can still be sure that the delegate will respond when it tries to tell it things.
Pros

• Very strict syntax. All events to be heard are clearly defined in the delegate protocol.
• Compile time Warnings / Errors if a method is not implemented as it should be by a delegate.
• Protocol defined within the scope of the controller only.
• Very traceable, and easy to identify flow of control within an application.
• Ability to have multiple protocols defined one controller, each with different delegates.
• No third party object required to maintain / monitor the communication process.
• Ability to receive a returned value from a called protocol method. This means that a delegate can help provide information back to a controller.

Cons

• Many lines of code required to define: 1. the protocol definition, 2. the delegate property in the controller, and 3. the implementation of the delegate method definitions within the delegate itself.
• Need to be careful to correctly set delegates to nil on object deallocation, failure to do so can cause memory crashes by calling methods on deallocated objects.
• Although possible, it can be difficult and the pattern does not really lend itself to have multiple delegates of the same protocol in a controller (telling multiple objects about the same event)

Source 
http://blog.shinetech.com/2011/06/14/delegation-notification-and-observation/

Observation in iOS

                Key value observing (KVO) is a pattern in which one object can observe the value of another object’s properties to find out about changes. Where the previous two patterns (delegation and notifications) are more suited to a controller communicating with arbitrary objects, KVO is more suited for objects of any type listening for changes of another arbitrary object (not necessarily, and most often not a controller). It is a way in which we can keep our objects in sync with one another; a way in which we can make one object react when another object’s state changes. It is only used for properties and cannot be used to respond to methods or other actions.
Pros

• Can provide an easy way to sync information between two objects. For example, a model and a view.
• Allows us to respond to state changes inside objects that we did not create, and don’t have access to alter the implementations of (SKD objects).
• Can provide us with the new value and previous value of the property we are observing.
• Can use key paths to observe properties, thus nested objects can be observed.
• Complete abstraction of the object being observed, as it does not need any extra code to allow it to be observed.

Cons

• The properties we wish to observe, must be defined using strings. Thus no compile time warnings or checking occurs.
• Re-factoring of properties can leave our observation code no longer working.
• Complex “IF” statements required if an object is observing multiple values. This is because all observation code is directed through a single method.
• Need to remove the observer when it is deallocated.

Source
http://blog.shinetech.com/2011/06/14/delegation-notification-and-observation/

Notifications in iOS

In iOS applications there is a concept of a “Notification Center”. It is a singleton object that allows for objects to be notified of events occurring. It allows us to satisfy the goal of communicating between a controller and an arbitrary object with a low level of coupling. The basic concept of this pattern is that a controller uses a key (notification name) in order to allow other objects to hear about special events occurring within the controller. Then unbeknown to the controller, other objects (observers) can react to the notification events by registering for notifications with the same key.
Pros

• Easy to implement, with not many lines of code.
• Can easily have multiple objects reacting to the same notification being posted.
• Controller can pass in a context (dictionary) object with custom information (userInfo) related to the notification being posted.

Cons

• No compile time to checks to ensure that notifications are correctly handled by observers.
• Required to un-register with the notification center if your previously registered object is deallocated.
• Not very traceable. Attempting to debug issues related to application flow and control can be very difficult.
• Third party object required to manage the link between controllers and observer objects.
• Notification Names, and UserInfo dictionary keys need to be known by both the observers and the controllers. If these are not defined in a common place, they can very easily become out of sync.
• No ability for the controller to get any information back from an observer after a notification is posted.

Source:
http://blog.shinetech.com/2011/06/14/delegation-notification-and-observation/ 

How to check Multitasking capablity in iOS ?

- (BOOL) isMultitaskingCapable
{
 UIDevice* device = [UIDevice currentDevice];
 BOOL backgroundSupported = NO;
 if ([device respondsToSelector:@selector(isMultitaskingSupported)])
  backgroundSupported = device.multitaskingSupported;
 
 return backgroundSupported;
}