Master CI/CD for Android Developers

In this lecture I talk about the topics that this course covers, and describe a bit about what you will learn in each section, just so you get the overall idea about what you will learn, and what you may already know aout the course topics.

In this lecture I briefly describe the three steps that conform DevOps and the CI/CD process that we will implement with the help of App Center.

In this lecture I talk about the advantages of implementing a DevOps strategy that includes Continuous Integration, Continuous Quality and Continupus Delivery not only from the developer point of view, but from the user and business POV.

In this lecture I will give you a sneak peak at the entire CI/CD flow entirely integrated with our version control's remote repository on GitHub so that builds and new releases are automatically triggered from App Center.

Here at the beginning of the section, I talk about why source control is important, and how you should structure your branches so that CI/CD can be easily implemented once we have everything in GitHub.

In this lecture you will create a new Android project and initialize the repository in the correct directory, so that the project is ready to commit changes to it and eventually push them to the GitHub remote.

In this lecture you will learn how to commit the changes that you make to your code to your repository, so the changes are tracked and versions of the same file can be identified in the source control system through those git commits.

In this lecture you will learn to create new branches directly from the terminal, as well as learn how to switch between them with the checkout command. This step is very important, because it helps set the foundation of the CI/CD process as we will eventually have it in App Center.

In this lecture I explain how you can commit different changes to different branches, how the IDE is aware of the current working branch, and displays what the branch contains, and how you can merge branches together, setting one important piece of the CI/CD puzzle

In this lecture you will create a new GitHub repository and explore the tabs that it contains, with the purpose of identifying the interface a bit better and starting to understand how Github will relate to the CI/CD process that we want to implement.

In this lecture you will push everything from your local repository to your new GitHub remote repository. You will push all the branches that contain all commits, and set upstreams so future push commands are easier to execute.

In this lecture I will cover two very important things that GitHub allows us to do inside of a remote repository, and that are going to be the backbone of the CI/CD structure: branch protection and collaboration. One will protect the master branch from unchecked merges, the other will allow other accounts to work in the same repository.

In this lecture you will create your first pull requests inside of the GitHub repository that we have created as the remote for our local repo. These pull requests will merge changes from dev to test, and eventually to master, which is protected so we will need to add an approving review.

In this lecture we are going to simulate a CI/CD rundown with the GitHub repository that we already have. We are going to be deploying some part of our code with the help of GitHub Pages, and we will use pull requests to simulate how eventually a Continuous Deployment process can work.

In this lecture we will start to talk about App Center, what services it provides, which we are going to be using, and how it will help us not only implement a CI/CD process, but identify what features we must add to our apps.

In this lecture you will create your new App Center account and explore what features you have inside. Create an organization that will hold distribution groups (important for the CD process) and add the app that you will use throughout the course.

In this lecture you will prepare a new Android application to connect to App Center through some NuGet packages that we have to add. This will be done through the App class and the initialization will prepare the projects to communicate with the App Center Apps we have ready in the portal.

In this lecture I will push all of our code over to GitHub and explain the two ways in which you can get the source code for each lecture of the course in which we work with code.

In this lecture we will setup the basic navigation of the application and set it to crash from two different places, so that we have something that is being tracked by App Center from the beginning

In this lecture you will code the functionality that tracks events, which can be added anywhere you want, and is done very similarly to how errors are tracked. Then, you will explore how this information gets added to App Center.

In this lecture you will learn how to track more context when the events are reported to app center, so as developers we understand better how are users behave inside the application and know what to improve.

In this lecture we cover the benefits of using Continuous Integration, and the reasons why you should consider always using it when you create new mobile app projects.

In this lecture you will first make sure that the remote repository contains all the main branches that we have mentioned that we need. You will then fetch all those branches to some new local branches, and finally work with a new feature branch that has to be merged into dev.

In this lecture you will setup Continuous Integration for one of your branches for the Android app that you have on App Center. This CI process will then be triggered when we merge into the dev branch from one of our feature branches.

After we had to create an additional App Center app, we created a big mess within our GitHub and App Center accounts, in this lecture, we will clean that mess up by identifying what happened on GitHub and App Center, and making sure that everything is clean and ready to keep working with Continuous Integration.

In this lecture we will use the checks that have been added to our GitHub repository from App Center to protect our branches, so that merges can only happen once the checks (builds) have succeeded.

In this lecture you will enable checks in your pull requests by making App Center send information to your GitHub repository, just like the GitHub repo was already sending info to App Center.

In this lecture we will execute a complete CI flow by coding a new feature into a new feature branch. This new feature, coded from Android Studio, will eventually be pushed to the remote, where a new pull request will start, which will itself trigger checks and builds in App Center.

In this lecture we will discuss what Continuous Quality means in the context of App Center, and how th power of App Center will allow us to automate the tests of our app (that we will create with Espresso) in thousands of physical devices with what once was Test Cloud.

In this lecture you will add a new project to the solution, which will contain the tests that we will have to run. After that, you will prepare the Android project to execute those tests, which will mean adding some Test cloud information and disabling some mono runtime features here and there.

In this lecture you will install the App Center CLI tools that will be necessary for the tests to be uploaded from our local machine to the Continuous Quality service that we will use throughout this section.

In this lecture we will prepare the Android project to create the APK file everytime it builds, and use the App Center CLI (Command Line Interface) to upload this APK file with the debug UI test configuration to App Center, where our test will run on as many physical devices as we want. We will also improve the test that Espresso is performing so that it waits for an element to be on the screen before making assertions.

In this lecture we will take a sneak peak at what automatic tests behave on App Center. Some automatic tests will be performed when the Continuous Integration process is triggered and be part of the CI process itself.

In this lecture I will discuss what Continuous Delivery means in the context of our mobile applications, and walk you through the actions that App Center will have to perform to get our apps to our users, through distribution groups, and through the App Stora and Play Store.

In this lecture you will be creating a distribution group for the Android application, which will be used by our continuous delivery process to distribute a new release of our application from the test branch everytime a pull request happens.

In this lecture we will configure our Android test branch to create a new release everytime a new build is triggered with Continuous Integration. For this we will need the help of JAVA to create a keystore file that we will upload to App Center

In this lecture you will learn how your beta testers will be able to install the application's releases that we have generated directly on their phones with the help of App Center, and start to use those new versions that we have prepared through Continuous Delivery.

App Center requires that we create an initial release of our Android Application in the Google Play Console, so that new releases can later be automated through a continuous integration and continuous delivery process triggered in our master branches.

In this lecture you will connect the Google Play Store to App Center so that Continuous Delivery is ready from the master branch. This will happen with a JSON file generated directly from the API console.

In this lecture we will trigger an entire CI/CD flow directly from GitHub and into the master branch, so that the CI process builds a new version of the app, and the CD process distributes it to the corresponding App stores.