Apple ID & iCloud in Enterprise

October 27, 2016 / Arun Patwardhan / Leave a comment

This is the third part in the 3 part series on Apple ID & iCloud. This part touches on enterprise specific aspects.

Here are the links to Part 1 & Part 2.

iCloud

September 19, 2016 / Arun Patwardhan / 1 Comment

This video is best viewed at 720p

Previous Video: Apple ID & iTunes

Collection Type, Sequence Type & Indexable Type

August 20, 2016February 27, 2017 / Arun Patwardhan / 1 Comment

This is for Swift Version 2.2 & earlier. I will be adding the snippet of code for the changes the Swift 3.x have introduced.

What are the Collection Type & Sequence Type Protocols?

The Collection Type, Sequence Type & Generator Type Protocols define rules that govern how different data structures or collections of data can be used, interacted with and operated within the Swift programming language. The CollectionType is a special case of the SequenceType.

Why do we need such Protocols?

Lets take the example of the Swift For-Loop.

var arrOfStrings : [String] = [String]()

arrOfStrings.append("Jill")
arrOfStrings.append("Jack")
arrOfStrings.append("John")
arrOfStrings.append("Jane")

for name in arrOfString
{
     print("The name is \(name)")
}

Now, if we have created our own data type. We would not be able to use the above for-loop as it would not conform to the … type protocols. The for-loop is expecting a data structure that acts and behaves in a way that is governed by the … protocols.

Just like the for-loop example above there are many other features within the Swift Programming Language that expect data structures to act and behave in a particular way. By designing our data structures to conform to these protocols we can make the easily compatible with the existing code and language features out there.

How do we use these protocols for our own data structures?

First we need to decide what kind of collection are we making. For the sake of this example I will create a Custom Stack.

class CustomStack<Element>
{
    var data : [Element] = [Element]()

    func push(Element newElement : Element)
    {
        data.append(newElement)
    }

    func pop() -> Element
    {
        return data.removeLast()
    }
}

The above code is very simple for the purpose of this exercise. Its a stack. Which is internally really an Array. It has functions to push data and pop data. We are now going to convert this type to a collection to conform to the CollectionType protocol.

Implementing the Indexable Protocol methods

As a first step we are going to make our CustomStack conform to the Indexable Protocol.

extension CustomStack : Indexable
{
    //INDEXABLE PROTOCOLS
    typealias Index = Int

    var startIndex : Int
    {
        return 0
    }

    var endIndex: Int
    {
        return (data.count - 1)
    }

    subscript (position : Int) -> Element
    {
        return data[position]
    }
}

The above change makes the data structure conform to the Indexable protocol. This is a requirement for it to be of type CollectionType. In order to conform to the Indexable protocol we need to implement a few computed properties. Let us look at the changes

typealias Index = Int

This line informs the system that the Indexing type for my data structure is an Int.

var startIndex : Int
{
    return 0
}

var endIndex: Int
{
    return (data.count - 1)
}

The next 2 are computed properties. Each provides the implementation of the startIndex and endIndex properties. Note that the type for both is Int as we have declared the Index type earlier as Int.

subscript (position : Int) -> Element
{
    return data[position]
}

The last implementation is of subscript. This provides the implementation to access an Element from the Stack using the Subscript operator.

Implementing the Sequence Type Protocol

Next we will implement the Sequence Type Protocol methods.

extension CustomStack : SequenceType
{
    typealias Generator = AnyGenerator<Element>
    
    func generate() -> Generator
    {
        var index = 0
        
        return AnyGenerator(body: {() -> Element? in
            if index < self.data.count
            {
                let res =  self.data[index]
                index += 1
                return res
            }
            return nil
        })
    }
}

Let us examine this code line by line.

typealias Generator = AnyGenerator<Element>

Objects of type Generator allow us to navigate through our collection. Quite like how iterators work in C++. This line specifies the type to be AnyGenerator for Elements.

func generate() -> Generator

Next we start the implementation of the generate function. This is required as part of the SequenceType protocol.

var index = 0

This index variable is used to track the element that is currently being accessed.

return AnyGenerator(body: {() -> Element? in
            if index < self.data.count
            {
                let res =  self.data[index]
                index += 1
                return res
            }
            return nil
        })

The return statement is the main statement. Here we are creating an object of type AnyGenerator. As an argument to the constructor call we are passing in a closure that will be used to iterate through the sequence. Note that the closure captures the index variable and holds a reference to its value even though we have left the original function.

Implementing the Collection Type Protocol

Next we will implement the Collection Type Protocol methods. We don’t really need to implement a lot in order to conform to the CollectionType protocol. In fact, if we just conform to the CollectionType protocol and use the implementations of the previous 2 extensions we should be just fine. However, for the sake of demonstration we are implementing the subscript functionality within the CollectionType.

extension CustomStack : CollectionType
{
    typealias SubSequence = CustomStack<Element>
    
    subscript (bounds: Range<CustomStack.Index>) -> CustomStack.SubSequence
    {
        let newStack : CustomStack<Element> = CustomStack<Element>()
        
        for i in bounds.startIndex...bounds.endIndex
        {
            newStack.push(Element: data[i])
        }
        return newStack
    }
}

Let us look at the code line by line.

typealias SubSequence = CustomStack<Element>

Again, as before this line indicates that the SubSequence type is actually a CustomStack.

subscript (bounds: Range<CustomStack.Index>) -> CustomStack.SubSequence

Here we start the implementation of the subscript functionality.

let newStack : CustomStack<Element> = CustomStack<Element>()
        
for i in bounds.startIndex...bounds.endIndex
{
     newStack.push(Element: data[i])
}
return newStack

The rest of the code is the implementation of the subscript range behaviour. One can have different implementations to achieve the same result.

CollectionType Video

Conclusion

As we can see, by designing our data structure to conform to a particular set of protocols. We have made it possible for our data structure to take advantages of the different features, functionalities and even API’s available within the Swift Language and the Frameworks used as a part of iOS, macOS, watchOS & tvOS development.

Creating Frameworks for iOS/OS X App Development

August 6, 2016 / Arun Patwardhan / 1 Comment

Creating Swift Frameworks

Creating Swift Frameworks is easy. The steps below walk you through creating a Swift Framework. The steps below have been performed on Xcode 7.3

Launch Xcode.
Select Create New Project. Or from the menu bar select File > New > Project
From the Template chooser select the Framework & Library Option under iOS
Select Cocoa Touch Framework
Give your project a name.
Make sure the language selected is Swift.
Feel free to enter values of your choice for organisation name and organisation identifier.
Save your project. Optionally, if you have a version control repository like Git you may save it there.
In left hand side bar make sure you have selected the Project Navigator.
Within the Project Navigator make sure you have selected the folder named after your project.
Click on File > New > File.
Make sure iOS Source is selected on the left hand side.
Select the file type as Swift.
Write down the code that you want to make available through a framework.
Now this is the key point. Place the keyword public before all the elements that you want to make publicly accessible.Why do we need to do this? To understand this we need to understand the scope of different elements within a typical Swift project.
Different variables/classes/functions that are declared within a module are accessible freely within the module. Swift files contain code & are themselves found within Swift modules. So a module can mean project or a framework.So, to access the variables/functions/classes from module A in module B, we have to make those elements of module A public in order to access them in module B.

For more information, do read Apple’s Swift Documentation.
The next steps depend on what your ultimate objective is. If you wish to build a framework for distribution then you need to follow a process that is similar to distributing an app. You need to get the code signing done & prepare the project for distribution.
If however, you plan to release it internally, or even just test it. Then you can follow the steps below.
Firstly, our objective is to make this framework run on both OS X(macOS) as well as iOS.
To do that we will be adding a new target. Click on File > New > Target.
Select OS X & the Frameworks & Libraries from the sidebar.
Select Cocoa Touch Framework
Give your framework a unique name. Something that indicates this framework is for OS X(macOS).
Now, we don’t need to rewrite the code for the Mac. We can simply make the file we have written a member for the OS X Framework Target.
To do that make sure that the right hand side sidebar is visible.
In the left hand side sidebar make sure that you have selected the new Swift file with the code you have written in there.
In the right hand side sidebar select the Document Inspector.
Under Target Membership make sure that both the Targets are checked. The target for iOS should already be checked.
Thats it. If you do not wish to make your code available for both iOS & OS X then skip steps 19 – 27.
The next part is building the framework. We will be building this framework for use internally. We will first build the iOS framework.
From the tool bar, make sure the target selected is for iOS. For the device you can select any device that you wish.
Then click on Product > Build to build the framework. If all goes well then you should get the message Build Succeeded on your screen.
To get hold of the framework, expand the product folder from the left hand side sidebar.
Select the Framework you have just built. Note that it should be black in colour. If you have opted to make a framework for OS X, then you should see that framework listed too, it should be in red colour. The red colour indicates that it has not yet been built.
Control-click on the iOS version of the framework and select Show in Finder.
This will take you directly to the folder containing the framework. Copy paste it to the desktop or to any other location to easily access it when required.
Repeat steps 30 – 34 to build the OS X version of the Framework. Make sure that the target selected is OS X.
Once we have done that, we need to test the framework we just created.
Create a dummy iOS Project for testing.
From the left hand side project navigator make sure that the blue project settings file is selected.
Make sure that the Target is selected within the settings screen.
Under the General tab scroll down to the Embedded Binaries section.
Click on the ‘+’ sign to add a framework.
Click on Add other
Navigate to the folder where you saved the Framework and select it.
Click Open
Select Copy Items if needed
The framework should be added to your project.
In the ViewController.swift file import your Framework: import CustomStack
Replace CustomStack with your frameworks name.
Try to write the code which uses the elements you have packaged within the framework.

Creating Mixed Frameworks (Swift & Objective-C)

The process of creating a mixed library is straightforward. Its almost the same as above with some minor differences.

Follow the steps mentioned above to add your Swift Code.
Add your objective-C files to the project.
While adding the files make sure that the checkbox for the targets is selected appropriately.
Write the code that you wish to write in Objective-C. Of course, if you are including prewritten files then you do not need to do this.
To make the Objective-C code accessible in Swift you need to make the following changes:
1. In the umbrella header of your framework add the line to import the header
```
#import "<FrameworkName>/<HeaderName>.h
```
2. Modify the access property located within the target membership of the Objective-C header file.
This should make your Objective-C code accessible to the Swift files.
Test the changes by accessing your Objective-C code in your Swift files within the framework.
Test the changes further by embedding your mixed language framework into a project & then try to access both the Swift as well as Objective-C versions of the code in your new project.
To make your Swift code accessible to Objective-C File make the following changes:
1. Make sure that your Swift code is compatible with Objective-C. There are 2 ways of doing this. One you can make your Swift class inherit from NSObject. The second way is to use the @objc keyword before your class declaration.
2. In the Objective-C header file add the line to add the bridging header which is auto generated. You do not need to create your own bridging header.
```
#import "<FrameworkName>/<FrameworkName>-Swift.h"
```
  Replace the word FrameworkName with the name of your Framework.
3. This should allow you to access your Swift code in your Objective-C header file within the same Framework Project.
This way you can make a single framework which contains code written in both Swift & Objective-C.

Loading your App on your iPhone

April 1, 2016 / Arun Patwardhan / Leave a comment

To view the channel click here.

Writing Swift Programs on Linux

January 23, 2016 / Arun Patwardhan / 2 Comments

Swift Programming on Linux

The steps below walk you through the process of downloading, installing & using the Swift Programming language on Linux. For this I will be using Ubuntu Linux 14.04.3 LTS version.

Setup & Configuration

Downloading Swift
The first step is to download Swift from the link given below. Select the correct version of the OS.
https://swift.org/download/#latest-development-snapshots
Install clang
The next step is to get hold of clang which is a compiler front end for C,C++,Objective-C & Objective-C++. For more information on clang:
https://en.wikipedia.org/wiki/Clang
http://clang.llvm.org
To install clang run the command:
sudo apt-get install clang
Extract the Swift files you downloaded and place them in a folder of your choice.
Next we will add swift to our path. Do that by running the command:
export PATH=/path to your swift folder/usr/bin/:”${PATH}”
Verify whether it works by trying the following 2 commands
which swift
swift –version

Testing the REPL

Next we try the REPL for swift. To invoke this just type the command:
swift
Write something like let myName : String = “Swift Code”
and then hit enter.
Follow it by print(myName) and then hit enter.
You should see the output printed. This is a nice way to test individual Swift statements.

Creating a Single File Project

To create a file based project:
1. Create a folder of your choice, lets call it Hello World:mkdir HelloWorld
2. Create a manifest file for the Package with the command: touch Package.swift
3. The source files for all your projects must be in the Sources folder, let’s create that: mkdir Sources
4. Create a file called main.swift using an editor of your choice. Place the statement print(“Hello, World”) in it.
5. Step out of the sources folder and then run the command to build the project: swift build
6. The executable will be inside a hidden folder called .build/debug
7. The name of the executable will be the same as the name of the project folder.
8. To run it simply type: .build/debug/HelloWorld

Creating a multi file project

Create a folder of your choice, lets call it Hello World:mkdir CentigradeToFahrenheit
Create a manifest file for the Package with the command: touch Package.swift
The source files for all your projects must be in the Sources folder, let’s create that: mkdir Sources
Create a file called converter.swift using an editor of your choice.
Write the following code in it.:
//note the code below is for demonstrating multi file projects & may not necessarily be accurate or correct
func centigrade_to_fahrenheit(temperatureInCentigrade : Float) -> Float
{
return ((temperatureInCentigrade*9.0/5.0)+32.0)
}
func string_to_float(input : String) -> Float
{
var number : Float = 0.0;
var result : Float = 0.0
for charac in input.characters
{
      switch charac
      {
          case “0”:
              number = 0.0;
          case “1”:
              number = 1.0;
          case “2”:
              number = 2.0;
          case “3”:
               number = 3.0;
          case “4”:
              number = 4.0;
          case “5”:
              number = 5.0;
          case “6”:
              number = 6.0;
          case “7”:
              number = 7.0;
          case “8”:
              number = 8.0;
          case “9”:
              number = 9.0;
          default:
              break
  }
  result = (result * 10.0) + number;
  }
  return result
}
Create a second file called main.swift
Write the following code in it:
if Process.arguments.count != 2
{
print(“USAGE: centigradeToFahrenheit 33.4”)
  print(“You are missing an argument”)
}
else
{
  let temperatureInCentigrade = string_to_float(Process.arguments[1])
  print(“\(temperatureInCentigrade) is equal to \(centigrade_to_fahrenheit(temperatureInCentigrade))”)
}
Step out of the sources folder and then run the command to build the project: swift build
The executable will be inside a hidden folder called .build/debug
The name of the executable will be the same as the name of the project folder.
To run it simply type: .build/debug/CentigradeToFahrenheit 100
1. Try with different input values and no input value.
That’s it. You are now ready to start typing code in Swift.

iOS Device guide for App Developers

April 3, 2015October 12, 2017 / Arun Patwardhan / Leave a comment

Developers making iOS Apps regularly come across situations where they need to find out the dimensions of the screen or the icons. This guide should give a better idea about the same.

iphones

	iPhone 5S/SE	iPhone 6/6S/7/8	iPhone 6+/6S+/7+/8+	iPhone X
Display Points	320×568	375×667	414×736	375×812
Pixels	640×1136	750×1334	1242×2208	1125×2436
Display Points to Pixels Ratio	1:2	1:2	1:3	1:3
Pixel Density	326 ppi	326 ppi	401 ppi	458ppi
App Icon Size in pixels	120×120	120×120	180×180	180×180
Aspect Ratio	16:9	16:9	16:9	19.5:9

ipads

	iPad Mini 2,3,4	iPad Air/iPad Air 2/iPad Pro 9.7”	iPad Pro 10.5	iPad Pro 12.9”
Display Points	1024×768	1024×768	1112×834	1366×1024
Pixels	2048×1536	2048×1536	2224×1668	2732×2048
Display Points to Pixels Ratio	1:2	1:2	1:2	1:2
Pixel Density	326 ppi	264ppi	264ppi	264ppi
App Icon Size in pixels	152×152	152×152	167×167	167×167
Aspect Ratio	4:3	4:3	16:9	16:9

Clarifying Swift & Objective-C

December 6, 2014 / Arun Patwardhan / Leave a comment

Apple made a surprising announcement at the recent WWDC held between June 2-6 2014. While everyone was looking forward to the launch of the new OS for both the Mobile as well as Mac platforms, Apple also announced a new programming language for developers. SWIFT.

It was described as Objective-C without C. Over the past few months I have gone over the features of the language & even converted many of the apps into Objective-C. While the initial learning curve is there, it is a fairly easy language to pick up. I will be going over a few interesting features of the language in this article. But what I will also be touching upon is the future & relevance of Objective-C.

Reduction in Lines of code: One of the first things that you will notice once you start programming in Swift is the reduction in the number of lines of code. Swift does away with the long syntax which you find in Objective-C. This makes the code look a lot more compact & less intimidating.

Lets take the example of creating an object in Swift & compare the syntax with that of Objective-C

Objective – C version: NSString *myString = [[NSString alloc] initWithString:@”This is a string”];

Swift version: var myString : String = String(“This is a string”)

As we can see, there is a great deal of simplicity that comes along. Reduction in the number of lines of code is of great importance to software developers. This means more compact code & improves readability. However, this comes at a price. While Objective-C code was more elaborate & did use many more lines of code it was far easier to understand by simply reading through it. In case of Swift the code will have to be complemented with details comments about what it does.

Single File: Another new feature there in Swift is the lack of header files. People coming from a Java background would find this familiar. The declaration of classes & implementation of its functions is done in .swift file now. This removes the necessity of having to import various header files. In case, certain frameworks need to be used all that needs to be done is to import that framework at the top of the file.

import framework

Replace the keyword framework with the name of the framework you wish to include.

Mixed Language Programming: Unlike Objective-C, Swift does not work well with other languages. In fact, Swift only works with Objective-C. So if you have any API’s or pieces of code that you have written in C or C++, you will have to create Objective-C wrapper classes for that C/C++ code so that you can incorporate it into your project.

This means that Objective-C is not going to be deprecated any time soon. Also, it will be equally important to learn Objective-C & can’t be ignored by people.

COMMON QUESTIONS:

– I already know Objective-C should I also learn Swift?
There is no pressing need to immediately learn Swift, though it would be a good idea to learn it anyways. None of the apps you have already made will stop working. However, you may come across code written in Swift or would need to incorporate programs written in Swift, so having knowledge of the same would be a good idea.

– I don’t know Swift or Objective-C which should I learn?
Again, as in the previous question knowing both is a really good idea. If you are confident that you will be making apps using Swift only, then you can learn just that for starters. If you feel that there is a good chance of having to read/modify or write Objective-C code then learning Objective-C before Swift makes more sense.

CONCLUSION: Swift is a very easy to use language & will sit nicely on familiar eyes. A lot of the code that will be written in the coming apps will definitely use Swift. However, this does not mean the end of the road for Objective-C. Nor does it mean that Objective-C will become redundant or obsolete. A developer can choose to use any of the languages to make the app. It will be nice for a new developer to first learn Objective-C & then move on to Swift as it will give the user a more all round understanding of the entire development framework .

iOS Developer Programs Explained

October 31, 2014 / Arun Patwardhan / Leave a comment

Most people who first venture off into App Development focus their efforts on the design of the App & its implementation. However, when the time to publish the app comes along then there are questions as to which developer program he/she should opt for.

Developer programs are online accounts created by Apple for the developer community. Each developer can register their own account from where they can manage the distribution of their apps, the collection of payments for purchase of apps or items within the app. The different programs offered are meant to cater to a specific audience set.

There are 4 different types of developer programs.

Free Membership
iOS Developer Program
Enterprise Developer Program
University Developer Program

Free Membership

This is the simplest program. Anyone can enrol for this & there is no cost involved. To sign up simply go to developer.apple.com & register. This is the perfect program for those looking to start iOS App Development. It gives the member full access to the latest guides, sample codes & information about the different classes & frameworks used for the current publicly available version of iOS.

iOS Developer Program

The iOS Developer Program is the paid version of the program. It costs $99 a year & is meant for those who wish to distribute apps on the App store. Apart from distribution it also gives the user options to test it on their own device. All the benefits from the Free Membership are also made available here.

Enterprise Developer Program

The Enterprise Developer Program is another paid program. It costs $299 a year & is meant for organisations who wish to distribute apps within the organisation to their own employees. The big difference between this program and the regular iOS Developer Program is the fact that in the Enterprise Program you have full control over how your apps are distributed to your employees & have to take care of the hosting as well as distribution aspects. The apps made by an organisation do not go onto the app store & are not verified by Apple.

University Developer Program

The University Developer Program is a free developer program meant for Universities or colleges. This program allows such educational institutes to test the apps made by students as part of the official curriculum. Limited distribution amongst students is also permitted. The program lacks the ability to perform large scale distribution or distribution on the App store.

The table below illustrates the different facilities made available to different account holders.

For more information related to the D-U-N-S Number:

Things to think about while being an App Developer

September 3, 2014 / Arun Patwardhan / Leave a comment

While we all are interested & excited about making new apps & publishing them to the app store, here is something else to think about & keep in mind.

An interesting article on NDTV.

Arun Patwardhan's Blog

Computing Tech Blog

Programming

Apple ID & iCloud in Enterprise

Collection Type, Sequence Type & Indexable Type

What are the Collection Type & Sequence Type Protocols?

Why do we need such Protocols?

How do we use these protocols for our own data structures?

Implementing the Indexable Protocol methods

Implementing the Sequence Type Protocol

Implementing the Collection Type Protocol

CollectionType Video

Conclusion

Creating Frameworks for iOS/OS X App Development

Creating Swift Frameworks

Creating Mixed Frameworks (Swift & Objective-C)

Loading your App on your iPhone

Writing Swift Programs on Linux

Swift Programming on Linux

Setup & Configuration

Testing the REPL

Creating a Single File Project

Creating a multi file project

iOS Device guide for App Developers

Clarifying Swift & Objective-C

iOS Developer Programs Explained

Free Membership

iOS Developer Program

Enterprise Developer Program

University Developer Program

Things to think about while being an App Developer

Share this:

Share this:

What are the Collection Type & Sequence Type Protocols?

Why do we need such Protocols?

How do we use these protocols for our own data structures?

Implementing the Indexable Protocol methods

Implementing the Sequence Type Protocol

Implementing the Collection Type Protocol

CollectionType Video

Conclusion

Creating Swift Frameworks

Creating Mixed Frameworks (Swift & Objective-C)

Share this:

Swift Programming on Linux

Setup & Configuration

Testing the REPL

Creating a Single File Project

Creating a multi file project

Share this:

Share this:

Share this:

Free Membership

iOS Developer Program

Enterprise Developer Program

University Developer Program

Share this:

Share this: