Category: iOS

Your First Swift 4 & iOS 12 App Online Course – Day 4

July 25th, 2018
Day 4

Getting the value of slider and printing it in the Alert Box
- Initialize a global variable currentValue of type Int and assign it the default value of 50.
- Inside the sliderMoved method assign the slider.value.rounded() to the currentValue. Remember to cast slider.value.rounded() as we only need the integer values and not the decimal ones.
- Copy the message inside the print statement in the sliderMoved method. Create another variable message inside showAlert() method of type string and assign the message to it. Replace slider.value in the message to currentValue.
- Replace the old message in UIAlertController with message variable. Now run the app and change the slider position. Click Hit Me. We see the current value in the alert message.
Current Value of slider in Alert Message

Connecting Outlets
- Right now we can access the slider only in one method. And we want to access its current value in another method or globally. This creates a need to have an instance variable of type UISlider. We can do that by using @IBOutlet like this
```
@IBOutlet weak var slider: UISlider!
```
- Next open Main.storyboard -> control + click on slider -> click on New Referencing outlets and connect it to ViewController which pops up two options -> select slider
- Now copy the code in sliderMoved to viewDidLoad. This makes sure that by default the current value of the slider is taken if the user hits the button “Hit Me!” without changing the slider value.
- By default the slider’s value id 50. So now when we run the app and click on “Hit Me” , 50 is shown.
Connecting outlets
Your First Swift 4 & iOS 12 App Online Course – Day 3

July 24th, 2018
Day 3

How does the app work?
- An app is composed of objects that can send messages to each other.
- Most of the objects are provided by the iOS, example UIButton, UIAlertController, etc.
- The remaining objects are created by us, for example, ViewController.
- In iOS, apps are event-driven.
What happens when we click “Hit Me” Button

Portrait vs Landscape
- In iOS, screen dimensions are measured in points. In older devices, 1 point = 1 pixel. Right now the plus devices had 1 point = 3 pixels.
- To change the orientation of our app to landscape – Click on BullsEye in project navigator -> Select BullsEye in Target part -> In the general area, scroll down to the Device Orientation and uncheck portrait. Now run the app, the app stays in landscape mode even when we rotate the device.
Adding all UI Elements

Next, I added all the UI elements of the app on the screen using the objects of UIKit.

Adding all the UI Elements
Your First Swift 4 & iOS 12 App Online Course – Day 2

July 20th, 2018
Day 2

Adding buttons and actions

How to add a button to the app?

Open Main.Storyboard -> Utilities Panel -> Object Library -> Drag button to the controller

ViewController

A view controller manages a single screen or a portion of a screen. In this app, we have only one screen so only one view controller. View Controller has two parts:
- Main.Storyboard where we add all the UI components to the view
- ViewController.swift where we write code to handle those components
Adding action to the button

Open ViewController.Swift and add a function showAlert() with @IBAction prefix currently printing “Hello World!”. Then go back to Main.storyboard and click on the ViewController in the navigation area. Click on the button “Click Me”. Hold the button down and take the cursor to the ViewController. A drop-down will show with the method showAlert(), select that method. Now the button is connected to the action. When we run the app and click on the button “Hello World” is printed in the console.

Printing on the console

Display Popup on clicking the button

Right now I just added the following code instead on print statement in the showAlert() method. We are going to learn what each statement means in the coming lessons.
```
let alert = UIAlertController(title: "Hello World!", message: "This is my first app", preferredStyle: .alert)
        
        let action = UIAlertAction(title: "Awesome", style: .default, handler: nil)
        
        alert.addAction(action)
        
        present(alert, animated: true, completion: nil)
```
Now when I run the app and click on the button a pop up appears on the screen.

Hello World Popup

This is the screenshot of the assignment about adding another button –

Knock Knock Popup
Your First Swift 4 & iOS 12 App Online Course – Day 1

July 20th, 2018
Day 1

Bull’s Eye App Programming To-Do List

Bull’s Eye app gives us a random value. And we need to take the slider to approximate value and click on the button to send our input. Then a score is calculated based on how close our guess was.

The second video focuses on making a list of things we will need to do to make our functioning Bull’s Eye App. Here’s my To-Do List for this app –
- Slider for getting the guess from the user
- Button for submitting the user’s guess
- Pop up to show the score after submitting the user’s guess
- Text showing the random number selected by the app
- Text showing the rounds and scores
- Reset button to reset score and round to zero and start a new game
- Info button to display the rules of the game.
Learning Swift – Enumerations

May 25th, 2017
In this post, we will implement enumerations in swift.

What’s an enumeration?

According to the official documentation of Swift:

“An enumeration defines a common type for a group of related values.”

In simple words, an enumeration is a user defined data type which stores a set of values. Examples of such sets can be days of the week, days of the month, etc.

How to define enums in swift?

In swift, the enumeration is defined using the following syntax:
```
enum EnumerationName {
    // cases
}
```
Here enum is the keyword, and enumerationName is the name for the enumeration. The following example code creates an enum which stores days of the week.
```
enum DaysOfWeek{
    case monday 
    case tuesday 
    case wednesday
    case thursday
    case friday 
    case saturday 
    case sunday 
}
```
Once the enums are created, we define a variable of this enum type as the following code shows:
```
var today = DaysOfWeek.tuesday
```
When we assign DaysOfWeek.tuesday to variable today, type of today becomes an enumeration. Switch statements which we studied in this post, can be used to match individual enumeration values.
```
today = .thursday
switch today{
case .monday, .tuesday, .wednesday, .thursday, .friday:
    print("Working Days")
case .saturday, .sunday:
    print("Holidays")
}
```
After first initialization, we can assign values to the enum variables only using “.casename”, as done in the above example through “.thursday“.

The output of above program is “Working Days” as “.thursday” falls into the first switch case.

Raw Values

In swift, enumerations can be initialized with raw values. In this example, we assign “Int” to the enumeration, making sure all the cases in this enumeration will have an integer raw value by default on initialization.
```
enum DaysOfWeek: Int{
    case monday
    case tuesday
    case wednesday
    case thursday
    case friday
    case saturday
    case sunday
}

var today = DaysOfWeek.thursday

print("\(today.rawValue)")
```
When we fetch the raw value using “today.rawValue“, we get an output of three. Because by default, if we don’t assign values to all the cases, swift assigns “0” to the first case and the remaining cases are incremented by “1“, i.e. monday is 0, tuesday is 1, wednesday is 2, thursday is 3 and so on.

Similarly, if we assign monday with 61, the output of thursday will be 64. Here, Swift assigns 61 to monday and all other values are incremented by 1.

Last, we assign separate and different values to all the enumeration cases.

The type of raw values in the enumerations could be float or double or string also.

Associated Values

The raw values are of the same type, so all cases store values of the same type. But in swift, enumeration cases can also store values of different data types. These values associated with each enumeration case are called associated values. For example the below enumeration:
```
enum EmployeeRecord{
    case name(String, String)
    case age(Int)
    case weight(Float)
}
```
Here we have an enumeration EmployeeRecord with three cases(values): name which can store two string values, age which can store one integer value and weight which can store a float value.

The next question that arises is how to initialize a variable of this enumeration type?
```
var employee = EmployeeRecord.name("John", "Doe")
```
Consider the name case which stores two strings. While initializing the variable employee with the enumeration EmployeeRecord, we fill in the values of the associated strings with “John” and “Doe“.
```
switch employee {
case .name(let first, let last):
    print("First Name: \(first)")
    print("Last Name: \(last)")
case .age(var age):
    print("Age: \(age)")
case .weight(let weight):
    print("Weight: \(weight)")
default:
    print("Invalid value")
}
```
Similarly, when we check these cases in the switch, we have to add the associated values as constants or variables to be able to use them. For the name, there are “let first” and “let second“.

With this, we complete enumeration in swift. If any questions, leave them in comments below. You can find the code for this post here.
Learning Swift: Functions [Argument labels]

March 31st, 2017
From last three posts, we have been working on functions in swift. So far we learned
In this post, we will learn about function argument labels.

Recall this syntax we discussed in the first post on functions.
```
func functionName (paramName: paramType  ) -> returnType{
 
 //block of code
 return object
 
 }
```
Here we have not used argument labels. First, let’s add the argument labels to this syntax.
```
func functionName (argumentLabel paramName: paramType  ) -> returnType{
 
 //block of code
 return object
 
 }
```
What is this argument label? Why do we use it? How’s it different from the parameter names.

Let’s find out.

Remember this factorial function from last few posts?
```
func factorial (number: Int) -> Int{
    var factorial = 1
    var temp = number
    while(temp>1){
        factorial =  factorial * temp
        temp = temp - 1
    }
    return factorial
}
```
We will add an argument label “of” to the parameter name number.
```
func factorial (of number: Int) -> Int{
    var factorial = 1
    var temp = number
    while(temp>1){
        factorial =  factorial * temp
        temp = temp - 1
    }
    return factorial
}
```
Immediately we have an error here, where we are calling this function factorial.

The error says “Incorrect argument label in call(have number:”, expected “of:”

When we replace the number with of, the error vanishes.

This “of’ here is an argument label. The argument labels are like external parameter name. These are used when calling a function. The other parameter name “number” is the internal parameter name and is used inside the function.

Earlier when there was no “of” ie argument label, the parameter name became the default argument label and we used “number:” instead of “of:”.

So when we explicitly write an argument label we have to use that in the function call. Else we use the parameter name as argument label.

The use of argument label makes a function more expressive, sort of like a sentence. Like this factorial function call above, now, can be read as the factorial of 7.

With this we complete functions. If you have any questions leave them in the comment section below.