From the Pipelines in the menu choose Releases, on the plus button click New and New release pipeline
Select start with an empty job and add name to the stage e.g. Deploy app to Test Flight and close the dialog the updated name will be auto saved
On the + Add an artifact from the build source choose the definition that builds your app and contains the ipa file in the artifacts
All other fields will be preselected, if you want to make more additional changes change the available options.
Create Task that builds your app
On stages select the stage that deploys your app and in the tasks click on the plus button
From the Tasks search for “Apple app Store release” and choose the task named like that
Note: In the Agent Job > Agent specification you should choose Mac OS or choose your Mac as self hosted agent
Lets get back to the task
– Authentication method
There are two options to authenticate with App Store. The Service connection and Username and Password. The main difference between these two is that Service connection can be used between other pipelines (if access granted).
User Name and Password
In the email field enter your email and in the password enter the password from your Apple Store account, if you are using two steps verification check the field and type those credentials as well.
Click on manage and you will be navigated to Service connections in Settings
Click on new service connection and choose Apple App Store than Next
In App Store email add your email address form App Store
In Password your personal password from App Store
In the Service connection name add meaningful name for your connection
Since other fields are optional you can just click save and the connection will be created for you
Navigate back to the release task and click on the refresh button next to the Service connection field and the connection will appear.
– Bundle ID
In the Bundle ID enter your unique identifier. That can be find in the info.plist from your Xamarin.iOS project the string form CFBundleIdentifier key.
– Binary Path
In the Binary Path choose the .ipa file from the drop, that file is the one from the artifacts that was created from the previous successful build definition.
In this post will be shown how to create Xamarin.iOS Build definition that will build your Xamarin iOS app and also create an archive file. The .ipa file later on can be deployed to the Test Flight and App Store. On how to deploy the app to the store can be seen in the following link: Release Xamarin iOS app with Azure DevOps
Before any app can be successfully distributed to the App Store there are some steps that needs to be done so the app will be recognized and verified from the Apple. That means that that every app has to have a Certificate and a Provisioning Profile valid files. For how to create those, check the following link: Create distribution certificates and provisioning profiles for your iOS app.
Create build definition
Navigate to your Azure DevOps account.
Form the Pipelines choose Pipelines and New pipeline
Click on Use the classic editor to create a pipeline without YAML.
Select your source. Than find the project you want to build
Select the default branch and click continue
From templates search for Xamarin.iOS and select the “Xamarin.iOS” task than apply
The definition will be created for you
Lets do some modifications
In the Pipeline > Agent Pool select the machine that will build your app “Hosted” if you want to use agent assigned to you or “Private” if you want to use your device as agent.
Enable “Install an Apple certificate” and “Install an Apple provisioning profile” tasks
Also remove “Select Xamarin SDK version“, “Copy Files to: $(build.artifactstagingdirectory)”, “Test with Visual Studio App Center”, “Deploy **/*.ipa to Visual Studio App Center” because we won’t need them for now.
Add the Provisioning profile and the .p12 files in Library
Choose from Pipeline > Library Library is used for keeping secure files
Choose Secure files and click on the +Secure files
Click on browse and add these two files separately
Install Apple certificate
Choose the .p12 file from the secure files in Certificate (P12) field
Navigate in the Variables from the menu and in P12password field as value add your p12 password also lock it so it wont be visible.
Install Apple provisioning profile
Choose the Provisioning profile from secure files in the Provisioning profile field
Unselect the “Build for iOS Simulator” checkbox
In the Signing & Provisioning in Signing identity enter $(APPLE_CERTIFICATE_SIGNING_IDENTITY). This variable is automatically set by the Install Apple Certificate task for the certificate you selected
In the Signing & Provisioning in Provisioning profile UUID enter $(APPLE_PROV_PROFILE_UUID). This variable is automatically set by the Install Apple Provisioning Profile task for the provisioning profile you selected.
Open the Advanced drop down list and in Arguments enter /p:IpaPackageDir=”$(Build.ArtifactStagingDirectory)”. With this set up the created .ipa file will be stored in the artifacts directory.
Every iOS app to be deployed to the App Store must first be identified by Apple. In this post will be shown how to generate those files so later on they can be used for the app deployment to the Store.
In this section we can register an unique identifier for our iOS app that will represent the app on App Store. There are no two applications on the App Store with the same identifier. They are usually created as com.yourbrandname.ios. This one must be the same as the string form CFBundleIdentifier key in the iOS project inside the info.plist file.
Choose Identifiers from the menu
Click on the plus icon next to Identifiers and select App IDs for registering individual app for App Store than continue
From the select type select App and continue
In the Bundle Id choose Explicit and type your Bundle Id e.g. com.yourbrandname.ios and in the description type something recognisable for example “You App Name Bundle Identifier”, continue
Review and Register
The identifier will be created in the identifiers
Certificates are used to sign your app. That helps Apple to identify our organization when submitting to App Store. Certificates includes private and public key. The certificate represents the public key and from that you can export the private key. The Apple does not keep information about the private key. .p12 file that will be exported in the next steps stores certificate together with the private key that corresponds to this certificate.
Launch Keychain Access located in /Applications/Utilities
Choose Keychain Access > Certificate Assistant > Request a Certificate from a Certificate Authority.
In the Certificate Assistant dialog, enter an email address in the User Email Address field.
In the Common Name field, enter a name for the key (for example, Gita Kumar Dev Key).
Leave the CA Email Address field empty.
Choose “Saved to disk”, and click Continue.
Navigate back to the Developer Apple site
Choose Certificates from the menu
Click on the plus button next to Certificates and select Apple Distribution than continue
Choose the created file form the Desktop (the one in the Create certificate signing request section)
The certificate will be created for you click on download and download it locally
Generate the .p12 file
Once the file is downloaded locally double click on the certificate
Certificate will be automatically added in your Keychain Access
If you have multiple certificates from the same account and you are not sure what is your new created certificate in the Keychain Access form the menu choose Keychain Access > Certificate Assistant > Evaluate Certificate and select the downloaded certificate(.cer) remember the Id
Go back in the Keychain and choose My certificates.
Find the certificate with the same ID and click on the arrow
The file with key image will appear, right click on it and click Export “…”
Add meaningful name of the p12 file than save
Add password and store it somewhere secure
The .p12 file will be downloaded in the disc
Provisioning profiles are used to confirm if the app can be installed in the particular Apple device. The provisioning profile contains information about the signing which means it first must be approved by Apple and the application identity
Choose profiles from the menu
Click on the plus button near the Profiles and from Distribution select App Store than continue
Choose App Id created in Identifiers and Continue
Select the certificate created in Certificates and continue
Add meaningful name for Provisioning Profile and Generate
Download and double click if you want to export it in your Keychain Access
Github & App center opportunities by making the release processes easier
The combination of these two powerful services has made the deployment for mobile application easier than ever, from building to testing and releasing in just few steps. I was amazed how repetitive process can be simplified and automated without any trouble for the developers. That is why I found it challenging and decided to create this article.
What are we going to do next?
For this article I choose to make modification on the application that was already on my repository for a while, you can look at this article for more details. The aim of the application is to represent just one place in Postcard format. Looking from that point of view there was no point to create so many repositories for the same application and a real time saver would be if the same application is able to be used for various places. I was thinking for a way to reuse the same code, but yet create many more different apps.
Why we need to brand an application?
At the first sight this may looks irrational but there are many use case scenarios where this is required, here are some of them:
You want to sell same product for different companies, but all of them have different name, different logo and colors that are typical for the brand.
You want to create multiple environments from the same application ALPHA, BETA, PRODUCTION they all are the same app but may work with another API.
Lets get started
Lets navigate to App Center, and choose Build section from the Menu. Choose to edit already existing build definition. In the built configuration there is a section called Build scripts. By using this section we can execute custom scripts in our application. As in the official documentation is stated three type of scripts are available: post-clone, pre-build and post-build. The post-clone script runs immediately after the repository was cloned but before we do anything else on our end. The pre-build script runs before the actual build starts. The post-build script runs after the build has finished and we have copied all the necessary artifacts to the output directory.
Where to create these scripts?
Create these scripts in the same folder where your .sln file is, or .cspoj file if Android. Note that there is already a collection of scripts that you may find useful.
The full code which I am modifying can be find on Github. It is an Xamarin.iOS application referring to the above script changes are in appcenter-pre-build.sh file.
Firstly lets take a look of the essential configuration information changes, that are under info.plist file.
Change App Name – Changing application name identifies what name users will see (from Postcard Zagreb -> Postcard Bitola)
Further more the changes should be applied as well as on the constants for the application. This usually includes Colors, Translations specific for application, Rules that tend to be modified during different scenario’s, variables that are used in the entire application.
Note: While developing application we have to be sure that we always use the same resource. e.g.: Using class for color palette, not hardcoding the colors.
In many of the scripts you may noticed that the environment variables are marked with $. Same as in the code, we do not hard code the values because we want to use the scripts for many postcards. Here is where we define the variables.
After applying all this changes and rebuilding the app from App Center, here is the product we get. A brand new postcard 🙂
A year ago I have published a public repository on how to create a stretchy header using Xamarin.iOS application. This time I decided to go a little further with this solution, by preparing it to be able to be rebranded. For now let’s look at how to implement this sassy component.
The app is postcard for places and for this demo I chose to write about my favorite city by far. Full implementation can be previewed on (Github Code).
Create TableView with source and delegate separate
Lets start with creating a TableView and presenting the data with TableViewDataSource and TableViewDelegate by providing custom cells that will contain the Header and the Content for the postcard. The Heather is chosen to be a photo and the Content is information, both about the city.
public class TableViewDataSource : UITableViewDataSource
private const int numberOfRowsInSection = 1;
public override UITableViewCell GetCell(UITableView tableView,
return tableView.DequeueReusableCell(TableViewContentCell.Key) as
public override nint RowsInSection(UITableView tableView,
public class TableViewDelegate : UITableViewDelegate
public override nfloat EstimatedHeight(UITableView tableView,
public override nfloat GetHeightForRow(UITableView tableView,
Add the Stretchy Header to the TableView
To achieve a transparency at the top of the screen the header has to be added as subview in the TableView. By doing this, the header goes above the content in the TableView and in this scenario they are overlapping. Next step is to push down the content by managing the ContentOffset and ContentInset of the TableView. In this demo the Header size is 300. After these steps proper position of the elements in the view is achieved.
TableView.DataSource = new TableViewDataSource();
TableView.Delegate = new TableViewDelegate();
tableViewHeaderCell = TableView.DequeueReusableHeaderFooterView(
as TableViewHeaderCell ??
tableViewHeaderCell.UserInteractionEnabled = true;
TableView.TableHeaderView = null;
To achieve the effect of stretching the header rectangle, a variable called effectiveHeight have to be created. The effectiveHeight is fixed size which is the initial height of the header. What is important for the header is to change the content mode to Aspect Fill so it will scale the content to fit the size of itself by changing the aspect ratio of the content.
The following code represents the ability of the header to adapt its size to the changes done while scrolling. As proposed the header is the default size when there is no movement. By scrolling, the header height is supposed to increase by adding the difference between the offset and the effectiveHeight. If the absolute value of the offset is smaller than the effectiveHeight no changes will occur. And simple as that we are done with the logic.
public void UpdateHeaderView()
var headerRect = new CGRect(0,
if (TableView.ContentOffset.Y < -effectiveHeight)
headerRect.Y = TableView.ContentOffset.Y;
headerRect.Height = (-TableView.ContentOffset.Y);
tableViewHeaderCell.Frame = headerRect;
Invoke method in scroll event of the TableView
As said above, this happens on scrolling the TableView. So, next create an event which will listen to table scroll and invoke it on the Scrolled method in the TableViewDelegate, than attach it on the TableView.
public delegate void DidScrollEventHandler();
public event DidScrollEventHandler DidTableScrolled;
public override void Scrolled(UIScrollView scrollView)