Feedback, finish Android page

Author: devinmarieb

jekyll/_cci2/authorize-google-cloud-sdk.md

@@ -36,31 +36,30 @@ Otherwise, follow the [Google Cloud SDK installation instructions](https://cloud
 
 Before you can use any tools in the Google Cloud SDK, you must authorize `gcloud`. Google offers two types of authorization: user accounts and service accounts. Because you are installing the Cloud SDK on CircleCI, the service account is the appropriate choice.
 
-### 1. Create a service account
+### a. Create a service account
 {: #create-a-service-account }
 
 Create a service account by following Steps 1-3 of [Google's instructions](https://cloud.google.com/sdk/docs/authorizing#authorizing_with_a_service_account). Remember to download the JSON-formatted key file.
 
-### 2. Add a key file
+### b. Add a key file
 {: #add-a-key-file }
 
 Add the key file to CircleCI as a [project environment variable](/docs/set-environment-variable/#set-an-environment-variable-in-a-project). In this example, the variable is named `GCLOUD_SERVICE_KEY`. Using this particular name is not required, but it will be used throughout the examples in this document.
 
-### 3. Add environment variables
+### c. Add environment variables
 {: #add-env-vars }
 
 For convenience, add two more environment variables to your CircleCI project:
 
   - `GOOGLE_PROJECT_ID`: the ID of your GCP project.
   - `GOOGLE_COMPUTE_ZONE`: the default [compute zone](https://cloud.google.com/compute/docs/regions-zones/).
 
-#### Add granular permissions
-{: #add-granular-permissions }
-
 If you are having issues pushing container images to GCR you may need more granular permissions than the default `service account` provides. You can grant permission changes in the Cloud Storage [IAM Console](https://console.cloud.google.com/iam-admin/iam/project).
-
+<br/>
+<br/>
 Refer to the Cloud Storage [permission documentation](https://cloud.google.com/storage/docs/access-control/iam-permissions)
 to learn more about Identity and Access Management (IAM) permissions.
+{: class="alert alert-info" }
 
 ## 3. Authenticate to Google Container Registry
 {: #authenticate-to-google-container-registry }
@@ -91,7 +90,7 @@ jobs:
           password: $GCLOUD_SERVICE_KEY  # JSON service account you created, do not encode to base64
 ```
 
-**Note:** If base64 encoding is required for your particular workflow, use the following command:
+If base64 encoding is required for your particular workflow, use the following command:
 
 ```shell
 cat <file> | base64 -w 0
@@ -118,7 +117,6 @@ jobs:
           gcloud --quiet config set compute/zone ${GOOGLE_COMPUTE_ZONE}
 ```
 
-**Note:**
 If you are using a custom base image, ensure that you have the most recent components by adding the following command before authorizing the SDK.
 
 ```shell

jekyll/_cci2/deploy-android-applications.adoc

@@ -21,28 +21,33 @@ In this how-to guide, you will learn how to automatically deploy your Android ap
 To complete this tutorial, you will need the following:
 
 - An Android project, built using link:https://gradle.org/[Gradle].
-- Your Android project set up in CircleCI. If this is your first time setting up a project in CircleCI, refer to our <<getting-started#,Quickstart Guide>> for a walkthrough.
+- Your Android project set up in CircleCI. If this is your first time setting up a project in CircleCI, refer to our xref:getting-started#[Quickstart guide] for a walkthrough.
 - Fastlane installed and granted access to Google Play Store using credentials from your Google Developers service account. You may follow the instructions to install, set up, and configure fastlane supply in the link:https://docs.fastlane.tools/getting-started/android/setup/[Fastlane Android setup documentation].
 
 NOTE: In the Fastlane setup, you will download a credentials file from your Google Developers service account. This tutorial assumes that you have saved this file in the `fastlane` folder as `api.json`.
 
-This tutorial also walks you through how to use the Android orb for deployment. You are not required to be familiar with the Android orb for this tutorial, but we recommend reading the <<orb-intro#,Orb introduction page>> if you have not used CircleCI orbs before. Alternatively, this tutorial also shows you how to deploy your project without using the orb.
+This tutorial also walks you through how to use the Android orb for deployment. You are not required to be familiar with the Android orb for this tutorial, but we recommend reading the xref:orb-intro#[Orb introduction page] if you have not used CircleCI orbs before. Alternatively, this tutorial also shows you how to deploy your project without using the orb.
 
 [#configure-fastlane-for-deployment-to-google-play-store]
 == 1. Configure Fastlane for deployment to Google Play Store
 
-. Navigate to your `fastlane` directory and open `Fastfile`. This file is used to configure the tasks you can execute with Fastlane. If you open the file, you will observe four different blocks:
-+
+To configure Fastlane for deployment, you will need to configure tasks and update the Play Store lane.
+
+[#configure-tasks]
+=== a. Configure tasks
+
+Navigate to your `fastlane` directory and open `Fastfile`. This file is used to configure the tasks you can execute with Fastlane. If you open the file, you will observe four different blocks:
+
 - `before_all`: This is where you specify instructions to be performed before a lane is executed.
-+
 - `lane`: This is where you define an actual task you want to perform, such as deploying to the Play Store. You can define as many lanes as you want.
-+
 - `after_all`: This block is called when the executed lane was successful.
-+
 - `error`: This block will be called if an error occurs in any of the other blocks.
 
-. The Fastfile already comes with a `playstore` lane that generates a release build and deploys it to the Play Store. You will modify this lane. In the Fastfile, update the `playstore` lane like so:
-+
+[#update-play-store-lane]
+=== b. Update Play Store lane
+
+The Fastfile already comes with a `playstore` lane that generates a release build and deploys it to the Play Store. You will modify this lane. In the Fastfile, update the `playstore` lane like so:
+
 ```
 lane :playstore do
     gradle(task: "bundle")
@@ -52,16 +57,19 @@ lane :playstore do
     )
   end
 ```
-+
+
 This lane will run `gradle bundle` and generate an `app-release.aab` (Android App Bundle), and then deploy the bundle to the internal track of your project in the Google Play Console.
 
 [#prepare-your-app-for-deployment]
 == 2. Prepare your app for deployment
 
-Next, you will make some updates to your app to prepare it for deployment. You will have to add a release signing config to your app-module `build.gradle` file. This enables Fastlane to use the same keystore you used in generating earlier releases of your app to also generate subsequent releases.
+To prepare your app for deployment, you will need to add a release signing configuration to your app-module `build.gradle` file. This enables Fastlane to use the same keystore you used in generating earlier releases of your app to also generate subsequent releases.
+
+[#add-signingconfig-snippet]
+=== a. Add signingConfigs snippet
+
+Add the following `signingConfigs` snippet to your app-module `build.gradle` file:
 
-. Add the `signingConfigs` snippet to your app-module `build.gradle`:
-+
 ```
 android {
   signingConfigs {
@@ -75,11 +83,14 @@ android {
     ...
   }
 ```
-+
+
 NOTE: For this tutorial, you will be generating a `keystore` and `keystore.properties` at runtime. You can replace the fields with your actual passwords and information for local deployment, but we strongly advise to *not* upload these credentials to a remote repository. If you need help generating a keystore for your application, you may refer to the link:https://developer.android.com/studio/publish/app-signing#generate-key[Android user guide].
 
-. Update the `buildTypes` section of the `build.gradle` file like so:
-+
+[#update-buildtypes]
+=== b. Update buildTypes
+
+Update the `buildTypes` section of your `build.gradle` file:
+
 ```
 buildTypes {
     release {
@@ -88,11 +99,14 @@ buildTypes {
     }
 }
 ```
-+
+
 With this, you have configured the app to use a specific keystore. Next, you will create functions in your `build.gradle` file to help you generate build numbers for your app versions.
 
-. Add the following snippet just before the `android` section of your app-module `build.gradle` file:
-+
+[#add-android-snippet]
+=== c. Add snippet before android section
+
+Add the following snippet just before the `android` section of your app-module `build.gradle` file:
+
 ```
 ext.versionMajor = 1
 ext.versionMinor = 0
@@ -122,12 +136,15 @@ private String generateVersionName() {
     return versionName
 }
 ```
-+
+
 In this snippet, you added variables that hold your app version values. You then added two methods, `generateVersionCode` and `generateVersionName` to generate the version code and version name based on how the app version value changes. This helps to give your app a unique and progressive way of generating your version code when you modify your app versions.
-+
+
 Note that you will need to update at least one parameter of the version for every deployment. Fastlane fails if a version code is reused.
 
-. Update these properties in the `defaultConfig` section of the `build.gradle` file like so:
+[#update-defaultconfig]
+=== d. Update properties in defaultConfig
+
+Update the following properties in the `defaultConfig` section of the `build.gradle` file:
 
 ```
 defaultConfig {
@@ -141,32 +158,39 @@ defaultConfig {
 Now your android app is able to be bundled and deployed on your local machine.
 
 [#set-up-circleci-deployment]
-== 3. Set up CircleCI Deployment
+== 3. Set up CircleCI deployment
+
+To set up CircleCI deployment, you will need to take a few security measures.
+
+[#convert-keystore-to-base64]
+=== a. Convert your keystore to base64
+
+You need to convert your keystore to base64 to safely access it in CircleCI. You can do this conversion in the terminal using the following command:
 
-. You need to convert your keystore to base64 to safely access it in CircleCI. You can do this conversion in the terminal using the following command:
-+
 ```shell
 $ base64 your_key_store
 ```
-+
+
 Save the output somewhere easily accessible for the next step.
 
-. Next, you need to set <<env-vars#,environment variables>> for deployment through CircleCI.
-+
+[#set-env-vars]
+=== b. Set environment variables
+
+Next, you need to set xref:env-vars#[environment variables] for deployment through CircleCI.
+
 Open your Android project in the link:https://app.circleci.com/[CircleCI web app] and select *Project Settings*. Navigate to *Environment Variables* and add the following variables:
-+
+
 - `$BASE64_KEYSTORE` - Your base64 keystore, generated in the previous step
-+
 - `$GOOGLE_PLAY_KEY` - The contents of your `api.json` file, generated from the Fastlane install before starting this tutorial
-+
 - `$RELEASE_KEY_ALIAS` - Your key alias
-+
 - `$RELEASE_KEY_PASSWORD` - Your key password
-+
 - `$RELEASE_STORE_PASSWORD` - Your keystore password
 
-. Add the following snippet to your `build.gradle` file. This allows you to import your keystore properties from a `keystore.properties` that will be generated at runtime.
-+
+[#import-keystore-properties]
+=== c. Import keystore properties
+
+Add the following snippet to your `build.gradle` file. This allows you to import your keystore properties from a `keystore.properties` that will be generated at runtime.
+
 ```
 def keyStorePropertiesFile = rootProject.file("keystore.properties")
 def keyStoreProperties = new Properties()
@@ -176,7 +200,7 @@ android {
 ...
 }
 ```
-+
+
 [NOTE]
 ====
 You can also create a `keystore.properties` file in your project directory for local bundling and deployment, if you wish. Do *not* push this file or your keystore to a remote repository.
@@ -196,12 +220,12 @@ Now, you need to configure `.circleci/config.yml` to decrypt your keystore, gene
 If you have not already done so, create a `.circleci` folder in the root of your project repository. Inside the `.circleci` folder, create a `config.yml` file.
 
 [#set-up-config-with-the-android-orb]
-== 4a. Set up config with the Android orb
+== 4a. Set up configuration with the Android orb
 
-Using the Android orb gives you two options for deploying to the Google Play Store. You can either use the deploy-to-play-store job from the orb, or run each command individually in a job.
+Using the Android orb gives you two options for deploying to the Google Play Store. You can either use the `deploy-to-play-store` job from the orb, or run each command individually in a job.
 
 [#use-the-deploy-to-play-store-job]
-=== i. Use the deploy-to-play-store job
+=== a. Use the deploy-to-play-store job
 
 To deploy using the deploy-to-play-store job you just need to add a `android/deploy-to-play-store` job to your list of jobs in your workflow.
 
@@ -234,10 +258,10 @@ workflows:
                 fastlane-working-directory: '.'
 ```
 
-NOTE: The executor has no default value and must be set in the config.
+NOTE: The executor has no default value and must be set in the configuration.
 
 [#run-each-command-individually]
-=== ii. Run each command individually
+=== b. Run each command individually
 
 To run each command individually in your workflow, you will need to add the following commands:
 
@@ -250,7 +274,7 @@ Additionally, you need to run either `npm install` or `yarn install` using the N
 
 As with the deploy-to-play-store approach, you will not need to set the parameters `base64-keystore`, `release-key-alias`, `release-key-password`, `release-store-password`, and `google-play-key`, if you had created environment variables as outlined earlier in this tutorial.
 
-Below is an example config of this approach:
+Below is an example configuration of this approach:
 
 ```yaml
 orbs:
@@ -281,57 +305,70 @@ jobs:
             lane-name: internal
 ```
 [#set-up-config-without-the-android-orb]
-== 4b. Set up config without the Android Orb
+== 4b. Set up configuration without the Android orb
+
+If you would prefer to not use the Android orb, you can follow the configuration directions below.
+
+[#decrypt-keystore]
+=== a. Decrypt keystore from base64
+
+Add the following command to your deployment job in `.circleci/config.yml` to decrypt your keystore from the base64 environment variable set earlier (`$BASE64_KEYSTORE`).
 
-. Add the following command to your deployment job in `.circleci/config.yml` to decrypt your keystore from the base64 environment variable set earlier (`$BASE64_KEYSTORE`).
-+
 ```yaml
 run:
   name: Decode Android key store
   command: echo $BASE64_KEYSTORE | base64 -d | tee keystore android/app/keystore > /dev/null
 ```
 
-. Next, you need to generate a `keystore.properties` file in order to publish your work to the Google Play Store.
-+
+[#generate-keystore-properties-file]
+=== b. Generate a keystore.properties file
+
+Next, you need to generate a `keystore.properties` file in order to publish your work to the Google Play Store.
+
 To do so, you need to create another environment variable named `$RELEASE_KEYSTORE`, that points to the location of the decrypted keystore.
-+
+
 Add the following command to your deployment job:
-+
+
 ```yaml
 run:
   name: Create keystore.properties
   command: cd android && printf 'releaseKeyAlias=%s\nreleaseKeyPassword=%s\nreleaseKeyStore=%s\nreleaseStorePassword=%s' \
   $RELEASE_KEY_ALIAS $RELEASE_KEY_PASSWORD $RELEASE_KEYSTORE $RELEASE_STORE_PASSWORD > keystore.properties
 ```
 
-. Finally, you need to create your Google Play API key from your `api.json` You have already saved the value with an environment variable `$GOOGLE_PLAY_KEY`, so you can refer to this variable and write the api.json file at runtime, instead of uploading it to a remote repository.
-+
+[#create-google-play-api-key]
+=== c. Create Google Play API key
+
+Finally, you need to create your Google Play API key from your `api.json` You have already saved the value with an environment variable `$GOOGLE_PLAY_KEY`, so you can refer to this variable and write the api.json file at runtime, instead of uploading it to a remote repository.
+
 Add the following command to the job:
-+
+
 ```yaml
 run:
   name: Create Google Play key
   command: echo $GOOGLE_PLAY_KEY > google-play-key.json
 ```
 
-. To now deploy your app, you need to add your fastlane steps. To do this you only need to add a command that runs `fastlane my_deployment_lane`; in this case, the command looks like this:
-+
+[#deploy-app]
+=== d. Deploy your app
+
+To now deploy your app, you need to add your Fastlane steps. To do this you only need to add a command that runs `fastlane my_deployment_lane`; in this case, the command looks like this:
+
 ```yaml
 run: fastlane playstore
 ```
-+
+
 NOTE: You may need to install Fastlane on the image you are running your pipeline on. To do this, run `sudo gem install fastlane`.
-+
+
 Fastlane recommends using Bundler in this step. If you choose to use Bundler, you will need to add another step to install Bundler:
-+
+
 ```
 run: sudo gem install fastlane
 ```
-+
+
 Then, replace the `run: fastlane playstore` step with `run: bundle exec fastlane playstore`.
 
 [#next-steps]
 == Next steps
 
-- A <<deploy-ios-applications#,guide to deploying iOS apps>> is also available.
-- Visit the xref:deployment-overview.adoc[Deployment overview] for a general introduction on deployment with CircleCI, as well as examples for specific deployment targets such as Google Cloud Platform, AWS, and Heroku.
+- xref:deploy-ios-applications#[Deploy iOS apps]

jekyll/_cci2/deploy-ios-applications.md

@@ -341,7 +341,7 @@ Once this is complete you will need to generate an API token to allow Fastlane t
 5. Go to your project settings in CircleCI and create a new environment variable named `VS_API_TOKEN` with the value of the API Key.
 
 ### 3. Fastlane configuration
-{: #fastlane-configuration }
+{: #fastlane-configuration-vs-app }
 
 Below is an example of a lane that distributes beta app builds to Visual Studio App Center. Both the username of your App Center account and an API Token with "Full Access" is required to upload the binary to App Center.
 
@@ -387,7 +387,7 @@ end
 2. On the Preferences page, go to the API Key section and copy your API Key.
 3. Go to your project settings in CircleCI and create a new environment variable named `TESTFAIRY_API_KEY` with the value of the API Key
 
-### 1. Fastlane configuration
+### Fastlane configuration
 {: #fastlane-configuration }
 
 To configure uploading to TestFairy within Fastlane, see the following example: