Search Your Question

Can you search your app content In spotlight (search bar)?

Ans : 


Using spotlight search, here we can find loan no 14356 in our application and redirect to view details page of this loan number.

Apple offers us many iOS features that can boost our apps visibility even when the user is not using it. For example, features like Spotlight, Today Widget, iMessage, Push Notifications, Siri and so on...

Spotlight is a super-powerful search feature in iOS that searches through the contents of your installed apps that support it.

If we want our app content to appear in Spotlight, we need to use the CoreSpotlight framework. For creating searchable content we will need to be familiar with:

  • CSSearchableItemAttributeSet - specifies the properties that you want to appear in Spotlight (i.e. title, contentDescription, thumbnail). 
  • CSSearchableItem - this class represents the search item. We can assign a unique identifier for referring the object, a domain to manage the items in groups and attributeSet where we pass the CSSearchableItemAttributeSet that we have created for this object. 
  • CSSearchableIndex - a class that is responsible for indexing the content on Spotlight. It requires an array of CSSearchableItem.
Let's understand through some coding :

We have array of favourite books : 

var favorites = [Int]()   ->   This array contains int id of favourite book.

To enable searching content, we have to add our favourite list in spotlight content like following :

First import ,
import CoreSpotlight 
import MobileCoreServices

When new item added to favourite, it should be also added using following custom function :


func index(item: Int) {
    let book = books[item]

    let attributeSet = CSSearchableItemAttributeSet(itemContentType: kUTTypeText as String)
    attributeSet.title = book[0]
    attributeSet.contentDescription = book[1]

    let item = CSSearchableItem(uniqueIdentifier: "\(item)", domainIdentifier: "com.iosiqabooks", attributeSet: attributeSet)
    CSSearchableIndex.default().indexSearchableItems([item]) { error in
        if let error = error {
            print("Indexing error: \(error.localizedDescription)")
        } else {
            print("Search item successfully indexed!")
        }
    }
}

Understanding above code :

Let's create CSSearchableItemAttributeSet object. This attribute set can store lots of information for search, including a title, description and image, as well as use-specific information such as dates (for events), camera focal length and flash setting (for photos), latitude and longitude (for places), and much more.

Regardless of what you choose, you wrap up the attribute set inside a CSSearchableItem object, which contains a unique identifier and a domain identifier. The former must identify the item absolutely uniquely inside your app, but the latter is a way to group items together. Grouping items is how you get to say "delete all indexed items from group X" if you choose to, but in our case we'll just use "com.iosiqaswift" because we don't need grouping. As for the unique identifier, we can use the project number.

To index an item, you need to call indexSearchableItems() on the default searchable index of CSSearchableIndex, passing in an array of CSSearchableItem objects. This method runs asynchronously, so we're going to use a trailing closure to be told whether the indexing was successful or not.

By default, search item expiry of 1 month. After 1 month, it is deleted from spotlight. We can manually set expiration date like :

item.expirationDate = Date.distantFuture : It will never expire.

If we want to remove content from spotlight or to disable search item for spotlight,

func deindex(item: Int) {
    CSSearchableIndex.default().deleteSearchableItems(withIdentifiers: ["\(item)"]) { error in
        if let error = error {
            print("Deindexing error: \(error.localizedDescription)")
        } else {
            print("Search item successfully removed!")
        }
    }
}

--------

We can now code for tapping on search result interaction in app delegate :

import CoreSpotlight in AppDelegate.swift.

We have to add following AppDelegate method :

func application(_ application: UIApplication, continue userActivity: NSUserActivity, restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void) -> Bool {
    if userActivity.activityType == CSSearchableItemActionType {
        if let uniqueIdentifier = userActivity.userInfo?[CSSearchableItemActivityIdentifier] as? String {
            if let navigationController = window?.rootViewController as? UINavigationController {
                if let viewController = navigationController.topViewController as? ViewController {
                    viewController.readBook(Int(uniqueIdentifier)!)
                }
            }
        }
    }

    return true
}

Credit : HackingWithSwift




Multiple option interview questions

What is the first method called in the iOS App initialisation flow? & what is the return type?
  • Main, , Return the is void.
  • App Delegate, Return type is Bool
  • UIApplicationMain, Return type is Bool
  • Main, Return type is int.

What is the parent class of App Delegate?
  • UIResponder
  • NSObject
  • UIApplicationMain
  • UIKit

What is the difference between [Foo new] and [[Foo alloc] init]?
  • New will not always initialize the object.
  • New is significantly faster than alloc + init.
  • None, they perform the same actions.
  • New does not exist in Objective-C.

What happens at runtime with the following :
    NSObject *obj1 = nil;
    NSObject *obj2 = [obj1 copy];
    NSLog(@"value of object 2  %@",obj2);
  • Application crashes with “SIGABRT”
  • Application continues, but issues “cannot access nil object reference” warning
  • Object 2 is instantiated as an NSObject with nil Values
  • Log prints “(null)” and continues as usual

What is the object.toString equivalent in Objective-C?
  • [NSObject toString];
  •  [NSObject description];
  • [NSObject stringWithFormat];
  •  [NSObject getDescription];

The format for a NSPredicate is the same as a Regular Expression
  • True
  • False

What can happen if you use “self” inside a block?
  • None of the above.
  • Self can become dangling pointer.
  • You can create a retain cycle.
  • By the time the block executes, self can be pointing to a different object[NSObject toString]

What is @dynamic directive meaning in iOS?
  • The @dynamic directive generates the accessor methods for you at compile time.
  • The @dynamic directive tells the compiler that you will provide accessor methods dynamically at runtime.
  • The @dynamic directive generates a getter method for your property at compile time.
  • The @dynamic directive generates a getter method for your property at run time.

You can use %@ to specify a dynamic property
  • True
  • False

What is difference between #import and #include?
  • #import ensures that a file is only ever included once, and #include allows the same thing.
  • None, they do the same thing.
  • #include is not valid syntax.
  • #include ensures that a file is only ever included once and #import permits the file to be included many times.

A UIView is a superclass of:
  • UIViewController
  • UIWindow
  • UIImage
  • UILabel
  • UIScreen

A method and a variable can have the same name in Objective C.
  • True
  • False

What framework is KVO (Key Value Observing) a part of?
  • Foundation
  • UIKit
  • CoreData
  • UIKItCore

What class method is used to make an NSArray from NSData class?
  • NSArray arrayWithObject:
  • NSArray dataWithContentsOfFile:
  • NSData dataWithContentsOfFile:
  • NSKeydUnarchiver unarchiveObjectWithData:

In Core Data, what is the name of the object representation for the database schema?
  • NSManageObjectContext
  • NSManagedObjectModel
  • NSEntityDescription
  • NSManagedObject

What’s the difference between “nil” and “NULL” ?
  • nil is a literal null value for Objective-C instances. NULL is object used to represent null.
  •  nil is a literal null value for Objective-C instances. NULL is literal null value for Objective-C classes.
  • Nil is a literal null value for Objective-C instances. NULL is literal null value for C pointers.
  • NULL is literal null value for Objective-C instances. Nil is literal null value for C pointers
  • they are the same thing


Which of the following is Singleton class?
  • NSFileManager
  • UIApplication
  • NSFileManger & UIApplication
  • NSArray & NSDictionary
  • NSString & NSOperations

What is the output of the below program?

    NSMutableString *tempString = [NSMutableString stringWithString:@"1"];
    dispatch_async(dispatch_get_main_queue(), ^{
        [tempString appendString:@"2"];
        NSLog(@"%@",tempString);
    });
    [tempString appendString:@"3"];
    NSLog(@"%@",tempString);


  • Log prints “13” & “132” and continues as usual.
  • Log prints “12” and then we will have a deadlock here because the main queue will block.
  • Log prints “123” and continues as usual.
  •  Log doesn’t print anything. It’s deadlock here because the main queue will block on the call to dispatch_async.

What is the output of the below program?

    NSMutableString *tempString = [NSMutableString stringWithString:@"1"];
    dispatch_sync(dispatch_get_main_queue(), ^{
        [tempString appendString:@"2"];
        NSLog(@"%@",tempString);
    });
    [tempString appendString:@"3"];
    NSLog(@"%@",tempString);
  • Log prints “13” & “132” and continues as usual.
  • Log prints “12” and then we will have a deadlock here because the main queue will block.
  • Log prints “123” and continues as usual.
  •  Log doesn’t print anything. It’s deadlock here because the main queue will block on the call to dispatch_async.

What is used to sort Core Data results?
  • NSSort
  • NSCoreDataSort
  • [self sort]
  • NSSortDescriptor
  • NSPredicate

Note : Answer is written in Bold.

GIT for Interview

1. Difference between Distributed & Central version control system.
A. GIT is distributed version control system.
     SVN is central version control system.

Central Version Control System : It is located in one place and people can check out from central location to make their changes and then check everything back in but some times it is problematic if central repository is corrupted or central system is not connected through network. For that we have to take backup manually in local machine.

Distributed Version Control System : Everybody has local repository. Your local repository has all information that remote repository has and till last sync done between local and remote repository. So sometimes, if remote repository is not able to be connected through internet, then we can see every changes as it is also saved in local repository. So every developer has repository in locally. So it is called in distributed version control system.


 2. Check version of GIT installed on your machine.
A. git --version

3. Setting configuration
A.
Set username : git config --global user.name "Manan Shah"
Set email : git config --global user.email "manan0shah@gmail.com"
Check configuration setting : git config --list

4. Get git function help
A.

git help <verb>
git verb --help

i.e git help config
     git config --help

     git help add
     git add -help

5. Setup git in your project
A. Goto finder/folder of project which we want to track, using terminal using cd command and write following command
 git init

6. To check status of untracked files in our repository
A. git status

7. Ignore files which we want to keep untracked. Like personal settings, preferences, etc
A. Create a gitignore file : touch .gitingore
     Write down list of files which we want to ignore to track as below :
     .ds_store
     .xcodeproj
     *.py  (wild card used to ignore files which has py extension)

After this, git status

--------------------------------------------

There are 3 area in area we have knowledge about.
1. Working directory
2. Staging Area
3. Git directory

(image from Pro Git" book : https://git-scm.com/book/en/v2)

1. Working directory : Untracked files reside in working directory. -> Files in red colour in terminal
2. Staging Area : When we use command git add . , then this files added to staging area. Which can be committed. -> Files in green colour in terminal
3. Git directory : When we commit our changes, then it goes to git directory. That can be push to remote directory. git commit -m "message for this commit like changes in setting"

Note : If we want to uncommit changes or remote files from staging area to working directory, then Use git reset 

We can check all commit log using command : git log

------------------------------------------

Cloning git repo

git clone <url_of_remote_git> <local_directory>

git clone https://....../remote_repo.git .    (. means in current folder)

-----------------------------------------

Viewing remote repository info

git remote -v  : Give information about your local repository path for fetch, push

git branch -a : Give list of all local and remote branches

-----------------------------------------

Pushing code

git diff : tells difference between remote and local files changes
git pull origin master : pull all changes made from remote repo to local
git push origin master : push all changes from local to remote repo

-----------------------------------------

Merge branch

Suppose, we have worked on calc branch and we need to merge calc branch into master branch.

git checkout master :  Switch to master branch or in which we have to merge
git pull origin master : Pull all changes in master branch from remote server
git branch --merged : Check branch name in which code is to be merged
git merge calc : Merge calc branch with master branch. It shows number of changes. If any conflicts are there, then  we have to solve it using editing code.
git push origin master : Push merged code to remote master branch

-----------------------------------------

Deleting branch

git branch -d calc : Delete calc branch locally
git branch -a : To check whether branch is deleted or not.
git push origin --delete calc : To delete calc branch remotely

-----------------------------------------------------------------------------------------------------------------

Different parameters for adding files to staging area  :

1. git add -A or git add --all (Default): adding all files from leading directory into staging area
2. git add -A my_dir/ or git add my_dir/ : adding only files located in my_dir into staging area
3. git add -u : adding only modified files into staging area
4. git add -u my_dir/ : adding only updated files located in my_dir into staging area
5. git add . : adding all files in current directory into staging area
6. git add .gitignore : Add only specific file into staging area.

Difference between git add -A and git add . : git add -a add all files in leading directory and git add . only add files from current directory.

-----------------------------------------------------------------------------------------------------------------

Switch to branch without commiting

git stash save "worked on save function" : It will save this branch at this point without commited. And this branch at initial stage.
git stash list : List all stashes here
stash@{0} : On add : worked on save function
git stash apply stash@{0} : Come to our point back using this command. stash will not be dropped.
git stash pop : Come to our point back & drop stash from list.
git stash drop stash@{0} : drop stash@{0}
git stash clear : Clear all stash in list

If we want to do changes from one branch to another branch, then this is most wanted method.

Suppose, I have changed code in master branch.  But I want it to CalC branch. Then,
git stash save "add function" :  save stash on master branch
git checkout CalC :  Switched to CalC branch
git stash pop : apply changes
git add . : add files to staging area
git commit -m "intr" : commit & push


Note : New stash come at top position. Always at 0th position. @{0}.

-----------------------------------------------------------------------------------------------------------------

Git difftool & mergetool

git diff : It shows modification with red(Previous) and green(Current) colour content between previous and current file on terminal window. It is very hard to see where we have changed or what word we have changed. Because git diff shows full line instead of changed word.

So instead of using, there are many diff tool and merge tool available. I,e DiffMerge
Using this tool, we can easily find changes and solve if any conflicts are there just because it is graphically represent instead of just terminal.
For that we have to download and install that tool and configuration with our git. After configuration, check configuration using git config --global --list

Check
diff.tool = diffmerge
merge.tool = diffmerge

happened or not?

Now,
to run that diff tool ,
git difftool : It required permission to open diff tool, press Y to open difftool, and we can see modification clearly with color and word by word.

We can take changes according to we required by simply click on which changes and from which file(previous or current).

git mergetool : To merge branch. If any conflict occur, we can easily solve using this type tool due to visual representation.



-----------------------------------------------------------------------------------------------------------------

To change last commit message,
git commit --amend -m "new message" : It will change message of last commit message.

Hight thank full to Corey Schafer

I took help from following videos  :

1. Git Tutorial for Beginners: Command-Line Fundamentals
2. Git Tutorial: Fixing Common Mistakes and Undoing Bad Commits
3. Git Tutorial: Using the Stash Command
4. Git Tutorial: Diff and Merge Tools
5. Git Tutorial: Change DiffMerge Font-Size on Mac OSX
6. Git Tutorial: Difference between "add -A", "add -u", "add .", and "add *"

If you have any doubts for git, please comment on this blog. 



How to call segue programmatic?

Ans : 

For segue first, We have to set identifier in Class Inspector right side in XCode. Through that identifier, we can call like

performSegue(withIdentifier: "identifier", sender: nil) 

What is Content Hugging and Content Compression Resistance Priority?

Ans : 

The priority really come in to play only if two different constraints conflict. The system will give importance to the one with higher priority. So, Priority is the tie-breaker in the autolayout world.

1. Content Hugging Priority : 

Larger the content hugging priority , the views bound will hug to the intrinsic content more tightly preventing the view to grow beyond its intrinsic content size. Setting a larger value to this priority indicates that we don’t want the view to grow larger than its content.


In above example, we set both label leading, trailing, top and bottom but not set width constraint. So here conflicts will occur. You can see red line between two label showing conflict.

Solution : If we have label's content hugging priority higher than there will be no conflicts as hight priority label will not grow its size more than its content size. See below image :

Blue label has more content hugging priority (251) than green label(250). Blue label's width will be set fixed as its content size.

2. Content Compression Resistance : 

Setting a higher value means that we don’t want the view to shrink smaller than the intrinsic content size. It's simple : Higher the priority means larger the resistance to get shrunk.

Example . One button having large name and auto layout is set on button as its width is become 40. So, button's content is not readable. See image :
Button horizontal compression resistance is 750 and width constraint priority is 1000.

For Solution, let's change horizontal compression resistance to 1000 and width constraint priority less than 1000 i.e 999 . Now see effect on below image :
Button horizontal compression resistance is 1000 and width constraint priority is 999.


If you have any comment, question, or recommendation, feel free to post them in the comment section below!

What is closure? Why we use closure instead of function sometime?

Ans : 

The two most used cases are completion blocks and higher order functions in Swift. 

Completion blocks: for example, when you have some time consuming task, you want to be notified when that task is finished. You can use closures for that, instead of a delegate (or many other things)


func longAction(completion: () -> ()) {
    for index in veryLargeArray {
        // do something with veryLargeArray, which is extremely time-consuming
    }
    completion() // notify the caller that the longAction is finished
}

//Or asynch version
func longAction(completion: () -> ()) {
    
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)) {
        
        for elem in veryLargeArray {
            // do something with veryLargeArray, which is extremely time-consuming
        }
        dispatch_async(dispatch_get_main_queue(), {
            completion() // notify the caller that the longAction is finished
        })
    }
}

longAction { print("work done") }

In the example above, when you have a time consuming task, you want to know when the for loop finishes iterating through the very large array. You put the closure { println("work done") } as an input parameter for the function which will be executed after the for loop finishes its work, and print "work done". And what happened is that you gave a function (closure) to longAction and name it to completion, and that function will be executed when you call completion in longAction.

Sorted method works using closure.

About how sorted (probably) works: So the idea is, that sorted will go through the array, and compare two consecutive elements (i, i + 1) with each other, and swap them, if needed. What does it mean "if needed"? You provided the closure { (s1: String, s2: String) -> Bool in return s1 > s2 }, which will return true if s1 is greater than s2. And if that closure returned true, the sorted algorithm will swap those two elements, and continues this with the next two elements (i + 1, i + 2, if the end of the array is not reached). So basically you have to provide a closure for sorted which will tell "when" to swap to elements.

Understand Closure


Differences between internal testers and external testers in test-flight?

Ans : 

Both internal and external testers will install your app from the TestFlight app. Once invited, they will be sent an email asking them to install the TestFlight app. Once they have done so, they'll be able to install your beta app...
Internal Testers: Think of these users as employees who receive instant updates to your app without approval/review
  • Must be added manually via iTC
  • 25 Max allowed
  • Once your app is uploaded it's available immediately for internal testers (before it has been reviewed)
  • All internal testers must be added as a user in your iTC "Users and Roles" settings, which gives them certain permissions (review other answers and the docs for this). You wouldn't want to give just anyone permissions here.
  • Do not have a 60-day time limit
External Testers
  • Will only be able to use your uploaded build for up to 60 days. If you add additional builds, they can update, and the 60 days starts over again.
  • Will be able to test your app after
    1. You have submitted it for review
    2. It gets approved in TestFlight review and
    3. You set it to be available for testing. The review process us usually instant for new builds with the same version number. If you add a new version number, the review process can take up to 48hrs as of 10/2016.
  • Up to 2000 email addresses can be added. Each email address will allow a user to install the app on multiple devices. The email addresses do not need to match their Apple IDs.
  • They receive an invite to install your app once your first build is available for testing. If you add a new user after making a build available for testing, they'll immediately receive an invite. All users will receive notifications to install newer versions of the app if you upload additional builds.
  • Will be disallowed from using your app after you have pushed it to the official app store (which promptly ends the beta) or 60 days have passed since you started the beta, whichever comes first. If you end the beta without launching in the app store, and they try to open it, it will crash. Yay, Apple UX! If you do push a version to the app store with the same bundleName, version, and bundleID (build number doesn't matter), then your beta testers will automatically receive the app-store version of the app when it goes live.

What are certificates and provisioning profile for uploading app to app store?

Ans : 

Certificates - This is a cryptographic certificate granted to you by Apple.  It works just like SSL where you get a certificate signed by an authority.  Apple signs the private key that you use to sign different pieces of your application.  Different certificates create different types of trust.  Some allow you to sign and submit your application for the App Store, while others allow your application's web server to send push notifications to users via APNS.  In the latter case, for instance, Apple uses this certificate to trust the web server sending the push notification.  Otherwise, it would be easy for an attacker to spoof a valid push notification and spam users.  The most common certificate you would create signs the key you use to deploy your application to a device or submit it to the App Store.

When you create a certificate through Apple's developer portal, you have to create your key pair and send a "Certificate Signing Request," which at first is likely pretty confusing to developers just trying to see their application run on a device.
If you visit the developer portal, you'll find you can create certificates for Development or Distribution.  These certificates are rooted to different authorities, so that the two worlds are never confused (though all iOS devices trust both in a seemingly equal fashion).
Provisioning Profiles - Probably the most confusing component in the system, a provisioning profile indicates the devices for which an application is correctly signed.  If you visit the developer portal, you'll notice you can create two types (again called Development and Distribution).  Provisioning profiles say "applications with this Identifier signed with this Certificate's private key are okay to run on these devices."  Now that you know a provisioning profile is tied to a certificate, you can see why you have to decide whether to create a Development or Distribution profile.  Development profiles are limited to 100 devices.  Distribution profiles can either be Ad-Hoc or App Store distribution profiles.  I am not sure whether Ad Hoc profiles have device limits.
You might ask, then, why not always use a Distribution profile?  It can deploy to an unlimited number of devices, and is still attached to a certificate owned by the developer.  Another piece of Apple's security puzzle are Entitlements.  In an iOS application's bundle, you'll find Entitlements.plist, which is a list of capabilities that an application wants.  When signing your application using a certificate intended for distribution, Xcode (really the signing utility) will not allow an entitlement with get-task-allow set to YES.  This is because get-task-allow is what allows a debugger to connect to a process, and Apple doesn't want that happening on apps meant for distribution.


Short Ans : 

1. A Certificate authenticates you as an entity. It can represent you as an individual, or your company.
2. The Identifier is a unique ID for your mobile app.
3. A provisioning profile associates your certificate with the App ID. It is the link between #1 and #2 above.



What is MLKit?

Ans : 

ML Kit is a mobile SDK that brings Google's machine learning expertise to Android and iOS apps in a powerful yet easy-to-use package.

Use : 

  • Text Recognition API to detect text in images 
  • Face Contour API to identify facial features in images 
  • Cloud Text Recognition API to expand text recognition capabilities (such as non-Latin alphabets) when the device has internet connectivity .
  • Learn how to host a custom pre-trained Tensor Flow Lite model using Firebase 
  • Custom Model API to download the pre-trained TensorFlow Lite model to your app Use the downloaded model to run inference and label images

What is handshaking process?

Ans :

Handshaking is an automated process that sets parameters for communication between two different devices before normal communication begins. Much like the way a human handshake sets the stage for the communication to follow, the computing handshake provides both devices with the basic rules for the way data is to be shared between them. These rules can include transfer rate, coding alphabet, parity, interrupt procedure and more.

What is Enumeration in Swift?

Ans : 

What is enum?
An enumeration defines a common type for a group of related values and enables you to work with those values in a type-safe way within your code.
Enumerations offer an easy way to work with sets of related constants. An enumeration, or Enum, is a symbolic name for a set of values. Enumerations are treated as data types, and you can use them to create sets of constants for use with variables and properties.

When to use an enum?
Whenever a procedure accepts a limited set of variables, consider using an enumeration. Enumerations make for clearer and more readable code, particularly when meaningful names are used.

The benefits of using enumerations include:

  • Reduces errors caused by transposing or mistyping numbers. 
  • Makes it easy to change values in the future. 
  • Makes code easier to read, which means it is less likely that errors will creep into it. 
  • Ensures forward compatibility. With enumerations, your code is less likely to fail if in the future someone changes the values corresponding to the member names.



What are the app id and bundle identifier?

Ans : 
Bundle ID : 
A bundle ID or bundle identifier uniquely identifies an application in Apple's ecosystem. This means that no two applications can have the same bundle identifier. To avoid conflicts, Apple encourages developers to use reverse domain name notation for choosing an application's bundle identifier.
i.e com.iosiqa.newapp or com.iosiqa.app.new

App ID : App ID consists of Team ID + Bundle ID. Team ID is provided by apple to one team in developer account.
i.e ABC12345.com.iosiqa.newapp

What is use of APP ID? 
Whenever you want to enable a capability or application service for your application, you enable that capability for the App ID your application is linked to. This used to be tedious, requiring a visit to Apple's developer website. Xcode has evolved quite a bit over the years and it takes care of the details most of the time.

How To declare custom tableview cell? What Is The Use Of dequeuereusablecellwithidentifier ?

Ans : 

Let's create custom cell :

1. Take viewcontroller or tableviewcontroller
2. In Tableview, put one uitableviewcell and change style to custom.
3. Give any string (i.e "newcell") to reuseidentifier of cell in attribute inspector.
4. Put labels, textfields, views in cell according to your need.
5. Add new file named as newCell.swift that inherit from UITableViewCell.
6. Select your cell and give class name newCell.
7. Now you can make outlet of that cell in newCell.swift.

Here magic will be created using dequeuereusablecellwithidentifier : 

The best part of using dequeueReusableCellWithIdentifier is that using this you can re-use your cells.

Imagine if your table has 1000 entries. Now, if for each entry a table cell would be created then for 1000 entries, 1000 tableview cells and memory allocation for 1000 tableview cells.

App will be slowed down or would crash if the entries goes beyond 1000.

When we use, dequeueReusableCellWithIdentifier, the tableView just creates exactly the number of cells based on your table height and cell height. Suppose, if it shows 4 cells in the tabelView and rest you can see by scrolling, then memory for only 4 cells would be allocated at any given point of time.

Now, when you will scroll the tableView, it will re-use the same cell but will change the cell content (data) based on your data source.

Hope this clears your doubt.

Code

- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
    UITableViewCell *cell =[tableView dequeueReusableCellWithIdentifier:"newcell"];
    cell.textLabel.text = @"Test";
    return cell;

}

Difference between App Bundle and File Directory

Ans : Although bundles and packages are sometimes referred to interchangeably, they actually represent very distinct concepts:

1.
A package is any directory that the Finder presents to the user as if it were a single file.
A bundle is a directory with a standardized hierarchical structure that holds executable code and the resources used by that code.

2.
The Finder considers a directory to be a package if any of the following conditions are true:
.The directory has a known filename extension: .app, .bundle, .framework, .plugin, .kext, and so on.
.The directory has an extension that some other application claims represents a package type; see Document Packages.

Difference between array, set and dictionary

Ans : 

Array :
Arrays are effectively ordered lists and are used to store lists of information in cases where order is important.
Cost of adding item in array is greater than set and dictionary if item is not appending first.

For example, posts in a social network app being displayed in a tableView may be stored in an array.

Set : 
Sets are different in the sense that order does not matter and these will be used in cases where order does not matter. Sets are especially useful when you need to ensure that an item only appears once in the set.

Dictionary : 
Dictionaries are used to store key, value pairs and are used when you want to easily find a value using a key, just like in a dictionary.


For example, you could store a list of items and links to more information about these items in a dictionary.


What is NSPredicate?

Ans : Using NSPredicate, we can filter records before fetching from Coredata or collections. It work in place of where clause in sql.

NSPredicate on Core Data :

When we want data from coredata of only who's name is Manan Shah. So using predicate we can filter as following :

var strName = "Manan Shah"
request.predicate = NSPredicate(format: "name = %@", strName)

NSPredicate on Collections : 

let manan = Person(firstName: "Manan", lastName: "Shah", age: 28)
let sagar = Person(firstName: "Sagar", lastName: "Shah", age: 26)

let people = [manan, sagar] as NSArray

let thirtiesPredicate = NSPredicate(format: "age >= 27")

people.filtered(using: thirtiesPredicate)
Result : manan object will be return.

What is safe area?

Ans: The Safe Area Layout Guide helps avoid underlapping System UI elements when positioning content and controls.

The Safe Area is the area in between System UI elements which are Status Bar, Navigation Bar and Tool Bar or Tab Bar. So when you add a Status bar to your app, the Safe Area shrink. When you add a Navigation Bar to your app, the Safe Area shrinks again.

On the iPhone X, the Safe Area provides additional inset from the top and bottom screen edges in portrait even when no bar is shown. In landscape, the Safe Area is inset from the sides of the screens and the home indicator.

The layout guide (Safe area) representing the portion of your view that is unobscured by bars and other content. In iOS 11+, Apple is deprecating the top and bottom layout guides and replacing them with a single safe area layout guide.

In iPhone X portrait, safe area insets from top(notch) and bottom(home) side, and
in landscape, left(notch/ home bar) and right side(home bar/notch) and also bottom side.

We can enable using of safe area layout guide property of view controller from class inspector.

Difference between SOAP and REST

Ans : 

1. Requests sent via REST tend to be much lighter than SOAP. Because of this, applications don't require much bandwidth to use REST web services over SOAP.

2. REST is good when working with web services open to the public, but if security is required, then the SOAP API is better to use. 

3. SOAP permits XML data format only while REST permits Plain text, HTML, XML, JSON etc.

i.e 

Suppose we want to retrieve today's weather report from a server which is providing weather information, your RESTful URL will look something like http://weatherdata.org/data/weather/uk/london (Not real link just example url), which is very similar to HTTP request like http://weatherdata.org/data/weather?q=uk,London.

On the other hand, in order to get the same data using SOAP, you need to create an XML message with header and body and send it http://www.webservicex.net/globalweather.asmx?op=GetWeather

In short, RESTfull web services are much simpler, flexible and expressive than SOAP web services in Java.

How many ways we can present view controller?

Ans : 

There are only 2 options to display one viewcontroller2 from viewcontroller1. It is depend on what we want to achieve.

1.Modal Presentation : Use this only viewcontroller2 should take focus away from viewcontroller1 entirely until it is dismissed.

[self presentViewController:viewController2 animated:YES completion:nil];

ViewController2's presenting viewcontroller is ViewController1.
ViewController1's presented viewcontroller is ViewController2.

UIAlertViewController is working on this way.

2. ViewController Containment : Use this if you want to display viewcontroller1's some view in which viewcontroller2's shows. So if there are 4 views, then in 4 views of viewcontroller1, we can show 4 different viewcontroller.

[self addChildViewController:viewController2];
[self.view addSubview:viewController2.view];
[viewController2 didMoveToParentViewController:self];

So here viewcontroller2's parent viewcontroller is viewcontroller1.
But viewcontroller1's child viewcontroller array contrains viewcontroller2.

UINavigationViewController is working on this way.

So interviewer ask questions about presented viewcontroller, parentviecontroller.

But in 1st way, parent viewcontroller is nil.
in 2nd way, presented viewcontroller, presenting viewcontroller is nil.

What is retain cycle or strong cycle?

Ans : 

According to ARC, variable should be one of three Strong, Weak or unowned. By default, variable has strong reference.

Let's take example :

class Employee {
var name  : String
var emid  : String
var title : String
init(name: String,emid: String, title: String) {
           self.name = name
   self.emid = emid
   self.title = title
        }

        deinit {
print("Employee : \(name) removed")
}
}

var manan : Employee? = Employee(name: "Manan", emid: "1234", title: "Sr iOS Developer")
manan = nil

Here deinit will be called and output will be "Employee Manan removed"

Now we add reference :

var sagar = manan
manan = nil

Here deinit will not be called due to adding reference. Here sagar has strong reference to variable which owned by manan before.

Now,

var sagar = manan
manan = nil
sagar = nil

Here deinit will be called and again output will be "Employee Manan removed"


Now let's discuss about Strong cycle :

Strong cycle occurs when two object has strong reference to each other. i.e objectA has strong reference to objectB and objectB has strong reference to objectA.


example :

class Employee {
var name  : String
var emid  : String
var title : String
var macBook : MacBook?
init(name: String,emid: String, title: String) {
           self.name = name
   self.emid = emid
   self.title = title
        }

        deinit {
print("Employee : \(name) removed")
}
}

class MacBook {
var serialNumber: String
var assignee : Employee?
        init(serialNumber: String) {
              self.serialNumber = serialNumber
        }

deinit {
print("Macbook : \(serialNumber) removed")
}
}

var manan : Employee? = Employee(name: "Manan", emid: "1234", title: "Sr iOS Developer")
var mac : MacBook? = MacBook(serialNumber: "ABC123")
manan?macBook= mac
manan = nil
mac = nil

Here, output :

Employee Manan removed
Macbook ABC123 removed

Why? Because here there is no strong reference from both side. So retain cycle is not yet created.

Now,

var manan : Employee? = Employee(name: "Manan", emid: "1234", title: "Sr iOS Developer")
var mac : MacBook? = MacBook(serialNumber: "ABC123")
manan?macBook= mac
mac?.assignee = manan
manan = nil
mac = nil

Output will be :

Nothing will be removed. Not output comes. Because of retain cycle. So there are strong relationship between both objects like manan has mac and mac is assigned to manan.

So, if we want to solve this problem we have to use weak or unowned reference for one side.

So,

weak var assignee : Employee?

Now output will be :

Employee Manan removed
Macbook ABC123 removed

So Now unowned : It is same as weak as it does not hold strong relationship with object. So when to use unowned : An unowned reference is used when the other instance has the same lifetime or a longer lifetime.

Difference between weak and unowned :


  • weak reference is used where there is possibility for that reference to become nil at some point during its lifetime. 
  • An unowned reference is used where there is no possibility for that reference becoming nil at any point until the self-object exist.
Example :

Every employee may or may not hold ICard but every ICard must be assigned to some one.
So Employee class has ICard variable as optional, but in ICard class, employee variable with optional and weak is not possible. If we want to use weak, we should make employee variable in ICard class optional. But we don't want that.

So, solution is that : 

unowned var employee : Employee

Now we are cleared about strong, weak and unowned and also our question : Retain Cycle or Strong Cycle.

Credit : Vinod Shwami

Application States

Ans : 

Before iOS 4.0 there were 3 states. Not running, inactive and active.

  1. Non-running - The app is not running.
  2. Inactive - The app is running in the foreground, but not receiving events. An iOS app can be placed into an inactive state, for example, when a call or SMS message is received.
  3. Active - The app is running in the foreground, and receiving events.
  4. Background - The app is running in the background, and executing code.
  5. Suspended - The app is in the background, but no code is being executed.
For maintaining above states, there are following app delegate methods:


application:willFinishLaunchingWithOptions (First method)
Method called when the launch process is initiated. This is the first opportunity to execute any code within the app.

application:didFinishLaunchingWithOptions
Method called when the launch process is nearly complete. Since this method is called is before any of the app's windows are displayed, it is the last opportunity to prepare the interface and make any final adjustments.

applicationDidBecomeActive
Once the application has become active, the application delegate will receive a callback notification message via the method applicationDidBecomeActive.

This method is also called each time the app returns to an active state from a previous switch to inactive from a resulting phone call or SMS.

applicationWillResignActive
 Each time a temporary event, such as a phone call, happens this method gets called. It is also important to note that "quitting" an iOS app does not terminate the processes, but rather moves the app to the background.

applicationDidEnterBackground
This method is called when an iOS app is running, but no longer in the foreground. In other words, the user interface is not currently being displayed. According to Apple's UIApplicationDelegate Protocol Reference, the app has approximately five seconds to perform tasks and return. If the method does not return within five seconds, the application is terminated.

applicationWillEnterForeground
This method is called as an app is preparing to move from the background to the foreground. The app, however, is not moved into an active state without the applicationDidBecomeActive method being called. This method gives a developer the opportunity to re-establish the settings of the previous running state before the app becomes active.

applicationWillTerminate
This method notifies your application delegate when a termination event has been triggered. Hitting the home button no longer quits the application. Force quitting the iOS app, or shutting down the device triggers the applicationWillTerminate method. This is the opportunity to save the application configuration, settings, and user preferences.



What is localization?

Ans : 

Localization is simply the process of translating your app into multiple languages. However, before you can localize your app, you first need to internationalize it. Internationalization is the process of making your app able to adapt to different languages, regions, and culture. Simple enough, I guess.

So after opening app, we can detect user's locale and change app's language,time accordingly.


Difference Between Inheritance And Extensions?

Ans : 

When to use extension : 
Are you adding general-purpose functionalities that should be available to every UITextField? If so, make an extension. All UITextField instances can call the new methods.

When to use inheritance : 
Are you adding functionality that should be restricted to special instances of UITextField that you would identify precisely? If so, make a subclass. Only the instances of the subclass can use the new methods.

Another diff :

In extension, there is no any specific name of extension in swift, but while subclassing there is another name of subclass.

In extension, we can not add variables (fields), in subclass it is possible to declare variables.


How To Access AppDelegate Methods In Other Class?

Ans : 

let appDelegate: AppDelegate? = UIApplication.shared.delegate as? AppDelegate
appDelegate?.application(UIApplication.shared, didFinishLaunchingWithOptions: nil)

You can make your custom method any called from viewcontroller like :

let appDelegate = UIApplication.shared.delegate as! AppDelegate appDelegate.anyAppDelegateInstaceMethod()

But above is only possible in iOS 10.0 or newer version.