The Error: The error message suggests that the ‘UIKit.UISceneSessionActivationRequest’ type, used as a parameter in ‘UIKit.UIApplication.ActivateSceneSession,’ is not available in iOS 16.2 and was introduced in iOS 17.0. This discrepancy indicates a version misalignment in the development environment, specifically with the iOS SDK and Xcode.
Root cause
The root cause of this error lies in the version of the macOS image used in the Azure Pipelines configuration. By default, the ‘macOS-latest’ image is pulled, which corresponds to macOS 12 (at the time of the blog post). However, the .NET MAUI app with Azure Pipelines requires macOS v13 to work seamlessly, as it aligns with the necessary dependencies for iOS development.
Resolution
To resolve this error, developers need to update the macOS image specified in the Azure Pipelines configuration. Instead of using ‘macOS-latest,’ the configuration should be modified to use ‘macOS-13.’ This ensures that the appropriate version of macOS is utilized during the build process, addressing the compatibility issues with iOS 16.2 and the required UIKit types.
Step-by-Step
-Open your Azure Pipelines configuration file (typically named azure-pipelines.yml). -Locate the section where the macOS image is specified. It might look something like this:
pool:
vmImage: 'macOS-latest'
-Update the image reference to ‘macOS-13’:
pool:
vmImage: 'macOS-13'
-Save the changes to the configuration file. -Commit the updated configuration file to your version control system (e.g., Git). -Trigger a new build in Azure Pipelines, and the updated macOS image will be used.
Values hard coded to an application is the brightest “DO NOT” thing in software development. But how to bring your Azure Function more professional level?
Start using application settings
You can define key value pairs on the Microsoft Azure portal for your Function app. Go to your app and find the Settings section, and click on the configuration button.
You can add your keys and values by clicking the New application setting button.
Application Settings are exposed as environment variables for access by your application at runtime. Learn more
Access your settings from your code
You can access your newly created setting from C# using the GetEnvironmentVariable call.
You do not need to add and modify the environment variables in your operating system. Add a new json file to your solution called ‘local.settings.json’, and fill it up with some data like below:
This content has 3 years. Some of the information in this post may be out of date or no longer work. Please, read this page keeping its age in your mind.
If you haven’t seen part 1, click here, and start build up your CI/CD pipeline now.
Part 2 Contains:
Configuring build with creating signed APK, and making artifacts from it
Setting up branch policy to master
Configure some magic
Let’s go back to Pipelines. Edit your previously created pipeline by clicking the three dot on the pipelines row.
CI is based on cloud machines hosted somewhere over the world. This computers called as agents. They are used to follow your instructions, defined in the yml file. The base Xamarin.Android yml is only to build your code. But we will make some additional steps in order to create a signed APK of every build. Follow up, to complete this setup.
Recommended branching strategy for this is to keep a development branch, and pull request your feature branches to it, and finally pull request the development branch to the master, and keep your master is always at your production version. The figure below shows visually this method. Source: https://dzone.com/articles/feature-branching-using-feature-flags-1
Create a signed APK or bundle from every build
First, set up some variables for this pipeline. You will find a Variables button on the right top of the tab. Click on it.
Let’s add a new variable by clicking the “New variable” button. We will need 4 vars.
Remember, that i told you, you will need to remember the alias, password, and the keystore name? You can forget them, after you have declared the variables for them.
Variables needed:
keystore_filename - AnAwesomeAppDelivery.keystore
keystore_alias - AnAwesomeAppDelivery
keystore_password - The password of the keystore.
When you create var for keystore_password, tick the “Keep this value secret” checkbox.
Go to the end of the boilerplate YAML file, and on the right top of the text editor, you can see a task wizard button. Click on that.
Search for “Download secure file” task on the search bar. Click on it, and set the “Secure file” to the value below, and click on “Add”.
$(keystore_filename)
This will get the variable value defined above. Press some enters to seperate our next task from the download secure file task, and jump into signing the APK.
Search for “Android signing” in tasks.
And set up the task like on the picture below. Please regret me for messing up the “Key password” value in the screenshot, the $(keystore_password) variable goes in that field too.
If everything set up correctly, it will make our APK in the output directory signed. But how we will access it? We need to drop our result to the pipeline artifacts. You can set the build output to the artifact staging directory, but i recommend to only copy the file, that you will need as a result. So make a copy task after Adding the Sign task, and some enters to the end of the YAML file. Follow the configurations in the picture.
Okay, we have copied the files, but the files wont appear in Azure DevOps, until we drop our packages to the Artifacts section of our build. Search for “Publish build artifacts”, select the task, and configure as the image below.
So how our YAML Looks like now? Like this below? Then go and save it. If not, correct your mistakes.
After saving the YAML, it recommends to Run it, so jump right into the fun, click on the “Run” button.
If everything is correct, it will show only green ticks. When you click on “Pipelines/pipelines” in the left menu of the DevOps page, you will see your state of your build. On the detailed view, you can access the created artifacts in order to download them.
Click on the row, and you can access the details of the build. If you have set up the pipeline correctly, it will show “1 published” label. Click on it, and you can access your signed application binary.
Merge the pipeline config branch to master
Set up main branch policies to run CI automatically
Go to Repos/Branches, and select the main branch, click on the three dot in the end of the row, and select “Branch policies”.
In the Build validation option, you can configure the previously created pipeline to run automatically whenever a new pull request gets accepted.
This content has 3 years. Some of the information in this post may be out of date or no longer work. Please, read this page keeping its age in your mind.
This tutorial will drive you through setting up a great CI/CD pipeline for Xamarin Android in a fully hosted Azure DevOps enviroment.
Part 1 contains:
Creating an empty Xamarin.Android build pipeline
Uploading keystore file to secure files
Start with some code
I have added some basic code to my demo repository. It is a boilerplate Xamarin Application, with no additional customized code. If you have code in your repo, make sure it builds successfully.
Create your first pipeline
On the left side menu, go to Pipelines/Pipelines. This menu will show up a welcome page, to create new pipeline.
Click on ‘Create Pipeline’ button, or if you have already created your first pipeline, find a button to add a new one.
On the next page, a wizard will guide you through the basic setup.
If you have your code in Azure Repos, click the button for that.
Select your repository where your Xamarin Android code lives.
On the next page, you can select a template to create your pipeline yml. Let’s choose Xamarin.Android.
If you want, you can rename your yml file. Pipeline files will be placed in your repository root by default. YML file extension stands for YAML files. Review your newly created file, how it looks like. Luckily, you do not have to write yaml too much, but good to know, how it markups the build process.
Okay it is enough for now, we have some things to do outside of the pipeline editor. Go save your configuration.
Create a new branch for the pipeline setup with name like pipeline_configuration. You can directly push the config to the main branch, but in this step of the tutorial, i recommend to create a branch for that. Later on, we will set branch policies 😉
Store your app signing key securely
Your app signing key is a very important file to keep your binaries trusted for your users. You can provide with signing, that the binary has been built by you, and not by a bad guy. Keeping this file secure is a must have thing.
Azure DevOps pipelines have a library function, where you can store your custom agent connection settings, and files needed to build or sign your applications securely.
Let’s jump into library menu. Select secure files option, and upload your keystore file.
If you do not have a keystore, you can create a new one when you are trying to publish a Xamarin.Android application as AdHoc. Keep your Alias, Password in mind, you will need this in the future.
The location of the release keystores on Mac is:
~/Library/Developer/Xamarin/Keystore/
Once, you have uploaded your keystore to the secure file storage, you need to set the permissions, to pipelines in order to access your secure files. Note your secure file filename, you will need this too in the future. Click the three dots on the uploaded file, and select edit.
Check the pipeline permissions checkbox, and save your file.
In the next session
We will continue set up CI to our Android project.
Go to Part 2 to continue configuring your repository
This content has 3 years. Some of the information in this post may be out of date or no longer work. Please, read this page keeping its age in your mind.