Problem: Decode objects from an array with different objects

struct Car: Decodable {
    let manufacturer: String
    let model: String
}

struct Person: Decodable {
    let name: String
    let lastName: String
}

let json = """
{
    "information_array": [
        {
            "manufacturer": "Audi",
            "model": "A3"
        },
        {
            "name": "John",
            "lastName": "Doe"
        },
        {
            "weatherType": "windy",
            "degrees": "10",
            "degreesType": "celcius"
        }
    ]
}
"""

Solution

struct OptionalDecodable<T: Decodable>: Decodable {
    let base: T?

    init(from decoder: Decoder) throws {
        let container = try decoder.singleValueContainer()
        self.base = try? container.decode(T.self)
    }
}

extension Decoder {
    func decodeObject<T: Decodable>() throws -> T {
        let container = try singleValueContainer()
        guard let object = try container.decode([OptionalDecodable<T>].self).compactMap({ $0.base }).first else {
            let context = DecodingError.Context(codingPath: container.codingPath,
                                                debugDescription: "Value for type \(type(of: T.self)) not found")
            throw DecodingError.valueNotFound(T.self, context)
        }
        return object
    }
    
    func decodeObjects<T: Decodable>() throws -> [T] {
        let container = try singleValueContainer()
        let objects = try container.decode([OptionalDecodable<T>].self).compactMap({ $0.base })
        return objects
    }
}

struct ContainerObject: Decodable {
    let car: Car
    let person: Person

    enum CodingKeys: String, CodingKey {
        case infoArray = "information_array"
    }

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        let arrayDecoder = try container.superDecoder(forKey: .infoArray)
        self.car = try arrayDecoder.decodeObject()
        self.person = try arrayDecoder.decodeObject()
    }
}

I just have watched the What’s new in Swift from WWDC 2018 and I thought it is a great motivation to write a blog post about this talk and summarize what I learned.

And here are some new Swift 4.2 features that I really liked.

Hope you will enjoy! 🤓

SE-0194 Derived Collection of Enum Cases

In case we need to print all available enum values, we had to create some helper variable that includes all enum cases. For example, a static array called allCases. A big drawback in that approach is that we need to remember to update the allCases array every time when we modify enum cases.

Swift 4.1 approach:

enum CarType {
    case sedan
    case crossover
    case hothatch
    case muscle
    case miniVan

    static var allCases : = [.sedan, .crossover, .hothatch, .muscle, miniVan]
}

in Swift 4.2 we can work with CaseIterable protocol which does all the work for us! Please take a look at the below example:

// CaseIterable protocol gave us a `allCases` variable, which is an array of all cases in the Enum.

enum CarType : CaseIterable {
    case sedan
    case crossover
    case hothatch
    case muscle
    case miniVan

    //there is no need to add `allCases` variable. `CaseIterable` protocol do the job!
}

for type in CarType.allCases {
    print(type)
}

Conditional Conformance

let arrayOfArrays = [[1,2],[3,4],[5,6]]

arrayOfArrays.contains([1,2]) // return false in Swift 4.1

arrayOfArrays.contains([1,2]) // now it returns True because of fact that the elements in the array conforms to Equatable protocol

It will work with Optional, Dictionary types as well. The conditional conformance works in the same way with Hashable, Encodable and Decodable protocols. So for example, because Int is Hashable, which means in that case that Int? is Hashable too, and as a result the [Int?] is Hashable as well!

let s: Set<[Int?]> = [[1, nil, 2], [3, 4], [5, nil, nil]]
s.contains([1,nil,2]) // returns true

Bool toggle

var isTheWeatherNice : Bool = true
print(isTheWeatherNice) // prints true
//now it's starts to rain
isTheWeatherNice.toggle() // it will change the bool value.
print(isTheWeatherNice) // prints false

Small, but in my opinion - very nice feature. I meet that extension for the first time while reading that objc.io blog posts.

Now it’s built into Swift 4.2. 🎉

Hashable protocol

protocol Hashable {
    func hash(into hasher: inout Hasher)
}

In Swift 4.2 we don’t have to provide custom algorithms for hashValue. Now swift handles a hash method quality with run performance. Important thing is that the hashValue use the random per-process seed which is created at the every app starts.

struct City: Hashable {
    let name : String
    let state : String
    let population : String
}
extension City : Hashable {
    func hash(into hasher: inout Hasher) {
        name.hash(into: &hasher)
        state.hash(into: &hasher)
    }
}
let warsaw = City(name : "Warsaw", state: "Mazowieckie")
print(warsaw.hashValue) // will print hash value, using the Swift algorithms from hash function.

⚠️ In that approach, you should change the code that relates to the hashValue as a constant. In every application run, the hash value will be different. ⚠️

SE-0202 Random Unification

Swift 4.1 approach:

let randomIntFrom1to10 = 1 + (arc4random() % 10) // return random number is the 1...10

But in Swift 4.2 there is no need to use arc4random() anymore. 🎉

let randomIntFrom0To20 = Int.random(in: 0 ..< 20)
let randomFloat = Float.random(in: 0 ..< 1)

Super cool thing is that we can get a random value from Collection types like Array or Dictionary.

let names = ["John", "Paul", "Peter", "Tim"]
names.randomElement()! 

let playerNumberToName : [Int: String] = [9: "Lewandowski", 7: "Ronaldo"]
playerNumberToName.randomElement()! 

As you might notice, the randomElement function returns an Optional, because of the case where we call this function on the empty collection.

let emptyCollection : [String] = []
emptyCollection.randomElement() // retuns nil

Another new function are shuffle or shuffled functions.

let names = ["John", "Paul", "Peter", "Tim"]
let shuffledNames = names.shuffled() // returns an array of names in shuffled order.

Conclusion

It would be great to use those features in stable versions. My impressions from Xcode 10(beta) and Swift 4.2 was pretty amazing. I highly recommend you to watch What’s new in Swift talk from WWDC 2018

Below you can find a link to a GitHub gist with all features described above.

https://gist.github.com/kamwysoc/e9322c84fd4fa051cb747ec08193dc0d

Source

• https://developer.apple.com/videos/play/wwdc2018/401/

• https://swift.org/documentation/

Ok… but what the pedometer is? Here you have a wikipedia definition:

A pedometer is a device, usually portable and electronic or electromechanical, that counts each step a person takes by detecting the motion of the person’s hands or hips.

and YES, you can create your own pedometer using iOS framework called CoreMotion.

CoreMotion is a well-known iOS framework. As we could read in docs it processes accelerometer, gyroscope, pedometer environment-related events. In this post I want to focus on the pedometer events and how to handle them.

Overview

CMPedometer

In order to use CoreMotion pedometer, we need to take a closer look at CMPedometer class. It allows the user to retrieve some information about steps taken in the past, for example: How many steps I have done for last 3 days? Another usage of CMPedometer class is to get the live updates about steps taken already.

open func queryPedometerData(from start: Date, to end: Date, withHandler handler: @escaping CoreMotion.CMPedometerHandler)

open func startUpdates(from start: Date, withHandler handler: @escaping CoreMotion.CMPedometerHandler)

CMPedometerData

Another class that should catch our attention is CMPedometerData. This class represents data that will be sent with every update in the above functions. It contains a lot of useful information like:

• numberOfSteps: NSNumber?
• distance: NSNumber?
• currentPace: NSNumber?
• floorsAscended: NSNumber?
• floorsDescended: NSNumber?

CMMotionActivityManager

If we want to start counting steps, it will be good to know about what kind of activity our user is doing at the moment. Here with some help comes the CMMotionActivityManager class. Using th e instance of this class we are able to get updates about the user activity type. In order to do this we should call:

open func startActivityUpdates(to queue: OperationQueue, withHandler handler: @escaping CoreMotion.CMMotionActivityHandler)

and the result of that is getting updates with CMMotionActivity which represents data for a single motion event update. This data is a pack of bool values:

• stationary: Bool
• walking: Bool
• running: Bool
• automotive: Bool
• cycling: Bool
• unknown: Bool

Code step by step…

1. Add NSMotionUsageDescription to your info.plist

As we can read in Apple docs

Important An iOS app linked on or after iOS 10.0 must include usage description keys in its Info.plist file for the types of data it needs. Failure to include these keys will cause the app to crash. To >access motion and fitness data specifically, it must include NSMotionUsageDescription.

So add to your info.plist NSMotionUsageDescription key modifying plain file:

<key>NSMotionUsageDescription</key>
<string>In order to count steps I need an access to your pedometer</string>

or adding new key via Xcode

2. Create an CMMotionActivityManager and CMPedometer instances

private let activityManager = CMMotionActivityManager()
private let pedometer = CMPedometer()

3. Create a method for tracking activity events

private func startTrackingActivityType() {
  activityManager.startActivityUpdates(to: OperationQueue.main) {
      [weak self] (activity: CMMotionActivity?) in

      guard let activity = activity else { return }
      DispatchQueue.main.async {
          if activity.walking {
              self?.activityTypeLabel.text = "Walking"
          } else if activity.stationary {
              self?.activityTypeLabel.text = "Stationary"
          } else if activity.running {
              self?.activityTypeLabel.text = "Running"
          } else if activity.automotive {
              self?.activityTypeLabel.text = "Automotive"
          }
      }
  }
}

4. Create a method for steps counting updates

private func startCountingSteps() {
  pedometer.startUpdates(from: Date()) {
      [weak self] pedometerData, error in
      guard let pedometerData = pedometerData, error == nil else { return }

      DispatchQueue.main.async {
          self?.stepsCountLabel.text = pedometerData.numberOfSteps.stringValue
      }
  }
}

5. Start getting updates

private func startUpdating() {
  if CMMotionActivityManager.isActivityAvailable() {
      startTrackingActivityType()
  }

  if CMPedometer.isStepCountingAvailable() {
      startCountingSteps()
  }
}

Conclusion

CoreMotion is a powerful framework and besides a pedometer it allows you to work with a plenty useful data from accelerometer and gyroscope as well You can find an example project at Github repository

Hope you like the post, feel free to share.

This post was primarly posted on my company blog

About the pattern

Facade pattern is one of the Structural Patterns. The main aim of it is to hide the complexity of a system, class or logic and provide all functionalities behind a simple interface. Commonly, Facade is implemented in a way that one class is related to other classes which represents a system logic. Please take a look at the diagram:

As you can see, there is one class called Facade which separates the logic from LogicA, LogicB, LogicC classes. As a result our client only call the Facade class in order to execute some methods that are implemented in other classes.

Implementation

Let’s imagine a simple scenario. You have already created a great app called Super-Photo. One of the core features of your app is saving/converting assets/posts with JPEG or PNG extension. In order to do this you want to save UIImage representation in two ways. One is saving it as a PNG type, the second is saving it as a JPEG file type.

Fistly, in order to handle our image types and possible errors in our code - it will be nice to have two enums that will make our code cleaner and more readable.

enum ImageSaverError: Error {
    case couldNotCreateDestinationPath
    case couldNotCreateJPEGDataFromImage
    case couldNotCreatePNGDataFromImage
    case couldNotSaveImageInDestinationPath
}

enum ImageType {
    case png
    case jpeg(compressionQuality: CGFloat)
}

On the next step you will need to create a class that will handle a data providing for each photo extension:

class ImageDataProvider {
    func data(from image: UIImage, type: ImageType) throws -> Data {
        switch type {
        case .jpeg(let compressionQuality):
            return try jpegData(from: image, compressionQuality: compressionQuality)
        case .png:
            return try pngData(from: image)
        }
    }

    private func pngData(from image: UIImage) throws -> Data {
        guard let imageData = UIImagePNGRepresentation(image) else { throw ImageSaverError.couldNotCreateJPEGDataFromImage }
        return imageData
    }

    private func jpegData(from image: UIImage, compressionQuality: CGFloat) throws -> Data {
        guard let imageData = UIImageJPEGRepresentation(image, compressionQuality) else { throw ImageSaverError.couldNotCreatePNGDataFromImage }
        return imageData
    }
}

As you’ve noticed, our ImageDataProvider takes image and type parameters and creates the image data with proper extension JPEG or PNG.

The last step is to create class which is needed to save UIImage. So let’s name it a PathProvider.

class PathProvider {
    func createDestinationPath(fileName: String) throws -> URL {
        guard let path = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first else {
            throw ImageSaverError.couldNotCreateDestinationPath
        }
        let destinationPath = path.appendingPathComponent("\(fileName)")
        return destinationPath
    }
}

Ok, so at the moment we have two classes with some logic inside. Now it’s time to create a facade for it!

Create a class called ImageSaverFacade :

class ImageSaverFacade {
    private let pathProvider = PathProvider()
    private let dataProvider = ImageDataProvider()

    func save(image: UIImage, type: ImageType, fileName: String, overwrite: Bool) throws {
        let destinationURL = try pathProvider.createDestinationPath(fileName: fileName)
        let imageData = try dataProvider.data(from: image, type: type)
        let writingOptions: Data.WritingOptions = overwrite ? (.atomic) : (.withoutOverwriting)
        try imageData.write(to: destinationURL, options: writingOptions)
    }
}

Our ImageSaverFacade class has two private objects of PathProvider and ImageDataProvider class. Because the client doesn’t need to know anything about logic inside, the only thing which ImageSaverFacade exposes to a public is one method:

• func save(image: UIImage, type: ImageType, fileName: String, overwrite: Bool) throws

This method is the only thing that our client should care about.

Now let’s move on to the facade usage part:

let imageSaver = ImageSaverFacade()
let image = UIImage(named: "my_image")!
do {
    try imageSaver.save(image: image, type: .png, fileName: "my_file_name", overwrite: true)
} catch  {
    //handle Error
}
// or
do {
    try imageSaver.save(image: image, type: .jpeg(compressionQuality: 1.0), fileName: "my_file_name", overwrite: false)
} catch  {
    //handle Error
}

Conclusion

Please notice that our facade covers logic associated with Data providing and creating a valid URL for file destination. And because of that, it is super easy to save UIImage as PNG or JPEG using our ImageSaverFacade. Only thing to do is to pass the correct parameters to facade method.

Facade design pattern can be used in many cases. Facade creates for you a simple gateway to a complicated system. By using it you will definitely make your code simpler to understand and read.

This post was primarly posted on my company blog

Motivation

I have configured a TeamCity many times and for many projects. There are many advantages of using Continuous Integration system in your project development process. Also, there is a lot of alternatives to TeamCity like CircleCI, TravisCI and many more. But in this post I want to share with you TeamCity experience that I have gained at Bright Inventions.

Every project that we start - we start from configuring Continuous Integration stuff and in our case we use TeamCity to handle that.

This post will be more like a tutorial that will guide you through all basic and most important steps in iOS project configuration. Also, I assume that you have already downloaded, and hosted your TeamCity service.

Hope you will like it!

Step 1: Create a root project

Firstly, you need to go to a page where your TeamCity is hosted. After loging-in, go to the Administration Page, click Projects tab in Project-related Settings section and click Create project

after that you should a see configuration screen for Version Control that is used in your project.

I prefer a way in which I will configure everything manually, but of course you can go with predefined sections like : From GitHub. From Bitbucket Cloud etc. All you need to do in this step is to provide a Name of your project and then tap Create

Step 2: Add VCS root

Of course, in order to build our project we need to provide sources to build. Our TeamCity service should be able to fetch changes from the repository. If you’re using a GitHub, BitBucket or platforms similar to these, you have two ways:

• Give credentials to account which has an access to the repository

or

• Generate a SSH key and use it to authorize TeamCity in GitHub/Bitbucket

In this post I will show you how to configure it with uploading SSH key.

Generate new SSH key

If you haven’t heard about generating SSH keys, or you don’t know what SSH keys really are, check this link

To generate new SSH keys you can use a terminal command:

ssh-keygen -t rsa

next, provide a name for new key, and an optional passphrase, then in the directory in which you run ssh-keygen -t rsa command you should see two files. One is a public key with .pub extension, and the second - private one. The public one will be used in your repository on github/bitbucket. The private key will be used in TeamCity service.

Use generated key in TeamCity

Go to an already created project, settings page and click VCS SSH Keys tab.

Click on Upload SSH Key. After that you should see a pop-up window which allows you to upload the previously created SSH Key. Please keep in mind that you should upload a private part of your key, without pub extension. If you choose correctly, click save and you should see a screen like this:

As you can see in Usage tab, the key is not used in the configuration yet. In order to use it - you have to go through the next steps…

Configure VCS root

Go to the already created project’s settings page. As you can notice in SSH Keys tab - appeared number ‘1’ - it means that we have one SSH key uploaded which is ready to use.

Click on VCS Roots tab, and then Create VC Root.

In our case, in Type of VCS select Git

In VCS root name provide a name which will be:

A unique name to distinguish this VCS root from other roots.

Next, in Fetch URL paste a link to your repository. Please remember to paste here a SSH link type e.g git@github.com:yournickname/yourrepositoryname.git

Next, the most important thing, in Authentication method select Uploaded Key and choose a previously uploaded private ssh key for you repository.

Almost done. Now go to the end of the page and click Test Connection.

If you see screen like this:

it means that our public part of generated SSH key is not used in the repository, and that’s why you get Auth failed error. So, all you need to do is to add a public part of SSH Key in Access keys or Deploy keys in your repository.

Here you have links for Bitbucket and GitHub instructions how to do that:

BitBucket - Use access keys

GitHub - Deploy keys

If you have successfully uploaded public part of SSH Key, click Test Connection again, and I hope you will be able to see Connection successful alert. It means that TeamCity has an access to read your repository.

Step 3: Create build configuration

Ok, our VCS is configured. Now it’s time to create build configuration in TeamCity project. Build configuration is a kind of lane which specifies what type of build you provide in this lane. It could be a lane for: compile your project and run unit tests or just compile a project or compile a project then create .ipa files and send it to iTunesConnect or even a separate lane for running UI tests.

Go to General Settings in you already created project and click Create build configuration

In next screen, once again, choose Manually option and name your new build configuration. In our case let’s name it [Develop] Build & Test. The name is meaningful and means that our lane will build iOS project with develop configuration - Develop and also, provides an short information what this lane will do - Build & Test which means that we compile our project and run unit tests.

Click Create and after that you should see:

Here, select a previously created VCS Root and click Attach.

All done, our build configuration is connected with VCS.

Step 4: Configure build steps for configuration

Now it’s time to define steps in our build configuration. What are the build steps? They are a sequence of instructions which TeamCity will run on our agent machine. Put it simply, it could be something like:

1. Fetch new changes from repo
2. Install dependencies (cocoapods, bundle install and stuff like that)
3. Compile project using script (xcodebuild, fastlane)

Please remember that build steps depend on how you configure your iOS project. In my example I used Fastlane, and Bundler to manage versions of gems installed in iOS project.

In order to create build steps go to Build configuration Settings and tap Build Steps

Click on Add build step, and on the next screen select a Command line runner type. In Step name name your build step(in my case it will be Install Dependencies). In Custom script type a script that will be executed in this build step. Again, in my case it will be

bundle install

click Save and your first step is ready!

I also added another command line build step called Build and tests which will run command:

bundle exec fastlane build_and_test

build_and_test is the name of the lane in Fastfile. If you’re not familiar with Fastlane, please have a look at this. It’s a great tool Fastlane

So, now we have all build steps created.

Step 5: Triggers

Have you ever wondered how TeamCity knows when to fetch new changes from the repository and build it? Triggers is an answer.

I prefer to use two types of triggers. One of these is called VCS Trigger which means that TeamCity checks automatically if something has changed in your repository and if this is a case then it will start a build configuration which contains that type of trigger. VCS Trigger is used in the configurations like Compile & Test for example. Because we want to compile and run tests after every push to the repository.

The latter trigger, is called Schedule Trigger. It is a simple trigger which could say : Run this configuration at every Monday at 7:00AM

Go to Triggers section in Build Configuration main page. Click Add new trigger and select VCS Trigger and simply click Save

VCS Trigger configured successfully, easy right?.

Next, do the same, Add new trigger -> Schedule Trigger and choose options that will meet your requirements (in my case it is a daily trigger at 04:00 AM) and click Save.

All triggers created!

Step 6: Add Build Features

Build features are cool stuff. For example, while using build features you can create a condition that checks which version of Ruby is installed, or you can create a condition that will check if there is some available space on your machine. It is super useful if you want to produce .ipa files and you know that you need at least 100MB free space. In this post I will show you how to configure two build features - one is XML report processing and the second one Ruby environment configurator.

• XML report processing

Go to Build Features section in the build configuration main page, and click Add build feature. Choose XML report processing, select Ant JUnit and in Monitoring rules paste a path for report.junit file which is generated by Fastlane after scan action. In report.junit you can find out how many tests have been run, how many tests failed, how many tests have been completed successfully.

• Ruby environment configurator

This time select Ruby environment configurator in Add build feature window. In gemset define which ruby version you need to have. In my case it was ruby-2.3.3.

This feature will check if this version of ruby is available on the agent machine and if not it will not start build configuration. It is an optional step, but sometimes it is incredibly useful - especially, if you use multiple ruby versions or someone else could change a global version of ruby on agent machine.

Step 7: Parameters

There are 3 types of parameters for build configuration or even root project.

• Configuration Parameter

• System properties(system.)

• Environment Variables(env.)

In this post I will focus on Environment variables. That type of variables are created after build start(is ready?) and they can be accessed via Command line with $ prefix. One example of Environment variable could be an XCode path. In order to compile our project we need XCode path which will be used by Fastlane tool. So in Fastfile I add line:

xcode_select ENV["XCODE_PATH"]

which means - select XCode from a path that you can find under ENV["XCODE_PATH"] variable.

On the build configuration main page select Parameters and click Add new parameter. In Name type env.XCODE_PATH, TeamCity should automatically change Kind to Environment variable and in the value provide a path to XCode.app on your agent machine.

By using parameters you can pass many useful values such as your build number or the name of scheme that should be built and many more. I encourage you to check it out :)

Step 8: Failure Conditions

Failure conditions should be used in a situation when you want to force your build to fail. A great example of that is a timeout. Let’s imagine that something bad happens on your agent machine and your build is hanging over 2 hours, when normally it takes a few minutes. Failure conditions come with help! You can set up here that if build lasts above n minutes then it should fail.

In the main page of build configuration go to Failure Conditions and on line if runs longer than specified limit in minutes put a value(in minutes). In my case it will be 60 minutes.

Step 9: Agent machine

As you have probably noticed, I often mention agent machine. Agent, in iOS case, it is a computer(Macbook, MacMini, etc) with macOS system. Agent is connected via script to your TeamCity page. TeamCity can communicate with agent in order to use it to execute build steps from build configuration. The important thing is that your agent should be turned ON all the time to provide continuous integration.

Ok, but how to configure an Agent?

Go to Agents tab in TeamCity page. You can find it at the top.

In a newly created TeamCity there are no available agents yet. Let’s click on Install Build Agents.

I prefer a way of installing it via Zip file distribution. After you click on that your web browser will download all the files that are necessary to run agent.

Great instruction how to configure Mac agent you can find in TeamCity docs here. Below are the steps from this documentation:

1.Make sure a JDK (JRE) 1.8 (versions 1.6-1.8 are supported, but 1.8 is recommended) is properly installed on the agent computer.

2.On the agent computer, make sure the JRE_HOME or JAVA_HOME environment variables are set (pointing to the installed JRE or JDK directory respectively).

3.In the TeamCity Web UI, navigate to the Agents tab.

4.Click the Install Build Agents link and select Zip file distribution to download the archive.

5.Unzip the downloaded file into the desired directory.

6.Navigate to the <installation path>\conf directory, locate the file called buildAgent.dist.properties and rename it to buildAgent.properties.

7.Edit the buildAgent.properties file to specify the TeamCity server URL and the name of the agent. Please refer to Build Agent Configuration section for details on agent configuration.

8.Under Linux, you may need to give execution permissions to the bin/agent.sh shell script.

After these steps you can start the agent via command:

pathToDownloadedUnzippedBuildAgentFiles\bin\agent.sh start

The next thing to do is to go to TeamCity page on Agents tab again. You will have to wait a bit, and after some time you should see one agent available under Unauthorized tab. Only thing to do is to Authorize agent. After this you will see you agent under Connected tab.

Step 10: Setup Agent requirements for build configuration

The last thing…You need to specify now which agent should build your configuration. If your TeamCity contains a projects for iOS and Android, probably it will have two agents - one for Android, and the second one for iOS. Of course, we don’t want to start our iOS build configuration on computer for Android project which probably will not have XCode, or even macOS. So, in order to provide a proper agent for you project you need to use Agent requirements for build configuration.

In the main page of build configuration go to Agent requirements tab and then:

• Select Add new requirement
• In Parameter Name type teamcity.agent.jvm.os.name
• In Condition select equals
• In Value select Mac OS X
• Save

The requirement which we have already created means that agent OS name should be Mac OS X because we configure a project for iOS.

Step 11: Ready for build - RUN! 🎉

All configured, you’re ready to start your build via TeamCity. Go to main TeamCity page and tap Run on your freshly created build configuration.

After that, you will be able to see build progress:

If you want to see the progress in a current build, just click on Running label and go to the Build log section. It is very useful if some errors occurred while compiling.

Finally, after all build steps you will be able to see:

As you can see, XML Processing Report Build Feature provides a cool output about unit tests: Test passed: 24.

Step 12: Artifacts!

Last optional step. I can imagine that you can find many cases that you want to compile a project, create a .ipa file and send it to the client. Artifacts are made for it. To do this: Go to build configuration settings by clicking Edit Settings:

in General Settings under Artifacts paths type a path to .ipa file which will be generated by your build scripts. I recommend using Fastlane again. Fastlane action called gym will build your project and create .ipa file in the output directory. More about gym you can read here.

If you do this, after next build you will be able to download .ipa via Artifacts page on TeamCity.

Conclusion

TeamCity is a great platform to provide Continuous Integration in your project. In combination with Fastlane it saves you many hours of manual deploying, testing and compiling.

Also, if you will configure Artifacts in build configuration, you can easily send a link to your TeamCity page to your client, and give him instructions how to download the .ipa with a few clicks. So, you don’t have to worry about sending .ipa files every time you create a new file version.

Hope you like the post. Feel free to share :)

This post was primarly posted on my company blog

Professional development process consists of many puzzles. Some of these puzzles can be: unit testing, choosing good architecture, clean code, continuous integration and many more. In this post I will focus on one of these puzzles - Continuous Integration(CI). An integral part of CI in iOS Development process is a great tool called Fastlane. Fastlane is a powerful engine which handles a number of tasks like: dealing with code signing, creating .ipa files, generating screenshots to AppStore and much more. One of the cool feature of Fastlane is the Slack integration - and this is what I wanted to write about.

💪 Motivation 💪

At Bright Inventions, I’m working on a few projects. Every project that we start, we start with a few basic steps: create a new repository, basic application setup and most important… Continuous Integration path. On iOS applications, it starts with installing the Fastlane, creating some lanes in Fastfile, then pushing changes to our new repository. Next step is configuring a new TeamCity(a service that we are using for CI) with a new agent machine for the project. And after that… our CI build service is ready to collect changes from the repository and trigger a build for our clients, or just build the application and run our unit/UI tests to check if everything works fine.

But what if something went wrong…

Let’s say that we were doing some code refactoring, we committed the changes and pushed into our repository. Next, our build system discovered that there were available new commits - so it started to fetch and built them and ran unit tests. And here some tests failed.

Of course, I don’t have constantly an opened browser to check on the Teamcity site if everything goes well when I push something to the repository. I want to be informed if something goes wrong like - if unit tests fails or timeout appears or compilation error happens. And here is the key word - INFORMED. How our build agent can inform us about an occurred error?

Emails

We use email service which is built-in into TeamCity. Every built lane has a rule which says ‘send email to all developers when something goes wrong and build fails’. This solution works fine and it’s commonly used in many projects and companies. But personally, I’m not 100% satisfied with it. If you work in several projects, you get more and more emails from clients, Jira, team etc. And let’s add to that getting new emails from our TeamCity service. Of course, I can create filters and group all the stuff(which I do), but even then it’s too much for me. Besides, there is a new thing - if some builds fail - in most cases, it is important to fix it quick. So I prefer another - quicker in my opinion - way to be notified if something bad happens.

❤️ Fastlane + Slack ❤️

1. Create your Fastfile in right way

Let’s consider a simple example. One lane which compiles the project and runs the unit tests:

platform :ios do
    desc "Runs all the tests"
    lane :test do
        begin
            test_lane()
        rescue => exception
            on_error(exception)
        end
    end
end

As you can see the body of :test lane consists of begin-rescue-end structure. It is a ruby specific construction. In begin you put some code that may fail. After the rescue => exception line you put the code that should be executed if something goes wrong. In our case, it will be on_error(exception) function. So the Fastfile should look like this:

platform :ios do
   desc "Runs all the tests"
   lane :test do
       begin
           test_lane()
       rescue => exception
           on_error(exception)
       end
   end
end

### Methods

def test_lane
   cocoapods
   clear_derived_data
   scan(scheme: "YourProjectSchemeName", configuration: "Debug")
end

def on_error(exception)
   slack(
       message: "Some thing goes wrong",
       success: false,
       slack_url: "https://your slack incoming webhook url",
       attachment_properties: {
           fields: [
               {
                   title: "Build number",
                   value: ENV["BUILD_NUMBER"],
               },
               {
                   title: "Error message",
                   value: exception.to_s,
                   short: false
               }
           ]
       }
   )
end

2. Generate slack URL

As you probably have noticed slack method takes a slack_url parameter. But how can I get one?

Create incoming webhook

Go to slack incoming weebhook webiste, log in, and after that you will be able too see screen like this:

Choose your channel (for test purposes, I recommend choosing a direct message to yourself). Click Add incoming WebHooks integration. Next step is to copy the Webhook URL and use it as slack_url.

Of course, after you learn how it works, you can generate a URL for specially created Channel in your slack team.

3. Build Slack message in Fastfile

First of all, here you can find an official documentation for Slack action in Fastlane tool. In the below section I’ll try to give you a closer look at that.

Code for that is really simple. Let’s create a simple slack_message lane to test how it works. Put a new lane in you Fastfile, and then just run:

fastlane slack_message,

or if you are using a bundler

bundle exec fastlane slack_message.

platform :ios do
   desc "Runs all the tests"
   lane :slack_message do
       slack(
           message: "App successfully uploaded to iTunesConnect.",
           success: true,
           slack_url: "https://your slack incoming webhook url"
       )
   end
end

This is how our message looks like:

As you can see by default you get some information about Git Commit, Git Commit Hash, Lane, Result, Git Author.

🔧 Customizing slack message 🔧

👉 message

Simple key for creating a message which will be display in a first row in Slack message. This can be literally everything.

• message: "App Successfully uploaded to iTunesConnect"
• message: "All tests have been successful"
• message: "Something went wrong" - My favorite error message 😉

but try to make your Slack message useful. As you can see above in my Fastfile I use a begin-rescue construction in Ruby. It is very useful because you can use an exception passed as a parameter to and create some meaningful error message.

I assume that all of you use and know CococaPods. Let’s imagine situation that our Podfile has a typo

platform :ios, '10.0'
inhibit_all_warnings!

target 'MyAppTarget' do
 use_frameworks!

 # Pods for MyApp
 podd 'SnapKit' # <------- should fail because of `podd`
 pod 'Result'
end

Now create a lane in our Fastfile that will install our CocoaPods, and build the project.

fastlane_version "2.54.1"

default_platform :ios

xcode_select ENV["XCODE_PATH"]

platform :ios do
   desc "Runs all the tests"
   lane :build_and_test do
       begin
           build_and_test_lane()
       rescue => exception
           on_error(exception)
       end
   end
end

def build_and_test_lane
   cocoapods
   clear_derived_data
   scan(scheme: "MyAppScheme", configuration: "Debug")
end

def on_error(exception)
       slack(
           message: "Lane failed with exception : #{exception}",
           success: false,
           slack_url: "https://slackurl",
       )
end

As you can see if something goes wrong in build_and_test_lane method our script will get an exception and run the on_error(exception) method. Let’s try it by…

fastlane build_and_test or bundle exec fastlane build_and_test

wait some time…. and…🔔 🔔

Now our message is meaningful and we know that our Podfile has some errors.

👉 deafult_payloads

As we can read in the documentation:

Don’t add this key or pass nil if you want all the default payloads. The available default payloads are: lane, test_result, git_branch, git_author, last_git_commit_message, last_git_commit_hash.

Personally, I think it is very important information, but if you want to customize the message by removing some of those - you can look at this example:

slack(
   message: "App successfully uploaded to iTunesConnect.",
   success: true,
   slack_url: "https://your slack incoming webhook url",
   default_payloads: [:git_branch, :last_git_commit_message]
)

Here is how a message with customized default_payloads looks like:

👉 success

You can also define if that message will be successful or not. Among other cases, success messages can be used if your app is successfully uploaded to iTunesConnect.

Second option is to set success to false, and then a message will look a bit different:

The red color suggests that something went wrong and you have to fix it, which is a great way to notify you about it.

👉 attachment_properties

Here a real customizing process begins. By using this property you can add any field to your Slack message. Let’s say that you want to add BUILD_NUMBER and URL to artifacts.

slack(
   message: "App successfully uploaded to iTunesConnect.",
   success: true,
   slack_url: "https://your slack incoming webhook url",
   default_payloads: [:git_branch, :last_git_commit_message],
   attachment_properties: {
       fields: [
           {
               title: "Build number",
               value: ENV["BUILD_NUMBER"],
           },
           {
               title: "Artifacts URL",
               value: "https://url-to-your-artifacts.com",
           }
       ]
   }
)

Another example… let’s modify our on_error(exception) method.

def on_error(exception)
       slack(
           message: "Error occured!",
           success: false,
           slack_url: "https://slackurl",
           attachment_properties: {
               fields: [
                   {
                       title: "Error message",
                       value: exception
                   }
               ]
           }
       )
end

and here we’ve got a message 🔔🔔

As you can see, now the error message is custom field.

👉 other flags…

In this post I have focused, in my humble opinion, on the most important keys which allow you to configure Slack message. The others are: channel, message, use_webhook_configured_username_and_icon, icon_url, payload. More information about these keys you can find on official documentation.

🎉 Conclusion 🎉

I ❤️ Fastlane tool. It helps all developers to save a lot of time during development process. I think one of the puzzles of this process is Continuous Integration in the full sense of the word. How do I understand the Continuous Integration? As you can read about it on wikipedia

In software engineering, continuous integration (CI) is the practice of merging all developer working copies to a shared mainline several times a day.

It is 100% true, but for me, it is also a state when I as a developer can be notified by CI agent about successes and errors without specially checking them before pushing changes to the repository. But don’t get me wrong. I don’t recommend committing and pushing without compiling(because our CI agent inform us when something fails). I’m talking about a situation when you have a number of projects that contain a number of tests (Yes, I assume you’re writing tests 😉). And I think you don’t want to run them every time before you push new changes to the repository. That’s why, you configure the whole CI stuff to avoid it. Let CI agent do it for you. In most cases all the tests will succeed 😉), so you can work continuously. But if somehow tests fail - let the CI agent ping you on a Slack 😉 Another thing is that, you can be informed about good things like: successfully uploaded .ipa to TestFlight.

Below you can find all links that were used in this post.

👉 CocoaPods

👉 Fastlane

👉 Slack incoming webhooks

👉 Fastlane Slack action

👉 Continuous Integration

👉 TeamCity

This post was primarly posted on my company blog

Let’s take a quick look at one of the design patterns that should help us to write a good Object-Oriented code. The basic assumption of Strategy Pattern is that you can define many implementations that will conform to the protocol.

Take a look at a simple example that can be used on iOS applications.

Firstly, create a protocol which contains a method. In our case it will be:

Define protocol

Create strategies

Ok, most of the iOS apps use an UIImage to represent images in applications. The UIImage instance can be used to produce two different data representations of image UIImagePNGRepresentation and UIImageJPEGRepresentation. Let’s create classes that handle this stuff.

Now, as you can see - both classes conforms to the ImageRepresentation protocol but they differ in implementation. Each class represents a different strategy.

Create client

The last thing - creating a client that uses one of the ImageRepresentation strategies.

Usage

Conclusions

The cool thing about Strategy Pattern is that we can change our strategy at runtime. While using the Strategy Pattern we definitely conform to “Open-Close” SOLID principle. Our client is open for extensions by changing the strategy without changing the client implementation(close for modification). Also, the ImageRepresenter with Strategy Pattern included will be easiest to test.

Let’s think how the above code could look like without Strategy Pattern:

Using Switch

or using multiple functions

Both of these solutions definitely are not on the same line with CleanCode. Also, it might be hard to maintain that kind of code. The switch statement can grow with the next cases - what if we had to handle a 10, 20 or 100 strategies? The second one using multiple functions is also bad because we will continue duplicating the similar methods to handle each case. This few arguments should convince you to use Strategy Pattern. And last but not least, this two examples breakes the Open-Close principle.

This post was primarly posted on my company blog

Get started

First of all we need to check if our device supports force touch events. Then if our device is familiar with force touch we can easily register our UIViewController for force touch events. Take a look at this snippet:

As you can see the above code uses the traitCollection property. It is available in every UIViewController and provides information about controller environment. In documentation we can read about it:

A trait collection encapsulates the system traits of an interface’s environment

So when we access traitCollection and get information about forceTouchCapability. It will return one of these values:

Another method that needs some attention is registerForPreviewing. It register UIViewController for force touch events. Documentation:

Registers a view controller to participate with 3D Touch preview (peek) and commit (pop).

There is also unregisterForPreviewing(withContext previewing: UIViewControllerPreviewing) function available. After unregistering, all features related to 3d Touch will be turned off for view controller that called unregisterForPreviewing method.

All registered, what’s next?

We should take a look on UIViewControllerPreviewingDelegate - this delegate class is responsible for handling events from 3d Touch in view controller that implements methods of this delegate.

There are two methods:

First method is responsible for catching force-touch events. For example if you firmly press some view in UIViewController, that conform to UIViewControllerPreviewingDelegate, the method will be called once until you release your finger or press more strongly the view. As you can see this method returns an optional UIViewController?. The controller returned from this function is used for action called Peek. There is also a second parameter named location it will give you an information about at what CGPoint in ViewController’s view, the app received force touch. Here you can see what the Peak looks like:

Second method is responsible for an event called Pop. When the 3d touch mechanism detects that you strongly pressed the ViewController that was returned from viewControllerForLocation method, it will call and pass that UIViewController as viewControllerToCommit to second previewingContext(_ previewingContext: UIViewControllerPreviewing, commit viewControllerToCommit: UIViewController) function.

Important thing is that when the viewControllerForLocation returns nil the second function viewControllerToCommit will be not called.

In this method we can present viewControllerToCommit or do another actions e.g animate touched view.

Implementation

Let’s imagine that you have UIViewController that contains two UIImageViews with beautiful apple images inside. For this controller we want to implement 3d Touch Peak&Pop feature.

In viewDidLoad() function, register our controller for force touch events.

Create and add the UIImageViews to the array named forceTouchableViews. In my implementation I created AppleImageView class that inherits from UIImageView and have a appleDescription property.

You might be wondering why the forceTouchableViews is needed. But keep calm and continue reading, I will get back to it later :-).

Now let’s create an extension for our UIViewController that will conform to UIViewControllerPreviewingDelegate

For my purposes I created an Apple model class that holds name and image property. Also I created AppleDescriptionViewController which will be responsible for representing the viewControllerToCommit parameter.

About the code

As you can see in viewControllerForLocation method, I iterate through my forceTouchableViews and check using wasTouched(in: location) function, if some of views was touched. If no view was touched the function will return nil. Ok, but what that wasTouched(in: location) function does?

It converts input point to location in superview(if exist) and then checks if that location is inside UIView’s bounds. If yes then it will return true and we can say that our view was touched.

If I determine that some of my apple image views was touched, then I create a AppleDescriptionViewController and return it.

The only thing just left is to press a little bit harder on our apple image view and we will get into last step. The body of that function is simple as follow:

Result

pretty nice, huh?

Conclusion

I don’t like the way to determine what view user touched. Checking a point and calculating location for that is not really nice. Maybe another, better way to implementing 3d touch mechanism for views could be: extending a UIView class by some property like 3dTouchGestureRecognizerDelegate then implementing some methods like in UIViewControllerPreviewingDelegate. Then we don’t have to check whether view was touched, because on the delegate methods the touched view could be passed as method parameter. Something familiar to gestureRecognizer. Maybe in future iOS updates the API will be changed? To sum up, UIViewControllerPreviewing allows us the create pretty nice features and I highly recommend to use that and make your application better!

The whole implementation with example app you can find in my GitHub repository .

Thanks for reading, and see you soon!

Modify your Info.plist file

1. Add to your Info.plist file a special key called UIApplicationShortcutItems. It should be an array.

2. Add items to UIApplicationShortcutItems array. Items should be a dictionary type.

3. Put info for each item.

There are few values to set here.

  - UIApplicationShortcutItemType (required)
  - UIApplicationShortcutItemTitle (required)
  - UIApplicationShortcutItemSubtitle
  - UIApplicationShortcutItemIconType
  - UIApplicationShortcutItemIconFile
  - UIApplicationShortcutItemUserInfo

I will focus on the values that I set in my example app. The UIApplicationShortcutItemType is a string that delivers an information to your app about what type of shortcut was pressed. UIApplicationShortcutItemTitle is what user sees when the shortcut is shown. UIApplicationShortcutItemIconType is a string that inform application what kind of system icon should be used for this shortcut. And the last one is UIApplicationShortcutItemIconFile defining the icon name that should be shown when the shortcut appears(instead of system icon).

Important thing here is that you can use system or your custom icons. Apple recommends that the custom icon should be square, single color, and 35x35 points.

More about UIApplicationShortcutItems keys and description you can get from Apple documentation.

The configured Info.plist could look like that:

and by code:

<key>UIApplicationShortcutItems</key>
<array>
	<dict>
		<key>UIApplicationShortcutItemType</key>
		<string>app.some_another_action</string>
		<key>UIApplicationShortcutItemTitle</key>
		<string>Title with custom icon</string>
		<key>UIApplicationShortcutItemIconFile</key>
		<string>apple-35</string>
	</dict>
	<dict>
		<key>UIApplicationShortcutItemType</key>
		<string>app.some_action</string>
		<key>UIApplicationShortcutItemIconType</key>
		<string>UIApplicationShortcutIconTypeAdd</string>
		<key>UIApplicationShortcutItemTitle</key>
		<string>Title with system icon</string>
	</dict>
</array>

Final result

Below you can see the result of above implementation.

Application shortcut tap handling

Ok, now move to AppDelegate class and let’s deal with the application’s shortcut tap events.

1.Override and implement UIApplicationDelegate method.

Let’s focus on this method:

func application(_ application: UIApplication, performActionFor shortcutItem: UIApplicationShortcutItem, completionHandler: @escaping (Bool) -> Swift.Void)

That method is called every time when the application shortcut is pressed. You don’t have to worry about your application state. If your app is in background mode it just wakes up your app and triggers performActionFor method. But if the application is terminated the app cycle will be didLauchWithOptions and then performActionFor shortcutItem will be called. Of course, you can take the application shortcut in didLauchWithOptions method by:

if let shortcutItem = launchOptions?[UIApplicationLaunchOptionsShortcutItemKey] as? UIApplicationShortcutItem {
  //deal with it here
}

before it triggers the performActionFor method.

2.Handling the UIApplicationShortcutItem

It’s time to write some code here. So let’s assume that your AppDelegate class includes these two methods:

func application(_ application: UIApplication, performActionFor shortcutItem: UIApplicationShortcutItem, completionHandler: @escaping (Bool) -> Swift.Void) {
    handleShortcut(shortcutItem)
}

private func handleShortcut(_ item: UIApplicationShortcutItem) {

}

Did you remember the UIApplicationShortcutItemType? Value for this key is very useful to identify what application shortcut was tapped. But on the Info.plist file it occurs as a String type and I strongly advise against comparing the string in their pure form. Very helpful here might be Enum type. So create the enum.

enum ApplicationShortcutTypes: String {
    case redApple = "show-red-apple"
    case greenApple = "show-green-apple"
}

I think comparing types using enum is a much better way to identify what type of shortcut was tapped.

Now get back to the handleShortcut method:

private func handleShortcut(_ item: UIApplicationShortcutItem) {
    guard let actionType = ApplicationShortcutTypes(rawValue: item.type) else {
        return
    }
    switch (actionType) {
    case .greenApple:
      showGreenAppleViewController()
    case .redApple:
      showRedAppleViewController()
    }
}

The effect of implementation will look like this:

As you can see above I create two quick actions with custom icon, title and subtitle.

Dynamic shortcut items

It is worth to mention about dynamic shortcut items. Yes, UIApplicationShortcutItems are split between static and dynamic.

• static - that items are placed in info.plist
• dynamic - that items can be added and removed in code

To add dynamic shortcut item you just have to add it to shortcutItems array.

UIApplication.sharedApplication().shortcutItems?.append(UIMutableApplicationShortcutItem(type: "my-dynamic-shortcut", localizedTitle: "Dynamic shortcut"))

to remove:

if let shortcutItem = UIApplication.sharedApplication().shortcutItems?.filter({ $0.type == "my-dynamic-shortcut" }).first {
    guard let index = UIApplication.sharedApplication().shortcutItems?.indexOf(shortcutItem) else {
      return
    }
    UIApplication.sharedApplication().shortcutItems?.removeAtIndex(index)
}

Conclusion

The 3D Touch is powerful feature and makes iOS apps very nice to use. Interesting fact is that from the iOS 10 all apps available on AppStore have predefined Share App shortcut. It allows us to share the applications without opening them. In my future posts I will describe more features that 3d touch gives us. So, thanks for reading and see you next time!

In this post, I would like to describe you to set up a proxy using Charles desktop app. I believe that many of you work with API or consume some REST Service. If haven’t heard about proxy yet I believe the knowledge from this post will be useful in your future development. The following example concerns an iOS environment and configuring at the OSX system.

What the proxy is?

To tell you what the Proxy is I use the definition that I found in Charles documentation

An HTTP Proxy is a server that receives requests from your web browser and then makes the request to the Internet on your behalf. It then returns the results to your browser.

So the Charles app is kind of monitor that inspects your network traffic, does all requests on your behalf and returns response back to you.

Do I really need it?

Yes! It might help you when you’re creating an app that consumes some API. You’ll be able to look throught the request and response from the server. Also, Charles app allows you to set a break point for endpoint and gives you ability to edit a request or response body, so you can test a various scenarios for your app. Likewise you can see how many request your app really does.

How to configure Charles?

First, go to Charles website and download the installation file. After the installation process you will see the main screen of the app. At start I recommend to select the Sequence tab on the top.

After some time you should see all request that you do on your mac. Now, we have two ways to configure the Charles. First way is to configure it for iOS Simulator. The second option is configure Charles for iOS device.

iOS Simluator configuration

Click on Help -> SSL Proxying -> Install Charles Root Certificate in iOS Simualator.

You will see the prompt:

Then click OK and for sure you should restart Simulator. After that steps Charles is configured and ready to work with your Simulator.

iOS Device configuration

On your device in Wi-Fi connection settings choose the same connection that your Mac using, tap on it. Then swipe down, and choose Proxy Setting to Manual.

In the IP field please put the same IP address that your Mac Wi-Fi uses. In the port field type 8888.

To see IP-address of your Wi-Fi on your Mac:

Right-click with option button on your wifi icon on the Mac

Then on your iOS device go to http://www.charlesproxy.com/getssl/ and install the certificate. I recommend to do it via Safari because it redirects you from URL to Certificates Settings on iOS Device. Then just install the certificate.

After the installation process, you will be able to see all request from your iOS device in Charles app on your Mac.

Ok, all configured but, how to use it?

After the configuration flow, you will see the Charles main window, and your network data. For the purposes of this post I wrote a simple app that consume free rest API https://www.freegeoip.net/. This API gives us some geo-information about any domain. For example: https://www.freegeoip.net/json/github.com returns geo-information about github.com site.

Now, let’s call https://www.freegeoip.net/json/twitter.com from iOS Simulator/iPhone. On Charles main window, we’re able too see the request was made and we received a response. There is no information about request parameters, response code, etc.

Let’s take a look on that.

Overview tab

In the Overview tab we can see information about Protocol used to this call, SSL, also you’re able too see the request time and size of request and response.

Ok, let’s have look on the request and response

Unfortunately, both are not readable for Charles. It’s all because the request is secure and uses the https. So, we need to inform Charles about that this domain is using the SSL to see the request details.

Adding Proxy SSL

There’re two ways to do that.

First you can click on the Proxy settings, then click Add the append host to the list. In the Host field type the host address of your server. In my example that would be www.freegeoip.net.

In the port field type 443. Why 443 ? Because the 443 is the default port HTTPS connections use.

Make sure that you have Enable Proxy SSL checkbox selected. After adding the host it should look like that :

Second way is much simpler, just right-click on the request and select the Enable SSL Proxying.

Request using SSL Proxying

After adding the SSL Proxying for our host server, perform request again.

As you can see right now we’re able to see the RC(response code) of the request. Here it is 200(OK). Also we know that our request was GET type. Let’s take a look at the request and response body.

In the request body, we have some information about Request type, language, and encoding. Also, you can find here some information about Cookies.

The response body becomes readable from Charles. After choosing the JSON text tab we can see formatted JSON string. All informations about the response are stored in the RAW tab. You can find here information about Response code, Content-Type, Server, encoding and many others.

And now the most important - response body:

Debugging

The cool thing about Charles is that the app allows you to debug the requests/responses in the same way as XCode and many others IDEs breakpoints work. But here you put the breakepoint on the request, not on the line of code.

To set a breakpoint, just right-click on the line with the request that you want to debug and select Breakpoints option.

Now, make the request again and you should see the Breakpoint-Window.

With the Overview and Edit Request tabs. Here you’re able to edit the request body, query string parameters, request method, cookies, headers or even choose the HTTP version. After editing the request just click Execute on the bottom.

After executing when the Charles receives the response we should see the Breakpoint-Window again and now we’re ready to edit the response!

By editing the response I mean that you can edit Response Headers and Response Body. Also you can check the body and the overview of the request. After editing the response, just click the Execute button. After that steps, the edited response goes to our device/simulator.

Note: Remember to set the breakpoint off, when you don’t need it anymore because if you don’t this the breakpoint will run every time that request was triggered.

Conclusion

Charles app is a great tool and has many many features. In my post I focused on the iOS environment, but you can also configure the proxy for your Android Emulator or Android device. I described most common usages which I do with Charles app. To sum up I think that app should take a place in your development tools directory if you work with some web server.

This post is cross-posted with my company blog