This project-based course shows how to automate your iOS development process using the features provided by App Center. Discover how to start with a provided iOS Swift application and gradually incorporate App Center services. By the end of the course, you will have a native iOS Swift app with a fully-integrated CI/CD pipeline.
- What is App Center?
- Building an app in App Center
- Creating and running a unit test with XCTest
- Adding the App Center SDK to your Xcode project
- Distributing a new release
- Generating a test crash
- Monitoring app crashes and performance with analytics
- Engaging your customers with targeted push notifications
Skill Level Beginner
- [Instructor] When we talk about continuous integration, what we really want to do is streamline the development process. I want to make sure that we have enough time to focus on the important issues and the important features of our applications with the ultimate goal of building amazing apps that our customers and users love. And what kind of app do users love? Well, they love apps that work well and provide the features they need. Now, as software engineers we want to focus on what we do best, and that's writing great code.
So we want to maximize the time we spend writing the code and minimize management time. Now, of course, we don't work in isolation. We consult with other members of our team, and we have processes to test our apps, deliver them to beta testers, and get feedback and analytics on the health and performance of our apps. And this is what we call the app delivery lifecycle. So what kinds of things are involved in this management process? Well, we often break them down into three categories or phases.
We have the development process. And then there's testing, and then monitoring the application once in the hands of users. Now, during the development phase we need to write code, of course, but we're also doing things like managing our build pipeline, right? We're compiling and packaging our application and deploying the build to testers so we can get that feedback. And we're managing our build environments. We ensuring that we're using the latest versions of FCKs and IDEs. We want to have the latest features, the latest fixes, and most likely the latest performance improvements.
And all this is really important, but managing the pipeline and managing the build agents can cut into that valuable development time. And it's very common now to be running unit and UI tests during the application development process. And we want to run these tests to ensure they pass before distributing to humans, you know, before our beta testers or our users are using our application. And once the application is in the hands of those testers or users, we want to monitor the app both from a performance perspective, you know, is the application crashing? Is it remaining performant? But are our users able to use the app as it was intended? Are they using all the amazing features that have been added? Where are they spending their time in the app? Are they using the app as we imagined or we intended? Now, how do we do all of these things while still having enough time to write code? Well, the answer is we're going to automate as many of these processes as possible so we can focus on building great apps.
So every time we make changes to our code we want to make sure it builds successfully. But we can go a step further and run our unit and UI tests on every commit. This is going to help us detect breaking changes and make sure that existing features continue to work as expected as we add features and continue development. And this is what's known as Continuous Integration. We automatically build and test the app every time the source code changes. And we may also want to make new builds available to our testers as we're developing our app, because the sooner our testers get a new version the sooner we can get feedback and ensure we're working on the right features.
And we call this Continuous Delivery. That's the ability to build a package and deploy our application every time our code changes. And everything we just talked about App Center can do for you, and those features are all integrated into a portal designed for application developers. When you commit source code changes build and tests are automatically run. Your application is packaged automatically, and beta testers are notified that a new version is ready.
And when testers run the application, if it crashes, we'll get a notification sent back to App Center with a detailed crash report that we can view in the portal, typically find and fix the issue. Now, keep in mind these services are modular. They all integrate and work really well together, but with App Center you can still pick and choose the features that you want to use. If you only want App Center to build on commit, that's great. And if you only want App Center to deploy new builds to beta testers, that's fine as well.
App Center provides integrated, comprehensive, and automatic CI and CD services for application developers.