Continuous Delivery for Mobile with fastlane电子书

Title Page

Copyright and Credits

Continuous Delivery for Mobile with fastlane

Dedication

www.PacktPub.com

Why subscribe?

PacktPub.com

Foreword

Contributors

About the author

About the reviewers

Packt is searching for authors like you

Preface

Who this book is for

What this book covers

To get the most out of this book

Download the example code files

Conventions used

Get in touch

Reviews

Introduction to fastlane and Continuous Delivery

Welcome to fastlane

Automation testing

Unit testing

Regression testing

Integration testing

Acceptance testing

Continuous Integration

Continuous Deployment

What is continuous delivery?

Benefits of CI, delivery, and deployment

What is fastlane?

Why fastlane?

The fastlane suite of tools

Spaceship under the hood

Accessing the fastlane documentation

Summary

Setting Up fastlane and Our Sample Project

Installing the Xcode command-line tools

Installing Homebrew, Git, and fastlane

Alternative methods of installing fastlane

Updating fastlane

Installing Carthage

Troubleshooting common problems

Setting up our project – Firefox for iOS

Running Firefox for iOS

Configuring fastlane

Updating fastlane

Summary

Manage Provisioning Profiles with sigh

Introduction

Development distribution overview

Enrollment

Individuals

Organizations

Educational institutions

Develop

Distribute

What are provisioning profiles?

About Bundle IDs

Types of provisioning profiles

The development team provisioning profile

Ad hoc provisioning profile

App Store provisioning profile

Enterprise provisioning profiles

Expiration of provisioning profiles

Introducing sigh

Usage

List of sigh commands

Our project problem

Updating our Fastfile

Summary

Manage Code Signing Certificates with cert

What you will learn

Skills learned

What are certificates?

Developer and distribution certificates

Development certificate

Distribution certificate

Managing certificates manually

Creating a certificate through Xcode

Creating a certificate through the developer portal

Verifying the private/public keys in keychain throughout this workflow, when using your certificate and provisioning profile, you need

Installing missing intermediate certificate authorities

Recreating certificates

Backing up certificates and provisioning profiles

Introducing cert

Usage

List of cert commands

Our project problem

Updating our fastfile

Summary

Sync Profiles and Certificates with match

Collective code signing

Security

Portal access management

Git access management

Encryption

Introducing match

Create a private Git repository

Initialize match

Running match for the first time

Recreating development certificates and provisioning profiles

Adding new team members

Handling multiple targets

Adding new devices

Our project problem

List of match commands

Summary

Manage Push Notification Profiles with pem

What push notifications are

How push notifications work

Provider

APNs

APNs-device trust connection

Local versus remote push notifications

Enabling push notifications

Enabling push notifications the traditional way via Xcode

Introducing pem

List of pem commands

Updating our Fastfile

Summary

Creating Our iOS and Android Apps with produce and supply

The process of creating an iOS

Registering your App ID with produce

Provisioning your app

Certificating your app

Distributing code-signing identities

Managing push notifications

Building and packaging your app

iTunes Connect versus Developer portal

Adding capabilities

iCloud/CloudKit

Passbook/Wallet

Apple Pay

In-App Purchase

Map/Location

Background Modes

App Groups

Inter-App Audio

HealthKit

Data Protection

Adding HomeKit support

Adding Associated Domains support

Keychain sharing support

Push notifications

Introducing produce

Usage

Enabling services

Optional parameters

App and bundle ID

Skipping iTunes Connect or Dev Center

Creating and associating a new app group

Updating our Fastfile

Introducing supply

Setting up a Google Play developer account

Setting up fastlane and supply

Using supply

Summary

Build and Package Apps for the App Store with gym

Traditional process of building an app

Using Xcode to build an app

Distributing your app for testing

Using xcodebuild to build an app for testing

Introducing gym

Usage

Parameters and options

Manifest files/app thinning

Storing gym configurations externally with a Gymfile

Exporting plist files

Updating our Fastfile

Summary

Distribute to Testers with TestFlight and Crashlytics

An overview of testing

Continuous delivery and testing

Beta testing tools

Overview of TestFlight

Setting up TestFlight

App information

Upload your test build

Managing and adding internal and external testers

View tester information

Crashlytics

Setting up Crashlytics

Distributing to Crashlytics manually

Introducing Pilot

Uploading a TestFlight build with fastlane

Listing all the builds

Managing TestFlight users with fastlane

Onboard new testers on TestFlight with onboard

Updating our Fastfile

Crashlytics and fastlane

Summary

Review Your App Metadata with precheck

An overview of App Store rules

App Store Review Guidelines

Safety

Objectionable content

User-generated content

Child content

Physical harm

Developer information

Performance related issues

Business related issues

Design related issues

Legal related issues

Common app rejections

Handy guideline references

Introducing precheck

Running a precheck

Precheckfile configuration

Updating our Fastfile

Summary

Taking Localized Screenshots with snapshot

An overview of capturing screenshots on iOS simulator

An overview of UI testing

XCTest framework

UI tests

XCUIApplication

XCUIElement

XCUIElementQuery

Accessibility

Introducing snapshot

Setting up snapshot in your project

Creating the UI Test Target

Initializing snapshot

Adding SnapshotHelper.swift to the target

Recording your app interactions

Generating snapshots

Confirming the screenshots

Other snapshot options

Working with snapfiles

Running Xcode simulators concurrently

Updating our Fastfile

An introduction to screengrab

Summary

Put Our Screenshots Inside Frames with frameit

An overview of how to design your App Store product page screenshots

Beautifying screenshots

Downloading the template files

Adding your own screenshots

Exporting the screenshots

Dealing with device variants for screenshots

Introducing frameit

Running a basic frameit command

Making our frames App Store compliant

Updating our Fastfile

Summary

Upload Screenshots and Metadata with deliver

How to manually upload a new build to iTunes Connect

Uploading using Xcode

Updating version and build number

Archiving

Uploading using Application Loader

Entering your app metadata

Submitting your app to be reviewed

Introducing deliver

Generating your deliverfile metadata

Uploading our metadata

Other deliver options

Updating our Fastfile

Summary

Automate Unit Tests with scan

An introduction to testing in iOS 11 and Swift 4

Create a test target

Adding a simple unit test

Examining other test cases

Introducing scan

Running a simple scan

Viewing the output results

Running a specific scan

Generating a Scanfile

Updating our Fastfile

Summary

Integrating Git into the fastlane Workflow

Introducing the various Git actions and commands

ensure_git_status_clean

ensure_git_branch

create_pull_request

git_pull

git_commit

push_to_git_remote

git_tag_exists

add_git_tag

push_git_tags

Calling bash commands using fastlane

Improving and optimizing our fastlane workflow

Working with the before_all lane

Ensuring our fastlane is always the latest

Optimizing our beta distribution workflow

Getting the latest code and ensuring a clean Git status

Building our app and running tests

Getting a list of commits to form the changelog

Bumping our project version, committing, and pushing our changes to Git

Summary

Creating and Using fastlane Action Plugins

Discovering new action plugins

build-in plugins

Third-party plugins

Implementing a fastlane plugin

self.run

self.description

self.details

self.available_options

self.example_code

self.category

self.authors

Creating your own fastlane plugin

Creating our new plugin

Creating our first Action

Testing our plugin

Publishing your plugin

Summary

Integrating Slack into the fastlane Workflow

Introducing Slack – a developer's communications platform of choice

Configuring Slack webhooks to connect to fastlane

Adding Slack actions into our workflow

Slack action arguments

Summary

Continuous Delivery Best Practices

Organizing your lanes

before_all and after_all lanes

Managing errors and exceptions

Managing the rest of our lanes

Making use of configuration files

Appfile

Deliverfile

Gymfile

Snapfile

Framefile

Matchfile

Scanfile

Real-world examples of configuration files

Private lanes and lane contexts

Final words

Configurations, Tools, and Resources

What you will learn

Skills learned

Working with fastlane and Gemfiles

Setting up two-factor authentication for your CI

Online resources

Other Books You May Enjoy

Leave a review - let other readers know what you think